@llblab/pi-actors 0.39.0 → 0.40.1

package/dist/lib/runs-retention.js

@@ -2,11 +2,21 @@
  * Async run retention operations.
  * Owns terminal-run archive and prune filesystem behavior.
  */
+import { createHash } from "node:crypto";
 import { cpSync, mkdirSync, renameSync, rmSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { writeJsonAtomic } from "./file-state.js";
 import { resolveArtifactManifest, } from "./runs-artifacts.js";
 import { safeRunId } from "./runs-identity.js";
+import { assertOwnedRunStateDirectory } from "./runs-ownership.js";
+function retainedArtifactFilename(name, path) {
+    const readableName = name.replace(/[^A-Za-z0-9_.-]+/g, "_") || "artifact";
+    const identity = createHash("sha256")
+        .update(`${name}\0${path}`)
+        .digest("hex")
+        .slice(0, 8);
+    return `${readableName}-${identity}--${basename(path)}`;
+}
 function archivePathFor(run, stateDir) {
     const archiveRoot = join(dirname(stateDir), "archived");
     mkdirSync(archiveRoot, { recursive: true });
@@ -15,6 +25,7 @@ function archivePathFor(run, stateDir) {
 export function archiveTerminalRun(status) {
     const stateDir = String(status.state_dir);
     const run = String(status.run ?? basename(stateDir));
+    assertOwnedRunStateDirectory(stateDir, run);
     const archiveDir = archivePathFor(run, stateDir);
     renameSync(stateDir, archiveDir);
     mkdirSync(stateDir, { recursive: true });
@@ -29,9 +40,10 @@ export function archiveTerminalRun(status) {
     writeJsonAtomic(join(stateDir, "archive-tombstone.json"), tombstone);
     return tombstone;
 }
-export function pruneTerminalRun(status, options = {}) {
+export function pruneTerminalRun(status, options = {}, deps = {}) {
     const stateDir = String(status.state_dir);
     const run = String(status.run ?? basename(stateDir));
+    assertOwnedRunStateDirectory(stateDir, run);
     const manifest = resolveArtifactManifest(status.artifacts);
     const preserved = {};
     if (options.preserveArtifacts && manifest) {
@@ -40,8 +52,11 @@ export function pruneTerminalRun(status, options = {}) {
         for (const [name, artifact] of Object.entries(manifest)) {
             if (!artifact.exists)
                 continue;
-            const target = join(preserveRoot, basename(artifact.path));
-            cpSync(artifact.path, target, { force: true });
+            const target = join(preserveRoot, retainedArtifactFilename(name, artifact.path));
+            (deps.copyArtifact ?? cpSync)(artifact.path, target, {
+                force: true,
+                preserveTimestamps: true,
+            });
             preserved[name] = target;
         }
     }

package/dist/lib/runs-start.d.ts

@@ -4,6 +4,6 @@
  * preparation before a new runner process is spawned.
  */
 export type RunJsonReader = (path: string) => Record<string, unknown> | undefined;
-export declare function assertNoActiveRunState(stateDir: string, readJson: RunJsonReader, runnerPath: string): void;
+export declare function assertNoActiveRunState(stateDir: string, readJson: RunJsonReader, _runnerPath: string): void;
 export declare function acquireStateStartLock(stateDir: string): () => void;
-export declare function prepareStateDirForStart(stateDir: string, readJson: RunJsonReader, runnerPath: string): void;
+export declare function prepareStateDirForStart(stateDir: string, readJson: RunJsonReader, _runnerPath: string): void;

package/dist/lib/runs-start.js

@@ -3,33 +3,64 @@
  * Owns active-run reuse checks, start lock acquisition, and safe state-dir
  * preparation before a new runner process is spawned.
  */
-import { mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
-import { isAlive, pidMatchesRun } from "./runs-process.js";
+import { isAlive, readProcessIdentity, verifyRunProcessIdentity, } from "./runs-process.js";
 const START_LOCK_MAX_AGE_MS = 5 * 60 * 1000;
-export function assertNoActiveRunState(stateDir, readJson, runnerPath) {
+export function assertNoActiveRunState(stateDir, readJson, _runnerPath) {
     const meta = readJson(join(stateDir, "run.json"));
     if (!meta)
         return;
     const pid = Number(meta.pid || 0);
     const cwd = String(meta.cwd ?? "");
-    if (!pid || !isAlive(pid) || !pidMatchesRun(pid, cwd, stateDir, runnerPath))
+    if (!pid || !isAlive(pid))
         return;
-    throw new Error(`Run state already has an active owned process: ${String(meta.run ?? stateDir)}. Stop it before reusing the same run_id or state_dir.`);
+    const identity = verifyRunProcessIdentity(pid, meta.process_identity);
+    if (identity.status === "owner_mismatch") {
+        throw new Error(`Run state process identity does not match the live pid: ${String(meta.run ?? stateDir)}. Refusing to reuse the state directory while pid ${pid} is alive.`);
+    }
+    if (identity.status === "unsupported_proof") {
+        throw new Error(`Run state process identity proof is unavailable: ${String(meta.run ?? stateDir)}. Refusing to reuse the state directory while pid ${pid} is alive.`);
+    }
+    if (identity.valid) {
+        throw new Error(`Run state already has an active owned process: ${String(meta.run ?? stateDir)}. Stop it before reusing the same run_id or state_dir.`);
+    }
+}
+function writeStartLockOwner(lockDir, recovered = false) {
+    const processIdentity = readProcessIdentity(process.pid);
+    writeFileSync(join(lockDir, "owner.json"), `${JSON.stringify({
+        pid: process.pid,
+        createdAt: new Date().toISOString(),
+        ...(processIdentity ? { process_identity: processIdentity } : {}),
+        ...(recovered ? { recovered: true } : {}),
+    })}\n`, "utf8");
+}
+function isStartLockOwnerProvenDead(lockDir) {
+    try {
+        const owner = JSON.parse(readFileSync(join(lockDir, "owner.json"), "utf8"));
+        const pid = Number(owner.pid || 0);
+        if (!pid)
+            return false;
+        return verifyRunProcessIdentity(pid, owner.process_identity).status === "dead_pid";
+    }
+    catch {
+        return false;
+    }
 }
 export function acquireStateStartLock(stateDir) {
     const lockDir = join(stateDir, ".start.lock");
     try {
         mkdirSync(lockDir);
-        writeFileSync(join(lockDir, "owner.json"), `${JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() })}\n`, "utf8");
+        writeStartLockOwner(lockDir);
     }
     catch (error) {
         try {
             const stat = statSync(lockDir);
-            if (Date.now() - stat.mtimeMs > START_LOCK_MAX_AGE_MS) {
+            if (Date.now() - stat.mtimeMs > START_LOCK_MAX_AGE_MS &&
+                isStartLockOwnerProvenDead(lockDir)) {
                 rmSync(lockDir, { recursive: true, force: true });
                 mkdirSync(lockDir);
-                writeFileSync(join(lockDir, "owner.json"), `${JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString(), recovered: true })}\n`, "utf8");
+                writeStartLockOwner(lockDir, true);
                 return () => rmSync(lockDir, { recursive: true, force: true });
             }
         }
@@ -40,17 +71,20 @@ export function acquireStateStartLock(stateDir) {
     }
     return () => rmSync(lockDir, { recursive: true, force: true });
 }
-export function prepareStateDirForStart(stateDir, readJson, runnerPath) {
+export function prepareStateDirForStart(stateDir, readJson, _runnerPath) {
     const existing = readJson(join(stateDir, "run.json"));
     const existingPid = Number(existing?.pid || 0);
-    const existingCwd = typeof existing?.cwd === "string" ? existing.cwd : undefined;
-    const existingResult = readJson(join(stateDir, "result.json"));
-    if (!existingResult &&
-        existingPid &&
-        existingCwd &&
-        isAlive(existingPid) &&
-        pidMatchesRun(existingPid, existingCwd, stateDir, runnerPath)) {
-        throw new Error(`Run state already has an active owned process: ${String(existing?.run ?? stateDir)}. Stop it before restarting.`);
+    if (existingPid && isAlive(existingPid)) {
+        const identity = verifyRunProcessIdentity(existingPid, existing?.process_identity);
+        if (identity.status === "owner_mismatch") {
+            throw new Error(`Run state process identity does not match the live pid: ${String(existing?.run ?? stateDir)}. Refusing to prepare the state directory while pid ${existingPid} is alive.`);
+        }
+        if (identity.status === "unsupported_proof") {
+            throw new Error(`Run state process identity proof is unavailable: ${String(existing?.run ?? stateDir)}. Refusing to prepare the state directory while pid ${existingPid} is alive.`);
+        }
+        if (identity.valid) {
+            throw new Error(`Run state already has an active owned process: ${String(existing?.run ?? stateDir)}. Stop it before restarting.`);
+        }
     }
     for (const file of [
         "events.jsonl",

package/dist/lib/runs-status.d.ts

@@ -3,6 +3,6 @@
  * Owns status derivation from run state files plus bounded log/event tails.
  */
 export type RunJsonReader = (path: string) => Record<string, unknown> | undefined;
-export declare function buildRunStatus(stateDir: string, runOrDir: string, meta: Record<string, unknown>, readJson: RunJsonReader, runnerPath: string, runnerIdentityGraceMs: number): Record<string, unknown>;
+export declare function buildRunStatus(stateDir: string, runOrDir: string, meta: Record<string, unknown>, readJson: RunJsonReader, _runnerPath: string, runnerIdentityGraceMs: number): Record<string, unknown>;
 export declare function tailFile(path: string, lines: number): string;
 export declare function tailLines(path: string, lines: number): string[];

package/dist/lib/runs-status.js

@@ -4,7 +4,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { isAlive, isWithinRunnerIdentityGrace, pidMatchesRun } from "./runs-process.js";
+import { isWithinRunnerIdentityGrace, verifyRunProcessIdentity, } from "./runs-process.js";
 import { readJsonlFileResilient } from "./state-readers.js";
 function getInterruptedRunStatus(stateDir) {
     const events = readJsonlFileResilient(join(stateDir, "events.jsonl")).records.slice(-200);
@@ -16,14 +16,14 @@ function getInterruptedRunStatus(stateDir) {
     }
     return undefined;
 }
-export function buildRunStatus(stateDir, runOrDir, meta, readJson, runnerPath, runnerIdentityGraceMs) {
+export function buildRunStatus(stateDir, runOrDir, meta, readJson, _runnerPath, runnerIdentityGraceMs) {
     const result = readJson(join(stateDir, "result.json"));
     const pid = Number(meta.pid || 0);
+    const processIdentity = verifyRunProcessIdentity(pid, meta.process_identity);
     const aliveOwnedRunner = Boolean(pid &&
-        isAlive(pid) &&
-        (!Array.isArray(meta.argv) ||
-            pidMatchesRun(pid, String(meta.cwd ?? ""), stateDir, runnerPath) ||
-            isWithinRunnerIdentityGrace(meta, runnerIdentityGraceMs)));
+        (processIdentity.valid ||
+            (processIdentity.status === "unsupported_proof" &&
+                isWithinRunnerIdentityGrace(meta, runnerIdentityGraceMs))));
     const status = result
         ? Number(result.code ?? 0) === 0
             ? "done"
@@ -35,8 +35,10 @@ export function buildRunStatus(stateDir, runOrDir, meta, readJson, runnerPath, r
     return {
         ...meta,
         eventsFile: join(stateDir, "events.jsonl"),
+        evidenceFile: join(stateDir, "review-evidence.json"),
         inboxFile: join(stateDir, "inbox.jsonl"),
         outboxFile: join(stateDir, "outbox.jsonl"),
+        process_identity_status: processIdentity.status,
         progress: readJson(join(stateDir, "progress.json")) || null,
         result: result || null,
         ...(terminalHandled ? { terminal_handled: terminalHandled } : {}),

package/dist/lib/runtime.js

@@ -4,6 +4,7 @@
  * Owns persisted tool loading, reserved-name guards, runtime registration, and warning notification
  */
 import { existsSync, watch } from "node:fs";
+import { basename, dirname } from "node:path";
 import * as Paths from "./paths.js";
 import * as RecipesDiscovery from "./recipes-discovery.js";
 import * as ToolsLocal from "./tools-local.js";
@@ -126,10 +127,13 @@ export function createAutoToolsRuntime(deps) {
 export function createRecipeToolReloadWatcher(runtime) {
     let reloadTimeout;
     let rootWatcher;
+    let parentWatcher;
     let failureNotified = false;
     const close = () => {
         rootWatcher?.close();
         rootWatcher = undefined;
+        parentWatcher?.close();
+        parentWatcher = undefined;
         if (reloadTimeout)
             clearTimeout(reloadTimeout);
         reloadTimeout = undefined;
@@ -150,23 +154,75 @@ export function createRecipeToolReloadWatcher(runtime) {
         }, 150);
         reloadTimeout.unref?.();
     };
+    const watchParent = (ctx, recipeRoot) => {
+        if (parentWatcher || rootWatcher)
+            return;
+        const parent = dirname(recipeRoot);
+        if (!existsSync(parent)) {
+            notifyFailure(ctx);
+            return;
+        }
+        try {
+            parentWatcher = watch(parent, (_event, changedFile) => {
+                if (changedFile &&
+                    String(changedFile) !== basename(recipeRoot) &&
+                    !existsSync(recipeRoot)) {
+                    return;
+                }
+                if (!existsSync(recipeRoot))
+                    return;
+                parentWatcher?.close();
+                parentWatcher = undefined;
+                watchRoot(ctx, recipeRoot);
+                scheduleReload(ctx);
+            });
+            parentWatcher.on("error", () => {
+                parentWatcher?.close();
+                parentWatcher = undefined;
+                notifyFailure(ctx);
+            });
+        }
+        catch {
+            notifyFailure(ctx);
+        }
+    };
+    const watchRoot = (ctx, recipeRoot) => {
+        if (rootWatcher)
+            return;
+        if (!existsSync(recipeRoot)) {
+            watchParent(ctx, recipeRoot);
+            return;
+        }
+        try {
+            rootWatcher = watch(recipeRoot, () => {
+                if (!existsSync(recipeRoot)) {
+                    rootWatcher?.close();
+                    rootWatcher = undefined;
+                    scheduleReload(ctx);
+                    watchParent(ctx, recipeRoot);
+                    return;
+                }
+                scheduleReload(ctx);
+            });
+            rootWatcher.on("error", () => {
+                rootWatcher?.close();
+                rootWatcher = undefined;
+                if (existsSync(recipeRoot))
+                    notifyFailure(ctx);
+                else
+                    watchParent(ctx, recipeRoot);
+            });
+        }
+        catch {
+            notifyFailure(ctx);
+        }
+    };
     return {
         close,
         watch(ctx) {
-            const recipeRoot = Paths.getRecipeRoot();
-            if (rootWatcher || !existsSync(recipeRoot))
+            if (rootWatcher || parentWatcher)
                 return;
-            try {
-                rootWatcher = watch(recipeRoot, () => scheduleReload(ctx));
-                rootWatcher.on("error", () => {
-                    rootWatcher?.close();
-                    rootWatcher = undefined;
-                    notifyFailure(ctx);
-                });
-            }
-            catch {
-                notifyFailure(ctx);
-            }
+            watchRoot(ctx, Paths.getRecipeRoot());
         },
     };
 }

package/dist/lib/tools-inspect.d.ts

@@ -4,7 +4,9 @@
  * Owns the public inspect execution path and compact observation responses
  */
 export interface InspectToolDeps<TContext = unknown> {
+    getRunStatus?: (runOrDir: string) => Record<string, any>;
     getTool?: (name: string) => any | undefined;
+    listRuns?: () => Array<Record<string, any>>;
     packagedRecipeRoot?: string;
     recipeRoot?: string;
 }

package/dist/lib/tools-inspect.js

@@ -122,6 +122,28 @@ function compactArtifactPath(value) {
     const record = asRecord(value);
     return String(record.path ?? "<missing>");
 }
+function readBoundedReviewEvidence(status, limit) {
+    const evidenceFile = status.evidenceFile;
+    if (typeof evidenceFile !== "string" || !existsSync(evidenceFile))
+        return undefined;
+    try {
+        const manifest = asRecord(JSON.parse(readFileSync(evidenceFile, "utf8")));
+        const commands = Array.isArray(manifest.commands) ? manifest.commands : [];
+        const bounded = commands.slice(-Math.max(1, limit));
+        return {
+            ...manifest,
+            commands: bounded,
+            commands_total: commands.length,
+            ...(bounded.length < commands.length ? { commands_truncated: true } : {}),
+        };
+    }
+    catch {
+        return {
+            status: "invalid",
+            error: "review evidence manifest is unreadable",
+        };
+    }
+}
 function compactActorFiles(status) {
     const run = String(status.run ?? "<unknown>");
     const artifacts = asRecord(status.artifacts);
@@ -130,6 +152,7 @@ function compactActorFiles(status) {
         status.stderrLog,
         status.eventsFile,
         status.outboxFile,
+        status.evidenceFile,
         status.state_dir
             ? `${String(status.state_dir)}/communication.json`
             : undefined,
@@ -268,7 +291,16 @@ function isTriageHighRiskRecipe(recipe) {
 function getPiActorsTriage(ctx, deps) {
     const runtime = getPiActorsRuntimeStatus();
     const currentSession = ToolsAccess.getContextSessionId(ctx);
-    const allRuns = AsyncRuns.listRuns().map((run) => AsyncRuns.getRunStatus(String(run.state_dir)));
+    const listRuns = deps.listRuns ?? AsyncRuns.listRuns;
+    const getRunStatus = deps.getRunStatus ?? AsyncRuns.getRunStatus;
+    const allRuns = listRuns().flatMap((run) => {
+        try {
+            return [getRunStatus(String(run.state_dir))];
+        }
+        catch {
+            return [];
+        }
+    });
     const visibleRuns = currentSession
         ? allRuns.filter((run) => !run.ownerId || run.ownerId === currentSession)
         : allRuns;
@@ -644,13 +676,18 @@ export function createInspectToolDefinition(deps = {}) {
                 case "files": {
                     const status = ToolsAccess.assertRunAccessibleToContext(runId, ctx);
                     const artifactManifest = AsyncRuns.resolveArtifactManifest(status.artifacts);
+                    const reviewEvidence = readBoundedReviewEvidence(status, Number(input.lines || Limits.DEFAULT_INSPECT_LINES));
                     const details = artifactManifest
                         ? {
                             ...status,
+                            ...(reviewEvidence ? { review_evidence: reviewEvidence } : {}),
                             artifact_manifest: artifactManifest,
                             next_actions: ToolsResponse.artifactNextActions(status.run ?? runId, asRecord(status.artifacts)),
                         }
-                        : status;
+                        : {
+                            ...status,
+                            ...(reviewEvidence ? { review_evidence: reviewEvidence } : {}),
+                        };
                     return {
                         content: [
                             {

package/dist/lib/tools-register.js

@@ -26,7 +26,6 @@ export function createRegisterToolDefinition(deps) {
             description: stringSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.description),
             draft: stringSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.draft),
             name: stringSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.name),
-            state_dir: stringSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.state_dir),
             template: unionSchema([
                 stringSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.template),
                 looseObjectSchema(Prompts.REGISTER_TOOL_PARAM_DESCRIPTIONS.template),

package/dist/lib/tools-spawn.js

@@ -94,7 +94,6 @@ export function createSpawnToolDefinition() {
             as: Schema.stringSchema("Optional actor address for the spawned run, e.g. run:<id>."),
             file: Schema.stringSchema("Optional template recipe JSON file. Bare names resolve under ~/.pi/agent/recipes."),
             recipe: Schema.stringSchema("Alias for file; template recipe JSON file/name to spawn."),
-            state_dir: Schema.stringSchema("Optional explicit run state directory."),
             template: Schema.unionSchema([
                 Schema.stringSchema("Inline command template string"),
                 Schema.arraySchema("Inline command-template sequence or parallel tree"),
@@ -105,6 +104,9 @@ export function createSpawnToolDefinition() {
         }, []),
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
             const input = asRecord(params);
+            if (input.state_dir !== undefined) {
+                throw new Error("spawn.state_dir is not supported; run state is runtime-owned so run:<id> remains addressable and retention-safe.");
+            }
             const runId = runIdFromActorAddress(typeof input.as === "string" ? input.as : undefined);
             const recipe = typeof input.file === "string"
                 ? input.file
@@ -118,7 +120,6 @@ export function createSpawnToolDefinition() {
                     launch_source: "spawn",
                     ownerId: getRunOwnerId(ctx),
                     run_id: runId,
-                    state_dir: typeof input.state_dir === "string" ? input.state_dir : undefined,
                     ...(input.template !== undefined
                         ? {
                             template: input.template,

package/dist/lib/tools.d.ts

@@ -18,5 +18,6 @@ export interface CoreActorToolDefinitionDeps<TContext extends RuntimeToolContext
     registryRuntime: Pick<RegisterToolRuntimeDeps<TContext>, "getToolNameBlocker" | "getTools" | "notify" | "registerRuntimeTool">;
     setActiveTools: (toolNames: string[]) => void;
 }
+export declare function resolveActiveRuntimeTool(name: string, activeTools: Pick<Map<string, unknown>, "has">, getDefinition: (name: string) => unknown): unknown;
 export declare const RESERVED_TOOL_NAMES: Set<string>;
 export declare function createCoreActorToolDefinitions<TContext extends RuntimeToolContext>(deps: CoreActorToolDefinitionDeps<TContext>): ActorToolDefinition[];

package/dist/lib/tools.js

@@ -7,6 +7,9 @@ import * as ToolsInspect from "./tools-inspect.js";
 import * as ToolsMessage from "./tools-message.js";
 import * as ToolsRegister from "./tools-register.js";
 import * as ToolsSpawn from "./tools-spawn.js";
+export function resolveActiveRuntimeTool(name, activeTools, getDefinition) {
+    return activeTools.has(name) ? getDefinition(name) : undefined;
+}
 export const RESERVED_TOOL_NAMES = new Set([
     "read",
     "write",

package/dist/pi-actors/index.js

@@ -0,0 +1 @@
+export { default } from "../index.js";

package/dist/recipes/subagent-judge.json

@@ -28,5 +28,6 @@
       "run.failed"
     ]
   },
-  "template": "pi -p --model {model} --thinking {thinking} {tools?--tools:--no-tools} {tools} Judge this report: {report}. Rubric: {rubric}. Evidence: {evidence}. Output format: {output_format}"
+  "accept_output": "review_evidence",
+  "template": "pi -p --model {model} --thinking {thinking} {tools?--tools:--no-tools} {tools} Judge this report: {report}. Rubric: {rubric}. Evidence: {evidence}. Begin the response with ACTOR_REVIEW_RESULT on its own line. Output format: {output_format}"
 }

package/dist/recipes/subagent-merge.json

@@ -30,5 +30,6 @@
       "run.failed"
     ]
   },
-  "template": "pi -p --model {model} --thinking {thinking} {tools?--tools:--no-tools} {tools} Merge these subagent outputs using mode {mode}: {inputs}. Merge policy: {merge_policy}. Risk policy: {risk_policy}. Output format: {output_format}"
+  "accept_output": "review_evidence",
+  "template": "pi -p --model {model} --thinking {thinking} {tools?--tools:--no-tools} {tools} Merge these subagent outputs using mode {mode}: {inputs}. Merge policy: {merge_policy}. Risk policy: {risk_policy}. Begin the response with ACTOR_REVIEW_RESULT on its own line. Output format: {output_format}"
 }

package/dist/recipes/subagent-normalize.json

@@ -26,5 +26,6 @@
       "run.failed"
     ]
   },
-  "template": "pi -p --model {model} --thinking {thinking} {tools?--tools:--no-tools} {tools} Normalize this subagent output. Target format: {format}. Preservation policy: {preservation_policy}. Input: {input}"
+  "accept_output": "review_evidence",
+  "template": "pi -p --model {model} --thinking {thinking} {tools?--tools:--no-tools} {tools} Normalize this subagent output. Begin the response with ACTOR_REVIEW_RESULT on its own line. Target format: {format}. Preservation policy: {preservation_policy}. Input: {input}"
 }

package/dist/recipes/subagent-review-coordinator.json

@@ -174,7 +174,7 @@
       "values": {
         "input": "Use merged and judged output from stdin.",
         "format": "{output_format}",
-        "preservation_policy": "Preserve branch status and explicitly mark Status as complete, degraded, or insufficient_data.",
+        "preservation_policy": "Preserve branch status and explicitly mark Status as complete, degraded, or insufficient_data. Include stable ACTOR_EVIDENCE_REF values from stdin in the Evidence section for every reviewer, verifier, merger, and judge source used. Do not claim complete when any required evidence reference is absent or inconsistent.",
         "model": "{merger_model}",
         "thinking": "{thinking}",
         "tools": "{tools}"

package/dist/recipes/subagent-review.json

@@ -32,5 +32,6 @@
       "run.failed"
     ]
   },
-  "template": "pi -p --model {model} --thinking {thinking} {tools?--tools:--no-tools} {tools} Review {scope} through this lens: {lens}. Instructions: {instructions}. Evidence policy: {evidence_policy}. Risk policy: {risk_policy}. Output format: {output_format}"
+  "accept_output": "review_evidence",
+  "template": "pi -p --model {model} --thinking {thinking} {tools?--tools:--no-tools} {tools} Review {scope} through this lens: {lens}. Instructions: {instructions}. Evidence policy: {evidence_policy}. Risk policy: {risk_policy}. Begin the response with ACTOR_REVIEW_RESULT on its own line. Output format: {output_format}"
 }

package/dist/recipes/subagent-verify.json

@@ -29,5 +29,6 @@
       "run.failed"
     ]
   },
-  "template": "pi -p --model {model} --thinking {thinking} {tools?--tools:--no-tools} {tools} Verify this claim against the provided evidence. Claim: {claim}. Evidence or artifact paths: {evidence}. Acceptance: {acceptance}. Evidence policy: {evidence_policy}. Output format: {output_format}"
+  "accept_output": "review_evidence",
+  "template": "pi -p --model {model} --thinking {thinking} {tools?--tools:--no-tools} {tools} Verify this claim against the provided evidence. Claim: {claim}. Evidence or artifact paths: {evidence}. Acceptance: {acceptance}. Evidence policy: {evidence_policy}. Begin the response with ACTOR_REVIEW_RESULT on its own line. Output format: {output_format}"
 }