@hyperdrive.bot/fleet-server 0.3.159 → 0.3.161

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

@@ -236,6 +236,8 @@ export declare class AgentManager {
     private readonly providerSwapMetadata;
     private readonly agents;
     private readonly timelineStore;
+    /** Deferred archive teardowns in flight, per agent. See `scheduleArchiveTeardown`. */
+    private readonly archiveTeardowns;
     private readonly agentsAwaitingInitialSnapshotPersist;
     private readonly sessionEventTails;
     private readonly foregroundRuns;
@@ -345,6 +347,8 @@ export declare class AgentManager {
     listDraftFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
     getAgent(id: string): ManagedAgent | null;
     getTimeline(id: string): AgentTimelineItem[];
+    /** Timeline row count, without the full copy `getTimeline(id).length` makes. */
+    getTimelineSize(id: string): number;
     /**
      * Timeline epoch for an agent. Row `seq` restarts at 1 whenever the store is
      * re-initialized without seeded rows, so a seq is only comparable WITHIN an
@@ -414,6 +418,31 @@ export declare class AgentManager {
     archiveAgent(agentId: string): Promise<{
         archivedAt: string;
     }>;
+    /**
+     * First half of `archiveAgent`: persist the archived record. After this the
+     * archive is durable and can be acknowledged; the process is still running.
+     */
+    markLiveAgentArchived(agentId: string): Promise<{
+        archivedAt: string;
+    }>;
+    /**
+     * Second half of `archiveAgent`: close the process and archive the subagents
+     * it spawned. Safe to run after the archive was acknowledged.
+     */
+    completeLiveAgentArchive(agentId: string): Promise<void>;
+    /**
+     * Run the deferred half of an archive (close the process if still open, archive
+     * subagents) in the background, serialized per agent.
+     *
+     * Everything that can revive the agent (unarchive, resume, reload) awaits it
+     * first via `awaitArchiveTeardown`, so the outcome is the same as the old
+     * synchronous archive: the revive always lands after the close, and a close
+     * can never land on a revived agent. Resolves to the error when the teardown
+     * failed, never rejects.
+     */
+    scheduleArchiveTeardown(agentId: string): Promise<Error | null>;
+    /** Wait for a pending archive teardown of this agent, if any. */
+    awaitArchiveTeardown(agentId: string | undefined): Promise<void>;
     private cascadeArchiveChildren;
     private markRecordArchived;
     private fireAgentArchived;

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

@@ -218,6 +218,8 @@ export class AgentManager {
         this.providerSwapMetadata = new Map();
         this.agents = new Map();
         this.timelineStore = new InMemoryAgentTimelineStore();
+        /** Deferred archive teardowns in flight, per agent. See `scheduleArchiveTeardown`. */
+        this.archiveTeardowns = new Map();
         this.agentsAwaitingInitialSnapshotPersist = new Set();
         this.sessionEventTails = new Map();
         this.foregroundRuns = new ForegroundRunState();
@@ -350,7 +352,7 @@ export class AgentManager {
             if (!this.timelineStore.has(agent.id)) {
                 continue;
             }
-            const len = this.timelineStore.getItems(agent.id).length;
+            const len = this.timelineStore.size(agent.id);
             totalItems += len;
             if (len > maxItemsPerAgent) {
                 maxItemsPerAgent = len;
@@ -640,6 +642,11 @@ export class AgentManager {
         this.requireAgent(id);
         return this.timelineStore.getItems(id);
     }
+    /** Timeline row count, without the full copy `getTimeline(id).length` makes. */
+    getTimelineSize(id) {
+        this.requireAgent(id);
+        return this.timelineStore.size(id);
+    }
     /**
      * Timeline epoch for an agent. Row `seq` restarts at 1 whenever the store is
      * re-initialized without seeded rows, so a seq is only comparable WITHIN an
@@ -690,6 +697,7 @@ export class AgentManager {
     // Reconstruct an agent from provider persistence. Callers should explicitly
     // hydrate timeline history after resume.
     async resumeAgentFromPersistence(handle, overrides, agentId, options) {
+        await this.awaitArchiveTeardown(agentId);
         const resolvedAgentId = validateAgentId(agentId ?? this.idFactory(), "resumeAgentFromPersistence");
         const metadata = (handle.metadata ?? {});
         const mergedConfig = {
@@ -853,6 +861,7 @@ export class AgentManager {
     // Hot-reload an active agent session with config overrides while preserving
     // in-memory timeline state.
     async reloadAgentSession(agentId, overrides, options) {
+        await this.awaitArchiveTeardown(agentId);
         let existing = this.requireSessionAgent(agentId);
         if (this.hasInFlightRun(agentId)) {
             await this.cancelAgentRun(agentId);
@@ -983,6 +992,15 @@ export class AgentManager {
         }, "agent.manager.close.complete");
     }
     async archiveAgent(agentId) {
+        const { archivedAt } = await this.markLiveAgentArchived(agentId);
+        await this.completeLiveAgentArchive(agentId);
+        return { archivedAt };
+    }
+    /**
+     * First half of `archiveAgent`: persist the archived record. After this the
+     * archive is durable and can be acknowledged; the process is still running.
+     */
+    async markLiveAgentArchived(agentId) {
         const agent = this.requireAgent(agentId);
         if (!this.registry) {
             throw new Error("Agent storage is not configured");
@@ -996,10 +1014,54 @@ export class AgentManager {
         }
         const { archivedAt } = await this.markRecordArchived(stored);
         agent.updatedAt = new Date(archivedAt);
-        await this.closeAgent(agentId);
-        await this.cascadeArchiveChildren(agentId);
         return { archivedAt };
     }
+    /**
+     * Second half of `archiveAgent`: close the process and archive the subagents
+     * it spawned. Safe to run after the archive was acknowledged.
+     */
+    async completeLiveAgentArchive(agentId) {
+        if (this.agents.has(agentId)) {
+            await this.closeAgent(agentId);
+        }
+        await this.cascadeArchiveChildren(agentId);
+    }
+    /**
+     * Run the deferred half of an archive (close the process if still open, archive
+     * subagents) in the background, serialized per agent.
+     *
+     * Everything that can revive the agent (unarchive, resume, reload) awaits it
+     * first via `awaitArchiveTeardown`, so the outcome is the same as the old
+     * synchronous archive: the revive always lands after the close, and a close
+     * can never land on a revived agent. Resolves to the error when the teardown
+     * failed, never rejects.
+     */
+    scheduleArchiveTeardown(agentId) {
+        const previous = this.archiveTeardowns.get(agentId) ?? Promise.resolve();
+        const run = previous
+            .then(async () => {
+            if (this.agents.has(agentId)) {
+                await this.closeAgent(agentId);
+            }
+            await this.cascadeArchiveChildren(agentId);
+            return null;
+        })
+            .catch((error) => (error instanceof Error ? error : new Error(String(error))));
+        const tracked = run.then(() => undefined);
+        this.archiveTeardowns.set(agentId, tracked);
+        void tracked.finally(() => {
+            if (this.archiveTeardowns.get(agentId) === tracked) {
+                this.archiveTeardowns.delete(agentId);
+            }
+        });
+        return run;
+    }
+    /** Wait for a pending archive teardown of this agent, if any. */
+    async awaitArchiveTeardown(agentId) {
+        if (!agentId)
+            return;
+        await this.archiveTeardowns.get(agentId);
+    }
     // Children created via the MCP `create_agent` tool carry the parent-agent-id
     // label pointing back at the caller. Archiving the parent cascades to those
     // children so subagent fleets don't outlive their orchestrator. Detached
@@ -1385,6 +1447,9 @@ export class AgentManager {
         return nextRecord;
     }
     async unarchiveSnapshot(agentId) {
+        // Let a deferred archive teardown finish before the record is revived, so
+        // it can never close the revived agent.
+        await this.awaitArchiveTeardown(agentId);
         const registry = this.requireRegistry();
         const record = await registry.get(agentId);
         if (!record || !record.archivedAt) {
@@ -2046,8 +2111,7 @@ export class AgentManager {
         };
     }
     async getLastAssistantMessageFromStores(agentId) {
-        const liveTimeline = this.timelineStore.getItems(agentId);
-        const liveSegment = this.getLastAssistantMessageSegmentFromTimeline(liveTimeline);
+        const liveSegment = this.timelineStore.getLastAssistantSegment(agentId);
         if (!this.durableTimelineStore) {
             return liveSegment?.text ?? null;
         }

package/dist/server/server/agent/agent-timeline-store.d.ts

@@ -13,6 +13,8 @@ export declare class InMemoryAgentTimelineStore {
     initialize(agentId: string, options?: SeedAgentTimelineOptions): void;
     delete(agentId: string): void;
     getItems(agentId: string): AgentTimelineItem[];
+    /** Row count without copying the timeline. */
+    size(agentId: string): number;
     getRows(agentId: string): AgentTimelineRow[];
     getEpoch(agentId: string): string;
     fetch(agentId: string, options?: AgentTimelineFetchOptions): AgentTimelineFetchResult;
@@ -21,6 +23,14 @@ export declare class InMemoryAgentTimelineStore {
     }): AgentTimelineRow;
     getLastItem(agentId: string): AgentTimelineItem | null;
     getLastAssistantMessage(agentId: string): string | null;
+    /**
+     * The last contiguous run of assistant_message items (Claude streams chunks),
+     * walked from the end in place, and whether it starts at the first row.
+     */
+    getLastAssistantSegment(agentId: string): {
+        text: string;
+        startsAtBeginning: boolean;
+    } | null;
     private requireState;
     private buildRowsFromItems;
 }

package/dist/server/server/agent/agent-timeline-store.js

@@ -16,13 +16,47 @@ const MAX_TIMELINE_FETCH_BYTES = 2 * 1024 * 1024;
 function cloneRow(row) {
     return { ...row };
 }
+/**
+ * Serialized size per stored row, computed once. Rows are append-only and never
+ * edited in place, so the size of a row never changes; without this every page
+ * fetch re-serialized every row it considered (a tool result can be megabytes).
+ */
+const rowByteCache = new WeakMap();
 function rowBytes(row) {
+    const cached = rowByteCache.get(row);
+    if (cached !== undefined) {
+        return cached;
+    }
+    let bytes = 0;
     try {
-        return JSON.stringify(row.item)?.length ?? 0;
+        bytes = JSON.stringify(row.item)?.length ?? 0;
     }
     catch {
-        return 0;
+        bytes = 0;
     }
+    rowByteCache.set(row, bytes);
+    return bytes;
+}
+/**
+ * Index of the first row whose seq is strictly greater than `seq` (or at least
+ * `seq` when `inclusive`), or `rows.length` when there is none. Rows are kept in
+ * ascending seq order, so this is a binary search instead of a linear scan of a
+ * timeline that can hold tens of thousands of rows.
+ */
+function firstIndexAfterSeq(rows, seq, inclusive = false) {
+    let low = 0;
+    let high = rows.length;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        const rowSeq = rows[mid].seq;
+        if (inclusive ? rowSeq >= seq : rowSeq > seq) {
+            high = mid;
+        }
+        else {
+            low = mid + 1;
+        }
+    }
+    return low;
 }
 /**
  * Trim a selected page to {@link MAX_TIMELINE_FETCH_BYTES}, dropping rows from
@@ -72,8 +106,8 @@ function fetchTail(ctx) {
 function fetchAfter(ctx) {
     const { state, direction, limit, selectAll, cursor, minSeq, maxSeq, window } = ctx;
     const baseSeq = cursor?.seq ?? 0;
-    const startIdx = state.rows.findIndex((row) => row.seq > baseSeq);
-    if (startIdx < 0) {
+    const startIdx = firstIndexAfterSeq(state.rows, baseSeq);
+    if (startIdx >= state.rows.length) {
         return {
             epoch: state.epoch,
             direction,
@@ -103,7 +137,8 @@ function fetchAfter(ctx) {
 function fetchBefore(ctx) {
     const { state, direction, limit, selectAll, cursor, minSeq, window } = ctx;
     const beforeSeq = cursor?.seq ?? state.nextSeq;
-    const endExclusive = state.rows.findIndex((row) => row.seq >= beforeSeq);
+    const firstAtOrAfter = firstIndexAfterSeq(state.rows, beforeSeq, true);
+    const endExclusive = firstAtOrAfter >= state.rows.length ? -1 : firstAtOrAfter;
     const boundedRows = endExclusive < 0 ? state.rows : state.rows.slice(0, endExclusive);
     const selected = applyByteBudget(selectAll || limit >= boundedRows.length
         ? boundedRows
@@ -162,6 +197,10 @@ export class InMemoryAgentTimelineStore {
     getItems(agentId) {
         return this.requireState(agentId).rows.map((row) => row.item);
     }
+    /** Row count without copying the timeline. */
+    size(agentId) {
+        return this.requireState(agentId).rows.length;
+    }
     getRows(agentId) {
         return this.requireState(agentId).rows.map(cloneRow);
     }
@@ -237,8 +276,16 @@ export class InMemoryAgentTimelineStore {
         return state.rows[state.rows.length - 1]?.item ?? null;
     }
     getLastAssistantMessage(agentId) {
+        return this.getLastAssistantSegment(agentId)?.text ?? null;
+    }
+    /**
+     * The last contiguous run of assistant_message items (Claude streams chunks),
+     * walked from the end in place, and whether it starts at the first row.
+     */
+    getLastAssistantSegment(agentId) {
         const rows = this.requireState(agentId).rows;
         const chunks = [];
+        let startsAtBeginning = false;
         for (let i = rows.length - 1; i >= 0; i -= 1) {
             const item = rows[i].item;
             if (item.type !== "assistant_message") {
@@ -248,11 +295,12 @@ export class InMemoryAgentTimelineStore {
                 continue;
             }
             chunks.push(item.text);
+            startsAtBeginning = i === 0;
         }
         if (chunks.length === 0) {
             return null;
         }
-        return chunks.toReversed().join("");
+        return { text: chunks.toReversed().join(""), startsAtBeginning };
     }
     requireState(agentId) {
         const state = this.states.get(agentId);

package/dist/server/server/agent/blocker-log.d.ts

@@ -50,6 +50,8 @@ export declare class BlockerLog {
     private readonly logger;
     private readonly now;
     private ensured;
+    /** Per-card view of the ledger, kept current incrementally (see JsonlCardIndex). */
+    private readonly index;
     constructor(options: BlockerLogOptions);
     /**
      * Record the current blocker set for a card. No-ops when the set is unchanged
@@ -60,7 +62,7 @@ export declare class BlockerLog {
     record(cardId: string, blockers: readonly string[] | undefined): void;
     /** All rows, oldest first. Returns [] when the log does not exist yet. */
     readAll(): BlockerRow[];
-    /** Rows for one card, oldest first. */
+    /** The newest rows for one card (at most DEFAULT_ROWS_PER_CARD), oldest first. */
     history(cardId: string): BlockerRow[];
     /** The most recent recording for a card, or null. */
     latest(cardId: string): BlockerRow | null;

package/dist/server/server/agent/blocker-log.js

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { JsonlCardIndex } from "./jsonl-card-index.js";
 /** Change detection only. NOT used for matching or counting. */
 function fingerprint(blockers) {
     return blockers
@@ -14,6 +15,18 @@ export class BlockerLog {
         this.filePath = path.join(options.dir, "blockers.jsonl");
         this.logger = options.logger;
         this.now = options.now ?? (() => new Date());
+        this.index = new JsonlCardIndex({
+            filePath: this.filePath,
+            parse: (line) => {
+                const parsed = JSON.parse(line);
+                return typeof parsed?.cardId === "string" && Array.isArray(parsed?.blockers)
+                    ? parsed
+                    : null;
+            },
+            cardIdOf: (row) => row.cardId,
+            count: (row) => ({ blocked: row.blockers.length > 0 ? 1 : 0 }),
+            onReadError: (error) => this.logger.error({ err: error }, "Blocker log read failed"),
+        });
     }
     /**
      * Record the current blocker set for a card. No-ops when the set is unchanged
@@ -73,14 +86,13 @@ export class BlockerLog {
         }
         return rows;
     }
-    /** Rows for one card, oldest first. */
+    /** The newest rows for one card (at most DEFAULT_ROWS_PER_CARD), oldest first. */
     history(cardId) {
-        return this.readAll().filter((row) => row.cardId === cardId);
+        return [...(this.index.get(cardId)?.rows ?? [])];
     }
     /** The most recent recording for a card, or null. */
     latest(cardId) {
-        const rows = this.history(cardId);
-        return rows.length > 0 ? rows[rows.length - 1] : null;
+        return this.index.get(cardId)?.rows.at(-1) ?? null;
     }
     /**
      * How many separate times this card has been recorded as blocked by anything.
@@ -88,7 +100,7 @@ export class BlockerLog {
      * Marco specifically", because that is a semantic question, see the module note.
      */
     blockedRecordings(cardId) {
-        return this.history(cardId).filter((r) => r.blockers.length > 0).length;
+        return this.index.get(cardId)?.counters.blocked ?? 0;
     }
     /**
      * Compact history for a judge briefing: one line per distinct recording,

package/dist/server/server/agent/card-move-log.d.ts

@@ -36,6 +36,8 @@ export declare class CardMoveLog {
     private readonly logger;
     private readonly now;
     private ensured;
+    /** Per-card view of the ledger, kept current incrementally (see JsonlCardIndex). */
+    private readonly index;
     constructor(options: CardMoveLogOptions);
     /**
      * Record a column change. No-ops when the column did not actually change, so
@@ -46,7 +48,7 @@ export declare class CardMoveLog {
     record(cardId: string, fromColumn: string | null, toColumn: string | null): void;
     /** All rows, oldest first. Returns [] when the log does not exist yet. */
     readAll(): CardMoveRow[];
-    /** Rows for one card, oldest first. */
+    /** The newest rows for one card (at most DEFAULT_ROWS_PER_CARD), oldest first. */
     history(cardId: string): CardMoveRow[];
     /**
      * How many times this card has been pushed away from active work.

package/dist/server/server/agent/card-move-log.js

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { JsonlCardIndex } from "./jsonl-card-index.js";
 /** Columns that mean "pushed away from now", used for the deferral count. */
 const DEFERRAL_TARGETS = new Set(["later", "future", "awaiting"]);
 /** Columns that mean "actively committed to". */
@@ -10,6 +11,16 @@ export class CardMoveLog {
         this.filePath = path.join(options.dir, "card-moves.jsonl");
         this.logger = options.logger;
         this.now = options.now ?? (() => new Date());
+        this.index = new JsonlCardIndex({
+            filePath: this.filePath,
+            parse: (line) => {
+                const parsed = JSON.parse(line);
+                return typeof parsed?.cardId === "string" && typeof parsed?.at === "string" ? parsed : null;
+            },
+            cardIdOf: (row) => row.cardId,
+            count: (row) => ({ deferrals: isDeferral(row) ? 1 : 0 }),
+            onReadError: (error) => this.logger.error({ err: error }, "Card move log read failed"),
+        });
     }
     /**
      * Record a column change. No-ops when the column did not actually change, so
@@ -71,9 +82,9 @@ export class CardMoveLog {
         }
         return rows;
     }
-    /** Rows for one card, oldest first. */
+    /** The newest rows for one card (at most DEFAULT_ROWS_PER_CARD), oldest first. */
     history(cardId) {
-        return this.readAll().filter((row) => row.cardId === cardId);
+        return [...(this.index.get(cardId)?.rows ?? [])];
     }
     /**
      * How many times this card has been pushed away from active work.
@@ -85,21 +96,11 @@ export class CardMoveLog {
      * a lie.
      */
     deferralCount(cardId) {
-        let count = 0;
-        for (const row of this.history(cardId)) {
-            if (row.fromColumn &&
-                ACTIVE_SOURCES.has(row.fromColumn) &&
-                row.toColumn &&
-                DEFERRAL_TARGETS.has(row.toColumn)) {
-                count += 1;
-            }
-        }
-        return count;
+        return this.index.get(cardId)?.counters.deferrals ?? 0;
     }
     /** When the card last entered its current column, from the log. Null if unknown. */
     lastMoveAt(cardId) {
-        const history = this.history(cardId);
-        return history.length > 0 ? history[history.length - 1].at : null;
+        return this.index.get(cardId)?.rows.at(-1)?.at ?? null;
     }
     ensureDir() {
         if (this.ensured) {
@@ -109,5 +110,11 @@ export class CardMoveLog {
         this.ensured = true;
     }
 }
+function isDeferral(row) {
+    return Boolean(row.fromColumn &&
+        ACTIVE_SOURCES.has(row.fromColumn) &&
+        row.toColumn &&
+        DEFERRAL_TARGETS.has(row.toColumn));
+}
 export const KANBAN_LABEL_KEY = "kanban";
 //# sourceMappingURL=card-move-log.js.map

package/dist/server/server/agent/import-sessions.js

@@ -88,7 +88,7 @@ export async function importProviderSession(input) {
     await unarchiveAgentState(input.agentStorage, input.agentManager, snapshot.id);
     return {
         snapshot,
-        timelineSize: input.agentManager.getTimeline(snapshot.id).length,
+        timelineSize: input.agentManager.getTimelineSize(snapshot.id),
     };
 }
 async function unarchiveAgentByHandle(agentStorage, agentManager, handle) {

package/dist/server/server/agent/jsonl-card-index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Per-card index over an append-only `*.jsonl` ledger (blockers.jsonl,
+ * card-moves.jsonl), so per-card reads stop re-reading and re-parsing the whole
+ * file on every digest write.
+ *
+ * - Incremental: each access `stat`s the file and parses only the bytes appended
+ *   since the last read, so rows appended by another process (a loop script) are
+ *   seen on the next access. A file that shrank (rotated or rewritten) is
+ *   re-indexed from scratch.
+ * - Bounded: a card keeps its newest `rowsPerCard` rows plus running counters
+ *   supplied by the caller (`count`), and at most `maxCards` cards are held,
+ *   least recently used evicted first. A read for an evicted card rebuilds that
+ *   one card with a full scan, which is the old cost, paid only on a miss.
+ */
+export interface JsonlCardIndexOptions<Row> {
+    filePath: string;
+    parse(line: string): Row | null;
+    cardIdOf(row: Row): string;
+    /** Running counters kept per card across the whole history, e.g. deferrals. */
+    count?: (row: Row) => Record<string, number>;
+    rowsPerCard?: number;
+    maxCards?: number;
+    onReadError?: (error: unknown) => void;
+}
+export interface CardEntry<Row> {
+    /** Newest rows for the card, oldest first, at most `rowsPerCard`. */
+    rows: Row[];
+    /** Every row ever indexed for the card, including trimmed ones. */
+    total: number;
+    counters: Record<string, number>;
+}
+export declare const DEFAULT_ROWS_PER_CARD = 64;
+export declare const DEFAULT_MAX_CARDS = 4096;
+export declare class JsonlCardIndex<Row> {
+    private readonly options;
+    private readonly cards;
+    private offset;
+    private mtimeMs;
+    private partial;
+    private evicted;
+    private readonly rowsPerCard;
+    private readonly maxCards;
+    constructor(options: JsonlCardIndexOptions<Row>);
+    /** The card's entry, current with the file. */
+    get(cardId: string): CardEntry<Row> | null;
+    /** Read whatever was appended since the last call. */
+    sync(): void;
+    private parseLine;
+    private add;
+    private rebuildCard;
+    private reset;
+}
+//# sourceMappingURL=jsonl-card-index.d.ts.map