takomi 2.1.33 → 2.1.35

package/.pi/extensions/takomi-runtime/takomi-stats.js

@@ -1,4 +1,5 @@
-import { promises as fs } from 'node:fs';
+import { createReadStream, promises as fs } from 'node:fs';
+import readline from 'node:readline';
 import os from 'os';
 import path from 'path';
 
@@ -120,8 +121,14 @@ async function scanPiSessions(root, source, events, sessionRows = [], taskRows =
   for (const file of await files(root)) {
     let provider = 'unknown', model = 'unknown', session = path.basename(file, '.jsonl'), cwd = '', currentTask = null;
     const row = { key: session, session, source, file, project: projectKey(file), cwd, start: '', end: '', turns: 0, messages: 0, toolCalls: 0, subagentCalls: 0, roles: new Map(), stages: new Map(), workflows: new Map(), activeMs: 0, activityTimestamps: [] };
-    const text = await fs.readFile(file, 'utf8').catch(() => '');
-    for (const line of text.split(/\r?\n/)) {
+    let lines;
+    try {
+      lines = readline.createInterface({ input: createReadStream(file, { encoding: 'utf8' }), crlfDelay: Infinity });
+    } catch {
+      continue;
+    }
+    try {
+      for await (const line of lines) {
       const obj = safeJson(line); if (!obj) continue;
       if (obj.timestamp) { row.start ||= obj.timestamp; row.end = obj.timestamp; addTimestamp(row.activityTimestamps, obj.timestamp); }
       if (obj.type === 'session') { session = obj.id || session; cwd = obj.cwd || cwd; row.key = session; row.session = session; row.cwd = cwd; }
@@ -164,6 +171,9 @@ async function scanPiSessions(root, source, events, sessionRows = [], taskRows =
       }
       const u = msg && msg.usage;
       if (u) events.push({ source, file, timestamp: obj.timestamp, day: dayOf(obj.timestamp), session, provider, model, project: projectKey(file), kind: 'usage', input: +u.input||0, cache: +u.cacheRead||0, output: +u.output||0, total: +u.totalTokens||0, cost: cost(model, +u.input||0, +u.cacheRead||0, +u.output||0, true) });
+      }
+    } catch {
+      continue;
     }
     pushTask(taskRows, currentTask);
     row.activeMs = activeDuration(row.activityTimestamps);

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

@@ -27,6 +27,8 @@ export type RuntimeHudState = {
   activeSessionId?: string;
   launchMode?: string;
   subagentsEnabled?: boolean;
+  modeSource?: "idle" | "manual" | "model" | "board";
+  modeReason?: string;
 };
 
 type Tone = "accent" | "warning" | "success" | "error" | "muted" | "dim" | "thinkingMinimal";
@@ -70,24 +72,30 @@ function badge(theme: Theme, label: string, tone: Tone): string {
 }
 
 export function renderRuntimeStatus(theme: Theme, state: RuntimeHudState): string {
+  const source = state.modeSource ?? "idle";
+  if (!state.enabled) return [theme.fg("accent", "Takomi"), theme.fg("dim", "off")].join(" ");
+  if (source === "idle") return [theme.fg("accent", "Takomi"), theme.fg("dim", "idle")].join(" ");
+
   const primary = state.stage ?? state.role;
   const stageBadge = badge(theme, primary, stageTone(state.stage));
-  const auto = state.autoOrch ? theme.fg("accent", "auto") : theme.fg("dim", "manual");
-  const gate = state.launchMode === "manual" ? theme.fg("warning", "review-gate") : theme.fg("accent", "auto-gate");
+  const sourceLabel = source === "manual" ? theme.fg("warning", "manual") : theme.fg("success", source);
+  const role = state.stage && state.role !== state.stage ? theme.fg("dim", state.role) : "";
   const plan = state.planMode ? theme.fg("warning", "plan") : theme.fg("dim", "direct");
-  const subagents = state.subagentsEnabled === false ? theme.fg("error", "subagents:off") : theme.fg("dim", "subagents:on");
-  return [theme.fg("accent", "Takomi"), stageBadge, theme.fg("dim", `role:${state.role}`), auto, gate, plan, subagents].join(" ");
+  const gate = state.launchMode === "manual" ? theme.fg("warning", "review-gate") : "";
+  const subagents = state.subagentsEnabled === false ? theme.fg("error", "subagents:off") : "";
+  return [theme.fg("accent", "Takomi"), sourceLabel, stageBadge, role, gate || plan, subagents].filter(Boolean).join(" ");
 }
 
 export function renderRuntimeWidget(theme: Theme, state: RuntimeHudState): string[] {
-  if (!state.enabled) return [];
+  if (!state.enabled || (state.modeSource ?? "idle") === "idle") return [];
   const primary = state.stage ?? state.role;
+  const sourceLabel = state.modeSource === "manual" ? theme.fg("warning", "manual") : theme.fg("success", state.modeSource ?? "model");
   const parts = [
     theme.fg("accent", "Takomi"),
+    sourceLabel,
     badge(theme, primary, stageTone(state.stage)),
-    theme.fg("dim", `role:${state.role}`),
-    state.autoOrch ? theme.fg("accent", "auto") : theme.fg("dim", "manual"),
-    state.launchMode === "manual" ? theme.fg("warning", "review-gate") : theme.fg("accent", "auto-gate"),
+    state.stage && state.role !== state.stage ? theme.fg("dim", `role:${state.role}`) : "",
+    state.launchMode === "manual" ? theme.fg("warning", "review-gate") : "",
     state.planMode ? theme.fg("warning", "plan") : theme.fg("dim", "direct"),
     state.subagentsEnabled === false ? theme.fg("error", "subagents:off") : theme.fg("dim", "subagents:on"),
     state.workflow ? theme.fg("dim", `wf:${state.workflow}`) : "",
@@ -115,7 +123,7 @@ export class TakomiFooterComponent implements Component {
     this.unsubscribeBranchChange();
   }
 
-  invalidate(): void {}
+  invalidate(): void { }
 
   render(width: number): string[] {
     const state = this.getState();
@@ -141,8 +149,7 @@ export class TakomiFooterComponent implements Component {
       .filter(([key]) => key !== "takomi-runtime")
       .map(([, value]) => value)
       .filter(Boolean);
-    const runtimeStatus = renderRuntimeStatus(this.theme, state);
-    const left = [runtimeStatus, ...extensionStatuses].join(this.theme.fg("dim", "  |  "));
+    const left = extensionStatuses.join(this.theme.fg("dim", "  |  "));
     const branch = this.footerData.getGitBranch();
     const rightText = [this.ctx.model?.id || "no-model", branch ? `git:${branch}` : ""].filter(Boolean).join(" | ");
     const right = this.theme.fg("dim", rightText);

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

@@ -44,10 +44,11 @@ const SubagentParameters = Type.Object({
   tasks: Type.Optional(Type.Array(TaskSchema, { description: "Parallel subagent tasks" })),
   confirmLaunch: Type.Optional(Type.Boolean({ description: "Required to launch immediately in manual Takomi launch mode" })),
   previewOnly: Type.Optional(Type.Boolean({ description: "Return the delegation plan without launching" })),
+  clarify: Type.Optional(Type.Boolean({ description: "Show the native pi-subagents TUI to preview/edit before execution. Especially useful for chains; requires an interactive Pi TUI." })),
   chain: Type.Optional(Type.Array(TaskSchema, { description: "Sequential chain of subagent tasks" })),
   agentScope: Type.Optional(Type.Union([Type.Literal("user"), Type.Literal("project"), Type.Literal("both")])),
-  confirmProjectAgents: Type.Optional(Type.Boolean({ description: "Prompt before running project-local agents. Default: true." })),
-  overrideUserBlock: Type.Optional(Type.Boolean({ description: "Only set true when the user explicitly approves retrying after a blocked/cancelled/review-gated launch." })),
+  // Project-agent confirmation and hard-stop overrides are enforced server-side;
+  // they are intentionally not model-callable parameters.
 });
 
 function registerSubagentTool(pi: ExtensionAPI): void {
@@ -59,9 +60,10 @@ function registerSubagentTool(pi: ExtensionAPI): void {
     promptGuidelines: [
       "Use this tool during orchestration when a specialist should handle a task.",
       "Use tasks for independent parallel work and chain for dependent handoffs with {previous}.",
+      "Set clarify=true when the user asks to preview/edit a subagent run in the native Pi TUI before launch.",
       "Use model, fallbackModels, and thinking only when deliberate; otherwise let the agent/profile defaults apply.",
       "If review sends work back to the same agent, reuse the same conversationId for continuity.",
-      "If a launch is blocked, cancelled, paused, or review-gated, do not retry automatically; wait for the user's next prompt. Use overrideUserBlock only after explicit user approval.",
+      "If a launch is blocked, cancelled, paused, or review-gated, do not retry automatically; wait for the user's next prompt."
     ],
     parameters: SubagentParameters,
     async execute(_toolCallId, params, signal, onUpdate, ctx) {

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

@@ -30,15 +30,82 @@ export function renderTakomiSubagentCall(params: TakomiSubagentToolParams, theme
   );
 }
 
-export function renderTakomiSubagentResult(result: ToolResult, options: { expanded?: boolean; isPartial?: boolean }, theme: Theme, context: any): any {
-  const native = renderNativeSubagentResult(result, options, theme, context);
-  if (native) return native;
-
-  const status = (result as any)?.isError ? "failed" : "completed";
-  const text = typeof (result as any)?.content === "string"
+function resultText(result: ToolResult): string {
+  return typeof (result as any)?.content === "string"
     ? (result as any).content
     : Array.isArray((result as any)?.content)
       ? (result as any).content.map((part: any) => part?.text ?? "").filter(Boolean).join("\n")
       : JSON.stringify((result as any)?.details ?? {}, null, 2);
+}
+
+function summarizeCollapsedResult(text: string, status: string, theme: Theme): string {
+  const policyMatch = text.match(/Required policies:\n((?:- .+\n?)+)/);
+  const policies = policyMatch?.[1]
+    ?.split("\n")
+    .map((line) => line.replace(/^[-\s]+/, "").trim())
+    .filter(Boolean) ?? [];
+  const lineCount = text ? text.split(/\r?\n/).length : 0;
+  const label = policies.length > 0
+    ? `policy context loaded: ${policies.join(", ")}`
+    : `${lineCount} result line${lineCount === 1 ? "" : "s"} hidden`;
+  const icon = status === "failed" ? "⚠" : status === "running" ? "…" : "✓";
+  const color = status === "failed" ? "warning" : status === "running" ? "accent" : "success";
+  return `${theme.fg(color, `${icon} takomi_subagent ${status}`)}${theme.fg("dim", ` · ${label} (ctrl+o to expand)`)}`;
+}
+
+function recentOutputLines(value: unknown): string[] {
+  if (Array.isArray(value)) return value.map(String).filter(Boolean).slice(-3);
+  if (typeof value === "string") return value.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-3);
+  return [];
+}
+
+function livePartialText(result: ToolResult, theme: Theme): string {
+  const details = (result as any)?.details ?? {};
+  const results = Array.isArray(details.results) ? details.results : [];
+  const progress = Array.isArray(details.progress) ? details.progress : [];
+  const lines = [
+    theme.fg("toolTitle", theme.bold("takomi_subagent running")),
+    theme.fg("dim", "Live detail is bounded while streaming so manual scroll/ctrl+o does not jump on every token."),
+  ];
+
+  const rows = results.length ? results : progress;
+  if (!rows.length) {
+    const text = resultText(result).split(/\r?\n/).find((line) => line.trim())?.trim();
+    lines.push(theme.fg("dim", text || "Waiting for subagent progress…"));
+    return lines.join("\n");
+  }
+
+  rows.slice(0, 6).forEach((row: any, index: number) => {
+    const status = row.status ?? (row.exitCode === 0 ? "completed" : row.exitCode === -1 ? "running" : row.exitCode === undefined ? "running" : "failed");
+    const agent = row.agent ?? `task ${index + 1}`;
+    const task = String(row.task ?? "").replace(/\s+/g, " ").trim();
+    const currentTool = row.currentTool ?? row.progress?.currentTool;
+    const tokens = row.tokens ?? row.progress?.tokens ?? row.usage?.output;
+    const tail = recentOutputLines(row.recentOutput ?? row.progress?.recentOutput ?? row.finalOutput ?? row.output);
+    lines.push(theme.fg("accent", `${index + 1}. ${agent} ${theme.fg("dim", `[${status}]`)}`));
+    if (task) lines.push(theme.fg("dim", `   ${task.slice(0, 140)}${task.length > 140 ? "…" : ""}`));
+    if (currentTool || tokens) lines.push(theme.fg("muted", `   ${[currentTool ? `tool:${currentTool}` : "", tokens ? `tokens:${tokens}` : ""].filter(Boolean).join(" | ")}`));
+    for (const line of tail) lines.push(theme.fg("dim", `   › ${line.slice(0, 160)}${line.length > 160 ? "…" : ""}`));
+  });
+  if (rows.length > 6) lines.push(theme.fg("muted", `… ${rows.length - 6} more running item${rows.length - 6 === 1 ? "" : "s"}`));
+  lines.push(theme.fg("muted", "Final output will use the normal expandable native subagent renderer."));
+  return lines.join("\n");
+}
+
+export function renderTakomiSubagentResult(result: ToolResult, options: { expanded?: boolean; isPartial?: boolean }, theme: Theme, context: any): any {
+  const status = (result as any)?.isError ? "failed" : options.isPartial ? "running" : "completed";
+  const text = resultText(result);
+
+  if (options.isPartial) {
+    if (options.expanded) return new Text(livePartialText(result, theme), 0, 0);
+    return new Text(summarizeCollapsedResult(text, status, theme), 0, 0);
+  }
+
+  const native = renderNativeSubagentResult(result, options, theme, context);
+  if (native) return native;
+
+  if (!options.expanded) {
+    return new Text(summarizeCollapsedResult(text, status, theme), 0, 0);
+  }
   return new Text(`${theme.fg("toolTitle", theme.bold(`takomi_subagent ${status}`))}\n${text || "No result content."}`, 0, 0);
 }

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

@@ -75,7 +75,7 @@ function resolveTasks(params: TakomiSubagentToolParams): TakomiSubagentToolTask[
       fallbackModels: params.fallbackModels,
       thinking: params.thinking,
       conversationId: params.conversationId,
-      cwd: params.cwd,
+      cwd: undefined,
       checklist: params.checklist,
     }];
   }
@@ -109,6 +109,26 @@ function modelWithThinking(model: string | undefined, thinking: string | undefin
   return `${model}:${level}`;
 }
 
+function isPathInside(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function resolveRelativeCwd(root: string, value: string | undefined, label: string): string {
+  const lexicalRoot = path.resolve(root);
+  const lexicalCandidate = value
+    ? path.isAbsolute(value) ? path.resolve(value) : path.resolve(lexicalRoot, value)
+    : lexicalRoot;
+  if (!isPathInside(lexicalRoot, lexicalCandidate)) throw new Error(`${label} escapes the current workspace.`);
+
+  const realRoot = fs.realpathSync(lexicalRoot);
+  const realCandidate = fs.realpathSync(lexicalCandidate);
+  const stat = fs.statSync(realCandidate);
+  if (!stat.isDirectory()) throw new Error(`${label} must be a directory inside the current workspace.`);
+  if (!isPathInside(realRoot, realCandidate)) throw new Error(`${label} escapes the current workspace.`);
+  return realCandidate;
+}
+
 function safeConversationSlug(value: string): string {
   return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96) || "conversation";
 }
@@ -164,13 +184,14 @@ function agentNameSet(discoverPiAgents: any, cwd: string): Set<string> {
   return new Set(discoverUnifiedAgents(discoverPiAgents, cwd, "both").agents.map((agent) => agent.name));
 }
 
-function mapSingleTask(task: TakomiSubagentToolTask, names: Set<string>) {
+function mapSingleTask(task: TakomiSubagentToolTask, names: Set<string>, rootCwd: 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,
+    cwd: resolveRelativeCwd(rootCwd, task.cwd, "task.cwd"),
     model: modelWithThinking(task.model, task.thinking),
+    fallbackModels: task.fallbackModels,
     skill: task.skills?.length ? task.skills : undefined,
   };
 }
@@ -186,20 +207,21 @@ function toSubagentParams(params: TakomiSubagentToolParams, rootCwd: string, dis
     cwd: rootCwd,
     context: "fresh" as const,
     async: false,
-    clarify: false,
+    clarify: params.clarify === true,
     includeProgress: true,
     sessionDir: stableConversationSessionDir(rootCwd, tasks),
   };
 
   if (mode === "single") {
     const task = tasks[0]!;
-    const mapped = mapSingleTask(task, names);
+    const mapped = mapSingleTask(task, names, rootCwd);
     return {
       ...base,
       agent: mapped.agent,
       task: mapped.task,
-      cwd: task.cwd ? path.resolve(rootCwd, task.cwd) : rootCwd,
+      cwd: mapped.cwd,
       model: mapped.model,
+      fallbackModels: mapped.fallbackModels,
       skill: mapped.skill,
     };
   }
@@ -207,19 +229,20 @@ function toSubagentParams(params: TakomiSubagentToolParams, rootCwd: string, dis
   if (mode === "parallel") {
     return {
       ...base,
-      tasks: tasks.map((task) => mapSingleTask(task, names)),
+      tasks: tasks.map((task) => mapSingleTask(task, names, rootCwd)),
     };
   }
 
   return {
     ...base,
     chain: tasks.map((task) => {
-      const mapped = mapSingleTask(task, names);
+      const mapped = mapSingleTask(task, names, rootCwd);
       return {
         agent: mapped.agent,
         task: mapped.task,
-        cwd: task.cwd,
+        cwd: mapped.cwd,
         model: mapped.model,
+        fallbackModels: mapped.fallbackModels,
         skill: mapped.skill,
       };
     }),
@@ -264,7 +287,7 @@ export function createTakomiPiSubagentsEngine(pi: ExtensionAPI) {
       onUpdate: ToolUpdate | undefined,
       ctx: ExtensionContext,
     ): Promise<AgentToolResult<Details>> {
-      const rootCwd = params.cwd ? path.resolve(ctx.cwd, params.cwd) : ctx.cwd;
+      const rootCwd = resolveRelativeCwd(ctx.cwd, params.cwd, "cwd");
       const { executor, discoverPiAgents } = await getExecutor();
       const subagentParams = toSubagentParams(params, rootCwd, discoverPiAgents);
       return executor.execute(id, subagentParams, signal ?? NEVER_ABORT, onUpdate, ctx);

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

@@ -1,3 +1,4 @@
+import fs from "node:fs/promises";
 import path from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { TakomiThinkingLevel } from "../../../src/pi-takomi-core";
@@ -28,9 +29,8 @@ export type TakomiSubagentToolParams = Partial<TakomiSubagentToolTask> & {
   chain?: TakomiSubagentToolTask[];
   confirmLaunch?: boolean;
   previewOnly?: boolean;
+  clarify?: boolean;
   agentScope?: TakomiAgentScope;
-  confirmProjectAgents?: boolean;
-  overrideUserBlock?: boolean;
 };
 
 type ToolUpdate = (partial: {
@@ -65,6 +65,10 @@ function hasProjectAgents(tasks: Array<{ agent: string }>, agents: Map<string, T
   return tasks.some((task) => agents.get(task.agent)?.source === "project");
 }
 
+function hostTrustsProjectAgents(): boolean {
+  return /^(1|true|yes)$/i.test(process.env.TAKOMI_TRUST_PROJECT_AGENTS || "");
+}
+
 function hardStopStore(pi: ExtensionAPI): Map<string, HardStopRecord> {
   const existing = RECENT_HARD_STOPS.get(pi);
   if (existing) return existing;
@@ -114,6 +118,31 @@ function consumeExpiredHardStop(pi: ExtensionAPI, fingerprint: string): HardStop
   return record;
 }
 
+function isPathInside(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+async function resolveRelativeCwd(root: string, value: string | undefined, label: string): Promise<string> {
+  const lexicalRoot = path.resolve(root);
+  const lexicalCandidate = value
+    ? path.isAbsolute(value) ? path.resolve(value) : path.resolve(lexicalRoot, value)
+    : lexicalRoot;
+  if (!isPathInside(lexicalRoot, lexicalCandidate)) throw new Error(`${label} escapes the current workspace.`);
+
+  const [realRoot, realCandidate] = await Promise.all([fs.realpath(lexicalRoot), fs.realpath(lexicalCandidate)]);
+  const stat = await fs.stat(realCandidate);
+  if (!stat.isDirectory()) throw new Error(`${label} must be a directory inside the current workspace.`);
+  if (!isPathInside(realRoot, realCandidate)) throw new Error(`${label} escapes the current workspace.`);
+  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 : "")
@@ -183,7 +212,7 @@ function resolveTasks(params: TakomiSubagentToolParams): TakomiSubagentToolTask[
       fallbackModels: params.fallbackModels,
       thinking: params.thinking,
       conversationId: params.conversationId,
-      cwd: params.cwd,
+      cwd: undefined,
       checklist: params.checklist,
     }];
   }
@@ -197,17 +226,31 @@ export async function executeTakomiSubagentTool(
   ctx: ExtensionContext,
 ) {
   const engine = getEngine(pi);
-  const rootCwd = params.cwd ? path.resolve(ctx.cwd, params.cwd) : ctx.cwd;
+  let rootCwd: string;
+  try {
+    rootCwd = await resolveRelativeCwd(ctx.cwd, params.cwd, "cwd");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return textResult(message, { results: [], agentScope: params.agentScope ?? "both" }, true);
+  }
   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 routingSnapshot = await loadTakomiModelRoutingSnapshot(rootCwd);
-  const tasks = resolveTasks(params).map((task) => applyTakomiRoutingDefaults({
-    ...task,
-    agent: resolveAgentName(task.agent, byName),
-  }, routingSnapshot));
+  let tasks: TakomiSubagentToolTask[];
+  try {
+    const rawTasks = resolveTasks(params);
+    await validateTaskCwds(rootCwd, rawTasks);
+    tasks = rawTasks.map((task) => applyTakomiRoutingDefaults({
+      ...task,
+      agent: resolveAgentName(task.agent, byName),
+    }, routingSnapshot));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return textResult(message, { results: [], availableAgents: agents.map((agent) => agent.name), agentScope }, true);
+  }
 
   if (!mode) {
     return textResult(
@@ -222,19 +265,23 @@ export async function executeTakomiSubagentTool(
 
   const fingerprint = createRunFingerprint(rootCwd, mode, tasks);
   const recentHardStop = consumeExpiredHardStop(pi, fingerprint);
-  if (recentHardStop && !params.overrideUserBlock) {
+  if (recentHardStop) {
     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 (params.overrideUserBlock) {
-    hardStopStore(pi).delete(fingerprint);
-  }
 
-  if (params.confirmProjectAgents !== false && ctx.hasUI && hasProjectAgents(tasks, byName)) {
+  const projectAgentsTrusted = hostTrustsProjectAgents();
+  if (!projectAgentsTrusted && 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.`);
+    const uniqueNames = [...new Set(names)].join(", ");
+    if (!ctx.hasUI) {
+      const message = `Blocked: project-local Takomi agents require interactive approval. Agents: ${uniqueNames}`;
+      rememberHardStop(pi, fingerprint, "project-agent-approval-required", message);
+      return hardStopResult(message, { results: [], agentScope, mode });
+    }
+    const ok = await ctx.ui.confirm("Run project-local Takomi agents?", `Agents: ${uniqueNames}\n\nProject agents are repo-controlled. Continue only for trusted repositories.`);
     if (!ok) {
       const message = "Canceled: project-local agents not approved.";
       rememberHardStop(pi, fingerprint, "project-agent-denied", message);
@@ -269,7 +316,7 @@ export async function executeTakomiSubagentTool(
   }
   try {
     const nativeParams: TakomiSubagentToolParams = mode === "single"
-      ? { ...params, agent: tasks[0]!.agent, task: tasks[0]!.task, agentScope }
+      ? { ...params, ...tasks[0]!, agentScope }
       : mode === "parallel"
         ? { ...params, tasks, agentScope }
         : { ...params, chain: tasks, agentScope };

package/assets/.agent/skills/photo-book-builder/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: photo-book-builder
 description: >
-  Automates high-resolution photo book creation, including chronological sorting, orientation balancing (landscape vs. portrait), print-ready full-bleed masonry layout generation, and cover art upscaling. Use this skill when asked to: (1) Organize a set of photos into chronological pages, (2) Generate 12" x 30" open spreads (9000 x 3600 px at 300 DPI) with exact gutter margins (150 px vertical center gutter) and custom margins, (3) Create or assemble full-bleed masonry grid layouts, (4) Upscale front, back, or briefcase box covers using high-quality LANCZOS interpolation.
+  Automates high-resolution photo book creation and correction passes, including chronological sorting, orientation balancing, print-ready full-bleed masonry layout generation, existing layout crop corrections, contact-sheet/cell mapping, and cover art upscaling. Use this skill when asked to: (1) Organize photos into page folders, (2) Generate or regenerate 12" x 30" open spreads (9000 x 3600 px at 300 DPI) with gutter margins, (3) Create or adapt full-bleed masonry grid layouts with project-specific photo counts, (4) Correct existing exports by raising/lowering images or adjusting per-image crop framing without overwriting originals, (5) Upscale front, back, or briefcase box covers using high-quality LANCZOS interpolation.
 ---
 
 # Photo Book Builder
@@ -10,7 +10,7 @@ This skill provides a complete system for organizing, structuring, and generatin
 
 ## Core Capabilities
 
-The photo book builder relies on four main stages:
+The photo book builder supports five main stages:
 
 ```mermaid
 graph TD
@@ -18,6 +18,8 @@ graph TD
     B --> C[Stage 2 & 3: Layout Generation]
     C -->|create_full_bleed_layouts.py| D[9000x3600 px Print Spreads]
     E[Stage 4: Cover Upscaling] -->|upscale_covers.py| F[Print-Ready Cover JPEGs]
+    D --> G[Stage 5: Correction Pass]
+    G -->|custom renderer or patched generator| H[New Corrected Export Folder]
 ```
 
 ---
@@ -50,6 +52,8 @@ Layout configurations are determined dynamically based on photo counts and orien
 *   **Template 6A (6 Photos: 5L, 1P)**: Two landscape rows (4 total), one portrait + landscape col.
 *   **Template 6B (6 Photos: 4L, 2P)**: Two large landscape rows (2 total), one double-portrait + double-landscape col.
 
+These templates are defaults, not hard limits. When a project already has a custom generator, page folders, or spreads with a different number of photos (for example 23-24 images per spread), preserve that project's generator and layout rules. Do not force the default 5/6-photo half-page templates onto an existing custom book.
+
 For a complete coordinate reference and details on column configurations, see [layout_templates.md](references/layout_templates.md).
 
 ---
@@ -58,6 +62,8 @@ For a complete coordinate reference and details on column configurations, see [l
 The layout compiler reads the page directories, detects photo orientations on the fly, applies the coordinate grids, crops photos to fill cells (using centered LANCZOS fit-scale), and merges them into $9000 \times 3600$ px JPEG spreads.
 *   **Page Swapping**: Alternating layout orientation avoids monotonous designs. Left page columns swap if `page_num % 2 == 0`, and right page columns swap if `page_num % 3 == 0`.
 
+When regenerating an existing project, first inspect local scripts in the delivery/project folder. If a project-specific script exists, prefer adapting it over the bundled default scripts. Avoid rerunning any organizer/reorganizer that flattens or moves page folders unless the user explicitly asks for a new organization pass.
+
 **Execution**:
 Compile the print-ready layouts:
 ```bash
@@ -79,6 +85,44 @@ python scripts/upscale_covers.py --src "path/to/cover.png" --out "path/to/upscal
 
 ---
 
+### Stage 5: Existing Layout Correction Pass
+Use this when the user provides screenshots or notes such as "blue means raise the image" and "red means take it down" for already-exported spreads.
+
+**Correction workflow**:
+1. Identify the current source workspace, existing export folder, and correction screenshots.
+2. Inspect the local layout generator and `photo_organization_map.json` if present.
+3. Create a contact sheet or map preview that overlays each cell with its source filename and rectangle. This prevents guessing from screenshots.
+4. Translate annotations into per-image corrections:
+    * Blue / "raise image up": move the visible subject up in the cell. In crop-ratio terms this usually means increasing vertical crop offset when there is extra source height below the crop.
+    * Red / "take it down": move the visible subject down in the cell. In crop-ratio terms this usually means decreasing vertical crop offset when there is extra source height above the crop.
+    * If the crop is already pinned at the top or bottom, use a small top-anchored or bottom-anchored overscale instead of adding filler or painting pixels. Start tiny, e.g. `1.006` to `1.012`; larger values can overshoot.
+5. Render to a new export folder. Never overwrite the original export unless the user explicitly asks.
+6. Verify file count, output dimensions, and a reduced review sheet of corrected spreads.
+
+**Per-image correction patterns**:
+```python
+CROP_OVERRIDES = {
+    "DSC01234.jpg": {"y_ratio": 0.30},  # raise visible subject
+    "DSC05678.jpg": {"y_ratio": 0.00},  # lower visible subject
+}
+```
+
+For edge-pinned images where ratio changes cannot move the frame:
+```python
+TOP_ANCHORED_OVERSCALE = {
+    "DSC01234.jpg": 1.010,  # tiny downward nudge without filler
+}
+```
+
+Keep corrections local to filenames/cells. Avoid global crop changes unless every affected image needs the same behavior.
+
+**Safety rules for correction passes**:
+* Preserve existing page folders and mapping files.
+* Prefer a renderer that reads existing pages and writes new spreads over a script that reorganizes files.
+* Use output folder names like `10 - layouts - crop-corrections-YYYYMMDD`.
+* Keep a short correction log with source filenames, correction type, output folder, and verification result.
+* On Windows, avoid giant one-shot patches or command lines; keep scripts and path lists small.
+
 ## Revert Option
 If you need to restart the process or undo the page folder classification, run the revert tool to move photos back to the root workspace directory and remove empty page folders:
 ```bash
@@ -88,9 +132,9 @@ python scripts/revert_organization.py --workspace-dir "path/to/workspace"
 ## Bundled Resources
 
 *   **Scripts**:
-    *   [organize_photos.py](file:///C:/Users/johno/.gemini/config/skills/photo-book-builder/scripts/organize_photos.py) - Groups and balances photo directories.
-    *   [create_full_bleed_layouts.py](file:///C:/Users/johno/.gemini/config/skills/photo-book-builder/scripts/create_full_bleed_layouts.py) - Assembles masonry grid pages into print-ready spreads.
-    *   [upscale_covers.py](file:///C:/Users/johno/.gemini/config/skills/photo-book-builder/scripts/upscale_covers.py) - General-purpose upscaling script.
-    *   [revert_organization.py](file:///C:/Users/johno/.gemini/config/skills/photo-book-builder/scripts/revert_organization.py) - Restores files back to flat source directories.
+    *   [organize_photos.py](scripts/organize_photos.py) - Groups and balances photo directories.
+    *   [create_full_bleed_layouts.py](scripts/create_full_bleed_layouts.py) - Assembles masonry grid pages into print-ready spreads.
+    *   [upscale_covers.py](scripts/upscale_covers.py) - General-purpose upscaling script.
+    *   [revert_organization.py](scripts/revert_organization.py) - Restores files back to flat source directories.
 *   **References**:
-    *   [layout_templates.md](file:///C:/Users/johno/.gemini/config/skills/photo-book-builder/references/layout_templates.md) - Exact coordinates, dimensions, and grid cells.
+    *   [layout_templates.md](references/layout_templates.md) - Exact coordinates, dimensions, and grid cells.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "takomi",
-  "version": "2.1.33",
+  "version": "2.1.35",
   "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": {
@@ -23,7 +23,9 @@
   ],
   "scripts": {
     "postinstall": "node src/postinstall.js",
-    "test": "node scripts/test-skill-selection.js",
+    "test": "npm run test:typecheck && npm run test:regressions && npm run test:skills",
+    "test:typecheck": "tsc --noEmit",
+    "test:regressions": "node scripts/test-regressions.js",
     "test:skills": "node scripts/test-skill-selection.js"
   },
   "repository": {
@@ -52,6 +54,20 @@
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2"
   },
+  "overrides": {
+    "protobufjs": "7.6.3",
+    "@protobufjs/utf8": "1.1.1",
+    "ws": "8.21.0",
+    "brace-expansion": "5.0.6"
+  },
+  "pnpm": {
+    "overrides": {
+      "protobufjs": "7.6.3",
+      "@protobufjs/utf8": "1.1.1",
+      "ws": "8.21.0",
+      "brace-expansion": "5.0.6"
+    }
+  },
   "bugs": {
     "url": "https://github.com/JStaRFilms/VibeCode-Protocol-Suite/issues"
   },