@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/runs/foreground/question-control.js

@@ -1,88 +1,193 @@
 import * as path from "node:path";
+import { errorMessage } from "../../shared/unknown.js";
 import { formatRunAction } from "../../shared/status-format.js";
-import { cancelSupervisorQuestion, claimQuestionRevival, formatSupervisorQuestions, listSupervisorQuestions, questionProcessAlive, questionRecoveryHint, readQuestionState, recordQuestionDelivery, releaseQuestionRevival, saveQuestionAnswer, supervisorQuestionPage } from "../shared/supervisor-questions.js";
-import { liveLaunchOverrideNotice, nestedResolutionScopeForExecutor, reviveSavedSubagent } from "./foreground-control.js";
+import { cancelSupervisorQuestion, claimQuestionRevival, formatSupervisorQuestions, listSupervisorQuestions, questionProcessAlive, questionRecoveryHint, readQuestionState, recordQuestionDelivery, releaseQuestionRevival, saveQuestionAnswer, supervisorQuestionPage, } from "../shared/supervisor-questions.js";
+import { liveLaunchOverrideNotice } from "./foreground-control.js";
+import { nestedResolutionScopeForExecutor } from "./execution-routing.js";
+import { reviveSavedSubagent } from "./saved-revival.js";
 function questionResult(questions, text) {
-    return { content: [{ type: "text", text }], details: { mode: "management", results: [], ...supervisorQuestionPage(questions) } };
+    return {
+        content: [{ type: "text", text }],
+        details: { mode: "management", results: [], ...supervisorQuestionPage(questions) },
+    };
+}
+function resultMatches(result, pattern) {
+    return result.content.some((item) => item.type === "text" && pattern.test(item.text));
+}
+function questionRunId(params) {
+    const dirId = params.dir !== undefined && params.dir.length > 0 ? path.basename(params.dir) : undefined;
+    return params.id ?? params.runId ?? dirId;
+}
+function pendingQuestion(question) {
+    return question.state === "awaiting_input" || question.state === "answer_pending";
 }
 export function projectSupervisorQuestions(result, params, ownerSessionId, childSafe = false) {
-    if (result.isError && !result.content.some((item) => item.type === "text" && /Async run not found|Status file not found/.test(item.text)))
+    const questionOnly = result.isError === true && resultMatches(result, /Async run not found|Status file not found/);
+    if (result.isError === true && !questionOnly) {
         return result;
-    const id = params.id ?? params.runId ?? (params.dir ? path.basename(params.dir) : undefined);
-    const questions = listSupervisorQuestions(ownerSessionId, id)
-        .filter((question) => question.state === "awaiting_input" || question.state === "answer_pending");
-    if (!questions.length)
+    }
+    const questions = listSupervisorQuestions(ownerSessionId, questionRunId(params)).filter(pendingQuestion);
+    if (questions.length === 0) {
         return result;
+    }
     const page = supervisorQuestionPage(questions);
-    const questionOnly = result.isError && result.content.some((item) => item.type === "text" && /Async run not found|Status file not found/.test(item.text));
     return {
         ...result,
         ...(questionOnly ? { isError: false } : {}),
-        content: [{ type: "text", text: [`Supervisor input (not execution completion):\n${formatSupervisorQuestions(page.questions, childSafe)}`,
-                    ...(page.questionList.nextOffset !== undefined ? [`More questions: ${formatRunAction("questions", id, { offset: page.questionList.nextOffset, limit: page.questionList.limit }, childSafe)}`] : []),
-                    ...(questionOnly ? [] : result.content.map((item) => item.type === "text" ? item.text : ""))].join("\n\n") }],
+        content: [
+            {
+                type: "text",
+                text: [
+                    `Supervisor input (not execution completion):\n${formatSupervisorQuestions(page.questions, childSafe)}`,
+                    ...(page.questionList.nextOffset !== undefined
+                        ? [
+                            `More questions: ${formatRunAction("questions", questionRunId(params), { offset: page.questionList.nextOffset, limit: page.questionList.limit }, childSafe)}`,
+                        ]
+                        : []),
+                    ...(questionOnly
+                        ? []
+                        : result.content.map((item) => (item.type === "text" ? item.text : ""))),
+                ].join("\n\n"),
+            },
+        ],
         details: { ...result.details, ...page },
     };
 }
+function supervisorControlRunId(result, params) {
+    return result.details.managementControl?.runId ?? params.id ?? params.runId;
+}
 export function cancelSupervisorInput(result, params, ownerSessionId, events) {
-    if (result.isError && !result.content.some((item) => item.type === "text" && /No interrupt-capable run|No running async run|has no (active|running) child at index \d+/.test(item.text)))
+    const rejected = result.isError === true &&
+        !resultMatches(result, /No interrupt-capable run|No running async run|has no (active|running) child at index \d+/);
+    if (rejected) {
         return result;
-    const id = result.details.managementControl?.runId ?? params.id ?? params.runId;
-    if (!id)
+    }
+    const id = supervisorControlRunId(result, params);
+    if (id === undefined || id.length === 0) {
         return result;
-    const questions = listSupervisorQuestions(ownerSessionId, id).filter((question) => (params.index === undefined || params.index === question.index) && (question.state === "awaiting_input" || question.state === "answer_pending"));
-    if (!questions.length)
+    }
+    const questions = listSupervisorQuestions(ownerSessionId, id).filter((question) => (params.index === undefined || params.index === question.index) && pendingQuestion(question));
+    if (questions.length === 0) {
         return result;
+    }
     for (const question of questions) {
         cancelSupervisorQuestion(question);
         events?.emit("subagent:supervisor-question-resolved", { questionId: question.questionId });
     }
     const cancelled = questions.map((question) => readQuestionState(question));
-    return result.isError ? questionResult(cancelled, `Cancelled ${questions.length} pending supervisor question(s). Any live waiter will abort its agent; cancellation is requested, not proof of process exit.`)
+    return result.isError === true
+        ? questionResult(cancelled, `Cancelled ${questions.length} pending supervisor question(s). Any live waiter will abort its agent; cancellation is requested, not proof of process exit.`)
         : { ...result, details: { ...result.details, ...supervisorQuestionPage(cancelled) } };
 }
+function selectQuestion(input) {
+    const { params } = input;
+    if (params.dir !== undefined) {
+        throw new Error("questions/answer use a run id, not dir.");
+    }
+    if (params.index !== undefined && (!Number.isSafeInteger(params.index) || params.index < 0)) {
+        throw new Error("index must be a non-negative integer.");
+    }
+    return listSupervisorQuestions(input.ctx.sessionManager.getSessionId(), params.id ?? params.runId).filter((question) => (params.index === undefined || question.index === params.index) &&
+        (params.action !== "questions" ||
+            params.questionId === undefined ||
+            question.questionId === params.questionId));
+}
+function questionPageResult(questions, params, childSafe) {
+    const page = supervisorQuestionPage(questions, params);
+    const text = [
+        formatSupervisorQuestions(page.questions, childSafe),
+        `Questions: ${page.questions.length} shown, ${page.questionList.total} total (offset ${page.questionList.offset}).`,
+        ...(page.questionList.nextOffset !== undefined
+            ? [
+                `More questions: ${formatRunAction("questions", params.id ?? params.runId, {
+                    offset: page.questionList.nextOffset,
+                    limit: page.questionList.limit,
+                    ...(params.index !== undefined ? { index: params.index } : {}),
+                    ...(params.questionId !== undefined ? { questionId: params.questionId } : {}),
+                }, childSafe)}`,
+            ]
+            : []),
+    ].join("\n\n");
+    return {
+        content: [{ type: "text", text }],
+        details: { mode: "management", results: [], ...page },
+    };
+}
+/** Save the durable answer before either notifying the live waiter or claiming revival. */
 export function controlSupervisorQuestion(input) {
     try {
+        const questions = selectQuestion(input);
         const { params } = input;
-        const id = params.id ?? params.runId;
-        if (params.dir !== undefined)
-            throw new Error("questions/answer use a run id, not dir.");
-        if (params.index !== undefined && (!Number.isSafeInteger(params.index) || params.index < 0))
-            throw new Error("index must be a non-negative integer.");
-        const questions = listSupervisorQuestions(input.ctx.sessionManager.getSessionId(), id)
-            .filter((question) => (params.index === undefined || question.index === params.index) && (params.action !== "questions" || params.questionId === undefined || question.questionId === params.questionId));
         if (params.action === "questions") {
-            const page = supervisorQuestionPage(questions, params), childSafe = Boolean(nestedResolutionScopeForExecutor(input.deps));
-            const text = [formatSupervisorQuestions(page.questions, childSafe),
-                `Questions: ${page.questions.length} shown, ${page.questionList.total} total (offset ${page.questionList.offset}).`,
-                ...(page.questionList.nextOffset !== undefined ? [`More questions: ${formatRunAction("questions", id, { offset: page.questionList.nextOffset, limit: page.questionList.limit,
-                        ...(params.index !== undefined ? { index: params.index } : {}), ...(params.questionId ? { questionId: params.questionId } : {}) }, childSafe)}`] : [])].join("\n\n");
-            return { content: [{ type: "text", text }], details: { mode: "management", results: [], ...page } };
+            return questionPageResult(questions, params, nestedResolutionScopeForExecutor(input.deps) !== undefined);
         }
-        if (!id || !params.questionId)
+        const id = params.id ?? params.runId;
+        if (id === undefined ||
+            id.length === 0 ||
+            params.questionId === undefined ||
+            params.questionId.length === 0) {
             throw new Error("action='answer' requires id and questionId.");
+        }
         const question = questions.find((entry) => entry.questionId === params.questionId);
-        if (!question)
+        if (!question) {
             throw new Error("Question not found in this session's runs. Resume the owning supervisor session to answer it.");
-        const answer = saveQuestionAnswer(question, params.message ?? "", undefined, params.messageOrigin);
-        input.deps.pi.events.emit("subagent:supervisor-question-resolved", { questionId: question.questionId });
-        if (!question.delivery && questionProcessAlive(question))
-            return questionResult([readQuestionState(question)], [`Answer saved for question ${question.questionId}. The live child will read it from the durable waiter; delivery is pending, not execution completion.`, liveLaunchOverrideNotice(params)].filter(Boolean).join("\n"));
-        const delivery = readQuestionState(question).delivery;
-        if (delivery)
-            return questionResult([readQuestionState(question)], `Question ${question.questionId} was already answered; no new work started. Delivery: ${delivery.kind}, run: ${delivery.runId}.`);
-        const claim = claimQuestionRevival(question);
-        if (!claim.claimed)
-            return questionResult([readQuestionState(question)], `Answer retained for question ${question.questionId}; continuation ${claim.runId} was already requested. No duplicate process started. Inspect that run first. ${questionRecoveryHint(question, Boolean(nestedResolutionScopeForExecutor(input.deps)))}`);
-        const result = reviveSavedSubagent({ ...input, params: { ...params, message: `${answer.origin === "human" ? "Direct user answer (human origin)" : "Supervisor answer"} to question ${question.questionId}:\n\n${answer.message}\n\nOriginal question:\n${question.message}` } }, { ...question, source: "question" }, claim.runId);
-        if (result.isError) {
-            releaseQuestionRevival(question);
-            return { ...result, details: { ...result.details, ...supervisorQuestionPage([readQuestionState(question)]) } };
         }
-        recordQuestionDelivery(question, { kind: "revive", runId: claim.runId, deliveredAt: Date.now() });
-        return { ...result, details: { ...result.details, ...supervisorQuestionPage([readQuestionState(question)]) } };
+        const answer = saveQuestionAnswer(question, params.message ?? "", undefined, params.messageOrigin);
+        input.deps.pi.events.emit("subagent:supervisor-question-resolved", {
+            questionId: question.questionId,
+        });
+        return deliverQuestionAnswer(input, question, answer);
     }
     catch (error) {
-        return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "management", results: [] } };
+        return {
+            content: [{ type: "text", text: errorMessage(error) }],
+            isError: true,
+            details: { mode: "management", results: [] },
+        };
+    }
+}
+function deliverQuestionAnswer(input, question, answer) {
+    if (!question.delivery && questionProcessAlive(question)) {
+        return questionResult([readQuestionState(question)], [
+            `Answer saved for question ${question.questionId}. The live child will read it from the durable waiter; delivery is pending, not execution completion.`,
+            liveLaunchOverrideNotice(input.params),
+        ]
+            .filter((notice) => notice !== undefined && notice.length > 0)
+            .join("\n"));
     }
+    const delivery = readQuestionState(question).delivery;
+    if (delivery) {
+        return questionResult([readQuestionState(question)], `Question ${question.questionId} was already answered; no new work started. Delivery: ${delivery.kind}, run: ${delivery.runId}.`);
+    }
+    return reviveQuestionAnswer(input, question, answer);
+}
+/** Claim before launch; publish delivery only after a successful handoff. */
+function reviveQuestionAnswer(input, question, answer) {
+    const claim = claimQuestionRevival(question);
+    if (!claim.claimed) {
+        return questionResult([readQuestionState(question)], `Answer retained for question ${question.questionId}; continuation ${claim.runId} was already requested. No duplicate process started. Inspect that run first. ${questionRecoveryHint(question, nestedResolutionScopeForExecutor(input.deps) !== undefined)}`);
+    }
+    // A throw can follow process handoff. Retain the claim on an ambiguous failure
+    // so a retry cannot launch a duplicate; only an explicit failed receipt releases it.
+    const result = reviveSavedSubagent({
+        ...input,
+        params: {
+            ...input.params,
+            message: `${answer.origin === "human" ? "Direct user answer (human origin)" : "Supervisor answer"} to question ${question.questionId}:\n\n${answer.message}\n\nOriginal question:\n${question.message}`,
+        },
+    }, { ...question, source: "question" }, claim.runId);
+    if (result.isError === true) {
+        releaseQuestionRevival(question);
+    }
+    else {
+        recordQuestionDelivery(question, {
+            kind: "revive",
+            runId: claim.runId,
+            deliveredAt: Date.now(),
+        });
+    }
+    return {
+        ...result,
+        details: { ...result.details, ...supervisorQuestionPage([readQuestionState(question)]) },
+    };
 }

package/dist/runs/foreground/resume-target.js

@@ -0,0 +1,221 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveAsyncResumeTarget } from "../background/async-resume.js";
+import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
+import { resolveNestedAsyncDir } from "../shared/nested-events.js";
+import { readStatus } from "../../shared/utils.js";
+import { resolveRememberedForegroundRun } from "./foreground-memory.js";
+function foregroundTarget(params, state) {
+    const requested = (params.id ?? params.runId)?.trim();
+    const run = resolveRememberedForegroundRun(requested, state);
+    if (!run) {
+        return;
+    }
+    if (run.children.length > 1 && params.index === undefined) {
+        throw new Error(`Foreground run '${run.runId}' has ${run.children.length} children. Provide index to choose one.`);
+    }
+    const index = params.index ?? 0;
+    if (!Number.isInteger(index)) {
+        throw new Error(`Foreground run '${run.runId}' index must be an integer.`);
+    }
+    const child = index >= 0 ? run.children.at(index) : undefined;
+    if (!child) {
+        throw new Error(`Foreground run '${run.runId}' has ${run.children.length} children. Index ${index} is out of range.`);
+    }
+    const sessionFile = foregroundSessionFile(run.runId, index, child);
+    return {
+        kind: "revive",
+        source: "foreground",
+        runId: run.runId,
+        state: "complete",
+        agent: child.agent,
+        index,
+        intercomTarget: resolveSubagentIntercomTarget(run.runId, child.agent, index),
+        cwd: run.cwd,
+        sessionFile,
+        effectiveAcceptance: child.effectiveAcceptance,
+    };
+}
+function foregroundSessionFile(runId, index, child) {
+    if (child.status === "detached") {
+        throw new Error(`Foreground run '${runId}' child ${index} is detached for intercom coordination and cannot be revived safely from the remembered foreground state. Reply to the supervisor request first; after the child exits, start a fresh follow-up if needed.`);
+    }
+    const file = child.sessionFile;
+    if (file === undefined || file.length === 0) {
+        throw new Error(`Foreground run '${runId}' child ${index} does not have a persisted session file to resume from.`);
+    }
+    if (path.extname(file) !== ".jsonl") {
+        throw new Error(`Foreground run '${runId}' child ${index} session file must be a .jsonl file: ${file}`);
+    }
+    const resolved = path.resolve(file);
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`Foreground run '${runId}' child ${index} session file does not exist: ${file}`);
+    }
+    return resolved;
+}
+function asyncCandidate(params) {
+    try {
+        const target = resolveAsyncResumeTarget(params);
+        return {
+            target: target.kind === "live"
+                ? { ...target, kind: "live", source: "async" }
+                : { ...target, kind: "revive", source: "async" },
+        };
+    }
+    catch (error) {
+        return {
+            error,
+            rethrow: () => {
+                throw error;
+            },
+        };
+    }
+}
+function foregroundCandidate(params, state) {
+    try {
+        return { target: foregroundTarget(params, state) };
+    }
+    catch (error) {
+        return {
+            error,
+            rethrow: () => {
+                throw error;
+            },
+        };
+    }
+}
+function exactError(error, source, requested) {
+    if (!(error instanceof Error) || requested.length === 0) {
+        return false;
+    }
+    const escaped = requested.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`\\b${source} run '${escaped}'`, "i").test(error.message);
+}
+function ambiguity(error) {
+    return error instanceof Error && /Ambiguous .*run id prefix/.test(error.message);
+}
+function preferCandidate(target, failure, requested, source) {
+    if (failure &&
+        (exactError(failure.error, source, requested) ||
+            (ambiguity(failure.error) && target.runId !== requested))) {
+        failure.rethrow();
+    }
+    return target;
+}
+function chooseBoth(foreground, asynchronous, requested) {
+    if (foreground.runId === requested && asynchronous.runId !== requested) {
+        return foreground;
+    }
+    if (asynchronous.runId === requested && foreground.runId !== requested) {
+        return asynchronous;
+    }
+    throw new Error(`Resume id '${requested}' is ambiguous between foreground run '${foreground.runId}' and async run '${asynchronous.runId}'. Provide a full run id.`);
+}
+function selectResumeCandidate(foreground, asynchronous, requested) {
+    const fg = "target" in foreground ? foreground.target : undefined;
+    const async = "target" in asynchronous ? asynchronous.target : undefined;
+    if (fg && async) {
+        return chooseBoth(fg, async, requested);
+    }
+    if (fg) {
+        return preferCandidate(fg, "error" in asynchronous ? asynchronous : undefined, requested, "async");
+    }
+    if (async) {
+        return preferCandidate(async, "error" in foreground ? foreground : undefined, requested, "foreground");
+    }
+    return rethrowMissingCandidates(foreground, asynchronous);
+}
+function rethrowMissingCandidates(foreground, asynchronous) {
+    if ("error" in foreground && Boolean(foreground.error)) {
+        foreground.rethrow();
+    }
+    if ("error" in asynchronous && Boolean(asynchronous.error)) {
+        asynchronous.rethrow();
+    }
+    throw new Error("Run not found. Provide id or runId.");
+}
+export function resolveResumeTarget(params, state) {
+    const requested = (params.id ?? params.runId)?.trim() ?? "";
+    return selectResumeCandidate(foregroundCandidate(params, state), asyncCandidate(params), requested);
+}
+function nestedSessionFile(run) {
+    return run.sessionFile ?? (run.steps?.length === 1 ? run.steps[0]?.sessionFile : undefined);
+}
+function pathWithin(base, candidate) {
+    const root = path.resolve(base), file = path.resolve(candidate);
+    return file === root || file.startsWith(`${root}${path.sep}`);
+}
+function trustedSessionFile(run, roots) {
+    const file = nestedSessionFile(run);
+    if (file === undefined || file.length === 0) {
+        throw new Error(`Nested run '${run.id}' does not have a persisted session file to resume from.`);
+    }
+    if (path.extname(file) !== ".jsonl") {
+        throw new Error(`Nested run '${run.id}' session file must be a .jsonl file: ${file}`);
+    }
+    if (!path.isAbsolute(file)) {
+        throw new Error(`Nested run '${run.id}' session file must be absolute: ${file}`);
+    }
+    const resolved = path.resolve(file);
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`Nested run '${run.id}' session file does not exist: ${file}`);
+    }
+    const stat = fs.lstatSync(resolved);
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        throw new Error(`Nested run '${run.id}' session file is not a regular file: ${file}`);
+    }
+    const real = fs.realpathSync(resolved);
+    const trusted = roots.filter((root) => fs.existsSync(root)).map((root) => fs.realpathSync(root));
+    if (!trusted.some((root) => pathWithin(root, real))) {
+        throw new Error(`Nested run '${run.id}' session file is outside trusted nested session roots: ${file}`);
+    }
+    if (!real.split(path.sep).includes(run.id)) {
+        throw new Error(`Nested run '${run.id}' session file is not under that nested run's session directory: ${file}`);
+    }
+    return real;
+}
+function nestedState(run) {
+    if (run.state === "complete" ||
+        run.state === "failed" ||
+        run.state === "blocked" ||
+        run.state === "paused") {
+        return run.state;
+    }
+    return "failed";
+}
+function nestedAgent(run) {
+    const agent = run.agent ?? run.agents?.[0] ?? (run.steps?.length === 1 ? run.steps[0]?.agent : undefined);
+    if (agent === undefined || agent.length === 0) {
+        throw new Error(`Could not determine child agent for nested run '${run.id}'.`);
+    }
+    return agent;
+}
+function nestedRuntimeDetails(dir) {
+    if (dir === undefined || dir.length === 0) {
+        return {};
+    }
+    return {
+        cwd: path.dirname(dir),
+        effectiveAcceptance: readStatus(dir)?.steps?.[0]?.acceptance?.effectiveAcceptance,
+    };
+}
+export function resolveNestedResumeTarget(target, trustedRoots) {
+    const run = target.match.run;
+    if (run.state === "running" || run.state === "queued") {
+        throw new Error(`Nested run '${run.id}' is live; route the follow-up to the owner process instead.`);
+    }
+    const agent = nestedAgent(run);
+    const dir = resolveNestedAsyncDir(target.match.rootRunId, run);
+    const runtime = nestedRuntimeDetails(dir);
+    return {
+        kind: "revive",
+        source: "nested",
+        runId: run.id,
+        state: nestedState(run),
+        agent,
+        index: 0,
+        intercomTarget: resolveSubagentIntercomTarget(run.id, agent, 0),
+        sessionFile: trustedSessionFile(run, trustedRoots),
+        ...runtime,
+    };
+}

package/dist/runs/foreground/revival-launch-policy.js

@@ -0,0 +1,58 @@
+import { acceptanceInputFromResolved } from "../shared/acceptance.js";
+import { resolveControlConfig } from "../shared/subagent-control.js";
+import { resolveConfiguredChildProjectTrustPolicy } from "../shared/pi-args.js";
+import { resolveCurrentMaxSubagentDepth, } from "../../shared/types.js";
+function resources(input) {
+    return {
+        maxOutput: input.params.maxOutput ?? input.saved?.maxOutput,
+        shareEnabled: input.params.share ?? input.saved?.share ?? false,
+    };
+}
+function artifacts(input) {
+    const disabled = input.params.artifacts === false ||
+        (input.params.artifacts === undefined && input.saved?.artifacts === false);
+    return {
+        artifactsDir: disabled ? undefined : (input.saved?.artifactsDir ?? input.tempArtifactsDir),
+    };
+}
+function outputTarget(input) {
+    const filename = input.generatedOutputFilename;
+    const output = filename !== undefined && filename.length > 0
+        ? true
+        : (input.saved?.output ?? input.contract.output);
+    return { output: input.params.output ?? output, generatedOutputFilename: filename };
+}
+function outputFormat(input) {
+    return {
+        outputMode: input.params.outputMode ?? input.saved?.outputMode ?? input.contract.outputMode,
+        outputSchema: input.params.outputSchema ?? input.saved?.outputSchema ?? input.contract.outputSchema,
+    };
+}
+function acceptance(input) {
+    return {
+        acceptance: input.params.acceptance ??
+            acceptanceInputFromResolved(input.contract.effectiveAcceptance ?? input.saved?.effectiveAcceptance),
+    };
+}
+function control(input) {
+    return {
+        controlConfig: resolveControlConfig(input.saved?.controlConfig ?? input.config.control, input.params.control),
+        projectTrust: input.saved?.projectTrust ??
+            resolveConfiguredChildProjectTrustPolicy(input.config.projectTrust),
+        maxSubagentDepth: input.saved?.maxSubagentDepth ??
+            resolveCurrentMaxSubagentDepth(input.config.maxSubagentDepth),
+        worktreeSetupHook: input.config.worktreeSetupHook,
+        worktreeSetupHookTimeoutMs: input.config.worktreeSetupHookTimeoutMs,
+    };
+}
+/** Explicit overrides win over the frozen launch; legacy contract output/acceptance remain recoverable. */
+export function resolveRevivalLaunchPolicy(input) {
+    return {
+        ...artifacts(input),
+        ...resources(input),
+        ...outputTarget(input),
+        ...outputFormat(input),
+        ...acceptance(input),
+        ...control(input),
+    };
+}