@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/dist/runs/shared/supervisor-questions.js

@@ -3,231 +3,157 @@ import * as path from "node:path";
 import { randomUUID } from "node:crypto";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { formatRunAction } from "../../shared/status-format.js";
-import { NativeJournal, ownerProjection, readJsonProjection } from "../../shared/journal-reader.js";
-import { getAgentDir } from "../../shared/utils.js";
 import { runCooperatively, runSynchronously } from "../../shared/cooperative.js";
-import { ASYNC_DIR, TEMP_ROOT_DIR } from "../../shared/types.js";
-export const LEGACY_QUESTIONS_DIR = path.join(TEMP_ROOT_DIR, "supervisor-questions");
-export const QUESTIONS_DIR = path.join(getAgentDir(), "sessions", "subagent-runs");
+import { ASYNC_DIR } from "../../shared/types.js";
+import { getRunMetadataDir, readRunJson, readQuestionOwner, safeId, QUESTIONS_DIR, migrateSupervisorQuestionSteps, migrateSupervisorQuestions, readQuestionContract, } from "./run-metadata.js";
+import { parseAsyncStatus, parseSupervisorQuestion } from "../background/run-schemas.js";
+import { hasErrorCode } from "../../shared/unknown.js";
+import { questionDir, readQuestionState } from "./supervisor-question-state.js";
+export { LEGACY_QUESTIONS_DIR, QUESTIONS_DIR, getRunMetadataDir, readQuestionOwner, saveAsyncRunResult, compactOwnerResult, saveRunStatus, readRunJson, saveQuestionOwner, saveQuestionContract, readQuestionContract, migrateSupervisorQuestions, migrateSupervisorQuestionSteps, } from "./run-metadata.js";
+export { readQuestionState, saveQuestionAnswer, recordQuestionDelivery, cancelSupervisorQuestion, questionProcessAlive, claimQuestionRevival, releaseQuestionRevival, } from "./supervisor-question-state.js";
 export function summarizeSupervisorQuestion(question) {
     const directory = questionDir(question);
+    const hasInterview = Boolean(question.interview);
     return {
-        questionId: question.questionId, runId: question.runId, ownerSessionId: question.ownerSessionId, ownerTarget: question.ownerTarget,
-        agent: question.agent, index: question.index, childSessionId: question.childSessionId, childTarget: question.childTarget,
-        sessionFile: question.sessionFile, cwd: question.cwd, pid: question.pid, processIdentity: question.processIdentity,
-        createdAt: question.createdAt, reason: question.reason, state: question.state, message: question.message.slice(0, 2048),
+        questionId: question.questionId,
+        runId: question.runId,
+        ownerSessionId: question.ownerSessionId,
+        ownerTarget: question.ownerTarget,
+        agent: question.agent,
+        index: question.index,
+        childSessionId: question.childSessionId,
+        childTarget: question.childTarget,
+        sessionFile: question.sessionFile,
+        cwd: question.cwd,
+        pid: question.pid,
+        processIdentity: question.processIdentity,
+        createdAt: question.createdAt,
+        reason: question.reason,
+        state: question.state,
+        message: question.message.slice(0, 2048),
         questionPath: path.join(directory, "question.json"),
         ...(question.message.length > 2048 ? { messageTruncated: true } : {}),
-        ...(question.interview ? { hasInterview: true } : {}),
-        ...(question.answer ? { answer: { message: question.answer.message.slice(0, 2048), answeredAt: question.answer.answeredAt, origin: question.answer.origin },
-            answerPath: path.join(directory, "answer.json"), ...(question.answer.message.length > 2048 ? { answerTruncated: true } : {}) } : {}),
-        ...(question.delivery ? { delivery: { kind: question.delivery.kind, runId: question.delivery.runId, deliveredAt: question.delivery.deliveredAt } } : {}),
-        ...(question.revival ? { revival: { runId: question.revival.runId, pid: question.revival.pid, startedAt: question.revival.startedAt } } : {}),
+        ...(hasInterview ? { hasInterview: true } : {}),
+        ...(question.answer
+            ? {
+                answer: {
+                    message: question.answer.message.slice(0, 2048),
+                    answeredAt: question.answer.answeredAt,
+                    origin: question.answer.origin,
+                },
+                answerPath: path.join(directory, "answer.json"),
+                ...(question.answer.message.length > 2048 ? { answerTruncated: true } : {}),
+            }
+            : {}),
+        ...(question.delivery
+            ? {
+                delivery: {
+                    kind: question.delivery.kind,
+                    runId: question.delivery.runId,
+                    deliveredAt: question.delivery.deliveredAt,
+                },
+            }
+            : {}),
+        ...(question.revival
+            ? {
+                revival: {
+                    runId: question.revival.runId,
+                    pid: question.revival.pid,
+                    startedAt: question.revival.startedAt,
+                },
+            }
+            : {}),
     };
 }
 export function supervisorQuestionPage(questions, options = {}) {
     const offset = options.offset ?? 0, limit = options.limit ?? 20;
-    if (!Number.isSafeInteger(offset) || offset < 0)
+    if (!Number.isSafeInteger(offset) || offset < 0) {
         throw new Error("Question offset must be a non-negative integer.");
-    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
-        throw new Error("Question limit must be from 1 to 100.");
-    const pending = (question) => question.state === "awaiting_input" || question.state === "answer_pending" ? 0 : 1;
-    const sorted = questions.toSorted((a, b) => pending(a) - pending(b) || a.createdAt - b.createdAt || a.questionId.localeCompare(b.questionId));
-    return { questions: sorted.slice(offset, offset + limit).map((question) => summarizeSupervisorQuestion(question)),
-        questionList: { total: questions.length, offset, limit, ...(offset + limit < questions.length ? { nextOffset: offset + limit } : {}) } };
-}
-function safeId(value) {
-    if (typeof value !== "string" || !/^[a-zA-Z0-9_-]+$/.test(value))
-        throw new Error("Invalid run or question ID.");
-    return value;
-}
-export function getRunMetadataDir(runId, root = QUESTIONS_DIR) {
-    return path.join(root, safeId(runId));
-}
-export function saveAsyncRunResult(runId, result) {
-    const file = path.join(getRunMetadataDir(runId), "result.json");
-    const previous = readRunJson(file);
-    if (previous?.completionId && result.completionId && previous.completionId !== result.completionId)
-        throw new Error("Conflicting completion identity");
-    const saved = { ...result, recordVersion: 3, completionId: previous?.completionId ?? result.completionId ?? randomUUID(),
-        ...(preserveLegacyOwner(file, previous) ? { legacySource: `${file}.legacy` } : {}),
-        results: result.results?.map((child, index) => compactOwnerResult(runId, index, child)) };
-    writeAtomicJson(file, saved);
-    return saved;
-}
-function preserveLegacyOwner(file, previous) {
-    if (!previous || previous.recordVersion === 3)
-        return false;
-    try {
-        fs.copyFileSync(file, `${file}.legacy`, fs.constants.COPYFILE_EXCL);
     }
-    catch (error) {
-        if (error.code !== "EEXIST")
-            throw error;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) {
+        throw new Error("Question limit must be from 1 to 100.");
     }
-    return true;
-}
-export function compactOwnerResult(runId, index, result, root = QUESTIONS_DIR) {
-    const output = result.finalOutput ?? result.output;
-    let fullOutputPath = result.fullOutputPath;
-    if (output && output.length > 8192) {
-        fullOutputPath ??= result.artifactPaths?.outputPath;
-        if (!fullOutputPath) {
-            fullOutputPath = path.join(getRunMetadataDir(runId, root), "outputs", `${index}.txt`);
-            fs.mkdirSync(path.dirname(fullOutputPath), { recursive: true });
-            fs.writeFileSync(fullOutputPath, output, { mode: 0o600 });
+    const pending = (question) => question.state === "awaiting_input" || question.state === "answer_pending" ? 0 : 1;
+    const sorted = questions.toSorted((a, b) => {
+        const priority = pending(a) - pending(b);
+        if (priority !== 0) {
+            return priority;
         }
-    }
-    let initialOutputPath = result.initialOutputPath;
-    if (result.initialOutput && result.initialOutput.length > 8192 && !initialOutputPath) {
-        initialOutputPath = path.join(getRunMetadataDir(runId, root), "outputs", `${index}.initial.txt`);
-        fs.mkdirSync(path.dirname(initialOutputPath), { recursive: true });
-        fs.writeFileSync(initialOutputPath, result.initialOutput, { mode: 0o600 });
-    }
-    return { ...result, messages: undefined, ...(fullOutputPath ? { fullOutputPath } : {}),
-        ...(initialOutputPath ? { initialOutputPath } : {}),
-        ...(result.finalOutput !== undefined ? { finalOutput: result.finalOutput.slice(-8192) } : {}),
-        ...(result.output !== undefined ? { output: result.output.slice(-8192) } : {}),
-        ...(result.initialOutput !== undefined ? { initialOutput: result.initialOutput.slice(-8192) } : {}) };
-}
-export function saveRunStatus(runId, status) {
-    writeAtomicJson(path.join(getRunMetadataDir(runId), "status.json"), status);
+        if (a.createdAt !== b.createdAt) {
+            return a.createdAt - b.createdAt;
+        }
+        return a.questionId.localeCompare(b.questionId);
+    });
+    return {
+        questions: sorted.slice(offset, offset + limit).map(summarizeSupervisorQuestion),
+        questionList: {
+            total: questions.length,
+            offset,
+            limit,
+            ...(offset + limit < questions.length ? { nextOffset: offset + limit } : {}),
+        },
+    };
 }
-export function readRunJson(file) {
-    try {
-        return readJsonProjection(file, ownerProjection);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
+function questionOwner(runId, root) {
+    const runDir = getRunMetadataDir(runId, root);
+    const status = readRunJson(path.join(runDir, "status.json"), parseAsyncStatus) ??
+        (root === QUESTIONS_DIR
+            ? readRunJson(path.join(ASYNC_DIR, safeId(runId), "status.json"), parseAsyncStatus)
+            : undefined);
+    const owner = readQuestionOwner(runId, root) ?? status;
+    if (owner?.sessionId === undefined || owner.sessionId === "") {
+        throw new Error(`Run ${runId} has no saved question owner; cannot create a recoverable supervisor question.`);
     }
+    return { sessionId: owner.sessionId, status };
 }
-function questionDir(question, root = QUESTIONS_DIR) {
-    return path.join(root, safeId(question.runId), "questions", safeId(question.questionId));
-}
-// Atomic publication without replacement: concurrent answers/launches have exactly one winner.
-function writeOnce(file, value) {
-    const temporary = `${file}.${randomUUID()}.tmp`;
-    writeAtomicJson(temporary, value);
-    try {
-        fs.linkSync(temporary, file);
-        return true;
-    }
-    catch (error) {
-        if (error.code === "EEXIST")
-            return false;
-        throw error;
-    }
-    finally {
-        fs.rmSync(temporary, { force: true });
+function validateQuestionInput(input) {
+    if (typeof input.sessionFile !== "string" ||
+        input.sessionFile === "" ||
+        path.extname(input.sessionFile) !== ".jsonl") {
+        throw new Error("Supervisor questions require a saved child session.");
     }
-}
-export function saveQuestionOwner(runId, sessionId, root = QUESTIONS_DIR) {
-    writeAtomicJson(path.join(root, safeId(runId), "question-owner.json"), { sessionId });
-}
-export function saveQuestionContract(runId, index, contract, root = QUESTIONS_DIR) {
-    if (!Number.isSafeInteger(index) || index < 0)
+    if (!Number.isSafeInteger(input.index) || input.index < 0) {
         throw new Error("Child index must be a non-negative integer.");
-    const file = path.join(root, safeId(runId), "contracts", `${index}.json`);
-    const previous = readRunJson(file);
-    writeAtomicJson(file, { ...previous, ...contract, recordVersion: 3,
-        ...(preserveLegacyOwner(file, previous) ? { legacySource: `${file}.legacy` } : {}),
-        ...(previous?.attemptBaseline && contract.baselineSource !== "native-migration" ? { attemptBaseline: previous.attemptBaseline } : {}),
-        ...(contract.result ? { result: compactOwnerResult(runId, index, contract.result, root) } : {}),
-        ...(previous?.launch ? { launch: previous.launch } : {}) });
-}
-export function readQuestionContract(runId, index, root = QUESTIONS_DIR, projection = {}) {
-    const contract = readRunJson(path.join(root, safeId(runId), "contracts", `${index}.json`));
-    if (!contract?.launch || projection.readConfiguration === false)
-        return contract;
-    const sessionFile = projection.sessionFile ?? contract.sessionFile;
-    if (contract.recordVersion !== 3 && !contract.effectiveConfiguration && sessionFile && fs.existsSync(sessionFile) && !contract.launch.model?.startsWith("claude-code/")) {
-        // One-time read-only native recovery. Subsequent controls use the compact
-        // selection, and the frozen requested profile is never rewritten.
-        const journal = new NativeJournal(sessionFile, "inspect", true);
-        contract.effectiveConfiguration = journal.configuration(projection.endedAt, contract.terminalLeafId);
-        saveQuestionContract(runId, index, { effectiveConfiguration: contract.effectiveConfiguration }, root);
     }
-    const native = contract.effectiveConfiguration ?? {};
-    return { ...contract, launch: { ...contract.launch, ...native } };
-}
-export function migrateSupervisorQuestions(ownerSessionId, runId) {
-    runSynchronously(migrateSupervisorQuestionSteps(ownerSessionId, runId));
-}
-export function* migrateSupervisorQuestionSteps(ownerSessionId, runId) {
-    if (!fs.existsSync(LEGACY_QUESTIONS_DIR))
-        return;
-    const runs = runId === undefined ? fs.readdirSync(LEGACY_QUESTIONS_DIR, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [safeId(runId)];
-    for (const id of runs) {
-        yield;
-        try {
-            const source = getRunMetadataDir(id, LEGACY_QUESTIONS_DIR);
-            const owner = readRunJson(path.join(source, "question-owner.json"));
-            if (owner?.sessionId !== ownerSessionId)
-                continue;
-            fs.cpSync(source, getRunMetadataDir(id), { recursive: true, force: false });
-        }
-        catch (error) {
-            if (runId !== undefined)
-                throw error;
-            console.error(`Could not recover legacy questions for ${id}: ${String(error)}`);
-        }
+    if (typeof input.message !== "string" || input.message.trim() === "") {
+        throw new Error("Supervisor question must not be empty.");
     }
 }
 export function createSupervisorQuestion(input, root = QUESTIONS_DIR) {
-    const runDir = path.join(root, safeId(input.runId));
-    const status = readRunJson(path.join(runDir, "status.json"))
-        ?? (root === QUESTIONS_DIR ? readRunJson(path.join(ASYNC_DIR, safeId(input.runId), "status.json")) : undefined);
-    const owner = readRunJson(path.join(runDir, "question-owner.json")) ?? status;
-    if (!owner?.sessionId)
-        throw new Error(`Run ${input.runId} has no saved question owner; cannot create a recoverable supervisor question.`);
-    if (!input.sessionFile || path.extname(input.sessionFile) !== ".jsonl")
-        throw new Error("Supervisor questions require a saved child session.");
-    if (!Number.isSafeInteger(input.index) || input.index < 0)
-        throw new Error("Child index must be a non-negative integer.");
-    if (!input.message.trim())
-        throw new Error("Supervisor question must not be empty.");
-    const contract = readQuestionContract(input.runId, input.index, root, { sessionFile: input.sessionFile })
-        ?? { effectiveAcceptance: status?.steps?.[input.index]?.acceptance?.effectiveAcceptance };
-    const question = { ...input, ...contract, sessionFile: input.sessionFile, pid: input.pid, ownerSessionId: owner.sessionId, questionId: randomUUID(), createdAt: Date.now() };
+    const owner = questionOwner(input.runId, root);
+    validateQuestionInput(input);
+    const contract = readQuestionContract(input.runId, input.index, root, {
+        sessionFile: input.sessionFile,
+    }) ?? {
+        effectiveAcceptance: owner.status?.steps?.[input.index]?.acceptance?.effectiveAcceptance,
+    };
+    const question = {
+        ...input,
+        ...contract,
+        sessionFile: input.sessionFile,
+        pid: input.pid,
+        ownerSessionId: owner.sessionId,
+        questionId: randomUUID(),
+        createdAt: Date.now(),
+    };
     writeAtomicJson(path.join(questionDir(question, root), "question.json"), question);
     return question;
 }
-function questionStatePaths(question, file, root) {
-    const current = path.join(questionDir(question, root), file);
-    const legacy = questionDir(question, LEGACY_QUESTIONS_DIR);
-    // Old waiters still claim the legacy file; both runtimes must compete on that same inode.
-    return root === QUESTIONS_DIR && fs.existsSync(path.join(legacy, "question.json")) ? [path.join(legacy, file), current] : [current];
-}
-function writeQuestionStateOnce(question, file, value, root) {
-    const [primary, ...mirrors] = questionStatePaths(question, file, root);
-    const written = writeOnce(primary, value);
-    const winner = written ? value : readRunJson(primary);
-    for (const target of mirrors)
-        writeOnce(target, winner);
-    return written;
-}
-export function readQuestionState(question, root = QUESTIONS_DIR) {
-    const read = (file) => questionStatePaths(question, file, root).map((entry) => readRunJson(entry)).find((entry) => entry !== undefined);
-    const answer = read("answer.json");
-    const delivery = read("delivery.json");
-    const cancelled = read("cancelled.json") !== undefined;
-    const revival = read("revival.json");
-    return { ...question, state: delivery ? "answered" : cancelled ? "cancelled" : answer ? "answer_pending" : "awaiting_input", ...(answer ? { answer } : {}), ...(delivery ? { delivery } : {}), ...(revival ? { revival } : {}) };
-}
 export function listRunQuestions(runDir) {
     let entries;
     try {
         entries = fs.readdirSync(path.join(runDir, "questions"), { withFileTypes: true });
     }
     catch (error) {
-        if (error.code === "ENOENT")
+        if (hasErrorCode(error, "ENOENT")) {
             return [];
+        }
         throw error;
     }
-    return entries.filter((entry) => entry.isDirectory()).flatMap((entry) => {
-        const question = readRunJson(path.join(runDir, "questions", entry.name, "question.json"));
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .flatMap((entry) => {
+        const question = readRunJson(path.join(runDir, "questions", entry.name, "question.json"), parseSupervisorQuestion);
         return question ? [readQuestionState(question, path.dirname(runDir))] : [];
     });
 }
@@ -237,17 +163,24 @@ export function listOwnedRunQuestions(ownerSessionId, runId) {
     return listRunQuestions(getRunMetadataDir(runId)).filter((question) => question.ownerSessionId === ownerSessionId);
 }
 export function pendingSupervisorQuestion(input) {
-    if (!input.sessionFile)
+    if (input.sessionFile === undefined || input.sessionFile === "") {
         return undefined;
+    }
     try {
         const pid = input.pid ?? readQuestionContract(input.runId, input.index)?.pid;
-        const question = listRunQuestions(getRunMetadataDir(input.runId)).find((question) => question.runId === input.runId && question.agent === input.agent && question.index === input.index
-            && question.sessionFile === input.sessionFile && question.pid === pid
-            && (question.state === "awaiting_input" || question.state === "answer_pending"));
-        if (question && (question.state === "awaiting_input" || question.state === "answer_pending"))
+        const question = listRunQuestions(getRunMetadataDir(input.runId)).find((candidate) => candidate.runId === input.runId &&
+            candidate.agent === input.agent &&
+            candidate.index === input.index &&
+            candidate.sessionFile === input.sessionFile &&
+            candidate.pid === pid &&
+            (candidate.state === "awaiting_input" || candidate.state === "answer_pending"));
+        if (question && (question.state === "awaiting_input" || question.state === "answer_pending")) {
             return {
-                questionId: question.questionId, state: question.state, ...(question.answer ? { answer: question.answer.message } : {}),
+                questionId: question.questionId,
+                state: question.state,
+                ...(question.answer ? { answer: question.answer.message } : {}),
             };
+        }
     }
     catch (error) {
         console.error(`Could not read supervisor wait for ${input.runId}:${input.index}:`, error);
@@ -261,13 +194,19 @@ export function listSupervisorQuestionsAsync(ownerSessionId) {
     return runCooperatively(supervisorQuestionSteps(ownerSessionId));
 }
 function* supervisorQuestionSteps(ownerSessionId, runId, root = QUESTIONS_DIR) {
-    if (runId !== undefined)
+    if (runId !== undefined) {
         safeId(runId);
-    if (root === QUESTIONS_DIR)
+    }
+    if (root === QUESTIONS_DIR) {
         yield* migrateSupervisorQuestionSteps(ownerSessionId);
-    if (!fs.existsSync(root))
+    }
+    if (!fs.existsSync(root)) {
         return [];
-    const runs = fs.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && (!runId || entry.name.startsWith(runId)));
+    }
+    const runs = fs
+        .readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() &&
+        (runId === undefined || runId === "" || entry.name.startsWith(runId)));
     const questions = [];
     for (const entry of runs) {
         yield;
@@ -275,76 +214,68 @@ function* supervisorQuestionSteps(ownerSessionId, runId, root = QUESTIONS_DIR) {
             questions.push(...listRunQuestions(path.join(root, entry.name)).filter((question) => question.ownerSessionId === ownerSessionId));
         }
         catch (error) {
-            if (runId !== undefined)
+            if (runId !== undefined) {
                 throw error;
-            console.error(`Could not list questions for ${entry.name}: ${String(error)}`);
+            }
+            console.error(`Could not list questions for ${entry.name}:`, error);
         }
     }
-    if (runId && new Set(questions.map((question) => question.runId)).size > 1)
-        throw new Error(`Ambiguous run ID prefix '${runId}'.`);
+    assertQuestionRunUnambiguous(runId, questions);
     return questions.sort((a, b) => a.createdAt - b.createdAt);
 }
-export function saveQuestionAnswer(question, message, root = QUESTIONS_DIR, origin) {
-    if (typeof message !== "string" || !message.trim())
-        throw new Error("action='answer' requires a non-empty message.");
-    const state = readQuestionState(question, root);
-    if (state.state === "cancelled")
-        throw new Error(`Question ${question.questionId} was cancelled. Use continue for a new follow-up.`);
-    const answer = { message: message.trim(), answeredAt: state.answer?.answeredAt ?? Date.now(), ...(state.answer?.origin ?? origin ? { origin: state.answer?.origin ?? origin } : {}) };
-    if (state.answer && state.answer.message !== answer.message)
-        throw new Error(`Question ${question.questionId} already has a different saved answer. The original answer was retained.`);
-    if (writeQuestionStateOnce(question, "answer.json", answer, root))
-        return answer;
-    const existing = readQuestionState(question, root).answer;
-    if (existing.message !== answer.message)
-        throw new Error(`Question ${question.questionId} already has a different saved answer. The original answer was retained.`);
-    return existing;
-}
-export function recordQuestionDelivery(question, delivery, root = QUESTIONS_DIR) {
-    writeQuestionStateOnce(question, "delivery.json", delivery, root);
-}
-export function cancelSupervisorQuestion(question, root = QUESTIONS_DIR) {
-    writeQuestionStateOnce(question, "cancelled.json", { cancelledAt: Date.now() }, root);
+function assertQuestionRunUnambiguous(runId, questions) {
+    if (runId !== undefined &&
+        runId !== "" &&
+        new Set(questions.map((question) => question.runId)).size > 1) {
+        throw new Error(`Ambiguous run ID prefix '${runId}'.`);
+    }
 }
-export function questionProcessAlive(question) {
-    if (!Number.isSafeInteger(question.pid) || question.pid <= 0)
-        throw new Error("Invalid child process ID.");
-    try {
-        process.kill(question.pid, 0);
-        return true;
+function questionAnswerHint(question, childSafe) {
+    if (question.delivery) {
+        return `Answer delivered via ${question.delivery.kind}; run: ${question.delivery.runId}`;
     }
-    catch (error) {
-        return error.code !== "ESRCH";
+    if (question.state === "cancelled") {
+        return "Question cancelled; use continue for a new follow-up.";
     }
-}
-export function claimQuestionRevival(question, root = QUESTIONS_DIR) {
-    const runId = `answer-${question.questionId}`;
-    if (readQuestionState(question, root).revival)
-        return { claimed: false, runId };
-    return { claimed: writeQuestionStateOnce(question, "revival.json", { runId, pid: process.pid, startedAt: Date.now() }, root), runId };
-}
-export function releaseQuestionRevival(question, root = QUESTIONS_DIR) {
-    for (const file of questionStatePaths(question, "revival.json", root))
-        fs.rmSync(file, { force: true });
+    if (question.answerTruncated === true) {
+        return `Retry answer with the exact saved message from ${question.answerPath ?? ""}; a preview is not a valid replacement.`;
+    }
+    return `Answer: ${formatRunAction("answer", question.runId, { questionId: question.questionId, message: question.answer?.message ?? "..." }, childSafe)}`;
 }
 export function questionRecoveryHint(question, childSafe = false) {
     return `Recover an unlaunched continuation: ${formatRunAction("resume", question.runId, { index: question.index, message: "Continue with the saved supervisor answer." }, childSafe)}`;
 }
 export function formatSupervisorQuestions(questions, childSafe = false) {
-    if (!questions.length)
+    if (questions.length === 0) {
         return "No supervisor questions owned by this session.";
-    return questions.map((question) => [
+    }
+    return questions
+        .map((question) => [
         `Question: ${question.questionId} | ${question.state}`,
         `Run: ${question.runId} | Child: ${question.index} (${question.agent}) | Owner: ${question.ownerSessionId}`,
         `Session: ${question.sessionFile} | Child target: ${question.childTarget}`,
         question.message,
-        ...(question.messageTruncated ? [`[Question preview truncated. Full question: ${question.questionPath}]`] : []),
-        ...(question.hasInterview ? [`Structured interview: ${question.questionPath}`] : []),
-        ...(question.answer ? [`Saved answer: ${question.answer.message}`, ...(question.answerTruncated ? [`[Answer preview truncated. Exact saved answer: ${question.answerPath}]`] : [])] : []),
-        ...(question.revival && !question.delivery ? [`Continuation requested: ${question.revival.runId}; delivery unconfirmed. Answer retained.`, questionRecoveryHint(question, childSafe)] : []),
-        question.delivery ? `Answer delivered via ${question.delivery.kind}; run: ${question.delivery.runId}`
-            : question.state === "cancelled" ? "Question cancelled; use continue for a new follow-up."
-                : question.answerTruncated ? `Retry answer with the exact saved message from ${question.answerPath}; a preview is not a valid replacement.`
-                    : `Answer: ${formatRunAction("answer", question.runId, { questionId: question.questionId, message: question.answer?.message ?? "..." }, childSafe)}`,
-    ].join("\n")).join("\n\n");
+        ...(question.messageTruncated === true
+            ? [`[Question preview truncated. Full question: ${question.questionPath}]`]
+            : []),
+        ...(question.hasInterview === true
+            ? [`Structured interview: ${question.questionPath}`]
+            : []),
+        ...(question.answer
+            ? [
+                `Saved answer: ${question.answer.message}`,
+                ...(question.answerTruncated === true
+                    ? [`[Answer preview truncated. Exact saved answer: ${question.answerPath ?? ""}]`]
+                    : []),
+            ]
+            : []),
+        ...(question.revival && !question.delivery
+            ? [
+                `Continuation requested: ${question.revival.runId}; delivery unconfirmed. Answer retained.`,
+                questionRecoveryHint(question, childSafe),
+            ]
+            : []),
+        questionAnswerHint(question, childSafe),
+    ].join("\n"))
+        .join("\n\n");
 }