@fitchmultz/pi-subagents 0.44.6 → 0.45.0

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

@@ -0,0 +1,338 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { NativeJournal } from "../../shared/journal-reader.js";
+import { snapshotNativeUsage } from "./native-usage.js";
+import { resolveCurrentSessionId } from "../../shared/session-identity.js";
+import { runCooperatively, runSynchronously } from "../../shared/cooperative.js";
+import { errorMessage, isRecord, recordAt } from "../../shared/unknown.js";
+import { createAsyncRunDiscovery } from "../background/async-status.js";
+import { parseDetails, parseForegroundResumeRun, parseOwnedRun, parseSubagentExecutionResult, } from "../background/run-schemas.js";
+import { collectInvocationAgentNames } from "../../shared/settings.js";
+import { normalizeSubagentParamsLike, } from "../foreground/subagent-params.js";
+import { getRunMetadataDir, migrateSupervisorQuestionSteps, readRunJson, saveQuestionOwner, saveRunStatus, } from "./supervisor-questions.js";
+import { ASYNC_DIR, SLASH_RESULT_TYPE, } from "../../shared/types.js";
+import { OWNED_RUN_ENTRY, rememberOwnedRun, saveForegroundRun } from "./run-persistence.js";
+import { resetOwnedRuns, setOwnedRun, setForegroundRun, suspendRunChanges, } from "./run-state-owner.js";
+import { recoverOutput } from "./legacy-output-recovery.js";
+import { recoveredAsyncRun, repairLegacyAsyncResult } from "./legacy-async-recovery.js";
+function receiptDetails(entry) {
+    try {
+        if (entry.type === "message" &&
+            entry.message.role === "toolResult" &&
+            ["subagent", "delegate", "agent_runs"].includes(entry.message.toolName)) {
+            return parseDetails(entry.message.details);
+        }
+        if (entry.type === "custom_message" && entry.customType === SLASH_RESULT_TYPE) {
+            const result = recordAt(entry.details, "result");
+            return result ? parseSubagentExecutionResult(result).details : undefined;
+        }
+    }
+    catch {
+        // Invalid legacy payloads do not grant ownership or establish completion.
+    }
+    return undefined;
+}
+function sessionFiles(root) {
+    if (!fs.existsSync(root)) {
+        return [];
+    }
+    return fs.readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+        const file = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            return sessionFiles(file);
+        }
+        return entry.name.endsWith(".jsonl") ? [file] : [];
+    });
+}
+function* restoreDeclaredRuns(state, ctx, entries) {
+    const owner = ctx.sessionManager.getSessionId();
+    for (const entry of entries) {
+        yield;
+        if (entry.type !== "custom" || entry.customType !== OWNED_RUN_ENTRY) {
+            continue;
+        }
+        const stored = ctx.sessionManager.getEntry(entry.id);
+        if (stored?.type !== "custom") {
+            continue;
+        }
+        try {
+            const run = parseOwnedRun(stored.data);
+            if (run.ownerSessionId === owner && run.runId !== "") {
+                setOwnedRun(state, run);
+            }
+        }
+        catch {
+            // Unvalidated copied or damaged metadata is not an ownership handle.
+        }
+    }
+}
+function legacyReceipt(entry) {
+    const details = receiptDetails(entry);
+    const runId = details?.runId ?? details?.asyncId;
+    if (details && details.mode !== "management" && runId !== undefined && runId !== "") {
+        return { entry, details, runId, mode: details.mode };
+    }
+    return undefined;
+}
+function* recoveredReceipts(ctx, entries) {
+    const receipts = [];
+    for (const entry of entries) {
+        yield;
+        const tool = entry.type === "message" &&
+            entry.message.role === "toolResult" &&
+            ["subagent", "delegate", "agent_runs"].includes(entry.message.toolName);
+        const slash = entry.type === "custom_message" && entry.customType === SLASH_RESULT_TYPE;
+        if (!tool && !slash) {
+            continue;
+        }
+        const receipt = ctx.sessionManager.getEntry(entry.id);
+        if (!receipt) {
+            continue;
+        }
+        const validated = legacyReceipt(receipt);
+        if (validated) {
+            receipts.push(validated);
+        }
+    }
+    return receipts;
+}
+function invocationCalls(entry) {
+    if (entry.type !== "message" || entry.message.role !== "assistant") {
+        return [];
+    }
+    return entry.message.content.flatMap((part) => {
+        if (part.type !== "toolCall" ||
+            !["subagent", "delegate"].includes(part.name) ||
+            !isRecord(part.arguments)) {
+            return [];
+        }
+        return [[part.id, normalizeSubagentParamsLike(part.arguments)]];
+    });
+}
+function* legacyCalls(ctx, entries) {
+    const calls = new Map();
+    for (const metadata of entries) {
+        yield;
+        if (metadata.type !== "message" || metadata.message.role !== "assistant") {
+            continue;
+        }
+        const entry = ctx.sessionManager.getEntry(metadata.id);
+        for (const [id, invocation] of entry ? invocationCalls(entry) : []) {
+            calls.set(id, invocation);
+        }
+    }
+    return calls;
+}
+function inheritedReceipts(ctx) {
+    const parent = ctx.sessionManager.getHeader()?.parentSession;
+    if (parent === undefined || parent === "") {
+        return new Set();
+    }
+    // A missing fork source cannot prove which copied receipts are genuinely new.
+    return fs.existsSync(parent) ? new Set(snapshotNativeUsage(parent)) : undefined;
+}
+function legacyChildren(details, request) {
+    return details.results.length > 0
+        ? details.results.map((result, index) => ({
+            agent: result.agent,
+            index,
+            task: result.task,
+            sessionFile: result.sessionFile,
+        }))
+        : collectInvocationAgentNames(request ?? {}).map((agent, index) => ({ agent, index }));
+}
+function legacyLineage(details, runId) {
+    return {
+        rootRunId: details.managementControl?.revivedFromRunId ?? runId,
+        predecessorRunId: details.managementControl?.revivedFromRunId,
+        source: (details.asyncId ?? "") !== "" ? "async" : "foreground",
+    };
+}
+function invocationCwd(ctx, request) {
+    const cwd = request?.cwd;
+    return cwd !== undefined && cwd !== "" ? path.resolve(ctx.cwd, cwd) : ctx.cwd;
+}
+function legacyRun(ctx, receipt, calls) {
+    const { entry, details, runId, mode } = receipt;
+    const request = entry.type === "message" && entry.message.role === "toolResult"
+        ? calls.get(entry.message.toolCallId)
+        : undefined;
+    return {
+        runId,
+        ownerSessionId: ctx.sessionManager.getSessionId(),
+        ...legacyLineage(details, runId),
+        mode,
+        cwd: invocationCwd(ctx, request),
+        task: details.results.at(0)?.task ?? request?.task ?? "Recovered delegated run",
+        startedAt: Date.parse(entry.timestamp),
+        asyncDir: details.asyncDir,
+        legacy: true,
+        children: legacyChildren(details, request),
+    };
+}
+function nativeLaunchCwd(run, details) {
+    const file = details.results.find((result) => (result.sessionFile ?? "") !== "")?.sessionFile;
+    if (file === undefined || file === "" || !fs.existsSync(file)) {
+        return run;
+    }
+    const header = new NativeJournal(file).records.at(0)?.value;
+    return header?.type === "session" && typeof header.cwd === "string" && header.cwd !== ""
+        ? { ...run, cwd: header.cwd }
+        : run;
+}
+function repairQuestionOwner(run) {
+    let owner;
+    try {
+        owner = readRunJson(path.join(getRunMetadataDir(run.runId), "question-owner.json"));
+    }
+    catch {
+        // A genuine receipt can repair unusable supplemental metadata.
+    }
+    const sessionId = isRecord(owner) ? owner.sessionId : undefined;
+    if (typeof sessionId !== "string" || sessionId.trim() === "") {
+        saveQuestionOwner(run.runId, run.ownerSessionId);
+    }
+}
+function saveLegacyForeground(run, details) {
+    if (run.source !== "foreground") {
+        return;
+    }
+    const results = details.results.map((result) => {
+        const finalOutput = result.finalOutput ??
+            recoverOutput(result.sessionFile, result.artifactPaths?.outputPath, run.startedAt);
+        return { ...result, finalOutput };
+    });
+    saveForegroundRun({ ...run, results });
+}
+function* restoreLegacyReceipts(state, ctx, entries) {
+    const receipts = yield* recoveredReceipts(ctx, entries);
+    const needsCalls = receipts.some((receipt) => state.ownedRuns?.has(receipt.runId) !== true);
+    const calls = needsCalls ? yield* legacyCalls(ctx, entries) : new Map();
+    const inherited = inheritedReceipts(ctx);
+    for (const receipt of receipts) {
+        yield;
+        if (!inherited ||
+            inherited.has(receipt.entry.id) ||
+            state.ownedRuns?.has(receipt.runId) === true) {
+            continue;
+        }
+        recoverLegacyReceipt(state, ctx, receipt, calls);
+    }
+}
+function recoverLegacyReceipt(state, ctx, receipt, calls) {
+    const { details, runId } = receipt;
+    const run = legacyRun(ctx, receipt, calls);
+    let recovered = run;
+    try {
+        recovered = nativeLaunchCwd(run, details);
+        saveLegacyForeground(recovered, details);
+        repairQuestionOwner(recovered);
+        rememberOwnedRun(state, recovered);
+    }
+    catch (error) {
+        // Receipt ownership survives incomplete supplemental child recovery.
+        rememberOwnedRun(state, {
+            ...recovered,
+            recoveryError: `Saved child recovery remains incomplete: ${errorMessage(error)}`,
+        });
+        console.error(`Could not recover legacy receipt ${runId}: ${errorMessage(error)}`);
+    }
+}
+function repairLegacyAsyncStatus(record) {
+    const status = record.status;
+    if (!record.durable && status && !["running", "queued"].includes(status.state)) {
+        saveRunStatus(status.runId, status);
+    }
+}
+function* discoverOwnedAsync(state, ctx, scan) {
+    const records = yield* scan.steps();
+    const owner = { ownerSessionId: ctx.sessionManager.getSessionId(), cwd: ctx.cwd };
+    for (const record of records) {
+        yield;
+        try {
+            const old = record.status ? state.ownedRuns?.get(record.status.runId) : undefined;
+            const run = recoveredAsyncRun(record, old, owner);
+            if (run) {
+                // Legacy terminal status is durable before the owner publishes its recovered handle.
+                repairLegacyAsyncStatus(record);
+                rememberOwnedRun(state, run);
+                repairLegacyAsyncResult(record);
+            }
+        }
+        catch (error) {
+            console.error(`Could not recover owned async metadata for '${record.location.resolvedId ?? "unknown"}':`, error);
+        }
+    }
+    return records;
+}
+function recoveredForegroundSessions(run, ownerFile) {
+    if (run.children.some((child) => (child.sessionFile ?? "") !== "") ||
+        run.legacy !== true ||
+        ownerFile === undefined ||
+        ownerFile === "") {
+        return undefined;
+    }
+    const root = path.join(path.dirname(ownerFile), path.basename(ownerFile, ".jsonl"), run.runId);
+    const files = sessionFiles(root).sort();
+    return files.length > 0
+        ? {
+            ...run,
+            children: files.map((sessionFile, index) => ({
+                agent: run.children[index]?.agent ?? "unknown",
+                index,
+                sessionFile,
+            })),
+        }
+        : undefined;
+}
+function* restoreForegroundHandles(state, ctx) {
+    for (const run of state.ownedRuns?.values() ?? []) {
+        yield;
+        try {
+            const stored = readRunJson(path.join(getRunMetadataDir(run.runId), "foreground.json"), parseForegroundResumeRun);
+            if (stored) {
+                setForegroundRun(state, stored);
+            }
+            const recovered = recoveredForegroundSessions(run, ctx.sessionManager.getSessionFile());
+            if (recovered) {
+                rememberOwnedRun(state, recovered);
+            }
+        }
+        catch (error) {
+            console.error(`Could not recover foreground owner ${run.runId}: ${errorMessage(error)}`);
+        }
+    }
+}
+export function restoreOwnedRuns(state, ctx) {
+    return runSynchronously(restoreOwnedRunSteps(state, ctx));
+}
+export async function restoreOwnedRunsAsync(state, ctx) {
+    // Publish readiness only after restoration, before browse/UI work can consume it.
+    const releaseNotifications = suspendRunChanges(state);
+    try {
+        return await runCooperatively(restoreOwnedRunSteps(state, ctx));
+    }
+    finally {
+        releaseNotifications();
+    }
+}
+function* restoreOwnedRunSteps(state, ctx) {
+    const startedAt = Date.now();
+    const ownerSessionId = ctx.sessionManager.getSessionId();
+    const entries = ctx.sessionManager.getEntries();
+    resetOwnedRuns(state);
+    yield* migrateSupervisorQuestionSteps(ownerSessionId);
+    yield* restoreDeclaredRuns(state, ctx, entries);
+    yield* restoreLegacyReceipts(state, ctx, entries);
+    // The retained discovery owner admits old slash launches without inventing tool receipts.
+    const scan = createAsyncRunDiscovery(ASYNC_DIR, {
+        sessionId: ctx.sessionManager.getSessionFile() ?? resolveCurrentSessionId(ctx.sessionManager),
+        ownerSessionId,
+        receiptRunIds: () => state.ownedRuns?.keys() ?? [],
+        skipInvalid: true,
+    });
+    const discover = () => runSynchronously(discoverOwnedAsync(state, ctx, scan));
+    const records = yield* discoverOwnedAsync(state, ctx, scan);
+    yield* restoreForegroundHandles(state, ctx);
+    return { startedAt, records, discover };
+}

package/dist/runs/shared/run-state-owner.js

@@ -0,0 +1,26 @@
+/** Explicit state-management boundary: these operations alone publish owner maps. */
+export function resetOwnedRuns(state) {
+    state.ownedRuns = new Map();
+}
+export function setOwnedRun(state, run) {
+    const previous = state.ownedRuns?.get(run.runId);
+    (state.ownedRuns ??= new Map()).set(run.runId, {
+        ...run,
+        children: run.children.map((child) => ({ ...child })),
+    });
+    return previous;
+}
+export function setForegroundRun(state, run) {
+    (state.foregroundRuns ??= new Map()).set(run.runId, {
+        ...run,
+        children: run.children.map((child) => ({ ...child })),
+    });
+}
+/** Restoration owns notification suspension; the returned release restores the same hook. */
+export function suspendRunChanges(state) {
+    const onRunsChanged = state.onRunsChanged;
+    state.onRunsChanged = undefined;
+    return () => {
+        state.onRunsChanged = onRunsChanged;
+    };
+}

package/dist/runs/shared/session-cwd-preload.js

@@ -1,33 +1,42 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
 import { realpathSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { importSelectedNative } from "../../shared/native-import.js";
+import { isRecord as isObject } from "../../shared/unknown.js";
+import { nonempty } from "./child-presence.js";
+import { optionalString, requiredString } from "./child-message-validation.js";
 // Node loads this before Pi selects its session and creates cwd-bound services.
 // Use the SDK beside the actual CLI (bundled or unbundled), never our dev peer.
 const configuration = process.env.PI_SUBAGENT_SESSION_CWD;
-if (configuration) {
-    const { sessionFile, cwd, nodeOptions } = JSON.parse(configuration);
-    const sdkUrl = pathToFileURL(join(dirname(realpathSync(process.argv[1])), "index.js"));
-    const { SessionManager } = await import(__rewriteRelativeImportExtension(sdkUrl.href));
-    const open = SessionManager.open;
+if (nonempty(configuration)) {
+    const value = JSON.parse(configuration);
+    if (!isObject(value)) {
+        throw new Error("Invalid native session cwd override");
+    }
+    const sessionFile = requiredString(value.sessionFile, "sessionFile");
+    const cwd = requiredString(value.cwd, "cwd");
+    const nodeOptions = optionalString(value.nodeOptions, "nodeOptions");
+    const entry = process.argv.at(1);
+    if (entry === undefined) {
+        throw new Error("Native Pi CLI entry point is missing");
+    }
+    const sdkUrl = pathToFileURL(join(dirname(realpathSync(entry)), "index.js"));
+    const { SessionManager } = await importSelectedNative(import.meta.url, "@earendil-works/pi-coding-agent", sdkUrl.href, () => import("@earendil-works/pi-coding-agent"));
+    const open = SessionManager.open.bind(SessionManager);
     SessionManager.open = (file, sessionDir, cwdOverride) => {
-        if (resolve(file) !== sessionFile)
+        if (resolve(file) !== sessionFile) {
             return open(file, sessionDir, cwdOverride);
+        }
         SessionManager.open = open;
-        // Keep the preload through a native launcher, then clear it before tools or nested children start.
+        // Keep preload through a native launcher, then clear it before tools or nested children start.
         delete process.env.PI_SUBAGENT_SESSION_CWD;
-        if (nodeOptions === undefined)
+        if (nodeOptions === undefined) {
             delete process.env.NODE_OPTIONS;
-        else
+        }
+        else {
             process.env.NODE_OPTIONS = nodeOptions;
-        // Public Pi SDK override preserves the file, header, identity and history.
+        }
+        // Public SDK override preserves the file, header, identity and history.
         return open(file, sessionDir, cwd);
     };
 }