@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/runs/shared/run-history-queries.js

@@ -1,45 +1,136 @@
 import { runHistoryIndex } from "./history-index.js";
 import { ownedRunView, resolveOwnedRun } from "./run-records.js";
-/** Browse observations never confer ownership or replace canonical control/receipt checks. */
-export async function ownedHistoryQuery(state, params, signal) {
-    const requested = params.id ?? params.runId;
-    const run = requested ? resolveOwnedRun(state, requested) : undefined;
-    if (requested && !run)
-        throw new Error("Run not found in this owning session.");
-    const index = await runHistoryIndex(state, true);
-    if (params.action === "history") {
-        if (!run)
-            throw new Error("History requires an owned run ID.");
-        const view = ownedRunView(run, state, { includeContinuations: false, readConfiguration: false, reconcile: false });
-        const child = params.index === undefined && view.children.length === 1 ? view.children[0] : view.children.find((child) => child.index === params.index);
-        if (!child)
-            throw new Error("Choose index for a run with multiple children.");
-        const input = { runId: run.runId, index: child.index, limit: params.limit, before: params.before, cursor: params.cursor, signal,
-            ...(child.state !== "live" ? { terminalEntryId: child.result?.terminalEntryId, endedAt: child.result?.terminalEntryId ? undefined : view.updatedAt } : {}) };
-        const page = await index.historyPage(input);
-        const earlier = page.previousCursor ? { action: "history", id: run.runId, index: child.index, limit: params.limit ?? 100, cursor: page.previousCursor } : undefined;
-        return { content: [{ type: "text", text: [
-                        `History: ${run.runId}, child ${child.index} (${child.agent}); ${page.entries.length} of ${page.count} indexed native entries.`,
-                        `Browse index: ${page.freshness.state}. These are bounded previews, not completion or delivery receipts.`,
-                        ...(page.unavailable ? [page.unavailable] : []),
-                        ...page.entries.map((entry) => `- ${entry.id} · position ${entry.sequence}\n${JSON.stringify(entry.entry)}`),
-                        ...(earlier ? [`Earlier: agent_runs(${JSON.stringify(earlier)})`] : []),
-                        ...(child.sessionFile ? [`Native source: ${child.sessionFile}. Open a selected record in Agents for validated full details.`] : []),
-                    ].join("\n") }], details: { mode: "management", results: [], runId: run.runId, history: page } };
+function selectHistoryChild(view, index) {
+    const child = index === undefined && view.children.length === 1
+        ? view.children[0]
+        : view.children.find((entry) => entry.index === index);
+    if (!child) {
+        throw new Error("Choose index for a run with multiple children.");
     }
-    if (params.action !== "search" || !params.query)
+    return child;
+}
+function historyInput(view, child, params, signal) {
+    return {
+        runId: view.runId,
+        index: child.index,
+        limit: params.limit,
+        before: params.before,
+        cursor: params.cursor,
+        signal,
+        ...(child.state !== "live"
+            ? {
+                terminalEntryId: child.result?.terminalEntryId,
+                endedAt: (child.result?.terminalEntryId ?? "") !== "" ? undefined : view.updatedAt,
+            }
+            : {}),
+    };
+}
+function historyResult(view, child, page, limit) {
+    const earlier = (page.previousCursor ?? "") !== ""
+        ? {
+            action: "history",
+            id: view.runId,
+            index: child.index,
+            limit: limit ?? 100,
+            cursor: page.previousCursor,
+        }
+        : undefined;
+    const source = child.sessionFile;
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
+                    `History: ${view.runId}, child ${child.index} (${child.agent}); ${page.entries.length} of ${page.count} indexed native entries.`,
+                    `Browse index: ${page.freshness.state}. These are bounded previews, not completion or delivery receipts.`,
+                    ...((page.unavailable ?? "") !== "" ? [page.unavailable] : []),
+                    ...page.entries.map((entry) => `- ${entry.id} · position ${entry.sequence}\n${JSON.stringify(entry.entry)}`),
+                    ...(earlier ? [`Earlier: agent_runs(${JSON.stringify(earlier)})`] : []),
+                    ...(source !== undefined && source !== ""
+                        ? [
+                            `Native source: ${source}. Open a selected record in Agents for validated full details.`,
+                        ]
+                        : []),
+                ].join("\n"),
+            },
+        ],
+        details: { mode: "management", results: [], runId: view.runId, history: page },
+    };
+}
+function searchInput(params, run, signal) {
+    if (params.query === undefined || params.query === "") {
         throw new Error("Search requires query.");
-    if (params.sort && !["relevance", "newest"].includes(params.sort))
+    }
+    if (params.sort !== undefined && !["relevance", "newest"].includes(params.sort)) {
         throw new Error("Search sort must be relevance or newest.");
-    const input = { query: params.query, runId: run?.runId, index: params.index, limit: params.limit, cursor: params.cursor,
-        sort: params.sort, agent: params.agent, signal };
+    }
+    return {
+        query: params.query,
+        runId: run?.runId,
+        index: params.index,
+        limit: params.limit,
+        cursor: params.cursor,
+        sort: params.sort === "relevance" || params.sort === "newest" ? params.sort : undefined,
+        agent: params.agent,
+        signal,
+    };
+}
+function searchContinuation(input, page) {
+    if ((page.nextCursor ?? "") === "") {
+        return [];
+    }
+    const next = {
+        action: "search",
+        query: input.query,
+        ...(input.runId !== undefined ? { id: input.runId } : {}),
+        ...(input.index !== undefined ? { index: input.index } : {}),
+        ...((input.agent ?? "") !== "" ? { agent: input.agent } : {}),
+        ...(input.sort !== undefined ? { sort: input.sort } : {}),
+        limit: input.limit ?? 20,
+        cursor: page.nextCursor,
+    };
+    return [`Next: agent_runs(${JSON.stringify(next)})`];
+}
+async function searchHistory(index, input) {
     const page = await index.search(input);
-    const next = page.nextCursor ? { action: "search", query: params.query, ...(run ? { id: run.runId } : {}), ...(params.index !== undefined ? { index: params.index } : {}),
-        ...(params.agent ? { agent: params.agent } : {}), ...(params.sort ? { sort: params.sort } : {}), limit: params.limit ?? 20, cursor: page.nextCursor } : undefined;
-    return { content: [{ type: "text", text: [
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
                     `Saved-text search: ${page.matches.length} matches in this owning session; index ${page.freshness.state}.`,
                     "Indexed excerpts may be stale. They do not establish completion, ownership, or delivery; full selected records are validated separately.",
                     ...page.matches.map((match) => `- ${match.runId}:${match.index} (${match.agent}) · entry ${match.entryId}\n${match.preview}\n${match.sessionFile}:${match.ref.start}`),
-                    ...(next ? [`Next: agent_runs(${JSON.stringify(next)})`] : []),
-                ].join("\n") }], details: { mode: "management", results: [], historySearch: page } };
+                    ...searchContinuation(input, page),
+                ].join("\n"),
+            },
+        ],
+        details: { mode: "management", results: [], historySearch: page },
+    };
+}
+/** Browse observations never confer ownership or replace canonical control/receipt checks. */
+export async function ownedHistoryQuery(state, params, signal) {
+    const requested = params.id ?? params.runId;
+    const run = requested !== undefined && requested !== "" ? resolveOwnedRun(state, requested) : undefined;
+    if (requested !== undefined && requested !== "" && !run) {
+        throw new Error("Run not found in this owning session.");
+    }
+    const index = await runHistoryIndex(state, true);
+    if (params.action !== "history") {
+        if (params.action !== "search") {
+            throw new Error("Search requires query.");
+        }
+        return searchHistory(index, searchInput(params, run, signal));
+    }
+    if (!run) {
+        throw new Error("History requires an owned run ID.");
+    }
+    const view = ownedRunView(run, state, {
+        includeContinuations: false,
+        readConfiguration: false,
+        reconcile: false,
+    });
+    const child = selectHistoryChild(view, params.index);
+    const page = await index.historyPage(historyInput(view, child, params, signal));
+    return historyResult(view, child, page, params.limit);
 }

package/dist/runs/shared/run-history.js

@@ -1,18 +1,34 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { historyDirectory, historyTransaction, openHistoryDatabase } from "../../history/database.js";
-import { getAgentDir } from "../../shared/utils.js";
+import { historyDirectory, historyTransaction, openHistoryDatabase, } from "../../history/database.js";
+import { isRecord } from "../../shared/unknown.js";
+import { getAgentDir } from "../../shared/agent-dir.js";
 const MAX_AGENT_SAMPLES = 1000;
 const MAX_LEGACY_BYTES = 1024 * 1024;
 const TIMING_DATABASE = "run-timing.sqlite";
+function validIdentity(entry) {
+    return (typeof entry.agent === "string" &&
+        entry.agent.length > 0 &&
+        entry.agent.length <= 256 &&
+        typeof entry.task === "string");
+}
+function validTiming(entry) {
+    return (typeof entry.ts === "number" &&
+        Number.isSafeInteger(entry.ts) &&
+        entry.ts >= 0 &&
+        typeof entry.duration === "number" &&
+        Number.isFinite(entry.duration) &&
+        entry.duration >= 0);
+}
 function validEntry(value) {
-    if (!value || typeof value !== "object")
+    if (!isRecord(value)) {
         return false;
-    const entry = value;
-    return typeof entry.agent === "string" && entry.agent.length > 0 && entry.agent.length <= 256
-        && typeof entry.task === "string" && Number.isSafeInteger(entry.ts) && entry.ts >= 0
-        && (entry.status === "ok" || entry.status === "error") && Number.isFinite(entry.duration) && entry.duration >= 0
-        && (entry.exit === undefined || Number.isSafeInteger(entry.exit));
+    }
+    return (validIdentity(value) &&
+        validTiming(value) &&
+        (value.status === "ok" || value.status === "error") &&
+        (value.exit === undefined ||
+            (typeof value.exit === "number" && Number.isSafeInteger(value.exit))));
 }
 /** Legacy samples are read-only, complete LF records from a bounded tail. */
 function legacySamples(agentDir, agent) {
@@ -24,48 +40,80 @@ function legacySamples(agentDir, agent) {
         let count = 0;
         while (count < bytes.length) {
             const read = fs.readSync(fd, bytes, count, bytes.length - count, start + count);
-            if (!read)
+            if (read === 0) {
                 break;
+            }
             count += read;
         }
-        const complete = bytes.subarray(0, count), first = start ? complete.indexOf(10) + 1 : 0, last = complete.lastIndexOf(10);
-        if (last < first || start && !first)
+        const complete = bytes.subarray(0, count), first = start > 0 ? complete.indexOf(10) + 1 : 0, last = complete.lastIndexOf(10);
+        if (last < first || (start > 0 && first === 0)) {
             return [];
-        const samples = [], retained = new Map();
-        for (const line of complete.subarray(first, last).toString("utf8").split("\n").reverse()) {
-            try {
-                const entry = JSON.parse(line);
-                if (!validEntry(entry) || agent !== undefined && entry.agent !== agent || (retained.get(entry.agent) ?? 0) >= MAX_AGENT_SAMPLES)
-                    continue;
-                samples.push({ ...entry, task: entry.task.slice(0, 200) });
-                retained.set(entry.agent, (retained.get(entry.agent) ?? 0) + 1);
-                if (agent !== undefined && samples.length === MAX_AGENT_SAMPLES)
-                    break;
-            }
-            catch { /* Incomplete or invalid timing samples are not evidence. */ }
         }
-        return samples;
+        return parseLegacyLines(complete.subarray(first, last).toString("utf8").split("\n").reverse(), agent);
     }
     catch {
         return [];
     }
     finally {
-        if (fd !== undefined)
+        if (fd !== undefined) {
             fs.closeSync(fd);
+        }
+    }
+}
+function parseLegacySample(line, agent) {
+    try {
+        const entry = JSON.parse(line);
+        if (!validEntry(entry) || (agent !== undefined && entry.agent !== agent)) {
+            return;
+        }
+        return entry;
+    }
+    catch {
+        // Invalid timing samples are not evidence; valid neighboring LF records survive.
+        return;
+    }
+}
+function parseLegacyLines(lines, agent) {
+    const samples = [];
+    const retained = new Map();
+    for (const line of lines) {
+        const entry = parseLegacySample(line, agent);
+        if (!entry || (retained.get(entry.agent) ?? 0) >= MAX_AGENT_SAMPLES) {
+            continue;
+        }
+        samples.push({ ...entry, task: entry.task.slice(0, 200) });
+        retained.set(entry.agent, (retained.get(entry.agent) ?? 0) + 1);
+        if (agent !== undefined && samples.length === MAX_AGENT_SAMPLES) {
+            break;
+        }
     }
+    return samples;
 }
 export function recordRun(agent, task, exitCode, durationMs) {
-    const entry = { agent, task: task.slice(0, 200), ts: Math.floor(Date.now() / 1000), status: exitCode === 0 ? "ok" : "error", duration: durationMs, ...(exitCode !== 0 ? { exit: exitCode } : {}) };
-    if (!validEntry(entry))
+    const entry = {
+        agent,
+        task: task.slice(0, 200),
+        ts: Math.floor(Date.now() / 1000),
+        status: exitCode === 0 ? "ok" : "error",
+        duration: durationMs,
+        ...(exitCode !== 0 ? { exit: exitCode } : {}),
+    };
+    if (!validIdentity({ ...entry }) ||
+        !validTiming({ ...entry }) ||
+        !Number.isSafeInteger(exitCode)) {
         return;
+    }
     let db;
     try {
         const agentDir = getAgentDir();
         fs.mkdirSync(agentDir, { recursive: true });
         db = openHistoryDatabase(path.join(historyDirectory(agentDir), TIMING_DATABASE));
         const connection = db;
-        const imported = connection.prepare("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='timing_meta'").get()
-            && connection.prepare("SELECT key FROM timing_meta WHERE key='legacy-imported'").get();
+        const imported = connection
+            .prepare("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='timing_meta'")
+            .get() !== undefined &&
+            connection.prepare("SELECT key FROM timing_meta WHERE key='legacy-imported'").get() !==
+                undefined;
         // Filesystem reads and JSON parsing must not consume another writer's admission budget.
         const legacy = imported ? [] : legacySamples(agentDir).reverse();
         // Allow brief native writer overlap; three attempts still bound best-effort admission.
@@ -78,28 +126,46 @@ export function recordRun(agent, task, exitCode, durationMs) {
             const save = (sample) => insert.run(sample.agent, sample.task, sample.ts, sample.status, sample.duration, sample.exit ?? null);
             if (!connection.prepare("SELECT key FROM timing_meta WHERE key='legacy-imported'").get()) {
                 // Another writer may have imported while this snapshot was being read.
-                for (const sample of legacy)
+                for (const sample of legacy) {
                     save(sample);
+                }
                 connection.exec("INSERT INTO timing_meta VALUES ('legacy-imported')");
             }
             save(entry);
-            connection.prepare("DELETE FROM samples WHERE agent=? AND sequence NOT IN (SELECT sequence FROM samples WHERE agent=? ORDER BY sequence DESC LIMIT ?)").run(agent, agent, MAX_AGENT_SAMPLES);
+            connection
+                .prepare("DELETE FROM samples WHERE agent=? AND sequence NOT IN (SELECT sequence FROM samples WHERE agent=? ORDER BY sequence DESC LIMIT ?)")
+                .run(agent, agent, MAX_AGENT_SAMPLES);
         });
     }
-    catch { /* Best-effort timing metadata must never interrupt a run. */ }
+    catch {
+        /* Best-effort timing metadata must never interrupt a run. */
+    }
     finally {
         db?.close();
     }
 }
 export function loadRunsForAgent(agent) {
     const agentDir = getAgentDir(), file = path.join(agentDir, "history-index", TIMING_DATABASE);
-    if (!fs.existsSync(file))
+    if (!fs.existsSync(file)) {
         return legacySamples(agentDir, agent);
+    }
     let db;
     try {
         db = openHistoryDatabase(path.join(historyDirectory(agentDir, false), TIMING_DATABASE), true);
-        return db.prepare("SELECT agent,task,ts,status,duration,exit FROM samples WHERE agent=? ORDER BY sequence DESC LIMIT ?").all(agent, MAX_AGENT_SAMPLES)
-            .map((row) => ({ agent: String(row.agent), task: String(row.task), ts: Number(row.ts), status: row.status, duration: Number(row.duration), ...(row.exit === null ? {} : { exit: Number(row.exit) }) }));
+        return db
+            .prepare("SELECT agent,task,ts,status,duration,exit FROM samples WHERE agent=? ORDER BY sequence DESC LIMIT ?")
+            .all(agent, MAX_AGENT_SAMPLES)
+            .flatMap((row) => {
+            const entry = {
+                agent: row.agent,
+                task: row.task,
+                ts: row.ts,
+                status: row.status,
+                duration: row.duration,
+                ...(row.exit === null ? {} : { exit: row.exit }),
+            };
+            return validEntry(entry) ? [entry] : [];
+        });
     }
     catch {
         return [];

package/dist/runs/shared/run-metadata-paths.js

@@ -0,0 +1,14 @@
+import * as path from "node:path";
+import { getAgentDir } from "../../shared/agent-dir.js";
+import { 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");
+export 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));
+}

package/dist/runs/shared/run-metadata.js

@@ -0,0 +1,158 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { parseAsyncResult, parseSupervisorRunContract } from "../background/run-schemas.js";
+import { hasErrorCode, isRecord } from "../../shared/unknown.js";
+import { writeAtomicJson } from "../../shared/atomic-json.js";
+import { NativeJournal, ownerProjection, readJsonProjection } from "../../shared/journal-reader.js";
+import { runSynchronously } from "../../shared/cooperative.js";
+import { getRunMetadataDir, safeId, QUESTIONS_DIR, LEGACY_QUESTIONS_DIR, } from "./run-metadata-paths.js";
+export { getRunMetadataDir, safeId, QUESTIONS_DIR, LEGACY_QUESTIONS_DIR, } from "./run-metadata-paths.js";
+import { compactOwnerResult } from "./owner-output.js";
+export { compactOwnerResult } from "./owner-output.js";
+function conflictingCompletion(previous, incoming) {
+    return (previous !== undefined &&
+        previous !== "" &&
+        incoming !== undefined &&
+        incoming !== "" &&
+        previous !== incoming);
+}
+export function saveAsyncRunResult(runId, result) {
+    const file = path.join(getRunMetadataDir(runId), "result.json");
+    const previous = readRunJson(file, parseAsyncResult);
+    if (conflictingCompletion(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 (!hasErrorCode(error, "EEXIST")) {
+            throw error;
+        }
+    }
+    return true;
+}
+export function saveRunStatus(runId, status) {
+    writeAtomicJson(path.join(getRunMetadataDir(runId), "status.json"), status);
+}
+export function readRunJson(file, project) {
+    try {
+        const value = readJsonProjection(file, ownerProjection);
+        return project === undefined ? value : project(value);
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT")) {
+            return;
+        }
+        throw error;
+    }
+}
+export function readQuestionOwner(runId, root = QUESTIONS_DIR) {
+    const value = readRunJson(path.join(getRunMetadataDir(runId, root), "question-owner.json"));
+    return isRecord(value) && typeof value.sessionId === "string"
+        ? { sessionId: value.sessionId }
+        : undefined;
+}
+export function saveQuestionOwner(runId, sessionId, root = QUESTIONS_DIR) {
+    writeAtomicJson(path.join(root, safeId(runId), "question-owner.json"), { sessionId });
+}
+function preservedAttemptBaseline(previous, incoming) {
+    return previous?.attemptBaseline && incoming.baselineSource !== "native-migration"
+        ? { attemptBaseline: previous.attemptBaseline }
+        : {};
+}
+export function saveQuestionContract(runId, index, contract, root = QUESTIONS_DIR) {
+    if (!Number.isSafeInteger(index) || 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, parseSupervisorRunContract);
+    writeAtomicJson(file, {
+        ...previous,
+        ...contract,
+        recordVersion: 3,
+        ...(preserveLegacyOwner(file, previous) ? { legacySource: `${file}.legacy` } : {}),
+        ...preservedAttemptBaseline(previous, contract),
+        ...(contract.result ? { result: compactOwnerResult(runId, index, contract.result, root) } : {}),
+        ...(previous?.launch ? { launch: previous.launch } : {}),
+    });
+}
+function nativeConfigurationAllowed(contract) {
+    return (contract.recordVersion !== 3 &&
+        !contract.effectiveConfiguration &&
+        contract.launch?.model?.startsWith("claude-code/") !== true);
+}
+function recoverNativeConfiguration(contract, sessionFile, endedAt) {
+    if (!nativeConfigurationAllowed(contract)) {
+        return;
+    }
+    if (sessionFile === undefined || sessionFile === "" || !fs.existsSync(sessionFile)) {
+        return;
+    }
+    const journal = new NativeJournal(sessionFile, "inspect", true);
+    return { effectiveConfiguration: journal.configuration(endedAt, contract.terminalLeafId) };
+}
+function withNativeConfiguration(contract, launch, effectiveConfiguration) {
+    const native = effectiveConfiguration ?? {};
+    return { ...contract, effectiveConfiguration, launch: { ...launch, ...native } };
+}
+export function readQuestionContract(runId, index, root = QUESTIONS_DIR, projection = {}) {
+    const contract = readRunJson(path.join(root, safeId(runId), "contracts", `${index}.json`), parseSupervisorRunContract);
+    if (!contract?.launch || projection.readConfiguration === false) {
+        return contract;
+    }
+    const sessionFile = projection.sessionFile ?? contract.sessionFile;
+    // Read native selection once, without rewriting the frozen requested launch.
+    const recovery = recoverNativeConfiguration(contract, sessionFile, projection.endedAt);
+    if (recovery) {
+        saveQuestionContract(runId, index, recovery, root);
+    }
+    const effectiveConfiguration = recovery?.effectiveConfiguration ?? contract.effectiveConfiguration;
+    return withNativeConfiguration(contract, contract.launch, effectiveConfiguration);
+}
+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 = readQuestionOwner(id, LEGACY_QUESTIONS_DIR);
+            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}:`, error);
+        }
+    }
+}