clinkx 1.0.0 → 1.1.0

package/clinkx-workflows/dist/workflow-tools.js

@@ -17,14 +17,16 @@
  */
 import { CallToolRequestSchema, ListToolsRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
 import { existsSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { computeRunHealth } from "./run-health.js";
 import { loadWorkflow, listWorkflowCatalog } from "./loader.js";
-import { WorkflowEngine } from "./engine.js";
+import { defaultWorkflowAllowedRoots, WorkflowEngine } from "./engine.js";
 import { readRunStateForStatus, reapRunCancelled, WorkflowStateStore } from "./state.js";
-import { parseContextBuilderLifecycleStateV1, } from "./context-builder-lifecycle-contract.js";
+import { isTerminalContextBuilderLifecycleStatus, parseContextBuilderLifecycleStateV1, } from "./context-builder-lifecycle-contract.js";
 import { validateRunId } from "./run-id.js";
+import { validateDynamicPaths } from "./path-validation.js";
 import { getMaxPromptBytes, getRunStateDir, getTemplatesPath, getWorkflowsContextDefault, getWorkflowsContextDefaultCurator, getWorkflowsMaxConcurrentAsync, resolveWorkspaceRoot, } from "./config.js";
-import { WorkflowCancellationError, } from "./errors.js";
+import { WorkflowCancellationError, WorkflowValidationError, } from "./errors.js";
 import { shutdownCoordinator } from "./shutdown.js";
 import { logger } from "./logger.js";
 import { createValidatorRegistry } from "./validators/index.js";
@@ -32,9 +34,11 @@ import { deriveDecisiveFailure } from "./run-summary-derived.js";
 import { buildRunSummaryOrUndefined, buildFailureRunSummary } from "./run-summary.js";
 import { extractCard } from "./run-summary/cards/index.js";
 import { renderWorkflowReceipt } from "./workflow-receipt.js";
-import { supportsRuntimeMembers, COUNCIL_RUNTIME_MEMBER_WORKFLOWS, expandCouncilComposition } from "./council-expander.js";
+import { supportsRuntimeMembers, COUNCIL_RUNTIME_MEMBER_WORKFLOWS, COUNCIL_STAGE_COUNT, expandCouncilComposition } from "./council-expander.js";
 import { resolveWorkflowContextMode, WorkflowContextModeResolverError, } from "./context-mode-resolver.js";
-import { WorkflowDelegateValidationError } from "./delegate-validate.js";
+import { resolveEffectiveChairmanCall } from "./chairman-knobs.js";
+import { disabledFinalizerOverrideRejection, effectiveFinalizerEnabled, } from "./delegate-finalizer-policy.js";
+import { delegateFinalizerMinScoreExplicit, WorkflowDelegateValidationError, } from "./delegate-validate.js";
 import { contextSearchTermsValidationError, contextSeedSourceValidationError, resolveSeedSource, } from "./seed-terms.js";
 import { LEGACY_PLAN_REVIEW_RECEIPTS_WORKFLOW_NAME, PLAN_REVIEW_RECEIPTS_WORKFLOW, admitCouncilPlanReview, assertPlanReviewPromptBudget, isPlanReviewRunState, } from "./plan-review/admission.js";
 import { PLAN_REVIEW_V1_CLI_NAMES } from "./plan-review/contract.js";
@@ -49,6 +53,7 @@ import { CouncilPlanReviewErrorSchema, createPlanReviewPublicationError, inspect
 import { validatePlanReviewCallBindings, validatePlanReviewPreparedInputPolicy, } from "./plan-review/runtime-policy.js";
 import { ContainedFilePolicyError, readContainedRelativeFile, } from "./contained-file.js";
 import { createDashboardRunReader } from "./dashboard/read-model.js";
+import { ROSTER_NAME_PATTERN, ResolvedRosterSchema, } from "./roster-contract.js";
 async function inspectLegacyWorkflowSessionLogGeneration(runDir, runId) {
     try {
         const result = await createDashboardRunReader().inspectGeneration?.(dirname(runDir), runId);
@@ -91,6 +96,38 @@ function createPreflightOnlyBackend(advertisedCliNames) {
 // Admission control
 // ---------------------------------------------------------------------------
 const activeRuns = new Map();
+/**
+ * Number of workflow tool handlers currently executing in the standalone
+ * registration path. This includes non-run tools such as status/list/cancel;
+ * it is kept separate from activeRuns because an admitted run can outlive its
+ * request handler (async mode), while a handler can be busy before admission.
+ */
+let activeWorkflowHandlers = 0;
+let workflowActivityObserver;
+/** Internal standalone-lifecycle seam; not part of the public package API. */
+export function getActiveWorkflowHandlerCount() {
+    return activeWorkflowHandlers;
+}
+/** Internal shared lifecycle seam used by the root server's compiled import. */
+export function getActiveWorkflowRunCount() {
+    return activeRuns.size;
+}
+/**
+ * Install the standalone server's activity sink. The observer is optional and
+ * process-local; library callers leave it unset, so importing this module or
+ * using the in-process registration path has no timer/lifecycle side effects.
+ */
+export function setWorkflowActivityObserver(observer) {
+    workflowActivityObserver = observer;
+}
+function notifyWorkflowActivity() {
+    try {
+        workflowActivityObserver?.();
+    }
+    catch (error) {
+        logger.warn({ err: error instanceof Error ? error.message : String(error) }, "workflow activity observer failed");
+    }
+}
 /**
  * In-process registry of AbortControllers for live async runs, keyed by run_id.
  * cancel_workflow aborts the controller to drive the run's own cancellation
@@ -109,6 +146,9 @@ export function resolveWorkflowAsyncAdmissionCap(options) {
     return getWorkflowsMaxConcurrentAsync();
 }
 function acquireMutex(runId, options) {
+    if (shutdownCoordinator.isShuttingDown()) {
+        throw new McpError(ErrorCode.InvalidRequest, "workflow server is shutting down");
+    }
     if (activeRuns.has(runId)) {
         throw new McpError(ErrorCode.InvalidParams, `run_id ${runId} already running`);
     }
@@ -120,6 +160,97 @@ function acquireMutex(runId, options) {
 }
 function releaseMutex(runId) {
     activeRuns.delete(runId);
+    notifyWorkflowActivity();
+}
+/** Own setup before its first await, and keep that ownership through cleanup. */
+function acquireWorkflowRun(runId, options, requestSignal) {
+    acquireMutex(runId, options);
+    const controller = new AbortController();
+    const signal = requestSignal === undefined
+        ? controller.signal
+        : AbortSignal.any([requestSignal, controller.signal]);
+    let backend;
+    let termination;
+    const terminate = () => {
+        if (backend === undefined || backend.isTerminated)
+            return termination ?? Promise.resolve();
+        termination ??= Promise.resolve().then(() => backend.terminate());
+        return termination;
+    };
+    let complete;
+    const completion = new Promise((resolve) => { complete = resolve; });
+    let handle;
+    try {
+        // The run owns persistence and close; shutdown only interrupts the lazy
+        // backend and waits until the run's own finally releases all resources.
+        handle = shutdownCoordinator.register({ terminate }, controller, async () => { }, completion);
+    }
+    catch (error) {
+        releaseMutex(runId);
+        complete();
+        throw error;
+    }
+    if (requestSignal === undefined)
+        cancelRegistry.set(runId, controller);
+    return {
+        signal,
+        throwIfCancelled: () => {
+            if (signal.aborted)
+                throw new WorkflowCancellationError();
+        },
+        setBackend: (value) => { backend = value; },
+        finish: async (store) => {
+            try {
+                try {
+                    await terminate();
+                }
+                catch (err) {
+                    logger.warn({ err }, "backend.terminate() failed during cleanup");
+                }
+                try {
+                    await store?.close();
+                }
+                catch (err) {
+                    logger.warn({ err }, "store.close() failed during cleanup");
+                }
+            }
+            finally {
+                cancelRegistry.delete(runId);
+                releaseMutex(runId);
+                shutdownCoordinator.unregister(handle);
+                complete();
+            }
+        },
+    };
+}
+async function markWorkflowCancelled(store) {
+    try {
+        await store?.markCancelled();
+    }
+    catch (err) {
+        // Preserve cancellation/no-response even if best-effort persistence fails.
+        logger.warn({ err }, "markCancelled during cancellation handling failed");
+    }
+}
+// Keep in sync with schema.ts model regex and ModelSchema (delegate-validate.ts).
+const MODEL_OVERRIDE_PATTERN = /^[^\s\u0000-][^\s\u0000]*$/;
+// Keep in sync with schema.ts effort regex and EffortSchema (delegate-validate.ts).
+const EFFORT_OVERRIDE_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+function parseInvocationOverride(raw, label, maxLength, pattern) {
+    if (typeof raw !== "string") {
+        throw new McpError(ErrorCode.InvalidParams, `${label} must be a string`);
+    }
+    const value = raw.trim();
+    if (value.length === 0) {
+        throw new McpError(ErrorCode.InvalidParams, `${label} must not be empty`);
+    }
+    if (value.length > maxLength) {
+        throw new McpError(ErrorCode.InvalidParams, `${label} must be at most ${maxLength} characters`);
+    }
+    if (!pattern.test(value)) {
+        throw new McpError(ErrorCode.InvalidParams, `${label} has an invalid format`);
+    }
+    return value;
 }
 export function parseMembersOverride(raw, knownCliNames) {
     if (raw == null)
@@ -140,7 +271,7 @@ export function parseMembersOverride(raw, knownCliNames) {
             throw new McpError(ErrorCode.InvalidParams, `members[${i}] must be a non-null object`);
         }
         const keys = Object.keys(item);
-        const allowedKeys = new Set(["cli_name", "stance"]);
+        const allowedKeys = new Set(["cli_name", "stance", "model", "effort"]);
         for (const key of keys) {
             if (!allowedKeys.has(key)) {
                 throw new McpError(ErrorCode.InvalidParams, `members[${i}] has unexpected key "${key}"`);
@@ -179,6 +310,12 @@ export function parseMembersOverride(raw, knownCliNames) {
         else if (i >= 3) {
             throw new McpError(ErrorCode.InvalidParams, "stance is required for members at index 3 and above");
         }
+        if (obj["model"] !== undefined) {
+            entry.model = parseInvocationOverride(obj["model"], `members[${i}].model`, 128, MODEL_OVERRIDE_PATTERN);
+        }
+        if (obj["effort"] !== undefined) {
+            entry.effort = parseInvocationOverride(obj["effort"], `members[${i}].effort`, 32, EFFORT_OVERRIDE_PATTERN);
+        }
         result.push(entry);
     }
     return result;
@@ -202,6 +339,93 @@ export function parseChairmanOverride(raw, knownCliNames) {
     }
     return trimmed;
 }
+function parseChairmanModelOverride(raw) {
+    if (raw === undefined)
+        return undefined;
+    return parseInvocationOverride(raw, "chairman_model", 128, MODEL_OVERRIDE_PATTERN);
+}
+function parseChairmanEffortOverride(raw) {
+    if (raw === undefined)
+        return undefined;
+    return parseInvocationOverride(raw, "chairman_effort", 32, EFFORT_OVERRIDE_PATTERN);
+}
+function invocationOverrideKnobs(value) {
+    if (value.model === undefined && value.effort === undefined) {
+        return undefined;
+    }
+    return {
+        ...(value.model === undefined ? {} : { model: value.model }),
+        ...(value.effort === undefined ? {} : { effort: value.effort }),
+    };
+}
+function validateInvocationOverridesAtAdmission(workflow, definition, parsedMembers, parsedChairman, parsedChairmanModel, parsedChairmanEffort, initialContextPolicy, resolvedVariables, validate, callerDelegateRaw) {
+    // Structural E5: independent of the optional adapter-capability hook so the
+    // standalone server rejects a disabled-finalizer override too. No-op when
+    // the policy has no enabled delegate (including the no-runner `off` default).
+    const admissionDelegate = initialContextPolicy.effectiveDelegate;
+    if (admissionDelegate?.enabled === true) {
+        const rejection = disabledFinalizerOverrideRejection(admissionDelegate, resolvedVariables, delegateFinalizerMinScoreExplicit(callerDelegateRaw));
+        if (rejection !== undefined) {
+            throw new McpError(ErrorCode.InvalidParams, rejection);
+        }
+    }
+    if (validate == null)
+        return;
+    const councilWorkflow = COUNCIL_RUNTIME_MEMBER_WORKFLOWS.has(workflow);
+    if (councilWorkflow && definition.stages.length !== COUNCIL_STAGE_COUNT) {
+        throw new McpError(ErrorCode.InvalidParams, `Council workflow "${workflow}" expects ${COUNCIL_STAGE_COUNT} stages, found ${definition.stages.length}`);
+    }
+    const staticChairman = councilWorkflow
+        ? definition.stages[3]?.calls[0]
+        : undefined;
+    for (const [stageIndex, stage] of definition.stages.entries()) {
+        for (const call of stage.calls) {
+            if (call === staticChairman) {
+                continue;
+            }
+            if (parsedMembers !== undefined && stageIndex < 2) {
+                continue;
+            }
+            const knobs = invocationOverrideKnobs(call);
+            if (knobs !== undefined) {
+                validate(call.cli_name, knobs);
+            }
+        }
+    }
+    if (parsedMembers !== undefined) {
+        for (const member of parsedMembers) {
+            const knobs = invocationOverrideKnobs(member);
+            if (knobs !== undefined) {
+                validate(member.cli_name, knobs);
+            }
+        }
+    }
+    if (councilWorkflow && staticChairman !== undefined) {
+        const effectiveChairman = resolveEffectiveChairmanCall({
+            staticCall: staticChairman,
+            chairmanCliName: parsedChairman,
+            chairmanModel: parsedChairmanModel,
+            chairmanEffort: parsedChairmanEffort,
+        });
+        const knobs = invocationOverrideKnobs(effectiveChairman);
+        if (knobs !== undefined) {
+            validate(effectiveChairman.cli_name, knobs);
+        }
+    }
+    const delegate = initialContextPolicy.effectiveDelegate;
+    if (delegate?.enabled === true) {
+        const curatorKnobs = invocationOverrideKnobs(delegate.curator);
+        if (curatorKnobs !== undefined) {
+            validate(delegate.curator.cli_name, curatorKnobs);
+        }
+        if (effectiveFinalizerEnabled(delegate, resolvedVariables)) {
+            const finalizerKnobs = invocationOverrideKnobs(delegate.finalizer);
+            if (finalizerKnobs !== undefined) {
+                validate(delegate.finalizer.cli_name, finalizerKnobs);
+            }
+        }
+    }
+}
 /**
  * Point a generic-council caller at the input shape the workflow actually takes.
  *
@@ -290,6 +514,94 @@ export function validateVariables(supplied, schema) {
     }
     return resolved;
 }
+/**
+ * Reject caller-supplied dynamic path variables that fall outside the workflow
+ * engine's allowed roots, at ADMISSION — before the concurrency mutex, before
+ * any run state exists, and before context preflight spends a delegate
+ * round-trip. The engine already rejects these paths, but only at
+ * `validateInputPathsExist()`, which runs AFTER preflight: by then the caller
+ * has paid for a curator/finalizer subprocess and is left with a `failed` run
+ * directory to inspect and prune.
+ *
+ * This is a pre-check, NOT a replacement. The engine's post-preflight check
+ * must stay: it is the only thing that covers preflight-produced bundle copies
+ * appended to `context_bundle_files`, which do not exist yet at admission.
+ *
+ * Three deliberate narrowings, each of which exists to avoid rejecting a run
+ * that succeeds today:
+ *
+ * (i)   Only variable names the DEFINITION actually wires through
+ *       `absolute_file_paths_from` / `images_from` are validated. A caller may
+ *       legitimately pass any other declared variable that happens to hold
+ *       path-like strings; the engine never resolves those as paths, so
+ *       validating them here would reject working runs.
+ * (ii)  `plan-review-receipts` is skipped entirely.
+ *       `enforcePlanReviewContextExclusions` strips force-excluded plan paths
+ *       BEFORE the engine's check, so a path destined for stripping is never
+ *       validated today and must not start being rejected at admission.
+ * (iii) The resume path does not call this. Resume prefers persisted inputs and
+ *       skips completed calls, so re-validating current variables could reject a
+ *       resume whose original admission passed.
+ *
+ * Non-array values and non-string entries are deliberately NOT rejected here —
+ * they are left to the engine so its existing error text is unchanged.
+ */
+function assertCallerDynamicPathsAllowed(normalized, variables, workflowName, runId) {
+    // Caveat (ii).
+    if (workflowName === PLAN_REVIEW_RECEIPTS_WORKFLOW) {
+        return;
+    }
+    // Caveat (i): the set of variable names this definition wires as paths.
+    const wiredNames = new Set();
+    const collectWiredNames = (declared) => {
+        if (typeof declared === "string") {
+            wiredNames.add(declared);
+            return;
+        }
+        if (declared === undefined) {
+            return;
+        }
+        for (const name of declared) {
+            wiredNames.add(name);
+        }
+    };
+    for (const stage of normalized.stages) {
+        for (const call of stage.calls) {
+            collectWiredNames(call.absolute_file_paths_from);
+            collectWiredNames(call.images_from);
+        }
+    }
+    if (wiredNames.size === 0) {
+        return;
+    }
+    // The engine derives its own roots and never consults CLINKX_ALLOWED_ROOTS;
+    // mirror that exact set so admission cannot be stricter or looser than
+    // dispatch.
+    const allowedRoots = defaultWorkflowAllowedRoots(getRunStateDir(runId));
+    const workspaceRoot = resolveWorkspaceRoot();
+    for (const name of wiredNames) {
+        const rawValue = variables[name];
+        if (!Array.isArray(rawValue)) {
+            continue;
+        }
+        // Mirrors resolveDynamicPathVariable (engine.ts) exactly.
+        const values = rawValue
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => (isAbsolute(entry) ? entry : resolve(workspaceRoot, entry)));
+        if (values.length === 0) {
+            continue;
+        }
+        try {
+            validateDynamicPaths(values, allowedRoots, `${workflowName}.${name}`);
+        }
+        catch (err) {
+            if (err instanceof WorkflowValidationError) {
+                throw new McpError(ErrorCode.InvalidParams, err.message);
+            }
+            throw err;
+        }
+    }
+}
 function validateContextBuilderAnchorSufficiency(variables, runner, contextDefault, defaultCurator) {
     if (runner == null) {
         return undefined;
@@ -803,6 +1115,21 @@ function appendDuplicateReplayBlock(content, store) {
         text: JSON.stringify({ duplicate_of_failed_run: duplicateOfFailedRun }),
     });
 }
+/**
+ * Trailing additive content block for the admission-time requested-value
+ * roster. Omitted when the run did not persist one (non-council, plan-review,
+ * or pre-roster state). Defensive optional access: partial store mocks may
+ * omit runState.
+ */
+function appendResolvedRosterBlock(content, store) {
+    const resolvedRoster = store?.runState?.resolvedRoster;
+    if (resolvedRoster === undefined)
+        return;
+    content.push({
+        type: "text",
+        text: JSON.stringify({ resolved_roster: resolvedRoster }),
+    });
+}
 // ---------------------------------------------------------------------------
 // Actionable error formatting (5-6)
 // ---------------------------------------------------------------------------
@@ -892,14 +1219,45 @@ function toCouncilPlanReviewError(runId, error) {
         },
     });
 }
+/**
+ * Read a well-formed `failureClass` the error already carries. Structural on
+ * purpose: errors crossing the engine boundary cannot be narrowed by
+ * `instanceof` here, and this must never GUESS a class — an error without one
+ * yields undefined, which `markFailed` treats as "leave the existing class
+ * alone".
+ */
+function carriedFailureClass(error) {
+    if (error == null || typeof error !== "object") {
+        return undefined;
+    }
+    const value = error.failureClass;
+    return value === "transient" || value === "permanent" ? value : undefined;
+}
 async function markWorkflowFailed(store, runId, error) {
     const message = error instanceof Error ? error.message : String(error);
+    // Forward a class the error already carries. Load-bearing on the RESUME path:
+    // `beginResumeAttempt` clears `failureClass`, and the resume preflight engine
+    // never runs `execute()`, so its catch never stamps one — without this a
+    // bounded-preflight timeout persists `failed` with no class at all, while the
+    // identical first-run failure keeps `transient`. Safe for the other call
+    // sites: `markFailed` assigns only when defined, so an error carrying no
+    // class still cannot clobber a class the engine already emitted.
     const planReviewError = toCouncilPlanReviewError(runId, error);
-    if (planReviewError === undefined) {
+    if (planReviewError !== undefined) {
+        // Plan-review terminal intent is first-wins. Forwarding a class here would
+        // flip `replaceFailureClass` and overwrite a recorded intent, so this call
+        // stays exactly as it was.
+        await store.markFailed(message, undefined, planReviewError);
+        return;
+    }
+    const failureClass = carriedFailureClass(error);
+    if (failureClass === undefined) {
+        // Nothing to add: keep the original single-argument call so callers that
+        // rely on `markFailed`'s existing behavior are byte-identical.
         await store.markFailed(message);
         return;
     }
-    await store.markFailed(message, undefined, planReviewError);
+    await store.markFailed(message, failureClass);
 }
 function getCallEntryByLocation(stages, location) {
     const dotIndex = location.indexOf(".");
@@ -912,6 +1270,54 @@ function getCallEntryByLocation(stages, location) {
     return stage?.calls.find((call) => call.callId === callId);
 }
 // ---------------------------------------------------------------------------
+// Roster preset admission (pre-mutex, pre-state)
+// ---------------------------------------------------------------------------
+function applyRosterPresetAtAdmission(workflow, args, variables, rosterLoader) {
+    const raw = args["roster"];
+    if (typeof raw !== "string") {
+        throw new McpError(ErrorCode.InvalidParams, "roster must be a string");
+    }
+    if (!COUNCIL_RUNTIME_MEMBER_WORKFLOWS.has(workflow)) {
+        throw new McpError(ErrorCode.InvalidParams, `roster parameter is not supported for workflow "${workflow}"`);
+    }
+    const conflicts = [];
+    if (args["members"] != null)
+        conflicts.push("members");
+    if (args["chairman"] != null)
+        conflicts.push("chairman");
+    if (args["chairman_model"] != null)
+        conflicts.push("chairman_model");
+    if (args["chairman_effort"] != null)
+        conflicts.push("chairman_effort");
+    const cbDelegate = variables?.["cb_delegate"];
+    if (typeof cbDelegate === "string" && cbDelegate !== "") {
+        conflicts.push("cb_delegate");
+    }
+    if (conflicts.length > 0) {
+        throw new McpError(ErrorCode.InvalidParams, `roster is exclusive and cannot be combined with ${conflicts.join(", ")}`);
+    }
+    if (rosterLoader == null) {
+        throw new McpError(ErrorCode.InvalidParams, "rosters are not available on this server");
+    }
+    const preset = rosterLoader.load(raw);
+    if (preset === undefined) {
+        const available = rosterLoader.list().map((entry) => entry.name).join(", ");
+        throw new McpError(ErrorCode.InvalidParams, `roster "${raw}" is not a known roster. Available: ${available}`);
+    }
+    const chairman = preset.chairman;
+    const nextVariables = preset.delegate !== undefined
+        ? { ...(variables ?? {}), cb_delegate: JSON.stringify(preset.delegate) }
+        : variables;
+    return {
+        rosterName: raw,
+        membersRaw: preset.members,
+        chairmanRaw: chairman?.cli_name,
+        chairmanModelRaw: chairman?.model,
+        chairmanEffortRaw: chairman?.effort,
+        variables: nextVariables,
+    };
+}
+// ---------------------------------------------------------------------------
 // Tool execution helpers
 // ---------------------------------------------------------------------------
 async function executeRunWorkflow(server, options, args, signal, progressToken) {
@@ -947,25 +1353,53 @@ async function executeRunWorkflow(server, options, args, signal, progressToken)
     const genericShaped = workflow === PLAN_REVIEW_RECEIPTS_WORKFLOW &&
         (args["plan_review"] == null ||
             args["members"] != null ||
-            args["chairman"] != null);
+            args["chairman"] != null ||
+            args["chairman_model"] != null ||
+            args["chairman_effort"] != null ||
+            args["roster"] != null);
     // Declarations hoisted out of the decorator's try so the bindings stay in
     // scope for the post-admission code below; the assignments and their order
     // are unchanged.
     let parsedMembers;
     let parsedChairman;
+    let parsedChairmanModel;
+    let parsedChairmanEffort;
     let resolvedVariables;
     let initialContextPolicy;
     let planReviewAdmission;
+    let admittedRosterName;
     try {
-        parsedMembers = parseMembersOverride(args["members"], knownCliNames);
-        parsedChairman = parseChairmanOverride(args["chairman"], knownCliNames);
+        let membersRaw = args["members"];
+        let chairmanRaw = args["chairman"];
+        let chairmanModelRaw = args["chairman_model"];
+        let chairmanEffortRaw = args["chairman_effort"];
+        let suppliedVariables = variables;
+        if (args["roster"] !== undefined) {
+            const applied = applyRosterPresetAtAdmission(workflow, args, variables, options.rosterLoader);
+            admittedRosterName = applied.rosterName;
+            membersRaw = applied.membersRaw;
+            chairmanRaw = applied.chairmanRaw;
+            chairmanModelRaw = applied.chairmanModelRaw;
+            chairmanEffortRaw = applied.chairmanEffortRaw;
+            suppliedVariables = applied.variables;
+        }
+        parsedMembers = parseMembersOverride(membersRaw, knownCliNames);
+        parsedChairman = parseChairmanOverride(chairmanRaw, knownCliNames);
+        parsedChairmanModel = parseChairmanModelOverride(chairmanModelRaw);
+        parsedChairmanEffort = parseChairmanEffortOverride(chairmanEffortRaw);
         if (parsedMembers != null && !COUNCIL_RUNTIME_MEMBER_WORKFLOWS.has(workflow)) {
             throw new McpError(ErrorCode.InvalidParams, `members parameter is not supported for workflow "${workflow}"`);
         }
         if (parsedChairman != null && !COUNCIL_RUNTIME_MEMBER_WORKFLOWS.has(workflow)) {
             throw new McpError(ErrorCode.InvalidParams, `chairman parameter is not supported for workflow "${workflow}"`);
         }
-        resolvedVariables = validateVariables(variables, loaded.definition.variables);
+        if (parsedChairmanModel != null && !COUNCIL_RUNTIME_MEMBER_WORKFLOWS.has(workflow)) {
+            throw new McpError(ErrorCode.InvalidParams, `chairman_model parameter is not supported for workflow "${workflow}"`);
+        }
+        if (parsedChairmanEffort != null && !COUNCIL_RUNTIME_MEMBER_WORKFLOWS.has(workflow)) {
+            throw new McpError(ErrorCode.InvalidParams, `chairman_effort parameter is not supported for workflow "${workflow}"`);
+        }
+        resolvedVariables = validateVariables(suppliedVariables, loaded.definition.variables);
         // When the runner is absent (preflight disabled / hard kill), the boundary
         // validator is inert. Skip it WITHOUT evaluating the context-default env
         // parsers — getWorkflowsContextDefaultCurator() throws on empty env, and a
@@ -975,6 +1409,9 @@ async function executeRunWorkflow(server, options, args, signal, progressToken)
             contextPolicy = validateContextBuilderAnchorSufficiency(resolvedVariables, options.contextBuilderRunner, options.contextDefault ?? getWorkflowsContextDefault(), options.defaultCurator ?? getWorkflowsContextDefaultCurator());
         }
         validateContextSeedSourceAtAdmission(resolvedVariables, contextPolicy);
+        // Pre-mutex, pre-state, pre-preflight: an out-of-roots caller path costs
+        // zero delegate round-trips and leaves no run directory behind.
+        assertCallerDynamicPathsAllowed(loaded.normalized, resolvedVariables, workflow, runId);
         initialContextPolicy = contextPolicy ?? resolveWorkflowContextMode(undefined, options.contextDefault ?? "off", false, undefined, options.defaultCurator);
         if (options.contextBuilderRunner != null) {
             try {
@@ -1009,6 +1446,11 @@ async function executeRunWorkflow(server, options, args, signal, progressToken)
         }
         throw err;
     }
+    validateInvocationOverridesAtAdmission(workflow, loaded.normalized, parsedMembers, parsedChairman, parsedChairmanModel, parsedChairmanEffort, initialContextPolicy, resolvedVariables, options.validateInvocationOverrides, 
+    // Caller-supplied cb_delegate only, never the roster-materialized one: a
+    // roster preset is Zod-parsed at load, which defaults min_score and erases
+    // whether the preset file actually requested it.
+    admittedRosterName === undefined ? variables?.["cb_delegate"] : undefined);
     // A-7: reject caller context anchors that resolve to the bound plan or any
     // plan-workspace PLAN.md. Pre-mutex, so a rejected request creates no state:
     // the caller must not be able to hand actors a MUTABLE plan alongside the
@@ -1031,8 +1473,8 @@ async function executeRunWorkflow(server, options, args, signal, progressToken)
             snapshotAbsolutePath: join(getRunStateDir(runId), PLAN_SNAPSHOT_RELPATH),
         };
     }
-    acquireMutex(runId, options);
     const isAsync = args["async"] === true;
+    const ownership = acquireWorkflowRun(runId, options, isAsync ? undefined : signal);
     if (isAsync) {
         // Everything between acquireMutex and the detached spawn must release the
         // mutex on ANY throw, or the run slot leaks permanently (bricks the server
@@ -1042,6 +1484,7 @@ async function executeRunWorkflow(server, options, args, signal, progressToken)
         let initializedPlanReview;
         let preparedSnapshot;
         try {
+            ownership.throwIfCancelled();
             const runDir = getRunStateDir(runId);
             if (existsSync(runDir)) {
                 throw new McpError(ErrorCode.InvalidParams, `run_id ${runId} already has persisted state at ${runDir}`);
@@ -1051,8 +1494,10 @@ async function executeRunWorkflow(server, options, args, signal, progressToken)
             preparedSnapshot = planReviewPlan === undefined
                 ? undefined
                 : await preparePlanReviewSnapshot(planReviewPlan);
+            ownership.throwIfCancelled();
             // Expand composition ONCE in the foreground; the detached run reuses it.
-            effectiveDefinition = expandRunWorkflowDefinition(loaded.normalized, workflow, parsedMembers, parsedChairman, planReviewPlan, preparedSnapshot);
+            effectiveDefinition = expandRunWorkflowDefinition(loaded.normalized, workflow, parsedMembers, parsedChairman, parsedChairmanModel, parsedChairmanEffort, planReviewPlan, preparedSnapshot);
+            const resolvedRoster = resolvedRosterForAdmission(workflow, effectiveDefinition, parsedMembers, parsedChairman, parsedChairmanModel, parsedChairmanEffort, initialContextPolicy, resolvedVariables, admittedRosterName);
             // Create the durable, pollable state record in the FOREGROUND so a failure
             // here surfaces synchronously (a real error, never a false "running").
             try {
@@ -1063,21 +1508,29 @@ async function executeRunWorkflow(server, options, args, signal, progressToken)
                     debugKeepArtifacts: debug,
                     async: true,
                     initialContextPolicy,
+                    ...(resolvedRoster !== undefined ? { resolvedRoster } : {}),
+                    ...(admittedRosterName !== undefined ? { rosterName: admittedRosterName } : {}),
                 });
             }
             catch (err) {
                 throw new McpError(ErrorCode.InternalError, `Failed to initialize async run ${runId}: ${err instanceof Error ? err.message : String(err)}`);
             }
+            ownership.throwIfCancelled();
             // A-10: the async acknowledgement is a durability boundary. A caller
             // cannot observe `running` until every plan-review snapshot and the
             // strict typed state subtree have committed successfully.
             if (planReviewPlan !== undefined) {
                 initializedPlanReview = await initializePlanReviewRunState(store, planReviewPlan, effectiveDefinition, preparedSnapshot);
             }
+            ownership.throwIfCancelled();
         }
         catch (err) {
-            if (store !== undefined && planReviewPlan !== undefined) {
-                try {
+            try {
+                if (ownership.signal.aborted || err instanceof WorkflowCancellationError) {
+                    await markWorkflowCancelled(store);
+                    throw new WorkflowCancellationError();
+                }
+                if (store !== undefined && planReviewPlan !== undefined) {
                     try {
                         await markWorkflowFailed(store, runId, err);
                     }
@@ -1106,26 +1559,17 @@ async function executeRunWorkflow(server, options, args, signal, progressToken)
                     });
                     return { content, isError: true };
                 }
-                finally {
-                    try {
-                        await store.close();
-                    }
-                    catch (closeError) {
-                        logger.warn({ err: closeError }, "store.close() failed during async initialization cleanup");
-                    }
-                    releaseMutex(runId);
-                }
+                throw err;
+            }
+            finally {
+                await ownership.finish(store);
             }
-            releaseMutex(runId);
-            throw err;
         }
         if (store === undefined || effectiveDefinition === undefined) {
-            releaseMutex(runId);
+            await ownership.finish(store);
             throw new McpError(ErrorCode.InternalError, `Failed to initialize async run ${runId}`);
         }
-        const detached = new AbortController();
-        cancelRegistry.set(runId, detached);
-        void runWorkflowDetached(server, options, workflow, runId, resolvedVariables, debug, receipt, validatorRegistry, loaded, parsedMembers, parsedChairman, true, detached.signal, undefined, store, effectiveDefinition, undefined, initializedPlanReview, initialContextPolicy).catch((err) => {
+        void runWorkflowDetached(server, options, workflow, runId, resolvedVariables, debug, receipt, validatorRegistry, loaded, parsedMembers, parsedChairman, parsedChairmanModel, parsedChairmanEffort, true, ownership, undefined, store, effectiveDefinition, undefined, initializedPlanReview, initialContextPolicy, admittedRosterName).catch((err) => {
             if (err instanceof WorkflowCancellationError) {
                 logger.info({ runId }, "workflow run cancelled");
                 return;
@@ -1134,7 +1578,9 @@ async function executeRunWorkflow(server, options, args, signal, progressToken)
         });
         // Additive-only ack shape: base {run_id, status:"running"} is unchanged;
         // the duplicate-replay field appears only when detected (warn-only, F6).
+        // resolved_roster is the admission-time requested-value projection (E2).
         const duplicateOfFailedRun = buildDuplicateOfFailedRunField(store);
+        const resolvedRoster = store.runState.resolvedRoster;
         return {
             content: [{
                     type: "text",
@@ -1144,11 +1590,14 @@ async function executeRunWorkflow(server, options, args, signal, progressToken)
                         ...(duplicateOfFailedRun !== undefined
                             ? { duplicate_of_failed_run: duplicateOfFailedRun }
                             : {}),
+                        ...(resolvedRoster !== undefined
+                            ? { resolved_roster: resolvedRoster }
+                            : {}),
                     }),
                 }],
         };
     }
-    return await runWorkflowDetached(server, options, workflow, runId, resolvedVariables, debug, receipt, validatorRegistry, loaded, parsedMembers, parsedChairman, false, signal, progressToken, undefined, undefined, planReviewPlan, undefined, initialContextPolicy);
+    return await runWorkflowDetached(server, options, workflow, runId, resolvedVariables, debug, receipt, validatorRegistry, loaded, parsedMembers, parsedChairman, parsedChairmanModel, parsedChairmanEffort, false, ownership, progressToken, undefined, undefined, planReviewPlan, undefined, initialContextPolicy, admittedRosterName);
 }
 async function preparePlanReviewSnapshot(plan) {
     try {
@@ -1224,7 +1673,100 @@ function resolvePlanReviewChairmanCallId(definition) {
     }
     return callId;
 }
-function expandRunWorkflowDefinition(definition, workflow, parsedMembers, parsedChairman, planReviewPlan, 
+function projectResolvedRosterSeat(call, index, stancePresent) {
+    return {
+        index,
+        cli_name: call.cli_name,
+        ...(call.model !== undefined ? { model: call.model } : {}),
+        ...(call.effort !== undefined ? { effort: call.effort } : {}),
+        stance_present: stancePresent,
+    };
+}
+function projectResolvedRosterDelegate(policy, resolvedVariables) {
+    const delegate = policy.effectiveDelegate;
+    if (delegate?.enabled !== true) {
+        return { enabled: false };
+    }
+    const finalizerEnabled = effectiveFinalizerEnabled(delegate, resolvedVariables);
+    return {
+        enabled: true,
+        curator: {
+            cli_name: delegate.curator.cli_name,
+            role: delegate.curator.role,
+            ...(delegate.curator.model !== undefined ? { model: delegate.curator.model } : {}),
+            ...(delegate.curator.effort !== undefined ? { effort: delegate.curator.effort } : {}),
+        },
+        finalizer: {
+            cli_name: delegate.finalizer.cli_name,
+            role: delegate.finalizer.role,
+            ...(delegate.finalizer.model !== undefined ? { model: delegate.finalizer.model } : {}),
+            ...(delegate.finalizer.effort !== undefined ? { effort: delegate.finalizer.effort } : {}),
+            effective_enabled: finalizerEnabled,
+        },
+    };
+}
+/**
+ * Requested-value roster projection for council workflows. Call AFTER
+ * `expandCouncilComposition` / `expandRunWorkflowDefinition`, AFTER
+ * `resolveEffectiveChairmanCall` values are on the definition (or passed as
+ * parsed chairman knobs), and AFTER `effectiveFinalizerEnabled` can be
+ * evaluated from `initialContextPolicy` — and BEFORE `WorkflowStateStore.create()`.
+ * `plan-review-receipts` and any non-council workflow return undefined.
+ */
+export function buildResolvedRoster(input) {
+    if (!supportsRuntimeMembers(input.workflow)) {
+        return undefined;
+    }
+    const stages = input.definition.stages;
+    if (stages.length !== COUNCIL_STAGE_COUNT) {
+        return undefined;
+    }
+    const memberCalls = stages[0]?.calls;
+    const reviewerCalls = stages[1]?.calls;
+    const chairmanCall = stages[3]?.calls[0];
+    if (memberCalls === undefined || reviewerCalls === undefined || chairmanCall === undefined) {
+        return undefined;
+    }
+    const members = memberCalls.map((call, index) => projectResolvedRosterSeat(call, index, input.parsedMembers?.[index]?.stance !== undefined));
+    const reviewers = reviewerCalls.map((call, index) => projectResolvedRosterSeat(call, index, false));
+    const effectiveChairman = resolveEffectiveChairmanCall({
+        staticCall: chairmanCall,
+        chairmanCliName: input.parsedChairman,
+        chairmanModel: input.parsedChairmanModel,
+        chairmanEffort: input.parsedChairmanEffort,
+    });
+    const delegate = projectResolvedRosterDelegate(input.initialContextPolicy, input.resolvedVariables);
+    const preflightCalls = delegate.enabled === true
+        ? 1 + (delegate.finalizer.effective_enabled ? 1 : 0)
+        : 0;
+    return ResolvedRosterSchema.parse({
+        ...(input.rosterName !== undefined ? { roster: input.rosterName } : {}),
+        members,
+        reviewers,
+        chairman: {
+            cli_name: effectiveChairman.cli_name,
+            ...(effectiveChairman.model !== undefined ? { model: effectiveChairman.model } : {}),
+            ...(effectiveChairman.effort !== undefined ? { effort: effectiveChairman.effort } : {}),
+        },
+        delegate,
+        provider_spawns: members.length + reviewers.length + 1,
+        preflight_calls: preflightCalls,
+    });
+}
+function resolvedRosterForAdmission(workflow, definition, parsedMembers, parsedChairman, parsedChairmanModel, parsedChairmanEffort, initialContextPolicy, resolvedVariables, rosterName) {
+    return buildResolvedRoster({
+        workflow,
+        definition,
+        ...(parsedMembers !== undefined ? { parsedMembers } : {}),
+        ...(parsedChairman !== undefined ? { parsedChairman } : {}),
+        ...(parsedChairmanModel !== undefined ? { parsedChairmanModel } : {}),
+        ...(parsedChairmanEffort !== undefined ? { parsedChairmanEffort } : {}),
+        initialContextPolicy,
+        resolvedVariables,
+        ...(rosterName !== undefined ? { rosterName } : {}),
+    });
+}
+function expandRunWorkflowDefinition(definition, workflow, parsedMembers, parsedChairman, parsedChairmanModel, parsedChairmanEffort, planReviewPlan, 
 /**
  * The already-verified snapshot. This function must NEVER read `plan_file`:
  * the text it inlines is the digest-verified canonical copy or nothing.
@@ -1240,18 +1782,22 @@ preparedSnapshot) {
         // string cannot carry. This is the single read — never re-read `plan_file`.
         preparedSnapshot?.ok === true ? preparedSnapshot.canonical : undefined);
     }
-    return parsedMembers != null || parsedChairman != null
-        ? expandCouncilComposition(definition, parsedMembers, workflow, parsedChairman)
+    return parsedMembers != null ||
+        parsedChairman != null ||
+        parsedChairmanModel !== undefined ||
+        parsedChairmanEffort !== undefined
+        ? expandCouncilComposition(definition, parsedMembers, workflow, parsedChairman, parsedChairmanModel, parsedChairmanEffort)
         : definition;
 }
-async function runWorkflowDetached(server, options, workflow, runId, resolvedVariables, debug, receipt, validatorRegistry, loaded, parsedMembers, parsedChairman, isAsync, signal, progressToken, preCreatedStore, preExpandedDefinition, planReviewPlan, preInitializedPlanReview, initialContextPolicy) {
+async function runWorkflowDetached(server, options, workflow, runId, resolvedVariables, debug, receipt, validatorRegistry, loaded, parsedMembers, parsedChairman, parsedChairmanModel, parsedChairmanEffort, isAsync, ownership, progressToken, preCreatedStore, preExpandedDefinition, planReviewPlan, preInitializedPlanReview, initialContextPolicy, rosterName) {
     let store = preCreatedStore ?? null;
     let backend = null;
     let reporter;
-    let shutdownHandle;
     let releaseLifecycleBinding;
     let initializedPlanReview = preInitializedPlanReview;
+    const signal = ownership.signal;
     try {
+        ownership.throwIfCancelled();
         // The async admission path already expanded the composition (and read the
         // snapshot) in the foreground; reuse both to avoid redundant work and a
         // second `plan_file` read.
@@ -1259,11 +1805,13 @@ async function runWorkflowDetached(server, options, workflow, runId, resolvedVar
             planReviewPlan === undefined
             ? undefined
             : await preparePlanReviewSnapshot(planReviewPlan);
+        ownership.throwIfCancelled();
         const effectiveDefinition = preExpandedDefinition ??
-            expandRunWorkflowDefinition(loaded.normalized, workflow, parsedMembers, parsedChairman, planReviewPlan, preparedSnapshot);
+            expandRunWorkflowDefinition(loaded.normalized, workflow, parsedMembers, parsedChairman, parsedChairmanModel, parsedChairmanEffort, planReviewPlan, preparedSnapshot);
         // Create state store (resumable if child config path is set) unless the
         // async admission path already created it in the foreground.
         if (store == null) {
+            const resolvedRoster = resolvedRosterForAdmission(workflow, effectiveDefinition, parsedMembers, parsedChairman, parsedChairmanModel, parsedChairmanEffort, initialContextPolicy, resolvedVariables, rosterName);
             store = await WorkflowStateStore.create({
                 runId,
                 definition: effectiveDefinition,
@@ -1271,8 +1819,11 @@ async function runWorkflowDetached(server, options, workflow, runId, resolvedVar
                 debugKeepArtifacts: debug,
                 async: isAsync,
                 initialContextPolicy,
+                ...(resolvedRoster !== undefined ? { resolvedRoster } : {}),
+                ...(rosterName !== undefined ? { rosterName } : {}),
             });
         }
+        ownership.throwIfCancelled();
         releaseLifecycleBinding = options.contextBuilderLifecycleRouter?.bind(runId, store);
         // A-5/A-6: snapshot + contract + typed subtree land here — after state
         // exists, before the backend is even created, so a snapshot/digest failure
@@ -1281,28 +1832,15 @@ async function runWorkflowDetached(server, options, workflow, runId, resolvedVar
         if (planReviewPlan !== undefined && preparedSnapshot !== undefined) {
             initializedPlanReview = await initializePlanReviewRunState(store, planReviewPlan, effectiveDefinition, preparedSnapshot);
         }
+        ownership.throwIfCancelled();
         const sessionLogGeneration = store.sessionLogGeneration ??
             await inspectLegacyWorkflowSessionLogGeneration(store.runDir, runId);
-        if (signal.aborted)
-            throw new WorkflowCancellationError();
-        // Create backend via factory
+        ownership.throwIfCancelled();
         backend = options.createBackend(runId);
+        ownership.setBackend(backend);
+        ownership.throwIfCancelled();
         await backend.connect();
-        // Wire up shutdown coordinator
-        const controller = new AbortController();
-        if (signal.aborted) {
-            controller.abort(new WorkflowCancellationError());
-        }
-        else {
-            signal.addEventListener("abort", () => {
-                controller.abort(new WorkflowCancellationError());
-            }, { once: true });
-        }
-        shutdownHandle = shutdownCoordinator.register(backend, controller, async () => {
-            if (store != null) {
-                await store.markCancelled();
-            }
-        });
+        ownership.throwIfCancelled();
         // Build engine hooks — capture store in a const for closure narrowing
         const storeRef = store;
         reporter = progressToken != null
@@ -1332,13 +1870,16 @@ async function runWorkflowDetached(server, options, workflow, runId, resolvedVar
             runId,
             sessionLogGeneration,
             runDir: storeRef.runDir,
-            signal: controller.signal,
+            signal,
             hooks,
             contextBuilderRunner: options.contextBuilderRunner,
             contextDefault: options.contextDefault,
             defaultCurator: options.defaultCurator,
             commitPreflightContext: storeRef.commitPreflightContext?.bind(storeRef),
             initialContextPolicy,
+            ...(options.deriveInvocationAudit === undefined
+                ? {}
+                : { deriveInvocationAudit: options.deriveInvocationAudit }),
             ...(initializedPlanReview !== undefined
                 ? {
                     planReviewContextPolicy: initializedPlanReview.context_policy,
@@ -1352,8 +1893,6 @@ async function runWorkflowDetached(server, options, workflow, runId, resolvedVar
                 : {}),
         });
         const result = await engine.execute();
-        if (shutdownHandle !== undefined)
-            shutdownCoordinator.unregister(shutdownHandle);
         // Build summary (fail-open)
         let summary;
         if (receipt) {
@@ -1373,16 +1912,13 @@ async function runWorkflowDetached(server, options, workflow, runId, resolvedVar
             debugBlock: debug ? buildDebugBlock(runId, result, store) : undefined,
         });
         appendDuplicateReplayBlock(content, store);
+        appendResolvedRosterBlock(content, store);
         return { content };
     }
     catch (error) {
-        if (shutdownHandle !== undefined)
-            shutdownCoordinator.unregister(shutdownHandle);
-        if (error instanceof WorkflowCancellationError) {
-            if (store != null) {
-                await store.markCancelled();
-            }
-            throw error;
+        if (signal.aborted || error instanceof WorkflowCancellationError) {
+            await markWorkflowCancelled(store);
+            throw new WorkflowCancellationError();
         }
         // Persist a terminal "failed" record for post-admission setup failures
         // (e.g. backend.connect() / engine construction). Idempotent: the engine
@@ -1417,29 +1953,17 @@ async function runWorkflowDetached(server, options, workflow, runId, resolvedVar
             debugBlock: debug && store != null ? buildErrorDebugBlock(runId, store) : undefined,
         });
         appendDuplicateReplayBlock(content, store);
+        appendResolvedRosterBlock(content, store);
         return { content, isError: true };
     }
     finally {
-        releaseLifecycleBinding?.();
-        reporter?.stop();
-        try {
-            if (backend != null && !backend.isTerminated) {
-                await backend.terminate();
-            }
-        }
-        catch (cleanupErr) {
-            logger.warn({ err: cleanupErr }, "backend.terminate() failed during cleanup");
-        }
         try {
-            if (store != null) {
-                await store.close();
-            }
+            releaseLifecycleBinding?.();
+            reporter?.stop();
         }
-        catch (cleanupErr) {
-            logger.warn({ err: cleanupErr }, "store.close() failed during cleanup");
+        finally {
+            await ownership.finish(store);
         }
-        cancelRegistry.delete(runId);
-        releaseMutex(runId);
     }
 }
 async function executeResumeWorkflow(server, options, args, signal, progressToken) {
@@ -1485,18 +2009,23 @@ async function executeResumeWorkflow(server, options, args, signal, progressToke
             isError: true,
         };
     }
-    acquireMutex(runId, options);
+    const ownership = acquireWorkflowRun(runId, options, signal);
+    const ownedSignal = ownership.signal;
     let store = null;
     let backend = null;
     let reporter;
-    let shutdownHandle;
     let releaseLifecycleBinding;
     try {
+        ownership.throwIfCancelled();
         const resumeOptions = {
             runId,
             debugKeepArtifacts: debug,
         };
         store = await WorkflowStateStore.resume(resumeOptions);
+        // Open this attempt before classifying an abort during reconstruction;
+        // otherwise a prior terminal record would suppress markCancelled.
+        await store.beginResumeAttempt();
+        ownership.throwIfCancelled();
         releaseLifecycleBinding = options.contextBuilderLifecycleRouter?.bind(runId, store);
         const validatorRegistry = createValidatorRegistry();
         const initialContextPolicy = store.runState.initialContextPolicy ??
@@ -1546,14 +2075,10 @@ async function executeResumeWorkflow(server, options, args, signal, progressToke
                 contextPolicy: restoredPlanReview.state.context_policy,
             });
         }
-        // Make this resume attempt durable before its preflight gate. Generic runs
-        // otherwise remain in the prior terminal state, causing markFailed /
-        // markCancelled to suppress a new pre-dispatch outcome as "idempotent".
-        await store.beginResumeAttempt();
+        ownership.throwIfCancelled();
         const sessionLogGeneration = store.sessionLogGeneration ??
             await inspectLegacyWorkflowSessionLogGeneration(store.runDir, runId);
-        if (signal.aborted)
-            throw new WorkflowCancellationError();
+        ownership.throwIfCancelled();
         if (store.runState.workflow_context === undefined) {
             const preflightEngine = new WorkflowEngine({
                 definition: store.definition,
@@ -1562,7 +2087,7 @@ async function executeResumeWorkflow(server, options, args, signal, progressToke
                 validatorRegistry,
                 runId,
                 runDir: store.runDir,
-                signal,
+                signal: ownedSignal,
                 resume: store.resume,
                 contextBuilderRunner: options.contextBuilderRunner,
                 contextDefault: options.contextDefault,
@@ -1570,6 +2095,9 @@ async function executeResumeWorkflow(server, options, args, signal, progressToke
                 commitPreflightContext: store.commitPreflightContext.bind(store),
                 requireContextPreflight: true,
                 initialContextPolicy,
+                ...(options.deriveInvocationAudit === undefined
+                    ? {}
+                    : { deriveInvocationAudit: options.deriveInvocationAudit }),
                 ...(restoredPlanReview === undefined
                     ? {}
                     : {
@@ -1579,24 +2107,20 @@ async function executeResumeWorkflow(server, options, args, signal, progressToke
                         commitPlanReviewContextProvenance: store.commitPlanReviewContextProvenance.bind(store),
                     }),
             });
-            await preflightEngine.prepareContextPreflight(signal);
-        }
-        // Create backend only after the resume context gate has committed or bypassed.
+            // D1: bound the resume-path preflight by the same fresh `timeout_seconds`
+            // budget a resumed run receives. `execute()` is never called on this engine,
+            // so without this the curator/finalizer delegate runs unbounded. The engine is
+            // constructed with `signal: ownedSignal`, which createDeadlineController chains,
+            // so cancellation ownership is unchanged.
+            await preflightEngine.prepareContextPreflightWithDeadline();
+        }
+        // Create backend only after the owned resume preflight has completed.
+        ownership.throwIfCancelled();
         backend = options.createBackend(runId);
+        ownership.setBackend(backend);
+        ownership.throwIfCancelled();
         await backend.connect();
-        // Wire up shutdown coordinator
-        const controller = new AbortController();
-        if (signal.aborted) {
-            controller.abort(new WorkflowCancellationError());
-        }
-        else {
-            signal.addEventListener("abort", () => {
-                controller.abort(new WorkflowCancellationError());
-            }, { once: true });
-        }
-        shutdownHandle = shutdownCoordinator.register(backend, controller, async () => {
-            await store.markCancelled();
-        });
+        ownership.throwIfCancelled();
         // Build engine hooks with progress reporter
         reporter = progressToken != null
             ? new WorkflowProgressReporter(server, progressToken, runId, store.definition)
@@ -1630,7 +2154,7 @@ async function executeResumeWorkflow(server, options, args, signal, progressToke
             runId,
             sessionLogGeneration,
             runDir: store.runDir,
-            signal: controller.signal,
+            signal: ownedSignal,
             hooks: rpt != null ? hooks : store.hooks,
             resume: store.resume,
             contextBuilderRunner: options.contextBuilderRunner,
@@ -1640,6 +2164,9 @@ async function executeResumeWorkflow(server, options, args, signal, progressToke
             restoredWorkflowContext: store.runState.workflow_context,
             requireContextPreflight: false,
             initialContextPolicy,
+            ...(options.deriveInvocationAudit === undefined
+                ? {}
+                : { deriveInvocationAudit: options.deriveInvocationAudit }),
             // A-7: replay the SAME enforced exclusion on resume, reconstructed from
             // persisted state rather than re-derived from caller variables.
             ...(restoredPlanReview !== undefined
@@ -1656,8 +2183,6 @@ async function executeResumeWorkflow(server, options, args, signal, progressToke
                 : {}),
         });
         const result = await engine.execute();
-        if (shutdownHandle !== undefined)
-            shutdownCoordinator.unregister(shutdownHandle);
         // Build summary (fail-open)
         let summary;
         if (receipt) {
@@ -1679,13 +2204,9 @@ async function executeResumeWorkflow(server, options, args, signal, progressToke
         return { content };
     }
     catch (error) {
-        if (shutdownHandle !== undefined)
-            shutdownCoordinator.unregister(shutdownHandle);
-        if (error instanceof WorkflowCancellationError) {
-            if (store != null) {
-                await store.markCancelled();
-            }
-            throw error;
+        if (ownedSignal.aborted || error instanceof WorkflowCancellationError) {
+            await markWorkflowCancelled(store);
+            throw new WorkflowCancellationError();
         }
         // Persist a terminal "failed" record for post-admission setup failures.
         // Idempotent: won't clobber an engine-emitted terminal status.
@@ -1718,25 +2239,13 @@ async function executeResumeWorkflow(server, options, args, signal, progressToke
         return { content, isError: true };
     }
     finally {
-        releaseLifecycleBinding?.();
-        reporter?.stop();
-        try {
-            if (backend != null && !backend.isTerminated) {
-                await backend.terminate();
-            }
-        }
-        catch (cleanupErr) {
-            logger.warn({ err: cleanupErr }, "backend.terminate() failed during cleanup");
-        }
         try {
-            if (store != null) {
-                await store.close();
-            }
+            releaseLifecycleBinding?.();
+            reporter?.stop();
         }
-        catch (cleanupErr) {
-            logger.warn({ err: cleanupErr }, "store.close() failed during cleanup");
+        finally {
+            await ownership.finish(store);
         }
-        releaseMutex(runId);
     }
 }
 // ---------------------------------------------------------------------------
@@ -1916,33 +2425,60 @@ async function executeWorkflowRunStatus(_options, args) {
                 selected: lifecycle.coverage.selected,
                 missing: lifecycle.coverage.missing,
             };
+            const finalizer = lifecycle.finalizer;
+            if (typeof finalizer.effective_enabled === "boolean" &&
+                typeof finalizer.execution_status === "string") {
+                const existingDelegate = context["delegate"] !== undefined &&
+                    typeof context["delegate"] === "object" &&
+                    context["delegate"] !== null
+                    ? context["delegate"]
+                    : {};
+                context["delegate"] = {
+                    ...existingDelegate,
+                    finalizer: {
+                        effective_enabled: finalizer.effective_enabled,
+                        execution_status: finalizer.execution_status,
+                        // The lifecycle contract only admits a score on succeeded
+                        // execution; re-check here so the projection cannot surface one
+                        // for any other outcome.
+                        ...(finalizer.execution_status === "succeeded" &&
+                            typeof finalizer.score === "number" &&
+                            Number.isFinite(finalizer.score)
+                            ? { score: finalizer.score }
+                            : {}),
+                    },
+                };
+            }
         }
         projection["context"] = context;
     }
+    else if (lifecycle != null &&
+        !isTerminalContextBuilderLifecycleStatus(lifecycle.status)) {
+        // Preflight in flight: `context` is reserved for committed-preflight
+        // semantics, so mid-scan progress rides on its own top-level key.
+        projection["context_progress"] = {
+            phase: lifecycle.phase,
+            status: lifecycle.status,
+            updated_at: lifecycle.updated_at,
+            counts: {
+                files_seen: lifecycle.counts.files_seen,
+                files_considered: lifecycle.counts.files_considered,
+                files_selected: lifecycle.counts.files_selected,
+                files_omitted: lifecycle.counts.files_omitted,
+                search_results: lifecycle.counts.search_results,
+                bytes_read: lifecycle.counts.bytes_read,
+                bytes_written: lifecycle.counts.bytes_written,
+            },
+        };
+    }
     // F7 read-time health projection: top-level run status alone overstates
     // health when on_failure:continue swallowed seat failures or context
     // preflight completed partial/degraded. Computed only from already-persisted
     // data; additive and advisory — never mutates status semantics.
-    const healthReasons = [];
-    if (status === "succeeded" && stages.some((stage) => stage.failed_calls > 0)) {
-        healthReasons.push("failed_calls_in_succeeded_run");
-    }
-    if (lifecycle?.status === "partial") {
-        healthReasons.push("context_partial");
+    projection["health"] = computeRunHealth(state, lifecycle);
+    if (state.resolvedRoster !== undefined) {
+        projection["resolved_roster"] = state.resolvedRoster;
     }
-    if (lifecycle?.status === "failed") {
-        healthReasons.push("context_lifecycle_failed");
-    }
-    if (lifecycle?.coverage.status === "degraded") {
-        healthReasons.push("coverage_degraded");
-    }
-    if (cb?.delegate?.fallback_used === true) {
-        healthReasons.push("delegate_fallback_used");
-    }
-    projection["health"] = {
-        classification: healthReasons.length > 0 ? "degraded" : "ok",
-        reasons: healthReasons,
-    };
     if (isPlanReviewRunState(state)) {
         const terminalExecutionStatus = state.status === "succeeded" ||
             state.status === "failed" ||
@@ -2180,6 +2716,14 @@ function executeListWorkflows(options) {
     if (options.availableCliNames != null && options.availableCliNames.length > 0) {
         response["available_cli_names"] = [...options.availableCliNames].sort();
     }
+    if (options.adapterCapabilities != null) {
+        const availableClis = [...options.adapterCapabilities()];
+        availableClis.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+        response["available_clis"] = availableClis;
+    }
+    if (options.rosterLoader != null) {
+        response["available_rosters"] = options.rosterLoader.list();
+    }
     return {
         content: [
             {
@@ -2352,9 +2896,15 @@ const RUN_WORKFLOW_SCHEMA = {
             default: false,
             description: "When true, start the run detached and return {run_id, status:'running'} immediately; poll workflow_run_status for progress and result.",
         },
+        roster: {
+            type: "string",
+            pattern: ROSTER_NAME_PATTERN.source,
+            maxLength: 64,
+            description: "Optional named roster preset; exclusive with members, chairman, chairman_model, chairman_effort, and a non-empty variables.cb_delegate.",
+        },
         members: {
             type: "array",
-            description: "Optional runtime council member composition override. Accepted only for council workflows (council-default, council-answer, council-code-review, council-debug, council-discover, council-plan-review). Each entry specifies a CLI adapter and an optional analytical stance. Seats at indices 0-2 may omit stance (inherits default); seats at indices 3-9 MUST provide stance. When provided, both the member stage (stage 0) and reviewer stage (stage 1) are expanded to match the specified count and CLI mapping. Reviewer stances are NOT inherited — reviewers keep their default review lens.",
+            description: "Optional runtime council member composition override. Accepted only for council workflows (council-default, council-answer, council-code-review, council-debug, council-discover, council-plan-review). Each entry specifies a CLI adapter, an optional analytical stance, and optional requested model/effort values whose support is adapter-declared. Seats at indices 0-2 may omit stance (inherits default); seats at indices 3-9 MUST provide stance. When provided, both the member stage (stage 0) and reviewer stage (stage 1) are expanded to match the specified count and CLI mapping. Reviewer stances are NOT inherited — reviewers keep their default review lens.",
             minItems: 1,
             maxItems: 10,
             items: {
@@ -2368,6 +2918,20 @@ const RUN_WORKFLOW_SCHEMA = {
                         type: "string",
                         description: "Analytical stance or perspective for this council seat. Required for seats at indices 3-9. Server enforces a 200-character limit after whitespace normalization (trim + collapse). Must not contain {{ or }}.",
                     },
+                    model: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 128,
+                        pattern: MODEL_OVERRIDE_PATTERN.source,
+                        description: "Optional requested model for this seat. Support is declared by the selected adapter; omission preserves its configured default.",
+                    },
+                    effort: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 32,
+                        pattern: "^[a-z0-9][a-z0-9_-]*$",
+                        description: "Optional requested reasoning effort for this seat. Support is declared by the selected adapter; omission preserves its configured default.",
+                    },
                 },
                 required: ["cli_name"],
                 additionalProperties: false,
@@ -2377,6 +2941,20 @@ const RUN_WORKFLOW_SCHEMA = {
             type: "string",
             description: "Optional CLI adapter name override for the council chairman seat. Accepted only for council workflows. Only changes the LLM adapter; the chairman's role and prompt template are preserved.",
         },
+        chairman_model: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+            pattern: MODEL_OVERRIDE_PATTERN.source,
+            description: "Optional requested model for the council chairman. Support is declared by the chairman adapter; omission preserves its configured default. May be supplied without chairman.",
+        },
+        chairman_effort: {
+            type: "string",
+            minLength: 1,
+            maxLength: 32,
+            pattern: "^[a-z0-9][a-z0-9_-]*$",
+            description: "Optional requested reasoning effort for the council chairman. Support is declared by the chairman adapter; omission preserves its configured default. May be supplied without chairman.",
+        },
         plan_review: PLAN_REVIEW_INPUT_SCHEMA,
     },
     required: ["workflow", "run_id"],
@@ -2536,7 +3114,7 @@ export function getWorkflowToolDefinitions(workflowsPath, availableCliNames) {
     return [
         {
             name: "run_workflow",
-            description: `Start a new multi-stage workflow execution.${workflowSuffix}\nAccepts optional \`members\` and \`chairman\` parameters for council workflows (council-default, council-answer, council-code-review, council-debug, council-discover, council-plan-review) to override member/reviewer composition and chairman CLI adapter at runtime.`,
+            description: `Start a new multi-stage workflow execution.${workflowSuffix}\nAccepts optional \`members\` and \`chairman\` parameters for council workflows (council-default, council-answer, council-code-review, council-debug, council-discover, council-plan-review) to override member/reviewer composition and chairman CLI adapter at runtime. Council runs include a \`resolved_roster\` of requested seat and delegate values (no provenance) on the async ack, a trailing sync content block, and workflow_run_status.`,
             inputSchema: runSchema,
         },
         {
@@ -2553,7 +3131,7 @@ export function getWorkflowToolDefinitions(workflowsPath, availableCliNames) {
         },
         {
             name: "workflow_run_status",
-            description: "Read-only status/progress of a workflow run. The full result is included only with include_result:true. Generic workflows preserve succeeded-final-call behavior; plan-review-receipts reports marker-driven availability and bytes independently of terminal status, with body-blind default polling. Every found run also carries a top-level `health` block {classification: \"ok\"|\"degraded\", reasons: string[]} computed read-time from persisted data — a run can be status:\"succeeded\" yet degraded when on_failure:continue swallowed failed calls or context preflight was partial/degraded (reasons: failed_calls_in_succeeded_run, context_partial, context_lifecycle_failed, coverage_degraded, delegate_fallback_used). When a context-builder lifecycle snapshot is persisted, the `context` block additionally includes `lifecycle_status` and `coverage` {policy, status, required, selected, missing}.",
+            description: "Read-only status/progress of a workflow run. The full result is included only with include_result:true. Generic workflows preserve succeeded-final-call behavior; plan-review-receipts reports marker-driven availability and bytes independently of terminal status, with body-blind default polling. Every found run also carries a top-level `health` block {classification: \"ok\"|\"degraded\", reasons: string[]} computed read-time from persisted data — a run can be status:\"succeeded\" yet degraded when on_failure:continue swallowed failed calls or context preflight was partial/degraded (reasons: failed_calls_in_succeeded_run, context_partial, context_lifecycle_failed, coverage_degraded, delegate_fallback_used, context_external_gaps — the finalizer reported evidence gaps outside the delegate packet under external_gap_policy:\"degrade\", so conclusions depending on them are conditional). When a context-builder lifecycle snapshot is persisted, the `context` block additionally includes `lifecycle_status` and `coverage` {policy, status, required, selected, missing}. A parsed snapshot also projects `context.delegate.finalizer` {effective_enabled, execution_status, score?}; `score` is present only for a succeeded finalizer that recorded one, and the finalizer key is omitted when the lifecycle is missing, unparseable, or those fields are absent. While context preflight is still running (non-terminal lifecycle, no committed context yet) the `context` block is absent and a top-level `context_progress` {phase, status, updated_at, counts} reports scan progress instead. Found council runs also include a top-level `resolved_roster` of requested seat and delegate values (no provenance) when the run persisted one; older runs omit the key.",
             inputSchema: WORKFLOW_RUN_STATUS_SCHEMA,
             annotations: { readOnlyHint: true },
         },
@@ -2615,21 +3193,35 @@ export async function handleWorkflowToolCall(server, options, name, args, signal
 export function registerWorkflowTools(server, options) {
     // tools/list
     server.setRequestHandler(ListToolsRequestSchema, async () => {
-        return { tools: getWorkflowToolDefinitions(options.workflowsPath, options.availableCliNames) };
+        activeWorkflowHandlers += 1;
+        try {
+            return { tools: getWorkflowToolDefinitions(options.workflowsPath, options.availableCliNames) };
+        }
+        finally {
+            activeWorkflowHandlers -= 1;
+            notifyWorkflowActivity();
+        }
     });
     // tools/call
     server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-        const { name, arguments: args } = request.params;
-        const progressToken = request.params._meta?.progressToken;
-        const result = await handleWorkflowToolCall(server, options, name, args ?? {}, extra.signal, progressToken);
-        if (result != null) {
-            return result;
+        activeWorkflowHandlers += 1;
+        try {
+            const { name, arguments: args } = request.params;
+            const progressToken = request.params._meta?.progressToken;
+            const result = await handleWorkflowToolCall(server, options, name, args ?? {}, extra.signal, progressToken);
+            if (result != null) {
+                return result;
+            }
+            logger.warn({ tool: name }, "unknown tool requested");
+            return {
+                content: [{ type: "text", text: `Unknown tool: ${String(name)}` }],
+                isError: true,
+            };
+        }
+        finally {
+            activeWorkflowHandlers -= 1;
+            notifyWorkflowActivity();
         }
-        logger.warn({ tool: name }, "unknown tool requested");
-        return {
-            content: [{ type: "text", text: `Unknown tool: ${String(name)}` }],
-            isError: true,
-        };
     });
 }
 //# sourceMappingURL=workflow-tools.js.map