takomi 2.1.4 → 2.1.5

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

@@ -1,6 +1,5 @@
 import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
-import type { AssistantMessage } from "@mariozechner/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { StringEnum } from "@mariozechner/pi-ai";
 import { Type } from "typebox";
@@ -47,9 +46,6 @@ import {
   type TakomiSubagentRuntimeEvent,
 } from "./subagent-types";
 import {
-  visibleWidth,
-  truncateToWidth,
-  formatFooterNumber,
   buildTaskPrompt,
   resolvePreferredModel,
 } from "./shared";
@@ -438,46 +434,8 @@ async function applyProfileDefaultsToTasks(ctx: ExtensionContext, tasks: Orchest
   return nextTasks;
 }
 
-// stripAnsi, visibleWidth, truncateToWidth, formatFooterNumber
-// are imported from "./shared"
-
 function installTakomiFooter(ctx: ExtensionContext, stateRef: { current: TakomiState }): void {
   ctx.ui.setFooter((tui, theme, footerData) => new TakomiFooterComponent(tui, theme, footerData, ctx, () => stateRef.current));
-  return;
-  ctx.ui.setFooter((_tui, theme, footerData) => ({
-    invalidate() {},
-    render(width: number): string[] {
-      const state = stateRef.current;
-      let input = 0;
-      let output = 0;
-      let cost = 0;
-      for (const entry of ctx.sessionManager.getBranch()) {
-        if (entry.type === "message" && entry.message.role === "assistant") {
-          const message = entry.message as AssistantMessage;
-          input += message.usage.input;
-          output += message.usage.output;
-          cost += message.usage.cost.total;
-        }
-      }
-
-      const cwd = theme.fg("dim", ctx.cwd);
-      const stats = theme.fg("dim", `↑${formatFooterNumber(input)} ↓${formatFooterNumber(output)} $${cost.toFixed(3)}`);
-      const leftPad = " ".repeat(Math.max(1, width - visibleWidth(cwd) - visibleWidth(stats)));
-      const topLine = truncateToWidth(cwd + leftPad + stats, width);
-
-      const extensionStatuses = [...footerData.getExtensionStatuses().entries()]
-        .filter(([key]) => key !== "takomi-runtime")
-        .map(([, value]) => value)
-        .filter(Boolean);
-      const runtimeStatus = renderRuntimeStatus(theme, state);
-      const left = [runtimeStatus, ...extensionStatuses].join(theme.fg("dim", "  ·  "));
-      const right = theme.fg("dim", ctx.model?.id || "no-model");
-      const rightPad = " ".repeat(Math.max(1, width - visibleWidth(left) - visibleWidth(right)));
-      const bottomLine = truncateToWidth(left + rightPad + right, width);
-
-      return [topLine, bottomLine];
-    },
-  }));
 }
 
 // Mutable state ref so the footer closure always reads the latest state

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

@@ -200,6 +200,7 @@ export type JsonRunHooks = {
     args?: string;
     isError?: boolean;
     summary?: string;
+    invocationId?: string;
   }) => void;
   onStderr?: (chunk: string) => void;
 };
@@ -274,6 +275,14 @@ function extractAssistantSnapshot(event: Record<string, unknown>, currentText: s
   return undefined;
 }
 
+function extractToolInvocationId(event: Record<string, unknown>, toolName: string): string {
+  for (const key of ["invocationId", "toolCallId", "toolUseId", "callId", "id"]) {
+    const value = event[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return toolName;
+}
+
 export function summarizeJsonEvent(event: Record<string, unknown>): string | undefined {
   const type = typeof event.type === "string" ? event.type : "";
   if (type === "tool_execution_start") {
@@ -356,13 +365,13 @@ export async function runPiAgentJson(cwd: string, args: string[], signal?: Abort
         if (event.type === "tool_execution_start") {
           const toolName = typeof event.toolName === "string" ? event.toolName : "tool";
           const args = typeof event.args === "string" ? event.args : event.args ? JSON.stringify(event.args) : undefined;
-          hooks?.onToolEvent?.({ type: "start", toolName, args, summary: messageText });
+          hooks?.onToolEvent?.({ type: "start", toolName, args, summary: messageText, invocationId: extractToolInvocationId(event, toolName) });
         } else if (event.type === "tool_execution_update") {
           const toolName = typeof event.toolName === "string" ? event.toolName : "tool";
-          hooks?.onToolEvent?.({ type: "update", toolName, summary: messageText });
+          hooks?.onToolEvent?.({ type: "update", toolName, summary: messageText, invocationId: extractToolInvocationId(event, toolName) });
         } else if (event.type === "tool_execution_end") {
           const toolName = typeof event.toolName === "string" ? event.toolName : "tool";
-          hooks?.onToolEvent?.({ type: "end", toolName, isError: event.isError === true, summary: messageText });
+          hooks?.onToolEvent?.({ type: "end", toolName, isError: event.isError === true, summary: messageText, invocationId: extractToolInvocationId(event, toolName) });
         }
 
         if (event.type === "message_end") {

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

@@ -89,12 +89,21 @@ export async function dispatchTakomiSubagent(
   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 = [...recentOutput, ...lines].slice(-8);
+    recentOutput.push(...lines);
+    if (recentOutput.length > 8) recentOutput.splice(0, recentOutput.length - 8);
     lastActivityAt = Date.now();
   };
 
@@ -210,18 +219,21 @@ export async function dispatchTakomiSubagent(
     },
     onToolEvent: (event) => {
       lastActivityAt = Date.now();
+      const invocationId = event.invocationId ?? event.toolName;
       if (event.type === "start") {
-        currentTool = event.toolName;
-        currentToolArgs = event.args;
-        currentToolStartedAt = Date.now();
+        activeToolInvocations.set(invocationId, {
+          tool: event.toolName,
+          args: event.args ?? "",
+          startedAt: Date.now(),
+        });
         toolCount += 1;
+        setCurrentToolFromActive();
       } else if (event.type === "end") {
-        recentTools = [...recentTools, { tool: event.toolName, args: currentTool === event.toolName ? currentToolArgs ?? "" : "", endMs: Date.now() }].slice(-8);
-        if (currentTool === event.toolName) {
-          currentTool = undefined;
-          currentToolArgs = undefined;
-          currentToolStartedAt = undefined;
-        }
+        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",

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

@@ -57,7 +57,6 @@ export function createTakomiLiveUpdateBridge(
     output: "Queued.",
     stderr: "",
     preflight: "",
-    startedAt: Date.now(),
     lastActivityAt: Date.now(),
     recentTools: [],
     recentOutput: ["Queued."],
@@ -80,7 +79,7 @@ export function createTakomiLiveUpdateBridge(
       if (!current) return;
       current.lastActivityAt = Date.now();
       if (event.type === "start") {
-        current.startedAt = current.startedAt ?? Date.now();
+        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;

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

@@ -1,37 +1,36 @@
-import { renderSubagentResult, syncResultAnimation } from "pi-subagents/src/tui/render";
-import type { AgentToolResult } from "@mariozechner/pi-agent-core";
-import type { Details } from "pi-subagents/src/shared/types";
-import type { Theme } from "@mariozechner/pi-coding-agent";
-import { Text } from "@mariozechner/pi-tui";
-import type { TakomiSubagentToolParams } from "./tool-runner";
-
-type ToolResult = AgentToolResult<Details>;
-
-function taskList(params: TakomiSubagentToolParams): Array<{ agent: string; task: string }> {
-  if (params.chain?.length) return params.chain;
-  if (params.tasks?.length) return params.tasks;
-  if (params.agent || params.task) return [{ agent: params.agent ?? "...", task: params.task ?? "..." }];
-  return [];
-}
-
-export function renderTakomiSubagentCall(params: TakomiSubagentToolParams, theme: Theme) {
-  const tasks = taskList(params);
-  const mode = params.chain?.length ? "chain" : params.tasks?.length ? "parallel" : "single";
-  if (tasks.length === 1) {
-    return new Text(
-      `${theme.fg("toolTitle", theme.bold("takomi_subagent "))}${theme.fg("accent", tasks[0]?.agent || "?")}`,
-      0,
-      0,
-    );
-  }
-  return new Text(
-    `${theme.fg("toolTitle", theme.bold("takomi_subagent "))}${mode} (${tasks.length})`,
-    0,
-    0,
-  );
-}
-
-export function renderTakomiSubagentResult(result: ToolResult, options: { expanded?: boolean; isPartial?: boolean }, theme: Theme, context: any) {
-  syncResultAnimation(result, context);
-  return renderSubagentResult(result, { expanded: options.expanded ?? false }, theme);
-}
+import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import { renderSubagentResult, syncResultAnimation, type Details } from "./pi-subagents-internal";
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import type { TakomiSubagentToolParams } from "./tool-runner";
+
+type ToolResult = AgentToolResult<Details>;
+
+function taskList(params: TakomiSubagentToolParams): Array<{ agent: string; task: string }> {
+  if (params.chain?.length) return params.chain;
+  if (params.tasks?.length) return params.tasks;
+  if (params.agent || params.task) return [{ agent: params.agent ?? "...", task: params.task ?? "..." }];
+  return [];
+}
+
+export function renderTakomiSubagentCall(params: TakomiSubagentToolParams, theme: Theme) {
+  const tasks = taskList(params);
+  const mode = params.chain?.length ? "chain" : params.tasks?.length ? "parallel" : "single";
+  if (tasks.length === 1) {
+    return new Text(
+      `${theme.fg("toolTitle", theme.bold("takomi_subagent "))}${theme.fg("accent", tasks[0]?.agent || "?")}`,
+      0,
+      0,
+    );
+  }
+  return new Text(
+    `${theme.fg("toolTitle", theme.bold("takomi_subagent "))}${mode} (${tasks.length})`,
+    0,
+    0,
+  );
+}
+
+export function renderTakomiSubagentResult(result: ToolResult, options: { expanded?: boolean; isPartial?: boolean }, theme: Theme, context: any) {
+  syncResultAnimation(result, context);
+  return renderSubagentResult(result, { expanded: options.expanded ?? false }, theme);
+}

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

@@ -1,228 +1,239 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import type { AgentToolResult } from "@mariozechner/pi-agent-core";
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { createSubagentExecutor, type SubagentParamsLike } from "pi-subagents/src/runs/foreground/subagent-executor";
-import { discoverAgents as discoverPiAgents, type AgentConfig, type AgentScope } from "pi-subagents/src/agents/agents";
-import {
-  DEFAULT_ARTIFACT_CONFIG,
-  TEMP_ARTIFACTS_DIR,
-  type Details,
-  type ExtensionConfig,
-  type SubagentState,
-} from "pi-subagents/src/shared/types";
-import { resolveAgentName } from "./agent-aliases";
-import type { TakomiSubagentToolParams, TakomiSubagentToolTask } from "./tool-runner";
-
-type ToolUpdate = (partial: AgentToolResult<Details>) => void;
-
-function getSubagentSessionRoot(parentSessionFile: string | null): string {
-  if (parentSessionFile) {
-    const baseName = path.basename(parentSessionFile, ".jsonl");
-    return path.join(path.dirname(parentSessionFile), baseName);
-  }
-  return fs.mkdtempSync(path.join(os.tmpdir(), "takomi-subagent-session-"));
-}
-
-function expandTilde(value: string): string {
-  return value.startsWith("~/") ? path.join(os.homedir(), value.slice(2)) : value;
-}
-
-function createState(): SubagentState {
-  return {
-    baseCwd: process.cwd(),
-    currentSessionId: null,
-    asyncJobs: new Map(),
-    foregroundRuns: new Map(),
-    foregroundControls: new Map(),
-    lastForegroundControlId: null,
-    pendingForegroundControlNotices: new Map(),
-    cleanupTimers: new Map(),
-    lastUiContext: null,
-    poller: null,
-    completionSeen: new Map(),
-    watcher: null,
-    watcherRestartTimer: null,
-    resultFileCoalescer: {
-      schedule: () => false,
-      clear: () => {},
-    },
-  };
-}
-
-function resolveMode(params: TakomiSubagentToolParams): "single" | "parallel" | "chain" | undefined {
-  const hasChain = Boolean(params.chain?.length);
-  const hasParallel = Boolean(params.tasks?.length);
-  const hasSingle = Boolean(params.agent && params.task);
-  if (Number(hasChain) + Number(hasParallel) + Number(hasSingle) !== 1) return undefined;
-  return hasChain ? "chain" : hasParallel ? "parallel" : "single";
-}
-
-function resolveTasks(params: TakomiSubagentToolParams): TakomiSubagentToolTask[] {
-  if (params.chain?.length) return params.chain;
-  if (params.tasks?.length) return params.tasks;
-  if (params.agent && params.task) {
-    return [{
-      agent: params.agent,
-      task: params.task,
-      workflow: params.workflow,
-      skills: params.skills,
-      model: params.model,
-      fallbackModels: params.fallbackModels,
-      thinking: params.thinking,
-      conversationId: params.conversationId,
-      cwd: params.cwd,
-      checklist: params.checklist,
-    }];
-  }
-  return [];
-}
-
-function normalizeThinking(value: unknown): string | undefined {
-  return typeof value === "string" && ["off", "minimal", "low", "medium", "high", "xhigh"].includes(value) ? value : undefined;
-}
-
-function buildTakomiTaskPrompt(task: TakomiSubagentToolTask): string {
-  const checklist = task.checklist?.length
-    ? [
-        "Checklist:",
-        ...task.checklist.map((item) => typeof item === "string" ? `- [ ] ${item}` : `- [${item.done ? "x" : " "}] ${item.text}`),
-      ].join("\n")
-    : "";
-  const takomiContext = [
-    task.workflow ? `Takomi workflow: ${task.workflow}` : "",
-    task.skills?.length ? `Takomi skills/context overlays: ${task.skills.join(", ")}` : "",
-    checklist,
-  ].filter(Boolean).join("\n\n");
-
-  return takomiContext ? `${takomiContext}\n\n${task.task}` : task.task;
-}
-
-function modelWithThinking(model: string | undefined, thinking: string | undefined): string | undefined {
-  const level = normalizeThinking(thinking);
-  if (!model || !level || level === "off") return model;
-  if (/:(off|minimal|low|medium|high|xhigh)$/i.test(model)) return model;
-  return `${model}:${level}`;
-}
-
-function defaultChildExtensions(): string[] {
-  // Child runs must not auto-load every user/project extension because this repo
-  // currently has both global and project Takomi extensions, which causes tool
-  // name conflicts in children. But model providers such as oauth-router are
-  // extensions too, so we explicitly allow the provider extension through.
-  const candidates = [
-    path.join(os.homedir(), ".pi", "agent", "extensions", "oauth-router", "index.ts"),
-  ];
-  return candidates.filter((candidate) => fs.existsSync(candidate));
-}
-
-function withTakomiAgentDefaults(agent: AgentConfig): AgentConfig {
-  return {
-    ...agent,
-    systemPromptMode: agent.systemPromptMode ?? "replace",
-    inheritProjectContext: agent.inheritProjectContext ?? true,
-    inheritSkills: agent.inheritSkills ?? false,
-    defaultContext: agent.defaultContext ?? "fresh",
-    extensions: [...new Set([...(agent.extensions ?? []), ...defaultChildExtensions()])],
-  };
-}
-
-function discoverUnifiedAgents(cwd: string, scope: AgentScope): { agents: AgentConfig[] } {
-  return { agents: discoverPiAgents(cwd, scope).agents.map(withTakomiAgentDefaults) };
-}
-
-function agentNameSet(cwd: string): Set<string> {
-  return new Set(discoverUnifiedAgents(cwd, "both").agents.map((agent) => agent.name));
-}
-
-function mapSingleTask(task: TakomiSubagentToolTask, names: Set<string>) {
-  const resolvedAgent = resolveAgentName(task.agent, new Map([...names].map((name) => [name, { name } as any])));
-  return {
-    agent: resolvedAgent,
-    task: buildTakomiTaskPrompt({ ...task, agent: resolvedAgent }),
-    cwd: task.cwd,
-    model: modelWithThinking(task.model, task.thinking),
-  };
-}
-
-function toSubagentParams(params: TakomiSubagentToolParams, rootCwd: string): SubagentParamsLike {
-  const mode = resolveMode(params);
-  const tasks = resolveTasks(params);
-  const names = agentNameSet(rootCwd);
-  if (!mode) throw new Error("Provide exactly one mode: agent/task, tasks, or chain.");
-
-  const base = {
-    agentScope: params.agentScope ?? "both",
-    cwd: rootCwd,
-    context: "fresh" as const,
-    async: false,
-    clarify: false,
-    includeProgress: true,
-  };
-
-  if (mode === "single") {
-    const task = tasks[0]!;
-    const mapped = mapSingleTask(task, names);
-    return {
-      ...base,
-      agent: mapped.agent,
-      task: mapped.task,
-      cwd: task.cwd ? path.resolve(rootCwd, task.cwd) : rootCwd,
-      model: mapped.model,
-    };
-  }
-
-  if (mode === "parallel") {
-    return {
-      ...base,
-      tasks: tasks.map((task) => mapSingleTask(task, names)),
-    };
-  }
-
-  return {
-    ...base,
-    chain: tasks.map((task) => {
-      const mapped = mapSingleTask(task, names);
-      return {
-        agent: mapped.agent,
-        task: mapped.task,
-        cwd: task.cwd,
-        model: mapped.model,
-      };
-    }),
-  };
-}
-
-export function createTakomiPiSubagentsEngine(pi: ExtensionAPI) {
-  const state = createState();
-  const config: ExtensionConfig = {
-    maxSubagentDepth: 2,
-    asyncByDefault: false,
-    forceTopLevelAsync: false,
-  };
-  const executor = createSubagentExecutor({
-    pi,
-    state,
-    config,
-    asyncByDefault: false,
-    tempArtifactsDir: TEMP_ARTIFACTS_DIR,
-    getSubagentSessionRoot,
-    expandTilde,
-    discoverAgents: discoverUnifiedAgents,
-  });
-
-  return {
-    async execute(
-      id: string,
-      params: TakomiSubagentToolParams,
-      signal: AbortSignal | undefined,
-      onUpdate: ToolUpdate | undefined,
-      ctx: ExtensionContext,
-    ): Promise<AgentToolResult<Details>> {
-      const rootCwd = params.cwd ? path.resolve(ctx.cwd, params.cwd) : ctx.cwd;
-      const subagentParams = toSubagentParams(params, rootCwd);
-      return executor.execute(id, subagentParams, signal ?? new AbortController().signal, onUpdate, ctx);
-    },
-  };
-}
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  createSubagentExecutor,
+  discoverPiAgents,
+  TEMP_ARTIFACTS_DIR,
+  type AgentConfig,
+  type AgentScope,
+  type Details,
+  type ExtensionConfig,
+  type SubagentParamsLike,
+  type SubagentState,
+} from "./pi-subagents-internal";
+import { resolveAgentName } from "./agent-aliases";
+import type { TakomiSubagentToolParams, TakomiSubagentToolTask } from "./tool-runner";
+
+type ToolUpdate = (partial: AgentToolResult<Details>) => void;
+
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+const NEVER_ABORT: AbortSignal = new AbortController().signal;
+
+function getSubagentSessionRoot(parentSessionFile: string | null): string {
+  if (parentSessionFile) {
+    const baseName = path.basename(parentSessionFile, ".jsonl");
+    return path.join(path.dirname(parentSessionFile), baseName);
+  }
+  return fs.mkdtempSync(path.join(os.tmpdir(), "takomi-subagent-session-"));
+}
+
+function expandTilde(value: string): string {
+  return value.startsWith("~/") ? path.join(os.homedir(), value.slice(2)) : value;
+}
+
+function createState(): SubagentState {
+  return {
+    baseCwd: process.cwd(),
+    currentSessionId: null,
+    asyncJobs: new Map(),
+    foregroundRuns: new Map(),
+    foregroundControls: new Map(),
+    lastForegroundControlId: null,
+    pendingForegroundControlNotices: new Map(),
+    cleanupTimers: new Map(),
+    lastUiContext: null,
+    poller: null,
+    completionSeen: new Map(),
+    watcher: null,
+    watcherRestartTimer: null,
+    resultFileCoalescer: {
+      schedule: () => false,
+      clear: () => {},
+    },
+  };
+}
+
+function resolveMode(params: TakomiSubagentToolParams): "single" | "parallel" | "chain" | undefined {
+  const hasChain = Boolean(params.chain?.length);
+  const hasParallel = Boolean(params.tasks?.length);
+  const hasSingle = Boolean(params.agent && params.task);
+  if (Number(hasChain) + Number(hasParallel) + Number(hasSingle) !== 1) return undefined;
+  return hasChain ? "chain" : hasParallel ? "parallel" : "single";
+}
+
+function resolveTasks(params: TakomiSubagentToolParams): TakomiSubagentToolTask[] {
+  if (params.chain?.length) return params.chain;
+  if (params.tasks?.length) return params.tasks;
+  if (params.agent && params.task) {
+    return [{
+      agent: params.agent,
+      task: params.task,
+      workflow: params.workflow,
+      skills: params.skills,
+      model: params.model,
+      fallbackModels: params.fallbackModels,
+      thinking: params.thinking,
+      conversationId: params.conversationId,
+      cwd: params.cwd,
+      checklist: params.checklist,
+    }];
+  }
+  return [];
+}
+
+function normalizeThinking(value: unknown): string | undefined {
+  return typeof value === "string" && (THINKING_LEVELS as readonly string[]).includes(value) ? value : undefined;
+}
+
+function buildTakomiTaskPrompt(task: TakomiSubagentToolTask): string {
+  const checklist = task.checklist?.length
+    ? [
+        "Checklist:",
+        ...task.checklist.map((item) => typeof item === "string" ? `- [ ] ${item}` : `- [${item.done ? "x" : " "}] ${item.text}`),
+      ].join("\n")
+    : "";
+  const takomiContext = [
+    task.workflow ? `Takomi workflow: ${task.workflow}` : "",
+    task.skills?.length ? `Takomi skills/context overlays: ${task.skills.join(", ")}` : "",
+    checklist,
+  ].filter(Boolean).join("\n\n");
+
+  return takomiContext ? `${takomiContext}\n\n${task.task}` : task.task;
+}
+
+function modelWithThinking(model: string | undefined, thinking: string | undefined): string | undefined {
+  const level = normalizeThinking(thinking);
+  if (!model || !level || level === "off") return model;
+  if (new RegExp(`:(${THINKING_LEVELS.join("|")})$`, "i").test(model)) return model;
+  return `${model}:${level}`;
+}
+
+function defaultChildExtensions(): string[] {
+  // Child runs must not auto-load every user/project extension because this repo
+  // currently has both global and project Takomi extensions, which causes tool
+  // name conflicts in children. But model providers such as oauth-router are
+  // extensions too, so we explicitly allow the provider extension through.
+  const roots = [
+    process.env.PI_AGENT_ROOT,
+    path.join(os.homedir(), ".pi", "agent"),
+    path.join(process.cwd(), ".pi"),
+  ].filter((root): root is string => Boolean(root));
+  const candidates = roots.flatMap((root) => [
+    path.join(root, "extensions", "oauth-router", "index.ts"),
+    path.join(root, "extensions", "oauth-router", "index.js"),
+  ]);
+  return candidates.filter((candidate) => fs.existsSync(candidate));
+}
+
+function withTakomiAgentDefaults(agent: AgentConfig): AgentConfig {
+  return {
+    ...agent,
+    systemPromptMode: agent.systemPromptMode ?? "replace",
+    inheritProjectContext: agent.inheritProjectContext ?? true,
+    inheritSkills: agent.inheritSkills ?? false,
+    defaultContext: agent.defaultContext ?? "fresh",
+    extensions: [...new Set([...(agent.extensions ?? []), ...defaultChildExtensions()])],
+  };
+}
+
+function discoverUnifiedAgents(cwd: string, scope: AgentScope): { agents: AgentConfig[] } {
+  return { agents: discoverPiAgents(cwd, scope).agents.map(withTakomiAgentDefaults) };
+}
+
+function agentNameSet(cwd: string): Set<string> {
+  return new Set(discoverUnifiedAgents(cwd, "both").agents.map((agent) => agent.name));
+}
+
+function mapSingleTask(task: TakomiSubagentToolTask, names: Set<string>) {
+  const resolvedAgent = resolveAgentName(task.agent, new Map([...names].map((name) => [name, { name } as any])));
+  return {
+    agent: resolvedAgent,
+    task: buildTakomiTaskPrompt({ ...task, agent: resolvedAgent }),
+    cwd: task.cwd,
+    model: modelWithThinking(task.model, task.thinking),
+  };
+}
+
+function toSubagentParams(params: TakomiSubagentToolParams, rootCwd: string): SubagentParamsLike {
+  const mode = resolveMode(params);
+  const tasks = resolveTasks(params);
+  const names = agentNameSet(rootCwd);
+  if (!mode) throw new Error("Provide exactly one mode: agent/task, tasks, or chain.");
+
+  const base = {
+    agentScope: params.agentScope ?? "both",
+    cwd: rootCwd,
+    context: "fresh" as const,
+    async: false,
+    clarify: false,
+    includeProgress: true,
+  };
+
+  if (mode === "single") {
+    const task = tasks[0]!;
+    const mapped = mapSingleTask(task, names);
+    return {
+      ...base,
+      agent: mapped.agent,
+      task: mapped.task,
+      cwd: task.cwd ? path.resolve(rootCwd, task.cwd) : rootCwd,
+      model: mapped.model,
+    };
+  }
+
+  if (mode === "parallel") {
+    return {
+      ...base,
+      tasks: tasks.map((task) => mapSingleTask(task, names)),
+    };
+  }
+
+  return {
+    ...base,
+    chain: tasks.map((task) => {
+      const mapped = mapSingleTask(task, names);
+      return {
+        agent: mapped.agent,
+        task: mapped.task,
+        cwd: task.cwd,
+        model: mapped.model,
+      };
+    }),
+  };
+}
+
+export function createTakomiPiSubagentsEngine(pi: ExtensionAPI) {
+  const state = createState();
+  const config: ExtensionConfig = {
+    maxSubagentDepth: 2,
+    asyncByDefault: false,
+    forceTopLevelAsync: false,
+  };
+  const executor = createSubagentExecutor({
+    pi,
+    state,
+    config,
+    asyncByDefault: false,
+    tempArtifactsDir: TEMP_ARTIFACTS_DIR,
+    getSubagentSessionRoot,
+    expandTilde,
+    discoverAgents: discoverUnifiedAgents,
+  });
+
+  return {
+    async execute(
+      id: string,
+      params: TakomiSubagentToolParams,
+      signal: AbortSignal | undefined,
+      onUpdate: ToolUpdate | undefined,
+      ctx: ExtensionContext,
+    ): Promise<AgentToolResult<Details>> {
+      const rootCwd = params.cwd ? path.resolve(ctx.cwd, params.cwd) : ctx.cwd;
+      const subagentParams = toSubagentParams(params, rootCwd);
+      return executor.execute(id, subagentParams, signal ?? NEVER_ABORT, onUpdate, ctx);
+    },
+  };
+}

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

@@ -0,0 +1,18 @@
+// Centralizes Takomi's current pi-subagents internal imports.
+// pi-subagents does not yet expose all of these helpers through a stable public API,
+// so package.json pins the dependency exactly and this adapter localizes future
+// upstream path changes to one file.
+export { createSubagentExecutor } from "pi-subagents/src/runs/foreground/subagent-executor";
+export type { SubagentParamsLike } from "pi-subagents/src/runs/foreground/subagent-executor";
+export { discoverAgents as discoverPiAgents } from "pi-subagents/src/agents/agents";
+export type { AgentConfig, AgentScope } from "pi-subagents/src/agents/agents";
+export {
+  DEFAULT_ARTIFACT_CONFIG,
+  TEMP_ARTIFACTS_DIR,
+} from "pi-subagents/src/shared/types";
+export type {
+  Details,
+  ExtensionConfig,
+  SubagentState,
+} from "pi-subagents/src/shared/types";
+export { renderSubagentResult, syncResultAnimation } from "pi-subagents/src/tui/render";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "takomi",
-  "version": "2.1.4",
+  "version": "2.1.5",
   "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": {
@@ -41,7 +41,7 @@
     "commander": "^13.1.0",
     "figlet": "^1.8.0",
     "fs-extra": "^11.3.0",
-    "pi-subagents": "^0.24.0",
+    "pi-subagents": "0.24.0",
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2"
   },

package/src/update-check.js

@@ -1,140 +1,144 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import https from 'https';
-import { spawnSync } from 'child_process';
-import pc from 'picocolors';
-
-const CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
-const CACHE_PATH = path.join(os.homedir(), '.takomi', 'update-check.json');
-const REGISTRY_URL = 'https://registry.npmjs.org/takomi/latest';
-
-function parseVersion(version = '') {
-  const [core] = String(version).replace(/^v/, '').split('-');
-  return core.split('.').map((part) => Number.parseInt(part, 10) || 0);
-}
-
-export function isNewerVersion(latest, current) {
-  const a = parseVersion(latest);
-  const b = parseVersion(current);
-  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
-    const left = a[i] || 0;
-    const right = b[i] || 0;
-    if (left > right) return true;
-    if (left < right) return false;
-  }
-  return false;
-}
-
-function fetchLatestPackageInfo(timeoutMs = 2500) {
-  return new Promise((resolve) => {
-    const req = https.get(REGISTRY_URL, {
-      headers: {
-        'accept': 'application/json',
-        'user-agent': 'takomi-update-check',
-      },
-      timeout: timeoutMs,
-    }, (res) => {
-      let body = '';
-      res.setEncoding('utf8');
-      res.on('data', (chunk) => { body += chunk; });
-      res.on('end', () => {
-        if (res.statusCode && res.statusCode >= 400) return resolve(null);
-        try {
-          resolve(JSON.parse(body));
-        } catch {
-          resolve(null);
-        }
-      });
-    });
-    req.on('timeout', () => {
-      req.destroy();
-      resolve(null);
-    });
-    req.on('error', () => resolve(null));
-  });
-}
-
-async function readCache() {
-  try {
-    return await fs.readJson(CACHE_PATH);
-  } catch {
-    return null;
-  }
-}
-
-async function writeCache(cache) {
-  try {
-    await fs.ensureDir(path.dirname(CACHE_PATH));
-    await fs.writeJson(CACHE_PATH, cache, { spaces: 2 });
-  } catch {
-    // Update checks must never block normal Takomi startup.
-  }
-}
-
-export async function getLatestTakomiVersion({ currentVersion, force = false } = {}) {
-  const now = Date.now();
-  const cache = await readCache();
-  if (!force && cache?.checkedAt && now - cache.checkedAt < CHECK_INTERVAL_MS) {
-    return cache;
-  }
-
-  const info = await fetchLatestPackageInfo();
-  const latestVersion = typeof info?.version === 'string' ? info.version : null;
-  const next = {
-    checkedAt: now,
-    currentVersion,
-    latestVersion,
-    updateAvailable: Boolean(latestVersion && currentVersion && isNewerVersion(latestVersion, currentVersion)),
-  };
-  await writeCache(next);
-  return next;
-}
-
-export function notifyIfTakomiUpdateAvailable(currentVersion) {
-  if (process.env.TAKOMI_NO_UPDATE_CHECK === '1') return;
-
-  // Fire-and-forget by design: launching the Takomi harness must never wait on
-  // network, DNS, npm registry latency, or cache file IO.
-  setTimeout(() => {
-    getLatestTakomiVersion({ currentVersion })
-      .then((result) => {
-        if (!result?.updateAvailable) return;
-        console.log(pc.yellow(`\n⬆ Takomi ${result.latestVersion} is available (installed: ${currentVersion}).`));
-        console.log(pc.dim('  Run: takomi upgrade'));
-        console.log(pc.dim('  Disable this check with TAKOMI_NO_UPDATE_CHECK=1.\n'));
-      })
-      .catch(() => {
-        // Silent: update checks must never affect harness startup or usage.
-      });
-  }, 0).unref?.();
-}
-
-export async function printTakomiUpdateStatus(currentVersion) {
-  const result = await getLatestTakomiVersion({ currentVersion, force: true });
-  if (!result?.latestVersion) {
-    console.log(pc.yellow('Could not check the npm registry for Takomi updates.'));
-    return;
-  }
-  if (result.updateAvailable) {
-    console.log(pc.yellow(`Takomi ${result.latestVersion} is available (installed: ${currentVersion}).`));
-    console.log(pc.dim('Run: takomi upgrade'));
-    return;
-  }
-  console.log(pc.green(`Takomi is up to date (${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',
-  });
-  if (result.status === 0) {
-    console.log(pc.green('\nTakomi updated. Run `takomi --version` to confirm.'));
-    return 0;
-  }
-  console.log(pc.red('\nTakomi update failed. Try manually: npm install -g takomi@latest'));
-  return result.status || 1;
-}
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import https from 'https';
+import { spawnSync } from 'child_process';
+import pc from 'picocolors';
+
+const CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
+const CACHE_PATH = path.join(os.homedir(), '.takomi', 'update-check.json');
+const REGISTRY_URL = 'https://registry.npmjs.org/takomi/latest';
+
+function parseVersion(version = '') {
+  const [core] = String(version).replace(/^v/, '').split('-');
+  return core.split('.').map((part) => Number.parseInt(part, 10) || 0);
+}
+
+export function isNewerVersion(latest, current) {
+  const a = parseVersion(latest);
+  const b = parseVersion(current);
+  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+    const left = a[i] || 0;
+    const right = b[i] || 0;
+    if (left > right) return true;
+    if (left < right) return false;
+  }
+  return false;
+}
+
+function fetchLatestPackageInfo(timeoutMs = 2500) {
+  return new Promise((resolve) => {
+    const req = https.get(REGISTRY_URL, {
+      headers: {
+        'accept': 'application/json',
+        'user-agent': 'takomi-update-check',
+      },
+      timeout: timeoutMs,
+    }, (res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        if (res.statusCode && res.statusCode >= 400) return resolve(null);
+        try {
+          resolve(JSON.parse(body));
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+    req.on('error', () => resolve(null));
+  });
+}
+
+async function readCache() {
+  try {
+    return await fs.readJson(CACHE_PATH);
+  } catch {
+    return null;
+  }
+}
+
+async function writeCache(cache) {
+  try {
+    await fs.ensureDir(path.dirname(CACHE_PATH));
+    await fs.writeJson(CACHE_PATH, cache, { spaces: 2 });
+  } catch {
+    // Update checks must never block normal Takomi startup.
+  }
+}
+
+export async function getLatestTakomiVersion({ currentVersion, force = false } = {}) {
+  const now = Date.now();
+  const cache = await readCache();
+  if (!force && cache?.checkedAt && cache.latestVersion && now - cache.checkedAt < CHECK_INTERVAL_MS) {
+    return {
+      ...cache,
+      currentVersion,
+      updateAvailable: Boolean(currentVersion && isNewerVersion(cache.latestVersion, currentVersion)),
+    };
+  }
+
+  const info = await fetchLatestPackageInfo();
+  const latestVersion = typeof info?.version === 'string' ? info.version : null;
+  const next = {
+    checkedAt: now,
+    currentVersion,
+    latestVersion,
+    updateAvailable: Boolean(latestVersion && currentVersion && isNewerVersion(latestVersion, currentVersion)),
+  };
+  await writeCache(next);
+  return next;
+}
+
+export function notifyIfTakomiUpdateAvailable(currentVersion) {
+  if (process.env.TAKOMI_NO_UPDATE_CHECK === '1') return;
+
+  // Fire-and-forget by design: launching the Takomi harness must never wait on
+  // network, DNS, npm registry latency, or cache file IO.
+  setTimeout(() => {
+    getLatestTakomiVersion({ currentVersion })
+      .then((result) => {
+        if (!result?.updateAvailable) return;
+        console.log(pc.yellow(`\n⬆ Takomi ${result.latestVersion} is available (installed: ${currentVersion}).`));
+        console.log(pc.dim('  Run: takomi upgrade'));
+        console.log(pc.dim('  Disable this check with TAKOMI_NO_UPDATE_CHECK=1.\n'));
+      })
+      .catch(() => {
+        // Silent: update checks must never affect harness startup or usage.
+      });
+  }, 0).unref?.();
+}
+
+export async function printTakomiUpdateStatus(currentVersion) {
+  const result = await getLatestTakomiVersion({ currentVersion, force: true });
+  if (!result?.latestVersion) {
+    console.log(pc.yellow('Could not check the npm registry for Takomi updates.'));
+    return;
+  }
+  if (result.updateAvailable) {
+    console.log(pc.yellow(`Takomi ${result.latestVersion} is available (installed: ${currentVersion}).`));
+    console.log(pc.dim('Run: takomi upgrade'));
+    return;
+  }
+  console.log(pc.green(`Takomi is up to date (${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',
+  });
+  if (result.status === 0) {
+    console.log(pc.green('\nTakomi updated. Run `takomi --version` to confirm.'));
+    return 0;
+  }
+  console.log(pc.red('\nTakomi update failed. Try manually: npm install -g takomi@latest'));
+  return result.status || 1;
+}