@marcoscale98/pi-extensible-workflows 5.14.1-fork.1

package/dist/src/trajectory.js

@@ -0,0 +1,594 @@
+import { createHash } from "node:crypto";
+import { open, readFile, readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, DefaultPackageManager, getAgentDir, SettingsManager, DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
+import { listRunIds, RunStore } from "./persistence.js";
+import { navigatorAttentionSortByState } from "./host-view.js";
+import { normalizeSubagentRunRequest } from "../subagents/src/contracts.js";
+import { statusValue, subagentErrorValue } from "../subagents/src/decode.js";
+import { isNodeError, jsonValue, object, resourcePatternHasMagic, selectResourcesByLayers } from "./utils.js";
+import { canonicalPath, sameFilesystemPath } from "./paths.js";
+export const TRAJECTORY_MAX_TRANSCRIPT_BYTES = 2 * 1024 * 1024;
+const TRAJECTORY_MAX_NON_TIMING_ENTRIES = 400;
+export { isTrajectoryAction, isTrajectoryTarget, trajectoryActionError } from "./trajectory-contracts.js";
+function sessionFile(reference) {
+    const locator = reference?.locator;
+    if (!object(locator) || typeof locator.sessionFile !== "string" || !locator.sessionFile)
+        return undefined;
+    return locator.sessionFile;
+}
+function transcriptToolCallId(value) {
+    if (!object(value))
+        return undefined;
+    if (typeof value.toolCallId === "string")
+        return value.toolCallId;
+    const message = object(value.message) ? value.message : undefined;
+    if (message && typeof message.toolCallId === "string")
+        return message.toolCallId;
+    if (!message || !Array.isArray(message.content))
+        return undefined;
+    for (const part of message.content)
+        if (object(part) && typeof part.id === "string")
+            return part.id;
+    return undefined;
+}
+function isTimingTranscriptEntry(value) { return object(value) && value.type === "custom" && value.customType === "pi-workflows:tool-timing"; }
+function timingToolCallId(value) {
+    if (!object(value) || !isTimingTranscriptEntry(value) || !object(value.data))
+        return undefined;
+    return typeof value.data.toolCallId === "string" ? value.data.toolCallId : undefined;
+}
+class OversizedTranscriptError extends Error {
+}
+async function readTranscript(path, throwOnError = false) {
+    let handle;
+    try {
+        const info = await stat(path);
+        if (!info.isFile())
+            return [];
+        const startOffset = Math.max(0, info.size - TRAJECTORY_MAX_TRANSCRIPT_BYTES);
+        const length = info.size - startOffset;
+        handle = await open(path, "r");
+        const buffer = Buffer.alloc(length);
+        let bytesRead = 0;
+        while (bytesRead < length) {
+            const result = await handle.read(buffer, bytesRead, length - bytesRead, startOffset + bytesRead);
+            if (result.bytesRead === 0)
+                break;
+            bytesRead += result.bytesRead;
+        }
+        let content = buffer.subarray(0, bytesRead).toString("utf8");
+        if (startOffset > 0) {
+            const boundary = Buffer.alloc(1);
+            const boundaryRead = await handle.read(boundary, 0, 1, startOffset - 1);
+            const startsAtRecordBoundary = boundaryRead.bytesRead === 1 && boundary[0] === 0x0a;
+            const firstLine = content.indexOf("\n");
+            if (firstLine < 0) {
+                if (!startsAtRecordBoundary && throwOnError)
+                    throw new OversizedTranscriptError("Transcript is too large");
+                if (!startsAtRecordBoundary)
+                    return [];
+            }
+            else if (firstLine === content.length - 1 && content.slice(0, firstLine).trim() && !startsAtRecordBoundary) {
+                if (throwOnError)
+                    throw new OversizedTranscriptError("Transcript is too large");
+                return [];
+            }
+            else
+                content = content.slice(firstLine + 1);
+        }
+        const entries = [];
+        for (const line of content.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const value = JSON.parse(line);
+                if (object(value))
+                    entries.push(value);
+            }
+            catch { /* A partially written JSONL line is ignored until the next poll. */ }
+        }
+        const retainedEntries = entries.filter((entry) => !isTimingTranscriptEntry(entry)).slice(-TRAJECTORY_MAX_NON_TIMING_ENTRIES);
+        const retainedIds = new Set(retainedEntries.map(transcriptToolCallId).filter((id) => id !== undefined));
+        const retainedTiming = entries.filter((entry) => { const id = timingToolCallId(entry); return id !== undefined && retainedIds.has(id); });
+        const retained = new Set([...retainedEntries, ...retainedTiming]);
+        return entries.filter((entry) => retained.has(entry));
+    }
+    catch (error) {
+        if (throwOnError)
+            throw error;
+        return [];
+    }
+    finally {
+        await handle?.close();
+    }
+}
+function transcriptPaths(run) {
+    const paths = new Map();
+    for (const agent of run.agents) {
+        const path = sessionFile(agent.attemptDetails?.at(-1)?.session);
+        if (path)
+            paths.set(agent.id, path);
+    }
+    return paths;
+}
+async function runTranscripts(run) {
+    const result = {};
+    for (const [agentId, path] of transcriptPaths(run))
+        result[agentId] = await readTranscript(path);
+    return result;
+}
+export function applySystemPrompts(run, prompts) {
+    if (!prompts.length)
+        return run;
+    const bySession = new Map();
+    for (const entry of prompts)
+        bySession.set(entry.sessionId, entry.prompt);
+    const agents = run.agents.map((agent) => {
+        if (agent.systemPrompt)
+            return agent;
+        const sessionId = agent.attemptDetails?.at(-1)?.session?.sessionId;
+        const prompt = typeof sessionId === "string" ? bySession.get(sessionId) : undefined;
+        if (prompt === undefined)
+            return agent;
+        return { ...agent, systemPrompt: prompt };
+    });
+    if (agents.every((agent, index) => agent === run.agents[index]))
+        return run;
+    return { ...run, agents };
+}
+function toolDefinitionsFor(tools, catalog) {
+    return tools.flatMap((name) => {
+        const description = catalog.get(name);
+        return description ? [{ name, description }] : [];
+    });
+}
+export function applyToolDescriptions(run, catalog) {
+    const agents = run.agents.map((agent) => {
+        if (agent.toolDefinitions?.length)
+            return agent;
+        const toolDefinitions = toolDefinitionsFor(agent.tools, catalog);
+        if (!toolDefinitions.length)
+            return agent;
+        return { ...agent, toolDefinitions };
+    });
+    if (agents.every((agent, index) => agent === run.agents[index]))
+        return run;
+    return { ...run, agents };
+}
+function piToolCatalog(cwd = process.cwd()) {
+    return new Map([
+        createReadToolDefinition(cwd),
+        createBashToolDefinition(cwd),
+        createGrepToolDefinition(cwd),
+        createFindToolDefinition(cwd),
+        createLsToolDefinition(cwd),
+        createEditToolDefinition(cwd),
+        createWriteToolDefinition(cwd),
+    ].map((tool) => [tool.name, tool.description]));
+}
+export function withPiToolDescriptions(run) {
+    return applyToolDescriptions(run, piToolCatalog());
+}
+export function withPiToolDescriptionsForTools(tools, cwd) {
+    return toolDefinitionsFor(tools, piToolCatalog(cwd));
+}
+function canonicalExtensionSelector(selector, base) {
+    const negated = selector.startsWith("!");
+    const body = negated ? selector.slice(1) : selector;
+    if (body === "*" || body === "**" || body.startsWith("**/"))
+        return selector;
+    const resolved = resolve(base, body);
+    if (resourcePatternHasMagic(body))
+        return `${negated ? "!" : ""}${resolved}`;
+    return `${negated ? "!" : ""}${canonicalPath(resolved)}`;
+}
+function skillNameFromPath(path) {
+    const file = basename(path);
+    return file.toLowerCase() === "skill.md" ? basename(dirname(path)) : file;
+}
+const discoveredResourcesByCwd = new Map();
+async function discoveredResources(cwd) {
+    const cached = discoveredResourcesByCwd.get(cwd);
+    if (cached)
+        return cached;
+    const pending = (async () => {
+        const agentDir = getAgentDir();
+        const settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: false });
+        const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
+        const resolved = await packageManager.resolve();
+        return {
+            extensions: [...new Set(resolved.extensions.filter((entry) => entry.enabled).map((entry) => canonicalPath(entry.path)))],
+            skills: [...new Set(resolved.skills.filter((entry) => entry.enabled).map((entry) => skillNameFromPath(entry.path)))],
+        };
+    })();
+    discoveredResourcesByCwd.set(cwd, pending);
+    // A cached rejection would keep the fallback empty for the rest of the process lifetime.
+    pending.catch(() => discoveredResourcesByCwd.delete(cwd));
+    return pending;
+}
+async function resolveResourceInspection(inspection, cwd, selectorCwd = cwd) {
+    if (!inspection || inspection.skills.length && inspection.extensions.length)
+        return inspection;
+    let discovered;
+    try {
+        discovered = await discoveredResources(cwd);
+    }
+    catch {
+        return inspection;
+    }
+    const sources = inspection.selectorSources ?? { global: inspection.selectors, project: {} };
+    const skills = inspection.skills.length ? inspection.skills : selectResourcesByLayers([sources.global.skills, sources.project.skills, sources.role?.skills, sources.call?.skills], discovered.skills);
+    const extensions = inspection.extensions.length ? inspection.extensions : selectResourcesByLayers([sources.global.extensions, sources.project.extensions, sources.role?.extensions, sources.call?.extensions].map((layer) => layer?.map((selector) => canonicalExtensionSelector(selector, selectorCwd))), discovered.extensions);
+    return skills === inspection.skills && extensions === inspection.extensions ? inspection : { ...inspection, skills, extensions };
+}
+export async function withResolvedAttemptResources(attempt, cwd) {
+    const resourceSelectors = await resolveResourceInspection(attempt.setup.resourceSelectors, cwd, attempt.setup.cwd || cwd);
+    if (resourceSelectors === attempt.setup.resourceSelectors)
+        return attempt;
+    return { ...attempt, setup: { ...attempt.setup, ...(resourceSelectors === undefined ? {} : { resourceSelectors }) } };
+}
+export async function withResolvedResources(run, cwd) {
+    const agents = await Promise.all(run.agents.map(async (agent) => {
+        const details = agent.attemptDetails;
+        const last = details?.at(-1);
+        if (!details || !last)
+            return agent;
+        const resourceSelectors = await resolveResourceInspection(last.setup.resourceSelectors, cwd, last.setup.cwd || cwd);
+        if (resourceSelectors === last.setup.resourceSelectors)
+            return agent;
+        return { ...agent, attemptDetails: [...details.slice(0, -1), { ...last, setup: { ...last.setup, ...(resourceSelectors === undefined ? {} : { resourceSelectors }) } }] };
+    }));
+    if (agents.every((agent, index) => agent === run.agents[index]))
+        return run;
+    return { ...run, agents };
+}
+function withoutAgentActivities(run) {
+    const agents = run.agents.map((agent) => {
+        if (agent.activity === undefined)
+            return agent;
+        const next = { ...agent };
+        delete next.activity;
+        return next;
+    });
+    return agents.every((agent, index) => agent === run.agents[index]) ? run : { ...run, agents };
+}
+async function loadTrajectoryRun(store, includeTranscripts = true) {
+    const value = await store.load();
+    const summary = await store.loadSummary().catch(() => undefined);
+    const prompts = await store.systemPrompts().catch(() => []);
+    const run = withoutAgentActivities(await withResolvedResources(withPiToolDescriptions(applySystemPrompts(value.run, prompts)), store.cwd));
+    return { run, snapshot: value.snapshot, awaiting: await store.awaitingCheckpoints(), ...(summary?.createdAt === undefined ? {} : { createdAt: summary.createdAt }), transcripts: includeTranscripts ? await runTranscripts(run) : {} };
+}
+export async function loadTrajectoryRuns(cwd, sessionId, home = homedir(), overlay) {
+    const loaded = [];
+    for (const runId of await listRunIds(cwd, sessionId, home, false)) {
+        try {
+            const value = await loadTrajectoryRun(new RunStore(cwd, sessionId, runId, home));
+            loaded.push(overlay ? { ...value, run: overlay(value.run) } : value);
+        }
+        catch { /* Ignore corrupt or concurrently removed runs. */ }
+    }
+    return loaded;
+}
+async function fileMtime(path) { return stat(path).then((value) => value.mtimeMs).catch(() => undefined); }
+/** Lists the session's runs, reloading one only when its state, journal, or a transcript (per `transcriptSignature`) changed. */
+function createCachedRunLoader(cwd, sessionId, home, load, transcriptSignature, overlay) {
+    const cache = new Map();
+    const changed = async (store, entry) => {
+        if (await fileMtime(join(store.directory, "state.json")) !== entry.stateMtimeMs)
+            return true;
+        if (await fileMtime(join(store.directory, "journal.json")) !== entry.journalMtimeMs)
+            return true;
+        for (const [agentId, path] of transcriptPaths(entry.value.run))
+            if (await transcriptSignature(path) !== entry.transcripts.get(agentId))
+                return true;
+        return false;
+    };
+    return async () => {
+        const ids = await listRunIds(cwd, sessionId, home, false);
+        const current = new Set(ids);
+        for (const runId of cache.keys())
+            if (!current.has(runId))
+                cache.delete(runId);
+        const loaded = [];
+        for (const runId of ids) {
+            const store = new RunStore(cwd, sessionId, runId, home);
+            try {
+                let entry = cache.get(runId);
+                if (!entry || await changed(store, entry)) {
+                    const value = await load(store);
+                    const transcripts = new Map();
+                    for (const [agentId, path] of transcriptPaths(value.run))
+                        transcripts.set(agentId, await transcriptSignature(path));
+                    entry = { value, stateMtimeMs: (await fileMtime(join(store.directory, "state.json"))) ?? 0, journalMtimeMs: (await fileMtime(join(store.directory, "journal.json"))) ?? 0, transcripts };
+                    cache.set(runId, entry);
+                }
+                loaded.push(overlay ? { ...entry.value, run: overlay(entry.value.run) } : entry.value);
+            }
+            catch {
+                cache.delete(runId); /* Ignore corrupt or concurrently removed runs. */
+            }
+        }
+        return loaded;
+    };
+}
+export function createTrajectoryRunLoader(cwd, sessionId, home = homedir(), overlay) {
+    return createCachedRunLoader(cwd, sessionId, home, (store) => loadTrajectoryRun(store), fileMtime, overlay);
+}
+function transcriptRevision(info) {
+    const digest = createHash("sha256").update(`${String(info.mtimeNs)}:${String(info.size)}`).digest();
+    return Math.max(1, digest.readUIntBE(0, 6));
+}
+async function transcriptMetadata(path) {
+    if (path === undefined)
+        return { revision: 0, status: "missing" };
+    try {
+        const info = await stat(path, { bigint: true });
+        const bytes = info.size > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(info.size);
+        if (!info.isFile())
+            return { revision: transcriptRevision(info), status: "failed" };
+        const revision = transcriptRevision(info);
+        if (info.size === 0n)
+            return { revision, status: "empty", bytes: 0, timing: [] };
+        try {
+            const entries = await readTranscript(path, true);
+            return { revision, status: "available", bytes, timing: entries.filter(isTimingTranscriptEntry) };
+        }
+        catch (error) {
+            if (error instanceof OversizedTranscriptError)
+                return { revision, status: "oversized", bytes, timing: [] };
+            throw error;
+        }
+    }
+    catch (error) {
+        if (isNodeError(error, "ENOENT"))
+            return { revision: 0, status: "missing" };
+        return { revision: 0, status: "failed" };
+    }
+}
+async function metadataForRun(value) {
+    const transcripts = {};
+    for (const [agentId, path] of transcriptPaths(value.run))
+        transcripts[agentId] = await transcriptMetadata(path);
+    return { ...value, transcripts };
+}
+async function fileSignature(path) {
+    try {
+        const info = await stat(path, { bigint: true });
+        return info.isFile() ? `${String(info.mtimeNs)}:${String(info.size)}` : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createTrajectoryRunMetadataLoader(cwd, sessionId, home = homedir(), overlay) {
+    return createCachedRunLoader(cwd, sessionId, home, async (store) => metadataForRun(await loadTrajectoryRun(store, false)), fileSignature, overlay);
+}
+export function createTrajectorySubagentMetadataLoader(cwd, sessionId, agentDir, overlay) {
+    const loader = createTrajectorySubagentLoader(cwd, sessionId, agentDir, undefined, false);
+    const cache = new Map();
+    return async () => {
+        const values = await loader();
+        const current = new Set(values.map((value) => value.id));
+        for (const id of cache.keys())
+            if (!current.has(id))
+                cache.delete(id);
+        return Promise.all(values.map(async (value) => {
+            const currentValue = overlay ? overlay(value) : value;
+            const path = sessionFile(currentValue.attempt?.session);
+            const signature = path === undefined ? undefined : await fileSignature(path);
+            let entry = cache.get(value.id);
+            if (!entry || entry.path !== path || entry.signature !== signature) {
+                entry = { path, signature, value: await transcriptMetadata(path) };
+                cache.set(value.id, entry);
+            }
+            return { ...currentValue, transcript: entry.value };
+        }));
+    };
+}
+function safeTrajectorySubagentId(id) { return id !== "." && id !== ".." && /^[A-Za-z0-9._-]+$/.test(id); }
+export function createTrajectoryTranscriptLoader(cwd, sessionId, home = homedir(), agentDir, resolveSubagentSession) {
+    return async (request) => {
+        let path;
+        try {
+            if (request.runId !== undefined && request.agentId !== undefined && request.subagentId === undefined) {
+                const value = await new RunStore(cwd, sessionId, request.runId, home).load();
+                path = sessionFile(value.run.agents.find((agent) => agent.id === request.agentId)?.attemptDetails?.at(-1)?.session);
+            }
+            else if (request.subagentId !== undefined && request.runId === undefined && request.agentId === undefined) {
+                if (!safeTrajectorySubagentId(request.subagentId))
+                    return { status: "missing", revision: 0, entries: [], error: "Transcript not found" };
+                const rawStatus = await readSubagentJson(join(agentDir, "subagents", request.subagentId, "status.json"));
+                const status = statusValue(rawStatus);
+                const statusRecord = object(rawStatus) ? rawStatus : undefined;
+                const statusCwd = statusRecord === undefined ? undefined : statusRecord.cwd;
+                if (!status || status.sessionId !== sessionId || typeof statusCwd === "string" && !sameFilesystemPath(statusCwd, cwd))
+                    return { status: "missing", revision: 0, entries: [], error: "Transcript not found" };
+                path = sessionFile(resolveSubagentSession?.(request.subagentId) ?? status.attemptDetails?.at(-1)?.session);
+            }
+        }
+        catch (error) {
+            return isNodeError(error, "ENOENT") ? { status: "missing", revision: 0, entries: [], error: "Transcript not found" } : { status: "failed", revision: 0, entries: [], error: "Transcript failed" };
+        }
+        const metadata = await transcriptMetadata(path);
+        if (request.revision !== undefined && request.revision !== metadata.revision)
+            return { ...metadata, entries: [], error: "Transcript revision is stale" };
+        if (metadata.status === "missing")
+            return { ...metadata, entries: [], error: "Transcript not found" };
+        if (metadata.status === "empty")
+            return { ...metadata, entries: [] };
+        if (path === undefined)
+            return { status: "missing", revision: 0, entries: [], error: "Transcript not found" };
+        if (metadata.status === "failed" || metadata.status === "oversized")
+            return { ...metadata, entries: [], error: metadata.status === "oversized" ? "Transcript is too large" : "Transcript failed" };
+        try {
+            const entries = await readTranscript(path, true);
+            if (Buffer.byteLength(JSON.stringify(entries)) > TRAJECTORY_MAX_TRANSCRIPT_BYTES)
+                return { ...metadata, status: "oversized", entries: [], error: "Transcript is too large" };
+            return { ...metadata, entries };
+        }
+        catch {
+            return { ...metadata, status: "failed", entries: [], error: "Transcript failed" };
+        }
+    };
+}
+const TRAJECTORY_SUBAGENT_FILES = ["status.json", "request.json", "result.json", "failure.json"];
+const TRAJECTORY_SUBAGENT_ATTENTION_ORDER = { running: 0, failed: 1, stopped: 2, completed: 3 };
+async function readSubagentJson(path, optional = false, maxBytes) {
+    try {
+        if (maxBytes !== undefined) {
+            const info = await stat(path);
+            if (!info.isFile() || info.size > maxBytes)
+                return undefined;
+        }
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (optional && isNodeError(error, "ENOENT"))
+            return undefined;
+        throw error;
+    }
+}
+async function subagentFileBytes(path) {
+    try {
+        const info = await stat(path);
+        return info.isFile() ? info.size : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function subagentArtifact(path, bytes) { return bytes === undefined ? undefined : { truncated: true, path, bytes }; }
+function boundedSubagentJson(value) { return jsonValue(value) ? value : undefined; }
+function withoutProgressActivity(progress) {
+    const rest = { ...progress };
+    delete rest.activity;
+    return rest;
+}
+async function loadTrajectorySubagent(directory, cwd, sessionId, includeTranscript = true) {
+    try {
+        const id = basename(directory);
+        const status = statusValue(await readSubagentJson(join(directory, "status.json")));
+        if (!status || status.id !== id)
+            return undefined;
+        if (status.sessionId !== sessionId)
+            return "foreign";
+        const progress = status.progress === undefined ? undefined : withoutProgressActivity(status.progress);
+        const request = normalizeSubagentRunRequest(await readSubagentJson(join(directory, "request.json")));
+        const resultPath = join(directory, "result.json");
+        const failurePath = join(directory, "failure.json");
+        const resultBytes = await subagentFileBytes(resultPath);
+        const failureBytes = await subagentFileBytes(failurePath);
+        const resultValue = await readSubagentJson(resultPath, true, DEFAULT_MAX_BYTES);
+        const failureValue = await readSubagentJson(failurePath, true, DEFAULT_MAX_BYTES);
+        const resultTruncated = resultValue === undefined && resultBytes !== undefined && resultBytes > DEFAULT_MAX_BYTES;
+        const failureTruncated = failureValue === undefined && failureBytes !== undefined && failureBytes > DEFAULT_MAX_BYTES;
+        if (!resultTruncated && resultValue !== undefined && boundedSubagentJson(resultValue) === undefined || !failureTruncated && failureValue !== undefined && subagentErrorValue(failureValue) === undefined)
+            return undefined;
+        const resultArtifact = resultTruncated ? subagentArtifact(resultPath, resultBytes) : undefined;
+        const failureArtifact = failureTruncated ? subagentArtifact(failurePath, failureBytes) : undefined;
+        const result = resultArtifact ?? (resultValue === undefined ? undefined : boundedSubagentJson(resultValue));
+        const failure = failureArtifact ?? (failureValue === undefined ? undefined : subagentErrorValue(failureValue));
+        const rawAttempt = status.attemptDetails?.at(-1);
+        const attempt = rawAttempt === undefined ? undefined : await withResolvedAttemptResources(rawAttempt, cwd);
+        const tools = progress?.state?.tools ?? attempt?.setup.tools ?? [];
+        const toolDefinitions = toolDefinitionsFor(tools, piToolCatalog(cwd));
+        const model = progress?.state?.model ?? attempt?.setup.model;
+        const transcriptPath = sessionFile(attempt?.session);
+        const transcript = !includeTranscript ? [] : transcriptPath === undefined ? [] : await readTranscript(transcriptPath);
+        return {
+            id, sessionId, cwd, mode: request.mode ?? "background", state: status.state, request, tools, transcript,
+            ...(request.label === undefined ? {} : { label: request.label }),
+            ...(request.role === undefined ? {} : { role: request.role }),
+            ...(status.startedAt === undefined ? {} : { startedAt: status.startedAt }),
+            ...(status.finishedAt === undefined ? {} : { finishedAt: status.finishedAt }),
+            ...(status.attempts === undefined ? {} : { attempts: status.attempts }),
+            ...(status.error === undefined ? {} : { error: status.error }),
+            ...(status.worktree === undefined ? {} : { worktree: status.worktree }),
+            ...(model === undefined ? {} : { model }),
+            ...(toolDefinitions.length ? { toolDefinitions } : {}),
+            ...(progress === undefined ? {} : { progress }),
+            ...(attempt === undefined ? {} : { attempt }),
+            ...(result === undefined ? {} : { result }),
+            ...(failure === undefined ? {} : { failure }),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function subagentCacheEntryChanged(directory, entry) {
+    for (const file of TRAJECTORY_SUBAGENT_FILES)
+        if (await fileMtime(join(directory, file)) !== entry.fileMtimes.get(file))
+            return true;
+    const transcriptPath = sessionFile(entry.value.attempt?.session);
+    return transcriptPath !== undefined && await fileMtime(transcriptPath) !== entry.transcriptMtime;
+}
+export function createTrajectorySubagentLoader(cwd, sessionId, agentDir, overlay, includeTranscript = true) {
+    const root = join(agentDir, "subagents");
+    const cache = new Map();
+    const negativeCache = new Map();
+    return async () => {
+        let entries;
+        try {
+            entries = await readdir(root, { withFileTypes: true });
+        }
+        catch (error) {
+            if (isNodeError(error, "ENOENT"))
+                return [];
+            throw error;
+        }
+        const ids = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+        const current = new Set(ids);
+        for (const id of cache.keys())
+            if (!current.has(id))
+                cache.delete(id);
+        for (const id of negativeCache.keys())
+            if (!current.has(id))
+                negativeCache.delete(id);
+        const loaded = [];
+        for (const id of ids) {
+            const directory = join(root, id);
+            const statusPath = join(directory, "status.json");
+            try {
+                const statusMtime = await fileMtime(statusPath);
+                if (negativeCache.has(id) && negativeCache.get(id) === statusMtime)
+                    continue;
+                negativeCache.delete(id);
+                let entry = cache.get(id);
+                if (!entry || await subagentCacheEntryChanged(directory, entry)) {
+                    const value = await loadTrajectorySubagent(directory, cwd, sessionId, includeTranscript);
+                    if (value === "foreign") {
+                        cache.delete(id);
+                        negativeCache.set(id, statusMtime);
+                        continue;
+                    }
+                    if (!value) {
+                        cache.delete(id);
+                        continue;
+                    }
+                    const fileMtimes = new Map();
+                    for (const file of TRAJECTORY_SUBAGENT_FILES)
+                        fileMtimes.set(file, await fileMtime(join(directory, file)));
+                    const transcriptPath = sessionFile(value.attempt?.session);
+                    entry = { value, fileMtimes, transcriptMtime: transcriptPath === undefined ? undefined : await fileMtime(transcriptPath) };
+                    cache.set(id, entry);
+                }
+                loaded.push(overlay ? overlay(entry.value) : entry.value);
+            }
+            catch {
+                cache.delete(id); /* Ignore corrupt or concurrently removed subagents. */
+            }
+        }
+        const attention = navigatorAttentionSortByState(loaded, (entry) => entry.state, () => undefined, TRAJECTORY_SUBAGENT_ATTENTION_ORDER);
+        return attention.sort((left, right) => {
+            if (left.state !== right.state)
+                return 0;
+            const leftTime = left.finishedAt ?? left.startedAt ?? -1;
+            const rightTime = right.finishedAt ?? right.startedAt ?? -1;
+            return rightTime - leftTime || left.id.localeCompare(right.id);
+        });
+    };
+}