takomi 2.1.44 → 2.5.1

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

@@ -3,13 +3,17 @@ import path from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { TakomiLaunchMode, TakomiThinkingLevel } from "../../../src/pi-takomi-core";
 import { loadTakomiProfile } from "../takomi-runtime/profile";
-import { applyTakomiRoutingDefaults, loadTakomiModelRoutingSnapshot } from "../takomi-runtime/model-routing-defaults";
+import { hasUserGateAutoProvenance } from "../takomi-runtime/gate-provenance";
+import { applyTakomiRoutingDefaults, isTakomiModelApproved, loadTakomiModelRoutingSnapshot } from "../takomi-runtime/model-routing-defaults";
 import { resolveAgentName } from "./agent-aliases";
 import { discoverTakomiAgents, type TakomiAgentConfig, type TakomiAgentScope } from "./agents";
 import { createTakomiDelegationPlan, renderTakomiDelegationPlan } from "./delegation-plan";
+import { rememberDetachedLaunch, resolveDetachedStatusResult } from "./detached-results";
 import { createTakomiPiSubagentsEngine } from "./pi-subagents-engine";
+import { createTakomiUxTasks, withTakomiUxDetails } from "./subagent-ux";
 
 type ChecklistItem = string | { text: string; done?: boolean };
+export type TakomiAcceptanceInput = false | "auto" | "none" | "attested" | "checked" | "verified" | "reviewed" | Record<string, unknown>;
 
 export type TakomiSubagentToolTask = {
   agent: string;
@@ -22,6 +26,8 @@ export type TakomiSubagentToolTask = {
   conversationId?: string;
   cwd?: string;
   checklist?: ChecklistItem[];
+  requiredCapabilities?: string[];
+  acceptance?: TakomiAcceptanceInput;
 };
 
 export type TakomiSubagentToolParams = Partial<TakomiSubagentToolTask> & {
@@ -50,10 +56,18 @@ const MAX_PARALLEL_TASKS = 8;
 const HARD_STOP_TTL_MS = 10 * 60 * 1000;
 const ENGINES = new WeakMap<ExtensionAPI, ReturnType<typeof createTakomiPiSubagentsEngine>>();
 
+type UserTurnMarker = {
+  sessionId?: string;
+  count: number;
+  lastEntryId?: string;
+  entryIds: string[];
+};
+
 type HardStopRecord = {
   at: number;
   reason: string;
   message: string;
+  userTurnMarker?: UserTurnMarker;
 };
 
 const RECENT_HARD_STOPS = new WeakMap<ExtensionAPI, Map<string, HardStopRecord>>();
@@ -66,6 +80,11 @@ function getEngine(pi: ExtensionAPI): ReturnType<typeof createTakomiPiSubagentsE
   return engine;
 }
 
+export function invalidateTakomiPiSubagentsEngine(pi: ExtensionAPI): void {
+  ENGINES.get(pi)?.dispose();
+  ENGINES.delete(pi);
+}
+
 function textResult<TDetails extends Record<string, unknown>>(text: string, details: TDetails, isError?: boolean) {
   return { content: [{ type: "text" as const, text }], details, isError };
 }
@@ -74,10 +93,27 @@ function hasProjectAgents(tasks: Array<{ agent: string }>, agents: Map<string, T
   return tasks.some((task) => agents.get(task.agent)?.source === "project");
 }
 
+function taskRequiresWrite(task: TakomiSubagentToolTask): boolean {
+  if (task.requiredCapabilities?.some((capability) => /^(write|edit|write-docs|write-code)$/i.test(capability))) return true;
+  return /\b(?:create|write|author|edit|modify|update|implement|fix)\b[\s\S]{0,100}\b(?:file|files|markdown|document|documents|artifact|artifacts|code|configuration)\b/i.test(task.task);
+}
+
+function capabilityMismatch(task: TakomiSubagentToolTask, agent: TakomiAgentConfig | undefined): string | undefined {
+  if (!agent) return undefined;
+  if (taskRequiresWrite(task) && !agent.tools?.some((tool) => tool === "write" || tool === "edit")) {
+    return `Task assigned to '${task.agent}' requires file writing, but that persona is inspection-only. Choose architect or designer for their authored Markdown, coder for code, or worker for other writable artifacts.`;
+  }
+  return undefined;
+}
+
 function hostTrustsProjectAgents(): boolean {
   return /^(1|true|yes)$/i.test(process.env.TAKOMI_TRUST_PROJECT_AGENTS || "");
 }
 
+function isProjectAgentApprovalHardStop(record: HardStopRecord | undefined): boolean {
+  return record?.reason === "project-agent-approval-required" || record?.reason === "project-agent-denied";
+}
+
 function hardStopStore(pi: ExtensionAPI): Map<string, HardStopRecord> {
   const existing = RECENT_HARD_STOPS.get(pi);
   if (existing) return existing;
@@ -86,22 +122,79 @@ function hardStopStore(pi: ExtensionAPI): Map<string, HardStopRecord> {
   return next;
 }
 
+type TakomiRunMode = "single" | "parallel" | "chain";
+
+function compactChecklistForFingerprint(checklist: ChecklistItem[] | undefined): Array<{ text: string; done: boolean }> | undefined {
+  if (!checklist?.length) return undefined;
+  return checklist.map((item) => typeof item === "string" ? { text: item, done: false } : { text: item.text, done: item.done ?? false });
+}
+
 function compactTaskForFingerprint(task: TakomiSubagentToolTask): Record<string, unknown> {
   return {
     agent: task.agent,
     task: task.task,
-    workflow: task.workflow,
-    skills: task.skills,
-    model: task.model,
-    fallbackModels: task.fallbackModels,
+    workflow: task.workflow || undefined,
+    skills: task.skills?.length ? task.skills : undefined,
+    model: task.model || undefined,
+    fallbackModels: task.fallbackModels?.length ? task.fallbackModels : undefined,
     thinking: task.thinking,
-    conversationId: task.conversationId,
+    conversationId: task.conversationId || undefined,
     cwd: task.cwd,
+    checklist: compactChecklistForFingerprint(task.checklist),
+    requiredCapabilities: task.requiredCapabilities?.length ? task.requiredCapabilities : undefined,
+    acceptance: task.acceptance,
   };
 }
 
-function createRunFingerprint(rootCwd: string, mode: "single" | "parallel" | "chain" | undefined, tasks: TakomiSubagentToolTask[]): string {
-  return JSON.stringify({ rootCwd, mode, tasks: tasks.map(compactTaskForFingerprint) });
+const IMPLICIT_CONTEXT = "implicit" as const;
+type CanonicalContext = typeof IMPLICIT_CONTEXT | "fresh" | "fork";
+
+function canonicalContextForFingerprint(context: TakomiSubagentToolParams["context"]): CanonicalContext {
+  // Omission delegates context selection to native pi-subagents, whose built-in
+  // and settings defaults are authoritative. Never approximate that resolution
+  // with Takomi-only discovery: implicit input is its own approval semantic.
+  return context ?? IMPLICIT_CONTEXT;
+}
+
+function canonicalContextsForFingerprint(
+  params: TakomiSubagentToolParams,
+  tasks: TakomiSubagentToolTask[],
+): CanonicalContext[] {
+  const context = canonicalContextForFingerprint(params.context);
+  // `context` is a global override. When omitted, each native task resolves its
+  // own default, but all retain the distinct implicit-input sentinel here.
+  return tasks.map(() => context);
+}
+
+function effectiveConcurrencyForFingerprint(mode: TakomiRunMode, concurrency: number | undefined): number | undefined {
+  if (mode !== "parallel") return undefined;
+  return typeof concurrency === "number" && Number.isInteger(concurrency) && concurrency >= 1 ? concurrency : 4;
+}
+
+function createRunFingerprint(
+  rootCwd: string,
+  mode: TakomiRunMode,
+  tasks: TakomiSubagentToolTask[],
+  params: TakomiSubagentToolParams,
+  agentScope: TakomiAgentScope,
+): string {
+  const context = canonicalContextForFingerprint(params.context);
+  return JSON.stringify({
+    rootCwd,
+    mode,
+    tasks: tasks.map(compactTaskForFingerprint),
+    launch: {
+      context: {
+        global: context,
+        perTask: canonicalContextsForFingerprint(params, tasks),
+      },
+      async: params.async === true,
+      concurrency: effectiveConcurrencyForFingerprint(mode, params.concurrency),
+      worktree: mode === "parallel" && params.worktree === true,
+      clarify: params.clarify === true,
+      agentScope,
+    },
+  });
 }
 
 function hardStopResult(message: string, details: Record<string, unknown>) {
@@ -112,8 +205,34 @@ function hardStopResult(message: string, details: Record<string, unknown>) {
   ].join("\n"), { ...details, takomiHardStop: true }, true);
 }
 
-function rememberHardStop(pi: ExtensionAPI, fingerprint: string, reason: string, message: string): void {
-  hardStopStore(pi).set(fingerprint, { at: Date.now(), reason, message });
+function rememberHardStop(
+  pi: ExtensionAPI,
+  fingerprint: string,
+  reason: string,
+  message: string,
+  userTurnMarker?: UserTurnMarker,
+): void {
+  hardStopStore(pi).set(fingerprint, { at: Date.now(), reason, message, userTurnMarker });
+}
+
+function readUserTurnMarker(ctx: ExtensionContext): UserTurnMarker {
+  const userEntries = ctx.sessionManager.getEntries().filter((entry) => entry.type === "message" && entry.message.role === "user");
+  const entryIds = userEntries.map((entry) => entry.id);
+  return {
+    sessionId: ctx.sessionManager.getSessionId(),
+    count: userEntries.length,
+    lastEntryId: entryIds.at(-1),
+    entryIds,
+  };
+}
+
+function hasStrictlyNewerUserTurn(record: HardStopRecord, current: UserTurnMarker): boolean {
+  const recorded = record.userTurnMarker;
+  if (!recorded || recorded.sessionId !== current.sessionId || current.count <= recorded.count) return false;
+  if (!recorded.lastEntryId) return true;
+
+  const recordedTurnIndex = current.entryIds.indexOf(recorded.lastEntryId);
+  return recordedTurnIndex >= 0 && recordedTurnIndex < current.entryIds.length - 1;
 }
 
 function consumeExpiredHardStop(pi: ExtensionAPI, fingerprint: string): HardStopRecord | undefined {
@@ -146,12 +265,6 @@ async function resolveRelativeCwd(root: string, value: string | undefined, label
   return realCandidate;
 }
 
-async function validateTaskCwds(root: string, tasks: TakomiSubagentToolTask[]): Promise<void> {
-  for (const [index, task] of tasks.entries()) {
-    await resolveRelativeCwd(root, task.cwd, `tasks[${index}].cwd`);
-  }
-}
-
 function getTextContent(result: any): string {
   return (result?.content ?? [])
     .map((item: any) => item?.type === "text" && typeof item.text === "string" ? item.text : "")
@@ -234,6 +347,8 @@ function resolveTasks(params: TakomiSubagentToolParams): TakomiSubagentToolTask[
       conversationId: params.conversationId,
       cwd: undefined,
       checklist: params.checklist,
+      requiredCapabilities: params.requiredCapabilities,
+      acceptance: params.acceptance,
     }];
   }
   return [];
@@ -255,6 +370,10 @@ export async function executeTakomiSubagentTool(
   }
   const profile = await loadTakomiProfile(rootCwd);
   const runtimeLaunchMode = readRuntimeLaunchMode(ctx);
+  const userTurnMarker = readUserTurnMarker(ctx);
+  // Auto launch mode may come from a model, profile, default, or restored
+  // runtime state. None of those are project-agent authorization.
+  const userGateAutoAuthorized = hasUserGateAutoProvenance(ctx.sessionManager.getEntries());
   const agentScope = params.agentScope ?? "both";
 
   if (params.action) {
@@ -266,10 +385,13 @@ export async function executeTakomiSubagentTool(
         onUpdate as any,
         ctx,
       );
+      const resolvedResult = params.action === "status"
+        ? await resolveDetachedStatusResult(pi, params, nativeResult)
+        : nativeResult;
       return {
-        ...nativeResult,
+        ...resolvedResult,
         details: {
-          ...(nativeResult?.details ?? {}),
+          ...(resolvedResult?.details ?? {}),
           takomi: {
             action: params.action,
             agentScope,
@@ -289,16 +411,39 @@ export async function executeTakomiSubagentTool(
   let tasks: TakomiSubagentToolTask[];
   try {
     const rawTasks = resolveTasks(params);
-    await validateTaskCwds(rootCwd, rawTasks);
-    tasks = rawTasks.map((task) => applyTakomiRoutingDefaults({
+    tasks = await Promise.all(rawTasks.map(async (task, index) => applyTakomiRoutingDefaults({
       ...task,
       agent: resolveAgentName(task.agent, byName),
-    }, routingSnapshot));
+      cwd: await resolveRelativeCwd(rootCwd, task.cwd, `tasks[${index}].cwd`),
+    }, routingSnapshot)));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return textResult(message, { results: [], availableAgents: agents.map((agent) => agent.name), agentScope }, true);
   }
 
+  for (const task of tasks) {
+    if (!byName.has(task.agent)) {
+      return textResult(
+        `Unknown or hidden Takomi persona '${task.agent}'. Available personas: ${agents.map((agent) => agent.name).join(", ") || "none"}.`,
+        { results: [], agentScope, task, reason: "unknown-persona" },
+        true,
+      );
+    }
+    const mismatch = capabilityMismatch(task, byName.get(task.agent));
+    if (mismatch) return textResult(`Blocked by Takomi capability validation.\n\n${mismatch}`, { results: [], agentScope, task, reason: "capability-mismatch" }, true);
+    if (task.model && routingSnapshot.approvedModels.length && !isTakomiModelApproved(task.model, routingSnapshot.approvedModels)) {
+      return textResult(
+        `Blocked by Takomi routing policy. Exact model '${task.model}' is not approved. No provider-equivalent substitution was attempted.`,
+        { results: [], agentScope, task, reason: "model-not-approved", approvedModels: routingSnapshot.approvedModels },
+        true,
+      );
+    }
+    const invalidFallback = task.fallbackModels?.find((model) => routingSnapshot.approvedModels.length && !isTakomiModelApproved(model, routingSnapshot.approvedModels));
+    if (invalidFallback) {
+      return textResult(`Blocked by Takomi routing policy. Explicit fallback '${invalidFallback}' is not approved.`, { results: [], agentScope, task, reason: "fallback-not-approved" }, true);
+    }
+  }
+
   if (!mode) {
     return textResult(
       `Provide exactly one mode: agent/task, tasks, or chain.\nAvailable agents: ${agents.map((agent) => `${agent.name} (${agent.source})`).join(", ") || "none"}`,
@@ -310,17 +455,23 @@ export async function executeTakomiSubagentTool(
     return textResult(`Too many parallel tasks (${tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`, { results: [], agentScope }, true);
   }
 
-  const fingerprint = createRunFingerprint(rootCwd, mode, tasks);
+  const fingerprint = createRunFingerprint(rootCwd, mode, tasks, params, agentScope);
+  const projectAgentsAuthorized = userGateAutoAuthorized || hostTrustsProjectAgents();
   const recentHardStop = consumeExpiredHardStop(pi, fingerprint);
-  if (recentHardStop) {
+  const authorizationOverridesHardStop = projectAgentsAuthorized && isProjectAgentApprovalHardStop(recentHardStop);
+  const consumesReviewGate = recentHardStop?.reason === "review-gate"
+    && params.confirmLaunch === true
+    && params.previewOnly !== true
+    && hasStrictlyNewerUserTurn(recentHardStop, userTurnMarker);
+  if (recentHardStop && !authorizationOverridesHardStop && !consumesReviewGate) {
     return hardStopResult(
       `Subagent launch blocked: the same request was already stopped (${recentHardStop.reason}).\n${recentHardStop.message}`,
       { results: [], availableAgents: agents.map((agent) => agent.name), agentScope, mode, blockedAt: recentHardStop.at, reason: recentHardStop.reason },
     );
   }
+  if (authorizationOverridesHardStop || consumesReviewGate) hardStopStore(pi).delete(fingerprint);
 
-  const projectAgentsTrusted = hostTrustsProjectAgents();
-  if (!projectAgentsTrusted && hasProjectAgents(tasks, byName)) {
+  if (!projectAgentsAuthorized && 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 uniqueNames = [...new Set(names)].join(", ");
     if (!ctx.hasUI) {
@@ -356,9 +507,9 @@ export async function executeTakomiSubagentTool(
   if (params.previewOnly) {
     return textResult(renderTakomiDelegationPlan(plan), { plan, availableAgents: agents.map((agent) => agent.name), agentScope, mode });
   }
-  if (plan.launchMode === "manual" && !params.confirmLaunch) {
+  if (plan.launchMode === "manual" && !consumesReviewGate) {
     const message = `${renderTakomiDelegationPlan(plan)}\n\nReview gate is awaiting explicit user approval.`;
-    rememberHardStop(pi, fingerprint, "review-gate", "Review gate displayed a delegation plan and paused before launch.");
+    rememberHardStop(pi, fingerprint, "review-gate", "Review gate displayed a delegation plan and paused before launch.", userTurnMarker);
     return hardStopResult(message, { plan, availableAgents: agents.map((agent) => agent.name), agentScope, mode });
   }
   try {
@@ -367,15 +518,33 @@ export async function executeTakomiSubagentTool(
       : mode === "parallel"
         ? { ...params, cwd: rootCwd, tasks, agentScope }
         : { ...params, cwd: rootCwd, chain: tasks, agentScope };
+    const uxTasks = createTakomiUxTasks(tasks);
+    const nativeOnUpdate = onUpdate
+      ? (partial: any) => onUpdate({
+          ...partial,
+          details: withTakomiUxDetails(partial?.details, uxTasks),
+        })
+      : undefined;
 
     const nativeResult: any = await engine.execute(
       "takomi-tool",
       nativeParams,
       signal,
-      onUpdate as any,
+      nativeOnUpdate as any,
       ctx,
     );
 
+    if (params.async === true) {
+      await rememberDetachedLaunch(
+        pi,
+        nativeResult,
+        uxTasks,
+        ctx,
+        rootCwd,
+        mode === "single" ? tasks[0]?.cwd ?? rootCwd : rootCwd,
+      );
+    }
+
     const takomi = {
       plan,
       agentScope,
@@ -390,7 +559,7 @@ export async function executeTakomiSubagentTool(
     return {
       ...nativeResult,
       details: {
-        ...(nativeResult?.details ?? {}),
+        ...withTakomiUxDetails(nativeResult?.details, uxTasks),
         takomi,
       },
     };

package/.pi/settings.json

@@ -1,42 +1,45 @@
 {
   "theme": "takomi-noir",
   "takomi": {
-    "modelRoutingPolicyFile": ".pi/takomi/model-routing.md"
-  },
-  "subagents": {
-    "agentOverrides": {
-      "general": {
-        "model": "oauth-router/gpt-5.4",
-        "thinking": "high",
-        "fallbackModels": [
-          "oauth-router/gpt-5.5:low"
-        ]
-      },
-      "orchestrator": {
-        "model": "oauth-router/gpt-5.5",
-        "thinking": "high"
-      },
-      "architect": {
-        "model": "oauth-router/gpt-5.5",
-        "thinking": "high"
-      },
-      "designer": {
-        "model": "oauth-router/gpt-5.4",
-        "thinking": "high",
-        "fallbackModels": [
-          "oauth-router/gpt-5.5:low"
-        ]
-      },
-      "coder": {
-        "model": "oauth-router/gpt-5.4",
-        "thinking": "high",
-        "fallbackModels": [
-          "oauth-router/gpt-5.5:low"
-        ]
-      },
-      "reviewer": {
-        "model": "oauth-router/gpt-5.5",
-        "thinking": "high"
+    "modelRoutingPolicyFile": ".pi/takomi/model-routing.md",
+    "routing": {
+      "defaultProvider": "openai-codex",
+      "approvedModels": [
+        "openai-codex/gpt-5.6-luna",
+        "openai-codex/gpt-5.6-sol",
+        "openai-codex/gpt-5.6-terra"
+      ],
+      "roleDefaults": {
+        "orchestrator": {
+          "model": "openai-codex/gpt-5.6-sol",
+          "thinking": "high"
+        },
+        "architect": {
+          "model": "openai-codex/gpt-5.6-sol",
+          "thinking": "high"
+        },
+        "designer": {
+          "model": "openai-codex/gpt-5.6-sol",
+          "thinking": "medium"
+        },
+        "coder": {
+          "model": "openai-codex/gpt-5.6-terra",
+          "thinking": "high",
+          "fallbackModels": [
+            "openai-codex/gpt-5.6-sol:low"
+          ]
+        },
+        "worker": {
+          "model": "openai-codex/gpt-5.6-luna",
+          "thinking": "high",
+          "fallbackModels": [
+            "openai-codex/gpt-5.6-sol:low"
+          ]
+        },
+        "reviewer": {
+          "model": "openai-codex/gpt-5.6-sol",
+          "thinking": "high"
+        }
       }
     }
   }