Fix the resume strip/apply mismatch and make onTasksChange required

Resumed transcripts stripped a manage_tasks call's raw rows only when it
had a successful tool_result, but hydrateTasksFromTurns already applies the
call unconditionally on the tool_call itself — a call with an errored or
missing result kept its raw rows next to the aggregated task block instead
of being replaced by it. The strip now matches the apply: manage_tasks rows
come out regardless of the result's outcome, because the tool_call is what
the underlying tool's side-effect-free handler makes authoritative, not
whatever result eventually shows up.

onTasksChange moves from optional to required on ChatDirectorOptions, same
motivation as CL-5709: an omitted required field is a visible gap in a
caller's diff, not an invisible one.

Author: TheGreatAxios

src/agent/director.test.ts

@@ -100,7 +100,7 @@ describe("ChatDirector tool-only loop protection", () => {
   const providerlessPolicy = { providerName: "test-provider" };
 
   test("nudges once at the family threshold, after pending tools execute", async () => {
-    const director = createChatDirector("system", [], { provider: providerlessPolicy });
+    const director = createChatDirector("system", [], { onTasksChange: () => {}, provider: providerlessPolicy });
     const capabilities = makeCapabilities();
 
     // Default family nudges at 12 consecutive tool-only turns.
@@ -111,7 +111,7 @@ describe("ChatDirector tool-only loop protection", () => {
   });
 
   test("the nudge is one-shot — it does not repeat on the next tool-only turn", async () => {
-    const director = createChatDirector("system", [], { provider: providerlessPolicy });
+    const director = createChatDirector("system", [], { onTasksChange: () => {}, provider: providerlessPolicy });
     const capabilities = makeCapabilities();
 
     await runToolOnlyStreak(director, capabilities, 12);
@@ -122,7 +122,7 @@ describe("ChatDirector tool-only loop protection", () => {
   });
 
   test("pauses and stops issuing infers at the family pause threshold", async () => {
-    const director = createChatDirector("system", [], { provider: providerlessPolicy });
+    const director = createChatDirector("system", [], { onTasksChange: () => {}, provider: providerlessPolicy });
     const capabilities = makeCapabilities();
 
     // Default family pauses at 20 consecutive tool-only turns.
@@ -136,7 +136,7 @@ describe("ChatDirector tool-only loop protection", () => {
   });
 
   test("resumes after the operator sends a new message", async () => {
-    const director = createChatDirector("system", [], { provider: providerlessPolicy });
+    const director = createChatDirector("system", [], { onTasksChange: () => {}, provider: providerlessPolicy });
     const capabilities = makeCapabilities();
 
     await runToolOnlyStreak(director, capabilities, 20);
@@ -147,7 +147,7 @@ describe("ChatDirector tool-only loop protection", () => {
   });
 
   test("a dismissed ask_operator counts toward the streak like any other tool-only turn", async () => {
-    const director = createChatDirector("system", [], { provider: providerlessPolicy });
+    const director = createChatDirector("system", [], { onTasksChange: () => {}, provider: providerlessPolicy });
     const capabilities = makeCapabilities();
 
     // 11 ordinary tool-only turns, then a turn whose only tool call is a
@@ -197,7 +197,7 @@ describe("ChatDirector tool-only loop protection", () => {
   });
 
   test("a busy-but-progressing session (text interleaved with tools) never trips", async () => {
-    const director = createChatDirector("system", [], { provider: providerlessPolicy });
+    const director = createChatDirector("system", [], { onTasksChange: () => {}, provider: providerlessPolicy });
     const capabilities = makeCapabilities();
 
     let lastActions: ReactorAction[] = [];
@@ -212,7 +212,7 @@ describe("ChatDirector tool-only loop protection", () => {
   });
 
   test("grok's tightened thresholds fire earlier than the default family", async () => {
-    const director = createChatDirector("system", [], { provider: { providerName: "xai/default", model: "grok-4.5" } });
+    const director = createChatDirector("system", [], { onTasksChange: () => {}, provider: { providerName: "xai/default", model: "grok-4.5" } });
     const capabilities = makeCapabilities();
 
     // Grok nudges at 6, well below the default family's 12.

src/agent/director.ts

@@ -305,10 +305,15 @@ function isCodeFile(path: string): boolean {
 
 // Single implementation of "what does a manage_tasks tool call do to the
 // task list", shared by the live decide() loop below and hydrateTasksFromTurns.
+// Task state is owned by the director, not by the tool: manage_tasks's
+// handler (src/agent/tools.ts) performs no side effect of its own — it
+// parses the same arguments and returns a fixed "Tasks updated." string. The
+// tool_call is therefore the authoritative event, and applying it here does
+// not need to wait on a tool_result the handler never varies.
 // Returns null when the call is not manage_tasks or its arguments don't
 // parse, so callers can distinguish "no valid manage_tasks call here" from
 // "a valid call that happened to be a no-op" — the latter still counts as an
-// update for onTasksChange purposes, matching prior behavior.
+// update for onTasksChange purposes.
 function applyManageTasksToolCall(tasks: Task[], block: { name: string; arguments: unknown }): Task[] | null {
   if (block.name !== "manage_tasks") return null;
   const taskArgs = parseManageTasksArgs(block.arguments);
@@ -321,7 +326,7 @@ export type ChatDirectorOptions = {
   inactivityTimeoutMs?: number | undefined;
   totalTimeoutMs?: number | undefined;
   workflowCoordinator?: WorkflowCoordinator | undefined;
-  onTasksChange?: ((tasks: Task[]) => void) | undefined;
+  onTasksChange: (tasks: Task[]) => void;
   requestContinuation?: (() => void) | undefined;
   provider?: { providerName: string; model?: string } | undefined;
 };
@@ -370,7 +375,7 @@ class ChatDirectorImpl extends DefaultDirector {
   private pendingToolOnlyNudge = false;
   private pausedForToolOnly = false;
 
-  constructor(systemPrompt: string, toolDefinitions: ToolDefinition[], options: ChatDirectorImplOptions = {}) {
+  constructor(systemPrompt: string, toolDefinitions: ToolDefinition[], options: ChatDirectorImplOptions) {
     super(systemPrompt, toolDefinitions, {});
     this._systemPrompt = systemPrompt;
     this._toolDefinitions = toolDefinitions;
@@ -802,7 +807,7 @@ class ChatDirectorImpl extends DefaultDirector {
 export function createChatDirector(
   systemPrompt: string,
   toolDefinitions: ToolDefinition[],
-  options: ChatDirectorOptions = {},
+  options: ChatDirectorOptions,
 ): ChatDirector {
   const { provider, ...rest } = options;
   return new ChatDirectorImpl(systemPrompt, toolDefinitions, {
@@ -813,11 +818,11 @@ export function createChatDirector(
   });
 }
 
-// Task state on hydrate is derived with the same manage_tasks-handling logic
-// live sessions use (applyManageTasksToolCall), applied unconditionally on
-// each tool_call regardless of whether its tool_result later errors — a
-// resumed transcript's task list matches what a live session would have
-// held at that point, rather than a looser hydrate-only interpretation.
+// Uses the same applyManageTasksToolCall a live session's decide() loop uses,
+// so hydrate necessarily reaches the same task state live decide() would
+// have produced from this transcript: the tool_call is the authoritative
+// event (see applyManageTasksToolCall), and there is only the one function
+// that knows how to turn a manage_tasks call into a task list.
 export function hydrateTasksFromTurns(turns: ConversationTurn[]): Task[] {
   let tasks: Task[] = [];
   for (const turn of turns) {

src/director.test.ts

@@ -79,7 +79,7 @@ describe("operator declined tool calls", () => {
   // reactor and break further sends, and it does not re-infer off a bare
   // decline.
   test("chat director surfaces the decline and waits, keeping the reactor alive", async () => {
-    const director = createChatDirector("", []);
+    const director = createChatDirector("", [], { onTasksChange: () => {} });
     const actions = actionsArray(await director.decide(makeToolErrorEvent("c", declined), mockState, mockCapabilities));
     expect(hasCheckpoint(actions)).toBe(true);
     expect(hasDeclineReply(actions)).toBe(true);
@@ -109,7 +109,7 @@ describe("open-task termination guard", () => {
   const hasReply = (a: ReactorAction[]): boolean => a.some((x) => x.type === "reply");
 
   test("re-infers instead of ending the turn while a task is still open", async () => {
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     await director.decide(manageTasksEvent("doing"), mockState, mockCapabilities);
 
     const actions = actionsArray(await director.decide(textTurn(), mockState, mockCapabilities));
@@ -118,7 +118,7 @@ describe("open-task termination guard", () => {
   });
 
   test("ends the turn normally once every task is terminal", async () => {
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     await director.decide(manageTasksEvent("done"), mockState, mockCapabilities);
 
     const actions = actionsArray(await director.decide(textTurn(), mockState, mockCapabilities));
@@ -127,7 +127,7 @@ describe("open-task termination guard", () => {
   });
 
   test("stops nudging and lets the turn end after the cap of content-free attempts", async () => {
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     await director.decide(manageTasksEvent("doing"), mockState, mockCapabilities);
 
     for (let i = 0; i < 3; i++) {
@@ -142,7 +142,7 @@ describe("open-task termination guard", () => {
   test("empty model turn settles with an empty reply before wait", async () => {
     // DefaultDirector ends empty responses with bare wait; without a reply,
     // agent.send hangs and the TUI Working spinner sticks forever.
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     const emptyTurn = {
       type: "inference.done",
       turn: { role: "assistant", model: "test", timestamp: 0, content: [] },
@@ -158,7 +158,7 @@ describe("open-task termination guard", () => {
   });
 
   test("a declined tool with open tasks re-infers, then terminates after its cap", async () => {
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     await director.decide(manageTasksEvent("doing"), mockState, mockCapabilities);
 
     for (let i = 0; i < 2; i++) {
@@ -177,7 +177,7 @@ describe("open-task termination guard", () => {
   // single user turn — the budget is monotonic per inbound message, not per
   // tool call, so it does not matter whether a tool call happens at all.
   test("a no-op tool call between nudges does not reset the idle budget", async () => {
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     await director.decide(manageTasksEvent("doing"), mockState, mockCapabilities);
 
     // Two content-free terminations spend two of the three nudges.
@@ -201,7 +201,7 @@ describe("open-task termination guard", () => {
   });
 
   test("a new user message resets the idle budget for the next turn", async () => {
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     await director.decide(manageTasksEvent("doing"), mockState, mockCapabilities);
 
     for (let i = 0; i < 3; i++) {
@@ -221,7 +221,7 @@ describe("open-task termination guard", () => {
   });
 
   test("a successful tool call between declines does not reset the declined budget", async () => {
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     await director.decide(manageTasksEvent("doing"), mockState, mockCapabilities);
 
     // Spend both of the declined-path nudges, with a successful tool result
@@ -242,7 +242,7 @@ describe("open-task termination guard", () => {
   });
 
   test("a declined tool with no open tasks surfaces the decline immediately", async () => {
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     const actions = actionsArray(await director.decide(makeToolErrorEvent("c", declined), mockState, mockCapabilities));
     expect(actions.some((a) => a.type === "reply" && "content" in a && a.content === "Tool call rejected by operator.")).toBe(true);
     expect(actions.some((a) => a.type === "infer")).toBe(false);
@@ -274,6 +274,7 @@ describe("chatDirector compaction", () => {
   test("schedules idle compaction after an over-threshold text-only reply", async () => {
     let continuations = 0;
     const director = createChatDirector("", [], {
+      onTasksChange: () => {},
       requestContinuation: () => {
         continuations++;
       },
@@ -328,7 +329,7 @@ describe("chatDirector compaction", () => {
   }
 
   function chatDirectorWithContinuation(onContinuation?: () => void) {
-    return createChatDirector("", [], { requestContinuation: onContinuation ?? (() => {}) });
+    return createChatDirector("", [], { onTasksChange: () => {}, requestContinuation: onContinuation ?? (() => {}) });
   }
 
   test("compacts at the tool.done pause once over threshold", async () => {
@@ -439,31 +440,31 @@ describe("chatDirector compaction", () => {
 describe("chatDirector LSP auto-activation", () => {
   test("reading a code file activates the lsp tool on success", async () => {
     const activated: string[][] = [];
-    const director = createChatDirector("", [], { onActivateTools: (names: string[]) => activated.push(names) });
+    const director = createChatDirector("", [], { onTasksChange: () => {}, onActivateTools: (names: string[]) => activated.push(names) });
     await director.decide(makeInferenceDoneEvent([{ id: "c", name: "read_file", args: { path: "src/foo.ts" } }]), mockState, mockCapabilities);
     await director.decide(makeToolDoneEvent("c"), mockState, mockCapabilities);
     expect(activated).toEqual([["lsp"]]);
   });
 
   test("editing a code file activates lsp", async () => {
     const activated: string[][] = [];
-    const director = createChatDirector("", [], { onActivateTools: (names: string[]) => activated.push(names) });
+    const director = createChatDirector("", [], { onTasksChange: () => {}, onActivateTools: (names: string[]) => activated.push(names) });
     await director.decide(makeInferenceDoneEvent([{ id: "c", name: "edit_file", args: { path: "lib/bar.rs" } }]), mockState, mockCapabilities);
     await director.decide(makeToolDoneEvent("c"), mockState, mockCapabilities);
     expect(activated).toEqual([["lsp"]]);
   });
 
   test("a non-code file does not activate lsp", async () => {
     const activated: string[][] = [];
-    const director = createChatDirector("", [], { onActivateTools: (names: string[]) => activated.push(names) });
+    const director = createChatDirector("", [], { onTasksChange: () => {}, onActivateTools: (names: string[]) => activated.push(names) });
     await director.decide(makeInferenceDoneEvent([{ id: "c", name: "read_file", args: { path: "README.md" } }]), mockState, mockCapabilities);
     await director.decide(makeToolDoneEvent("c"), mockState, mockCapabilities);
     expect(activated).toEqual([]);
   });
 
   test("a failed read does not activate lsp", async () => {
     const activated: string[][] = [];
-    const director = createChatDirector("", [], { onActivateTools: (names: string[]) => activated.push(names) });
+    const director = createChatDirector("", [], { onTasksChange: () => {}, onActivateTools: (names: string[]) => activated.push(names) });
     await director.decide(makeInferenceDoneEvent([{ id: "c", name: "read_file", args: { path: "src/foo.ts" } }]), mockState, mockCapabilities);
     await director.decide(makeToolErrorEvent("c", "Error: not found"), mockState, mockCapabilities);
     expect(activated).toEqual([]);
@@ -495,7 +496,7 @@ describe("updateToolDefinitions rewrites infer tools", () => {
   };
 
   test("a tool registered after construction is advertised on the next inference", async () => {
-    const director = createChatDirector("base-prompt", []);
+    const director = createChatDirector("base-prompt", [], { onTasksChange: () => {} });
     director.updateToolDefinitions([lateTool]);
 
     const result = await director.decide(makeMessageReceivedEvent("hello"), mockState, capabilitiesWithInferArgs);
@@ -508,7 +509,7 @@ describe("updateToolDefinitions rewrites infer tools", () => {
   // The provider cache is a prefix cache keyed on the tools array; a tool_search
   // between turns must not reshape it.
   test("wire tools are byte-identical across a turn that ran tool_search", async () => {
-    const director = createChatDirector("base-prompt", [lateTool]);
+    const director = createChatDirector("base-prompt", [lateTool], { onTasksChange: () => {} });
 
     const before = await firstInferTools(director, makeMessageReceivedEvent("do work"));
 
@@ -529,7 +530,7 @@ describe("updateToolDefinitions rewrites infer tools", () => {
   // advance_workflow is always on the wire so a workflow going active never grows
   // the array and busts the provider cache prefix.
   test("advance_workflow is advertised even with no active workflow", async () => {
-    const director = createChatDirector("base-prompt", []);
+    const director = createChatDirector("base-prompt", [], { onTasksChange: () => {} });
     director.updateToolDefinitions([lateTool]);
 
     const result = await director.decide(makeMessageReceivedEvent("hello"), mockState, capabilitiesWithInferArgs);
@@ -564,6 +565,7 @@ describe("updateToolDefinitions rewrites infer tools", () => {
     const director = createChatDirector(
       "base-prompt",
       computeAdvertised(toolset.dynamicRunner.currentDefinitions()),
+      { onTasksChange: () => {} },
     );
 
     // Before discovery: the MCP tool is registered (dispatchable) but not wired.
@@ -600,7 +602,7 @@ describe("updateToolDefinitions rewrites infer tools", () => {
 
   test("the new-task path also carries the current tools", async () => {
     const classifier = async (_msg: string, _meta: SessionMetadata) => ({ kind: "new_task" as const, reason: "pivot" } as TaskBoundary);
-    const director = createChatDirector("base-prompt", [], { taskClassifier: classifier });
+    const director = createChatDirector("base-prompt", [], { onTasksChange: () => {}, taskClassifier: classifier });
     director.updateToolDefinitions([lateTool]);
 
     const result = await director.decide(makeMessageReceivedEvent("new thing"), mockState, capabilitiesWithInferArgs);
@@ -656,7 +658,7 @@ describe("transient nudges", () => {
     }) as unknown as ReactorInboundEvent;
 
   test("open-task nudge uses ephemeralTurns, not systemPrompt", async () => {
-    const director = createChatDirector("stable-base", []);
+    const director = createChatDirector("stable-base", [], { onTasksChange: () => {} });
     await director.decide(manageTasksEvent("doing"), mockState, mockCapabilities);
     const actions = actionsArray(await director.decide(textTurn(), mockState, mockCapabilities));
     const infer = actions.find((a) => a.type === "infer");
@@ -704,7 +706,7 @@ describe("goal continue-rule", () => {
 
   test("active not-met goal rewrites a clean yield into re-infer", async () => {
     const { createGoalGovernor } = await import("./agent/goal.js");
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     const g = createGoalGovernor({
       evaluate: async () => ({ met: false, reason: "tests still red" }),
     });
@@ -724,7 +726,7 @@ describe("goal continue-rule", () => {
 
   test("met goal leaves terminal reply and marks achieved", async () => {
     const { createGoalGovernor } = await import("./agent/goal.js");
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     const g = createGoalGovernor({
       evaluate: async () => ({ met: true, reason: "green" }),
     });
@@ -744,7 +746,7 @@ describe("goal continue-rule", () => {
   test("open-task nudge still wins over goal when tasks are open", async () => {
     const { createGoalGovernor } = await import("./agent/goal.js");
     let evals = 0;
-    const director = createChatDirector("base", []);
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
     const g = createGoalGovernor({
       evaluate: async () => {
         evals++;