pi-extensible-workflows 2.0.0 → 3.1.0

package/README.md

@@ -6,7 +6,7 @@
 
 Turn multi-agent tasks into deterministic jobs that fan out in parallel, pause for approval, and resume without rerunning completed work.
 
-[Documentation](https://vekexasia.github.io/pi-extensible-workflows/) | [Developer guide](https://vekexasia.github.io/pi-extensible-workflows/developers.html) | [Agent guide](https://vekexasia.github.io/pi-extensible-workflows/agents.html)
+[Documentation](https://vekexasia.github.io/pi-extensible-workflows/) | [Developer guide](https://vekexasia.github.io/pi-extensible-workflows/developers.html) | [Agent guide](https://vekexasia.github.io/pi-extensible-workflows/agents.html) | [Extension authoring](https://vekexasia.github.io/pi-extensible-workflows/extensions.html)
 
 Requires Node.js 22.19 or newer. This is a trusted Pi extension with the same filesystem and process access as Pi.
 
@@ -22,19 +22,25 @@ For source installs and local development, see the [installation guide](https://
 
 The main Pi agent acts as the orchestrator: it writes workflow scripts on the fly for each task. Pi extensions can add reusable functions and variables to those scripts; every registered function is also directly runnable as a top-level workflow.
 
+Inline workflow launches require a non-empty `name`; registered function launches reject `name` and use their registered function name as the run name. Workflow worktree scopes always use the explicit `withWorktree(name, callback)` form.
+
 A workflow can fan out across specialized agents, combine their results, and resume without rerunning completed work.
 
 ```js
 const reviews = await parallel("review", {
-  correctness: () => agent("Review the current changes for correctness issues."),
-  security: () => agent("Review the current changes for security risks.", {
-    role: "security-specialist",
-  }),
+  correctness: () =>
+    agent("Review the current changes for correctness issues."),
+  security: () =>
+    agent("Review the current changes for security risks.", {
+      role: "security-specialist",
+    }),
   tests: () => agent("Review the current changes for missing test coverage."),
 });
 
 const summary = await agent(
-  prompt("Deduplicate and prioritize these findings:\n\n{reviews}", { reviews }),
+  prompt("Deduplicate and prioritize these findings:\n\n{reviews}", {
+    reviews,
+  }),
 );
 
 return summary;
@@ -46,7 +52,7 @@ Learn more about roles, workflow contracts, and extension APIs in the documentat
 - [Global and project settings](https://vekexasia.github.io/pi-extensible-workflows/developers.html#settings)
 - [Aggregate run budgets](https://vekexasia.github.io/pi-extensible-workflows/developers.html#budgets)
 - [Workflow DSL and worktrees](https://vekexasia.github.io/pi-extensible-workflows/developers.html#dsl)
-- [Reusable extension primitives](https://vekexasia.github.io/pi-extensible-workflows/developers.html#extensions)
+- [Extension authoring guide](https://vekexasia.github.io/pi-extensible-workflows/extensions.html)
 - [Run artifacts and lifecycle events](https://vekexasia.github.io/pi-extensible-workflows/developers.html#lifecycle)
 - [Run inspection and recovery](https://vekexasia.github.io/pi-extensible-workflows/developers.html#operations)
 - [Agent patterns and model selection](https://vekexasia.github.io/pi-extensible-workflows/agents.html#patterns)
@@ -54,21 +60,22 @@ Learn more about roles, workflow contracts, and extension APIs in the documentat
 
 ## Configuration
 
-Global workflow settings live at `~/.pi/agent/pi-extensible-workflows/settings.json` by default and configure concurrency, model aliases, and workflow-agent skill or extension exclusions. Trusted projects can add resource exclusions at `<project>/.pi/pi-extensible-workflows/settings.json`; they cannot override global aliases or concurrency. See [global and project settings](https://vekexasia.github.io/pi-extensible-workflows/developers.html#settings) for the schema and merge rules.
+Global workflow settings live at `~/.pi/agent/pi-extensible-workflows/settings.json` by default. Trusted projects can add partial overrides at `<project>/.pi/pi-extensible-workflows/settings.json`; precedence is defaults < global < trusted project < per-run options. Project collections replace global collections, so `{}` and empty arrays clear inherited aliases or resource exclusions. Untrusted project settings are ignored. See [global and project settings](https://vekexasia.github.io/pi-extensible-workflows/developers.html#settings) for the schema, trust gate, source reporting, and merge rules.
 
 ## CLI
 
 ```sh
 npx pi-extensible-workflows doctor
+npx pi-extensible-workflows doctor cleanup [--older-than-days <days>] [--yes]
 npx pi-extensible-workflows inspect [session-id]
 npx pi-extensible-workflows transcript <session-file>
 npx pi-extensible-workflows run <workflow-name> [workflow arguments]
 npx pi-extensible-workflows export <workflow-name> [--name <command>] [--output <path>] [--force]
 ```
 
-`doctor` validates the installation and active Pi resources. `inspect` opens a read-only terminal view of persisted workflow runs. `transcript` renders a session transcript to stdout. `run` derives flat CLI arguments and help from a registered function's input schema. Use `--input '<json>'` for nested or otherwise complex inputs. It executes in the current working directory, writes the final JSON result to stdout, and writes progress and errors to stderr. `export` creates an executable POSIX launcher in `~/.local/bin` by default.
-`run` and `export` accept the trust overrides `--approve` and `--no-approve`; the generated launcher forwards its arguments to `run`. `--` ends launcher option parsing, and later tokens are passed to workflow input instead of being interpreted as launcher options.
-Launch snapshots use identity version 4. A cold resume intentionally rejects persisted v3 runs with `RESUME_INCOMPATIBLE`; relaunch the workflow instead.
+`doctor` validates the installation and active Pi resources and remains read-only. `doctor cleanup` is an explicit, dry-run-first maintenance command: it previews terminal workflow runs older than 90 days across the current project's stored sessions and deletes them only with `--yes`; use `--older-than-days` to change the positive age threshold. It protects active, corrupt, leased, and dependency-linked runs. `inspect` opens a read-only terminal view of persisted workflow runs. `transcript` renders a session transcript to stdout. `run` derives flat CLI arguments and help from a registered function's input schema. Use `--input '<json>'` for nested or otherwise complex inputs. It executes in the current working directory, writes the final JSON result to stdout, and writes progress and errors to stderr. `export` creates an executable POSIX launcher in `~/.local/bin` by default.
+`run` and `export` accept the trust overrides `--approve` and `--no-approve`; the generated launcher forwards its arguments to `run`. `--` ends launcher option parsing, and later tokens are passed to workflow input instead of being interpreted as launcher options. Headless `run` and generated `export` launchers cannot execute workflows containing checkpoints; use the Pi workflow tool/UI path for checkpointed workflows.
+Launch snapshots use identity version 5. Cold resume rejects older snapshots, including v4 snapshots created with the previous worktree or registered-function naming contracts, with `RESUME_INCOMPATIBLE`; relaunch the workflow instead.
 
 ## Development
 

package/dist/src/agent-execution.d.ts

@@ -1,22 +1,8 @@
-import { type AgentSessionEvent, type InlineExtension, type SessionStats, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
 type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
-type AgentMessage = {
-    role: string;
-    content?: unknown;
-    stopReason?: string;
-    errorMessage?: string;
-    usage?: {
-        input: number;
-        output: number;
-        cacheRead: number;
-        cacheWrite: number;
-        cost: {
-            total: number;
-        };
-    };
-};
-import type { AgentIdentity, AgentResourceExclusions, AgentResourcePolicy, AgentSetupSummary, JsonSchema, JsonValue, ModelSpec, WorkflowRunContext } from "./index.js";
+import type { AgentIdentity, AgentResourceExclusions, AgentResourcePolicy, AgentSetupSummary, JsonSchema, JsonValue, ModelSpec, NativeSession, RegisteredAgentSetupHook, SessionFactory, SessionInput, WorkflowRunContext } from "./types.js";
 import type { RunStore } from "./persistence.js";
+export type { AgentSetup, AgentSetupContext, AgentSetupHook, NativeSession, RegisteredAgentSetupHook, SessionFactory, SessionInput } from "./types.js";
 export interface AgentBudgetHooks {
     beforeAttempt(): void;
     beforeTurn(): void;
@@ -63,10 +49,6 @@ export interface AgentExecutionOptions {
     budget?: AgentBudgetHooks;
     agentOptions?: Readonly<Record<string, JsonValue>>;
     agentIdentity?: AgentIdentity;
-    conversation?: {
-        id: string;
-        turn: number;
-    };
 }
 export interface AgentExecutionRoot {
     cwd: string;
@@ -125,74 +107,6 @@ export interface AgentExecutionResult {
     attempts: readonly AgentAttempt[];
     cwd: string;
 }
-export interface AgentSetup {
-    prompt: string;
-    options: Record<string, JsonValue>;
-    sessionInput: SessionInput;
-    createSession: SessionFactory;
-}
-export interface AgentSetupContext {
-    readonly run: Readonly<WorkflowRunContext>;
-    readonly identity: Readonly<AgentIdentity>;
-    readonly attempt: number;
-    readonly signal: AbortSignal;
-}
-export interface AgentSetupHook {
-    priority?: number;
-    setup: (agent: AgentSetup, context: Readonly<AgentSetupContext>) => void | Promise<void>;
-}
-export interface RegisteredAgentSetupHook {
-    name: string;
-    priority: number;
-    setup: AgentSetupHook["setup"];
-}
-type NativeSessionStats = Pick<SessionStats, "tokens" | "cost">;
-export interface NativeSession {
-    readonly sessionId: string;
-    readonly sessionFile: string | undefined;
-    readonly messages: readonly AgentMessage[];
-    getSessionStats(): NativeSessionStats;
-    readonly systemPrompt?: string;
-    readonly model?: {
-        provider: string;
-        model?: string;
-        id?: string;
-    };
-    readonly agent?: {
-        state: {
-            tools: readonly {
-                name: string;
-            }[];
-        };
-    };
-    getLeafId?: () => string | null;
-    getToolDefinitions?: () => unknown;
-    subscribe?(listener: (event: AgentSessionEvent) => void): () => void;
-    prompt(text: string): Promise<void>;
-    steer?(text: string): Promise<void>;
-    abort?(): Promise<void>;
-    dispose(): void;
-}
-export interface SessionInput {
-    cwd: string;
-    model: ModelSpec;
-    tools: string[];
-    sessionLabel: string;
-    agentDir?: string;
-    customTools?: ToolDefinition[];
-    resultTool?: ToolDefinition;
-    systemPromptAppend?: string;
-    extensionFactories?: InlineExtension[];
-    resourcePolicy?: AgentResourcePolicy;
-    options?: Record<string, JsonValue>;
-    continuation?: {
-        sessionId: string;
-        sessionFile: string;
-        leafId: string;
-    };
-    allowModelChange?: boolean;
-}
-export type SessionFactory = (input: SessionInput) => Promise<NativeSession>;
 export declare function createNativeAgentSession(input: SessionInput): Promise<NativeSession>;
 export declare class WorkflowAgentExecutor {
     private readonly root;
@@ -222,10 +136,6 @@ export interface ScheduledAgentOptions {
     timeoutMs?: number | null;
     agentOptions?: Readonly<Record<string, JsonValue>>;
     agentIdentity?: AgentIdentity;
-    conversation?: {
-        id: string;
-        turn: number;
-    };
 }
 export type ScheduledAgentResult = {
     id: string;
@@ -279,6 +189,7 @@ export declare class FairAgentScheduler {
     private readonly writeOwnership?;
     constructor(runner: ScheduledAgentRunner, sessionLimit?: number, writeOwnership?: OwnershipWriter | undefined);
     addRun(runId: string, limit?: number, beforeLaunch?: () => void): void;
+    updateRunLimit(runId: string, limit: number): void;
     spawn(runId: string, prompt: string, options: ScheduledAgentOptions, parentId?: string): {
         id: string;
         result: Promise<ScheduledAgentResult>;
@@ -296,4 +207,3 @@ export declare class FairAgentScheduler {
     restoreRun(runId: string, limit: number, ownership: readonly OwnershipRecord[], beforeLaunch?: () => void): void;
     flush(): Promise<void>;
 }
-export {};

package/dist/src/agent-execution.js

@@ -1,17 +1,16 @@
-import { createHash } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { Type } from "@earendil-works/pi-ai";
 import { Value } from "typebox/value";
 import { createAgentSession, DefaultPackageManager, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
-import { mergeAgentResourceExclusions, resolveModelReference, WorkflowError } from "./index.js";
+import { jsonObject, disabledResources, mergeAgentResourceExclusions, modelAliasName, modelCapability, resolveModelReference, unmatchedResourcePatterns } from "./utils.js";
+import { WorkflowError } from "./types.js";
 function parseModel(value, fallback, thinking, aliases = {}, knownModels, settingsPath) {
     if (!value)
         return { ...fallback, ...(thinking ? { thinking } : {}) };
     const parsed = resolveModelReference(value, aliases, knownModels, settingsPath);
     return { ...parsed, ...(thinking ? { thinking } : !parsed.thinking && fallback.thinking ? { thinking: fallback.thinking } : {}) };
 }
-function modelCapability(model) { return `${model.provider}/${model.model}`; }
 function text(messages) {
     const message = [...messages].reverse().find((item) => item.role === "assistant");
     if (!message || !Array.isArray(message.content))
@@ -54,33 +53,8 @@ catch {
 } }
 export async function createNativeAgentSession(input) {
     const agentDir = input.agentDir ?? getAgentDir();
-    let manager;
-    if (input.continuation) {
-        try {
-            manager = SessionManager.open(input.continuation.sessionFile, input.agentDir ? join(agentDir, "sessions") : undefined, input.cwd);
-            const header = manager.getHeader();
-            if (!header || canonicalSourcePath(header.cwd) !== canonicalSourcePath(input.cwd) || manager.getSessionId() !== input.continuation.sessionId || !manager.getEntry(input.continuation.leafId))
-                throw new Error("Persisted transcript identity does not match the conversation head");
-            manager.branch(input.continuation.leafId);
-            const context = manager.buildSessionContext();
-            if (context.model && (context.model.provider !== input.model.provider || context.model.modelId !== input.model.model)) {
-                if (!input.allowModelChange)
-                    throw new Error("Persisted transcript model does not match the conversation execution policy");
-                manager.appendModelChange(input.model.provider, input.model.model);
-            }
-            if (input.model.thinking && context.thinkingLevel !== input.model.thinking)
-                throw new Error("Persisted transcript thinking level does not match the conversation execution policy");
-        }
-        catch (error) {
-            if (error instanceof WorkflowError && error.code === "RESUME_INCOMPATIBLE")
-                throw error;
-            throw new WorkflowError("RESUME_INCOMPATIBLE", `Cannot reopen conversation transcript: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    else {
-        manager = input.agentDir ? SessionManager.create(input.cwd, join(agentDir, "sessions")) : SessionManager.create(input.cwd);
-        manager.appendSessionInfo(input.sessionLabel);
-    }
+    const manager = input.agentDir ? SessionManager.create(input.cwd, join(agentDir, "sessions")) : SessionManager.create(input.cwd);
+    manager.appendSessionInfo(input.sessionLabel);
     const modelRuntime = await ModelRuntime.create({ authPath: join(agentDir, "auth.json"), modelsPath: join(agentDir, "models.json") });
     const model = modelRuntime.getModel(input.model.provider, input.model.model);
     if (!model)
@@ -95,14 +69,17 @@ export async function createNativeAgentSession(input) {
         settingsManager.setProjectTrusted(policy.projectTrusted);
         const packageManager = new DefaultPackageManager({ cwd: input.cwd, agentDir, settingsManager });
         const resolved = await packageManager.resolve();
-        const disabledExtensions = new Set(policy.effective.extensions);
-        const extensionPaths = [...new Set(resolved.extensions.filter(({ enabled, metadata }) => enabled && (policy.projectTrusted || metadata.scope !== "project")).map(({ path }) => canonicalSourcePath(path)).filter((path) => !disabledExtensions.has(canonicalSourcePath(path))))];
+        const discoveredExtensions = [...new Set(resolved.extensions.filter(({ enabled, metadata }) => enabled && (policy.projectTrusted || metadata.scope !== "project")).map(({ path }) => canonicalSourcePath(path)))];
+        const excludedExtensions = new Set(disabledResources(policy.effective.extensions, discoveredExtensions));
+        const extensionPaths = discoveredExtensions.filter((path) => !excludedExtensions.has(path));
+        Object.assign(policy, { excludedExtensions: [...excludedExtensions], unmatchedExtensions: unmatchedResourcePatterns(policy.effective.extensions, discoveredExtensions) });
         const skillPaths = [...new Set(resolved.skills.filter(({ enabled, metadata }) => enabled && (policy.projectTrusted || metadata.scope !== "project")).map(({ path }) => path))];
         const updateSkillMatches = (skills) => {
-            const names = new Set(skills.map(({ name }) => name));
-            Object.assign(policy, { unmatchedSkills: policy.effective.skills.filter((name) => !names.has(name)) });
+            const names = [...new Set(skills.map(({ name }) => name))];
+            const excludedSkills = disabledResources(policy.effective.skills, names);
+            Object.assign(policy, { excludedSkills, unmatchedSkills: unmatchedResourcePatterns(policy.effective.skills, names) });
+            return new Set(excludedSkills);
         };
-        const disabledSkills = new Set(policy.effective.skills);
         resourceLoader = new DefaultResourceLoader({
             cwd: input.cwd,
             agentDir,
@@ -113,22 +90,18 @@ export async function createNativeAgentSession(input) {
             additionalSkillPaths: skillPaths,
             ...(input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}),
             skillsOverride: (base) => {
-                updateSkillMatches(base.skills);
+                const disabledSkills = updateSkillMatches(base.skills);
                 return { ...base, skills: base.skills.filter(({ name }) => !disabledSkills.has(name)) };
             },
             ...(input.systemPromptAppend ? { appendSystemPromptOverride: (base) => [...base, input.systemPromptAppend ?? ""] } : {}),
         });
         await resourceLoader.reload();
-        const discoveredExtensions = new Set(resolved.extensions.filter(({ enabled, metadata }) => enabled && (policy.projectTrusted || metadata.scope !== "project")).map(({ path }) => canonicalSourcePath(path)));
-        Object.assign(policy, { unmatchedExtensions: policy.effective.extensions.filter((path) => !discoveredExtensions.has(canonicalSourcePath(path))) });
     }
     else if (input.systemPromptAppend || input.extensionFactories?.length) {
         resourceLoader = new DefaultResourceLoader({ cwd: input.cwd, agentDir, ...(input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}), ...(input.systemPromptAppend ? { appendSystemPromptOverride: (base) => [...base, input.systemPromptAppend ?? ""] } : {}) });
         await resourceLoader.reload();
     }
-    const { session, modelFallbackMessage } = await createAgentSession({ ...(input.options ?? {}), cwd: input.cwd, agentDir, modelRuntime, model, ...(settingsManager ? { settingsManager } : {}), ...(input.model.thinking ? { thinkingLevel: input.model.thinking } : {}), tools, ...(customTools.length ? { customTools } : {}), ...(input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}), ...(resourceLoader ? { resourceLoader } : {}), sessionManager: manager });
-    if (input.continuation && modelFallbackMessage)
-        throw new WorkflowError("RESUME_INCOMPATIBLE", modelFallbackMessage);
+    const { session } = await createAgentSession({ ...(input.options ?? {}), cwd: input.cwd, agentDir, modelRuntime, model, ...(settingsManager ? { settingsManager } : {}), ...(input.model.thinking ? { thinkingLevel: input.model.thinking } : {}), tools, ...(customTools.length ? { customTools } : {}), ...(input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}), ...(resourceLoader ? { resourceLoader } : {}), sessionManager: manager });
     return Object.assign(session, {
         getLeafId: () => manager.getLeafId(),
         getToolDefinitions: () => session.getAllTools().map(({ name, description, parameters, promptGuidelines }) => ({ name, description, parameters, ...(promptGuidelines ? { promptGuidelines } : {}) })),
@@ -136,24 +109,6 @@ export async function createNativeAgentSession(input) {
 }
 function changedOption(options, baseline, key) { return JSON.stringify(options[key]) !== JSON.stringify(baseline[key]); }
 function validThinking(value) { return typeof value === "string" && ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(value); }
-function jsonValue(value, seen = new Set()) {
-    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[key])).every((item) => jsonValue(item, seen));
-    seen.delete(value);
-    return valid;
-}
-function jsonObject(value) { return jsonValue(value) && typeof value === "object" && value !== null && !Array.isArray(value); }
 function isChildAgentToolParams(value) {
     if (!jsonObject(value) || typeof value.prompt !== "string" || typeof value.label !== "string")
         return false;
@@ -179,58 +134,9 @@ function fallbackSetupContext(root, options, signal) {
     return { run, identity: Object.freeze({ ...identity, structuralPath: Object.freeze([...identity.structuralPath]) }) };
 }
 function resourcePolicySummary(policy) {
-    return { skills: [...policy.effective.skills], extensions: [...policy.effective.extensions], unmatchedSkills: [...policy.unmatchedSkills], unmatchedExtensions: [...policy.unmatchedExtensions] };
-}
-function canonicalJson(value) {
-    if (Array.isArray(value))
-        return value.map((item) => canonicalJson(item));
-    if (value && typeof value === "object")
-        return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson(item)]));
-    return value;
-}
-function fingerprint(value) { return createHash("sha256").update(JSON.stringify(canonicalJson(value))).digest("hex"); }
-function promptFingerprint(value) { return createHash("sha256").update(value).digest("hex"); }
-function fixedConversationOptions(options) {
-    const fixedOptions = structuredClone(options);
-    delete fixedOptions.timeoutMs;
-    delete fixedOptions.retries;
-    return fixedOptions;
-}
-function conversationExecutionPolicy(options, setup) {
-    return structuredClone({
-        model: setup.sessionInput.model,
-        tools: [...setup.sessionInput.tools],
-        cwd: setup.sessionInput.cwd,
-        role: options.role ?? null,
-        worktreeOwner: options.worktreeOwner ?? null,
-        parent: options.parent ?? null,
-        systemPromptAppend: setup.sessionInput.systemPromptAppend ?? "",
-        options: fixedConversationOptions(setup.options),
-        resourcePolicy: setup.sessionInput.resourcePolicy ? resourcePolicySummary(setup.sessionInput.resourcePolicy) : null,
-    });
-}
-function conversationPolicyMatches(expected, current, allowModelChange) {
-    if (fingerprint(expected) === fingerprint(current))
-        return true;
-    if (!allowModelChange || !expected || typeof expected !== "object" || Array.isArray(expected) || !current || typeof current !== "object" || Array.isArray(current))
-        return false;
-    const expectedModel = conversationPolicyModel(expected);
-    const currentModel = conversationPolicyModel(current);
-    if (!expectedModel || !currentModel)
-        return false;
-    return fingerprint(expected) === fingerprint({ ...current, model: { ...currentModel, provider: expectedModel.provider, model: expectedModel.model } });
-}
-function conversationPolicyModel(policy) {
-    if (!policy || typeof policy !== "object" || Array.isArray(policy))
-        return undefined;
-    const model = policy.model;
-    if (!model || typeof model !== "object" || Array.isArray(model) || typeof model.provider !== "string" || typeof model.model !== "string")
-        return undefined;
-    const thinking = typeof model.thinking === "string" && ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(model.thinking) ? model.thinking : undefined;
-    return thinking === undefined ? { provider: model.provider, model: model.model } : { provider: model.provider, model: model.model, thinking };
+    return { skills: [...policy.effective.skills], extensions: [...policy.effective.extensions], excludedSkills: [...(policy.excludedSkills ?? [])], excludedExtensions: [...(policy.excludedExtensions ?? [])], unmatchedSkills: [...policy.unmatchedSkills], unmatchedExtensions: [...policy.unmatchedExtensions] };
 }
-function conversationFailure(message) { return new WorkflowError("RESUME_INCOMPATIBLE", message); }
-async function prepareAgentSetup(root, createSession, task, options, resolved, cwd, attempt, signal, customTools, resultTool, continuation) {
+async function prepareAgentSetup(root, createSession, task, options, resolved, cwd, attempt, signal, customTools, resultTool) {
     const setupSignal = signal ?? root.runContext?.signal ?? new AbortController().signal;
     const baselineOptions = structuredClone(options.agentOptions ?? {});
     const baseResourcePolicy = await root.agentResourcePolicy?.();
@@ -265,8 +171,6 @@ async function prepareAgentSetup(root, createSession, task, options, resolved, c
         setup.sessionInput.tools = [...setup.options.tools];
     if (changedOption(setup.options, baselineOptions, "cwd") && typeof setup.options.cwd === "string")
         setup.sessionInput.cwd = setup.options.cwd;
-    if (continuation)
-        setup.sessionInput.continuation = { sessionId: continuation.sessionId, sessionFile: continuation.sessionFile, leafId: continuation.leafId };
     const model = setup.sessionInput.model;
     const summary = { hookNames: [...hookNames], model: { provider: model.provider, model: model.model, ...(model.thinking ? { thinking: model.thinking } : {}) }, tools: [...setup.sessionInput.tools], cwd: setup.sessionInput.cwd, ...(setup.sessionInput.resourcePolicy ? { disabledAgentResources: resourcePolicySummary(setup.sessionInput.resourcePolicy) } : {}) };
     return { setup, summary };
@@ -291,17 +195,18 @@ export class WorkflowAgentExecutor {
         if (forbidden)
             throw new WorkflowError("UNKNOWN_TOOL", `Tool is outside the launching session boundary: ${forbidden}`);
         const requestedModel = options.model ?? definition?.model;
-        const hasAlias = requestedModel !== undefined && Object.prototype.hasOwnProperty.call(this.root.modelAliases ?? {}, requestedModel);
-        if (requestedModel !== undefined && this.root.blockedAliases?.has(requestedModel) && !hasAlias) {
-            const target = this.root.blockedAliasTargets?.[requestedModel];
+        const alias = requestedModel === undefined ? undefined : modelAliasName(requestedModel, this.root.modelAliases ?? {});
+        const blockedAlias = requestedModel?.split(":", 1)[0];
+        if (requestedModel !== undefined && blockedAlias && this.root.blockedAliases?.has(blockedAlias) && !alias) {
+            const target = this.root.blockedAliasTargets?.[blockedAlias];
             throw new WorkflowError("UNKNOWN_MODEL", `Unknown model alias ${requestedModel}${target ? ` resolved to ${target}` : ""}${this.root.settingsPath ? ` (settings: ${this.root.settingsPath})` : ""}`);
         }
-        const aliasThinking = requestedModel !== undefined && hasAlias ? resolveModelReference(requestedModel, this.root.modelAliases, this.root.knownModels ?? this.root.availableModels, this.root.settingsPath).thinking : undefined;
+        const aliasThinking = requestedModel !== undefined && alias ? resolveModelReference(requestedModel, this.root.modelAliases, this.root.knownModels ?? this.root.availableModels, this.root.settingsPath).thinking : undefined;
         const model = options.modelOverride ?? parseModel(requestedModel, this.root.model, options.thinking ?? (aliasThinking === undefined ? definition?.thinking : undefined), this.root.modelAliases, this.root.knownModels ?? this.root.availableModels, this.root.settingsPath);
         const availableModels = this.root.knownModels ?? this.root.availableModels ?? new Set([modelCapability(this.root.model)]);
         if (!availableModels.has(modelCapability(model)))
             throw new WorkflowError("UNKNOWN_MODEL", `Unknown model${requestedModel ? ` ${requestedModel} resolved to ${modelCapability(model)}` : ""}${this.root.settingsPath ? ` (settings: ${this.root.settingsPath})` : ""}`);
-        return { model, ...(hasAlias ? { requestedModel } : {}), tools: [...requested], systemPromptAppend: definition?.prompt ?? "" };
+        return { model, ...(alias && requestedModel ? { requestedModel } : {}), tools: [...requested], systemPromptAppend: definition?.prompt ?? "" };
     }
     async execute(task, options, signal, customTools = [], setSteer, beforeRetry) {
         const executionSignal = signal ?? this.root.runContext?.signal;
@@ -339,29 +244,7 @@ export class WorkflowAgentExecutor {
                 throw new WorkflowError("INVALID_METADATA", "Only child agents or worktree scopes may provide a cwd");
             cwd = this.root.cwd;
         }
-        let conversationRecord;
-        if (options.conversation) {
-            const store = this.root.runStore;
-            if (!store)
-                throw conversationFailure("Conversation persistence is unavailable");
-            try {
-                conversationRecord = await store.conversation(options.conversation.id);
-            }
-            catch (error) {
-                throw conversationFailure(`Cannot load conversation state: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            if (conversationRecord) {
-                const model = conversationPolicyModel(conversationRecord.policy);
-                if (model)
-                    resolved = this.resolve({ ...options, modelOverride: model });
-            }
-            if (!Number.isInteger(options.conversation.turn) || options.conversation.turn < 1)
-                throw conversationFailure("Conversation turn must be a positive integer");
-            if (conversationRecord ? conversationRecord.head.turn + 1 !== options.conversation.turn : options.conversation.turn !== 1)
-                throw conversationFailure(`Conversation turn ${String(options.conversation.turn)} does not continue its persisted head`);
-        }
         const attempts = [];
-        let conversationBaseline;
         let maxAttempts = (options.retries ?? 0) + 1;
         for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
             if (recoveryModel)
@@ -374,10 +257,6 @@ export class WorkflowAgentExecutor {
             let setupFailed = false;
             let budgetError;
             let turnStarted = false;
-            let conversationSystemPrompt = "";
-            let conversationToolDefinitionsSha256 = "";
-            let conversationMismatch;
-            const conversationMismatchError = () => conversationMismatch ? new WorkflowError("RESUME_INCOMPATIBLE", conversationMismatch.message) : undefined;
             const hasSchemaResult = () => schemaResult !== undefined;
             const resultTool = options.schema ? {
                 name: "workflow_result", label: "Workflow Result", description: "Submit the terminal structured workflow result", parameters: Type.Unsafe(options.schema),
@@ -411,70 +290,21 @@ export class WorkflowAgentExecutor {
             };
             try {
                 setupFailed = true;
-                const prepared = await prepareAgentSetup(this.root, this.createSession, task, options, resolved, cwd, attempt, executionSignal, customTools, resultTool, conversationRecord?.head);
+                const prepared = await prepareAgentSetup(this.root, this.createSession, task, options, resolved, cwd, attempt, executionSignal, customTools, resultTool);
                 setup = prepared.setup;
                 setupSummary = prepared.summary;
                 setupFailed = false;
                 if (executionSignal?.aborted)
                     throw new WorkflowError("CANCELLED", "Agent cancelled");
-                if (recoveryModel && conversationRecord)
-                    setup.sessionInput.allowModelChange = true;
                 const started = Date.now();
                 session = await setup.createSession(setup.sessionInput);
                 if (setup.sessionInput.resourcePolicy)
                     setupSummary = { ...setupSummary, disabledAgentResources: resourcePolicySummary(setup.sessionInput.resourcePolicy) };
-                if (options.conversation) {
-                    conversationSystemPrompt = session.systemPrompt ?? "";
-                    conversationToolDefinitionsSha256 = fingerprint(session.getToolDefinitions?.() ?? session.agent?.state.tools ?? []);
-                    const currentExecutionPolicy = conversationExecutionPolicy(options, setup);
-                    if (conversationRecord) {
-                        if (session.sessionId !== conversationRecord.head.sessionId || requiredFile(session.sessionFile) !== conversationRecord.head.sessionFile)
-                            throw conversationFailure("Conversation transcript identity changed");
-                        if (!session.getLeafId || (!recoveryModel && session.getLeafId() !== conversationRecord.head.leafId))
-                            throw conversationFailure("Conversation transcript leaf identity changed");
-                        if (!conversationPolicyMatches(conversationRecord.policy, currentExecutionPolicy, Boolean(recoveryModel)))
-                            throw conversationFailure("Conversation execution policy changed");
-                        if (!session.subscribe && (promptFingerprint(conversationSystemPrompt) !== conversationRecord.head.systemPromptSha256 || conversationSystemPrompt !== conversationRecord.head.systemPrompt))
-                            throw conversationFailure("Conversation system prompt changed");
-                        if (conversationToolDefinitionsSha256 !== conversationRecord.head.toolDefinitionsSha256)
-                            throw conversationFailure("Conversation tool definitions changed");
-                    }
-                    else if (conversationBaseline) {
-                        if (!conversationPolicyMatches(conversationBaseline.executionPolicy, currentExecutionPolicy, Boolean(recoveryModel)))
-                            throw conversationFailure("Conversation execution policy changed");
-                        if (conversationToolDefinitionsSha256 !== conversationBaseline.toolDefinitionsSha256)
-                            throw conversationFailure("Conversation tool definitions changed");
-                    }
-                    else {
-                        conversationBaseline = { executionPolicy: currentExecutionPolicy, toolDefinitionsSha256: conversationToolDefinitionsSha256 };
-                    }
-                    if (!session.subscribe) {
-                        const expectedPrompt = conversationRecord?.head.systemPrompt ?? conversationBaseline?.systemPrompt;
-                        const expectedDigest = conversationRecord?.head.systemPromptSha256 ?? conversationBaseline?.systemPromptSha256;
-                        if (expectedPrompt !== undefined && expectedDigest !== undefined && (promptFingerprint(conversationSystemPrompt) !== expectedDigest || expectedPrompt !== conversationSystemPrompt))
-                            throw conversationFailure("Conversation system prompt changed");
-                        if (!conversationRecord && conversationBaseline && conversationBaseline.systemPrompt === undefined)
-                            conversationBaseline = { ...conversationBaseline, systemPrompt: conversationSystemPrompt, systemPromptSha256: promptFingerprint(conversationSystemPrompt) };
-                    }
-                    if (conversationRecord && (!session.model || session.model.provider !== setup.sessionInput.model.provider || (session.model.model ?? session.model.id) !== setup.sessionInput.model.model))
-                        throw conversationFailure("Conversation model changed");
-                }
                 const includeAttemptSetup = Boolean(this.root.agentSetupHooks?.length || setup.sessionInput.resourcePolicy);
                 await options.onAttempt?.({ attempt, sessionId: session.sessionId, sessionFile: requiredFile(session.sessionFile), ...(includeAttemptSetup ? { setup: setupSummary } : {}) });
                 const activeSession = session;
                 unsubscribe = activeSession.subscribe?.((event) => {
                     if (event.type === "agent_start" && session?.systemPrompt !== undefined) {
-                        if (options.conversation) {
-                            conversationSystemPrompt = session.systemPrompt;
-                            const expectedPrompt = conversationRecord?.head.systemPrompt ?? conversationBaseline?.systemPrompt;
-                            const expectedDigest = conversationRecord?.head.systemPromptSha256 ?? conversationBaseline?.systemPromptSha256;
-                            if (expectedPrompt !== undefined && expectedDigest !== undefined && (promptFingerprint(conversationSystemPrompt) !== expectedDigest || expectedPrompt !== conversationSystemPrompt)) {
-                                conversationMismatch = conversationFailure("Conversation system prompt changed");
-                                void session.abort?.();
-                            }
-                            if (!conversationRecord && conversationBaseline && conversationBaseline.systemPrompt === undefined)
-                                conversationBaseline = { ...conversationBaseline, systemPrompt: conversationSystemPrompt, systemPromptSha256: promptFingerprint(conversationSystemPrompt) };
-                        }
                         if (this.root.runStore) {
                             systemPromptTurn += 1;
                             const entry = { sessionId: session.sessionId, attempt, turn: systemPromptTurn, prompt: session.systemPrompt };
@@ -528,6 +358,7 @@ export class WorkflowAgentExecutor {
                         if (activity?.kind === "tool" && activity.text === event.toolName)
                             activity = undefined;
                         report(false);
+                        toolCalls.delete(event.toolCallId);
                     }
                 });
                 report(false);
@@ -548,8 +379,6 @@ export class WorkflowAgentExecutor {
                     if (!hasSchemaResult())
                         throw error;
                 }
-                if (conversationMismatch)
-                    throw conversationMismatch;
                 throwIfTerminalAssistantError(session, setup.sessionInput.model);
                 {
                     const completedAccounting = accounting(session.getSessionStats());
@@ -596,9 +425,6 @@ export class WorkflowAgentExecutor {
                     if (schemaResult === undefined)
                         throw new WorkflowError("RESULT_INVALID", "Agent did not submit a valid workflow_result after one repair");
                 }
-                const mismatch = conversationMismatchError();
-                if (mismatch)
-                    throw mismatch;
                 const value = options.schema ? schemaResult : text(session.messages);
                 if (options.worktreeOwner)
                     await this.root.runStore?.snapshotWorktree(options.worktreeOwner);
@@ -607,22 +433,13 @@ export class WorkflowAgentExecutor {
                 await flushSystemPrompts();
                 unsubscribe?.();
                 const attemptAccounting = accounting(session.getSessionStats());
-                const leafId = session.getLeafId?.() ?? undefined;
-                if (options.conversation) {
-                    if (!leafId)
-                        throw conversationFailure("Conversation transcript has no persisted leaf");
-                    const store = this.root.runStore;
-                    if (!store)
-                        throw conversationFailure("Conversation persistence is unavailable");
-                    await store.saveConversation({ id: options.conversation.id, policy: conversationExecutionPolicy(options, setup), head: { turn: options.conversation.turn, sessionId: session.sessionId, sessionFile: requiredFile(session.sessionFile), leafId, systemPrompt: conversationSystemPrompt, systemPromptSha256: promptFingerprint(conversationSystemPrompt), toolDefinitionsSha256: conversationToolDefinitionsSha256 } });
-                }
                 const includeCompletedSetup = Boolean(this.root.agentSetupHooks?.length || setup.sessionInput.resourcePolicy);
                 attempts.push({ attempt, sessionId: session.sessionId, sessionFile: requiredFile(session.sessionFile), result: value, accounting: attemptAccounting, ...(includeCompletedSetup ? { setup: setupSummary } : {}) });
                 session.dispose();
                 return { value, attempts, cwd: setupSummary.cwd };
             }
             catch (error) {
-                const typed = budgetError ?? conversationMismatch ?? (error instanceof WorkflowError ? error : new WorkflowError(executionSignal?.aborted && setupFailed ? "CANCELLED" : "AGENT_FAILED", error instanceof Error ? error.message : String(error)));
+                const typed = budgetError ?? (error instanceof WorkflowError ? error : new WorkflowError(executionSignal?.aborted && setupFailed ? "CANCELLED" : "AGENT_FAILED", error instanceof Error ? error.message : String(error)));
                 if (session) {
                     report(true);
                     await progress;
@@ -704,6 +521,15 @@ export class FairAgentScheduler {
         this.#runs.set(runId, { limit, ...(beforeLaunch ? { beforeLaunch } : {}), logical: 0, active: 0, queue: [] });
         this.#runOrder.push(runId);
     }
+    updateRunLimit(runId, limit) {
+        const run = this.#runs.get(runId);
+        if (!run)
+            throw new WorkflowError("INTERNAL_ERROR", `Unknown scheduler run: ${runId}`);
+        if (!Number.isInteger(limit) || limit < 1 || limit > this.sessionLimit)
+            throw new WorkflowError("INVALID_SETTINGS", "Invalid run concurrency");
+        run.limit = limit;
+        this.#dispatch();
+    }
     spawn(runId, prompt, options, parentId) {
         const run = this.#runs.get(runId);
         if (!run)