@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/agent/activity-curator.js

@@ -0,0 +1,227 @@
+import { isLikelyExternalToolName } from "@hyperdrive.bot/fleet-protocol/tool-name-normalization";
+import { buildToolCallDisplayModel } from "@hyperdrive.bot/fleet-protocol/tool-call-display";
+import { projectTimelineRows } from "./timeline-projection.js";
+const DEFAULT_MAX_ITEMS = 0;
+const MAX_TOOL_INPUT_CHARS = 400;
+const MAX_TOOL_SUMMARY_CHARS = 200;
+function appendText(buffer, text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return buffer;
+    }
+    if (!buffer) {
+        return normalized;
+    }
+    return `${buffer}\n${normalized}`;
+}
+function activityEntry(text) {
+    return { text };
+}
+function flushBuffers(entries, buffers, options) {
+    if (buffers.message.trim()) {
+        const text = buffers.message.trim();
+        entries.push(activityEntry(options?.labelAssistantMessages ? `[Assistant] ${text}` : text));
+    }
+    if (buffers.thought.trim()) {
+        const text = buffers.thought.trim();
+        entries.push(activityEntry(`[Thought] ${text}`));
+    }
+    buffers.message = "";
+    buffers.thought = "";
+}
+function formatToolInputJson(input) {
+    if (input === undefined) {
+        return null;
+    }
+    try {
+        const encoded = JSON.stringify(input);
+        if (!encoded) {
+            return null;
+        }
+        if (encoded.length <= MAX_TOOL_INPUT_CHARS) {
+            return encoded;
+        }
+        return `${encoded.slice(0, MAX_TOOL_INPUT_CHARS)}...`;
+    }
+    catch {
+        return null;
+    }
+}
+function formatToolSummary(summary) {
+    if (typeof summary !== "string") {
+        return null;
+    }
+    const normalized = summary.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+        return null;
+    }
+    if (normalized.length <= MAX_TOOL_SUMMARY_CHARS) {
+        return normalized;
+    }
+    return `${normalized.slice(0, MAX_TOOL_SUMMARY_CHARS - 3)}...`;
+}
+function inputFromUnknownDetail(detail) {
+    return detail.type === "unknown" ? detail.input : null;
+}
+function projectForCuration(items) {
+    const rows = items.map((item, index) => ({
+        seq: index + 1,
+        timestamp: "",
+        item,
+    }));
+    return projectTimelineRows({ rows, mode: "projected" }).map((entry) => entry.item);
+}
+function shouldIncludeItem(item, options) {
+    if (!options?.includeKinds) {
+        return true;
+    }
+    return options.includeKinds.includes(item.type);
+}
+function formatToolCallEntry(item, options) {
+    const inputJson = formatToolInputJson(inputFromUnknownDetail(item.detail));
+    const display = buildToolCallDisplayModel({
+        name: item.name,
+        status: item.status,
+        error: item.error,
+        detail: item.detail,
+        metadata: item.metadata,
+    });
+    const displayName = display.displayName;
+    const summary = formatToolSummary(display.summary);
+    if ((options?.includeExternalToolInput ?? true) &&
+        isLikelyExternalToolName(item.name) &&
+        inputJson) {
+        return activityEntry(`[${displayName}] ${inputJson}`);
+    }
+    return activityEntry(summary ? `[${displayName}] ${summary}` : `[${displayName}]`);
+}
+function curateProjectedActivityEntries(items, options) {
+    if (items.length === 0) {
+        return [];
+    }
+    const maxItems = options?.maxItems ?? DEFAULT_MAX_ITEMS;
+    const recentItems = maxItems > 0 && items.length > maxItems ? items.slice(-maxItems) : items;
+    const entries = [];
+    const buffers = { message: "", thought: "" };
+    for (const item of recentItems) {
+        if (!shouldIncludeItem(item, options)) {
+            continue;
+        }
+        switch (item.type) {
+            case "user_message":
+                flushBuffers(entries, buffers, options);
+                entries.push(activityEntry(`[User] ${item.text.trim()}`));
+                break;
+            case "assistant_message":
+                buffers.message = appendText(buffers.message, item.text);
+                break;
+            case "reasoning":
+                buffers.thought = appendText(buffers.thought, item.text);
+                break;
+            case "tool_call": {
+                flushBuffers(entries, buffers, options);
+                entries.push(formatToolCallEntry(item, options));
+                break;
+            }
+            case "todo":
+                flushBuffers(entries, buffers, options);
+                entries.push(activityEntry("[Tasks]"));
+                for (const entry of item.items) {
+                    const checkbox = entry.completed ? "[x]" : "[ ]";
+                    const text = `- ${checkbox} ${entry.text}`;
+                    entries.push(activityEntry(text));
+                }
+                break;
+            case "error":
+                flushBuffers(entries, buffers, options);
+                entries.push(activityEntry(`[Error] ${item.message}`));
+                break;
+            case "compaction":
+                flushBuffers(entries, buffers, options);
+                entries.push(activityEntry("[Compacted]"));
+                break;
+        }
+    }
+    flushBuffers(entries, buffers, options);
+    return entries;
+}
+function curateAgentActivityEntries(timeline, options) {
+    const collapsed = projectForCuration(timeline);
+    return curateProjectedActivityEntries(collapsed, options);
+}
+/**
+ * Convert normalized agent timeline items into a concise text summary.
+ */
+export function curateAgentActivity(timeline, options) {
+    const entries = curateAgentActivityEntries(timeline, options);
+    return entries.length > 0
+        ? entries.map((entry) => entry.text).join("\n")
+        : "No activity to display.";
+}
+function selectForkContextRows(input) {
+    const boundaryMessageId = input.boundaryMessageId?.trim() || null;
+    if (!boundaryMessageId) {
+        const projected = projectTimelineRows({ rows: input.rows, mode: "projected" });
+        return {
+            items: projected.map((entry) => entry.item),
+            boundaryMessageId: null,
+        };
+    }
+    const boundaryIndex = input.rows.findLastIndex((row) => row.item.type === "assistant_message" && row.item.messageId === boundaryMessageId);
+    if (boundaryIndex < 0) {
+        throw new Error("Selected assistant message is no longer available.");
+    }
+    const selectedRows = input.rows.slice(0, boundaryIndex + 1);
+    const projected = projectTimelineRows({ rows: selectedRows, mode: "projected" });
+    return {
+        items: projected.map((entry) => entry.item),
+        boundaryMessageId,
+    };
+}
+function trimContextMetadata(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function buildForkContextText(input) {
+    const header = ["Chat history from a previous Paseo agent."];
+    const agentTitle = trimContextMetadata(input.agentTitle);
+    const cwd = trimContextMetadata(input.cwd);
+    if (agentTitle) {
+        header.push(`Source agent: ${agentTitle}`);
+    }
+    if (cwd) {
+        header.push(`Source directory: ${cwd}`);
+    }
+    return `${header.join("\n")}\n\n${input.body}`;
+}
+export function buildAgentForkContextAttachment(input) {
+    const selected = selectForkContextRows({
+        rows: input.rows,
+        boundaryMessageId: input.boundaryMessageId,
+    });
+    const entries = curateProjectedActivityEntries(selected.items, {
+        maxItems: 0,
+        labelAssistantMessages: true,
+        includeKinds: ["user_message", "assistant_message", "tool_call"],
+        includeExternalToolInput: false,
+    });
+    const body = entries.length > 0
+        ? entries.map((entry) => entry.text).join("\n")
+        : "No chat history to display.";
+    return {
+        attachment: {
+            type: "text",
+            mimeType: "text/plain",
+            contextKind: "chat_history",
+            title: "Chat history",
+            text: buildForkContextText({
+                body,
+                agentTitle: input.agentTitle,
+                cwd: input.cwd,
+            }),
+        },
+        itemCount: selected.items.length,
+        boundaryMessageId: selected.boundaryMessageId,
+    };
+}
+//# sourceMappingURL=activity-curator.js.map

package/dist/server/server/agent/agent-archive.d.ts

@@ -0,0 +1,11 @@
+import type { StoredAgentRecord } from "./agent-storage.js";
+export type ArchivedStoredAgentRecord = StoredAgentRecord & {
+    archivedAt: string;
+};
+interface BuildArchivedAgentRecordOptions {
+    archivedAt?: string;
+    updatedAt?: string;
+}
+export declare function buildArchivedAgentRecord(record: StoredAgentRecord, options?: BuildArchivedAgentRecordOptions): ArchivedStoredAgentRecord;
+export {};
+//# sourceMappingURL=agent-archive.d.ts.map

package/dist/server/server/agent/agent-archive.js

@@ -0,0 +1,16 @@
+export function buildArchivedAgentRecord(record, options) {
+    const archivedAt = options?.archivedAt ?? new Date().toISOString();
+    return {
+        ...record,
+        archivedAt,
+        updatedAt: options?.updatedAt ?? record.updatedAt,
+        lastStatus: normalizeArchivedStatus(record.lastStatus),
+        requiresAttention: false,
+        attentionReason: null,
+        attentionTimestamp: null,
+    };
+}
+function normalizeArchivedStatus(status) {
+    return status === "running" || status === "initializing" ? "idle" : status;
+}
+//# sourceMappingURL=agent-archive.js.map

package/dist/server/server/agent/agent-list-filter.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Daemon-side adapter between `AgentListItemPayload` records and the shared
+ * filter predicate in `@hyperdrive.bot/fleet-protocol/agent-filter`.
+ *
+ * The predicate and every value type live in `protocol` precisely so this file
+ * cannot invent its own semantics: all it does is (a) roll up the corpus-wide
+ * facts a single record cannot know, (b) project each record into an
+ * `AgentFilterSubject`, and (c) report the vocabulary a caller needs in order
+ * to name a value in the first place.
+ *
+ * (c) is not a convenience. The app renders a chip per discovered tag, kanban
+ * bucket and provider, so a human can always see the vocabulary before they
+ * filter on it. A tool caller sees a JSON schema, which can describe the CLOSED
+ * dimensions (six state buckets, two origins) but not the open ones. Returning
+ * the facets alongside the page is what makes "filter by tag" usable without
+ * guessing a string.
+ */
+import { type AgentFilterCriteria, type AgentFilterSubject, type AgentTimeField } from "@hyperdrive.bot/fleet-protocol/agent-filter";
+import type { AgentListItemPayload } from "@hyperdrive.bot/fleet-protocol/messages";
+/**
+ * The agent's user tag names, without the `tag:` prefix, sorted.
+ *
+ * A `"false"` value means "not tagged" and is skipped, matching the app's
+ * `getAgentTags` and the MCP tool's reader. This filter used to key on the KEY
+ * alone, so the same labels bag could read as tagged here and untagged in the
+ * UI. `$PASEO_HOME/agents/*.json` is a documented hand-editable file, so that
+ * divergence was reachable without any code writing the value.
+ */
+export declare function tagsFromLabels(labels: Record<string, string> | undefined): string[];
+/** The agent's kanban bucket id, or `null` when it carries no bucket label. */
+export declare function kanbanBucketFromLabels(labels: Record<string, string> | undefined): string | null;
+/**
+ * `parentAgentId -> count of still-alive children` across the corpus.
+ *
+ * The list payload carries the relationship only in the label, so this reads
+ * the label rather than the hydrated field the app can fall back to.
+ */
+export declare function countActiveChildrenByParent(agents: readonly AgentListItemPayload[]): Map<string, number>;
+/**
+ * Fills each record's `activeChildCount` with the corpus rollup, so that
+ * `deriveAgentStateBucket` can return `pending` from a list item.
+ *
+ * Same sum the app computes in `use-aggregated-agents`: live subagents PLUS the
+ * agent's own in-flight background tasks. Counting only one half is how a
+ * session with an armed monitor reported `done` in one surface and `running` in
+ * another.
+ */
+export declare function withActiveChildCounts(agents: readonly AgentListItemPayload[]): AgentListItemPayload[];
+/** The bucket the UI groups and filters by, derived from a list item. */
+export declare function stateBucketFor(agent: AgentListItemPayload): "running" | "failed" | "done" | "attention" | "needs_input" | "pending";
+/**
+ * Projects one record into the shape the predicate reads.
+ *
+ * `timeField` is baked in here rather than carried on the criteria for the same
+ * reason the app treats it as a mode: the reader is asking about creation OR
+ * about activity, never the intersection.
+ */
+export declare function toAgentFilterSubject(agent: AgentListItemPayload, timeField: AgentTimeField): AgentFilterSubject;
+/** The open-set vocabulary a caller needs before it can name a value. */
+export interface AgentListFacets {
+    tags: string[];
+    kanban: string[];
+    providers: string[];
+}
+/**
+ * Every value present in the corpus for each OPEN dimension, sorted.
+ *
+ * Computed over the records the caller could reach BEFORE the filter narrows
+ * them, so the facets keep describing what is available rather than shrinking
+ * to whatever the current query already matched -- a vocabulary that collapses
+ * as you use it cannot be used to widen a search.
+ */
+export declare function collectAgentListFacets(agents: readonly AgentListItemPayload[]): AgentListFacets;
+/** Applies the shared predicate to a corpus already carrying child counts. */
+export declare function filterAgentList(agents: readonly AgentListItemPayload[], criteria: AgentFilterCriteria, timeField: AgentTimeField, now: Date): AgentListItemPayload[];
+//# sourceMappingURL=agent-list-filter.d.ts.map

package/dist/server/server/agent/agent-list-filter.js

@@ -0,0 +1,184 @@
+/**
+ * Daemon-side adapter between `AgentListItemPayload` records and the shared
+ * filter predicate in `@hyperdrive.bot/fleet-protocol/agent-filter`.
+ *
+ * The predicate and every value type live in `protocol` precisely so this file
+ * cannot invent its own semantics: all it does is (a) roll up the corpus-wide
+ * facts a single record cannot know, (b) project each record into an
+ * `AgentFilterSubject`, and (c) report the vocabulary a caller needs in order
+ * to name a value in the first place.
+ *
+ * (c) is not a convenience. The app renders a chip per discovered tag, kanban
+ * bucket and provider, so a human can always see the vocabulary before they
+ * filter on it. A tool caller sees a JSON schema, which can describe the CLOSED
+ * dimensions (six state buckets, two origins) but not the open ones. Returning
+ * the facets alongside the page is what makes "filter by tag" usable without
+ * guessing a string.
+ */
+import { agentPassesFilter, deriveAgentOrigin, } from "@hyperdrive.bot/fleet-protocol/agent-filter";
+import { PARENT_AGENT_ID_LABEL } from "@hyperdrive.bot/fleet-protocol/agent-labels";
+import { deriveAgentStateBucket } from "@hyperdrive.bot/fleet-protocol/agent-state-bucket";
+/** Same convention the workspace tag rail and `set_session_tags` use. */
+const TAG_LABEL_PREFIX = "tag:";
+/** `agent.labels.kanban` holds the bucket id; absence means the default column. */
+const KANBAN_LABEL_KEY = "kanban";
+/**
+ * The agent's user tag names, without the `tag:` prefix, sorted.
+ *
+ * A `"false"` value means "not tagged" and is skipped, matching the app's
+ * `getAgentTags` and the MCP tool's reader. This filter used to key on the KEY
+ * alone, so the same labels bag could read as tagged here and untagged in the
+ * UI. `$PASEO_HOME/agents/*.json` is a documented hand-editable file, so that
+ * divergence was reachable without any code writing the value.
+ */
+export function tagsFromLabels(labels) {
+    if (!labels)
+        return [];
+    return Object.entries(labels)
+        .filter(([key, value]) => key.startsWith(TAG_LABEL_PREFIX) &&
+        key.length > TAG_LABEL_PREFIX.length &&
+        value !== "false")
+        .map(([key]) => key.slice(TAG_LABEL_PREFIX.length))
+        .sort();
+}
+/** The agent's kanban bucket id, or `null` when it carries no bucket label. */
+export function kanbanBucketFromLabels(labels) {
+    const value = labels?.[KANBAN_LABEL_KEY]?.trim();
+    return value ? value : null;
+}
+/**
+ * A child is "alive" while it is running or still spinning up, mirroring
+ * `packages/app/src/utils/active-children.ts` exactly. An archived or settled
+ * child must stop counting, or its parent never leaves `pending`.
+ */
+function isAliveChild(agent) {
+    if (agent.archivedAt)
+        return false;
+    return agent.status === "running" || agent.status === "initializing";
+}
+/**
+ * `parentAgentId -> count of still-alive children` across the corpus.
+ *
+ * The list payload carries the relationship only in the label, so this reads
+ * the label rather than the hydrated field the app can fall back to.
+ */
+export function countActiveChildrenByParent(agents) {
+    const counts = new Map();
+    for (const agent of agents) {
+        const parentId = agent.labels?.[PARENT_AGENT_ID_LABEL]?.trim();
+        if (!parentId || !isAliveChild(agent))
+            continue;
+        counts.set(parentId, (counts.get(parentId) ?? 0) + 1);
+    }
+    return counts;
+}
+/**
+ * Fills each record's `activeChildCount` with the corpus rollup, so that
+ * `deriveAgentStateBucket` can return `pending` from a list item.
+ *
+ * Same sum the app computes in `use-aggregated-agents`: live subagents PLUS the
+ * agent's own in-flight background tasks. Counting only one half is how a
+ * session with an armed monitor reported `done` in one surface and `running` in
+ * another.
+ */
+export function withActiveChildCounts(agents) {
+    const childrenByParent = countActiveChildrenByParent(agents);
+    return agents.map((agent) => {
+        const activeChildCount = (childrenByParent.get(agent.id) ?? 0) + (agent.activeBackgroundTaskCount ?? 0);
+        return activeChildCount > 0 ? { ...agent, activeChildCount } : agent;
+    });
+}
+/** The bucket the UI groups and filters by, derived from a list item. */
+export function stateBucketFor(agent) {
+    return deriveAgentStateBucket({
+        status: agent.status,
+        pendingPermissionCount: agent.pendingPermissionCount ?? 0,
+        requiresAttention: agent.requiresAttention ?? false,
+        attentionReason: agent.attentionReason ?? null,
+        activeChildCount: agent.activeChildCount ?? 0,
+    });
+}
+/**
+ * A `switch`, not the ternary this replaced: that one treated every field which
+ * was not "created" as "active", so adding "archived" to the union would have
+ * compiled clean here and measured last-activity while the caller asked for the
+ * archive date. Exhaustive, so a new field is a type error instead.
+ *
+ * Picks the RAW wire value first and parses once, because on this payload the
+ * timestamps are ISO strings rather than Dates.
+ */
+function timeValueFor(agent, field) {
+    const raw = (() => {
+        switch (field) {
+            case "created":
+                return agent.createdAt;
+            case "active":
+                return agent.lastUserMessageAt ?? agent.updatedAt;
+            case "archived":
+                return agent.archivedAt;
+            default: {
+                // This package does not enable `noImplicitReturns`, so without the
+                // never-assignment a field with no case here falls out of the switch as
+                // `undefined` and reads downstream as "no timestamp" - a silent wrong
+                // answer instead of a build failure. Verified by widening the union and
+                // watching this line, and only this line, catch it.
+                const unhandled = field;
+                return unhandled;
+            }
+        }
+    })();
+    if (!raw)
+        return null;
+    const date = new Date(raw);
+    return Number.isFinite(date.getTime()) ? date : null;
+}
+/**
+ * Projects one record into the shape the predicate reads.
+ *
+ * `timeField` is baked in here rather than carried on the criteria for the same
+ * reason the app treats it as a mode: the reader is asking about creation OR
+ * about activity, never the intersection.
+ */
+export function toAgentFilterSubject(agent, timeField) {
+    return {
+        stateBucket: stateBucketFor(agent),
+        tags: tagsFromLabels(agent.labels),
+        kanbanBucket: kanbanBucketFromLabels(agent.labels),
+        isArchived: Boolean(agent.archivedAt),
+        timeValue: timeValueFor(agent, timeField),
+        provider: agent.provider,
+        origin: deriveAgentOrigin(agent.labels),
+        searchableText: `${agent.title ?? ""} ${agent.cwd}`.toLowerCase(),
+    };
+}
+/**
+ * Every value present in the corpus for each OPEN dimension, sorted.
+ *
+ * Computed over the records the caller could reach BEFORE the filter narrows
+ * them, so the facets keep describing what is available rather than shrinking
+ * to whatever the current query already matched -- a vocabulary that collapses
+ * as you use it cannot be used to widen a search.
+ */
+export function collectAgentListFacets(agents) {
+    const tags = new Set();
+    const kanban = new Set();
+    const providers = new Set();
+    for (const agent of agents) {
+        for (const tag of tagsFromLabels(agent.labels))
+            tags.add(tag);
+        const bucket = kanbanBucketFromLabels(agent.labels);
+        if (bucket)
+            kanban.add(bucket);
+        providers.add(agent.provider);
+    }
+    return {
+        tags: [...tags].sort(),
+        kanban: [...kanban].sort(),
+        providers: [...providers].sort(),
+    };
+}
+/** Applies the shared predicate to a corpus already carrying child counts. */
+export function filterAgentList(agents, criteria, timeField, now) {
+    return agents.filter((agent) => agentPassesFilter(toAgentFilterSubject(agent, timeField), criteria, now));
+}
+//# sourceMappingURL=agent-list-filter.js.map

package/dist/server/server/agent/agent-loading.d.ts

@@ -0,0 +1,12 @@
+import type { Logger } from "pino";
+import type { AgentProvider } from "./agent-sdk-types.js";
+import type { AgentManager, ManagedAgent } from "./agent-manager.js";
+import type { AgentStorage } from "./agent-storage.js";
+export interface EnsureAgentLoadedDeps {
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    validProviders?: Iterable<AgentProvider>;
+    logger: Logger;
+}
+export declare function ensureAgentLoaded(agentId: string, deps: EnsureAgentLoadedDeps): Promise<ManagedAgent>;
+//# sourceMappingURL=agent-loading.d.ts.map

package/dist/server/server/agent/agent-loading.js

@@ -0,0 +1,76 @@
+import { buildConfigOverrides, buildSessionConfig, extractTimestamps, isStoredAgentProviderAvailable, toAgentPersistenceHandle, } from "../persistence-hooks.js";
+import { resolveUsableResumeCwd } from "./resolve-resume-cwd.js";
+const pendingAgentInitializations = new Map();
+export async function ensureAgentLoaded(agentId, deps) {
+    const existing = deps.agentManager.getAgent(agentId);
+    if (existing) {
+        return existing;
+    }
+    const inflight = pendingAgentInitializations.get(agentId);
+    if (inflight) {
+        return inflight;
+    }
+    const initPromise = (async () => {
+        const record = await deps.agentStorage.get(agentId);
+        if (!record) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        const validProviders = deps.validProviders ?? deps.agentManager.getRegisteredProviderIds();
+        if (!isStoredAgentProviderAvailable(record, validProviders)) {
+            throw new Error(`Agent ${agentId} references unavailable provider '${record.provider}'`);
+        }
+        const handle = toAgentPersistenceHandle(validProviders, record.persistence);
+        // A recorded cwd may no longer exist: the worktree was cleaned up, or the
+        // session came from another machine (`/Users/claudinho/...` on a linux box).
+        // normalizeConfig stats the cwd and throws "Working directory does not
+        // exist", so loading the agent fails outright and every READ of that session
+        // fails with it, including get_agent_activity, even though the transcript is
+        // sitting on disk and perfectly readable.
+        //
+        // The interactive resume path in session.ts already solves this with
+        // resolveUsableResumeCwd. ensureAgentLoaded did not, so schedules and the
+        // Jarvis judge hit the wall instead. Measured 2026-07-31: 27 of 1,226 agents
+        // were unreadable for this reason alone.
+        //
+        // Resuming does not need the original directory, only *a* valid one: the
+        // transcript is read from the provider store regardless.
+        const resolvedCwd = record.cwd ? await resolveUsableResumeCwd(record.cwd) : null;
+        if (resolvedCwd?.substituted) {
+            deps.logger.warn({ agentId, original: resolvedCwd.original, fallback: resolvedCwd.cwd }, "Agent cwd no longer exists; loading against an existing directory instead");
+        }
+        const cwdOverride = resolvedCwd?.substituted ? { cwd: resolvedCwd.cwd } : {};
+        let snapshot;
+        if (handle) {
+            snapshot = await deps.agentManager.resumeAgentFromPersistence(handle, { ...buildConfigOverrides(record), ...cwdOverride }, agentId, extractTimestamps(record));
+            deps.logger.info({ agentId, provider: record.provider }, "Agent resumed from persistence");
+        }
+        else {
+            const baseConfig = buildSessionConfig(record, {
+                validProviders,
+            });
+            if (!baseConfig) {
+                throw new Error(`Agent ${agentId} references unavailable provider '${record.provider}'`);
+            }
+            const config = { ...baseConfig, ...cwdOverride };
+            snapshot = await deps.agentManager.createAgent(config, agentId, {
+                labels: record.labels,
+                workspaceId: record.workspaceId,
+                digest: record.digest,
+            });
+            deps.logger.info({ agentId, provider: record.provider }, "Agent created from stored config");
+        }
+        await deps.agentManager.hydrateTimelineFromProvider(agentId);
+        return deps.agentManager.getAgent(agentId) ?? snapshot;
+    })();
+    pendingAgentInitializations.set(agentId, initPromise);
+    try {
+        return await initPromise;
+    }
+    finally {
+        const current = pendingAgentInitializations.get(agentId);
+        if (current === initPromise) {
+            pendingAgentInitializations.delete(agentId);
+        }
+    }
+}
+//# sourceMappingURL=agent-loading.js.map