takomi 2.0.7 → 2.1.0

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

@@ -0,0 +1,83 @@
+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();
+    },
+  };
+}

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

@@ -0,0 +1,174 @@
+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 { Theme } from "@mariozechner/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
+import type { TakomiDispatchResult } from "./dispatch";
+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;
+};
+
+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,
+  );
+}
+
+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);
+}
+

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

@@ -0,0 +1,209 @@
+import path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { TakomiThinkingLevel } from "../../../src/pi-takomi-core";
+import { loadTakomiProfile } from "../takomi-runtime/profile";
+import {
+  TAKOMI_SUBAGENT_EVENT_CHANNEL,
+  type TakomiSubagentRuntimeEvent,
+} from "../takomi-runtime/subagent-types";
+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 { createTakomiLiveUpdateBridge } from "./live-updates";
+
+type ChecklistItem = string | { text: string; done?: boolean };
+
+export type TakomiSubagentToolTask = {
+  agent: string;
+  task: string;
+  workflow?: string;
+  skills?: string[];
+  model?: string;
+  fallbackModels?: string[];
+  thinking?: TakomiThinkingLevel;
+  conversationId?: string;
+  cwd?: string;
+  checklist?: ChecklistItem[];
+};
+
+export type TakomiSubagentToolParams = Partial<TakomiSubagentToolTask> & {
+  tasks?: TakomiSubagentToolTask[];
+  chain?: TakomiSubagentToolTask[];
+  confirmLaunch?: boolean;
+  previewOnly?: boolean;
+  agentScope?: TakomiAgentScope;
+  confirmProjectAgents?: boolean;
+};
+
+type ToolUpdate = (partial: {
+  content: Array<{ type: "text"; text: string }>;
+  details: Record<string, unknown>;
+}) => void;
+const MAX_PARALLEL_TASKS = 8, MAX_CONCURRENCY = 4;
+
+function emitRuntimeSubagentEvent(pi: ExtensionAPI, event: TakomiSubagentRuntimeEvent): void {
+  pi.events.emit(TAKOMI_SUBAGENT_EVENT_CHANNEL, event);
+}
+
+function resultText(result: TakomiDispatchResult): string {
+  return [
+    result.preflight,
+    result.output || result.stderr || `Subagent ${result.agent} finished without output.`,
+  ].filter(Boolean).join("\n\n");
+}
+
+function textResult<TDetails extends Record<string, unknown>>(text: string, details: TDetails, isError?: boolean) {
+  return { content: [{ type: "text" as const, text }], details, isError };
+}
+
+async function mapWithConcurrencyLimit<TIn, TOut>(
+  items: TIn[],
+  concurrency: number,
+  fn: (item: TIn, index: number) => Promise<TOut>,
+): Promise<TOut[]> {
+  const results = new Array<TOut>(items.length);
+  let nextIndex = 0;
+  const workers = new Array(Math.min(Math.max(concurrency, 1), items.length)).fill(undefined).map(async () => {
+    while (nextIndex < items.length) {
+      const current = nextIndex++;
+      results[current] = await fn(items[current], current);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+function hasProjectAgents(tasks: Array<{ agent: string }>, agents: Map<string, TakomiAgentConfig>): boolean {
+  return tasks.some((task) => agents.get(task.agent)?.source === "project");
+}
+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 [];
+}
+export async function executeTakomiSubagentTool(
+  pi: ExtensionAPI,
+  params: TakomiSubagentToolParams,
+  signal: AbortSignal | undefined,
+  onUpdate: ToolUpdate | undefined,
+  ctx: ExtensionContext,
+) {
+  const rootCwd = params.cwd ? path.resolve(ctx.cwd, params.cwd) : ctx.cwd;
+  const profile = await loadTakomiProfile(rootCwd);
+  const agentScope = params.agentScope ?? "both";
+  const agents = discoverTakomiAgents(rootCwd, agentScope);
+  const byName = new Map<string, TakomiAgentConfig>(agents.map((agent) => [agent.name, agent]));
+  const mode = resolveMode(params);
+  const tasks = resolveTasks(params).map((task) => ({
+    ...task,
+    agent: resolveAgentName(task.agent, byName),
+  }));
+
+  if (!mode) {
+    return textResult(
+      `Provide exactly one mode: agent/task, tasks, or chain.\nAvailable agents: ${agents.map((agent) => `${agent.name} (${agent.source})`).join(", ") || "none"}`,
+      { results: [], availableAgents: agents.map((agent) => agent.name), agentScope },
+      true,
+    );
+  }
+  if (mode === "parallel" && tasks.length > MAX_PARALLEL_TASKS) {
+    return textResult(`Too many parallel tasks (${tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`, { results: [], agentScope }, true);
+  }
+  if (params.confirmProjectAgents !== false && ctx.hasUI && hasProjectAgents(tasks, byName)) {
+    const names = tasks.map((task) => byName.get(task.agent)).filter((agent): agent is TakomiAgentConfig => agent?.source === "project").map((agent) => agent.name);
+    const ok = await ctx.ui.confirm("Run project-local Takomi agents?", `Agents: ${[...new Set(names)].join(", ")}\n\nProject agents are repo-controlled. Continue only for trusted repositories.`);
+    if (!ok) return textResult("Canceled: project-local agents not approved.", { results: [], agentScope, mode });
+  }
+  const plan = createTakomiDelegationPlan({
+    source: "takomi-tool",
+    launchMode: profile.launchMode ?? "auto",
+    profile,
+    tasks: tasks.map((task, index) => ({
+      id: task.conversationId ?? `direct-${index + 1}`,
+      title: task.task,
+      agent: task.agent,
+      task: task.task,
+      workflow: task.workflow,
+      model: task.model,
+      fallbackModels: task.fallbackModels,
+      thinking: task.thinking,
+      conversationId: task.conversationId,
+      checklist: task.checklist,
+      dispatchPolicy: "subagent",
+    })),
+  });
+  if (params.previewOnly || (plan.launchMode === "manual" && !params.confirmLaunch)) {
+    return textResult(renderTakomiDelegationPlan(plan), { plan, availableAgents: agents.map((agent) => agent.name), agentScope, mode });
+  }
+  const live = createTakomiLiveUpdateBridge(tasks, mode, agentScope, onUpdate);
+  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,
+      task: item.task.replaceAll("{previous}", previousOutput),
+      rootCwd,
+      cwd: item.cwd,
+      workflow: item.workflow,
+      skills: item.skills,
+      model: item.model,
+      fallbackModels: item.fallbackModels,
+      thinking: item.thinking,
+      conversationId: item.conversationId,
+      checklist: item.checklist,
+      source: "takomi-tool",
+    }, signal, {
+      emit: (event) => {
+        emitRuntimeSubagentEvent(pi, event);
+        live.event(index, event);
+      },
+    });
+    live.finish(index, result);
+    return result;
+  };
+  const results: TakomiDispatchResult[] = [];
+  try {
+    if (mode === "chain") {
+      let previousOutput = "";
+      for (const [index, item] of tasks.entries()) {
+        const result = await runOne(item, index, previousOutput);
+        previousOutput = result.output;
+        results.push(result);
+        if (result.code !== 0) return textResult(resultText(result), { results, mode, agentScope }, true);
+      }
+    } else if (mode === "parallel") {
+      results.push(...await mapWithConcurrencyLimit(tasks, MAX_CONCURRENCY, async (item, index) => {
+        return runOne(item, index);
+      }));
+    } else {
+      results.push(await runOne(tasks[0], 0));
+    }
+  } catch (error) {
+    return textResult(error instanceof Error ? error.message : String(error), { results, mode, agentScope }, true);
+  }
+
+  const failed = results.find((result) => result.code !== 0);
+  return textResult(results.map(resultText).join("\n\n---\n\n"), { results, mode, agentScope }, Boolean(failed) || undefined);
+}

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

@@ -0,0 +1,199 @@
+---
+description: Run the full Takomi Vibe Build workflow for the next request
+---
+# Workflow: Build VibeCode Project V3 (The Builder)
+
+> Pi prompt alias for the richer build workflow.
+
+> **Version 3** — verification after every file, FR-based progress, type-safe development, and explicit handoff.
+
+**You are the VibeCode Builder Agent.**
+You execute the approved plan.
+You do **not** drift into loose strategy here — you build, verify, and report.
+Follow the blueprints precisely. Keep scope tight. Verify constantly.
+
+---
+
+## Provider / Model Selection
+Before using `takomi_subagent`, setting a model override, or naming a provider/model:
+- use the injected Pi model-registry context and active Takomi routing policy
+- prefer provider-qualified model IDs from the registry context
+- only choose from available options
+- do **not** hardcode a model/provider from memory
+- if the intended provider is unavailable, say so immediately and continue without that subagent unless the user approves another route
+- run `pi --list-models` only when registry context is missing or the user asks for visible diagnostics
+
+---
+
+## Steps
+
+### 1. Context Loading (MANDATORY)
+Before writing any code, read and internalize:
+- `docs/Project_Requirements.md`
+- `docs/Coding_Guidelines.md`
+- `docs/issues/`
+- `docs/mockups/` if they exist
+
+Acknowledge aloud that you will:
+- run `tsc --noEmit` after every TypeScript file edit when relevant
+- reference the issue file for each FR implemented
+- mark acceptance criteria as you complete them
+
+If any of the required docs are missing, call that out clearly before proceeding.
+
+### 2. Project Scaffolding / Setup
+If setup work is needed:
+- prefer `pnpm`
+- use PowerShell-safe commands when giving command examples
+- scaffold in a temporary directory when appropriate
+- merge carefully into the repo root
+- do **not** clobber existing work silently
+
+Example scaffold flow:
+
+```powershell
+mkdir temp-scaffold
+pnpm create next-app temp-scaffold --ts --tailwind --eslint --app --src-dir --import-alias "@/*" --use-pnpm --no-git --skip-install
+Get-ChildItem -Path temp-scaffold -Force | Copy-Item -Destination . -Recurse -Force
+Remove-Item -Path temp-scaffold -Recurse -Force
+pnpm install
+```
+
+### 3. Styling / Foundation Setup
+Establish or align global styling and structure with:
+- the approved design system
+- repository conventions
+- mockups if present
+
+If a global style layer exists, refine it instead of replacing it casually.
+
+### 4. MUS Implementation Loop
+For each FR marked `MUS`:
+
+#### 4.1 Announce the FR
+Use a visible progress statement such as:
+
+```text
+📋 Implementing FR-XXX: [Title]
+```
+
+#### 4.2 Read the Issue
+Open `docs/issues/FR-XXX.md` and review:
+- user story
+- proposed solution
+- implementation flow
+- technical approach
+- acceptance criteria
+
+#### 4.3 Implement
+Build according to:
+- `docs/Coding_Guidelines.md`
+- `docs/mockups/` if present
+- the issue guidance
+- existing project patterns
+
+#### 4.4 Verify (MANDATORY)
+After **every** TypeScript / TSX edit:
+
+```bash
+npx tsc --noEmit
+```
+
+If type-check fails:
+1. stop
+2. fix the error before touching the next TS file
+3. rerun until it passes
+
+#### 4.5 Mark Progress
+Update the corresponding issue file as acceptance criteria are completed.
+
+Example:
+
+```markdown
+## Acceptance Criteria
+- [x] Outcome 1 ✅ Completed
+- [x] Outcome 2 ✅ Completed
+- [ ] Outcome 3
+```
+
+### 5. Progress Checkpoints
+After every 3 FRs, or after a meaningful chunk of work, report:
+- completed FRs
+- blocked FRs
+- current verification status
+- next FRs
+
+Suggested format:
+
+```text
+📊 Progress Checkpoint
+
+✅ Completed:
+- FR-001: [Title]
+- FR-002: [Title]
+- FR-003: [Title]
+
+📈 Type-check: PASS
+🎯 Next: FR-004, FR-005, FR-006
+```
+
+### 6. Final Verification Gate
+Before claiming build completion, run the strongest practical verification available:
+- TypeScript
+- lint
+- build
+- project verification scripts if present
+
+Typical sequence:
+
+```bash
+npx tsc --noEmit
+pnpm lint
+pnpm build
+python scripts/vibe-verify.py 2>/dev/null
+```
+
+Fix failures before declaring success.
+
+### 7. Generate Handoff Report
+Create or update `docs/Builder_Handoff_Report.md` with:
+- what was built
+- FRs completed
+- files created/modified
+- verification results
+- how to run the project
+- future work / remaining FRs
+
+Include a concise verification table when useful.
+
+### 8. Final Message
+End with a clear build handoff that states:
+- implemented features
+- verification results
+- where the handoff report lives
+- the recommended next command or next stage (`continueBuild` or `finalize`)
+
+---
+
+## Recovery Protocol
+If something breaks badly:
+- inspect `git status`
+- inspect `git diff`
+- revert surgically when needed
+- stash if necessary
+- do not plow ahead through broken state
+
+---
+
+## Output Rules
+- treat build as a disciplined implementation workflow
+- do not one-shot freestyle large implementation without structure
+- keep progress visible
+- keep scope controlled
+- keep verification explicit
+- stay aligned with approved requirements and mockups
+
+---
+
+## Current User Request
+$@