takomi 2.1.2 → 2.1.4

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

@@ -1,75 +1,76 @@
-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 { createTakomiPiSubagentsEngine } from "./pi-subagents-engine";
+
+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 {
+  const engine = createTakomiPiSubagentsEngine(pi);
+  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 engine.execute(toolCallId, params, signal, onUpdate as any, ctx);
+    },
+    renderCall: renderTakomiSubagentCall,
+    renderResult: renderTakomiSubagentResult,
+  });
+}
+
+export default function takomiSubagents(pi: ExtensionAPI) {
+  registerSubagentTool(pi);
+}

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

@@ -1,83 +1,136 @@
-import type { TakomiThinkingLevel } from "../../../src/pi-takomi-core";
-import type { TakomiSubagentRuntimeEvent } from "../takomi-runtime/subagent-types";
-import type { TakomiDispatchResult } from "./dispatch";
-
-type ToolUpdate = (partial: {
-  content: Array<{ type: "text"; text: string }>;
-  details: Record<string, unknown>;
-}) => void;
-
-type LiveTask = {
-  agent: string;
-  task: string;
-  workflow?: string;
-  model?: string;
-  thinking?: TakomiThinkingLevel;
-  conversationId?: string;
-};
-
-function appendLine(value: string, line: string): string {
-  const next = [value, line.trim()].filter(Boolean).join("\n");
-  return next.split(/\r?\n/).slice(-12).join("\n");
-}
-
-export function createTakomiLiveUpdateBridge(
-  tasks: LiveTask[],
-  mode: "single" | "parallel" | "chain",
-  agentScope: string,
-  onUpdate: ToolUpdate | undefined,
-) {
-  const results: TakomiDispatchResult[] = tasks.map((task, index) => ({
-    agent: task.agent,
-    task: task.task,
-    workflow: task.workflow,
-    model: task.model,
-    thinking: task.thinking,
-    conversationId: task.conversationId ?? `pending-${index + 1}`,
-    code: -1,
-    output: "Queued.",
-    stderr: "",
-    preflight: "",
-  }));
-
-  const emit = () => {
-    const done = results.filter((result) => result.code === 0).length;
-    const running = results.filter((result) => result.code === -1).length;
-    onUpdate?.({
-      content: [{ type: "text", text: `Takomi ${mode}: ${done}/${results.length} done, ${running} running` }],
-      details: { results: [...results], mode, agentScope },
-    });
-  };
-
-  return {
-    results,
-    event(index: number, event: TakomiSubagentRuntimeEvent): void {
-      const current = results[index];
-      if (!current) return;
-      if (event.type === "start") {
-        current.conversationId = event.state.conversationId ?? current.conversationId;
-        current.thinking = event.state.thinking ?? current.thinking;
-        current.output = event.state.summary ?? "Starting.";
-      } else if (event.type === "update") {
-        current.model = event.patch.model ?? current.model;
-        current.thinking = event.patch.thinking ?? current.thinking;
-        current.output = event.patch.outputText ?? event.patch.summary ?? current.output;
-        if (event.patch.logs?.length) current.output = appendLine(current.output, event.patch.logs.join("\n"));
-      } else if (event.type === "appendLog") {
-        current.output = appendLine(current.output, event.chunk);
-      } else if (event.type === "complete") {
-        current.code = 0;
-        current.output = event.patch?.outputText ?? event.patch?.summary ?? current.output;
-      } else if (event.type === "block") {
-        current.code = 1;
-        current.output = event.patch?.outputText ?? event.patch?.summary ?? current.output;
-        if (event.patch?.logs?.length) current.stderr = event.patch.logs.join("\n");
-      }
-      emit();
-    },
-    finish(index: number, result: TakomiDispatchResult): void {
-      results[index] = result;
-      emit();
-    },
-  };
-}
+import type { TakomiThinkingLevel } from "../../../src/pi-takomi-core";
+import type { TakomiSubagentRuntimeEvent } from "../takomi-runtime/subagent-types";
+import type { TakomiDispatchResult } from "./dispatch";
+
+type ToolUpdate = (partial: {
+  content: Array<{ type: "text"; text: string }>;
+  details: Record<string, unknown>;
+}) => void;
+
+type LiveTask = {
+  agent: string;
+  task: string;
+  workflow?: string;
+  model?: string;
+  thinking?: TakomiThinkingLevel;
+  conversationId?: string;
+};
+
+function mergeRecentTools(
+  existing: Array<{ tool: string; args: string; endMs: number }> | undefined,
+  incoming: Array<{ tool: string; args: string; endMs: number }> | undefined,
+): Array<{ tool: string; args: string; endMs: number }> | undefined {
+  if (!incoming?.length) return existing;
+  return incoming.slice(-8);
+}
+
+function appendLine(value: string, line: string): string {
+  const next = [value, line.trim()].filter(Boolean).join("\n");
+  return next.split(/\r?\n/).slice(-12).join("\n");
+}
+
+function compactOutputPreview(text: string): string[] {
+  const lines = text
+    .split(/\r?\n/)
+    .map((line) => line.replace(/\s+/g, " ").trim())
+    .filter(Boolean)
+    .filter((line) => !/^\*\*[^*]+\*\*\s+I\s/i.test(line))
+    .filter((line) => !/\bI need to make sure\b/i.test(line))
+    .filter((line) => !/\bI want the user to\b/i.test(line));
+  return lines.slice(-3);
+}
+
+export function createTakomiLiveUpdateBridge(
+  tasks: LiveTask[],
+  mode: "single" | "parallel" | "chain",
+  agentScope: string,
+  onUpdate: ToolUpdate | undefined,
+) {
+  const results: TakomiDispatchResult[] = tasks.map((task, index) => ({
+    agent: task.agent,
+    task: task.task,
+    workflow: task.workflow,
+    model: task.model,
+    thinking: task.thinking,
+    conversationId: task.conversationId ?? `pending-${index + 1}`,
+    code: -1,
+    output: "Queued.",
+    stderr: "",
+    preflight: "",
+    startedAt: Date.now(),
+    lastActivityAt: Date.now(),
+    recentTools: [],
+    recentOutput: ["Queued."],
+    toolCount: 0,
+  }));
+
+  const emit = () => {
+    const done = results.filter((result) => result.code === 0).length;
+    const running = results.filter((result) => result.code === -1).length;
+    onUpdate?.({
+      content: [{ type: "text", text: `Takomi ${mode}: ${done}/${results.length} done, ${running} running` }],
+      details: { results: [...results], mode, agentScope },
+    });
+  };
+
+  return {
+    results,
+    event(index: number, event: TakomiSubagentRuntimeEvent): void {
+      const current = results[index];
+      if (!current) return;
+      current.lastActivityAt = Date.now();
+      if (event.type === "start") {
+        current.startedAt = current.startedAt ?? Date.now();
+        current.conversationId = event.state.conversationId ?? current.conversationId;
+        current.thinking = event.state.thinking ?? current.thinking;
+        current.sessionFile = event.state.sessionFile ?? current.sessionFile;
+        current.output = event.state.summary ?? "Starting.";
+        current.recentOutput = [current.output].filter(Boolean).slice(-8);
+      } else if (event.type === "update") {
+        current.model = event.patch.model ?? current.model;
+        current.thinking = event.patch.thinking ?? current.thinking;
+        current.sessionFile = event.patch.sessionFile ?? current.sessionFile;
+        current.currentTool = event.patch.currentTool;
+        current.currentToolArgs = event.patch.currentToolArgs;
+        current.currentToolStartedAt = event.patch.currentToolStartedAt;
+        current.recentTools = mergeRecentTools(current.recentTools, event.patch.recentTools);
+        current.toolCount = event.patch.toolCount ?? current.toolCount;
+        current.output = event.patch.outputText ?? event.patch.summary ?? current.output;
+        current.recentOutput = event.patch.recentOutput
+          ?? (event.patch.outputText ? compactOutputPreview(event.patch.outputText) : current.recentOutput);
+        if (event.patch.logs?.length) current.output = appendLine(current.output, event.patch.logs.join("\n"));
+      } else if (event.type === "appendLog") {
+        current.output = appendLine(current.output, event.chunk);
+        current.recentOutput = [...(current.recentOutput ?? []), event.chunk.trim()].filter(Boolean).slice(-8);
+      } else if (event.type === "complete") {
+        current.code = 0;
+        current.endedAt = Date.now();
+        current.currentTool = undefined;
+        current.currentToolArgs = undefined;
+        current.currentToolStartedAt = undefined;
+        current.output = event.patch?.outputText ?? event.patch?.summary ?? current.output;
+        current.recentOutput = event.patch?.recentOutput ?? current.recentOutput;
+        current.recentTools = mergeRecentTools(current.recentTools, event.patch?.recentTools);
+        current.toolCount = event.patch?.toolCount ?? current.toolCount;
+        current.sessionFile = event.patch?.sessionFile ?? current.sessionFile;
+      } else if (event.type === "block") {
+        current.code = 1;
+        current.endedAt = Date.now();
+        current.currentTool = undefined;
+        current.currentToolArgs = undefined;
+        current.currentToolStartedAt = undefined;
+        current.output = event.patch?.outputText ?? event.patch?.summary ?? current.output;
+        current.recentOutput = event.patch?.recentOutput ?? current.recentOutput;
+        current.recentTools = mergeRecentTools(current.recentTools, event.patch?.recentTools);
+        current.toolCount = event.patch?.toolCount ?? current.toolCount;
+        current.sessionFile = event.patch?.sessionFile ?? current.sessionFile;
+        if (event.patch?.logs?.length) current.stderr = event.patch.logs.join("\n");
+      }
+      emit();
+    },
+    finish(index: number, result: TakomiDispatchResult): void {
+      results[index] = result;
+      emit();
+    },
+  };
+}

package/.pi/extensions/takomi-subagents/native-render.ts

@@ -1,21 +1,11 @@
 import { renderSubagentResult, syncResultAnimation } from "pi-subagents/src/tui/render";
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
-import type { Details, SingleResult, AgentProgress } from "pi-subagents/src/shared/types";
+import type { Details } from "pi-subagents/src/shared/types";
 import type { Theme } from "@mariozechner/pi-coding-agent";
-import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
-import type { TakomiDispatchResult } from "./dispatch";
+import { Text } from "@mariozechner/pi-tui";
 import type { TakomiSubagentToolParams } from "./tool-runner";
 
-type ToolResult = {
-  content?: Array<{ type: string; text?: string }>;
-  details?: {
-    results?: TakomiDispatchResult[];
-    mode?: "single" | "parallel" | "chain";
-    agentScope?: string;
-    plan?: unknown;
-  };
-  isError?: boolean;
-};
+type ToolResult = AgentToolResult<Details>;
 
 function taskList(params: TakomiSubagentToolParams): Array<{ agent: string; task: string }> {
   if (params.chain?.length) return params.chain;
@@ -41,134 +31,7 @@ export function renderTakomiSubagentCall(params: TakomiSubagentToolParams, theme
   );
 }
 
-function parseTakomiOutput(outputText: string) {
-  const rawLines = outputText.split(/\r?\n/);
-  const textLines: string[] = [];
-  const recentTools: Array<{ tool: string; args: string; endMs: number }> = [];
-  let currentTool: string | undefined;
-  let currentToolArgs: string | undefined;
-
-  for (const line of rawLines) {
-    if (!line.trim()) continue;
-
-    // 1. Check for tool lifecycle markers
-    if (line.startsWith("Tool start: ")) {
-      currentTool = line.replace("Tool start: ", "").trim();
-      continue;
-    }
-    if (line.startsWith("Tool complete: ") || line.startsWith("Tool failed: ")) {
-      const toolName = line.replace(/Tool (complete|failed): /, "").trim();
-      recentTools.push({ tool: toolName, args: "", endMs: Date.now() });
-      if (currentTool === toolName) {
-        currentTool = undefined;
-        currentToolArgs = undefined;
-      }
-      continue;
-    }
-
-    // 2. Handle JSON blobs (tool calls)
-    const jsonStartIdx = line.indexOf('{"');
-    if (jsonStartIdx !== -1) {
-      const beforeJson = line.substring(0, jsonStartIdx).trim();
-      if (beforeJson) textLines.push(beforeJson);
-
-      const jsonPart = line.substring(jsonStartIdx);
-      try {
-        const parsed = JSON.parse(jsonPart);
-        const toolName = parsed.tool || (parsed.command ? parsed.command.split(" ")[0] : undefined);
-        if (toolName) {
-          const args = parsed.args ? JSON.stringify(parsed.args) : (parsed.command || "");
-          currentTool = toolName;
-          currentToolArgs = args;
-        }
-      } catch (e) {
-        if (jsonPart.trim().length > 1) {
-          textLines.push(jsonPart);
-        }
-      }
-      continue;
-    }
-
-    // 3. Skip lone brackets
-    const trimmed = line.trim();
-    if (trimmed === "{" || trimmed === "}") continue;
-
-    // 4. Everything else is text (thoughts)
-    textLines.push(line);
-  }
-
-  return { textLines, recentTools, currentTool, currentToolArgs };
-}
-
 export function renderTakomiSubagentResult(result: ToolResult, options: { expanded?: boolean; isPartial?: boolean }, theme: Theme, context: any) {
-  const details = result.details;
-  const results = details?.results ?? [];
-
-  if (results.length === 0) {
-    const text = result.content?.find((item) => item.type === "text")?.text ?? "(no output)";
-    return new Text(text, 0, 0);
-  }
-
-  const mappedResults: SingleResult[] = results.map((r, i) => {
-    const isRunning = r.code === -1;
-    const outputText = r.output || r.stderr || "";
-    const { textLines, recentTools, currentTool, currentToolArgs } = parseTakomiOutput(outputText);
-    
-    const recentOutput = textLines.slice(-5);
-
-    const progress: AgentProgress | undefined = isRunning ? {
-      index: i,
-      agent: r.agent,
-      status: "running",
-      task: r.task || "",
-      lastActivityAt: Date.now(),
-      currentTool,
-      currentToolArgs,
-      currentToolStartedAt: currentTool ? Date.now() : undefined,
-      recentTools,
-      recentOutput,
-      toolCount: recentTools.length + (currentTool ? 1 : 0),
-      tokens: 0,
-      durationMs: 0,
-    } : {
-      index: i,
-      agent: r.agent,
-      status: "completed", // Takomi results in mappedResults are usually final if code !== -1
-      task: r.task || "",
-      lastActivityAt: Date.now(),
-      recentTools,
-      recentOutput: [],
-      toolCount: recentTools.length,
-      tokens: 0,
-      durationMs: 0,
-    };
-
-    return {
-      agent: r.agent,
-      task: r.task || "",
-      exitCode: isRunning ? 0 : r.code,
-      model: r.model,
-      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-      progress,
-      truncation: isRunning ? undefined : {
-        text: textLines.join("\n").replace(/\n/g, "  \n"),
-        truncated: false
-      }
-    };
-  });
-
-  const mappedDetails: Details = {
-    mode: details?.mode ?? "single",
-    results: mappedResults,
-    chainAgents: details?.mode === "chain" ? results.map(r => r.agent) : undefined,
-  };
-
-  const agentToolResult: AgentToolResult<Details> = {
-    content: result.content as any || [],
-    details: mappedDetails,
-  };
-
-  syncResultAnimation(agentToolResult, context);
-  return renderSubagentResult(agentToolResult, { expanded: options.expanded ?? false }, theme);
+  syncResultAnimation(result, context);
+  return renderSubagentResult(result, { expanded: options.expanded ?? false }, theme);
 }
-