@llblab/pi-actors 0.37.1 → 0.38.1

package/BACKLOG.md

@@ -71,4 +71,4 @@ These are valid ideas but not current focus. Reintroduce only with concrete evid
 
 ## Suggested Milestone Order
 
-No current milestone. Reassess runtime evidence before adding the next reliability slice.
+1. Re-curate after the next real packaged review-swarm dogfood run.

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## Unreleased
 
+## 0.38.1: Windows Recipe ACL Hotfix
+
+- `[Registry]` Replaced POSIX mode-bit recipe-root writability checks on Windows with ACL-aware diagnostics, avoiding false `world-writable` and `group-writable` startup warnings from Node's NTFS mode emulation while still flagging broad Windows write grants.
+- `[Tests]` Added portable coverage for broad Windows ACL parsing and skipped the POSIX chmod diagnostic regression on Windows.
+
+## 0.38.0: Review Swarm Pipeline Hardening
+
+- `[Recipes]` Added current model/thinking inheritance for packaged review/lens-swarm recipes through `{current_model}` and `{current_thinking}`, so normal subagent review swarms use the selected Pi session policy by default while explicit args still override it.
+- `[Runtime]` Injected the current Pi model and thinking level into spawn/runtime tool recipe values and fail fast before async fanout when a current placeholder cannot be resolved.
+- `[Runtime]` Persisted `model_policy` provenance in async run status, progress, terminal results, compact status text, and terminal follow-ups so operators can distinguish inherited, explicit, mixed, and unresolved model/thinking policy.
+- `[Runtime]` Materialized child `pi -p` prompts into run-local `prompts/command-NNN.md` files and invoked Pi with `@file` arguments, preserving long quoted prompts and recipe context without fragile inline argv transport.
+- `[Runtime]` Expanded parallel branch diagnostics with stdout/stderr byte counts, tail previews, failure reasons, prompt-file paths, soft-quorum usability, and failed-run result/progress details; branch-failure fanouts now fail when every branch fails or emits empty output.
+- `[Recipes]` Added `subagent-preflight` and wired the review coordinator to run stage model/thinking/tool smoke checks before reviewer fanout, so unavailable providers fail before expensive reviewer branches launch.
+- `[Recipes]` Made review pipelines quorum-aware with `subagent_ttl_ms`, `reviewer_concurrency`, `min_successful_reviewers`, and `merge_policy` knobs; partial reviewer evidence is preserved, verifier/merger stages run only after the evidence threshold is met, and normalized reports must mark `complete`, `degraded`, or `insufficient_data`.
+- `[Diagnostics]` Preflight command failures now emit `ACTOR_PREFLIGHT_FAILED` diagnostics with stage, selected model/thinking, provider error class, prompt file, and suggested override args; fake-`pi` coverage proves reviewer fanout starts only after preflight passes.
+- `[Tests]` Added a deterministic packaged review-readiness dogfood fixture to `npm run conformance`, using a fake local `pi` executable to verify preflight, degraded reviewer fanout, prompt-file artifacts, branch failure capture, merge gating, and terminal status without external model APIs.
+- `[Guidance]` Updated README, actor/swarm skills, recipe docs, async-run docs, and onboarding copy to steer review swarms away from `models.json` rediscovery and toward maintained recipes with current model/thinking inheritance, policy provenance, prompt-file transport, preflight, quorum controls, and inspectable branch diagnostics.
+- `[Backlog]` Captured the remaining `pi-telegram` review-swarm dogfood lessons as concrete `pi-actors` hardening work: review-pipeline preflight/quorum resilience, model-provenance visibility, and a deterministic review-swarm fixture.
+
 ## 0.37.1: Subagent Recipe Prompt Injection Hotfix
 
 - `[Recipes]` Fixed actor recipe context injection for child `pi -p` launches with options after the print flag, so packaged subagent recipes such as `subagent-review` and `pipeline-review-readiness` append context to the actual prompt instead of corrupting `--model` or other option values.

package/README.md

@@ -111,22 +111,23 @@ cat > ~/.pi/agent/recipes/docs_review.json <<'JSON'
 {
   "description": "Start an async docs review actor",
   "async": true,
-  "args": ["scope:path", "model:string"],
+  "args": ["scope:path", "model:string", "thinking:string"],
+  "defaults": { "model": "{current_model}", "thinking": "{current_thinking}" },
   "mailbox": {
     "accepts": ["control.kill", "control.continue"],
     "emits": ["review.completed", "run.failed"]
   },
-  "template": "pi -p --model {model} --no-tools \"Review {scope} for unclear actor-runtime onboarding. Return concise findings.\""
+  "template": "pi -p --model {model} --thinking {thinking} --no-tools \"Review {scope} for unclear actor-runtime onboarding. Return concise findings.\""
 }
 JSON
 ```
 
-Because it lives under `~/.pi/agent/recipes/`, the file becomes a persistent agent tool by location. The filename is the tool id.
+Because it lives under `~/.pi/agent/recipes/`, the file becomes a persistent agent tool by location. The filename is the tool id. `{current_model}` and `{current_thinking}` inherit the selected Pi session model/thinking level; pass `model=...` or `thinking=...` only when a run should intentionally diverge. Run status/progress and terminal follow-ups include `model_policy` provenance so inherited, explicit, and unresolved policy choices stay inspectable.
 
 Start it:
 
 ```text
-docs_review scope="README.md" model="current-review-model" run_id=docs_review
+docs_review scope="README.md" run_id=docs_review
 ```
 
 Inspect only when there is a reason:
@@ -258,7 +259,7 @@ Templates support:
 - Retries, recovery, failure policy, delays, and guarded execution;
 - Async run values such as `{run_id}`, `{state_dir}`, `{actor_address}`, `{default_room}`, and `{communication_file}`.
 
-The template owns execution shape. The recipe owns saved metadata, defaults, imports, mailbox, and artifacts. JSON is the canonical precise recipe format; Markdown recipes use frontmatter plus fenced `template`/`json recipe` blocks for literate authoring and compile into the same model. The run actor owns detached lifecycle, state, messages, cancellation, and inspection. File-backed async recipes also provide child `pi -p` actors with a bounded JSONL recipe context bundle by default, including raw entry/import recipe records and a `"you_are_here": true` marker for the recipe node that launched the child. Set `"actor_context": false` or `"off"` in a recipe to suppress that context for minimal prompts.
+The template owns execution shape. The recipe owns saved metadata, defaults, imports, mailbox, and artifacts. JSON is the canonical precise recipe format; Markdown recipes use frontmatter plus fenced `template`/`json recipe` blocks for literate authoring and compile into the same model. The run actor owns detached lifecycle, state, messages, cancellation, and inspection. File-backed async recipes also provide child `pi -p` actors with a bounded JSONL recipe context bundle by default, including raw entry/import recipe records and a `"you_are_here": true` marker for the recipe node that launched the child; the runner materializes child prompts under `prompts/` and invokes Pi with `@file` arguments. Set `"actor_context": false` or `"off"` in a recipe to suppress that context for minimal prompts.
 
 ## Recipe Library
 

package/dist/index.js

@@ -84,13 +84,33 @@ export default function toolRegistryExtension(pi) {
         onChange: () => activeRunContext && scheduleRunEventUpdate(activeRunContext),
     });
     const actorToolDefinitions = new Map();
+    const withCurrentThinkingContext = (definition) => {
+        if (typeof definition.execute !== "function")
+            return definition;
+        const execute = definition.execute;
+        return {
+            ...definition,
+            execute: (...args) => {
+                const nextArgs = [...args];
+                const ctx = nextArgs[4];
+                if (ctx && typeof ctx === "object") {
+                    nextArgs[4] = {
+                        ...ctx,
+                        getThinkingLevel: () => pi.getThinkingLevel(),
+                    };
+                }
+                return execute(...nextArgs);
+            },
+        };
+    };
     const runtime = Runtime.createAutoToolsRuntime({
         configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
         exec: CommandTemplates.execCommandTemplate,
         getActiveTools: () => pi.getActiveTools(),
         registerTool: (definition) => {
-            actorToolDefinitions.set(definition.name, definition);
-            pi.registerTool(definition);
+            const wrapped = withCurrentThinkingContext(definition);
+            actorToolDefinitions.set(wrapped.name, wrapped);
+            pi.registerTool(wrapped);
         },
         reservedToolNames: Tools.RESERVED_TOOL_NAMES,
         setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
@@ -161,5 +181,5 @@ export default function toolRegistryExtension(pi) {
         getRuntimeTool: (name) => actorToolDefinitions.get(name),
         registryRuntime: runtime,
         setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
-    }));
+    }).map(withCurrentThinkingContext));
 }

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

@@ -3,6 +3,7 @@
  * Owns launch, state observation, listing, message/control facade methods, and retention while runs-* subdomains own narrower run internals.
  */
 import type { CommandTemplateFailureScope, CommandTemplateValue } from "./command-templates.ts";
+import { type CurrentPolicyProvenance } from "./model-context.ts";
 import * as RecipesReferences from "./recipes-references.ts";
 import { type RunArtifactDeclaration } from "./runs-artifacts.ts";
 import { type RunOutboxEvent } from "./runs-outbox.ts";
@@ -28,6 +29,8 @@ export interface AsyncRunStartParams {
     args?: string[];
     defaults?: Record<string, unknown>;
     parallel?: boolean;
+    concurrency?: number | string;
+    min_successful?: number | string;
     label?: string;
     when?: boolean | string;
     timeout?: number | string;
@@ -41,6 +44,7 @@ export interface AsyncRunStartParams {
     recover?: CommandTemplateValue;
     repeat?: number;
     values?: Record<string, unknown>;
+    policy_values?: Record<string, unknown>;
     actor_context?: boolean | string;
     cwd?: string;
 }
@@ -63,6 +67,7 @@ export interface AsyncRunMeta {
     artifacts?: Record<string, RunArtifactDeclaration>;
     control?: AsyncRunControlEndpoint;
     mailbox?: RecipesReferences.TemplateRecipeMailbox;
+    model_policy?: CurrentPolicyProvenance;
     recipe_context_records?: RecipesReferences.TemplateRecipeContextRecord[];
     retire_when?: "children_terminal";
 }

package/dist/lib/async-runs.js

@@ -7,6 +7,7 @@ import { closeSync, existsSync, mkdirSync, openSync, writeFileSync, } from "node
 import { basename, dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { writeJsonAtomic } from "./file-state.js";
+import { CURRENT_MODEL_VALUE_KEY, CURRENT_THINKING_VALUE_KEY, describeCurrentPolicyProvenance, } from "./model-context.js";
 import * as Paths from "./paths.js";
 import * as RecipesReferences from "./recipes-references.js";
 import * as RecipesUsage from "./recipes-usage.js";
@@ -50,6 +51,8 @@ function resolveRunTemplate(params) {
         "args",
         "defaults",
         "parallel",
+        "concurrency",
+        "min_successful",
         "label",
         "when",
         "timeout",
@@ -128,6 +131,74 @@ function resolveStartParams(params) {
 function readJson(path) {
     return readJsonFileResilient(path, undefined).value;
 }
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isFalsyValue(value) {
+    if (value === undefined || value === null || value === false)
+        return true;
+    const normalized = String(value).trim().toLowerCase();
+    return (normalized === "" ||
+        normalized === "0" ||
+        normalized === "false" ||
+        normalized === "no");
+}
+function stringReferencesPlaceholder(value, placeholder) {
+    return new RegExp(`\\{\\s*${placeholder}\\s*\\}`).test(value);
+}
+function collectUnresolvedCurrentPlaceholderReferences(value, values, placeholder, valueKey, path = "template", refs = []) {
+    if (typeof value === "string") {
+        if (stringReferencesPlaceholder(value, placeholder) &&
+            isFalsyValue(values[valueKey])) {
+            refs.push(path);
+        }
+        return refs;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => collectUnresolvedCurrentPlaceholderReferences(item, values, placeholder, valueKey, `${path}[${index}]`, refs));
+        return refs;
+    }
+    if (!isRecord(value))
+        return refs;
+    for (const [key, child] of Object.entries(value)) {
+        if (key === "defaults" && isRecord(child)) {
+            for (const [defaultKey, defaultValue] of Object.entries(child)) {
+                if (typeof defaultValue === "string" &&
+                    stringReferencesPlaceholder(defaultValue, placeholder) &&
+                    isFalsyValue(values[defaultKey]) &&
+                    isFalsyValue(values[valueKey])) {
+                    refs.push(`${path}.defaults.${defaultKey}`);
+                }
+            }
+            continue;
+        }
+        collectUnresolvedCurrentPlaceholderReferences(child, values, placeholder, valueKey, `${path}.${key}`, refs);
+    }
+    return refs;
+}
+function assertCurrentPlaceholderReferencesResolved(template, defaults, values, modelPolicy) {
+    const checks = [
+        {
+            label: "model",
+            placeholder: "current_model",
+            valueKey: CURRENT_MODEL_VALUE_KEY,
+        },
+        {
+            label: "thinking level",
+            placeholder: "current_thinking",
+            valueKey: CURRENT_THINKING_VALUE_KEY,
+        },
+    ];
+    for (const check of checks) {
+        const refs = collectUnresolvedCurrentPlaceholderReferences(template, values, check.placeholder, check.valueKey);
+        if (defaults) {
+            collectUnresolvedCurrentPlaceholderReferences({ defaults }, values, check.placeholder, check.valueKey, "recipe", refs);
+        }
+        if (refs.length === 0)
+            continue;
+        throw Object.assign(new Error(`Template recipe requires the current Pi ${check.label} for inheritance, but no current ${check.label} was available. Pass explicit values or launch from a Pi session with a selected ${check.label}. unresolved=${refs.slice(0, 4).join(",")}`), { model_policy: modelPolicy });
+    }
+}
 function acquireStateStartLock(stateDir) {
     return RunsStart.acquireStateStartLock(stateDir);
 }
@@ -139,6 +210,20 @@ export function startRun(params, cwd) {
     const resolved = resolveRunTemplate(startParams);
     const run = safeRunId(startParams.run_id);
     const stateDir = resolveStateDir(startParams, run);
+    const values = {
+        ...(startParams.values || {}),
+        actor_address: `run:${run}`,
+        communication_file: join(stateDir, "communication.json"),
+        default_room: `room:${run}`,
+        run_id: run,
+        state_dir: stateDir,
+    };
+    const modelPolicy = describeCurrentPolicyProvenance({
+        defaults: startParams.defaults,
+        template: resolved.template,
+        values: startParams.policy_values ?? startParams.values ?? {},
+    });
+    assertCurrentPlaceholderReferencesResolved(resolved.template, startParams.defaults, values, modelPolicy);
     assertNoActiveRunState(stateDir);
     mkdirSync(stateDir, { recursive: true });
     const releaseStartLock = acquireStateStartLock(stateDir);
@@ -162,14 +247,6 @@ export function startRun(params, cwd) {
         const outFd = openSync(stdout, "a");
         const errFd = openSync(stderr, "a");
         const argv = asyncRunnerArgv(stateDir);
-        const values = {
-            ...(startParams.values || {}),
-            actor_address: `run:${run}`,
-            communication_file: join(stateDir, "communication.json"),
-            default_room: `room:${run}`,
-            run_id: run,
-            state_dir: stateDir,
-        };
         const outputValues = {
             ...(startParams.defaults || {}),
             ...values,
@@ -192,6 +269,7 @@ export function startRun(params, cwd) {
             ...(startParams.tool ? { tool: startParams.tool } : {}),
             template: resolved.template,
             values,
+            model_policy: modelPolicy,
             ...(artifacts ? { artifacts } : {}),
             ...(startParams.control ? { control: startParams.control } : {}),
             ...(startParams.mailbox ? { mailbox: startParams.mailbox } : {}),
@@ -215,6 +293,7 @@ export function startRun(params, cwd) {
         writeJsonAtomic(join(stateDir, "progress.json"), {
             completed: 0,
             failures: [],
+            model_policy: modelPolicy,
             phase: "starting",
             updatedAt: new Date().toISOString(),
         });

package/dist/lib/command-templates.d.ts

@@ -15,6 +15,8 @@ export interface CommandTemplateObjectConfig {
     actorRecipeContext?: CommandTemplateActorRecipeContext;
     label?: string;
     parallel?: boolean;
+    concurrency?: number | string;
+    min_successful?: number | string;
     when?: boolean | string;
     template?: CommandTemplateValue;
     args?: string[];

package/dist/lib/execution.d.ts

@@ -22,10 +22,13 @@ export interface ToolExecResult {
 export interface BranchReport {
     code: number;
     command: string;
+    failureReason?: string;
     killed: boolean;
     label: string;
     status: "done" | "failed" | "timeout";
     stderr?: string;
+    stderrBytes: number;
+    stdout?: string;
     stdoutBytes: number;
 }
 export interface SoftQuorumReport {
@@ -53,6 +56,7 @@ export interface RegisteredToolExecutionResult {
             killed: boolean;
         }>;
         softQuorum?: SoftQuorumReport;
+        failureReason?: string;
         template: CommandTemplates.CommandTemplateValue;
         templateWarnings?: string[];
         tool: string;

package/dist/lib/execution.js

@@ -37,6 +37,15 @@ function formatInvocationDetail(invocation) {
 function formatCommandDetail(commands) {
     return commands.length === 1 ? commands[0] : commands.join(" && ");
 }
+function getExecutionFailureReason(branches, softQuorum, stderr) {
+    if (/parallel branch quorum not met/.test(stderr)) {
+        return "parallel_quorum_not_met";
+    }
+    if (branches.length > 0 && softQuorum?.usable === false) {
+        return "all_branches_unusable";
+    }
+    return "command_failed";
+}
 function mergeDefaults(inherited, own) {
     if (!inherited && !own)
         return undefined;
@@ -53,17 +62,32 @@ function getBranchStatus(result) {
         return "done";
     return result.killed ? "timeout" : "failed";
 }
+function getBranchFailureReason(result) {
+    if (result.code === 0) {
+        return result.stdout.trim() ? undefined : "empty_output";
+    }
+    if (result.killed)
+        return "timeout_or_killed";
+    return result.stderr.trim() ? "nonzero_exit" : "nonzero_exit_empty_stderr";
+}
 function createBranchReport(label, command, result) {
+    const failureReason = getBranchFailureReason(result);
     return {
         code: result.code,
         command,
+        ...(failureReason ? { failureReason } : {}),
         killed: result.killed,
         label,
         status: getBranchStatus(result),
-        ...(result.stderr ? { stderr: result.stderr.slice(0, 1000) } : {}),
+        ...(result.stderr ? { stderr: result.stderr.slice(-1000) } : {}),
+        stderrBytes: Buffer.byteLength(result.stderr),
+        ...(result.stdout ? { stdout: result.stdout.slice(-1000) } : {}),
         stdoutBytes: Buffer.byteLength(result.stdout),
     };
 }
+function isUsableBranch(branch) {
+    return branch.status === "done" && branch.stdoutBytes > 0;
+}
 function createSoftQuorum(branches) {
     if (branches.length === 0)
         return undefined;
@@ -75,9 +99,12 @@ function createSoftQuorum(branches) {
         done,
         expected: branches.length,
         failed,
-        usable: done > 0,
+        usable: branches.some(isUsableBranch),
     };
 }
+function countUsableBranches(branches) {
+    return branches.filter(isUsableBranch).length;
+}
 function getMaxParallelBranches() {
     const raw = Number(process.env.PI_ACTORS_MAX_PARALLEL_BRANCHES ?? "");
     return Number.isInteger(raw) && raw > 0 ? raw : DEFAULT_MAX_PARALLEL_BRANCHES;
@@ -111,6 +138,24 @@ function normalizeRetry(value, values) {
         throw new Error("Command template retry must be a positive integer.");
     return resolved;
 }
+function normalizeConcurrency(value, values, branchCount) {
+    const resolved = resolveNumericControlField(value, values, "concurrency");
+    if (resolved === undefined)
+        return branchCount;
+    if (!Number.isInteger(resolved) || resolved < 1)
+        throw new Error("Command template concurrency must be a positive integer.");
+    return Math.min(resolved, branchCount);
+}
+function normalizeMinSuccessful(value, values, branchCount) {
+    const resolved = resolveNumericControlField(value, values, "min_successful");
+    if (resolved === undefined)
+        return undefined;
+    if (!Number.isInteger(resolved) || resolved < 0)
+        throw new Error("Command template min_successful must be a non-negative integer.");
+    if (resolved > branchCount)
+        throw new Error(`Command template min_successful ${resolved} exceeds branch count ${branchCount}.`);
+    return resolved;
+}
 function getRecoverConfig(config) {
     const recovered = Array.isArray(config) ? { template: config } : config;
     const normalized = CommandTemplates.normalizeCommandTemplateConfig(recovered);
@@ -174,8 +219,20 @@ async function applyDelay(delay, values, signal) {
         return;
     await sleep(resolved, signal);
 }
-function joinParallelStdout(branches, results) {
-    return results
+function getParallelStatus(branches, minSuccessful) {
+    const usable = countUsableBranches(branches);
+    if (minSuccessful !== undefined && usable < minSuccessful) {
+        return "insufficient_data";
+    }
+    return branches.every(isUsableBranch) ? "complete" : "degraded";
+}
+function formatParallelStatusHeader(branches, minSuccessful) {
+    if (minSuccessful === undefined)
+        return undefined;
+    return `--- parallel_status: ${getParallelStatus(branches, minSuccessful)} usable: ${countUsableBranches(branches)} expected: ${branches.length} minimum: ${minSuccessful} ---`;
+}
+function joinParallelStdout(branches, results, minSuccessful) {
+    const body = results
         .map((result, index) => {
         const branch = branches[index];
         const header = `--- branch: ${branch.label} status: ${branch.status} ---`;
@@ -185,6 +242,24 @@ function joinParallelStdout(branches, results) {
         return `${header}\nexit: ${branch.code}${stderr}`;
     })
         .join("\n");
+    return [formatParallelStatusHeader(branches, minSuccessful), body]
+        .filter(Boolean)
+        .join("\n");
+}
+async function mapConcurrent(items, concurrency, fn) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function worker() {
+        for (;;) {
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= items.length)
+                return;
+            results[index] = await fn(items[index], index);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+    return results;
 }
 async function executeRetriableTemplateConfig(normalized, inherited, params, exec, cwd, signal, stdin, isRoot, actorRecipeContext) {
     const maxAttempts = normalizeRetry(normalized.retry, {
@@ -270,7 +345,17 @@ async function executeTemplateConfig(config, inherited, params, exec, cwd, signa
                 },
             };
         });
-        return executeTemplateConfig({ parallel: normalized.parallel === true, template: repeatedSteps }, context, params, exec, cwd, signal, stdin, isRoot, actorRecipeContext);
+        return executeTemplateConfig({
+            parallel: normalized.parallel === true,
+            ...(normalized.concurrency !== undefined
+                ? { concurrency: normalized.concurrency }
+                : {}),
+            ...(normalized.min_successful !== undefined
+                ? { min_successful: normalized.min_successful }
+                : {}),
+            ...(normalized.failure !== undefined ? { failure: normalized.failure } : {}),
+            template: repeatedSteps,
+        }, context, params, exec, cwd, signal, stdin, isRoot, actorRecipeContext);
     }
     if (normalized.retry !== undefined &&
         (Array.isArray(normalized.template) || normalized.recover !== undefined)) {
@@ -310,10 +395,17 @@ async function executeTemplateConfig(config, inherited, params, exec, cwd, signa
         throw new Error(formatToolText("Tool template produced no command steps."));
     if (normalized.parallel === true) {
         assertParallelBranchLimit(steps.length);
-        const branchResults = await Promise.all(steps.map((step) => executeTemplateConfig(step, context, params, exec, cwd, signal, stdin, false, actorRecipeContext)));
+        const concurrency = normalizeConcurrency(normalized.concurrency, controlValues, steps.length);
+        const minSuccessful = normalizeMinSuccessful(normalized.min_successful, controlValues, steps.length);
+        const branchResults = await mapConcurrent(steps, concurrency, (step) => executeTemplateConfig(step, context, params, exec, cwd, signal, stdin, false, actorRecipeContext));
         const commands = branchResults.flatMap((item) => item.commands);
         const failures = branchResults.flatMap((item) => item.failures);
         const branches = branchResults.map((item, index) => createBranchReport(getNodeLabel(steps[index], index), item.commands.at(-1) ?? "<template>", item.result));
+        const usableBranches = countUsableBranches(branches);
+        const quorumUnmet = minSuccessful !== undefined && usableBranches < minSuccessful;
+        const quorumFailureMessage = quorumUnmet
+            ? `parallel branch quorum not met: usable ${usableBranches}/${branches.length}, minimum ${minSuccessful}`
+            : "";
         const nodeFailure = getFailureScope(normalized);
         const rootFailure = branchResults.find((item, index) => {
             if (item.result.code === 0)
@@ -335,6 +427,7 @@ async function executeTemplateConfig(config, inherited, params, exec, cwd, signa
             };
         }
         const firstFailedBranch = branchResults.find((item) => item.result.code !== 0);
+        const allBranchesUnusable = branches.every((branch) => !isUsableBranch(branch));
         const successful = branchResults.map((item) => {
             if (item.result.code === 0)
                 return item.result;
@@ -348,9 +441,31 @@ async function executeTemplateConfig(config, inherited, params, exec, cwd, signa
                 .map((item) => item.stderr)
                 .filter(Boolean)
                 .join("\n"),
-            stdout: joinParallelStdout(branches, successful),
+            stdout: joinParallelStdout(branches, successful, minSuccessful),
         };
-        if (firstFailedBranch && nodeFailure === "branch") {
+        if (quorumUnmet && nodeFailure === "root") {
+            return {
+                commands,
+                branches: [
+                    ...branchResults.flatMap((item) => item.branches),
+                    ...branches,
+                ],
+                criticalFailure: true,
+                failureScope: "root",
+                failures,
+                result: {
+                    ...result,
+                    code: firstFailedBranch?.result.code || 1,
+                    stderr: [result.stderr, quorumFailureMessage]
+                        .filter(Boolean)
+                        .join("\n"),
+                },
+            };
+        }
+        const branchFailureTriggered = minSuccessful === undefined
+            ? firstFailedBranch || allBranchesUnusable
+            : quorumUnmet;
+        if (branchFailureTriggered && nodeFailure === "branch") {
             return {
                 commands,
                 branches: [
@@ -359,7 +474,19 @@ async function executeTemplateConfig(config, inherited, params, exec, cwd, signa
                 ],
                 failureScope: "branch",
                 failures,
-                result: { ...result, code: firstFailedBranch.result.code || 1 },
+                result: {
+                    ...result,
+                    code: firstFailedBranch?.result.code || 1,
+                    stderr: [
+                        result.stderr,
+                        allBranchesUnusable
+                            ? "all parallel branches failed or produced empty output"
+                            : "",
+                        quorumFailureMessage,
+                    ]
+                        .filter(Boolean)
+                        .join("\n"),
+                },
             };
         }
         return {
@@ -421,9 +548,25 @@ export async function executeRegisteredTool(cfg, params, exec, cwd, signal) {
     const executed = await executeTemplateSteps(cfg, Schema.normalizeRuntimeValues(params, cfg.argTypes), exec, cwd, signal);
     const command = formatCommandDetail(executed.commands);
     const result = executed.result;
+    const softQuorum = createSoftQuorum(executed.branches);
     if (result.code !== 0) {
         const formatted = formatFailureOutput(cfg.name, result.code, result.killed, result.stdout, result.stderr);
-        throw new Error(formatted.text);
+        throw Object.assign(new Error(formatted.text), {
+            details: {
+                branches: executed.branches,
+                code: result.code,
+                command,
+                killed: result.killed,
+                ...(executed.failures.length > 0
+                    ? { nonCriticalFailures: executed.failures }
+                    : {}),
+                ...(softQuorum ? { softQuorum } : {}),
+                failureReason: getExecutionFailureReason(executed.branches, softQuorum, result.stderr),
+                template: cfg.template,
+                tool: cfg.name,
+                truncated: formatted.truncated,
+            },
+        });
     }
     const formatted = formatOutput(cfg.name, "stdout", result.stdout);
     const templateWarnings = CommandTemplates.getCommandTemplateWarnings(createTemplateConfig(cfg));
@@ -438,9 +581,7 @@ export async function executeRegisteredTool(cfg, params, exec, cwd, signal) {
             ...(executed.failures.length > 0
                 ? { nonCriticalFailures: executed.failures }
                 : {}),
-            ...(createSoftQuorum(executed.branches)
-                ? { softQuorum: createSoftQuorum(executed.branches) }
-                : {}),
+            ...(softQuorum ? { softQuorum } : {}),
             template: cfg.template,
             ...(templateWarnings.length > 0 ? { templateWarnings } : {}),
             tool: cfg.name,

package/dist/lib/model-context.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Current model/thinking propagation helpers
+ * Zones: pi session context, recipe inheritance
+ * Owns current model/thinking extraction from Pi tool contexts and implicit command-template values.
+ */
+export interface CurrentModelContext {
+    currentThinking?: unknown;
+    getThinkingLevel?: () => unknown;
+    model?: {
+        id?: unknown;
+        modelId?: unknown;
+        provider?: unknown;
+    };
+    sessionManager?: {
+        getBranch?: () => unknown[];
+        getSessionId?: () => string;
+    };
+    thinkingLevel?: unknown;
+}
+export declare const CURRENT_MODEL_VALUE_KEY = "current_model";
+export declare const CURRENT_THINKING_VALUE_KEY = "current_thinking";
+export type CurrentPolicySource = "explicit" | "inherited" | "mixed" | "unresolved" | "unused";
+export interface CurrentPolicyAxisProvenance {
+    explicit_keys?: string[];
+    inherited_keys?: string[];
+    source: CurrentPolicySource;
+    unresolved_keys?: string[];
+    value?: string;
+}
+export interface CurrentPolicyProvenance {
+    model: CurrentPolicyAxisProvenance;
+    thinking: CurrentPolicyAxisProvenance;
+}
+export interface CurrentPolicyRecipeSummary {
+    model?: {
+        inherited_defaults?: string[];
+        public_args?: string[];
+    };
+    thinking?: {
+        inherited_defaults?: string[];
+        public_args?: string[];
+    };
+}
+export declare function getCurrentModelPattern(ctx: CurrentModelContext | undefined): string | undefined;
+export declare function getCurrentThinkingLevel(ctx: CurrentModelContext | undefined): string | undefined;
+export declare function withCurrentModelValues<T extends Record<string, unknown>>(values: T, ctx: CurrentModelContext | undefined): T & Record<string, unknown>;
+export declare function describeCurrentPolicyProvenance(input: {
+    defaults?: Record<string, unknown>;
+    template: unknown;
+    values?: Record<string, unknown>;
+}): CurrentPolicyProvenance;
+export declare function describeRecipeCurrentPolicy(input: {
+    args?: unknown;
+    defaults?: Record<string, unknown>;
+    template: unknown;
+}): CurrentPolicyRecipeSummary | undefined;