Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(daemon): reconcile Codex tool lifecycle by call id (#678)

Gustavo Yede8689099f33
diff --git a/src/daemon/agent-driver/src/adapters/codex/normalizer.test.ts b/src/daemon/agent-driver/src/adapters/codex/normalizer.test.ts
index eeb34a305..c12b143b1 100644
--- a/src/daemon/agent-driver/src/adapters/codex/normalizer.test.ts
+++ b/src/daemon/agent-driver/src/adapters/codex/normalizer.test.ts
@@ -118,6 +118,23 @@ describe("CodexEventNormalizer — tool_call/tool_output symmetry", () => {
expect(completed).toEqual([{ kind: "tool_output", name: "mcp_search" }]);
});
+ it("carries the stable app-server item id across both sides of a tool lifecycle", () => {
+ const n = new CodexEventNormalizer();
+ const item = { type: "mcpToolCall", id: "item-42", server: "browser", tool: "click" };
+
+ expect(n.normalizeLine(notify("item/started", { item }))).toEqual([{
+ kind: "tool_call",
+ callId: "item-42",
+ name: "mcp_click",
+ input: item,
+ }]);
+ expect(n.normalizeLine(notify("item/completed", { item: { ...item, status: "failed" } }))).toEqual([{
+ kind: "tool_output",
+ callId: "item-42",
+ name: "mcp_click",
+ }]);
+ });
+
it("does not expose canSteerBusy or a turnState field (dead/redundant driver-level gate must not silently reappear)", () => {
const n = new CodexEventNormalizer();
expect((n as unknown as { canSteerBusy?: unknown }).canSteerBusy).toBeUndefined();
diff --git a/src/daemon/agent-driver/src/adapters/codex/normalizer.ts b/src/daemon/agent-driver/src/adapters/codex/normalizer.ts
index 0b0ddb6f1..261c265dc 100644
--- a/src/daemon/agent-driver/src/adapters/codex/normalizer.ts
+++ b/src/daemon/agent-driver/src/adapters/codex/normalizer.ts
@@ -484,21 +484,23 @@ export class CodexEventNormalizer {
private handleItemStarted(params: any): AdapterEvent[] {
const t = params?.item?.type ?? params?.type;
+ const callId = this.itemCallId(params);
+ const identity = callId ? { callId } : {};
switch (t) {
case "commandExecution":
- return [{ kind: "tool_call", name: "shell", input: params?.item }];
+ return [{ kind: "tool_call", ...identity, name: "shell", input: params?.item }];
case "contextCompaction":
return [{ kind: "compaction_started" }];
case "enteredReviewMode":
return [{ kind: "review_started" }];
case "fileChange":
- return [{ kind: "tool_call", name: "file_change", input: normalizeFileChangeInput(params?.item) }];
+ return [{ kind: "tool_call", ...identity, name: "file_change", input: normalizeFileChangeInput(params?.item) }];
case "mcpToolCall":
- return [{ kind: "tool_call", name: `mcp_${params?.item?.name ?? "tool"}`, input: params?.item }];
+ return [{ kind: "tool_call", ...identity, name: `mcp_${params?.item?.tool ?? params?.item?.name ?? "tool"}`, input: params?.item }];
case "webSearch":
- return [{ kind: "tool_call", name: "web_search", input: params?.item }];
+ return [{ kind: "tool_call", ...identity, name: "web_search", input: params?.item }];
case "collabAgentToolCall":
- return [{ kind: "tool_call", name: "collab_tool_call", input: params?.item }];
+ return [{ kind: "tool_call", ...identity, name: "collab_tool_call", input: params?.item }];
default:
return [];
}
@@ -506,21 +508,23 @@ export class CodexEventNormalizer {
private handleItemCompleted(params: any): AdapterEvent[] {
const t = params?.item?.type ?? params?.type;
+ const callId = this.itemCallId(params);
+ const identity = callId ? { callId } : {};
switch (t) {
case "commandExecution":
- return [{ kind: "tool_output", name: "shell" }];
+ return [{ kind: "tool_output", ...identity, name: "shell" }];
case "contextCompaction":
return [{ kind: "compaction_finished" }];
case "exitedReviewMode":
return [{ kind: "review_finished" }];
case "fileChange":
- return [{ kind: "tool_output", name: "file_change" }];
+ return [{ kind: "tool_output", ...identity, name: "file_change" }];
case "mcpToolCall":
- return [{ kind: "tool_output", name: `mcp_${params?.item?.name ?? "tool"}` }];
+ return [{ kind: "tool_output", ...identity, name: `mcp_${params?.item?.tool ?? params?.item?.name ?? "tool"}` }];
case "webSearch":
- return [{ kind: "tool_output", name: "web_search" }];
+ return [{ kind: "tool_output", ...identity, name: "web_search" }];
case "collabAgentToolCall":
- return [{ kind: "tool_output", name: "collab_tool_call" }];
+ return [{ kind: "tool_output", ...identity, name: "collab_tool_call" }];
case "agentMessage":
return [{ kind: "assistant_message_completed", text: params?.item?.text ?? "" }];
case "reasoning":
@@ -529,4 +533,9 @@ export class CodexEventNormalizer {
return [];
}
}
+
+ private itemCallId(params: any): string | undefined {
+ const value = params?.item?.id ?? params?.itemId;
+ return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+ }
}
diff --git a/src/daemon/agent-driver/src/contract.ts b/src/daemon/agent-driver/src/contract.ts
index 252629a7d..98a3cea76 100644
--- a/src/daemon/agent-driver/src/contract.ts
+++ b/src/daemon/agent-driver/src/contract.ts
@@ -498,6 +498,12 @@ export interface AgentSessionSnapshot {
readonly queueDwellCount: number;
readonly queueDwellTotalMs: number;
readonly sseReconnectCount: number;
+ /** Current blocker count only; call identities and tool names are never exposed. */
+ readonly outstandingToolUses?: number;
+ /** Outstanding calls whose adapter did not provide a stable identity. */
+ readonly anonymousOutstandingToolUses?: number;
+ /** Duplicate starts, unmatched finishes, or unattributable lifecycle events. */
+ readonly toolLifecycleMismatchCount?: number;
readonly resumeOutcome: "not_requested" | "pending" | "resumed" | "reset_required" | "failed";
readonly terminalOwnerKind:
| "transport_request"
diff --git a/src/daemon/agent-driver/src/controller/logical-session.test.ts b/src/daemon/agent-driver/src/controller/logical-session.test.ts
index 831b4e7ab..c61fb3b6e 100644
--- a/src/daemon/agent-driver/src/controller/logical-session.test.ts
+++ b/src/daemon/agent-driver/src/controller/logical-session.test.ts
@@ -879,6 +879,9 @@ describe("logical delivery diagnostics", () => {
queueDwellCount: 0,
queueDwellTotalMs: 0,
sseReconnectCount: 0,
+ outstandingToolUses: 0,
+ anonymousOutstandingToolUses: 0,
+ toolLifecycleMismatchCount: 0,
resumeOutcome: "not_requested",
terminalOwnerKind: "vendor_message",
},
@@ -1619,6 +1622,63 @@ describe("backend-owned delivery behavior", () => {
await session.stop({ reason: "shutdown", forceAfterMs: 10 });
});
+ it("deduplicates replayed identified tool starts and ignores unmatched finishes", async () => {
+ const { session, driver } = makeSession("claude");
+ const observed: Array<AgentEvent<BuiltinBackendSpecs, BuiltinBackendId>> = [];
+ const collecting = (async () => { for await (const event of session.events) observed.push(event); })();
+ await session.start({ id: "one", kind: "user", text: "start" });
+ await emit(driver, { kind: "tool_call", callId: "call-1", name: "Read", input: {} });
+ await emit(driver, { kind: "tool_call", callId: "call-1", name: "Read", input: {} });
+ await emit(driver, { kind: "tool_output", callId: "unknown", name: "Read" });
+ await emit(driver, { kind: "tool_output", name: "Read" });
+ await session.send({ id: "two", kind: "user", text: "follow" });
+
+ expect(driver.writes).toEqual([]);
+ expect(session.snapshot().diagnostics).toMatchObject({
+ deliveryPhase: "tool_wait",
+ metrics: {
+ outstandingToolUses: 1,
+ anonymousOutstandingToolUses: 0,
+ toolLifecycleMismatchCount: 3,
+ },
+ });
+
+ await emit(driver, { kind: "tool_output", callId: "call-1", name: "Read" });
+ await vi.waitFor(() => expect(driver.writes).toEqual(["follow"]));
+ expect(session.snapshot().diagnostics.metrics.outstandingToolUses).toBe(0);
+ expect(observed.filter((event) => event.type === "tool_started")).toHaveLength(1);
+ expect(observed.filter((event) => event.type === "tool_finished")).toHaveLength(1);
+ expect(observed.find((event) => event.type === "tool_started")).toMatchObject({ callId: "call-1" });
+ expect(observed.find((event) => event.type === "tool_finished")).toMatchObject({ callId: "call-1" });
+ await session.stop({ reason: "shutdown", forceAfterMs: 10 });
+ await collecting;
+ });
+
+ it("does not let an unattributable lifecycle event create a future tool blocker", async () => {
+ const lane = new ControlledRuntimeLane();
+ lane.startAdmission = { ok: true, acceptedAs: "prompt", receipt: "codex:test:1" };
+ const { session } = makeSession("codex", { lane });
+
+ (session as any).onAdapterEvent(
+ { kind: "tool_call", callId: "orphan", name: "browser", input: {} },
+ lane,
+ 0,
+ );
+ (session as any).onAdapterEvent(
+ { kind: "tool_output", callId: "orphan", name: "browser" },
+ lane,
+ 0,
+ );
+ expect(session.snapshot().diagnostics).toMatchObject({
+ deliveryPhase: "idle",
+ metrics: { outstandingToolUses: 0, toolLifecycleMismatchCount: 2 },
+ });
+
+ await session.start({ id: "one", kind: "user", text: "start" });
+ expect(session.snapshot().diagnostics.deliveryPhase).toBe("working");
+ await session.stop({ reason: "shutdown", forceAfterMs: 10 });
+ });
+
it("flushes after review finishes but not while review is active", async () => {
const { session, driver } = makeSession("codex");
await session.start({ id: "one", kind: "user", text: "start" });
diff --git a/src/daemon/agent-driver/src/controller/logical-session.ts b/src/daemon/agent-driver/src/controller/logical-session.ts
index 1fbe56fd9..ef180a17c 100644
--- a/src/daemon/agent-driver/src/controller/logical-session.ts
+++ b/src/daemon/agent-driver/src/controller/logical-session.ts
@@ -208,7 +208,9 @@ implements AgentSession<Specs, Id> {
private interruptedTurnId?: string;
private processTurnEnded = false;
private stopRequestId?: string;
- private outstandingToolUses = 0;
+ private anonymousOutstandingToolUses = 0;
+ private readonly outstandingToolCallIds = new Set<string>();
+ private toolLifecycleMismatchCount = 0;
private compacting = false;
private reviewing = false;
private readonly steeringDeliveries = new Set<SteeringDelivery>();
@@ -419,6 +421,9 @@ implements AgentSession<Specs, Id> {
queueDwellCount: this.metricValue(this.queueDwellCount),
queueDwellTotalMs: this.metricValue(this.queueDwellTotalMs),
sseReconnectCount: this.metricValue(this.sseReconnectCount),
+ outstandingToolUses: this.outstandingToolUseCount(),
+ anonymousOutstandingToolUses: this.metricValue(this.anonymousOutstandingToolUses),
+ toolLifecycleMismatchCount: this.metricValue(this.toolLifecycleMismatchCount),
resumeOutcome: this.resumeOutcome,
terminalOwnerKind: this.adapter.execution.terminalOwnership,
},
@@ -784,13 +789,34 @@ implements AgentSession<Specs, Id> {
}
return;
case "tool_call":
- this.outstandingToolUses += 1;
- if (turnId) this.emit({ type: "tool_started", turnId, name: event.name, input: jsonValue(event.input) });
+ if (!turnId) {
+ this.toolLifecycleMismatchCount += 1;
+ return;
+ }
+ if (!this.startToolUse(event.callId)) return;
+ const startedCallId = this.toolCallId(event.callId);
+ this.emit({
+ type: "tool_started",
+ turnId,
+ ...(startedCallId ? { callId: startedCallId } : {}),
+ name: event.name,
+ input: jsonValue(event.input),
+ });
return;
case "tool_output":
- this.outstandingToolUses = Math.max(0, this.outstandingToolUses - 1);
- if (turnId) this.emit({ type: "tool_finished", turnId, name: event.name });
- if (this.outstandingToolUses === 0 && !this.toolBoundaryFlushDisabled) void this.flushSafeBoundaryQueue();
+ if (!turnId) {
+ this.toolLifecycleMismatchCount += 1;
+ return;
+ }
+ if (!this.finishToolUse(event.callId)) return;
+ const finishedCallId = this.toolCallId(event.callId);
+ this.emit({
+ type: "tool_finished",
+ turnId,
+ ...(finishedCallId ? { callId: finishedCallId } : {}),
+ name: event.name,
+ });
+ if (this.outstandingToolUseCount() === 0 && !this.toolBoundaryFlushDisabled) void this.flushSafeBoundaryQueue();
return;
case "compaction_started":
case "compaction_finished":
@@ -977,7 +1003,7 @@ implements AgentSession<Specs, Id> {
this.activeTurn = undefined;
this.turnError = undefined;
this.interruptedTurnId = undefined;
- this.outstandingToolUses = 0;
+ this.clearOutstandingToolUses();
this.compacting = false;
this.reviewing = false;
this.toolBoundaryFlushDisabled = false;
@@ -1005,7 +1031,7 @@ implements AgentSession<Specs, Id> {
private canFlushSafeBoundaryQueue(): boolean {
return this.state === "working"
&& this.behavior.midTurnDelivery === "safe_boundary_queue"
- && this.outstandingToolUses === 0
+ && this.outstandingToolUseCount() === 0
&& !this.compacting
&& !this.reviewing
&& this.activeTurn !== undefined
@@ -1198,7 +1224,7 @@ implements AgentSession<Specs, Id> {
if (this.behavior.midTurnDelivery === "next_turn_queue" && this.queued.length > 0) return "next_turn_queued";
if (this.compacting) return "compacting";
if (this.reviewing) return "reviewing";
- if (this.outstandingToolUses > 0) return "tool_wait";
+ if (this.outstandingToolUseCount() > 0) return "tool_wait";
if (this.activeTurn) return "working";
return "idle";
}
@@ -1208,6 +1234,51 @@ implements AgentSession<Specs, Id> {
return Number.isFinite(now) && now >= 0 ? now : 0;
}
+ private outstandingToolUseCount(): number {
+ return this.anonymousOutstandingToolUses + this.outstandingToolCallIds.size;
+ }
+
+ private startToolUse(rawCallId?: string): boolean {
+ const callId = this.toolCallId(rawCallId);
+ if (!callId) {
+ this.anonymousOutstandingToolUses += 1;
+ return true;
+ }
+ if (this.outstandingToolCallIds.has(callId)) {
+ this.toolLifecycleMismatchCount += 1;
+ return false;
+ }
+ this.outstandingToolCallIds.add(callId);
+ return true;
+ }
+
+ private finishToolUse(rawCallId?: string): boolean {
+ const callId = this.toolCallId(rawCallId);
+ if (!callId) {
+ if (this.anonymousOutstandingToolUses === 0) {
+ this.toolLifecycleMismatchCount += 1;
+ return false;
+ }
+ this.anonymousOutstandingToolUses -= 1;
+ return true;
+ }
+ if (!this.outstandingToolCallIds.delete(callId)) {
+ this.toolLifecycleMismatchCount += 1;
+ return false;
+ }
+ return true;
+ }
+
+ private clearOutstandingToolUses(): void {
+ this.anonymousOutstandingToolUses = 0;
+ this.outstandingToolCallIds.clear();
+ }
+
+ private toolCallId(rawCallId?: string): string | undefined {
+ const callId = rawCallId?.trim();
+ return callId && callId.length <= 1_024 ? callId : undefined;
+ }
+
private metricValue(value: number): number {
return Number.isFinite(value) && value >= 0 ? value : 0;
}
diff --git a/src/daemon/agent-driver/src/internal/adapter.ts b/src/daemon/agent-driver/src/internal/adapter.ts
index 2fec6c19e..5d0366e78 100644
--- a/src/daemon/agent-driver/src/internal/adapter.ts
+++ b/src/daemon/agent-driver/src/internal/adapter.ts
@@ -61,8 +61,8 @@ export type AdapterEvent =
| { kind: "assistant_reasoning_completed"; text: string }
| { kind: "assistant_message_delta"; text: string }
| { kind: "assistant_message_completed"; text: string }
- | { kind: "tool_call"; name: string; input: unknown }
- | { kind: "tool_output"; name: string }
+ | { kind: "tool_call"; callId?: string; name: string; input: unknown }
+ | { kind: "tool_output"; callId?: string; name: string }
| { kind: "compaction_started" }
| { kind: "compaction_finished" }
| { kind: "review_started" }
diff --git a/src/daemon/src/diagnostics/privacyPolicy.test.ts b/src/daemon/src/diagnostics/privacyPolicy.test.ts
index 92acc6f8a..503f03417 100644
--- a/src/daemon/src/diagnostics/privacyPolicy.test.ts
+++ b/src/daemon/src/diagnostics/privacyPolicy.test.ts
@@ -169,6 +169,9 @@ const FSM_FIELD_RULES: Readonly<Record<string, ProjectionFieldRule>> = {
queueDwellCount: { type: "number", min: 0, max: Number.MAX_VALUE, optional: true },
queueDwellTotalMs: { type: "number", min: 0, max: Number.MAX_VALUE, optional: true },
sseReconnectCount: { type: "number", min: 0, max: Number.MAX_VALUE, optional: true },
+ outstandingToolUses: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER, optional: true },
+ anonymousOutstandingToolUses: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER, optional: true },
+ toolLifecycleMismatchCount: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER, optional: true },
resumeOutcome: { type: "enum", values: ["not_requested", "pending", "resumed", "reset_required", "failed"], optional: true },
terminalOwnerKind: { type: "enum", values: ["transport_request", "vendor_message", "prompt_invocation", "lane_generation"], optional: true },
effects: { type: "enum_array", values: EXPECTED_MANAGER_EFFECTS, maxItems: 32, dropUnknown: true },
@@ -449,6 +452,9 @@ const TRACE_METRICS = {
queueDwellCount: 5,
queueDwellTotalMs: 6.5,
sseReconnectCount: 7,
+ outstandingToolUses: 2,
+ anonymousOutstandingToolUses: 0,
+ toolLifecycleMismatchCount: 1,
resumeOutcome: "resumed",
terminalOwnerKind: "transport_request",
} as const;
diff --git a/src/daemon/src/diagnostics/privacyPolicy.ts b/src/daemon/src/diagnostics/privacyPolicy.ts
index 4ba27e1d1..8ef4862b2 100644
--- a/src/daemon/src/diagnostics/privacyPolicy.ts
+++ b/src/daemon/src/diagnostics/privacyPolicy.ts
@@ -278,11 +278,18 @@ function projectFsm(row: Record<string, unknown>, targetAgentId: string): Record
"queueDwellTotalMs",
"sseReconnectCount",
] as const;
+ const toolMetricKeys = [
+ "outstandingToolUses",
+ "anonymousOutstandingToolUses",
+ "toolLifecycleMismatchCount",
+ ] as const;
const hasMetrics = metricKeys.some((key) => key in row || row[key] !== undefined)
+ || toolMetricKeys.some((key) => key in row || row[key] !== undefined)
|| "resumeOutcome" in row
|| "terminalOwnerKind" in row;
if (hasMetrics) {
if (!metricKeys.every((key) => copyFiniteNumber(row, output, key))) return null;
+ if (!toolMetricKeys.every((key) => copyInteger(row, output, key, { optional: true }))) return null;
const resumeOutcome = enumValue(row.resumeOutcome, RESUME_OUTCOMES);
const terminalOwnerKind = enumValue(row.terminalOwnerKind, TERMINAL_OWNER_KINDS);
if (!resumeOutcome || !terminalOwnerKind) return null;
diff --git a/src/daemon/src/manager/managerPolicy.test.ts b/src/daemon/src/manager/managerPolicy.test.ts
index 09c7a66ea..c5eb3eb4a 100644
--- a/src/daemon/src/manager/managerPolicy.test.ts
+++ b/src/daemon/src/manager/managerPolicy.test.ts
@@ -619,6 +619,92 @@ describe("reduceManager — tick: stall + idle hibernation", () => {
]);
});
+ it("settles identified tool blockers exactly once across duplicate and late lifecycle events", () => {
+ let s = createInitialManagerState(100);
+ s = register(s, "a", PERSISTENT_GATED);
+ s = reduceManager(s, { type: "wake", agentId: "a", message: { text: "root" }, nowMs: 0 }).state;
+ s = spawnRoot(s, 0, "root-turn");
+ const lifecycle = (
+ state: ManagerState,
+ type: "turn_tool_started" | "turn_tool_finished",
+ callId: string,
+ nowMs: number,
+ ): ManagerState => reduceManager(state, {
+ type,
+ agentId: "a",
+ sessionInstanceId: SESSION_INSTANCE,
+ turnId: "root-turn",
+ callId,
+ nowMs,
+ }).state;
+
+ s = lifecycle(s, "turn_tool_started", "call-1", 10);
+ s = lifecycle(s, "turn_tool_started", "call-1", 20);
+ s = lifecycle(s, "turn_tool_started", "call-2", 30);
+ expect(s.agents.a.execution.lease).toMatchObject({
+ outstandingToolUses: 2,
+ outstandingToolCallIds: ["call-1", "call-2"],
+ lastWorkAt: 30,
+ });
+
+ const leaseBeforeAnonymousFinish = s.agents.a.execution.lease;
+ s = reduceManager(s, {
+ type: "turn_tool_finished",
+ agentId: "a",
+ sessionInstanceId: SESSION_INSTANCE,
+ turnId: "root-turn",
+ nowMs: 35,
+ }).state;
+ expect(s.agents.a.execution.lease).toEqual(leaseBeforeAnonymousFinish);
+ expect(s.agents.a.execution.lease.lastWorkAt).toBe(30);
+
+ s = lifecycle(s, "turn_tool_finished", "call-1", 40);
+ s = lifecycle(s, "turn_tool_finished", "call-1", 50);
+ expect(s.agents.a.execution.lease).toMatchObject({
+ outstandingToolUses: 1,
+ outstandingToolCallIds: ["call-2"],
+ lastWorkAt: 40,
+ });
+ expect(reduceManager(s, { type: "tick", nowMs: 500 }).effects).toEqual([]);
+
+ s = lifecycle(s, "turn_tool_finished", "call-2", 60);
+ expect(s.agents.a.execution.lease).toEqual({
+ state: "active",
+ identity: { sessionInstanceId: SESSION_INSTANCE, turnId: "root-turn" },
+ lastWorkAt: 60,
+ nativeDeadlineAt: 160,
+ recoveryExtensionsUsed: 0,
+ });
+ });
+
+ it("reopens a completed root for a late identified tool start", () => {
+ let s = createInitialManagerState(100);
+ s = register(s, "a", PERSISTENT_GATED);
+ s = reduceManager(s, { type: "wake", agentId: "a", message: { text: "root" }, nowMs: 0 }).state;
+ s = spawnRoot(s, 0, "root-turn");
+ s = completeRoot(s, "root-turn", 10).state;
+
+ s = reduceManager(s, {
+ type: "turn_tool_started",
+ agentId: "a",
+ sessionInstanceId: SESSION_INSTANCE,
+ turnId: "root-turn",
+ callId: "late-call",
+ nowMs: 20,
+ }).state;
+
+ expect(s.agents.a.execution.lease).toEqual({
+ state: "suspect_active",
+ identity: { sessionInstanceId: SESSION_INSTANCE, turnId: "root-turn" },
+ lastWorkAt: 20,
+ nativeDeadlineAt: 120,
+ recoveryExtensionsUsed: 0,
+ outstandingToolUses: 1,
+ outstandingToolCallIds: ["late-call"],
+ reason: "work_after_terminal",
+ });
+ });
+
it("stops a persistent agent that sat idle past the idle timeout (sessionId preserved)", () => {
let s = createInitialManagerState(100_000, 100); // idleTimeoutMs = 100
s = register(s, "a", PERSISTENT_GATED);
diff --git a/src/daemon/src/manager/managerPolicy.ts b/src/daemon/src/manager/managerPolicy.ts
index 7f10a40db..26df98ef5 100644
--- a/src/daemon/src/manager/managerPolicy.ts
+++ b/src/daemon/src/manager/managerPolicy.ts
@@ -58,6 +58,7 @@ export type RootLease =
nativeDeadlineAt: number;
recoveryExtensionsUsed: number;
outstandingToolUses?: number;
+ outstandingToolCallIds?: readonly string[];
}
| {
state: "suspect_active";
@@ -66,6 +67,7 @@ export type RootLease =
nativeDeadlineAt: number;
recoveryExtensionsUsed: number;
outstandingToolUses?: number;
+ outstandingToolCallIds?: readonly string[];
reason: "work_after_terminal";
};
@@ -155,8 +157,8 @@ export type ManagerEvent =
nowMs: number;
}
| { type: "turn_work"; agentId: string; sessionInstanceId: string; turnId: string; nowMs: number }
- | { type: "turn_tool_started"; agentId: string; sessionInstanceId: string; turnId: string; nowMs: number }
- | { type: "turn_tool_finished"; agentId: string; sessionInstanceId: string; turnId: string; nowMs: number }
+ | { type: "turn_tool_started"; agentId: string; sessionInstanceId: string; turnId: string; callId?: string; nowMs: number }
+ | { type: "turn_tool_finished"; agentId: string; sessionInstanceId: string; turnId: string; callId?: string; nowMs: number }
| {
type: "turn_completed";
agentId: string;
@@ -388,6 +390,7 @@ export function reduceManager(state: ManagerState, event: ManagerEvent): ReduceR
if ((lease.state === "active" || lease.state === "suspect_active") && lease.outstandingToolUses !== undefined) {
const unblockedLease = { ...lease };
delete unblockedLease.outstandingToolUses;
+ delete unblockedLease.outstandingToolCallIds;
a.execution.lease = unblockedLease;
}
});
@@ -689,14 +692,23 @@ function onTurnToolLifecycle(
&& current.lastTerminal !== null
&& sameIdentity(current.lastTerminal.identity, identity);
if (!matchesActive && !matchesTerminal) return { state, effects: [] };
- if (lifecycle === "finished" && matchesActive && (current.outstandingToolUses ?? 0) === 0) {
- return { state, effects: [] };
- }
return mutate(state, event.agentId, (agent) => {
if (!matchesSession(agent, event.sessionInstanceId)) return;
const lease = agent.execution.lease;
+ const callId = normalizedToolCallId(event.callId);
if ((lease.state === "active" || lease.state === "suspect_active") && sameIdentity(lease.identity, identity)) {
- const outstandingToolUses = (lease.outstandingToolUses ?? 0) + (lifecycle === "started" ? 1 : -1);
+ const identified = new Set(lease.outstandingToolCallIds ?? []);
+ const currentCount = lease.outstandingToolUses ?? 0;
+ const anonymousCount = Math.max(0, currentCount - identified.size);
+ if (lifecycle === "started") {
+ if (callId && identified.has(callId)) return;
+ if (callId) identified.add(callId);
+ } else if (callId) {
+ if (!identified.delete(callId)) return;
+ } else if (anonymousCount === 0) {
+ return;
+ }
+ const outstandingToolUses = currentCount + (lifecycle === "started" ? 1 : -1);
if (outstandingToolUses > 0) {
agent.execution.lease = {
...lease,
@@ -704,10 +716,12 @@ function onTurnToolLifecycle(
nativeDeadlineAt: event.nowMs + agent.turnSilence.normalBudgetMs,
recoveryExtensionsUsed: 0,
outstandingToolUses,
+ ...(identified.size > 0 ? { outstandingToolCallIds: [...identified] } : {}),
};
} else {
const unblockedLease = { ...lease };
delete unblockedLease.outstandingToolUses;
+ delete unblockedLease.outstandingToolCallIds;
agent.execution.lease = {
...unblockedLease,
lastWorkAt: event.nowMs,
@@ -725,6 +739,7 @@ function onTurnToolLifecycle(
nativeDeadlineAt: event.nowMs + agent.turnSilence.normalBudgetMs,
recoveryExtensionsUsed: 0,
outstandingToolUses: 1,
+ ...(callId ? { outstandingToolCallIds: [callId] } : {}),
reason: "work_after_terminal",
};
}
@@ -941,6 +956,11 @@ function sameIdentity(left: TurnIdentity, right: TurnIdentity): boolean {
return left.sessionInstanceId === right.sessionInstanceId && left.turnId === right.turnId;
}
+function normalizedToolCallId(rawCallId?: string): string | undefined {
+ const callId = rawCallId?.trim();
+ return callId && callId.length <= 1_024 ? callId : undefined;
+}
+
function leaseIsWorking(lease: RootLease): boolean {
return lease.state === "active" || lease.state === "suspect_active";
}
diff --git a/src/daemon/src/manager/managerRuntime.test.ts b/src/daemon/src/manager/managerRuntime.test.ts
index 6deb1b615..ce07e826f 100644
--- a/src/daemon/src/manager/managerRuntime.test.ts
+++ b/src/daemon/src/manager/managerRuntime.test.ts
@@ -3678,6 +3678,9 @@ describe("AgentProcessManager — onFsmTransition trace (observability, zero beh
queueDwellCount: 4,
queueDwellTotalMs: 8.5,
sseReconnectCount: 6,
+ outstandingToolUses: 2,
+ anonymousOutstandingToolUses: 0,
+ toolLifecycleMismatchCount: 1,
resumeOutcome: "resumed",
terminalOwnerKind: "transport_request",
},
@@ -3706,6 +3709,9 @@ describe("AgentProcessManager — onFsmTransition trace (observability, zero beh
queueDwellCount: 4,
queueDwellTotalMs: 8.5,
sseReconnectCount: 6,
+ outstandingToolUses: 2,
+ anonymousOutstandingToolUses: 0,
+ toolLifecycleMismatchCount: 1,
resumeOutcome: "resumed",
terminalOwnerKind: "transport_request",
});
diff --git a/src/daemon/src/manager/managerRuntime.ts b/src/daemon/src/manager/managerRuntime.ts
index 488777b92..966130b37 100644
--- a/src/daemon/src/manager/managerRuntime.ts
+++ b/src/daemon/src/manager/managerRuntime.ts
@@ -134,6 +134,9 @@ interface FsmTraceRecord extends TraceRecordBase, Partial<TraceSpanMetadata> {
queueDwellCount?: number;
queueDwellTotalMs?: number;
sseReconnectCount?: number;
+ outstandingToolUses?: number;
+ anonymousOutstandingToolUses?: number;
+ toolLifecycleMismatchCount?: number;
resumeOutcome?: "not_requested" | "pending" | "resumed" | "reset_required" | "failed";
terminalOwnerKind?: "transport_request" | "vendor_message" | "prompt_invocation" | "lane_generation";
sinceProgressMs: number;
@@ -1139,6 +1142,9 @@ export class AgentProcessManager {
| "queueDwellCount"
| "queueDwellTotalMs"
| "sseReconnectCount"
+ | "outstandingToolUses"
+ | "anonymousOutstandingToolUses"
+ | "toolLifecycleMismatchCount"
| "resumeOutcome"
| "terminalOwnerKind"
> {
@@ -2024,9 +2030,9 @@ export class AgentProcessManager {
case "assistant_message_completed":
return { type: "turn_work" as const, turnId: event.turnId };
case "tool_started":
- return { type: "turn_tool_started" as const, turnId: event.turnId };
+ return { type: "turn_tool_started" as const, turnId: event.turnId, callId: event.callId };
case "tool_finished":
- return { type: "turn_tool_finished" as const, turnId: event.turnId };
+ return { type: "turn_tool_finished" as const, turnId: event.turnId, callId: event.callId };
case "compaction_started":
case "compaction_finished":
case "review_started":