@hyperdrive.bot/fleet-server 0.3.164 → 0.3.166

package/dist/server/extensions/daemon-backend.js

@@ -8,6 +8,7 @@
  */
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { stateDbFor } from "../server/state/state-db.js";
 const STATUS_POLL_INTERVAL_MS = 2000;
 function mapStatus(agent) {
     if (agent.pendingPermissions.size > 0)
@@ -57,7 +58,19 @@ export function createDaemonExtensionBackend(deps) {
         .listAgents()
         .filter((agent) => !agent.internal)
         .map((agent) => toSummary(agent, serverId));
+    // Extension storage lives in state.sqlite's `extension_kv` (one row per
+    // extension and key) when the daemon has it; the per-extension JSON file is
+    // mirrored. Without it, the file is the store, as before.
+    const stateDb = stateDbFor(paseoHome);
+    const kv = stateDb?.doc("extension_kv") ?? null;
     async function readStore(extensionId) {
+        if (kv) {
+            const store = {};
+            for (const row of kv.loadAll(extensionId)) {
+                store[row.id] = JSON.parse(row.body);
+            }
+            return store;
+        }
         try {
             const raw = await readFile(storePath(paseoHome, extensionId), "utf8");
             return JSON.parse(raw);
@@ -120,6 +133,18 @@ export function createDaemonExtensionBackend(deps) {
                 return store[key];
             },
             set: async (extensionId, key, value) => {
+                if (kv && stateDb) {
+                    await kv.put(extensionId, key, value ?? null);
+                    const file = storePath(paseoHome, extensionId);
+                    stateDb.mirror.write(`extension-kv:${file}`, async () => {
+                        const rev = stateDb.mirrorRev();
+                        const store = await readStore(extensionId);
+                        await mkdir(path.dirname(file), { recursive: true });
+                        await writeFile(file, JSON.stringify(store, null, 2));
+                        await stateDb.manifest.record("extension_kv", file, rev);
+                    });
+                    return;
+                }
                 const store = await readStore(extensionId);
                 store[key] = value;
                 const file = storePath(paseoHome, extensionId);

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

@@ -3,6 +3,7 @@ import type { Logger } from "pino";
 import { type SessionDigest } from "../messages.js";
 import type { ManagedAgent } from "./agent-manager.js";
 import type { AgentSessionConfig } from "./agent-sdk-types.js";
+import type { ChangedRow } from "../state/state-db.js";
 declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     id: z.ZodString;
     provider: z.ZodString;
@@ -172,18 +173,30 @@ export declare const SERIALIZABLE_CONFIG_KEYS: ReadonlyArray<keyof SerializableA
 export type SerializableAgentConfig = Pick<AgentSessionConfig, "modeId" | "model" | "thinkingOptionId" | "featureValues" | "extra" | "systemPrompt" | "outputLanguage" | "goal" | "jobToBeDone" | "mcpServers" | "allowedTools">;
 export type StoredAgentRecord = z.infer<typeof STORED_AGENT_SCHEMA>;
 export declare function parseStoredAgentRecord(value: unknown): StoredAgentRecord;
+/**
+ * Where agent records are durably kept. Two implementations: the legacy
+ * per-agent JSON files (`FileAgentRecordBackend`) and `state.sqlite`
+ * (`state/agent-state.ts`). `AgentStorage` keeps the in-memory Map as the only
+ * read path either way; a backend is only loaded once and then written to.
+ */
+export interface AgentRecordBackend {
+    loadAll(): Promise<StoredAgentRecord[]>;
+    /** `previous` is the record this one replaces, when there was one. */
+    write(record: StoredAgentRecord, previous: StoredAgentRecord | null): Promise<void>;
+    remove(agentId: string, previous: StoredAgentRecord | null): Promise<void>;
+    /** Changes since a daemon-wide revision, or null when the backend has no revisions. */
+    listChangedSince?(rev: number, limit?: number): ChangedRow[] | null;
+}
 export declare class AgentStorage {
     private cache;
-    private pathById;
-    private pathsById;
     private pendingWrites;
     private deleting;
     private loaded;
-    private baseDir;
     private loadPromise;
     private logger;
+    private readonly backend;
     private readonly changeListeners;
-    constructor(baseDir: string, logger: Logger);
+    constructor(baseDir: string, logger: Logger, backend?: AgentRecordBackend);
     /**
      * Called after a record lands in (or leaves) the cache, so a listener that
      * reads the record back sees the new state. Feeds the agent directory
@@ -194,6 +207,11 @@ export declare class AgentStorage {
     initialize(): Promise<void>;
     list(): Promise<StoredAgentRecord[]>;
     get(agentId: string): Promise<StoredAgentRecord | null>;
+    /**
+     * Agent rows changed after `rev` (tombstones included), oldest first. Null on
+     * the file backend, which has no revisions. Internal until the delta protocol.
+     */
+    listChangedSince(rev: number, limit?: number): ChangedRow[] | null;
     upsert(record: StoredAgentRecord): Promise<void>;
     private queueRecordWrite;
     private writeRecord;
@@ -203,24 +221,61 @@ export declare class AgentStorage {
         title?: string | null;
         internal?: boolean;
     }): Promise<void>;
+    /**
+     * Read-modify-write of one stored agent inside its write queue. `build` gets
+     * the latest record (after every earlier write for the agent landed) and
+     * returns the next one, or null to leave it untouched. Resolves with what was
+     * written, or null.
+     */
+    update(agentId: string, build: (record: StoredAgentRecord) => StoredAgentRecord | null): Promise<StoredAgentRecord | null>;
     setTitle(agentId: string, title: string): Promise<void>;
     setGeneratedTitle(agentId: string, title: string): Promise<StoredAgentRecord>;
     /**
-     * Targeted digest-only update. Drains pending writes, reads the latest record,
-     * and updates ONLY the digest field — so an async digest refresh can never
-     * clobber a concurrent title/label write (which a full-record persist would).
-     * Mirrors setGeneratedTitle. See docs/session-digest.md §5.
+     * Targeted digest-only update. Reads the latest record inside the per-agent
+     * write queue and updates ONLY the digest field, so an async digest refresh
+     * can never clobber a concurrent title/label write (which a full-record
+     * persist would). See docs/session-digest.md §5.
      */
     setDigest(agentId: string, digest: SessionDigest): Promise<StoredAgentRecord>;
+    /**
+     * Read-modify-write inside the per-agent write queue. The read happens when
+     * the previous write for this agent has landed, so two updates racing (an
+     * archive teardown persisting its final snapshot while the user renames the
+     * agent) can no longer both start from the same old record and have the later
+     * one silently drop the earlier one's change.
+     */
+    private queueRecordUpdate;
     flush(): Promise<void>;
     private load;
     private doLoad;
-    private scanDisk;
-    private readRecordFile;
-    private buildRecordPath;
+}
+/**
+ * The legacy layout: one `<baseDir>/<project-dir>/<agentId>.json` per agent.
+ * Also what the sqlite backend mirrors to, so it must work without a prior
+ * `loadAll` (the mirror never scans): a path it has not indexed is derived from
+ * the previous record's cwd.
+ */
+export declare class FileAgentRecordBackend implements AgentRecordBackend {
+    private readonly baseDir;
+    private readonly logger;
+    private readonly observer?;
+    private pathById;
+    private pathsById;
+    constructor(baseDir: string, logger: Logger, observer?: {
+        written(filePath: string): Promise<void>;
+        removed(filePath: string): Promise<void>;
+    } | undefined);
+    /** Tell the backend a file for `agentId` exists (the sqlite mirror seeds this from its manifest). */
+    indexPath(agentId: string, filePath: string): void;
+    loadAll(): Promise<StoredAgentRecord[]>;
+    write(record: StoredAgentRecord, previous: StoredAgentRecord | null): Promise<void>;
+    remove(agentId: string, previous: StoredAgentRecord | null): Promise<void>;
     private addIndexedPath;
     private removeIndexedPath;
-    private waitForPendingWrite;
 }
+/** Every `*.json` directly under `baseDir` or one project directory below it. */
+export declare function listAgentRecordFiles(baseDir: string): Promise<string[]>;
+export declare function readAgentRecordFile(filePath: string, logger: Logger): Promise<StoredAgentRecord | null>;
+export declare function agentRecordPath(baseDir: string, record: StoredAgentRecord): string;
 export {};
 //# sourceMappingURL=agent-storage.d.ts.map

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

@@ -90,17 +90,15 @@ export function parseStoredAgentRecord(value) {
     return STORED_AGENT_SCHEMA.parse(value);
 }
 export class AgentStorage {
-    constructor(baseDir, logger) {
+    constructor(baseDir, logger, backend) {
         this.cache = new Map();
-        this.pathById = new Map();
-        this.pathsById = new Map();
         this.pendingWrites = new Map();
         this.deleting = new Set();
         this.loaded = false;
         this.loadPromise = null;
         this.changeListeners = new Set();
-        this.baseDir = baseDir;
         this.logger = logger.child({ module: "agent", component: "agent-storage" });
+        this.backend = backend ?? new FileAgentRecordBackend(baseDir, this.logger);
     }
     /**
      * Called after a record lands in (or leaves) the cache, so a listener that
@@ -134,6 +132,13 @@ export class AgentStorage {
         await this.load();
         return this.cache.get(agentId) ?? null;
     }
+    /**
+     * Agent rows changed after `rev` (tombstones included), oldest first. Null on
+     * the file backend, which has no revisions. Internal until the delta protocol.
+     */
+    listChangedSince(rev, limit) {
+        return this.backend.listChangedSince?.(rev, limit) ?? null;
+    }
     async upsert(record) {
         await this.load();
         await this.queueRecordWrite(record);
@@ -157,23 +162,9 @@ export class AgentStorage {
         return tracked;
     }
     async writeRecord(record) {
-        const agentId = record.id;
-        const nextPath = this.buildRecordPath(record);
-        const previousPath = this.pathById.get(agentId);
-        await writeJsonFileAtomic(nextPath, record);
-        this.addIndexedPath(agentId, nextPath);
-        if (previousPath && previousPath !== nextPath) {
-            try {
-                await fs.unlink(previousPath);
-            }
-            catch {
-                // ignore cleanup errors
-            }
-            this.removeIndexedPath(agentId, previousPath);
-        }
-        this.cache.set(agentId, record);
-        this.pathById.set(agentId, nextPath);
-        this.notifyChanged(agentId, "upsert");
+        await this.backend.write(record, this.cache.get(record.id) ?? null);
+        this.cache.set(record.id, record);
+        this.notifyChanged(record.id, "upsert");
     }
     beginDelete(agentId) {
         this.deleting.add(agentId);
@@ -182,88 +173,109 @@ export class AgentStorage {
         await this.load();
         this.beginDelete(agentId);
         await (this.pendingWrites.get(agentId) ?? Promise.resolve());
-        const paths = Array.from(this.pathsById.get(agentId) ?? []);
-        await Promise.all(paths.map(async (filePath) => {
-            try {
-                await fs.unlink(filePath);
-            }
-            catch (error) {
-                const code = error.code;
-                if (code && code !== "ENOENT") {
-                    this.logger.warn({ err: error, agentId, filePath }, "Failed to remove agent record file");
-                }
-            }
-        }));
+        await this.backend.remove(agentId, this.cache.get(agentId) ?? null);
         const existed = this.cache.delete(agentId);
-        this.pathById.delete(agentId);
-        this.pathsById.delete(agentId);
         if (existed) {
             this.notifyChanged(agentId, "remove");
         }
     }
     async applySnapshot(agent, options) {
         await this.load();
-        await this.waitForPendingWrite(agent.id);
-        const existing = (await this.get(agent.id)) ?? null;
         const hasTitleOverride = options !== undefined && Object.prototype.hasOwnProperty.call(options, "title");
         const hasInternalOverride = options !== undefined && Object.prototype.hasOwnProperty.call(options, "internal");
-        const record = toStoredAgentRecord(agent, {
-            title: hasTitleOverride ? (options?.title ?? null) : (existing?.title ?? null),
-            createdAt: existing?.createdAt,
-            internal: hasInternalOverride ? options?.internal : (agent.internal ?? existing?.internal),
+        await this.queueRecordUpdate(agent.id, (existing) => {
+            const record = toStoredAgentRecord(agent, {
+                title: hasTitleOverride ? (options?.title ?? null) : (existing?.title ?? null),
+                createdAt: existing?.createdAt,
+                internal: hasInternalOverride ? options?.internal : (agent.internal ?? existing?.internal),
+            });
+            // Preserve soft-delete/archive status across snapshot flushes.
+            // `archivedAt` is not part of the ManagedAgent snapshot, so a naive projection
+            // would wipe it during normal persistence (including on daemon restart).
+            if (existing && existing.archivedAt !== undefined) {
+                record.archivedAt = existing.archivedAt;
+            }
+            return record;
         });
-        // Preserve soft-delete/archive status across snapshot flushes.
-        // `archivedAt` is not part of the ManagedAgent snapshot, so a naive projection
-        // would wipe it during normal persistence (including on daemon restart).
-        if (existing && existing.archivedAt !== undefined) {
-            record.archivedAt = existing.archivedAt;
-        }
-        await this.upsert(record);
+    }
+    /**
+     * Read-modify-write of one stored agent inside its write queue. `build` gets
+     * the latest record (after every earlier write for the agent landed) and
+     * returns the next one, or null to leave it untouched. Resolves with what was
+     * written, or null.
+     */
+    async update(agentId, build) {
+        await this.load();
+        let skipped = false;
+        const written = await this.queueRecordUpdate(agentId, (record) => {
+            const next = record ? build(record) : null;
+            if (!next) {
+                skipped = true;
+                // Nothing to write: hand the queue the current record untouched.
+                return record;
+            }
+            return next;
+        }, () => skipped);
+        return skipped ? null : written;
     }
     async setTitle(agentId, title) {
         await this.load();
-        await this.waitForPendingWrite(agentId);
-        const record = await this.get(agentId);
-        if (!record) {
-            throw new Error(`Agent ${agentId} not found`);
-        }
-        await this.upsert({ ...record, title });
+        await this.queueRecordUpdate(agentId, (record) => {
+            if (!record) {
+                throw new Error(`Agent ${agentId} not found`);
+            }
+            return { ...record, title };
+        });
     }
     async setGeneratedTitle(agentId, title) {
         await this.load();
-        await this.waitForPendingWrite(agentId);
-        const record = this.cache.get(agentId) ?? null;
-        if (!record) {
-            throw new Error(`Agent ${agentId} not found`);
-        }
-        const nextRecord = {
-            ...record,
-            title,
-            updatedAt: new Date().toISOString(),
-        };
-        await this.queueRecordWrite(nextRecord);
-        return nextRecord;
+        return this.queueRecordUpdate(agentId, (record) => {
+            if (!record) {
+                throw new Error(`Agent ${agentId} not found`);
+            }
+            return { ...record, title, updatedAt: new Date().toISOString() };
+        });
     }
     /**
-     * Targeted digest-only update. Drains pending writes, reads the latest record,
-     * and updates ONLY the digest field — so an async digest refresh can never
-     * clobber a concurrent title/label write (which a full-record persist would).
-     * Mirrors setGeneratedTitle. See docs/session-digest.md §5.
+     * Targeted digest-only update. Reads the latest record inside the per-agent
+     * write queue and updates ONLY the digest field, so an async digest refresh
+     * can never clobber a concurrent title/label write (which a full-record
+     * persist would). See docs/session-digest.md §5.
      */
     async setDigest(agentId, digest) {
         await this.load();
-        await this.waitForPendingWrite(agentId);
-        const record = this.cache.get(agentId) ?? null;
-        if (!record) {
-            throw new Error(`Agent ${agentId} not found`);
-        }
-        const nextRecord = {
-            ...record,
-            digest,
-            updatedAt: new Date().toISOString(),
-        };
-        await this.queueRecordWrite(nextRecord);
-        return nextRecord;
+        return this.queueRecordUpdate(agentId, (record) => {
+            if (!record) {
+                throw new Error(`Agent ${agentId} not found`);
+            }
+            return { ...record, digest, updatedAt: new Date().toISOString() };
+        });
+    }
+    /**
+     * Read-modify-write inside the per-agent write queue. The read happens when
+     * the previous write for this agent has landed, so two updates racing (an
+     * archive teardown persisting its final snapshot while the user renames the
+     * agent) can no longer both start from the same old record and have the later
+     * one silently drop the earlier one's change.
+     */
+    queueRecordUpdate(agentId, build, skip = () => false) {
+        let built = null;
+        const prev = (this.pendingWrites.get(agentId) ?? Promise.resolve()).catch(() => undefined);
+        const next = prev.then(async () => {
+            built = build(this.cache.get(agentId) ?? null);
+            if (skip() || this.deleting.has(agentId)) {
+                return undefined;
+            }
+            await this.writeRecord(built);
+            return undefined;
+        });
+        const tracked = next.finally(() => {
+            if (this.pendingWrites.get(agentId) === tracked) {
+                this.pendingWrites.delete(agentId);
+            }
+        });
+        this.pendingWrites.set(agentId, tracked);
+        return tracked.then(() => built);
     }
     async flush() {
         await this.load().catch(() => undefined);
@@ -281,10 +293,11 @@ export class AgentStorage {
     }
     async doLoad() {
         this.cache.clear();
-        this.pathById.clear();
-        this.pathsById.clear();
         try {
-            const records = await this.scanDisk();
+            const records = await this.backend.loadAll();
+            for (const record of records) {
+                this.cache.set(record.id, record);
+            }
             this.loaded = true;
             return records;
         }
@@ -298,65 +311,85 @@ export class AgentStorage {
             return [];
         }
     }
-    async scanDisk() {
-        const records = [];
-        let entries = [];
-        try {
-            entries = await fs.readdir(this.baseDir, { withFileTypes: true });
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return [];
-            }
-            throw error;
-        }
-        const rootRecordPaths = entries
-            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
-            .map((entry) => path.join(this.baseDir, entry.name));
-        const projectDirs = entries
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => path.join(this.baseDir, entry.name));
-        const projectFileLists = await Promise.all(projectDirs.map(async (projectDir) => {
-            try {
-                const files = await fs.readdir(projectDir, { withFileTypes: true });
-                return files
-                    .filter((file) => file.isFile() && file.name.endsWith(".json"))
-                    .map((file) => path.join(projectDir, file.name));
-            }
-            catch {
-                return [];
-            }
-        }));
-        const allFilePaths = [...rootRecordPaths, ...projectFileLists.flat()];
-        const loaded = await Promise.all(allFilePaths.map(async (filePath) => {
-            const record = await this.readRecordFile(filePath);
+}
+/**
+ * The legacy layout: one `<baseDir>/<project-dir>/<agentId>.json` per agent.
+ * Also what the sqlite backend mirrors to, so it must work without a prior
+ * `loadAll` (the mirror never scans): a path it has not indexed is derived from
+ * the previous record's cwd.
+ */
+export class FileAgentRecordBackend {
+    constructor(baseDir, logger, observer) {
+        this.baseDir = baseDir;
+        this.logger = logger;
+        this.observer = observer;
+        this.pathById = new Map();
+        this.pathsById = new Map();
+    }
+    /** Tell the backend a file for `agentId` exists (the sqlite mirror seeds this from its manifest). */
+    indexPath(agentId, filePath) {
+        this.addIndexedPath(agentId, filePath);
+        if (!this.pathById.has(agentId))
+            this.pathById.set(agentId, filePath);
+    }
+    async loadAll() {
+        this.pathById.clear();
+        this.pathsById.clear();
+        const files = await listAgentRecordFiles(this.baseDir);
+        const loaded = await Promise.all(files.map(async (filePath) => {
+            const record = await readAgentRecordFile(filePath, this.logger);
             return record ? { record, filePath } : null;
         }));
+        const records = [];
         for (const item of loaded) {
             if (!item)
                 continue;
             const { record, filePath } = item;
             records.push(record);
-            this.cache.set(record.id, record);
             this.pathById.set(record.id, filePath);
             this.addIndexedPath(record.id, filePath);
         }
         return records;
     }
-    async readRecordFile(filePath) {
-        try {
-            const content = await fs.readFile(filePath, "utf8");
-            const parsed = JSON.parse(content);
-            return parseStoredAgentRecord(parsed);
-        }
-        catch (error) {
-            this.logger.error({ err: error, filePath }, "Skipping invalid agent record");
-            return null;
+    async write(record, previous) {
+        const agentId = record.id;
+        const nextPath = agentRecordPath(this.baseDir, record);
+        const previousPath = this.pathById.get(agentId) ??
+            (previous ? agentRecordPath(this.baseDir, previous) : undefined);
+        await writeJsonFileAtomic(nextPath, record);
+        this.addIndexedPath(agentId, nextPath);
+        await this.observer?.written(nextPath);
+        if (previousPath && previousPath !== nextPath) {
+            try {
+                await fs.unlink(previousPath);
+            }
+            catch {
+                // ignore cleanup errors
+            }
+            this.removeIndexedPath(agentId, previousPath);
+            await this.observer?.removed(previousPath);
         }
+        this.pathById.set(agentId, nextPath);
     }
-    buildRecordPath(record) {
-        const projectDir = projectDirNameFromCwd(record.cwd);
-        return path.join(this.baseDir, projectDir, `${record.id}.json`);
+    async remove(agentId, previous) {
+        const paths = new Set(this.pathsById.get(agentId) ?? []);
+        if (previous) {
+            paths.add(agentRecordPath(this.baseDir, previous));
+        }
+        await Promise.all(Array.from(paths).map(async (filePath) => {
+            try {
+                await fs.unlink(filePath);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code && code !== "ENOENT") {
+                    this.logger.warn({ err: error, agentId, filePath }, "Failed to remove agent record file");
+                }
+            }
+            await this.observer?.removed(filePath);
+        }));
+        this.pathById.delete(agentId);
+        this.pathsById.delete(agentId);
     }
     addIndexedPath(agentId, filePath) {
         const paths = this.pathsById.get(agentId) ?? new Set();
@@ -373,10 +406,53 @@ export class AgentStorage {
             this.pathsById.delete(agentId);
         }
     }
-    async waitForPendingWrite(agentId) {
-        await (this.pendingWrites.get(agentId) ?? Promise.resolve()).catch(() => undefined);
+}
+/** Every `*.json` directly under `baseDir` or one project directory below it. */
+export async function listAgentRecordFiles(baseDir) {
+    let entries = [];
+    try {
+        entries = await fs.readdir(baseDir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    const rootRecordPaths = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+        .map((entry) => path.join(baseDir, entry.name));
+    const projectDirs = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(baseDir, entry.name));
+    const projectFileLists = await Promise.all(projectDirs.map(async (projectDir) => {
+        try {
+            const files = await fs.readdir(projectDir, { withFileTypes: true });
+            return files
+                .filter((file) => file.isFile() && file.name.endsWith(".json"))
+                .map((file) => path.join(projectDir, file.name));
+        }
+        catch {
+            return [];
+        }
+    }));
+    return [...rootRecordPaths, ...projectFileLists.flat()];
+}
+export async function readAgentRecordFile(filePath, logger) {
+    try {
+        const content = await fs.readFile(filePath, "utf8");
+        const parsed = JSON.parse(content);
+        return parseStoredAgentRecord(parsed);
+    }
+    catch (error) {
+        logger.error({ err: error, filePath }, "Skipping invalid agent record");
+        return null;
     }
 }
+export function agentRecordPath(baseDir, record) {
+    const projectDir = projectDirNameFromCwd(record.cwd);
+    return path.join(baseDir, projectDir, `${record.id}.json`);
+}
 function projectDirNameFromCwd(cwd) {
     // path.win32.parse handles drive letters, UNC roots, and Unix roots on all platforms
     const { root } = path.win32.parse(cwd);

package/dist/server/server/agent/providers/claude/transport/pty-query.js

@@ -166,6 +166,14 @@ const INVISIBLE_STRIP_GATE_RE = /removed\d+invisiblecharacters?·(?:(reviewandpr
 const INVISIBLE_STRIP_SCAN_CHARS = 400;
 /** How long after an Enter to keep looking for the gate before trusting the reaction. */
 const INVISIBLE_STRIP_GATE_WAIT_MS = 1000;
+/**
+ * Pause between seeing the gate and pressing Enter again. The CLI ignores an Enter that
+ * lands right after it paints the gate: live on 0.3.163 paseo pressed ~30ms later and
+ * nothing was sent for six attempts (session 977f4263, 2026-09-26). Measured against
+ * claude 2.1.283 in tmux: a second Enter 30ms after the gate submitted nothing; 100ms,
+ * 200ms, 300ms and 1.5s each submitted. 500ms is five times the smallest delay that worked.
+ */
+const INVISIBLE_STRIP_SETTLE_MS = 500;
 /**
  * Code points the CLI deletes before it records a prompt, so the transcript `user` record
  * no longer contains them. Measured against claude 2.1.283 by pasting each candidate into a
@@ -948,6 +956,7 @@ export class PtyQuery {
         await pollUntil(() => this.invisibleStripGateAt > enterAt, INVISIBLE_STRIP_GATE_WAIT_MS, 100);
         if (this.invisibleStripGateAt > enterAt && !this.invisibleStripEmpty) {
             this.recordLine("--- CLI stripped invisible characters from the answer; pressing Enter again ---");
+            await delay(INVISIBLE_STRIP_SETTLE_MS);
             await this.transport.writeRaw?.("\r");
         }
         // Same reason as sendDialogAnswer: with more than one question the picker advances
@@ -1516,6 +1525,7 @@ export class PtyQuery {
         }
         this.recordLine("--- CLI stripped invisible characters and is waiting; pressing Enter again ---");
         this.logger.info({ sessionId: this.sessionId }, "PtyQuery: CLI held the prompt after stripping invisible characters; confirming");
+        await delay(INVISIBLE_STRIP_SETTLE_MS);
         await this.transport.writeRaw?.("\r");
         return "pressed";
     }

package/dist/server/server/bootstrap.d.ts

@@ -148,6 +148,11 @@ export interface PaseoDaemon {
     browserToolsBroker: BrowserToolsBroker;
     start(): Promise<void>;
     stop(): Promise<void>;
+    /**
+     * First thing on SIGTERM/SIGINT: commit queued state writes and start every
+     * pending legacy file write, before the slower service teardown.
+     */
+    beginStateShutdown(): void;
     getListenTarget(): ListenTarget | null;
 }
 /**