@hyperdrive.bot/fleet-server 0.3.159 → 0.3.161

package/dist/server/server/agent/jsonl-card-index.js

@@ -0,0 +1,138 @@
+import * as fs from "node:fs";
+export const DEFAULT_ROWS_PER_CARD = 64;
+export const DEFAULT_MAX_CARDS = 4096;
+export class JsonlCardIndex {
+    constructor(options) {
+        this.options = options;
+        this.cards = new Map();
+        this.offset = 0;
+        this.mtimeMs = -1;
+        this.partial = "";
+        this.evicted = false;
+        this.rowsPerCard = options.rowsPerCard ?? DEFAULT_ROWS_PER_CARD;
+        this.maxCards = options.maxCards ?? DEFAULT_MAX_CARDS;
+    }
+    /** The card's entry, current with the file. */
+    get(cardId) {
+        this.sync();
+        const entry = this.cards.get(cardId);
+        if (entry) {
+            // LRU touch.
+            this.cards.delete(cardId);
+            this.cards.set(cardId, entry);
+            return entry;
+        }
+        return this.evicted ? this.rebuildCard(cardId) : null;
+    }
+    /** Read whatever was appended since the last call. */
+    sync() {
+        let info;
+        try {
+            info = fs.statSync(this.options.filePath);
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT") {
+                this.options.onReadError?.(error);
+            }
+            if (this.offset > 0)
+                this.reset();
+            return;
+        }
+        if (info.size < this.offset) {
+            this.reset();
+        }
+        if (info.size === this.offset && info.mtimeMs === this.mtimeMs) {
+            return;
+        }
+        const length = info.size - this.offset;
+        if (length > 0) {
+            const buffer = Buffer.alloc(length);
+            let fd = null;
+            try {
+                fd = fs.openSync(this.options.filePath, "r");
+                fs.readSync(fd, buffer, 0, length, this.offset);
+            }
+            catch (error) {
+                this.options.onReadError?.(error);
+                return;
+            }
+            finally {
+                if (fd !== null)
+                    fs.closeSync(fd);
+            }
+            this.offset = info.size;
+            const text = this.partial + buffer.toString("utf8");
+            const lines = text.split("\n");
+            // A torn trailing line (crash or a writer mid-append) waits for its newline.
+            this.partial = lines.pop() ?? "";
+            for (const line of lines) {
+                const row = this.parseLine(line);
+                if (row)
+                    this.add(row);
+            }
+        }
+        this.mtimeMs = info.mtimeMs;
+    }
+    parseLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return null;
+        try {
+            return this.options.parse(trimmed);
+        }
+        catch {
+            return null;
+        }
+    }
+    add(row, cards = this.cards) {
+        const cardId = this.options.cardIdOf(row);
+        let entry = cards.get(cardId);
+        if (!entry) {
+            entry = { rows: [], total: 0, counters: {} };
+            cards.set(cardId, entry);
+            if (cards === this.cards && cards.size > this.maxCards) {
+                const oldest = cards.keys().next().value;
+                cards.delete(oldest);
+                this.evicted = true;
+            }
+        }
+        entry.rows.push(row);
+        if (entry.rows.length > this.rowsPerCard)
+            entry.rows.shift();
+        entry.total += 1;
+        for (const [key, value] of Object.entries(this.options.count?.(row) ?? {})) {
+            entry.counters[key] = (entry.counters[key] ?? 0) + value;
+        }
+    }
+    rebuildCard(cardId) {
+        let raw;
+        try {
+            raw = fs.readFileSync(this.options.filePath, "utf8");
+        }
+        catch {
+            return null;
+        }
+        const scratch = new Map();
+        for (const line of raw.split("\n")) {
+            const row = this.parseLine(line);
+            if (row && this.options.cardIdOf(row) === cardId)
+                this.add(row, scratch);
+        }
+        const entry = scratch.get(cardId) ?? null;
+        if (entry) {
+            this.cards.set(cardId, entry);
+            if (this.cards.size > this.maxCards) {
+                this.cards.delete(this.cards.keys().next().value);
+            }
+        }
+        return entry;
+    }
+    reset() {
+        this.cards.clear();
+        this.offset = 0;
+        this.mtimeMs = -1;
+        this.partial = "";
+        this.evicted = false;
+    }
+}
+//# sourceMappingURL=jsonl-card-index.js.map

package/dist/server/server/agent/lifecycle-command.d.ts

@@ -11,6 +11,11 @@ export interface LifecycleAgentManager {
     archiveAgent(agentId: string): Promise<{
         archivedAt: string;
     }>;
+    markLiveAgentArchived(agentId: string): Promise<{
+        archivedAt: string;
+    }>;
+    completeLiveAgentArchive(agentId: string): Promise<void>;
+    scheduleArchiveTeardown(agentId: string): Promise<Error | null>;
     archiveSnapshot(agentId: string, archivedAt: string): Promise<StoredAgentRecord>;
     closeAgent(agentId: string): Promise<void>;
     setLabels(agentId: string, labels: Record<string, string>): Promise<void>;
@@ -45,8 +50,20 @@ export interface ArchiveAgentResult {
     agentId: string;
     archivedAt: string;
     record: StoredAgentRecord;
+    /**
+     * Archiving the agent's subagents. Already settled unless `deferTeardown` was
+     * set. Resolves to the error when it failed, never
+     * rejects: the archive itself is already durable.
+     */
+    teardown: Promise<Error | null>;
 }
-export declare function archiveAgentCommand(dependencies: AgentLifecycleCommandDependencies, agentId: string): Promise<ArchiveAgentResult>;
+export declare function archiveAgentCommand(dependencies: AgentLifecycleCommandDependencies, agentId: string, options?: {
+    /**
+     * Return once the agent is stopped, archived and closed, leaving the cascade
+     * to its subagents running in `teardown`.
+     */
+    deferTeardown?: boolean;
+}): Promise<ArchiveAgentResult>;
 export declare function closeAgentCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, agentId: string): Promise<void>;
 export interface UpdateAgentResult {
     accepted: boolean;

package/dist/server/server/agent/lifecycle-command.js

@@ -22,10 +22,28 @@ export async function cancelAgentRunCommand(dependencies, agentId) {
         cancelled,
     };
 }
-export async function archiveAgentCommand(dependencies, agentId) {
+export async function archiveAgentCommand(dependencies, agentId, options) {
     const liveAgent = dependencies.agentManager.getAgent(agentId);
     let record;
-    if (liveAgent) {
+    let teardown = Promise.resolve(null);
+    if (liveAgent && options?.deferTeardown) {
+        // The agent itself is stopped, archived and closed BEFORE replying, exactly
+        // as without deferral, so the reply and every later request see a closed,
+        // archived agent. Only archiving its subagents (a walk over every stored
+        // record, then one archive per child) is deferred.
+        await cancelAgentRunCommand(dependencies, agentId);
+        await dependencies.agentManager.clearAgentAttention(agentId).catch(() => undefined);
+        await dependencies.agentManager.markLiveAgentArchived(agentId);
+        await dependencies.agentManager.closeAgent(agentId);
+        record = await dependencies.agentStorage.get(agentId);
+        teardown = dependencies.agentManager.scheduleArchiveTeardown(agentId).then((error) => {
+            if (error) {
+                dependencies.logger.error({ err: error, agentId }, "Archived agent teardown failed; the archive itself is persisted");
+            }
+            return error;
+        });
+    }
+    else if (liveAgent) {
         await cancelAgentRunCommand(dependencies, agentId);
         await dependencies.agentManager.clearAgentAttention(agentId).catch(() => undefined);
         await dependencies.agentManager.archiveAgent(agentId);
@@ -44,6 +62,7 @@ export async function archiveAgentCommand(dependencies, agentId) {
         agentId,
         archivedAt: record.archivedAt,
         record,
+        teardown,
     };
 }
 export async function closeAgentCommand(dependencies, agentId) {

package/dist/server/server/agent/mcp-shared.d.ts

@@ -243,5 +243,6 @@ export declare function toScheduleSummary(schedule: z.infer<typeof StoredSchedul
     pausedAt: string | null;
     expiresAt: string | null;
     maxRuns: number | null;
+    droppedRunCount?: number | undefined;
 };
 //# sourceMappingURL=mcp-shared.d.ts.map

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

@@ -70,6 +70,8 @@ export interface AgentManagerProviderState {
 }
 export declare class ProviderSnapshotManager {
     private readonly snapshots;
+    /** Last snapshot pushed per cwd key, so an unchanged snapshot is not re-broadcast. */
+    private readonly lastEmittedFingerprintByCwd;
     private readonly providerLoads;
     private readonly events;
     private destroyed;
@@ -137,6 +139,13 @@ export declare class ProviderSnapshotManager {
     destroy(): void;
     private buildRegistry;
     private resolveParent;
+    /**
+     * The global snapshot as it stands, WITHOUT starting a load. Every read
+     * through `listProviders` / `getSnapshot` warms a cold snapshot, and a global
+     * warm-up is pushed to every connected client; background work that can live
+     * without an answer uses this instead.
+     */
+    peekGlobalProviders(): ProviderSnapshotEntry[];
     private getSnapshotForTarget;
     private getReadyProvider;
     private requireProvider;

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

@@ -37,6 +37,8 @@ function resolveDiagnosticTimeoutMs(option, refreshTimeoutMs) {
 export class ProviderSnapshotManager {
     constructor(options) {
         this.snapshots = new Map();
+        /** Last snapshot pushed per cwd key, so an unchanged snapshot is not re-broadcast. */
+        this.lastEmittedFingerprintByCwd = new Map();
         this.providerLoads = new Map();
         this.events = new EventEmitter();
         this.destroyed = false;
@@ -165,6 +167,17 @@ export class ProviderSnapshotManager {
             if (trimmed) {
                 return trimmed;
             }
+            // The global snapshot first, for providers whose catalog does not depend on
+            // the cwd: a new worktree has no snapshot yet, and waiting for one meant
+            // create_agent sat behind every provider CLI listing its models. Providers
+            // that read project config (opencode, ACP, pi) keep the cwd snapshot, so a
+            // project-level default model is still honoured.
+            if (CWD_INDEPENDENT_CATALOG_PROVIDERS.has(input.provider)) {
+                const globalEntry = this.peekGlobalProviders().find((entry) => entry.provider === input.provider);
+                if (globalEntry?.enabled && globalEntry.status === "ready" && globalEntry.models?.length) {
+                    return (globalEntry.models.find((model) => model.isDefault) ?? globalEntry.models[0]).id;
+                }
+            }
             const models = await this.listModels({
                 provider: input.provider,
                 cwd: input.cwd ? expandTilde(input.cwd) : undefined,
@@ -347,6 +360,16 @@ export class ProviderSnapshotManager {
             }),
         };
     }
+    /**
+     * The global snapshot as it stands, WITHOUT starting a load. Every read
+     * through `listProviders` / `getSnapshot` warms a cold snapshot, and a global
+     * warm-up is pushed to every connected client; background work that can live
+     * without an answer uses this instead.
+     */
+    peekGlobalProviders() {
+        const snapshot = this.snapshots.get(GLOBAL_PROVIDER_SNAPSHOT_KEY);
+        return snapshot ? entriesToArray(snapshot) : [];
+    }
     getSnapshotForTarget(target) {
         const providersToWarm = this.resolveProvidersToWarm(target.snapshotCwd);
         if (providersToWarm.length > 0) {
@@ -635,7 +658,16 @@ export class ProviderSnapshotManager {
         if (!snapshot) {
             return;
         }
-        this.events.emit("change", entriesToArray(snapshot), cwdKey);
+        const entries = entriesToArray(snapshot);
+        // Every listener serializes and pushes the whole snapshot to its client, so
+        // an update that changes nothing (a reload that returns the same catalog, a
+        // reset of an already-loading entry) is dropped here.
+        const fingerprint = JSON.stringify(entries);
+        if (this.lastEmittedFingerprintByCwd.get(cwdKey) === fingerprint) {
+            return;
+        }
+        this.lastEmittedFingerprintByCwd.set(cwdKey, fingerprint);
+        this.events.emit("change", entries, cwdKey);
     }
     getOrCreateSnapshot(cwdKey) {
         const existing = this.snapshots.get(cwdKey);
@@ -726,6 +758,11 @@ function createFetchCatalogOptions(scope, force) {
         ? { scope: "global", force }
         : { scope: "workspace", cwd: scope.cwd, force };
 }
+/**
+ * Providers whose `fetchCatalog` ignores the workspace scope (see opencode,
+ * acp and pi, which read project config from the cwd and are NOT listed here).
+ */
+const CWD_INDEPENDENT_CATALOG_PROVIDERS = new Set(["claude", "codex"]);
 export function isGlobalProviderSnapshotKey(cwd) {
     return cwd === GLOBAL_PROVIDER_SNAPSHOT_KEY;
 }

package/dist/server/server/agent/structured-generation-providers.d.ts

@@ -16,8 +16,9 @@ export interface StructuredGenerationProviderIdentifier {
 }
 export declare const DEFAULT_STRUCTURED_GENERATION_PROVIDERS: readonly StructuredGenerationProviderIdentifier[];
 export interface ResolveStructuredGenerationProvidersOptions {
+    /** The agent's cwd; read only when the global snapshot has nothing usable yet. */
     cwd: string;
-    providerSnapshotManager: Pick<ProviderSnapshotManager, "listProviders">;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "listProviders"> & Partial<Pick<ProviderSnapshotManager, "peekGlobalProviders">>;
     daemonConfig?: StructuredGenerationDaemonConfig | null;
     currentSelection?: {
         provider?: AgentProvider | null;

package/dist/server/server/agent/structured-generation-providers.js

@@ -11,19 +11,28 @@ export async function resolveStructuredGenerationProviders(options) {
         if (explicitProviders.length === configuredProviders.length) {
             return dedupeProviders(explicitProviders);
         }
-        const providerEntries = await options.providerSnapshotManager.listProviders({
-            cwd: options.cwd,
-            wait: false,
-        });
+        const providerEntries = peekGlobal(options) ??
+            (await options.providerSnapshotManager.listProviders({
+                cwd: options.cwd,
+                wait: false,
+            }));
         const providers = resolveConfiguredProviders(configuredProviders, providerEntries);
         if (providers.length > 0) {
             return dedupeProviders(providers);
         }
     }
-    const providerEntries = await options.providerSnapshotManager.listProviders({
-        cwd: options.cwd,
-        wait: true,
-    });
+    // Background generation (digests, titles, branch names) only needs to know
+    // which models exist. Peek at the global snapshot WITHOUT starting a load (a
+    // global load is pushed to every client); only when it has nothing usable yet,
+    // read the agent's cwd snapshot as before, whose updates go only to clients
+    // that asked for that cwd.
+    let providerEntries = peekGlobal(options) ?? [];
+    if (!providerEntries.some((entry) => entry.enabled && (entry.models?.length ?? 0) > 0)) {
+        providerEntries = await options.providerSnapshotManager.listProviders({
+            cwd: options.cwd,
+            wait: true,
+        });
+    }
     const enabledEntries = providerEntries.filter((entry) => entry.enabled);
     const modelEntries = enabledEntries.filter((entry) => (entry.models?.length ?? 0) > 0);
     const entriesByProvider = new Map(enabledEntries.map((entry) => [entry.provider, entry]));
@@ -233,4 +242,8 @@ function readModelMetadataString(model, key) {
     const value = model.metadata?.[key];
     return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
+function peekGlobal(options) {
+    const entries = options.providerSnapshotManager.peekGlobalProviders?.() ?? [];
+    return entries.some((entry) => entry.enabled && entry.status === "ready") ? entries : null;
+}
 //# sourceMappingURL=structured-generation-providers.js.map

package/dist/server/server/fleet/decision-service.d.ts

@@ -17,11 +17,19 @@ export interface DecisionServiceOptions {
 export declare class LoopDecisionService {
     private readonly dir;
     private readonly now;
+    /**
+     * Parsed decisions keyed by the directory's mtime. Every create/resolve is an
+     * atomic rename into the directory, which bumps its mtime, so one stat decides
+     * whether the listing is still current. A list used to readdir and re-parse
+     * every file, synchronously, on each RPC.
+     */
+    private cached;
     constructor(options: DecisionServiceOptions);
     private pathFor;
     private writeAtomic;
     create(input: CreateLoopDecisionInput): LoopDecision;
     private readAll;
+    private readAllFromDisk;
     /**
      * The inbox. Expiry is applied on read so a decision cannot appear pending after its
      * clock ran out just because no tick happened to fire.

package/dist/server/server/fleet/decision-service.js

@@ -1,9 +1,16 @@
 import { randomUUID } from "node:crypto";
-import { mkdirSync, readFileSync, readdirSync, writeFileSync, renameSync } from "node:fs";
+import { mkdirSync, readFileSync, readdirSync, statSync, writeFileSync, renameSync } from "node:fs";
 import { join } from "node:path";
 import { assertDecisionIsSound, isDecisionPending, LoopDecisionSchema, sortDecisionsByUrgency, } from "@hyperdrive.bot/fleet-protocol/fleet/decisions";
 export class LoopDecisionService {
     constructor(options) {
+        /**
+         * Parsed decisions keyed by the directory's mtime. Every create/resolve is an
+         * atomic rename into the directory, which bumps its mtime, so one stat decides
+         * whether the listing is still current. A list used to readdir and re-parse
+         * every file, synchronously, on each RPC.
+         */
+        this.cached = null;
         this.dir = join(options.paseoHome, "fleet", "decisions");
         this.now = options.now ?? (() => new Date());
     }
@@ -16,6 +23,7 @@ export class LoopDecisionService {
         const temp = `${target}.tmp`;
         writeFileSync(temp, JSON.stringify(decision, null, 2), "utf8");
         renameSync(temp, target);
+        this.cached = null;
     }
     create(input) {
         // Unsound decisions are refused here, before a human can ever see one.
@@ -50,6 +58,21 @@ export class LoopDecisionService {
         return decision;
     }
     readAll() {
+        let mtimeMs;
+        try {
+            mtimeMs = statSync(this.dir).mtimeMs;
+        }
+        catch {
+            return [];
+        }
+        if (this.cached && this.cached.mtimeMs === mtimeMs) {
+            return [...this.cached.decisions];
+        }
+        const decisions = this.readAllFromDisk();
+        this.cached = { mtimeMs, decisions };
+        return [...decisions];
+    }
+    readAllFromDisk() {
         let names;
         try {
             names = readdirSync(this.dir);

package/dist/server/server/fleet/fleet-controls.js

@@ -1,7 +1,7 @@
 import { spawn, execFileSync } from "node:child_process";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { LOOP_PARAMS_VALUES_FILE } from "./fleet-reader.js";
+import { LOOP_PARAMS_VALUES_FILE, rememberCrontab } from "./fleet-reader.js";
 import { validateLoopParams, } from "@hyperdrive.bot/fleet-protocol/fleet/params";
 import { applyModeToCommand, defaultSystemdUnitDir, loopRunnerRegExp, parseModeFromCommand, PAUSE_MARKER, SystemdUserScheduler, } from "./fleet-scheduler.js";
 function resolveRunScript(dir) {
@@ -55,6 +55,7 @@ function readCrontabText() {
 }
 function writeCrontabText(content) {
     execFileSync("crontab", ["-"], { input: content });
+    rememberCrontab(content);
 }
 function backupCrontab(paseoHome, content, now) {
     const dir = join(paseoHome, "fleet", "crontab-backups");

package/dist/server/server/fleet/fleet-reader.d.ts

@@ -79,6 +79,18 @@ export declare function discoverLoopDirs(loopsDir: string): Array<{
 }>;
 /** Parse `crontab -l` into name → {cadence, mode} by matching run(-poll).sh paths. */
 export declare function parseCrontab(crontab: string): Map<string, CronEntry>;
+/**
+ * `crontab -l` is a fork of the whole daemon, and it ran synchronously on every
+ * Loops list. Text younger than CRONTAB_CACHE_TTL_MS is served as is; between
+ * that and CRONTAB_MAX_STALE_MS it is served once while an async refresh runs;
+ * older than that (the first list after a long idle) is read synchronously.
+ * The daemon's own crontab writes replace the cache and void any refresh that
+ * started before them (`rememberCrontab`).
+ */
+export declare const CRONTAB_CACHE_TTL_MS = 5000;
+export declare const CRONTAB_MAX_STALE_MS = 60000;
+/** Record crontab text the daemon just wrote, or drop the cache with no argument. */
+export declare function rememberCrontab(text?: string): void;
 /** File names a loop uses to declare and store its parameters. */
 export declare const LOOP_PARAMS_SCHEMA_FILE = "params.schema.json";
 export declare const LOOP_PARAMS_VALUES_FILE = "params.json";

package/dist/server/server/fleet/fleet-reader.js

@@ -15,7 +15,7 @@
  */
 import { readdirSync, readFileSync, statSync, existsSync } from "node:fs";
 import { join } from "node:path";
-import { execFileSync } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { defaultSystemdUnitDir, PAUSE_MARKER, SystemdUserScheduler, } from "./fleet-scheduler.js";
@@ -141,7 +141,21 @@ export function parseCrontab(crontab) {
     }
     return map;
 }
-function readCrontab() {
+/**
+ * `crontab -l` is a fork of the whole daemon, and it ran synchronously on every
+ * Loops list. Text younger than CRONTAB_CACHE_TTL_MS is served as is; between
+ * that and CRONTAB_MAX_STALE_MS it is served once while an async refresh runs;
+ * older than that (the first list after a long idle) is read synchronously.
+ * The daemon's own crontab writes replace the cache and void any refresh that
+ * started before them (`rememberCrontab`).
+ */
+export const CRONTAB_CACHE_TTL_MS = 5000;
+export const CRONTAB_MAX_STALE_MS = 60000;
+let crontabCache = null;
+let crontabRefresh = null;
+/** Bumped by every write; a refresh started under an older generation is dropped. */
+let crontabGeneration = 0;
+function readCrontabNow() {
     try {
         return execFileSync("crontab", ["-l"], { encoding: "utf8" });
     }
@@ -149,6 +163,38 @@ function readCrontab() {
         return "";
     }
 }
+function refreshCrontabInBackground() {
+    if (crontabRefresh)
+        return;
+    const generation = crontabGeneration;
+    crontabRefresh = new Promise((resolve) => {
+        execFile("crontab", ["-l"], { encoding: "utf8" }, (error, stdout) => {
+            if (generation === crontabGeneration) {
+                crontabCache = { text: error ? "" : stdout, readAt: Date.now() };
+            }
+            resolve();
+        });
+    }).finally(() => {
+        crontabRefresh = null;
+    });
+}
+function readCrontab() {
+    const now = Date.now();
+    const age = crontabCache ? now - crontabCache.readAt : Infinity;
+    if (!crontabCache || age >= CRONTAB_MAX_STALE_MS) {
+        crontabCache = { text: readCrontabNow(), readAt: now };
+        return crontabCache.text;
+    }
+    if (age >= CRONTAB_CACHE_TTL_MS) {
+        refreshCrontabInBackground();
+    }
+    return crontabCache.text;
+}
+/** Record crontab text the daemon just wrote, or drop the cache with no argument. */
+export function rememberCrontab(text) {
+    crontabGeneration += 1;
+    crontabCache = text === undefined ? null : { text, readAt: Date.now() };
+}
 /** File names a loop uses to declare and store its parameters. */
 export const LOOP_PARAMS_SCHEMA_FILE = "params.schema.json";
 export const LOOP_PARAMS_VALUES_FILE = "params.json";

package/dist/server/server/schedule/service.d.ts

@@ -115,6 +115,8 @@ export declare class ScheduleService {
      * neither can be fresh while the other is stale.
      */
     private agentScheduleFacts;
+    /** Store version the facts above were built from. */
+    private agentScheduleFactsVersion;
     constructor(options: ScheduleServiceOptions);
     /**
      * The daemon's one runs/day limiter, or undefined when the ledger is.
@@ -140,6 +142,8 @@ export declare class ScheduleService {
      * listing, so a caller can never get one refreshed and the other stale.
      */
     listAgentScheduleFacts(): Promise<AgentScheduleFacts>;
+    /** Rebuild the facts index only when the store changed since the last build. */
+    private refreshAgentScheduleFacts;
     /**
      * Synchronous read of the cached next-fire index, for the projection paths that
      * are not async and cannot await a store read.

package/dist/server/server/schedule/service.js

@@ -101,7 +101,8 @@ function normalizeMaxRuns(value) {
     return value;
 }
 function countCompletedRuns(schedule) {
-    return schedule.runs.filter((run) => run.status !== "running").length;
+    // Runs trimmed by the retention cap still count toward maxRuns.
+    return (schedule.runs.filter((run) => run.status !== "running").length + (schedule.droppedRunCount ?? 0));
 }
 function shouldCompleteSchedule(schedule, now) {
     if (schedule.expiresAt && new Date(schedule.expiresAt).getTime() <= now.getTime()) {
@@ -209,6 +210,8 @@ export class ScheduleService {
          * neither can be fresh while the other is stale.
          */
         this.agentScheduleFacts = null;
+        /** Store version the facts above were built from. */
+        this.agentScheduleFactsVersion = -1;
         this.store = new ScheduleStore(join(options.paseoHome, "schedules"));
         this.logger = options.logger.child({ module: "schedule-service" });
         this.agentManager = options.agentManager;
@@ -237,6 +240,15 @@ export class ScheduleService {
         return this.capLimiter;
     }
     async start() {
+        try {
+            const removed = await this.store.sweepOrphanedTempFiles();
+            if (removed > 0) {
+                this.logger.info({ removed }, "Removed orphaned schedule temp files");
+            }
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to sweep orphaned schedule temp files");
+        }
         await this.recoverInterruptedRuns();
         // Ingestion ledger maintenance. Order matters: release first, so a claim stranded by a
         // crash records its failure and refreshes last_fail_at, then prune, so a row released
@@ -361,8 +373,17 @@ export class ScheduleService {
      * listing, so a caller can never get one refreshed and the other stale.
      */
     async listAgentScheduleFacts() {
-        const facts = indexAgentScheduleFacts(await this.store.list());
+        const schedules = await this.store.list();
+        return this.refreshAgentScheduleFacts(schedules);
+    }
+    /** Rebuild the facts index only when the store changed since the last build. */
+    refreshAgentScheduleFacts(schedules) {
+        if (this.agentScheduleFacts && this.agentScheduleFactsVersion === this.store.version) {
+            return this.agentScheduleFacts;
+        }
+        const facts = indexAgentScheduleFacts(schedules);
         this.agentScheduleFacts = facts;
+        this.agentScheduleFactsVersion = this.store.version;
         return facts;
     }
     /**
@@ -510,9 +531,9 @@ export class ScheduleService {
     async tick() {
         const now = this.now();
         const schedules = await this.store.list();
-        // The tick already paid for the store read, so keep the projection cache warm
-        // off the same list rather than re-reading disk on every agent-list build.
-        this.agentScheduleFacts = indexAgentScheduleFacts(schedules);
+        // Keep the projection cache warm off the same list; a no-op unless the
+        // store changed since the last build.
+        this.refreshAgentScheduleFacts(schedules);
         for (const schedule of schedules) {
             if (schedule.status !== "active" || !schedule.nextRunAt) {
                 continue;