takomi 2.1.43 → 2.1.45

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

@@ -14,6 +14,7 @@ import {
 import { resolveAgentName } from "./agent-aliases";
 import { applyTakomiRoutingDefaults, loadTakomiModelRoutingSnapshotSync } from "../takomi-runtime/model-routing-defaults";
 import type { TakomiSubagentToolParams, TakomiSubagentToolTask } from "./tool-runner";
+import { ensureTakomiAsyncLifecycle, getTakomiAsyncLifecycleSnapshot } from "./async-lifecycle";
 
 type ToolUpdate = (partial: AgentToolResult<Details>) => void;
 
@@ -32,28 +33,6 @@ 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" | "action" | undefined {
   if (params.action) return "action";
   const hasChain = Boolean(params.chain?.length);
@@ -78,6 +57,7 @@ function resolveTasks(params: TakomiSubagentToolParams): TakomiSubagentToolTask[
       conversationId: params.conversationId,
       cwd: undefined,
       checklist: params.checklist,
+      acceptance: params.acceptance,
     }];
   }
   return [];
@@ -92,6 +72,7 @@ function buildTakomiTaskPrompt(task: TakomiSubagentToolTask): string {
     ? [
         "Checklist:",
         ...task.checklist.map((item) => typeof item === "string" ? `- [ ] ${item}` : `- [${item.done ? "x" : " "}] ${item.text}`),
+        "When an item's state changes, report that exact item in explicit assistant progress/final output as a markdown checkbox. Mark it complete only after it is actually complete.",
       ].join("\n")
     : "";
   const takomiContext = [
@@ -194,6 +175,10 @@ function mapSingleTask(task: TakomiSubagentToolTask, names: Set<string>, rootCwd
     model: modelWithThinking(task.model, task.thinking),
     fallbackModels: task.fallbackModels,
     skill: task.skills?.length ? task.skills : undefined,
+    // Native omission means auto-inferred enforcement. Takomi's public default
+    // is deliberately ordinary/no-contract; only caller-supplied acceptance is
+    // enforced, and every explicit value is forwarded unchanged.
+    acceptance: task.acceptance ?? { level: "none", reason: "No explicit Takomi acceptance contract." },
   };
 }
 
@@ -238,6 +223,7 @@ function toSubagentParams(params: TakomiSubagentToolParams, rootCwd: string, dis
       model: mapped.model,
       fallbackModels: mapped.fallbackModels,
       skill: mapped.skill,
+      acceptance: mapped.acceptance,
     };
   }
 
@@ -259,42 +245,65 @@ function toSubagentParams(params: TakomiSubagentToolParams, rootCwd: string, dis
         model: mapped.model,
         fallbackModels: mapped.fallbackModels,
         skill: mapped.skill,
+        acceptance: mapped.acceptance,
       };
     }),
   };
 }
 
 export function createTakomiPiSubagentsEngine(pi: ExtensionAPI) {
-  const state = createState();
-  let executorPromise: Promise<any> | null = null;
+  let executorBinding: {
+    state: SubagentState;
+    generation: number;
+    promise: Promise<any>;
+  } | null = null;
 
-  async function getExecutor() {
-    if (!executorPromise) {
-      executorPromise = loadPiSubagentsInternals().then((internals) => {
-        const config = {
-          maxSubagentDepth: 2,
-          asyncByDefault: false,
-          forceTopLevelAsync: false,
-        };
-        return {
-          executor: internals.createSubagentExecutor({
-            pi,
-            state,
-            config,
-            asyncByDefault: false,
-            tempArtifactsDir: internals.TEMP_ARTIFACTS_DIR,
-            getSubagentSessionRoot,
-            expandTilde,
-            discoverAgents: (cwd: string, scope: AgentScope) => discoverUnifiedAgents(internals.discoverPiAgents, cwd, scope),
+  async function getExecutor(ctx: ExtensionContext) {
+    // Ownership can change when either extension reloads. Re-check after the
+    // executor factory resolves so an in-flight native takeover can never return
+    // an executor bound to a lifecycle that was disposed during initialization.
+    for (;;) {
+      const lifecycle = await ensureTakomiAsyncLifecycle(pi, ctx);
+      if (!executorBinding
+        || executorBinding.state !== lifecycle.state
+        || executorBinding.generation !== lifecycle.generation) {
+        const state = lifecycle.state;
+        executorBinding = {
+          state,
+          generation: lifecycle.generation,
+          promise: loadPiSubagentsInternals().then((internals) => {
+            const config = {
+              maxSubagentDepth: 2,
+              asyncByDefault: false,
+              forceTopLevelAsync: false,
+            };
+            return {
+              executor: internals.createSubagentExecutor({
+                pi,
+                state,
+                config,
+                asyncByDefault: false,
+                tempArtifactsDir: internals.TEMP_ARTIFACTS_DIR,
+                getSubagentSessionRoot,
+                expandTilde,
+                discoverAgents: (cwd: string, scope: AgentScope) => discoverUnifiedAgents(internals.discoverPiAgents, cwd, scope),
+              }),
+              discoverPiAgents: internals.discoverPiAgents,
+            };
           }),
-          discoverPiAgents: internals.discoverPiAgents,
         };
-      });
+      }
+      const binding = executorBinding;
+      const executor = await binding.promise;
+      const current = getTakomiAsyncLifecycleSnapshot(pi);
+      if (current?.state === binding.state && current?.generation === binding.generation) return executor;
     }
-    return executorPromise;
   }
 
   return {
+    dispose(): void {
+      executorBinding = null;
+    },
     async execute(
       id: string,
       params: TakomiSubagentToolParams,
@@ -303,7 +312,7 @@ export function createTakomiPiSubagentsEngine(pi: ExtensionAPI) {
       ctx: ExtensionContext,
     ): Promise<AgentToolResult<Details>> {
       const rootCwd = resolveRelativeCwd(ctx.cwd, params.cwd, "cwd");
-      const { executor, discoverPiAgents } = await getExecutor();
+      const { executor, discoverPiAgents } = await getExecutor(ctx);
       const subagentParams = toSubagentParams(params, rootCwd, discoverPiAgents);
       return executor.execute(id, subagentParams, signal ?? NEVER_ABORT, onUpdate, ctx);
     },

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

@@ -14,28 +14,34 @@ let cachedInternals: any | null = null;
 export async function loadPiSubagentsInternals() {
   if (cachedInternals) return cachedInternals;
 
-  const [executorModule, agentsModule, sharedTypesModule, renderModule] = await Promise.all([
+  const [executorModule, agentsModule, sharedTypesModule, renderModule, watcherModule, sessionModule] = await Promise.all([
     dynamicImport(spec("src/runs/foreground/subagent-executor")),
     dynamicImport(spec("src/agents/agents")),
     dynamicImport(spec("src/shared/types")),
     dynamicImport(spec("src/tui/render")),
+    dynamicImport(spec("src/runs/background/result-watcher")),
+    dynamicImport(spec("src/shared/session-identity")),
   ]);
 
   cachedInternals = {
     createSubagentExecutor: executorModule.createSubagentExecutor,
+    createResultWatcher: watcherModule.createResultWatcher,
     discoverPiAgents: agentsModule.discoverAgents,
+    resolveCurrentSessionId: sessionModule.resolveCurrentSessionId,
     DEFAULT_ARTIFACT_CONFIG: sharedTypesModule.DEFAULT_ARTIFACT_CONFIG,
+    ASYNC_DIR: sharedTypesModule.ASYNC_DIR,
+    RESULTS_DIR: sharedTypesModule.RESULTS_DIR,
     TEMP_ARTIFACTS_DIR: sharedTypesModule.TEMP_ARTIFACTS_DIR,
+    WIDGET_KEY: sharedTypesModule.WIDGET_KEY,
     renderSubagentResult: renderModule.renderSubagentResult,
-    clearLegacyResultAnimationTimer: renderModule.clearLegacyResultAnimationTimer,
+    renderWidget: renderModule.renderWidget,
   };
   return cachedInternals;
 }
 
-export function renderNativeSubagentResult(result: unknown, options: unknown, theme: unknown, context: unknown): unknown | undefined {
+export function renderNativeSubagentResult(result: unknown, options: unknown, theme: unknown, frame?: number): unknown | undefined {
   if (!cachedInternals?.renderSubagentResult) return undefined;
-  cachedInternals.clearLegacyResultAnimationTimer?.(context);
-  return cachedInternals.renderSubagentResult(result, options, theme);
+  return cachedInternals.renderSubagentResult(result, options, theme, frame);
 }
 
 export type SubagentParamsLike = any;

package/.pi/extensions/takomi-subagents/result-heartbeat.ts

@@ -0,0 +1,55 @@
+export const TAKOMI_SUBAGENT_HEARTBEAT_MS = 125;
+
+type Timer = ReturnType<typeof setInterval>;
+
+type HeartbeatState = {
+  takomiSubagentHeartbeatTimer?: Timer;
+  takomiSubagentHeartbeatFrame?: number;
+};
+
+export type TakomiSubagentRenderContext = {
+  state: Record<string, unknown>;
+  invalidate?: () => void;
+};
+
+const activeHeartbeatStates = new Set<HeartbeatState>();
+
+export function clearTakomiSubagentResultHeartbeat(context: TakomiSubagentRenderContext): void {
+  const state = context.state as HeartbeatState;
+  if (state.takomiSubagentHeartbeatTimer !== undefined) {
+    clearInterval(state.takomiSubagentHeartbeatTimer);
+    state.takomiSubagentHeartbeatTimer = undefined;
+  }
+  activeHeartbeatStates.delete(state);
+}
+
+export function ensureTakomiSubagentResultHeartbeat(context: TakomiSubagentRenderContext): void {
+  const state = context.state as HeartbeatState;
+  if (state.takomiSubagentHeartbeatTimer !== undefined || typeof context.invalidate !== "function") return;
+
+  state.takomiSubagentHeartbeatFrame ??= 0;
+  state.takomiSubagentHeartbeatTimer = setInterval(() => {
+    state.takomiSubagentHeartbeatFrame = ((state.takomiSubagentHeartbeatFrame ?? 0) + 1) % 10;
+    try {
+      context.invalidate?.();
+    } catch {
+      // A replaced session makes its row context stale. Stop immediately rather
+      // than retaining the old UI through a failing interval callback.
+      clearTakomiSubagentResultHeartbeat(context);
+    }
+  }, TAKOMI_SUBAGENT_HEARTBEAT_MS);
+  state.takomiSubagentHeartbeatTimer.unref?.();
+  activeHeartbeatStates.add(state);
+}
+
+export function getTakomiSubagentHeartbeatFrame(context: TakomiSubagentRenderContext): number {
+  return (context.state as HeartbeatState).takomiSubagentHeartbeatFrame ?? 0;
+}
+
+export function clearAllTakomiSubagentResultHeartbeats(): void {
+  for (const state of [...activeHeartbeatStates]) {
+    if (state.takomiSubagentHeartbeatTimer !== undefined) clearInterval(state.takomiSubagentHeartbeatTimer);
+    state.takomiSubagentHeartbeatTimer = undefined;
+    activeHeartbeatStates.delete(state);
+  }
+}

package/.pi/extensions/takomi-subagents/subagent-ux.ts

@@ -0,0 +1,162 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+export type TakomiUxChecklistItem = {
+  id: string;
+  index: number;
+  text: string;
+  done: boolean;
+  stateSource: "input" | "agent-reported";
+};
+
+export type TakomiUxTask = {
+  agent: string;
+  task: string;
+  checklist: TakomiUxChecklistItem[];
+};
+
+const CHECKBOX_LINE = /^\s*[-*+]\s+\[([ xX])\]\s+(.+?)\s*$/;
+const ACCEPTANCE_BLOCK = /```acceptance-report\s*[\s\S]*?```/gi;
+const OSC_SEQUENCE = /\x1b\][\s\S]*?(?:\x07|\x1b\\|$)/g;
+const CSI_SEQUENCE = /(?:\x1b\[|\x9b)[0-?]*[ -\/]*[@-~]/g;
+const ESC_SEQUENCE = /\x1b(?:[()][0-2A-Z0-9]|[=>]|[ -\/]*[@-~]?)/g;
+const UNSAFE_CONTROLS = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g;
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+/** Remove terminal control sequences before untrusted values reach Text/Markdown. */
+export function sanitizeUntrustedText(value: string): string {
+  return value
+    .replace(OSC_SEQUENCE, "")
+    .replace(CSI_SEQUENCE, "")
+    .replace(ESC_SEQUENCE, "")
+    .replace(UNSAFE_CONTROLS, "");
+}
+
+/** Sanitize string leaves while retaining native result shape and Markdown syntax. */
+export function sanitizeUntrustedValue<T>(value: T, seen = new WeakMap<object, unknown>()): T {
+  if (typeof value === "string") return sanitizeUntrustedText(value) as T;
+  if (!value || typeof value !== "object") return value;
+  if (seen.has(value as object)) return seen.get(value as object) as T;
+  const output: any = Array.isArray(value) ? [] : {};
+  seen.set(value as object, output);
+  for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
+    output[key] = sanitizeUntrustedValue(child, seen);
+  }
+  return output as T;
+}
+
+export function createTakomiUxTasks(
+  tasks: Array<{ agent: string; task: string; checklist?: Array<string | { text: string; done?: boolean }> }>,
+): TakomiUxTask[] {
+  return tasks.map((task, taskIndex) => ({
+    agent: task.agent,
+    task: task.task,
+    checklist: (task.checklist ?? []).map((item, index) => ({
+      id: `task-${taskIndex + 1}-item-${index + 1}`,
+      index,
+      text: typeof item === "string" ? item : item.text,
+      done: typeof item === "string" ? false : item.done === true,
+      stateSource: "input",
+    })),
+  }));
+}
+
+export function withTakomiUxDetails(details: unknown, tasks: TakomiUxTask[]): Record<string, unknown> {
+  const base = details && typeof details === "object" && !Array.isArray(details)
+    ? details as Record<string, unknown>
+    : {};
+  return { ...base, takomiUx: { tasks } };
+}
+
+function textParts(content: unknown): string[] {
+  if (typeof content === "string") return content.trim() ? [content] : [];
+  if (!Array.isArray(content)) return [];
+  return content
+    .filter((part): part is { type: "text"; text: string } => (
+      Boolean(part) && typeof part === "object" && (part as any).type === "text" && typeof (part as any).text === "string"
+    ))
+    .map((part) => part.text)
+    .filter((text) => text.trim().length > 0);
+}
+
+/** Only explicit, visible assistant text is eligible for compact narrative. */
+export function explicitAssistantTexts(result: any): string[] {
+  if (!Array.isArray(result?.messages)) return [];
+  return result.messages
+    .filter((message: any) => message?.role === "assistant")
+    .flatMap((message: any) => textParts(message.content));
+}
+
+/**
+ * Markdown boxes are not structured truth. Exact, unambiguous self-reports may
+ * update a uniquely-labelled input item and are retained as agent-reported.
+ */
+export function resolvedChecklist(items: TakomiUxChecklistItem[], assistantTexts: string[]): TakomiUxChecklistItem[] {
+  const states = items.map((item) => ({ ...item }));
+  const sourceCounts = new Map<string, number>();
+  for (const item of items) sourceCounts.set(item.text, (sourceCounts.get(item.text) ?? 0) + 1);
+
+  for (const text of assistantTexts) {
+    const reports = text.split(/\r?\n/).map((line) => line.match(CHECKBOX_LINE)).filter(Boolean) as RegExpMatchArray[];
+    const reportCounts = new Map<string, number>();
+    for (const report of reports) {
+      const label = report[2] ?? "";
+      reportCounts.set(label, (reportCounts.get(label) ?? 0) + 1);
+    }
+    for (const report of reports) {
+      const label = report[2] ?? "";
+      if (sourceCounts.get(label) !== 1 || reportCounts.get(label) !== 1) continue;
+      const item = states.find((candidate) => candidate.text === label);
+      if (!item) continue;
+      item.done = (report[1] ?? "").toLowerCase() === "x";
+      item.stateSource = "agent-reported";
+    }
+  }
+  return states;
+}
+
+function cleanNarrative(value: string): string {
+  return sanitizeUntrustedText(value)
+    .replace(ACCEPTANCE_BLOCK, "")
+    .replace(/\r/g, "")
+    .trim();
+}
+
+function meaningfulLines(value: string): string[] {
+  return cleanNarrative(value)
+    .split("\n")
+    .map((line) => line.replace(/\s+/g, " ").trim())
+    .filter(Boolean);
+}
+
+export function clipVisibleLine(line: string, maxColumns: number): string {
+  const safe = sanitizeUntrustedText(line);
+  if (visibleWidth(safe) <= maxColumns) return safe;
+  const target = Math.max(0, maxColumns - 1);
+  let output = "";
+  let width = 0;
+  for (const { segment } of segmenter.segment(safe)) {
+    const nextWidth = visibleWidth(segment);
+    if (width + nextWidth > target) break;
+    output += segment;
+    width += nextWidth;
+  }
+  return `${output}…`;
+}
+
+export function boundNarrative(
+  value: string,
+  options: { maxLines: number; maxColumns: number; from?: "start" | "end" },
+): { lines: string[]; truncated: boolean } {
+  const source = meaningfulLines(value);
+  const selected = options.from === "start" ? source.slice(0, options.maxLines) : source.slice(-options.maxLines);
+  const clipped = selected.map((line) => clipVisibleLine(line, options.maxColumns));
+  return {
+    lines: clipped,
+    truncated: source.length > selected.length || selected.some((line, index) => line !== clipped[index]),
+  };
+}
+
+export function finalAnswer(result: any): string {
+  if (typeof result?.finalOutput === "string" && result.finalOutput.trim()) return cleanNarrative(result.finalOutput);
+  return cleanNarrative(explicitAssistantTexts(result).at(-1) ?? "");
+}