@llblab/pi-actors 0.37.1 → 0.38.0

package/dist/skills/actors/SKILL.md

@@ -2,7 +2,7 @@
 name: actors
 description: Required practical guide for non-trivial pi-actors use. Read before using or changing spawn, message, inspect, actor runs, tools, recipes, command templates, async lifecycle, mailboxes, artifacts, and local orchestration mechanics.
 metadata:
-  version: 0.37.1
+  version: 0.38.0
 ---
 
 # Actors (pi-actors)
@@ -199,9 +199,9 @@ Rules:
 7. Declare `mailbox` for actors that accept or emit meaningful messages.
 8. Declare `artifacts` for durable outputs the coordinator should inspect.
 9. File-backed recipe identity comes from the filename basename; legacy top-level `name` fields are ignored by loaders.
-10. File-backed async recipes pass child `pi -p` actors a bounded JSONL recipe context bundle by default: raw entry/import recipe records, derived `name`, import path/alias, and `"you_are_here": true` on the launching recipe node. Set `"actor_context": false` or `"off"` to suppress it for minimal prompts.
+10. File-backed async recipes pass child `pi -p` actors a bounded JSONL recipe context bundle by default: raw entry/import recipe records, derived `name`, import path/alias, and `"you_are_here": true` on the launching recipe node. The runner materializes child prompts under `prompts/command-NNN.md` and invokes Pi with `@file` args so large prompts and recipe context stay inspectable and argv-safe. Set `"actor_context": false` or `"off"` to suppress recipe context for minimal prompts.
 11. Keep packaged recipes generic: no machine-local paths, no private companion identities, no project-specific defaults unless the recipe is explicitly project-specific.
-12. Do not ship concrete model-version defaults in packaged recipes; expose `model`, `models`, and stage-specific model args so the caller must choose current policy at launch.
+12. Do not ship concrete model-version defaults in packaged recipes. For review-oriented subagent/lens recipes, default model/thinking args through `{current_model}` and `{current_thinking}` so they inherit the selected Pi session policy; keep `model`, `models`, `thinking`, and stage-specific model args explicit so callers can override policy at launch.
 
 Priority for same-id recipes:
 
@@ -284,7 +284,7 @@ The user recipe root is the default tool set by location. It accepts canonical J
 
 Use packaged recipes by name with `spawn file=<name>` for async actors, or register/call them as tools when repeated use deserves a stable shortcut.
 
-Packaged review recipes are directly spawnable. Use `spawn file="pipeline-review-readiness" values={...}` for readiness review or `spawn file="subagent-review" values={...}` for one reviewer; pass model/thinking/tool policy through values, then inspect the run. Do not recreate their script commands, call packaged scripts directly, or create wrapper recipes just to launch the maintained recipe.
+Packaged review recipes are directly spawnable. Use `spawn file="pipeline-review-readiness" values={...}` for readiness review or `spawn file="subagent-review" values={...}` for one reviewer; pass model/thinking/tool policy through values, then inspect the run. Review coordinators preflight stage models before fanout; `ACTOR_PREFLIGHT_FAILED` diagnostics identify the failed stage, selected policy, provider error class, prompt file, and override args. Quorum-aware review fanout exposes `subagent_ttl_ms`, `reviewer_concurrency`, `min_successful_reviewers`, and `merge_policy`; partial reviewer evidence is preserved and marked `complete`, `degraded`, or `insufficient_data`. Run status/progress exposes `model_policy` so inherited vs explicit model/thinking choices remain visible. Do not recreate their script commands, call packaged scripts directly, or create wrapper recipes just to launch the maintained recipe.
 
 - [`pipeline-room-swarm`](../../recipes/pipeline-room-swarm.json): room-visible swarm coordination with roles, rounds, optional locker, artifact synthesis, and `subagent_ttl_ms` for hard participant budgets.
 - [`pipeline-repo-health`](../../recipes/pipeline-repo-health.json): git/doc/validation evidence → normalized repository health report.

package/dist/skills/swarm/SKILL.md

@@ -2,7 +2,7 @@
 name: swarm
 description: Subagent orchestration with scoped locks and quorum consensus. Use for multi-model review, parallel scoped work, delegated audit, and coordinated subagent execution.
 metadata:
-  version: 0.37.1
+  version: 0.38.0
 ---
 
 # Swarm
@@ -162,7 +162,7 @@ Use [`references/development-swarm.md`](./references/development-swarm.md) for c
 
 Purpose: turn one result into many risk lenses and a decision-grade verdict.
 
-Use lens swarm for broad coverage, quorum for confidence on one critical judgement, or both for high-stakes releases. The final report should separate consensus findings, minority findings, merger findings, risks, and recommended next actions.
+Use lens swarm for broad coverage, quorum for confidence on one critical judgement, or both for high-stakes releases. In adapters that expose current session model/thinking policy, default ordinary same-policy review swarms to that current policy and require explicit args only when intentionally varying models or thinking levels. Run a cheap model/tool preflight before launching expensive reviewer fanout; if it fails, use the `ACTOR_PREFLIGHT_FAILED` stage/model/error-class/prompt-file diagnostic to choose explicit override args instead of rerunning blindly. For packaged review swarms, tune `min_successful_reviewers`, `reviewer_concurrency`, `subagent_ttl_ms`, and `merge_policy` instead of manual reruns; preserve partial reports and label the outcome `complete`, `degraded`, or `insufficient_data`. The final report should separate consensus findings, minority findings, merger findings, risks, and recommended next actions.
 
 A review swarm synthesis must not fabricate claims. Every final finding should trace to a reviewer note, checked artifact, command output, source, or explicit merger rationale. Devil's Advocate critical findings must be preserved or explicitly disproved with evidence.
 

package/docs/async-runs.md

@@ -87,10 +87,11 @@ Use ordinary files under the extension temp directory so status tools stay simpl
 
 - `run.json`: pid, optional source metadata (`launch_source`, `tool`, `recipe`, `recipe_file`), command-template config, cwd, coordinator owner id, values, named `artifacts`, mailbox metadata, created time, and state dir.
 - `communication.json`: compact actor communication snapshot with self/root/parent, default-room, member, and contact hints for room-aware scripts and agents.
-- `progress.json`: phase, active command count, completed count, failures, and updated time.
+- `progress.json`: phase, active command count, completed count, failures, updated time, and optional `model_policy` provenance for inherited/explicit model and thinking values.
 - `events.jsonl`: append-only implementation lifecycle log.
 - `outbox.jsonl`: implementation storage for actor-message envelopes used by `inspect view=messages`, coordinator notifications, or follow-up context. Coordinator follow-ups preserve bounded `body` previews plus message metadata for decision points.
 - `stdout.log` and `stderr.log`: detached process output.
+- `prompts/command-NNN.md`: state-owned prompt files materialized for child `pi -p` commands so long prompts and appended recipe context travel as `@file` arguments instead of fragile inline argv text.
 - `result.json`: final code, killed flag, output selector, and optional full-output path.
 
 For pi-actors, actor run state defaults to:
@@ -109,6 +110,7 @@ State files use this shape:
 ~/.pi/agent/tmp/pi-actors/runs/<run>/outbox.jsonl
 ~/.pi/agent/tmp/pi-actors/runs/<run>/stdout.log
 ~/.pi/agent/tmp/pi-actors/runs/<run>/stderr.log
+~/.pi/agent/tmp/pi-actors/runs/<run>/prompts/command-001.md
 ~/.pi/agent/tmp/pi-actors/runs/<run>/result.json
 ```
 

package/docs/command-templates.md

@@ -50,6 +50,8 @@ Common object fields:
 
 - `label`: Optional human label for diagnostics and parallel branch reports.
 - `parallel`: Optional boolean for array templates. Default is `false` for sequence; `true` runs children concurrently.
+- `concurrency`: Optional positive integer cap for a `parallel: true` node. Omit it to launch all children at once.
+- `min_successful`: Optional non-negative integer evidence threshold for a `parallel: true` node. Usable branches are successful branches with non-empty stdout; joins include a `parallel_status` header when this is set.
 - `when`: Optional node guard. A false guard skips the node; strings may be `flag`, `!flag`, or `{flag?yes:no}` style expressions.
 - `args`: Optional placeholder declarations. Untyped names remain valid; compact typed forms such as `file:path`, `request_timeout:int`, `speed:number`, `dry_run:bool`, `prompts:array`, and `mode:enum(check,fix)` are valid when the host supports typed tool schemas. Defaults belong in `defaults` or inline placeholder defaults; hosts may normalize interactive shorthand such as `request_timeout:int=60000` before persistence.
 - `defaults`: Placeholder default values by name.
@@ -187,6 +189,7 @@ Composition rules:
 - Skipped nodes preserve current stdin/stdout flow and do not execute commands
 - Each parallel child receives the same stdin, and child stdout values are joined in stable array order before flowing to the next sequence leaf
 - Parallel branch joins include branch label and status, and tool details include branch metadata plus coverage summary
+- `min_successful` adds a join header with `complete`, `degraded`, or `insufficient_data`; with `failure: "branch"` or `"root"`, an unmet threshold fails at that scope
 - Each leaf still applies its own inline defaults
 
 ```json
@@ -398,7 +401,7 @@ string           → leaf command
 string[]         → sequential composition
 { template }     → leaf command object
 { parallel, template } → sequence or parallel subtree
-{ parallel, when, args, defaults, delay, retry, failure, recover, output, template } → full node
+{ parallel, concurrency, min_successful, when, args, defaults, delay, retry, failure, recover, output, template } → full node
 ```
 
 Start with a string. Add composition when needed. Add `parallel: true` when independent work can run concurrently. Add `when` when a node is conditional. Add delay when launch pacing matters. Add retry when flaky. Add `failure` when propagation scope matters. Add `recover` when a retried node needs cleanup before another attempt. Same contract, growing capability, no dead weight.

package/docs/recipe-library.md

@@ -29,6 +29,7 @@ Core subagent recipes:
 - `recipes/subagent-prompt.json`: Start one prompt-driven subagent.
 - `recipes/subagent-tools.json`: Start a subagent with an explicit tool allowlist.
 - `recipes/subagents-prompts.json`: Run prompt fanout with one imported subagent component.
+- `recipes/subagent-preflight.json`: Tiny model/thinking/tool-policy smoke check before expensive fanout; failures surface `ACTOR_PREFLIGHT_FAILED` with stage, selected policy, provider error class, prompt file, and override args.
 - `recipes/subagent-review.json`: Evidence-grounded review lens.
 - `recipes/subagent-critic.json`: Assumption and failure-mode critique.
 - `recipes/subagent-plan.json`: Bounded plan slices and validation gates.
@@ -46,7 +47,7 @@ Core subagent recipes:
 - `recipes/subagent-followup.json`: Same-context or degraded continuation.
 - `recipes/subagent-judge.json`: Post-merge/report quality judge.
 
-Most atoms expose policy knobs such as `model`, `thinking`, `tools`, `output_format`, `evidence_policy`, `risk_policy`, source policy, continuity policy, handoff format, or model pools. Packaged recipes intentionally do not ship concrete model-version defaults: callers must pass current model policy at launch, which keeps reusable recipe components from aging around old provider aliases. The generic prompt launchers, including `subagent-tools` and `subagents-prompts`, expose the same core model/thinking/tool/output knobs so callers do not need separate recipe families for policy tuning. Interactive async atoms also declare mailbox metadata for their basic control, completion, and domain-result message surface. Higher-level recipes pass these knobs through instead of hard-coding local policy.
+Most atoms expose policy knobs such as `model`, `thinking`, `tools`, `output_format`, `evidence_policy`, `risk_policy`, source policy, continuity policy, handoff format, or model pools. Packaged recipes intentionally do not ship concrete model-version defaults: review-oriented subagent and lens-swarm recipes default model/thinking args through `{current_model}` and `{current_thinking}` so they inherit the selected Pi session policy, and callers can still pass explicit values when a run should diverge. Recipe inspection marks these inherited policy defaults as `current_policy`, and run status/progress records whether launch policy was inherited, explicit, mixed, or unresolved. Generic prompt launchers, including `subagent-tools` and `subagents-prompts`, expose the same core model/thinking/tool/output knobs so callers do not need separate recipe families for policy tuning. Interactive async atoms also declare mailbox metadata for their basic control, completion, and domain-result message surface. Higher-level recipes pass these knobs through instead of hard-coding local policy.
 
 For one-off packaged subagent reviews, launch the recipe directly with `spawn file="subagent-review" values={...}` or `spawn file="pipeline-review-readiness" values={...}`. Do not copy the underlying `pi -p` command or wrap the recipe unless you are creating a durable operator tool with a narrower interface.
 
@@ -73,7 +74,7 @@ inspect target=run:docs_review view=tail
 Pipeline recipes demonstrate second-order composition:
 
 - `recipes/coordinator-locker.json`: Long-lived coordinator cell with queue, acquire/renew/release lease locks, journal, actor messages for worker coordination, and platform-adapted control metadata.
-- `recipes/subagent-review-coordinator.json`: Lens reviewers → verifier → merger → judge → normalizer.
+- `recipes/subagent-review-coordinator.json`: Model/tool preflight with compact provider diagnostics → quorum-aware lens reviewers → verifier → merger → judge → normalizer. Review pipelines expose `subagent_ttl_ms`, `reviewer_concurrency`, `min_successful_reviewers`, and `merge_policy` knobs; reviewer joins preserve partial evidence and mark `complete`, `degraded`, or `insufficient_data`. `npm run conformance` includes a fake-`pi` review-readiness dogfood fixture for this packaged path.
 - `recipes/pipeline-release-readiness.json`: Task-first release cell: changelog section → package summary → packaged skill summary → validation → release review → artifact report.
 - `recipes/pipeline-release-summary.json`: Evidence-only release summary cell: changelog section → package summary → packaged skill summary → validation → release summary / risks / PR body draft artifact. It does not commit, open a PR, merge, tag, publish, or perform external release side effects.
 - `recipes/pipeline-repo-health.json`: Task-first repository-health cell: git status/log → docs index → validation → normalized artifact report.

package/docs/template-recipes.md

@@ -208,7 +208,7 @@ Top-level command-template flags may sit beside recipe metadata such as `async`:
 }
 ```
 
-Valid command-template flags include `args`, `defaults`, `parallel`, `when`, `label`, `timeout`, `delay`, `output`, `retry`, `failure`, `recover`, and `repeat`.
+Valid command-template flags include `args`, `defaults`, `parallel`, `concurrency`, `min_successful`, `when`, `label`, `timeout`, `delay`, `output`, `retry`, `failure`, `recover`, and `repeat`.
 
 Timeout is disabled by default. Set a positive `timeout` when a recipe should fail closed after a bounded runtime; omit it, or set `0`, for intentionally open-ended runs that will be stopped by async cancellation, such as background audio playback.
 
@@ -260,7 +260,7 @@ If a tool recipe contains `async: true`, calling the tool starts a detached acto
 
 ## Values And Public Args
 
-Recipe placeholders come from runtime values, recipe `defaults`, inline placeholder defaults, and registered-tool defaults.
+Recipe placeholders come from runtime values, recipe `defaults`, inline placeholder defaults, and registered-tool defaults. Pi tool launches also inject `{current_model}` and `{current_thinking}` when the active session exposes a selected model and thinking level; recipes that require those placeholders fail before fanout when the current value is unavailable unless the caller supplies an explicit override such as `model` or `thinking`. Async runs persist `model_policy` provenance in run status, progress, and terminal results so operators can tell whether model/thinking values were inherited, explicit, mixed, or unresolved.
 
 Recipe tools derive public arguments from the referenced or co-located command template when the recipe is available locally. Explicit `args` is still available when the public tool surface should be narrower than the recipe internals.
 

package/index.ts

@@ -102,13 +102,34 @@ export default function toolRegistryExtension(pi: Pi.ExtensionAPI) {
       activeRunContext && scheduleRunEventUpdate(activeRunContext),
   });
   const actorToolDefinitions = new Map<string, Tools.ActorToolDefinition>();
+  const withCurrentThinkingContext = <T extends Tools.ActorToolDefinition>(
+    definition: T,
+  ): T => {
+    if (typeof definition.execute !== "function") return definition;
+    const execute = definition.execute as (...args: unknown[]) => unknown;
+    return {
+      ...definition,
+      execute: (...args: unknown[]) => {
+        const nextArgs = [...args];
+        const ctx = nextArgs[4];
+        if (ctx && typeof ctx === "object") {
+          nextArgs[4] = {
+            ...(ctx as Record<string, unknown>),
+            getThinkingLevel: () => pi.getThinkingLevel(),
+          };
+        }
+        return execute(...nextArgs);
+      },
+    } as T;
+  };
   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),
@@ -186,6 +207,6 @@ export default function toolRegistryExtension(pi: Pi.ExtensionAPI) {
       getRuntimeTool: (name) => actorToolDefinitions.get(name),
       registryRuntime: runtime,
       setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
-    }),
+    }).map(withCurrentThinkingContext),
   );
 }

package/lib/async-runs.ts

@@ -22,6 +22,12 @@ import type {
   CommandTemplateValue,
 } from "./command-templates.ts";
 import { writeJsonAtomic } from "./file-state.ts";
+import {
+  CURRENT_MODEL_VALUE_KEY,
+  CURRENT_THINKING_VALUE_KEY,
+  describeCurrentPolicyProvenance,
+  type CurrentPolicyProvenance,
+} from "./model-context.ts";
 import * as Paths from "./paths.ts";
 import * as RecipesReferences from "./recipes-references.ts";
 import * as RecipesUsage from "./recipes-usage.ts";
@@ -93,6 +99,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;
@@ -106,6 +114,7 @@ export interface AsyncRunStartParams {
   recover?: CommandTemplateValue;
   repeat?: number;
   values?: Record<string, unknown>;
+  policy_values?: Record<string, unknown>;
   actor_context?: boolean | string;
   cwd?: string;
 }
@@ -136,6 +145,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";
 }
@@ -180,6 +190,8 @@ function resolveRunTemplate(params: AsyncRunStartParams): {
     "args",
     "defaults",
     "parallel",
+    "concurrency",
+    "min_successful",
     "label",
     "when",
     "timeout",
@@ -270,6 +282,130 @@ function readJson(path: string): Record<string, unknown> | undefined {
   ).value;
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function isFalsyValue(value: unknown): boolean {
+  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: string,
+  placeholder: string,
+): boolean {
+  return new RegExp(`\\{\\s*${placeholder}\\s*\\}`).test(value);
+}
+
+function collectUnresolvedCurrentPlaceholderReferences(
+  value: unknown,
+  values: Record<string, unknown>,
+  placeholder: string,
+  valueKey: string,
+  path = "template",
+  refs: string[] = [],
+): string[] {
+  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: CommandTemplateValue,
+  defaults: Record<string, unknown> | undefined,
+  values: Record<string, unknown>,
+  modelPolicy: CurrentPolicyProvenance,
+): void {
+  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: string): () => void {
   return RunsStart.acquireStateStartLock(stateDir);
 }
@@ -286,6 +422,25 @@ export function startRun(
   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);
@@ -315,14 +470,6 @@ export function startRun(
     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,
@@ -345,6 +492,7 @@ export function startRun(
       ...(startParams.tool ? { tool: startParams.tool } : {}),
       template: resolved.template,
       values,
+      model_policy: modelPolicy,
       ...(artifacts ? { artifacts } : {}),
       ...(startParams.control ? { control: startParams.control } : {}),
       ...(startParams.mailbox ? { mailbox: startParams.mailbox } : {}),
@@ -368,6 +516,7 @@ export function startRun(
     writeJsonAtomic(join(stateDir, "progress.json"), {
       completed: 0,
       failures: [],
+      model_policy: modelPolicy,
       phase: "starting",
       updatedAt: new Date().toISOString(),
     });

package/lib/command-templates.ts

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