@fitchmultz/pi-subagents 0.44.7 → 0.46.0

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

@@ -1,72 +1,98 @@
 import { SubagentHistoryIndex } from "../../history/index.js";
-import { getAgentDir } from "../../shared/utils.js";
+import { getAgentDir } from "../../shared/agent-dir.js";
+function reportCloseFailure(error) {
+    console.error("Could not close subagent history:", error);
+}
+async function closeOwners(previous, index) {
+    await Promise.all([previous, index?.close()]);
+}
 export function closeRunHistory(state) {
     const index = state.historyIndex;
     state.historyIndex = undefined;
     state.historyReady = undefined;
-    state.historyClosing = Promise.all([state.historyClosing, index?.close()]).then(() => { });
-    return state.historyClosing;
+    const closing = closeOwners(state.historyClosing, index);
+    state.historyClosing = closing;
+    return closing;
+}
+function observeReadiness(state, index) {
+    // Keep the original rejected readiness promise for callers and explicit retry.
+    // This observer owns disposal, not a replacement readiness result.
+    state.historyReady?.catch(() => {
+        if (state.historyIndex === index) {
+            index.close().catch(reportCloseFailure);
+        }
+    });
 }
 function admitOwner(state, ownerSessionId, ownerSessionFile) {
-    const index = state.historyIndex = new SubagentHistoryIndex(getAgentDir());
-    const snapshot = { ownerSessionId, ownerSessionFile,
-        runs: [...(state.ownedRuns?.values() ?? [])], foregroundRuns: [...(state.foregroundRuns?.values() ?? [])] };
+    const index = new SubagentHistoryIndex(getAgentDir());
+    state.historyIndex = index;
+    const snapshot = {
+        ownerSessionId,
+        ownerSessionFile,
+        runs: [...(state.ownedRuns?.values() ?? [])],
+        foregroundRuns: [...(state.foregroundRuns?.values() ?? [])],
+    };
     state.historyReady = (state.historyClosing ?? Promise.resolve()).then(() => index.setOwner(snapshot));
-    index.onChanged(() => { if (state.historyIndex === index)
-        state.onRunsChanged?.(); });
-    // Retain failed readiness until an explicit retry; background updates must not start a crash loop.
-    void state.historyReady.catch(() => {
-        if (state.historyIndex === index)
-            void index.close();
+    index.onChanged(() => {
+        if (state.historyIndex === index) {
+            state.onRunsChanged?.();
+        }
     });
+    observeReadiness(state, index);
     return index;
 }
 export function startRunHistory(state, ctx) {
-    void closeRunHistory(state).catch((error) => console.error("Could not close subagent history:", error));
-    // Fresh sessions pay no process/database startup cost until they actually browse or own work.
-    if (state.ownedRuns?.size)
+    closeRunHistory(state).catch(reportCloseFailure);
+    // Fresh sessions pay no process/database startup cost until they browse or own work.
+    if ((state.ownedRuns?.size ?? 0) > 0) {
         admitOwner(state, ctx.sessionManager.getSessionId(), ctx.sessionManager.getSessionFile());
+    }
 }
 export function updateRunHistory(state, run) {
     const index = state.historyIndex;
-    if (!index)
+    if (!index) {
         return;
+    }
     state.historyReady = (state.historyReady ?? Promise.resolve()).then(() => index.updateRun(run, state.foregroundRuns?.get(run.runId)));
-    void state.historyReady.catch(() => {
-        if (state.historyIndex === index)
-            void index.close();
-    });
+    observeReadiness(state, index);
 }
 function historyOwner(state) {
     const current = state.lastUiContext?.sessionManager.getSessionId();
-    if (current)
+    if (current !== undefined && current !== "") {
         return current;
-    // Non-UI callers can hold restored owner handles without an ExtensionContext.
-    // Never infer ownership from a directory or adopt records found by the index.
+    }
+    // Non-UI callers hold restored handles; a directory/index record cannot grant ownership.
     const owners = new Set([...(state.ownedRuns?.values() ?? [])].map((run) => run.ownerSessionId));
-    if (owners.size > 1)
+    if (owners.size > 1) {
         throw new Error("History requires one verified owning session.");
+    }
     const owner = owners.values().next().value ?? state.currentSessionId;
-    if (!owner)
+    if (owner === null || owner === "") {
         throw new Error("History requires an active owning session.");
+    }
     return owner;
 }
+async function retryFailedOwner(state, ownerSessionId) {
+    const closing = closeRunHistory(state);
+    await closing;
+    if (state.historyClosing !== closing || historyOwner(state) !== ownerSessionId) {
+        throw new Error("Owning session changed while history was loading.");
+    }
+}
 export async function runHistoryIndex(state, retry = false) {
     const ownerSessionId = historyOwner(state);
-    if (retry && state.historyIndex?.failure) {
-        const closing = closeRunHistory(state);
-        await closing;
-        if (state.historyClosing !== closing || historyOwner(state) !== ownerSessionId)
-            throw new Error("Owning session changed while history was loading.");
+    if (retry && state.historyIndex?.failure !== undefined) {
+        await retryFailedOwner(state, ownerSessionId);
     }
-    if (!state.historyIndex) {
+    const index = state.historyIndex ??
         admitOwner(state, ownerSessionId, state.lastUiContext?.sessionManager.getSessionFile());
-    }
-    const index = state.historyIndex;
     await state.historyReady;
-    if (state.historyIndex !== index || historyOwner(state) !== ownerSessionId)
+    if (state.historyIndex !== index || historyOwner(state) !== ownerSessionId) {
         throw new Error("Owning session changed while history was loading.");
-    if (index.failure)
-        throw index.failure;
+    }
+    const failure = index.failure;
+    if (failure instanceof Error) {
+        throw failure;
+    }
     return index;
 }

package/dist/runs/shared/legacy-async-recovery.js

@@ -0,0 +1,114 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readAsyncResultFile } from "../background/async-result-file.js";
+import { getRunMetadataDir, saveAsyncRunResult } from "./supervisor-questions.js";
+import { RESULTS_DIR, } from "../../shared/types.js";
+import { savedWorkflowNodes, workflowChildren } from "./workflow-graph.js";
+import { recoverLegacyTerminalOutput } from "./legacy-output-recovery.js";
+function childSession(step, status) {
+    return step.sessionFile ?? (status.steps?.length === 1 ? status.sessionFile : undefined);
+}
+function recoveredChild(step, status) {
+    const sessionFile = childSession(step, status);
+    return {
+        agent: step.agent,
+        sessionFile,
+        model: step.model,
+        acceptance: step.acceptance,
+        exitCode: step.exitCode,
+        agentProcessExit: step.agentProcessExit,
+        success: step.status === "complete" || step.status === "completed",
+        interrupted: step.status === "paused" || undefined,
+        timedOut: step.status === "timed-out" || undefined,
+        error: step.error,
+        output: recoverLegacyTerminalOutput(sessionFile, step.startedAt ?? status.startedAt, step.endedAt ?? status.endedAt, step.acceptance) ?? "",
+    };
+}
+function needsResultRepair(record) {
+    return (record.status !== null &&
+        !record.durable &&
+        !["running", "queued"].includes(record.status.state) &&
+        !fs.existsSync(path.join(getRunMetadataDir(record.status.runId), "result.json")));
+}
+/** Metadata recovery never runs the child or treats live logs as a final answer. */
+export function repairLegacyAsyncResult(record) {
+    const { location, status } = record;
+    if (!status || !needsResultRepair(record)) {
+        return;
+    }
+    const resultPath = path.join(RESULTS_DIR, `${status.runId}.json`);
+    if (fs.existsSync(resultPath)) {
+        saveAsyncRunResult(status.runId, readAsyncResultFile(resultPath));
+        return;
+    }
+    const steps = status.steps ?? [];
+    if (steps.length === 0 || steps.some((step) => ["running", "pending"].includes(step.status))) {
+        return;
+    }
+    saveAsyncRunResult(status.runId, {
+        id: status.runId,
+        sessionId: status.sessionId,
+        mode: status.mode,
+        state: status.state,
+        success: status.state === "complete",
+        error: status.error,
+        timestamp: status.endedAt ?? status.lastUpdate ?? status.startedAt,
+        cwd: status.cwd,
+        asyncDir: location.asyncDir ?? undefined,
+        sessionFile: status.sessionFile,
+        results: steps.map((step) => recoveredChild(step, status)),
+    });
+}
+function declaredWorkflowChildren(status, old, nodes) {
+    return status.mode === "chain" &&
+        nodes &&
+        old?.children.some((child) => (child.workflowNodeId ?? "") !== "") !== true
+        ? []
+        : (old?.children ?? []);
+}
+function projectedChildren(status, old) {
+    const nodes = savedWorkflowNodes(status);
+    const declared = declaredWorkflowChildren(status, old, nodes);
+    const children = workflowChildren(declared, nodes ? status.workflowGraph : undefined);
+    const projected = [];
+    for (const [index, step] of (status.steps ?? []).entries()) {
+        const previous = children.find((child) => child.index === index);
+        const node = status.mode === "chain" ? nodes?.[index] : undefined;
+        projected.push({
+            ...previous,
+            agent: step.agent,
+            index,
+            ...(node ? { workflowNodeId: node.id } : {}),
+            label: step.label ?? children[index]?.label,
+            sessionFile: childSession(step, status),
+        });
+    }
+    return projected;
+}
+function asyncLineage(old, status, durable) {
+    return {
+        rootRunId: old?.rootRunId ?? status.runId,
+        task: old?.task ?? "Recovered background run",
+        legacy: old?.legacy ?? !durable,
+    };
+}
+export function recoveredAsyncRun(record, old, owner) {
+    const { location, status, durable } = record;
+    const asyncDir = location.asyncDir;
+    if (!status || asyncDir === null || asyncDir === "") {
+        return undefined;
+    }
+    return {
+        ...old,
+        runId: status.runId,
+        ownerSessionId: owner.ownerSessionId,
+        ...asyncLineage(old, status, durable),
+        source: "async",
+        mode: status.mode,
+        cwd: status.cwd ?? old?.cwd ?? owner.cwd,
+        startedAt: status.startedAt,
+        asyncDir,
+        pid: status.pid,
+        children: projectedChildren(status, old),
+    };
+}

package/dist/runs/shared/legacy-output-recovery.js

@@ -0,0 +1,148 @@
+import * as fs from "node:fs";
+import { NativeJournal, readOutputPage } from "../../shared/journal-reader.js";
+import { isRecord, isUnknownArray, recordAt } from "../../shared/unknown.js";
+import { resolveFinalizationOutput } from "./acceptance-finalization.js";
+import { parseAcceptanceReport, validateAcceptanceReportShape } from "./acceptance-reports.js";
+function assistantContent(message) {
+    if (!message ||
+        message.role !== "assistant" ||
+        !isUnknownArray(message.content) ||
+        (typeof message.errorMessage === "string" && message.errorMessage !== "") ||
+        message.stopReason === "error") {
+        return undefined;
+    }
+    return message.content;
+}
+function assistantText(message) {
+    const content = assistantContent(message);
+    for (const part of content?.toReversed() ?? []) {
+        if (isRecord(part) &&
+            part.type === "text" &&
+            typeof part.text === "string" &&
+            part.text.trim() !== "") {
+            return part.text;
+        }
+    }
+    return undefined;
+}
+function existingFile(file) {
+    return file !== undefined && file !== "" && fs.existsSync(file);
+}
+/** Legacy foreground receipts can refer to a final output artifact or native assistant answer. */
+export function recoverOutput(sessionFile, outputFile, endedAt) {
+    if (outputFile !== undefined && existingFile(outputFile)) {
+        return readOutputPage(outputFile).text;
+    }
+    if (sessionFile === undefined || !existingFile(sessionFile)) {
+        return undefined;
+    }
+    const journal = new NativeJournal(sessionFile);
+    for (const record of journal.branch(undefined, endedAt).reverse()) {
+        if (record.value.type !== "message" ||
+            recordAt(record.value, "message")?.role !== "assistant") {
+            continue;
+        }
+        const output = assistantText(recordAt(journal.body(record), "message"));
+        if (output !== undefined) {
+            return output;
+        }
+    }
+    return undefined;
+}
+function structuredCall(part) {
+    if (!isRecord(part) ||
+        part.name !== "structured_output" ||
+        typeof part.id !== "string" ||
+        !isRecord(part.arguments)) {
+        return undefined;
+    }
+    return { id: part.id, arguments: part.arguments };
+}
+function successfulStructuredResult(records, call) {
+    if (records.some((record) => recordAt(record.value, "message")?.role !== "toolResult")) {
+        return false;
+    }
+    const last = records.at(-1);
+    const result = last ? recordAt(last.value, "message") : undefined;
+    return (result !== undefined &&
+        result.toolCallId === call.id &&
+        result.toolName === "structured_output" &&
+        result.isError === false);
+}
+function resolvedAnswer(raw) {
+    const answer = resolveFinalizationOutput(raw, "");
+    return answer !== "" ? answer : undefined;
+}
+function structuredAnswer(call) {
+    const value = call.arguments.value;
+    if (!isRecord(value) || !("report" in value)) {
+        return undefined;
+    }
+    if (typeof value.report === "string" &&
+        parseAcceptanceReport(value.report).report !== undefined) {
+        return resolvedAnswer(value.report);
+    }
+    if (typeof value.answer === "string" &&
+        value.answer.trim() !== "" &&
+        validateAcceptanceReportShape(value.report) === undefined) {
+        return value.answer;
+    }
+    return undefined;
+}
+function terminalContent(message) {
+    if (!message ||
+        (message.errorMessage !== undefined && message.errorMessage !== "") ||
+        (message.stopReason !== "stop" && message.stopReason !== "toolUse")) {
+        return undefined;
+    }
+    return assistantContent(message);
+}
+function terminalText(message, index, total) {
+    const output = assistantText(message);
+    return index === total - 1 && message?.stopReason === "stop" && output !== undefined
+        ? resolvedAnswer(output)
+        : undefined;
+}
+function terminalAnswer(journal, records) {
+    const index = records.findLastIndex((record) => recordAt(record.value, "message")?.role === "assistant");
+    if (index < 0) {
+        return undefined;
+    }
+    const message = recordAt(journal.body(records[index]), "message");
+    const content = terminalContent(message);
+    if (!content) {
+        return undefined;
+    }
+    const calls = content.filter((part) => isRecord(part) && part.type === "toolCall");
+    if (calls.length === 0) {
+        return terminalText(message, index, records.length);
+    }
+    const call = calls.length === 1 ? structuredCall(calls[0]) : undefined;
+    return call && successfulStructuredResult(records.slice(index + 1), call)
+        ? structuredAnswer(call)
+        : undefined;
+}
+function reviewedAnswer(acceptance) {
+    const review = acceptance?.finalization;
+    const output = review?.status === "completed" ? review.turns.at(-1)?.rawOutput : undefined;
+    return output !== undefined && output.trim() !== "" ? resolvedAnswer(output) : undefined;
+}
+/** Only bounded, terminal native evidence can become a recovered background final answer. */
+export function recoverLegacyTerminalOutput(sessionFile, startedAt, endedAt, acceptance) {
+    const reviewed = reviewedAnswer(acceptance);
+    if (reviewed !== undefined) {
+        return reviewed;
+    }
+    // Mutable live/finalization streams are not final-answer receipts.
+    if (endedAt === undefined ||
+        !Number.isFinite(endedAt) ||
+        sessionFile === undefined ||
+        !existingFile(sessionFile)) {
+        return undefined;
+    }
+    const journal = new NativeJournal(sessionFile);
+    const records = journal
+        .branch(undefined, endedAt)
+        .filter(({ value }) => value.type === "message" && Date.parse(value.timestamp ?? "") >= startedAt);
+    return terminalAnswer(journal, records);
+}

package/dist/runs/shared/mcp-config-schema.js

@@ -0,0 +1,36 @@
+import { Type, Check } from "../../shared/native-typebox.js";
+const TextList = Type.Array(Type.String());
+const TextRecord = Type.Record(Type.String(), Type.String());
+export const ToolPrefixSchema = Type.Union([
+    Type.Literal("server"),
+    Type.Literal("none"),
+    Type.Literal("short"),
+]);
+export const ServerSchema = Type.Object({
+    command: Type.Optional(Type.String()),
+    args: Type.Optional(TextList),
+    socket: Type.Optional(Type.String()),
+    env: Type.Optional(TextRecord),
+    cwd: Type.Optional(Type.String()),
+    url: Type.Optional(Type.String()),
+    headers: Type.Optional(TextRecord),
+    auth: Type.Optional(Type.Union([Type.Literal("oauth"), Type.Literal("bearer"), Type.Literal(false)])),
+    bearerToken: Type.Optional(Type.String()),
+    bearerTokenEnv: Type.Optional(Type.String()),
+    exposeResources: Type.Optional(Type.Boolean()),
+    excludeTools: Type.Optional(TextList),
+    includeTools: Type.Optional(TextList),
+    toolPrefix: Type.Optional(ToolPrefixSchema),
+    disabled: Type.Optional(Type.Boolean()),
+});
+export const ServersSchema = Type.Record(Type.String(), ServerSchema);
+export const CacheSchema = Type.Object({
+    version: Type.Literal(1),
+    servers: Type.Record(Type.String(), Type.Object({
+        configHash: Type.Optional(Type.String()),
+        tools: Type.Optional(Type.Array(Type.Object({ name: Type.Optional(Type.String()) }))),
+        resources: Type.Optional(Type.Array(Type.Object({ uri: Type.Optional(Type.String()), name: Type.Optional(Type.String()) }))),
+        cachedAt: Type.Optional(Type.Number()),
+    })),
+});
+export { Check };