takomi 2.1.2 → 2.1.3

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

@@ -1,215 +1,215 @@
-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;
-};
-
-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 });
-
-  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,
-    };
-    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) => {
-      hooks?.emit?.({ type: "update", runKey, patch: { outputText: text, boardTaskStatus: input.boardTaskStatus, checklist: input.checklist } });
-    },
-    onEventText: (line) => {
-      hooks?.emit?.({ type: "appendLog", runKey, chunk: line });
-    },
-    onStderr: (chunk) => {
-      hooks?.emit?.({ type: "appendLog", runKey, chunk });
-    },
-  });
-
-  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,
-  };
-
-  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;
-}
+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;
+};
+
+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 });
+
+  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,
+    };
+    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) => {
+      hooks?.emit?.({ type: "update", runKey, patch: { outputText: text, boardTaskStatus: input.boardTaskStatus, checklist: input.checklist } });
+    },
+    onEventText: (line) => {
+      hooks?.emit?.({ type: "appendLog", runKey, chunk: line });
+    },
+    onStderr: (chunk) => {
+      hooks?.emit?.({ type: "appendLog", runKey, chunk });
+    },
+  });
+
+  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,
+  };
+
+  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;
+}

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

@@ -1,75 +1,75 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "typebox";
-import { renderTakomiSubagentCall, renderTakomiSubagentResult } from "./native-render";
-import { executeTakomiSubagentTool } from "./tool-runner";
-
-const ChecklistItemSchema = Type.Object({
-  text: Type.String(),
-  done: Type.Optional(Type.Boolean()),
-});
-
-const ThinkingSchema = Type.Union([
-  Type.Literal("off"),
-  Type.Literal("minimal"),
-  Type.Literal("low"),
-  Type.Literal("medium"),
-  Type.Literal("high"),
-  Type.Literal("xhigh"),
-]);
-
-const TaskSchema = Type.Object({
-  agent: Type.String(),
-  task: Type.String(),
-  workflow: Type.Optional(Type.String()),
-  skills: Type.Optional(Type.Array(Type.String())),
-  model: Type.Optional(Type.String()),
-  fallbackModels: Type.Optional(Type.Array(Type.String())),
-  thinking: Type.Optional(ThinkingSchema),
-  conversationId: Type.Optional(Type.String()),
-  cwd: Type.Optional(Type.String()),
-  checklist: Type.Optional(Type.Array(Type.Union([Type.String(), ChecklistItemSchema]))),
-});
-
-const SubagentParameters = Type.Object({
-  agent: Type.Optional(Type.String({ description: "Agent name for single execution" })),
-  task: Type.Optional(Type.String({ description: "Task for single execution" })),
-  workflow: Type.Optional(Type.String({ description: "Workflow or playbook overlay for this task" })),
-  skills: Type.Optional(Type.Array(Type.String(), { description: "Extra skills to apply during the task" })),
-  model: Type.Optional(Type.String({ description: "Optional per-run model override" })),
-  fallbackModels: Type.Optional(Type.Array(Type.String(), { description: "Optional ordered model fallback list" })),
-  thinking: Type.Optional(ThinkingSchema),
-  conversationId: Type.Optional(Type.String({ description: "Persistent conversation id to resume the same subagent session" })),
-  cwd: Type.Optional(Type.String({ description: "Working directory override" })),
-  checklist: Type.Optional(Type.Array(Type.Union([Type.String(), ChecklistItemSchema]), { description: "Optional checklist for the subagent" })),
-  tasks: Type.Optional(Type.Array(TaskSchema, { description: "Parallel subagent tasks" })),
-  confirmLaunch: Type.Optional(Type.Boolean({ description: "Required to launch immediately in manual Takomi launch mode" })),
-  previewOnly: Type.Optional(Type.Boolean({ description: "Return the delegation plan without launching" })),
-  chain: Type.Optional(Type.Array(TaskSchema, { description: "Sequential chain of subagent tasks" })),
-  agentScope: Type.Optional(Type.Union([Type.Literal("user"), Type.Literal("project"), Type.Literal("both")])),
-  confirmProjectAgents: Type.Optional(Type.Boolean({ description: "Prompt before running project-local agents. Default: true." })),
-});
-
-function registerSubagentTool(pi: ExtensionAPI): void {
-  pi.registerTool({
-    name: "takomi_subagent",
-    label: "Takomi",
-    description: "Run subagents with Pi-style single, parallel, or chain modes plus Takomi lifecycle metadata.",
-    promptSnippet: "Delegate lifecycle-aware Takomi work to specialist subagents. Use single, tasks, or chain; reuse conversationId for review loops.",
-    promptGuidelines: [
-      "Use this tool during orchestration when a specialist should handle a task.",
-      "Use tasks for independent parallel work and chain for dependent handoffs with {previous}.",
-      "Use model, fallbackModels, and thinking only when deliberate; otherwise let the agent/profile defaults apply.",
-      "If review sends work back to the same agent, reuse the same conversationId for continuity.",
-    ],
-    parameters: SubagentParameters,
-    async execute(_toolCallId, params, signal, onUpdate, ctx) {
-      return executeTakomiSubagentTool(pi, params, signal, onUpdate, ctx);
-    },
-    renderCall: renderTakomiSubagentCall,
-    renderResult: renderTakomiSubagentResult,
-  });
-}
-
-export default function takomiSubagents(pi: ExtensionAPI) {
-  registerSubagentTool(pi);
-}
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "typebox";
+import { renderTakomiSubagentCall, renderTakomiSubagentResult } from "./native-render";
+import { executeTakomiSubagentTool } from "./tool-runner";
+
+const ChecklistItemSchema = Type.Object({
+  text: Type.String(),
+  done: Type.Optional(Type.Boolean()),
+});
+
+const ThinkingSchema = Type.Union([
+  Type.Literal("off"),
+  Type.Literal("minimal"),
+  Type.Literal("low"),
+  Type.Literal("medium"),
+  Type.Literal("high"),
+  Type.Literal("xhigh"),
+]);
+
+const TaskSchema = Type.Object({
+  agent: Type.String(),
+  task: Type.String(),
+  workflow: Type.Optional(Type.String()),
+  skills: Type.Optional(Type.Array(Type.String())),
+  model: Type.Optional(Type.String()),
+  fallbackModels: Type.Optional(Type.Array(Type.String())),
+  thinking: Type.Optional(ThinkingSchema),
+  conversationId: Type.Optional(Type.String()),
+  cwd: Type.Optional(Type.String()),
+  checklist: Type.Optional(Type.Array(Type.Union([Type.String(), ChecklistItemSchema]))),
+});
+
+const SubagentParameters = Type.Object({
+  agent: Type.Optional(Type.String({ description: "Agent name for single execution" })),
+  task: Type.Optional(Type.String({ description: "Task for single execution" })),
+  workflow: Type.Optional(Type.String({ description: "Workflow or playbook overlay for this task" })),
+  skills: Type.Optional(Type.Array(Type.String(), { description: "Extra skills to apply during the task" })),
+  model: Type.Optional(Type.String({ description: "Optional per-run model override" })),
+  fallbackModels: Type.Optional(Type.Array(Type.String(), { description: "Optional ordered model fallback list" })),
+  thinking: Type.Optional(ThinkingSchema),
+  conversationId: Type.Optional(Type.String({ description: "Persistent conversation id to resume the same subagent session" })),
+  cwd: Type.Optional(Type.String({ description: "Working directory override" })),
+  checklist: Type.Optional(Type.Array(Type.Union([Type.String(), ChecklistItemSchema]), { description: "Optional checklist for the subagent" })),
+  tasks: Type.Optional(Type.Array(TaskSchema, { description: "Parallel subagent tasks" })),
+  confirmLaunch: Type.Optional(Type.Boolean({ description: "Required to launch immediately in manual Takomi launch mode" })),
+  previewOnly: Type.Optional(Type.Boolean({ description: "Return the delegation plan without launching" })),
+  chain: Type.Optional(Type.Array(TaskSchema, { description: "Sequential chain of subagent tasks" })),
+  agentScope: Type.Optional(Type.Union([Type.Literal("user"), Type.Literal("project"), Type.Literal("both")])),
+  confirmProjectAgents: Type.Optional(Type.Boolean({ description: "Prompt before running project-local agents. Default: true." })),
+});
+
+function registerSubagentTool(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "takomi_subagent",
+    label: "Takomi",
+    description: "Run subagents with Pi-style single, parallel, or chain modes plus Takomi lifecycle metadata.",
+    promptSnippet: "Delegate lifecycle-aware Takomi work to specialist subagents. Use single, tasks, or chain; reuse conversationId for review loops.",
+    promptGuidelines: [
+      "Use this tool during orchestration when a specialist should handle a task.",
+      "Use tasks for independent parallel work and chain for dependent handoffs with {previous}.",
+      "Use model, fallbackModels, and thinking only when deliberate; otherwise let the agent/profile defaults apply.",
+      "If review sends work back to the same agent, reuse the same conversationId for continuity.",
+    ],
+    parameters: SubagentParameters,
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      return executeTakomiSubagentTool(pi, params, signal, onUpdate, ctx);
+    },
+    renderCall: renderTakomiSubagentCall,
+    renderResult: renderTakomiSubagentResult,
+  });
+}
+
+export default function takomiSubagents(pi: ExtensionAPI) {
+  registerSubagentTool(pi);
+}