takomi 2.1.11 → 2.1.12

package/.pi/README.md

@@ -103,18 +103,18 @@ So when working on packaging, agents should distinguish between:
 - Orchestrator sessions run in hybrid mode:
   - human-readable docs live under `docs/tasks/orchestrator-sessions/<sessionId>/`
   - machine state lives under `.pi/takomi/orchestrator/<sessionId>.json`
-- Task packets can carry `workflow`, `skills`, `preferredModel`, `fallbackModels`, `preferredThinking`, `dispatchPolicy`, `conversationId`, and `checklist` metadata.
-- Board redispatch and direct subagent calls now build a `TakomiDelegationPlan` before launch. In auto mode the plan launches immediately; in manual mode the plan is returned for review until `confirmLaunch=true` is supplied.
+- Task packets can carry `workflow`, `skills`, `preferredModel`, `fallbackModels`, `preferredThinking`, `executionHint`, `conversationId`, and `checklist` metadata.
+- Direct `takomi_subagent` calls build a `TakomiDelegationPlan` before launch. In auto mode the plan launches immediately; in manual mode the plan is returned for review until `confirmLaunch=true` is supplied.
 - The subagent tool supports `conversationId`, so reviewed work can be sent back to the same agent for continuation instead of restarting from scratch.
 - The subagent tool supports Pi-style single, parallel `tasks`, and sequential `chain` modes.
 - The subagent tool supports `agentScope` values of `user`, `project`, and `both`; project-local agents require confirmation by default.
 - The subagent tool also supports per-run `workflow`, `skills`, `model`, `fallbackModels`, `thinking`, and `checklist` overrides.
-- Board redispatch and direct `takomi_subagent` calls now share one launch path, so model preflight, thinking, fallback behavior, default prompts, and persisted session files stay aligned.
-- Pi's default `subagent` tool remains owned by the user-level/default subagent extension to avoid tool-name conflicts; Takomi uses `takomi_subagent` as the preferred lifecycle-aware interface and renders it with the native Pi-style result surface.
-- Treat raw `subagent` usage as advanced/internal. Normal Takomi lifecycle work should go through `takomi_subagent` or `takomi_board`.
+- `takomi_board` records session/state/markdown artifacts only; it does not run subagents.
+- Pi's default `subagent` tool remains owned by the user-level/default subagent extension to avoid tool-name conflicts; Takomi uses `takomi_subagent` as the preferred lifecycle-aware execution interface and renders it with the native Pi-style result surface.
+- Treat raw `subagent` usage as advanced/internal. Normal Takomi lifecycle execution should go through `takomi_subagent`, then `takomi_board update_task` should record the outcome.
 - Active Takomi subagent work now streams through the native Pi-style result UI instead of Takomi's older below-editor stack.
 - Use Pi's native result expansion, `Alt+T`, or `/takomi subagents expand` to inspect detailed subagent output.
-- Takomi still tracks active runs internally for status, review continuity, and board synchronization, but it no longer opens a custom subagent fullscreen overlay.
+- Takomi still tracks active runs internally for status and review continuity, but board synchronization is explicit: run with `takomi_subagent`, then update the board.
 - `takomi-context-manager` reduces prompt bloat by replacing the always-on skill description dump with a names-only Skill Index plus progressive `skill_manifest`/`skill_load` tools.
 - `takomi-context-manager` treats `/takomi routing` as the source of truth for model-routing policy via `.pi/settings.json -> takomi.modelRoutingPolicyFile`.
 - `takomi-context-manager` gates `takomi_subagent` when model-routing context has not been loaded, provides the routing policy, and tells the agent to retry.
@@ -122,11 +122,9 @@ So when working on packaging, agents should distinguish between:
 - `takomi-context-manager` detects known duplicate global/project Takomi extension paths in `context_report` to help diagnose tool registration conflicts.
 - `takomi_board` can:
   - create a Genesis-first lifecycle session by default
+  - preserve authored `master_plan.md` and task packet markdown
   - expand a lifecycle stage into additional tasks
-  - update task status and notes
-  - update checklist progress
-  - dispatch approved tasks as single, parallel, or chain subagent run groups
+  - update task status, notes, and checklist progress
   - rewrite JSON machine state
-  - regenerate task docs into `pending/`, `in-progress/`, `completed/`, and `blocked/`
-  - redispatch a task to the same agent with the same `conversationId`
-  - use `review_and_redispatch` for a cleaner review loop
+  - keep task docs organized in `pending/`, `in-progress/`, `completed/`, and `blocked/`
+- `takomi_board` intentionally cannot dispatch or redispatch agents. Use `takomi_subagent` for single, parallel, or chain execution, then call `takomi_board update_task` with the result.

package/.pi/agents/orchestrator.md

@@ -49,7 +49,13 @@ Map sequential vs parallel work explicitly.
 ## Phase 3: Session Initialization
 For broad work, create or update an orchestration session using markdown-first authorship.
 
-Do **not** let JSON/tool fields generate the human plan by themselves. First author the session docs naturally, then register them with `takomi_board` using `masterPlanMarkdown` and each task's `taskMarkdown`.
+Do **not** let JSON/tool fields generate the human plan by themselves. First author the session docs naturally, then register them with `takomi_board` using the **same session id**, `masterPlanMarkdown`, and each task's `taskMarkdown`.
+
+`takomi_board` only tracks session/state/markdown artifacts. Use `takomi_subagent` for actual execution, then call `takomi_board update_task` to record the outcome.
+
+Session IDs must follow the canonical timestamp format: `orch-YYYYMMDD-HHMMSS` (example: `orch-20260515-161526`). Use this exact ID for both the markdown folder and the board JSON state.
+
+If you already wrote `docs/tasks/orchestrator-sessions/<sessionId>/master_plan.md`, call `takomi_board` with `sessionId: "<sessionId>"`. Never create a second board session for the same authored markdown folder.
 
 ### Master Plan Shape
 Create `docs/tasks/orchestrator-sessions/<sessionId>/master_plan.md` with:
@@ -81,7 +87,7 @@ Each task packet should include:
 - `## Constraints`
 - optional `## Dependencies`, `## Verification`, or `## Handoff Notes` when useful
 
-Task packets should be self-contained enough for a subagent to execute without guessing, but scoped enough to review.
+Task packets should be self-contained enough for a subagent to execute without guessing, but scoped enough to review. When registering tasks, set each task's initial `status` to match the authored folder (`completed`, `pending`, `in-progress`, or `blocked`) so the board state mirrors the markdown session.
 
 Keep human-readable markdown meaningful; keep JSON as tracking/continuity metadata.
 

package/.pi/extensions/takomi-runtime/index.ts

@@ -33,10 +33,6 @@ import {
   type TakomiWorkflowId,
   type VibeLifecycleStage,
 } from "../../../src/pi-takomi-core";
-import { discoverProjectAgents, type TakomiAgentConfig } from "../takomi-subagents/agents";
-import { dispatchTakomiSubagent, type TakomiDispatchResult } from "../takomi-subagents/dispatch";
-import { createTakomiDelegationPlan, renderTakomiDelegationPlan } from "../takomi-subagents/delegation-plan";
-import { executeTakomiSubagentTool } from "../takomi-subagents/tool-runner";
 import {
   renderRuntimeStatus,
   renderRuntimeWidget,
@@ -192,7 +188,7 @@ async function loadRolePrompt(cwd: string, role: TakomiRole): Promise<string> {
           cleaned,
         ].join("\n\n");
       }
-    } catch {}
+    } catch { }
   }
 
   return fallbackRolePrompt(role);
@@ -242,7 +238,7 @@ async function loadWorkflowPrompt(cwd: string, workflow: TakomiWorkflowId): Prom
       const raw = await readFile(candidate, "utf8");
       const cleaned = stripTemplateOnlyRequestPlaceholder(stripPromptFrontmatter(raw));
       if (cleaned) return cleaned;
-    } catch {}
+    } catch { }
   }
 
   return undefined;
@@ -278,11 +274,7 @@ function shouldAutoRoute(text: string): boolean {
 }
 
 function buildTaskRows(tasks: OrchestratorTask[]): string {
-  return tasks.map((task) => `${task.id}: ${task.stage ?? "-"} | ${task.title} [${task.status}] -> ${task.preferredAgent ?? task.role}${task.conversationId ? ` (${task.conversationId})` : ""}${task.workflow ? ` | workflow=${task.workflow}` : ""}${task.preferredModel ? ` | model=${task.preferredModel}` : ""}${task.preferredThinking ? ` | thinking=${task.preferredThinking}` : ""}${task.dispatchPolicy ? ` | dispatch=${task.dispatchPolicy}` : ""}${task.skills?.length ? ` | skills=${task.skills.join(",")}` : ""}`).join("\n");
-}
-
-function resolveTaskAgent(task: OrchestratorTask): string {
-  return task.preferredAgent ?? (task.role === "code" ? "coder" : task.role === "design" ? "designer" : task.role === "architect" ? "architect" : task.role === "review" ? "reviewer" : "orchestrator");
+  return tasks.map((task) => `${task.id}: ${task.stage ?? "-"} | ${task.title} [${task.status}] -> ${task.preferredAgent ?? task.role}${task.conversationId ? ` (${task.conversationId})` : ""}${task.workflow ? ` | workflow=${task.workflow}` : ""}${task.preferredModel ? ` | model=${task.preferredModel}` : ""}${task.preferredThinking ? ` | thinking=${task.preferredThinking}` : ""}${task.dispatchPolicy ? ` | execution=${task.dispatchPolicy}` : ""}${task.skills?.length ? ` | skills=${task.skills.join(",")}` : ""}`).join("\n");
 }
 
 function appendTaskNote(existing: string | undefined, heading: string, body?: string): string {
@@ -469,6 +461,7 @@ type IncomingTask = {
   id?: string;
   title: string;
   taskMarkdown?: string;
+  status?: OrchestratorTaskStatus;
   role: TakomiRole;
   stage?: VibeLifecycleStage;
   workflow?: TakomiWorkflowId;
@@ -478,6 +471,7 @@ type IncomingTask = {
   preferredModelHint?: string;
   preferredThinking?: TakomiThinkingLevel;
   fallbackModels?: string[];
+  executionHint?: TakomiDispatchPolicy;
   dispatchPolicy?: TakomiDispatchPolicy;
   skills?: string[];
   checklist?: Array<string | { text: string; done?: boolean }>;
@@ -518,7 +512,8 @@ async function materializeTasksFromInput(
       preferredModelHint: [task.preferredModelHint, resolvedModel.warning].filter(Boolean).join(" ").trim() || undefined,
       preferredThinking: task.preferredThinking ?? defaults.thinking,
       fallbackModels: fallbackModels.length ? fallbackModels : undefined,
-      dispatchPolicy: task.dispatchPolicy ?? defaults.dispatchPolicy,
+      status: task.status ?? "pending",
+      dispatchPolicy: task.executionHint ?? task.dispatchPolicy ?? defaults.dispatchPolicy,
       skills: task.skills,
       checklist: (task.checklist ?? []).map((item) => typeof item === "string" ? { text: item } : item),
       objective: task.objective,
@@ -569,7 +564,7 @@ async function refreshUi(ctx: ExtensionContext, state: TakomiState) {
   if (!ctx.hasUI) return;
   ctx.ui.setTitle("Takomi");
   ctx.ui.setHeader((_tui, theme) => ({
-    invalidate() {},
+    invalidate() { },
     render() {
       return renderTakomiHeader(theme);
     },
@@ -780,34 +775,25 @@ export default function takomiRuntime(pi: ExtensionAPI) {
     name: "takomi_board",
     label: "Takomi Board",
     description: "Create and manage lifecycle-aware Takomi orchestration session artifacts.",
-    promptSnippet: "Track/delegate a Genesis -> Design -> Build orchestration session after the core plan has been authored in markdown.",
+    promptSnippet: "Register or update Takomi session/state/markdown artifacts; subagent execution happens elsewhere.",
     promptGuidelines: [
       "Use this when you need a concrete orchestrator session directory and task artifacts on disk.",
-      "Do not use takomi_board as a substitute for authoring PRD, issue, design, build, master-plan, or task markdown. Write the human-facing markdown first, then use this tool to register/preserve it for state tracking and dispatch.",
-      "For high-quality orchestration sessions, provide masterPlanMarkdown and taskMarkdown values that contain the authored plan/task packets; JSON fields should carry IDs/status/roles/workflow/dependencies/checklists for tracking, not replace expressive markdown.",
+      "takomi_board never runs subagents. Author the human-facing markdown first, use takomi_subagent for execution, then return here with takomi_board update_task to record the outcome.",
+      "Session IDs must use the canonical timestamp format orch-YYYYMMDD-HHMMSS. Use the same sessionId for the authored docs folder and the board JSON state.",
+      "For high-quality orchestration sessions, provide sessionId, masterPlanMarkdown, and taskMarkdown values that match the authored session folder. If you already wrote docs/tasks/orchestrator-sessions/<id>, call this tool with sessionId=<id>; do not create a second session id.",
+      "JSON fields should carry IDs/status/roles/workflow/dependencies/checklists for tracking, not replace expressive markdown.",
       "A new session should normally begin Genesis-first, then expand Design and Build into as many tasks as the scope actually needs.",
       "If the request is small enough, do not force orchestration just because the tool exists.",
-      "If a reviewed task needs more work, keep or reuse its conversationId so the same subagent can continue it.",
+      "If a reviewed task needs more work, reuse the task conversationId when you call takomi_subagent again, then update the board with the new result.",
     ],
     parameters: Type.Object({
-      action: StringEnum(["init_session", "expand_stage", "show_workflows", "show_session", "update_task", "redispatch_task", "review_and_redispatch", "dispatch_tasks"] as const),
+      action: StringEnum(["init_session", "expand_stage", "show_workflows", "show_session", "update_task"] as const),
       title: Type.Optional(Type.String()),
       sessionId: Type.Optional(Type.String()),
       taskId: Type.Optional(Type.String()),
-      taskIds: Type.Optional(Type.Array(Type.String())),
-      dispatchMode: Type.Optional(StringEnum(["single", "parallel", "chain"] as const)),
-      agentScope: Type.Optional(StringEnum(["user", "project", "both"] as const)),
-      confirmProjectAgents: Type.Optional(Type.Boolean()),
       stage: Type.Optional(StringEnum(["genesis", "design", "build"] as const)),
       status: Type.Optional(StringEnum(["pending", "in-progress", "completed", "blocked"] as const)),
       notes: Type.Optional(Type.String()),
-      rerunInstructions: Type.Optional(Type.String()),
-      confirmLaunch: Type.Optional(Type.Boolean()),
-      previewOnly: Type.Optional(Type.Boolean()),
-      preferredAgent: Type.Optional(Type.String()),
-      preferredModel: Type.Optional(Type.String()),
-      preferredThinking: Type.Optional(ThinkingSchema),
-      includeReview: Type.Optional(Type.Boolean()),
       checklist: Type.Optional(Type.Array(Type.Union([
         Type.String(),
         Type.Object({ text: Type.String(), done: Type.Optional(Type.Boolean()) }),
@@ -822,6 +808,7 @@ export default function takomiRuntime(pi: ExtensionAPI) {
         id: Type.Optional(Type.String()),
         title: Type.String(),
         taskMarkdown: Type.Optional(Type.String()),
+        status: Type.Optional(StringEnum(["pending", "in-progress", "completed", "blocked"] as const)),
         role: StringEnum(["general", "orchestrator", "architect", "design", "code", "review"] as const),
         stage: Type.Optional(StringEnum(["genesis", "design", "build"] as const)),
         workflow: Type.Optional(StringEnum(["vibe-genesis", "vibe-design", "vibe-build"] as const)),
@@ -831,7 +818,7 @@ export default function takomiRuntime(pi: ExtensionAPI) {
         preferredModelHint: Type.Optional(Type.String()),
         preferredThinking: Type.Optional(ThinkingSchema),
         fallbackModels: Type.Optional(Type.Array(Type.String())),
-        dispatchPolicy: Type.Optional(StringEnum(["direct", "subagent", "review-first"] as const)),
+        executionHint: Type.Optional(StringEnum(["direct", "subagent", "review-first"] as const)),
         skills: Type.Optional(Type.Array(Type.String())),
         checklist: Type.Optional(Type.Array(Type.Union([
           Type.String(),
@@ -866,8 +853,10 @@ export default function takomiRuntime(pi: ExtensionAPI) {
           readFile(paths.stateFile, "utf8").catch(() => "{}"),
         ]);
         return {
-          content: [{ type: "text", text: `${masterPlan}\n\n---\n\nMachine state\n\n\
-${stateJson}` }],
+          content: [{
+            type: "text", text: `${masterPlan}\n\n---\n\nMachine state\n\n\
+${stateJson}`
+          }],
           details: { paths, state: normalizeSessionState({ sessionId: params.sessionId, title: "Takomi Session", ...(JSON.parse(stateJson) as Partial<OrchestratorSessionState>) }) },
         };
       }
@@ -931,242 +920,6 @@ ${stateJson}` }],
         };
       }
 
-      if (params.action === "dispatch_tasks") {
-        if (!state.subagentsEnabled) {
-          return {
-            content: [{ type: "text", text: "Takomi subagents are disabled. Use /takomi subagents on before dispatching board tasks." }],
-            details: { sessionId: params.sessionId, taskIds: params.taskIds },
-            isError: true,
-          };
-        }
-        if (!params.sessionId || !params.taskIds?.length) {
-          return { content: [{ type: "text", text: "sessionId and taskIds are required for dispatch_tasks" }], details: {}, isError: true };
-        }
-        const { state: sessionState } = await loadSessionState(ctx.cwd, params.sessionId);
-        const selectedTasks = params.taskIds.map((id) => sessionState.tasks.find((task) => task.id === id));
-        if (selectedTasks.some((task) => !task)) {
-          return {
-            content: [{ type: "text", text: `Some taskIds were not found in session ${params.sessionId}.` }],
-            details: { requestedTaskIds: params.taskIds, availableTaskIds: sessionState.tasks.map((task) => task.id) },
-            isError: true,
-          };
-        }
-        const boardTasks = selectedTasks as OrchestratorTask[];
-        const mode = params.dispatchMode ?? (boardTasks.length === 1 ? "single" : "parallel");
-        const toolTasks = boardTasks.map((task) => ({
-          agent: params.preferredAgent ?? resolveTaskAgent(task),
-          task: task.notes || task.title,
-          workflow: task.workflow,
-          skills: task.skills,
-          model: params.preferredModel ?? task.preferredModel,
-          fallbackModels: task.fallbackModels,
-          thinking: params.preferredThinking ?? task.preferredThinking,
-          conversationId: task.conversationId ?? task.id,
-          checklist: task.checklist,
-        }));
-        if (params.previewOnly || ((state.launchMode ?? activeProfile.launchMode) === "manual" && !params.confirmLaunch)) {
-          return executeTakomiSubagentTool(pi, {
-            ...(mode === "chain" ? { chain: toolTasks } : mode === "parallel" ? { tasks: toolTasks } : toolTasks[0]),
-            previewOnly: true,
-            agentScope: params.agentScope ?? "both",
-            confirmProjectAgents: params.confirmProjectAgents,
-          }, _signal, _onUpdate, ctx);
-        }
-        for (const task of boardTasks) task.status = "in-progress";
-        let nextState = buildSessionState(sessionState.sessionId, sessionState.title, sessionState.tasks, new Date(), {
-          sessionIntent: sessionState.sessionIntent,
-          lifecycle: sessionState.lifecycle,
-        });
-        const paths = await syncTaskArtifacts(ctx.cwd, nextState);
-        const toolResult = await executeTakomiSubagentTool(pi, {
-          ...(mode === "chain" ? { chain: toolTasks } : mode === "parallel" ? { tasks: toolTasks } : toolTasks[0]),
-          confirmLaunch: true,
-          agentScope: params.agentScope ?? "both",
-          confirmProjectAgents: params.confirmProjectAgents,
-        }, _signal, _onUpdate, ctx);
-        const results = (toolResult.details as { results?: TakomiDispatchResult[] }).results ?? [];
-        for (let index = 0; index < boardTasks.length; index++) {
-          const result = results[index];
-          const task = boardTasks[index];
-          if (!result) continue;
-          task.conversationId = result.conversationId;
-          task.notes = appendTaskNote(task.notes, "Model preflight", result.preflight);
-          task.notes = appendTaskNote(task.notes, "Last dispatch output", result.output || result.stderr);
-          if (result.code !== 0) task.status = "blocked";
-          if (result.model) task.preferredModel = result.model;
-          if (result.thinking) task.preferredThinking = result.thinking;
-        }
-        nextState = buildSessionState(sessionState.sessionId, sessionState.title, sessionState.tasks, new Date(), {
-          sessionIntent: sessionState.sessionIntent,
-          lifecycle: sessionState.lifecycle,
-        });
-        await syncTaskArtifacts(ctx.cwd, nextState);
-        return {
-          content: toolResult.content,
-          details: { ...toolResult.details, sessionId: params.sessionId, paths, lifecycle: nextState.lifecycle, mode },
-          isError: results.some((result) => result.code !== 0) || undefined,
-        };
-      }
-
-      if (params.action === "redispatch_task" || params.action === "review_and_redispatch") {
-        if (!state.subagentsEnabled) {
-          return {
-            content: [{ type: "text", text: "Takomi subagents are disabled. Use /takomi subagents on before redispatching." }],
-            details: { sessionId: params.sessionId, taskId: params.taskId },
-            isError: true,
-          };
-        }
-        if (!params.sessionId || !params.taskId) {
-          return { content: [{ type: "text", text: "sessionId and taskId are required for redispatch_task" }], details: {}, isError: true };
-        }
-        const { state: sessionState } = await loadSessionState(ctx.cwd, params.sessionId);
-        const task = sessionState.tasks.find((item) => item.id === params.taskId);
-        if (!task) {
-          return { content: [{ type: "text", text: `Task ${params.taskId} not found in session ${params.sessionId}` }], details: {}, isError: true };
-        }
-        const draftChecklist = resolveChecklistState(task.checklist, params.checklist, params.checklistUpdates);
-        const agentName = params.preferredAgent ?? resolveTaskAgent(task);
-        const draftModel = params.preferredModel ?? task.preferredModel;
-        const draftThinking = params.preferredThinking ?? task.preferredThinking;
-        const conversationId = task.conversationId ?? task.id;
-        const launchMode = state.launchMode ?? activeProfile.launchMode ?? "auto";
-        const plan = createTakomiDelegationPlan({
-          source: "runtime-board",
-          sessionId: params.sessionId,
-          launchMode,
-          profile: activeProfile,
-          tasks: [{
-            id: task.id,
-            title: task.title,
-            agent: agentName,
-            task: params.rerunInstructions ?? task.notes ?? task.title,
-            role: task.role,
-            stage: task.stage,
-            workflow: task.workflow,
-            model: draftModel,
-            fallbackModels: task.fallbackModels,
-            thinking: draftThinking,
-            conversationId,
-            checklist: draftChecklist,
-            dispatchPolicy: task.dispatchPolicy,
-            review: params.includeReview,
-          }],
-        });
-        if (params.previewOnly || (launchMode === "manual" && !params.confirmLaunch)) {
-          return {
-            content: [{ type: "text", text: renderTakomiDelegationPlan(plan) }],
-            details: { sessionId: params.sessionId, taskId: task.id, plan },
-          };
-        }
-
-        const agents: TakomiAgentConfig[] = discoverProjectAgents(ctx.cwd);
-        const config = agents.find((agent: TakomiAgentConfig) => agent.name === agentName);
-        if (!config) {
-          return { content: [{ type: "text", text: `Preferred agent '${agentName}' not found.` }], details: { availableAgents: agents.map((agent: TakomiAgentConfig) => agent.name) }, isError: true };
-        }
-
-        task.status = "in-progress";
-        task.checklist = draftChecklist;
-        task.preferredAgent = agentName;
-        task.preferredModel = draftModel;
-        task.preferredThinking = draftThinking;
-        if (params.action === "review_and_redispatch") {
-          task.notes = appendTaskNote(task.notes, "Review feedback", params.notes);
-        } else if (params.notes) {
-          task.notes = params.notes;
-        }
-        let nextState = buildSessionState(
-          sessionState.sessionId,
-          sessionState.title,
-          sessionState.tasks,
-          new Date(),
-          {
-            sessionIntent: sessionState.sessionIntent,
-            lifecycle: sessionState.lifecycle,
-          },
-        );
-        const paths = await syncTaskArtifacts(ctx.cwd, nextState);
-        task.conversationId = conversationId;
-        const runKey = conversationId;
-        const parentRunKey = task.parentTaskId
-          ? (() => {
-              const parentTask = sessionState.tasks.find((item) => item.id === task.parentTaskId);
-              if (parentTask) return parentTask.conversationId ?? parentTask.id;
-              return subagentController.getKnownParentRunKey(task.parentTaskId);
-            })()
-          : undefined;
-
-        const result = await dispatchTakomiSubagent(ctx, {
-          agent: config,
-          task: task.notes || task.title,
-          rootCwd: ctx.cwd,
-          workflow: task.workflow,
-          skills: task.skills,
-          model: task.preferredModel,
-          fallbackModels: task.fallbackModels,
-          thinking: task.preferredThinking,
-          conversationId,
-          checklist: task.checklist,
-          stage: task.stage,
-          taskLabel: `${task.id} - ${task.title}`,
-          parentTaskId: task.parentTaskId,
-          parentRunKey,
-          boardTaskStatus: task.status,
-          source: "runtime-board",
-          rerunInstructions: params.rerunInstructions,
-        }, _signal, {
-          emit: (event) => {
-            void applySubagentRuntimeEvent(event, ctx);
-          },
-        });
-
-        task.notes = appendTaskNote(task.notes, "Model preflight", result.preflight);
-        if (result.model) task.preferredModel = result.model;
-        if (result.warning) {
-          task.notes = appendTaskNote(task.notes, "Model fallback", result.warning);
-          if (ctx.hasUI) ctx.ui.notify(result.warning, "warning");
-        }
-        if (result.thinking) task.preferredThinking = result.thinking;
-
-        if (result.code !== 0) {
-          task.status = "blocked";
-          task.notes = appendTaskNote(task.notes, "Redispatch failure", result.stderr || result.output);
-          nextState = buildSessionState(
-            sessionState.sessionId,
-            sessionState.title,
-            sessionState.tasks,
-            new Date(),
-            {
-              sessionIntent: sessionState.sessionIntent,
-              lifecycle: sessionState.lifecycle,
-            },
-          );
-          await syncTaskArtifacts(ctx.cwd, nextState);
-          return {
-            content: [{ type: "text", text: `Redispatch failed for task ${task.id}.\n\n${result.stderr || result.output || "No output"}` }],
-            details: { sessionId: params.sessionId, task, paths, result },
-            isError: true,
-          };
-        }
-
-        task.notes = appendTaskNote(task.notes, "Last redispatch output", result.output);
-        nextState = buildSessionState(
-          sessionState.sessionId,
-          sessionState.title,
-          sessionState.tasks,
-          new Date(),
-          {
-            sessionIntent: sessionState.sessionIntent,
-            lifecycle: sessionState.lifecycle,
-          },
-        );
-        await syncTaskArtifacts(ctx.cwd, nextState);
-        return {
-          content: [{ type: "text", text: `${result.preflight}\n\n${result.output || `Redispatched task ${task.id} to ${agentName}.`}` }],
-          details: { sessionId: params.sessionId, task, paths, lifecycle: nextState.lifecycle, agent: agentName, conversationId: task.conversationId, action: params.action, result },
-        };
-      }
-
       if (params.action === "expand_stage") {
         if (!params.sessionId || !params.stage || !params.tasks?.length) {
           return { content: [{ type: "text", text: "sessionId, stage, and at least one task are required for expand_stage" }], details: {}, isError: true };
@@ -1359,7 +1112,7 @@ ${stateJson}` }],
       modelPreflightContext,
       `Execution mode: ${route.executionMode}. Session recommendation: ${route.sessionRecommendation}.`,
       `Takomi execution gate: ${effectiveState.launchMode === "manual" ? "review" : "auto"}. In review gate mode, show the delegation plan before launching and return to the user after each task with results, verification guidance, and the recommended next step.`,
-      !effectiveState.subagentsEnabled ? "Takomi subagents are disabled for this session. Do not call takomi_subagent, subagent, or redispatch board tasks until the user enables subagents." : "",
+      !effectiveState.subagentsEnabled ? "Takomi subagents are disabled for this session. Do not call takomi_subagent or subagent until the user enables subagents." : "",
       !genesisExists ? "Project foundation is missing or incomplete. Do not skip Genesis unless the user explicitly waives it." : "",
       "Takomi is the default orchestration mindset here. Do not wait for the literal phrase 'use Takomi' before applying lifecycle judgment.",
       "Task fan-out is flexible. Do not force exactly three tasks; decompose Genesis, Design, and Build work to fit the actual scope.",
@@ -1368,7 +1121,7 @@ ${stateJson}` }],
       "Before any Takomi subagent dispatch or model override, use the injected Pi model-registry context and project routing policy. Prefer provider-qualified model IDs. Do not run `pi --list-models` unless the registry context is missing or the user asks for a visible diagnostic.",
       "When useful, state the current Takomi stage and the recommended next stage.",
       effectiveState.stage === "build"
-        ? "For build orchestration, it is valid to dispatch tasks to specialist subagents, review them, and send fixes back to the same agent by reusing its conversation id."
+        ? "For build orchestration, use takomi_subagent to dispatch work to specialist subagents, then record the result on takomi_board; reuse the same conversation id when sending fixes back to the agent."
         : "",
     ].filter(Boolean);
 

package/.pi/extensions/takomi-subagents/live-updates.ts

@@ -1,6 +1,6 @@
 import type { TakomiThinkingLevel } from "../../../src/pi-takomi-core";
 import type { TakomiSubagentRuntimeEvent } from "../takomi-runtime/subagent-types";
-import type { TakomiDispatchResult } from "./dispatch";
+import type { TakomiDispatchResult } from "./run-types";
 
 type ToolUpdate = (partial: {
   content: Array<{ type: "text"; text: string }>;

package/.pi/extensions/takomi-subagents/run-types.ts

@@ -0,0 +1,25 @@
+import type { TakomiThinkingLevel } from "../../../src/pi-takomi-core";
+
+export type TakomiDispatchResult = {
+  agent: string;
+  task: string;
+  workflow?: string;
+  model?: string;
+  warning?: string;
+  thinking?: TakomiThinkingLevel;
+  conversationId: string;
+  code: number;
+  output: string;
+  stderr: string;
+  preflight: string;
+  startedAt?: number;
+  endedAt?: number;
+  lastActivityAt?: number;
+  currentTool?: string;
+  currentToolArgs?: string;
+  currentToolStartedAt?: number;
+  recentTools?: Array<{ tool: string; args: string; endMs: number }>;
+  recentOutput?: string[];
+  toolCount?: number;
+  sessionFile?: string;
+};

package/.pi/extensions/takomi-subagents/tool-runner.ts

@@ -9,7 +9,8 @@ import {
 import { resolveAgentName } from "./agent-aliases";
 import { discoverTakomiAgents, type TakomiAgentConfig, type TakomiAgentScope } from "./agents";
 import { createTakomiDelegationPlan, renderTakomiDelegationPlan } from "./delegation-plan";
-import { dispatchTakomiSubagent, type TakomiDispatchResult } from "./dispatch";
+import type { TakomiDispatchResult } from "./run-types";
+import { createTakomiPiSubagentsEngine } from "./pi-subagents-engine";
 import { createTakomiLiveUpdateBridge } from "./live-updates";
 
 type ChecklistItem = string | { text: string; done?: boolean };
@@ -110,6 +111,7 @@ export async function executeTakomiSubagentTool(
   onUpdate: ToolUpdate | undefined,
   ctx: ExtensionContext,
 ) {
+  const engine = createTakomiPiSubagentsEngine(pi);
   const rootCwd = params.cwd ? path.resolve(ctx.cwd, params.cwd) : ctx.cwd;
   const profile = await loadTakomiProfile(rootCwd);
   const agentScope = params.agentScope ?? "both";
@@ -161,10 +163,9 @@ export async function executeTakomiSubagentTool(
   const runOne = async (item: TakomiSubagentToolTask, index: number, previousOutput = "") => {
     const config = byName.get(item.agent);
     if (!config) throw new Error(`Unknown subagent '${item.agent}'. Available: ${agents.map((agent) => `${agent.name} (${agent.source})`).join(", ") || "none"}`);
-    const result = await dispatchTakomiSubagent(ctx, {
-      agent: config,
+    const raw: any = await engine.execute(`takomi-tool-${index + 1}`, {
+      agent: item.agent,
       task: item.task.replaceAll("{previous}", previousOutput),
-      rootCwd,
       cwd: item.cwd,
       workflow: item.workflow,
       skills: item.skills,
@@ -173,13 +174,22 @@ export async function executeTakomiSubagentTool(
       thinking: item.thinking,
       conversationId: item.conversationId,
       checklist: item.checklist,
-      source: "takomi-tool",
-    }, signal, {
-      emit: (event) => {
-        emitRuntimeSubagentEvent(pi, event);
-        live.event(index, event);
-      },
-    });
+    }, signal, undefined as any, ctx);
+    const single = raw?.details?.results?.[0] ?? {};
+    const result: TakomiDispatchResult = {
+      agent: single.agent ?? config.name,
+      task: item.task,
+      workflow: item.workflow,
+      model: single.model ?? item.model,
+      warning: single.warning,
+      thinking: item.thinking,
+      conversationId: single.conversationId ?? item.conversationId ?? `${config.name}-${Date.now()}`,
+      code: single.exitCode ?? 1,
+      output: single.messages?.map((message: any) => message?.content?.map((part: any) => part?.type === "text" ? part.text : "").filter(Boolean).join("\n")).filter(Boolean).join("\n\n") ?? "",
+      stderr: single.stderr ?? "",
+      preflight: raw?.content?.[0]?.text ?? "",
+      sessionFile: single.sessionFile,
+    };
     live.finish(index, result);
     return result;
   };

package/.pi/prompts/takomi-prompt.md

@@ -16,6 +16,9 @@ Always-on Takomi behavior.
 - Do not blend architecture, design, and implementation sloppily.
 - When the right path is clear, make a recommendation instead of hedging.
 - For broad work, Genesis may create the orchestration session that carries work into later stages.
+- Orchestration sessions use canonical timestamp IDs: `orch-YYYYMMDD-HHMMSS`.
+- Orchestration sessions are markdown-first: author `master_plan.md` and task packets first, then call `takomi_board` with the same `sessionId`, `masterPlanMarkdown`, task `taskMarkdown`, and matching task statuses. Do not create a second board session for already-authored session docs.
+- `takomi_board` never runs subagents. Use `takomi_subagent` for execution, then come back to `takomi_board update_task` to record results.
 
 ## Shared Mode Pattern
 - Load context before acting.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "takomi",
-  "version": "2.1.11",
+  "version": "2.1.12",
   "description": "🎯 Stop wrestling with AI. Start building with purpose. The artisan's toolkit for agent workflows, Codex skills, and original Takomi capabilities like 21st.dev integration.",
   "type": "module",
   "bin": {

package/src/pi-takomi-core/orchestration.ts

@@ -316,7 +316,7 @@ export function renderMasterPlan(sessionOrId: OrchestratorSessionState | string,
     "- Human-readable task docs live in this session folder.",
     "- Machine state lives in `.pi/takomi/orchestrator/<sessionId>.json`.",
     "- Sessions follow the Genesis -> Design -> Build lifecycle, but each stage may stay compact or expand into more tasks.",
-    "- Rich runtime metadata such as conversation continuity, model overrides, and dispatch behavior remains in JSON rather than cluttering the markdown surface.",
+    "- Rich runtime metadata such as conversation continuity, model overrides, and execution hints remains in JSON rather than cluttering the markdown surface.",
   ].join("\n");
 }
 

package/src/update-check.js

@@ -130,11 +130,18 @@ export async function printTakomiUpdateStatus(currentVersion) {
 
 export function upgradeTakomiPackage() {
   console.log(pc.cyan('Updating Takomi from npm...\n'));
-  const command = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-  const result = spawnSync(command, ['install', '-g', 'takomi@latest'], {
-    stdio: 'inherit',
-    shell: process.platform === 'win32',
-  });
+
+  // Avoid `shell: true` here. Newer Node versions emit DEP0190 when args are
+  // passed alongside `shell: true`, because they are concatenated rather than
+  // escaped. On Windows, invoke the npm cmd shim through cmd.exe explicitly.
+  const result = process.platform === 'win32'
+    ? spawnSync('cmd.exe', ['/d', '/s', '/c', 'npm.cmd', 'install', '-g', 'takomi@latest'], {
+        stdio: 'inherit',
+      })
+    : spawnSync('npm', ['install', '-g', 'takomi@latest'], {
+        stdio: 'inherit',
+      });
+
   if (result.status === 0) {
     console.log(pc.green('\nTakomi updated. Run `takomi --version` to confirm.'));
     return 0;

package/.pi/extensions/takomi-subagents/dispatch-helpers.ts

@@ -1,62 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import type { TakomiDispatchInput } from "./dispatch";
-
-export function uniqueStrings(values: Array<string | undefined>): string[] {
-  return [...new Set(values.filter((value): value is string => Boolean(value?.trim())))];
-}
-
-export function hasThinkingSuffix(model?: string): boolean {
-  return /:(off|minimal|low|medium|high|xhigh)$/i.test(model ?? "");
-}
-
-export function buildFallbackModels(input: TakomiDispatchInput): string[] {
-  return uniqueStrings([
-    input.agent.model,
-    ...(input.fallbackModels ?? []),
-    ...(input.agent.fallbackModels ?? []),
-  ]);
-}
-
-function buildPrimeStub(input: TakomiDispatchInput): string {
-  const checklist = [
-    "Prime context before work: inspect the repo docs and current task state.",
-    "Follow the role prompt and assigned workflow.",
-    "Use repo context as the source of truth; do not rely on optional skills as a prerequisite.",
-  ];
-  if (input.workflow) checklist.push(`This task uses the ${input.workflow} workflow.`);
-  return [`Takomi subagent preflight:`, ...checklist].join("\n");
-}
-
-function stripPromptFrontmatter(content: string): string {
-  return content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "").trim();
-}
-
-function workflowPromptFile(workflow?: string): string | undefined {
-  if (workflow === "vibe-genesis") return "genesis-prompt.md";
-  if (workflow === "vibe-design") return "design-prompt.md";
-  if (workflow === "vibe-build") return "build-prompt.md";
-  return undefined;
-}
-
-function loadWorkflowPrompt(input: TakomiDispatchInput): string | undefined {
-  const fileName = workflowPromptFile(input.workflow);
-  if (!fileName) return undefined;
-  const promptPath = path.join(input.rootCwd, ".pi", "prompts", fileName);
-  try {
-    const prompt = stripPromptFrontmatter(fs.readFileSync(promptPath, "utf8"));
-    return prompt ? [`Full assigned workflow loaded from ${path.relative(input.rootCwd, promptPath)}:`, prompt].join("\n\n") : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-export function buildSystemPrompt(input: TakomiDispatchInput): string {
-  return [
-    input.agent.systemPrompt,
-    buildPrimeStub(input),
-    loadWorkflowPrompt(input) ?? (input.workflow ? `\nUse the ${input.workflow} workflow for this task.` : ""),
-    input.skills?.length ? `\nOptional skill/context overlays for this task: ${input.skills.join(", ")}. Use them only if available and genuinely helpful; otherwise rely on the harness workflow and repo context.` : "",
-    input.thinking ? `\nUse Pi thinking level '${input.thinking}' for this delegated run when the selected model supports it.` : "",
-  ].filter(Boolean).join("\n");
-}

package/.pi/extensions/takomi-subagents/dispatch.ts

@@ -1,318 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import path from "node:path";
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { TakomiThinkingLevel } from "../../../src/pi-takomi-core";
-import {
-  buildTaskPrompt,
-  runModelPreflight,
-  runPiAgentJson,
-  writeTempPrompt,
-  type ChecklistInput,
-} from "../takomi-runtime/shared";
-import type {
-  TakomiSubagentRuntimeEvent,
-  TakomiSubagentRunPatch,
-} from "../takomi-runtime/subagent-types";
-import type { TakomiAgentConfig } from "./agents";
-import {
-  buildFallbackModels,
-  buildSystemPrompt,
-  hasThinkingSuffix,
-} from "./dispatch-helpers";
-
-export type TakomiDispatchInput = {
-  agent: TakomiAgentConfig;
-  task: string;
-  rootCwd: string;
-  cwd?: string;
-  workflow?: string;
-  skills?: string[];
-  model?: string;
-  fallbackModels?: string[];
-  thinking?: TakomiThinkingLevel;
-  conversationId?: string;
-  checklist?: ChecklistInput;
-  stage?: string;
-  taskLabel?: string;
-  parentTaskId?: string;
-  parentRunKey?: string;
-  boardTaskStatus?: "pending" | "in-progress" | "completed" | "blocked";
-  source: "runtime-board" | "takomi-tool";
-  rerunInstructions?: string;
-};
-
-export type TakomiDispatchResult = {
-  agent: string;
-  task: string;
-  workflow?: string;
-  model?: string;
-  warning?: string;
-  thinking?: TakomiThinkingLevel;
-  conversationId: string;
-  code: number;
-  output: string;
-  stderr: string;
-  preflight: string;
-  startedAt?: number;
-  endedAt?: number;
-  lastActivityAt?: number;
-  currentTool?: string;
-  currentToolArgs?: string;
-  currentToolStartedAt?: number;
-  recentTools?: Array<{ tool: string; args: string; endMs: number }>;
-  recentOutput?: string[];
-  toolCount?: number;
-  sessionFile?: string;
-};
-
-export type TakomiDispatchHooks = {
-  emit?: (event: TakomiSubagentRuntimeEvent) => void;
-  onPatch?: (patch: TakomiSubagentRunPatch, runKey: string) => void | Promise<void>;
-};
-
-export async function dispatchTakomiSubagent(
-  ctx: ExtensionContext,
-  input: TakomiDispatchInput,
-  signal?: AbortSignal,
-  hooks?: TakomiDispatchHooks,
-): Promise<TakomiDispatchResult> {
-  const subagentCwd = input.cwd ? path.resolve(input.rootCwd, input.cwd) : input.rootCwd;
-  const conversationId = input.conversationId || `${input.agent.name}-${Date.now()}`;
-  const runKey = conversationId;
-  const sessionDir = path.join(input.rootCwd, ".pi", "takomi", "subagents");
-  const sessionPath = path.join(sessionDir, `${conversationId}.jsonl`);
-  await mkdir(sessionDir, { recursive: true });
-  const startedAt = Date.now();
-  let lastActivityAt = startedAt;
-  let currentTool: string | undefined;
-  let currentToolArgs: string | undefined;
-  let currentToolStartedAt: number | undefined;
-  let toolCount = 0;
-  let recentTools: Array<{ tool: string; args: string; endMs: number }> = [];
-  const activeToolInvocations = new Map<string, { tool: string; args: string; startedAt: number }>();
-  let recentOutput: string[] = [];
-
-  const setCurrentToolFromActive = () => {
-    const latest = [...activeToolInvocations.values()].at(-1);
-    currentTool = latest?.tool;
-    currentToolArgs = latest?.args;
-    currentToolStartedAt = latest?.startedAt;
-  };
-
-  const appendRecentOutput = (text: string) => {
-    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-    if (!lines.length) return;
-    recentOutput.push(...lines);
-    if (recentOutput.length > 8) recentOutput.splice(0, recentOutput.length - 8);
-    lastActivityAt = Date.now();
-  };
-
-  hooks?.emit?.({
-    type: "start",
-    runKey,
-    state: {
-      agent: input.agent.name,
-      taskLabel: input.taskLabel ?? input.task.split(/\r?\n/)[0]?.trim() ?? input.agent.name,
-      workflow: input.workflow,
-      stage: input.stage,
-      conversationId,
-      parentTaskId: input.parentTaskId,
-      parentRunKey: input.parentRunKey,
-      checklist: input.checklist,
-      boardTaskStatus: input.boardTaskStatus,
-      fallbackModels: input.fallbackModels,
-      thinking: input.thinking ?? input.agent.thinking,
-      summary: "Preparing delegated run.",
-      source: input.source,
-    },
-  });
-
-  const fallbackModels = buildFallbackModels(input);
-  const preflight = await runModelPreflight(ctx, subagentCwd, input.model, fallbackModels, signal);
-  const thinking = input.thinking ?? input.agent.thinking;
-
-  if (preflight.model) {
-    const patch = {
-      model: preflight.model,
-      fallbackModels,
-      thinking,
-      boardTaskStatus: input.boardTaskStatus,
-      checklist: input.checklist,
-      summary: `Model ready: ${preflight.model}${thinking ? ` (${thinking})` : ""}`,
-    };
-    hooks?.emit?.({ type: "update", runKey, patch });
-    await hooks?.onPatch?.(patch, runKey);
-  }
-
-  if (!preflight.model) {
-    const result = {
-      agent: input.agent.name,
-      task: input.task,
-      workflow: input.workflow,
-      model: "",
-      warning: preflight.warning,
-      thinking,
-      conversationId,
-      code: 1,
-      output: "",
-      stderr: preflight.report,
-      preflight: preflight.report,
-      startedAt,
-      endedAt: Date.now(),
-      lastActivityAt,
-      recentTools,
-      recentOutput,
-      toolCount,
-      sessionFile: sessionPath,
-    };
-    hooks?.emit?.({
-      type: "block",
-      runKey,
-      patch: {
-        summary: `Subagent ${input.agent.name} blocked before launch.`,
-        boardTaskStatus: input.boardTaskStatus,
-        checklist: input.checklist,
-        fallbackModels,
-        thinking,
-        logs: [preflight.warning || "No model matched the requested run."],
-      },
-    });
-    return result;
-  }
-
-  const promptPath = await writeTempPrompt(input.agent.name, buildSystemPrompt(input));
-  const taskPrompt = buildTaskPrompt({
-    task: input.rerunInstructions?.trim() || input.task,
-    workflow: input.workflow,
-    skills: input.skills,
-    checklist: input.checklist,
-    stage: input.stage,
-  });
-  const args = ["--mode", "json", "--append-system-prompt", promptPath, "--session", sessionPath, taskPrompt];
-  args.unshift("--model", preflight.model);
-  if (thinking && !hasThinkingSuffix(preflight.model)) args.unshift("--thinking", thinking);
-  if (input.agent.tools?.length) args.unshift("--tools", input.agent.tools.join(","));
-
-  const result = await runPiAgentJson(subagentCwd, args, signal, {
-    onAssistantText: (text) => {
-      appendRecentOutput(text);
-      hooks?.emit?.({
-        type: "update",
-        runKey,
-        patch: {
-          outputText: text,
-          recentOutput,
-          currentTool,
-          currentToolArgs,
-          currentToolStartedAt,
-          recentTools,
-          toolCount,
-          boardTaskStatus: input.boardTaskStatus,
-          checklist: input.checklist,
-        },
-      });
-    },
-    onEventText: (line) => {
-      appendRecentOutput(line);
-      hooks?.emit?.({ type: "appendLog", runKey, chunk: line });
-      hooks?.emit?.({ type: "update", runKey, patch: { recentOutput, boardTaskStatus: input.boardTaskStatus, checklist: input.checklist } });
-    },
-    onToolEvent: (event) => {
-      lastActivityAt = Date.now();
-      const invocationId = event.invocationId ?? event.toolName;
-      if (event.type === "start") {
-        activeToolInvocations.set(invocationId, {
-          tool: event.toolName,
-          args: event.args ?? "",
-          startedAt: Date.now(),
-        });
-        toolCount += 1;
-        setCurrentToolFromActive();
-      } else if (event.type === "end") {
-        const active = activeToolInvocations.get(invocationId);
-        recentTools.push({ tool: event.toolName, args: active?.args ?? "", endMs: Date.now() });
-        if (recentTools.length > 8) recentTools.splice(0, recentTools.length - 8);
-        activeToolInvocations.delete(invocationId);
-        setCurrentToolFromActive();
-      }
-      hooks?.emit?.({
-        type: "update",
-        runKey,
-        patch: {
-          currentTool,
-          currentToolArgs,
-          currentToolStartedAt,
-          recentTools,
-          recentOutput,
-          toolCount,
-          boardTaskStatus: input.boardTaskStatus,
-          checklist: input.checklist,
-        },
-      });
-    },
-    onStderr: (chunk) => {
-      appendRecentOutput(chunk);
-      hooks?.emit?.({ type: "appendLog", runKey, chunk });
-      hooks?.emit?.({ type: "update", runKey, patch: { recentOutput, boardTaskStatus: input.boardTaskStatus, checklist: input.checklist } });
-    },
-  });
-
-  const output = result.stdout.trim();
-  const dispatchResult: TakomiDispatchResult = {
-    agent: input.agent.name,
-    task: input.task,
-    workflow: input.workflow,
-    model: preflight.model,
-    warning: preflight.warning,
-    thinking,
-    conversationId,
-    code: result.code,
-    output,
-    stderr: result.stderr.trim(),
-    preflight: preflight.report,
-    startedAt,
-    endedAt: Date.now(),
-    lastActivityAt,
-    currentTool,
-    currentToolArgs,
-    currentToolStartedAt,
-    recentTools,
-    recentOutput,
-    toolCount,
-    sessionFile: sessionPath,
-  };
-
-  if (result.code !== 0) {
-    hooks?.emit?.({
-      type: "block",
-      runKey,
-      patch: {
-        model: preflight.model,
-        fallbackModels,
-        thinking,
-        boardTaskStatus: input.boardTaskStatus,
-        checklist: input.checklist,
-        summary: `Subagent ${input.agent.name} failed.`,
-        outputText: output || undefined,
-        logs: [result.stderr || result.stdout || "No output"],
-      },
-    });
-    return dispatchResult;
-  }
-
-  hooks?.emit?.({
-    type: "complete",
-    runKey,
-    patch: {
-      model: preflight.model,
-      fallbackModels,
-      thinking,
-      boardTaskStatus: input.boardTaskStatus,
-      checklist: input.checklist,
-      summary: output || `Subagent ${input.agent.name} run finished. Checklist-validated task completion is still a board action.`,
-      outputText: output || undefined,
-    },
-  });
-
-  return dispatchResult;
-}