pi-extensible-workflows 1.0.0 → 1.0.1

package/dist/src/workflow-evals.d.ts

@@ -252,6 +252,7 @@ export interface CaptureCaseInput {
     maxCost: number;
 }
 export declare function parseSemanticJudge(raw: string, criteria: readonly SemanticCriterion[]): CriterionResult[];
+export declare function findSessionFile(directory: string, sessionId: string): string | undefined;
 export declare function captureEvalCase(input: CaptureCaseInput): Promise<EvalCaseResult>;
 export interface IsolatedProcessOptions {
     childPath: string;

package/dist/src/workflow-evals.js

@@ -8,13 +8,12 @@ import { Value } from "typebox/value";
 import { getAgentDir, parseFrontmatter, SessionManager } from "@earendil-works/pi-coding-agent";
 import { CAPTURE_ERROR_PREFIX, CAPTURE_IDENTITY, resolveWorkflowSkillPath } from "./eval-capture-extension.js";
 export { resolveWorkflowSkillPath } from "./eval-capture-extension.js";
-import { ERROR_CODES, inspectWorkflowScript, loadAgentDefinitions, runWorkflow, WorkflowError } from "./index.js";
+import { ERROR_CODES, inspectWorkflowScript, isObject, loadAgentDefinitions, runWorkflow, WORKFLOW_CALL_KINDS, WorkflowError } from "./index.js";
 const CASE_PROCESS_GRACE_MS = 1_000;
 export const SAFE_PARENT_EVAL_TOOLS = Object.freeze(["read", "grep", "find", "bash", "workflow"]);
 const EVAL_MODEL_TOKEN = "$EVAL_MODEL";
 const semantic = (description) => [{ id: "intent", description }];
 const JSON_RESULT_TYPES = ["null", "boolean", "number", "integer", "string", "array", "object"];
-const WORKFLOW_CALL_KINDS = ["agent", "conversation", "parallel", "pipeline", "checkpoint", "phase", "withWorktree"];
 const AGENT_OPTION_NAMES = ["role", "model", "thinking", "tools", "retries"];
 const expectationKeys = ["firstSignificantAction", "firstTool", "firstBatchToolSequence", "parentToolSequence", "workflowCallCount", "requiredOperations", "forbiddenOperations", "requiredRoles", "minimumAgentCalls", "requireOutputSchema", "expectedResults", "agentPolicies", "requiredAgentOrder", "requiredAgentStructures", "requiredDataFlow"];
 const caseKeys = ["id", "prompt", "timeoutMs", "maxCost", "expectations", "expectedWorkflowCalls", "semanticCriteria"];
@@ -234,7 +233,6 @@ catch (error) {
     cases.push(candidate);
 } return Object.freeze(cases); }
 export const INITIAL_WORKFLOW_EVAL_CASES = loadWorkflowEvalCases();
-function isObject(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }
 function isJson(value) { if (value === null || typeof value === "string" || typeof value === "boolean")
     return true; if (typeof value === "number")
     return Number.isFinite(value); if (Array.isArray(value))
@@ -945,6 +943,27 @@ function seedEvalProject(cwd, home, model) {
             writeFileSync(path, `${content.slice(0, frontmatterEnd).replace(/^model:.*$/m, `model: ${model}`)}${content.slice(frontmatterEnd)}`);
     }
 }
+export function findSessionFile(directory, sessionId) {
+    if (!existsSync(directory))
+        return undefined;
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            const found = findSessionFile(path, sessionId);
+            if (found)
+                return found;
+        }
+        else if (entry.name.endsWith(".jsonl")) {
+            try {
+                const header = JSON.parse(readFileSync(path, "utf8").split("\n")[0] ?? "{}");
+                if (isObject(header) && header.id === sessionId)
+                    return path;
+            }
+            catch { /* Ignore incomplete sessions. */ }
+        }
+    }
+    return undefined;
+}
 async function findParentSession(cwd, sessionDir, sessionId) {
     try {
         const sessions = await SessionManager.list(cwd, sessionDir);
@@ -953,28 +972,7 @@ async function findParentSession(cwd, sessionDir, sessionId) {
             return found.path;
     }
     catch { /* Fall through to the JSONL scan. */ }
-    const visit = (directory) => {
-        if (!existsSync(directory))
-            return undefined;
-        for (const entry of readdirSync(directory, { withFileTypes: true })) {
-            const path = join(directory, entry.name);
-            if (entry.isDirectory()) {
-                const found = visit(path);
-                if (found)
-                    return found;
-            }
-            else if (entry.name.endsWith(".jsonl")) {
-                try {
-                    const header = JSON.parse(readFileSync(path, "utf8").split("\n")[0] ?? "{}");
-                    if (isObject(header) && header.id === sessionId)
-                        return path;
-                }
-                catch { /* Ignore incomplete files. */ }
-            }
-        }
-        return undefined;
-    };
-    return visit(sessionDir);
+    return findSessionFile(sessionDir, sessionId);
 }
 function emptyAccounting(cost = 0) { return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost, models: [] }; }
 function emptyMetrics(requiredWorkflowCallCount = 1) { return { parentUsageThroughCandidate: null, parentOutputTokensThroughCandidate: null, nonWorkflowToolSequenceBeforeCandidate: [], nonWorkflowToolCallCountBeforeCandidate: 0, workflowCallCountBeforeCandidate: 0, invalidWorkflowCallCount: 0, productionValidationErrorCodes: [], candidateCallIndices: [], staticCandidates: [], semanticCriteria: [], anyValidCandidate: false, requiredWorkflowCallCount, surplusWorkflowCallCount: 0 }; }

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "pi-extensible-workflows",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Deterministic multi-agent workflow orchestration for Pi",
   "homepage": "https://vekexasia.github.io/pi-extensible-workflows/",
-  "repository": { "type": "git", "url": "git+https://github.com/vekexasia/pi-extensible-workflows.git" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vekexasia/pi-extensible-workflows.git"
+  },
   "type": "module",
   "keywords": [
     "pi-package",

package/skills/pi-extensible-workflows/SKILL.md

@@ -92,7 +92,11 @@ const results = await parallel("implementation", {
 });
 ```
 
-Registered extension functions receive `withWorktree` in their context, so they may create a shared scope internally. Their public inputs and outputs must remain JSON; callbacks cannot cross the extension-function boundary.
+Registered extension functions receive `withWorktree` in their context, so they may create a shared scope internally. They can compose other registered functions without importing their source:
+```ts
+const report = await context.invoke("reviewRepository", { focus: "security" });
+```
+Their public inputs and outputs must remain JSON; callbacks cannot cross the extension-function boundary.
 
 ## Rules
 
@@ -104,7 +108,7 @@ Registered extension functions receive `withWorktree` in their context, so they
 - Preserve item metadata in workflow code between pipeline stages instead of requiring agents to echo it through `outputSchema`.
 - Repeated work uses a JavaScript loop; each direct `agent(...)` call receives deterministic call-site and occurrence identity.
 - Runs default to background; set tool-call `foreground: true` when asked to wait.
-- Add `budget` only when the run needs aggregate token, cost, duration, or launch limits; each dimension accepts optional `soft` and `hard` values. Soft crossings request wrap-up, while hard exhaustion blocks further budgeted work.
+- Add `budget` only when the run needs aggregate limits. The only valid dimension names are exactly `tokens`, `costUsd`, `durationMs`, and `agentLaunches` (never `cost`, `duration`, `launches`, or other shorthand). Each dimension is `{ soft?: number, hard?: number }`; `soft` must be less than `hard`.
 - A `budget_exhausted` run is resumable through `workflow_resume`. Omitted patch values stay unchanged, explicit `null` removes a limit, and any relaxation requires an exact human-approved proposal through `workflow_respond`.
 - `parallel()` and `pipeline()` return keyed bare values. Await results before use.
 - Interpolate results with `prompt("...{value}", { value })`; placeholders in plain strings stay literal.

package/src/agent-execution.ts

@@ -192,6 +192,42 @@ export async function createNativeAgentSession(input: SessionInput): Promise<Nat
 }
 function changedOption(options: Readonly<Record<string, JsonValue>>, baseline: Readonly<Record<string, JsonValue>>, key: string): boolean { return JSON.stringify(options[key]) !== JSON.stringify(baseline[key]); }
 function validThinking(value: unknown): value is ThinkingLevel { return typeof value === "string" && ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(value); }
+function jsonValue(value: unknown, seen = new Set<object>()): value is JsonValue {
+  if (value === null || typeof value === "boolean" || typeof value === "string") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || seen.has(value)) return false;
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return false;
+  const keys = Reflect.ownKeys(value);
+  if (keys.some((key) => typeof key !== "string")) return false;
+  seen.add(value);
+  const valid = (Array.isArray(value) ? Array.from(value) : keys.map((key) => (value as Record<string, unknown>)[key as string])).every((item) => jsonValue(item, seen));
+  seen.delete(value);
+  return valid;
+}
+function jsonObject(value: unknown): value is Record<string, JsonValue> { return jsonValue(value) && typeof value === "object" && value !== null && !Array.isArray(value); }
+interface ChildAgentToolParams {
+  prompt: string;
+  label: string;
+  tools?: string[];
+  model?: string;
+  thinking?: ThinkingLevel;
+  role?: string;
+  outputSchema?: JsonSchema;
+  retries?: number;
+  timeoutMs?: number | null;
+  [key: string]: unknown;
+}
+function isChildAgentToolParams(value: unknown): value is ChildAgentToolParams & Record<string, JsonValue> {
+  if (!jsonObject(value) || typeof value.prompt !== "string" || typeof value.label !== "string") return false;
+  if (value.tools !== undefined && (!Array.isArray(value.tools) || value.tools.some((tool) => typeof tool !== "string"))) return false;
+  if (value.model !== undefined && typeof value.model !== "string") return false;
+  if (value.thinking !== undefined && !validThinking(value.thinking)) return false;
+  if (value.role !== undefined && typeof value.role !== "string") return false;
+  if (value.outputSchema !== undefined && !jsonObject(value.outputSchema)) return false;
+  if (value.retries !== undefined && (typeof value.retries !== "number" || !Number.isInteger(value.retries) || value.retries < 0)) return false;
+  if (value.timeoutMs !== undefined && (value.timeoutMs !== null && (typeof value.timeoutMs !== "number" || !Number.isInteger(value.timeoutMs) || value.timeoutMs < 1))) return false;
+  return true;
+}
 function fallbackSetupContext(root: AgentExecutionRoot, options: AgentExecutionOptions, signal: AbortSignal): { run: Readonly<WorkflowRunContext>; identity: Readonly<AgentIdentity> } {
   const identity = options.agentIdentity ?? { structuralPath: [], callSite: options.label, occurrence: 1 };
   const run = root.runContext ?? Object.freeze({ cwd: root.cwd, sessionId: "", runId: "", workflow: Object.freeze({ name: options.workflowName }), args: null, signal });
@@ -640,17 +676,19 @@ export class FairAgentScheduler {
     if (nodes.every(({ restored }) => restored)) run.logical = 0;
   }
 
-  /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-argument, @typescript-eslint/restrict-template-expressions */
   toolsFor(parentId: string, resolveTools?: (role: string | undefined, tools: readonly string[] | undefined, model: string | undefined, inheritedTools: readonly string[], thinking: ThinkingLevel | undefined) => readonly string[]): ToolDefinition[] {
     const parent = this.#node(parentId);
     if (!parent.options.tools.includes("agent")) return [];
     const agentTool = {
       name: "agent", label: "Child Agent", description: "Start a direct child agent",
       parameters: Type.Object({ prompt: Type.String(), label: Type.String(), tools: Type.Optional(Type.Array(Type.String())), model: Type.Optional(Type.String()), thinking: Type.Optional(Type.String()), role: Type.Optional(Type.String()), outputSchema: Type.Optional(Type.Unsafe<JsonSchema>({})), retries: Type.Optional(Type.Integer({ minimum: 0 })), timeoutMs: Type.Optional(Type.Union([Type.Integer({ minimum: 1 }), Type.Null()])) }, { additionalProperties: true }),
-      execute: async (_id: string, params: { prompt: string; label: string; tools?: string[]; model?: string; thinking?: ThinkingLevel; role?: string; outputSchema?: JsonSchema; retries?: number; timeoutMs?: number | null; [key: string]: unknown }) => {
+      execute: async (_id: string, rawParams: unknown) => {
+        if (!isChildAgentToolParams(rawParams)) throw new WorkflowError("INVALID_METADATA", "Invalid child agent parameters");
+        const params = rawParams;
         if (params.role !== undefined && (params.model !== undefined || params.thinking !== undefined || params.tools !== undefined)) throw new WorkflowError("INVALID_METADATA", "Role agents must not specify model, thinking, or tools");
         const tools = (params.tools !== undefined || params.role !== undefined ? resolveTools?.(params.role, params.tools, params.model, parent.options.tools, params.thinking) : undefined) ?? params.tools ?? parent.options.tools;
-        const agentOptions = Object.fromEntries(Object.entries(params).filter(([key]) => key !== "prompt")) as Record<string, JsonValue>;
+        const agentOptions = { ...params };
+        Reflect.deleteProperty(agentOptions, "prompt");
         const options: ScheduledAgentOptions = { label: params.label, requestedLabel: params.label, cwd: parent.options.cwd, tools, agentOptions, ...(params.model ? { model: params.model } : {}), ...(params.thinking ? { thinking: params.thinking } : {}), ...(params.role ? { role: params.role } : {}), ...(params.outputSchema ? { schema: params.outputSchema } : {}), ...(params.retries === undefined ? {} : { retries: params.retries }), ...(params.timeoutMs === undefined ? {} : { timeoutMs: params.timeoutMs }) };
         const child = this.spawn(parent.runId, params.prompt, options, parentId);
         return { content: [{ type: "text" as const, text: JSON.stringify({ id: child.id }) }], details: { id: child.id } };
@@ -694,14 +732,14 @@ export class FairAgentScheduler {
 
   #inherit(parent: ScheduledNode | undefined, options: ScheduledAgentOptions): Readonly<ScheduledAgentOptions> {
     if (!options.label.trim() || !options.cwd || !Array.isArray(options.tools)) throw new WorkflowError("INVALID_METADATA", "Agents require label, cwd, and tools");
-    if (!parent) return Object.freeze({ ...options, tools: Object.freeze([...options.tools]), ...(options.agentOptions ? { agentOptions: structuredClone(options.agentOptions) } : {}), ...(options.agentIdentity ? { agentIdentity: Object.freeze({ ...options.agentIdentity, structuralPath: Object.freeze([...options.agentIdentity.structuralPath]) }) } : {}) });
+    const inheritedTools: readonly string[] = options.tools;
+    if (!parent) return Object.freeze({ ...options, tools: Object.freeze([...inheritedTools]), ...(options.agentOptions ? { agentOptions: structuredClone(options.agentOptions) } : {}), ...(options.agentIdentity ? { agentIdentity: Object.freeze({ ...options.agentIdentity, structuralPath: Object.freeze([...options.agentIdentity.structuralPath]) }) } : {}) });
     if (options.cwd !== parent.options.cwd) throw new WorkflowError("UNKNOWN_TOOL", "Child cwd cannot differ from its parent");
-    const forbidden = options.tools.find((tool) => !parent.options.tools.includes(tool));
+    const forbidden = inheritedTools.find((tool: string) => !parent.options.tools.includes(tool));
     if (forbidden) throw new WorkflowError("UNKNOWN_TOOL", `Child tool escalates parent boundary: ${forbidden}`);
     const identity = options.agentIdentity ?? parent.options.agentIdentity;
-    return Object.freeze({ ...options, cwd: parent.options.cwd, tools: Object.freeze([...options.tools]), ...(options.agentOptions ? { agentOptions: structuredClone(options.agentOptions) } : {}), ...(parent.options.parentBreadcrumb && !options.parentBreadcrumb ? { parentBreadcrumb: parent.options.parentBreadcrumb } : {}), ...(identity ? { agentIdentity: Object.freeze({ ...identity, structuralPath: Object.freeze([...identity.structuralPath]) }) } : {}), ...(parent.options.worktreeOwner ? { worktreeOwner: parent.options.worktreeOwner } : {}) });
+    return Object.freeze({ ...options, cwd: parent.options.cwd, tools: Object.freeze([...inheritedTools]), ...(options.agentOptions ? { agentOptions: structuredClone(options.agentOptions) } : {}), ...(parent.options.parentBreadcrumb && !options.parentBreadcrumb ? { parentBreadcrumb: parent.options.parentBreadcrumb } : {}), ...(identity ? { agentIdentity: Object.freeze({ ...identity, structuralPath: Object.freeze([...identity.structuralPath]) }) } : {}), ...(parent.options.worktreeOwner ? { worktreeOwner: parent.options.worktreeOwner } : {}) });
   }
-  /* eslint-enable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-argument, @typescript-eslint/restrict-template-expressions */
 
   #enqueue(runId: string, node: ScheduledNode | undefined, start: () => void): void { this.#runs.get(runId)?.queue.push({ ...(node ? { node } : {}), start }); this.#dispatch(); }
 

package/src/ambient-workflow-evals.ts

@@ -1,12 +1,13 @@
 import { spawn, type ChildProcess } from "node:child_process";
 import { execFileSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CAPTURE_IDENTITY } from "./eval-capture-extension.js";
-import { extractCapturedWorkflows, extractParentOracleFile } from "./workflow-evals.js";
+import { isObject } from "./index.js";
+import { extractCapturedWorkflows, extractParentOracleFile, findSessionFile } from "./workflow-evals.js";
 
 export const AMBIENT_OPT_IN = "PI_WORKFLOW_EVAL_AMBIENT";
 export const AMBIENT_CAPTURE_NOTE = "Ambient Tier D uses the explicit capture extension. Pi 0.80.6 orders CLI extensions before discovered extensions and the first tool registration wins, so ambient tools and skills remain available while workflow execution stays capture-only.";
@@ -327,26 +328,13 @@ function ambientAgentDir(environment: NodeJS.ProcessEnv): string {
   return environment.PI_CODING_AGENT_DIR ?? process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
 }
 
-function isObject(value: unknown): value is Record<string, unknown> { return typeof value === "object" && value !== null && !Array.isArray(value); }
-
-function findSessionFile(directory: string, sessionId: string): string | undefined {
-  if (!existsSync(directory)) return undefined;
-  for (const entry of readdirSync(directory, { withFileTypes: true })) {
-    const path = join(directory, entry.name);
-    if (entry.isDirectory()) { const found = findSessionFile(path, sessionId); if (found) return found; }
-    else if (entry.name.endsWith(".jsonl")) {
-      try { const header = JSON.parse(readFileSync(path, "utf8").split("\n")[0] ?? "{}") as unknown; if (isObject(header) && header.id === sessionId) return path; } catch { /* Ignore incomplete sessions. */ }
-    }
-  }
-  return undefined;
-}
-
-function emptyResult(candidate: AmbientEvalCase, repository: AmbientFixtureRepository, worktree: AmbientCaseWorktree, environment: NodeJS.ProcessEnv, error: string): AmbientCaseResult {
+type AmbientCaseResultDraft = Omit<AmbientCaseResult, "manifest"> & { manifest: Omit<AmbientManifest, "gitStatusAfter"> };
+function emptyResult(candidate: AmbientEvalCase, repository: AmbientFixtureRepository, worktree: AmbientCaseWorktree, environment: NodeJS.ProcessEnv, error: string): AmbientCaseResultDraft {
   const accounting = emptyAccounting();
   return {
     id: candidate.id, status: "failed", workflows: [], accounting, accountingTrustworthy: false, diagnostics: [], errors: [error],
     manifest: {
-      invocationMode: AMBIENT_INVOCATION_MODE, fixtureRoot: repository.fixtureRoot, worktreePath: worktree.path, ambientAgentDir: ambientAgentDir(environment), fixtureFileList: worktree.fixtureFiles, gitStatusBefore: worktree.gitStatusBefore, gitStatusAfter: worktree.gitStatusBefore, parentToolSequence: [], skillReads: [], workflowCalls: [], workflowCallCount: 0, tokenCost: accounting,
+      invocationMode: AMBIENT_INVOCATION_MODE, fixtureRoot: repository.fixtureRoot, worktreePath: worktree.path, ambientAgentDir: ambientAgentDir(environment), fixtureFileList: worktree.fixtureFiles, gitStatusBefore: worktree.gitStatusBefore, parentToolSequence: [], skillReads: [], workflowCalls: [], workflowCallCount: 0, tokenCost: accounting,
       cleanup: { processExited: false, processGroupTerminated: false, worktreeRemoved: false, fixtureRepoRemoved: false, tempRootRemoved: false, captureIdentityVerified: false, realWorkflowAgentsLaunched: 0 },
     },
   };
@@ -356,12 +344,13 @@ async function runAmbientCase(repository: AmbientFixtureRepository, candidate: A
   const worktree = createAmbientCaseWorktree(repository, candidate.id);
   const sessionId = randomUUID();
   const sessionDir = join(repository.root, "sessions", candidate.id);
-  let result: AmbientCaseResult | undefined;
-  let gitStatusAfter: readonly string[] = worktree.gitStatusBefore;
+  let result: AmbientCaseResultDraft | undefined;
+  let failure: string | undefined;
+  let gitStatusAfter: readonly string[];
   try {
     const pi = await runAmbientPiProcess({ worktree: worktree.path, sessionDir, sessionId, prompt: candidate.prompt, provider, model, ...(thinking ? { thinking } : {}), ...(piCommand ? { piCommand } : {}), timeoutMs: candidate.timeoutMs, maxCost: candidate.maxCost, environment });
     const sessionFile = findSessionFile(sessionDir, sessionId);
-    if (!sessionFile) result = emptyResult(candidate, repository, worktree, environment, "Ambient parent session was not written.");
+    if (!sessionFile) failure = "Ambient parent session was not written.";
     else {
       const oracle = extractParentOracleFile(sessionFile);
       const workflows = extractCapturedWorkflows(oracle);
@@ -371,24 +360,25 @@ async function runAmbientCase(repository: AmbientFixtureRepository, candidate: A
       result = {
         id: candidate.id, status, workflows, accounting: oracle.usage, accountingTrustworthy: !pi.timedOut && !pi.budgetExceeded && pi.exitCode === 0, diagnostics: [pi.stderr].filter(Boolean), errors,
         manifest: {
-          invocationMode: AMBIENT_INVOCATION_MODE, fixtureRoot: repository.fixtureRoot, worktreePath: worktree.path, ambientAgentDir: ambientAgentDir(environment), fixtureFileList: worktree.fixtureFiles, gitStatusBefore: worktree.gitStatusBefore, gitStatusAfter, parentToolSequence: oracle.parentToolSequence, skillReads: oracle.skillReads, workflowCalls: workflows, workflowCallCount: oracle.workflowCallCount, tokenCost: oracle.usage,
+          invocationMode: AMBIENT_INVOCATION_MODE, fixtureRoot: repository.fixtureRoot, worktreePath: worktree.path, ambientAgentDir: ambientAgentDir(environment), fixtureFileList: worktree.fixtureFiles, gitStatusBefore: worktree.gitStatusBefore, parentToolSequence: oracle.parentToolSequence, skillReads: oracle.skillReads, workflowCalls: workflows, workflowCallCount: oracle.workflowCallCount, tokenCost: oracle.usage,
           cleanup: { processExited: pi.exitCode !== null, processGroupTerminated: pi.processGroupTerminated, worktreeRemoved: false, fixtureRepoRemoved: false, tempRootRemoved: false, captureIdentityVerified, realWorkflowAgentsLaunched: 0 },
         },
       };
     }
   } catch (error) {
-    result = emptyResult(candidate, repository, worktree, environment, error instanceof Error ? error.message : String(error));
+    failure = error instanceof Error ? error.message : String(error);
   } finally {
     try { gitStatusAfter = gitStatus(worktree.path); } catch { gitStatusAfter = ["<unavailable>"]; }
     const worktreeRemoved = removeAmbientCaseWorktree(repository, worktree);
-    if (!result) result = emptyResult(candidate, repository, worktree, environment, "Ambient case produced no result.");
+    if (!result) result = emptyResult(candidate, repository, worktree, environment, failure ?? "Ambient case produced no result.");
     const cleanup = { ...result.manifest.cleanup, worktreeRemoved };
-    result = { ...result, manifest: { ...result.manifest, gitStatusAfter, cleanup } };
-    writeFileSync(join(artifactsDir, `${candidate.id}.json`), `${JSON.stringify(result, null, 2)}\n`, { mode: 0o600 });
+    result = { ...result, manifest: { ...result.manifest, cleanup } };
   }
-  return result;
-}
 
+  const finalized: AmbientCaseResult = { ...result, manifest: { ...result.manifest, gitStatusAfter } };
+  writeFileSync(join(artifactsDir, `${candidate.id}.json`), `${JSON.stringify(finalized, null, 2)}\n`, { mode: 0o600 });
+  return finalized;
+}
 export function assertAmbientOptIn(environment: NodeJS.ProcessEnv = process.env): void {
   if (environment[AMBIENT_OPT_IN] !== "1") throw new Error(`Ambient Tier D evals are opt-in. Set ${AMBIENT_OPT_IN}=1 to run them.`);
 }

package/src/doctor.ts

@@ -13,7 +13,6 @@ import {
 import {
   DEFAULT_SETTINGS,
   loadSettings,
-  parseModelReference,
   resolveAgentResourcePolicy,
   resolveModelReference,
   parseRoleMarkdown,
@@ -188,9 +187,6 @@ function inspectRole(path: string, activeTools: ReadonlySet<string>, knownModels
   return definition;
 }
 
-class DoctorModelSet extends Set<string> {
-  override has(value: string): boolean { parseModelReference(value); return true; }
-}
 function matchResourcePolicy(policy: AgentResourcePolicy, pi: DoctorPiState): AgentResourcePolicy {
   const extensions = new Set((pi.extensions ?? []).map(canonical));
   const skills = new Set(pi.skills ?? []);
@@ -262,12 +258,13 @@ export async function doctor(options: DoctorOptions = {}): Promise<DoctorReport>
     let valid = true;
     try {
       const checked = preflight(workflow.script, {
-        models: new DoctorModelSet(pi.knownModels),
+        models: new Set(pi.knownModels),
         tools: activeTools,
         agentTypes: new Set(definitions.keys()),
         modelAliases: aliases,
         knownModels,
         settingsPath,
+        skipModelAvailability: true,
       }, [], { name, description: workflow.description });
       for (const model of checked.referenced.models) if (!knownModels.has(model) || !availableModels.has(model)) diagnostics.push(diagnostic("warning", "MODEL_UNAVAILABLE", `Model is valid-shaped but unavailable: ${model}`, name));
     } catch (error) {