@cursor/bdk 0.2.10 → 0.2.12

package/dist/internal/session-live-publisher.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Publishes session events to the managed live relay (`session.live`) so the
+ * playground, the session view, and the CLI can show a hosted turn while it
+ * runs. The on-disk event log and the storage coordinator stay the durable
+ * path; this is a best-effort copy for viewers.
+ *
+ * The relay keeps events only while a viewer watches. Unwatched, a session
+ * sends a small probe at most once per `recheckAfterMs` window and nothing
+ * else. Once a viewer watches, events go out in short batches, and when the
+ * relay reports a gap (`replayFromIndex`) the missing events are reread from
+ * the local log and resent.
+ *
+ * Publishing can never slow or fail a turn: {@link SessionLivePublisher.event}
+ * is synchronous, requests time out quickly, queues are bounded, a failed
+ * batch is dropped, and repeated failures pause the session. A 404 means the
+ * backend predates the relay and turns publishing off for the process.
+ */
+import type { SessionEvent } from "../types.js";
+import { type CursorApiTransportOptions } from "./cursor/cursor-api-transport.js";
+import { type SessionLiveEventWire } from "./store-api-protocol.js";
+/** How long events collect before a batch goes out. */
+export declare const SESSION_LIVE_BATCH_WINDOW_MS = 150;
+export interface SessionLivePublisherOptions extends CursorApiTransportOptions {
+    /** Local events from `fromIndex` on, for replays. */
+    readEvents(sessionId: string, fromIndex: number): Promise<SessionEvent[]>;
+    /** Whether the managed store API is bound; defaults to the pod's store pin. */
+    isEnabled?: () => boolean;
+    logger?: (line: string) => void;
+    now?: () => number;
+}
+export interface SessionLivePublisher {
+    /** Offer one appended event. Never throws and never waits. */
+    event(event: SessionEvent): void;
+    close(): void;
+}
+/**
+ * The event as it crosses the live wire. Delta events drop the accumulated
+ * `text` (viewers rebuild it from deltas), and an event over the per-event
+ * cap keeps only its envelope, marked `liveTruncated`.
+ */
+export declare function toSessionLiveWire(event: SessionEvent): {
+    wire: SessionLiveEventWire;
+    bytes: number;
+};
+export declare function createSessionLivePublisher(options: SessionLivePublisherOptions): SessionLivePublisher;
+//# sourceMappingURL=session-live-publisher.d.ts.map

package/dist/internal/session-live-publisher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-live-publisher.d.ts","sourceRoot":"","sources":["../../src/internal/session-live-publisher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EACL,KAAK,yBAAyB,EAI/B,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAIL,KAAK,oBAAoB,EAM1B,MAAM,yBAAyB,CAAC;AAEjC,uDAAuD;AACvD,eAAO,MAAM,4BAA4B,MAAM,CAAC;AA+ChD,MAAM,WAAW,2BAA4B,SAAQ,yBAAyB;IAC5E,qDAAqD;IACrD,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAC1E,+EAA+E;IAC/E,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC;IAC1B,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,8DAA8D;IAC9D,KAAK,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;IACjC,KAAK,IAAI,IAAI,CAAC;CACf;AAMD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG;IACtD,IAAI,EAAE,oBAAoB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;CACf,CAoBA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,2BAA2B,GACnC,oBAAoB,CAqStB"}

package/dist/internal/session-live-publisher.js

@@ -0,0 +1,352 @@
+/**
+ * Publishes session events to the managed live relay (`session.live`) so the
+ * playground, the session view, and the CLI can show a hosted turn while it
+ * runs. The on-disk event log and the storage coordinator stay the durable
+ * path; this is a best-effort copy for viewers.
+ *
+ * The relay keeps events only while a viewer watches. Unwatched, a session
+ * sends a small probe at most once per `recheckAfterMs` window and nothing
+ * else. Once a viewer watches, events go out in short batches, and when the
+ * relay reports a gap (`replayFromIndex`) the missing events are reread from
+ * the local log and resent.
+ *
+ * Publishing can never slow or fail a turn: {@link SessionLivePublisher.event}
+ * is synchronous, requests time out quickly, queues are bounded, a failed
+ * batch is dropped, and repeated failures pause the session. A 404 means the
+ * backend predates the relay and turns publishing off for the process.
+ */
+import { resolveCursorApiBaseUrl, resolveCursorApiFetch, resolveCursorApiKey, } from "./cursor/cursor-api-transport.js";
+import { isStoreApiLaneEnabled } from "./cursor/store-api-client.js";
+import { describeError } from "./describe-error.js";
+import { SESSION_LIVE_MAX_BATCH_BYTES, SESSION_LIVE_MAX_BATCH_EVENTS, SESSION_LIVE_MAX_EVENT_BYTES, STORE_API_PATH, STORE_API_PROTOCOL_VERSION, STORE_API_SESSION_LIVE_CALL, sessionLiveResponseSchema, } from "./store-api-protocol.js";
+/** How long events collect before a batch goes out. */
+export const SESSION_LIVE_BATCH_WINDOW_MS = 150;
+/** A batch this large goes out without waiting for the window. */
+const SESSION_LIVE_EAGER_BATCH_BYTES = 64 * 1024;
+const SESSION_LIVE_REQUEST_TIMEOUT_MS = 1_000;
+/** Queued events per session; past this the oldest drop and the relay asks for a replay. */
+const SESSION_LIVE_MAX_QUEUED_EVENTS = 2_000;
+const SESSION_LIVE_FAILURES_BEFORE_PAUSE = 3;
+const SESSION_LIVE_PAUSE_MS = 60_000;
+/** The same replay request is honored at most this often. */
+const SESSION_LIVE_REPLAY_COOLDOWN_MS = 5_000;
+/** A session with no events for this long drops its state. */
+const SESSION_LIVE_IDLE_MS = 10 * 60_000;
+const TERMINAL_EVENT_TYPES = new Set(["session.completed", "session.failed"]);
+const BOUNDARY_EVENT_TYPES = new Set([
+    "turn.completed",
+    "turn.failed",
+    "session.waiting",
+    "session.completed",
+    "session.failed",
+]);
+const DELTA_EVENT_TYPES = new Set(["message.appended", "reasoning.appended"]);
+function utf8Bytes(text) {
+    return Buffer.byteLength(text, "utf8");
+}
+/**
+ * The event as it crosses the live wire. Delta events drop the accumulated
+ * `text` (viewers rebuild it from deltas), and an event over the per-event
+ * cap keeps only its envelope, marked `liveTruncated`.
+ */
+export function toSessionLiveWire(event) {
+    let wire = event;
+    if (DELTA_EVENT_TYPES.has(event.type)) {
+        const data = event.data;
+        if (data !== undefined && "text" in data) {
+            const { text: _text, ...rest } = data;
+            wire = { ...wire, data: rest };
+        }
+    }
+    const serialized = JSON.stringify(wire);
+    const bytes = utf8Bytes(serialized);
+    if (bytes <= SESSION_LIVE_MAX_EVENT_BYTES) {
+        return { wire, bytes };
+    }
+    const stub = { index: event.index, type: event.type };
+    if (typeof event.at === "string")
+        stub.at = event.at;
+    if (typeof event.turnId === "string")
+        stub.turnId = event.turnId;
+    if (typeof event.sessionId === "string")
+        stub.sessionId = event.sessionId;
+    stub.liveTruncated = true;
+    return { wire: stub, bytes: utf8Bytes(JSON.stringify(stub)) };
+}
+export function createSessionLivePublisher(options) {
+    const now = options.now ?? Date.now;
+    const logger = options.logger ?? (() => { });
+    const isEnabled = options.isEnabled ?? (() => isStoreApiLaneEnabled(options));
+    const sessions = new Map();
+    let disabled = false;
+    let closed = false;
+    const stateFor = (sessionId) => {
+        let state = sessions.get(sessionId);
+        if (state === undefined) {
+            state = {
+                subscribed: false,
+                nextProbeAt: 0,
+                queue: [],
+                queuedBytes: 0,
+                timer: undefined,
+                inFlight: false,
+                sendAgain: false,
+                failures: 0,
+                pausedUntil: 0,
+                lastReplay: undefined,
+                lastEventAt: now(),
+                closing: false,
+            };
+            sessions.set(sessionId, state);
+        }
+        return state;
+    };
+    const dropSession = (sessionId, state) => {
+        if (state.timer !== undefined) {
+            clearTimeout(state.timer);
+        }
+        sessions.delete(sessionId);
+    };
+    const sweepIdle = () => {
+        const cutoff = now() - SESSION_LIVE_IDLE_MS;
+        for (const [sessionId, state] of sessions) {
+            if (!state.inFlight && state.lastEventAt < cutoff) {
+                dropSession(sessionId, state);
+            }
+        }
+    };
+    const clearQueue = (state) => {
+        state.queue = [];
+        state.queuedBytes = 0;
+    };
+    const enqueue = (state, events) => {
+        const byIndex = new Map(state.queue.map((entry) => [entry.index, entry]));
+        for (const event of events) {
+            const { wire, bytes } = toSessionLiveWire(event);
+            byIndex.set(event.index, { index: event.index, wire, bytes });
+        }
+        // Over the cap, the newest events drop: the viewer needs an unbroken run
+        // from its next index, and the relay asks for the rest again once the
+        // oldest land.
+        const queue = [...byIndex.values()]
+            .sort((a, b) => a.index - b.index)
+            .slice(0, SESSION_LIVE_MAX_QUEUED_EVENTS);
+        state.queue = queue;
+        state.queuedBytes = queue.reduce((total, entry) => total + entry.bytes, 0);
+    };
+    const takeBatch = (state) => {
+        const batch = [];
+        let bytes = 0;
+        while (batch.length < SESSION_LIVE_MAX_BATCH_EVENTS) {
+            const next = state.queue[0];
+            if (next === undefined) {
+                break;
+            }
+            if (batch.length > 0 && bytes + next.bytes > SESSION_LIVE_MAX_BATCH_BYTES) {
+                break;
+            }
+            batch.push(next);
+            bytes += next.bytes;
+            state.queue.shift();
+        }
+        state.queuedBytes -= bytes;
+        return batch;
+    };
+    const post = async (sessionId, events) => {
+        let response;
+        try {
+            response = await resolveCursorApiFetch(options)(`${resolveCursorApiBaseUrl(options)}${STORE_API_PATH}/${STORE_API_SESSION_LIVE_CALL}`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${resolveCursorApiKey(options)}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    v: STORE_API_PROTOCOL_VERSION,
+                    call: STORE_API_SESSION_LIVE_CALL,
+                    payload: { sessionId, events },
+                }),
+                signal: AbortSignal.timeout(SESSION_LIVE_REQUEST_TIMEOUT_MS),
+            });
+        }
+        catch (error) {
+            return { kind: "failed", reason: describeError(error) };
+        }
+        if (response.status === 404) {
+            return { kind: "not_found" };
+        }
+        if (response.status === 429) {
+            const seconds = Number(response.headers.get("retry-after"));
+            return {
+                kind: "shed",
+                retryAfterMs: Number.isFinite(seconds) && seconds > 0 ? seconds * 1_000 : SESSION_LIVE_PAUSE_MS,
+            };
+        }
+        if (!response.ok) {
+            return { kind: "failed", reason: `HTTP ${response.status}` };
+        }
+        try {
+            const parsed = sessionLiveResponseSchema.safeParse(await response.json());
+            return parsed.success
+                ? { kind: "ok", reply: parsed.data }
+                : { kind: "failed", reason: "response failed the session.live schema" };
+        }
+        catch {
+            return { kind: "failed", reason: "non-JSON response" };
+        }
+    };
+    const replay = async (sessionId, state, from) => {
+        const at = now();
+        if (state.lastReplay !== undefined &&
+            state.lastReplay.from === from &&
+            at - state.lastReplay.at < SESSION_LIVE_REPLAY_COOLDOWN_MS) {
+            return;
+        }
+        state.lastReplay = { from, at };
+        try {
+            enqueue(state, await options.readEvents(sessionId, from));
+        }
+        catch (error) {
+            logger(`[bdk] live replay read failed for ${sessionId}: ${describeError(error)}`);
+        }
+    };
+    const schedule = (sessionId, state, delayMs) => {
+        if (state.timer !== undefined || closed) {
+            return;
+        }
+        state.timer = setTimeout(() => {
+            state.timer = undefined;
+            void send(sessionId, state);
+        }, delayMs);
+        state.timer.unref?.();
+    };
+    const send = async (sessionId, state) => {
+        if (disabled || closed) {
+            return;
+        }
+        if (state.inFlight) {
+            state.sendAgain = true;
+            return;
+        }
+        state.inFlight = true;
+        state.sendAgain = false;
+        const batch = state.subscribed ? takeBatch(state) : [];
+        try {
+            const outcome = await post(sessionId, batch.map((entry) => entry.wire));
+            switch (outcome.kind) {
+                case "not_found":
+                    disabled = true;
+                    for (const [id, other] of sessions) {
+                        dropSession(id, other);
+                    }
+                    logger("[bdk] live session relay unavailable (404); live publishing off for this process");
+                    return;
+                case "shed":
+                    state.subscribed = false;
+                    clearQueue(state);
+                    state.pausedUntil = now() + outcome.retryAfterMs;
+                    return;
+                case "failed":
+                    state.failures += 1;
+                    clearQueue(state);
+                    if (state.failures >= SESSION_LIVE_FAILURES_BEFORE_PAUSE) {
+                        state.failures = 0;
+                        state.subscribed = false;
+                        state.pausedUntil = now() + SESSION_LIVE_PAUSE_MS;
+                        logger(`[bdk] live publishing paused for ${sessionId}: ${outcome.reason}`);
+                    }
+                    return;
+                case "ok": {
+                    state.failures = 0;
+                    const { reply } = outcome;
+                    state.subscribed = reply.subscribed;
+                    if (!reply.subscribed) {
+                        clearQueue(state);
+                        state.nextProbeAt = now() + reply.recheckAfterMs;
+                        return;
+                    }
+                    if (reply.replayFromIndex !== null) {
+                        await replay(sessionId, state, reply.replayFromIndex);
+                    }
+                    return;
+                }
+            }
+        }
+        finally {
+            state.inFlight = false;
+            if (state.closing && state.queue.length === 0) {
+                dropSession(sessionId, state);
+            }
+            else if (state.subscribed && (state.queue.length > 0 || state.sendAgain)) {
+                schedule(sessionId, state, 0);
+            }
+            else if (state.sendAgain) {
+                void send(sessionId, state);
+            }
+        }
+    };
+    return {
+        event(event) {
+            if (disabled || closed) {
+                return;
+            }
+            try {
+                const sessionId = event.sessionId;
+                if (typeof sessionId !== "string" || sessionId === "") {
+                    return;
+                }
+                let state = sessions.get(sessionId);
+                if (state === undefined) {
+                    sweepIdle();
+                    state = stateFor(sessionId);
+                    if (!isEnabled()) {
+                        // Decided once per session: the pin is a file read, and delta
+                        // events arrive per token.
+                        state.pausedUntil = Number.POSITIVE_INFINITY;
+                    }
+                }
+                const at = now();
+                state.lastEventAt = at;
+                if (TERMINAL_EVENT_TYPES.has(event.type)) {
+                    state.closing = true;
+                }
+                if (at < state.pausedUntil) {
+                    if (state.closing) {
+                        dropSession(sessionId, state);
+                    }
+                    return;
+                }
+                if (!state.subscribed) {
+                    if (at >= state.nextProbeAt && !state.inFlight) {
+                        state.nextProbeAt = at + SESSION_LIVE_BATCH_WINDOW_MS;
+                        void send(sessionId, state);
+                    }
+                    else if (state.closing && !state.inFlight) {
+                        dropSession(sessionId, state);
+                    }
+                    return;
+                }
+                enqueue(state, [event]);
+                if (BOUNDARY_EVENT_TYPES.has(event.type) ||
+                    state.queuedBytes >= SESSION_LIVE_EAGER_BATCH_BYTES) {
+                    if (state.timer !== undefined) {
+                        clearTimeout(state.timer);
+                        state.timer = undefined;
+                    }
+                    void send(sessionId, state);
+                    return;
+                }
+                schedule(sessionId, state, SESSION_LIVE_BATCH_WINDOW_MS);
+            }
+            catch (error) {
+                logger(`[bdk] live publish skipped: ${describeError(error)}`);
+            }
+        },
+        close() {
+            closed = true;
+            for (const [sessionId, state] of sessions) {
+                dropSession(sessionId, state);
+            }
+        },
+    };
+}

package/dist/internal/session-run-log.js

@@ -10,7 +10,7 @@ import { agentSdkStorageKeys } from "../storage-protocol.js";
 import { resolveApiKeySync } from "./cursor/credentials.js";
 import { describeError } from "./describe-error.js";
 import { isRecord } from "./is-record.js";
-import { resolveAgentV2Hosting } from "./v2-hosting.js";
+import { isCursorManagedV2Hosting, resolveAgentV2Hosting } from "./v2-hosting.js";
 export const SESSION_RUN_LOG_VERSION = 1;
 /** Last N log-ring lines kept on each execution. */
 export const SESSION_RUN_LOG_MAX_ENTRIES = 200;
@@ -44,7 +44,7 @@ export async function flushSessionRunFatal(error) {
     }
     await Promise.race([
         fatalFlush(error).catch(() => undefined),
-        new Promise(resolve => {
+        new Promise((resolve) => {
             setTimeout(resolve, SESSION_RUN_FATAL_FLUSH_TIMEOUT_MS);
         }),
     ]);
@@ -74,7 +74,7 @@ export function serializeSessionRunError(error) {
 }
 export function snapshotSessionRunLogs(entries) {
     const tail = entries.slice(-SESSION_RUN_LOG_MAX_ENTRIES);
-    return tail.map(entry => ({
+    return tail.map((entry) => ({
         index: entry.index,
         at: entry.at,
         line: boundedText(entry.line, SESSION_RUN_LOG_MAX_LINE_CHARS),
@@ -196,7 +196,7 @@ function boundExecution(write) {
     };
 }
 function upsertExecution(existing, next) {
-    const executions = existing.filter(entry => entry.executionId !== next.executionId);
+    const executions = existing.filter((entry) => entry.executionId !== next.executionId);
     executions.push(next);
     executions.sort((a, b) => a.writtenAt.localeCompare(b.writtenAt));
     return executions.slice(-SESSION_RUN_LOG_MAX_EXECUTIONS);
@@ -210,7 +210,7 @@ function shrinkSessionDocument(document) {
     };
     let serialized = JSON.stringify(next);
     while (serialized.length > MAX_DOCUMENT_CHARS) {
-        const oldestWithLogs = executions.findIndex(entry => entry.logs.length > 0);
+        const oldestWithLogs = executions.findIndex((entry) => entry.logs.length > 0);
         if (oldestWithLogs >= 0) {
             const entry = executions[oldestWithLogs];
             executions = executions.map((item, index) => index === oldestWithLogs
@@ -368,7 +368,7 @@ export function selectSessionRunLogStore(input) {
         architecture: input.project.agent.architecture,
         env: input.env,
     });
-    if (hosting.kind !== "cursor-managed") {
+    if (!isCursorManagedV2Hosting(hosting)) {
         return undefined;
     }
     return createSessionRunLogStore({

package/dist/internal/sessions-client.js

@@ -143,7 +143,7 @@ function parseSessionSummary(value) {
  * one are skipped).
  */
 export function pickPreviousSession(sessions) {
-    const followable = sessions.filter(s => typeof s.continuationToken === "string" && s.continuationToken !== "");
+    const followable = sessions.filter((s) => typeof s.continuationToken === "string" && s.continuationToken !== "");
     if (followable.length === 0) {
         return undefined;
     }
@@ -171,7 +171,7 @@ export function formatSessionsTable(sessions, options) {
         return `${sourceLine}No sessions.\n`;
     }
     const header = ["SESSION", "CHANNEL", "MODE", "TURNS", "RUNNING", "UPDATED"];
-    const rows = sessions.map(s => [
+    const rows = sessions.map((s) => [
         s.sessionId,
         s.channelId,
         s.mode,
@@ -182,7 +182,7 @@ export function formatSessionsTable(sessions, options) {
     return `${sourceLine}${renderTable(header, rows)}\n`;
 }
 function renderTable(header, rows) {
-    const widths = header.map((h, i) => Math.max(h.length, ...rows.map(row => (row[i] ?? "").length)));
+    const widths = header.map((h, i) => Math.max(h.length, ...rows.map((row) => (row[i] ?? "").length)));
     const renderRow = (row) => row
         .map((cell, i) => cell.padEnd(widths[i] ?? 0))
         .join("  ")

package/dist/internal/skill-catalog.js

@@ -16,9 +16,9 @@ export function skillListEntry(skill) {
     return { name: skill.name, description: skill.description };
 }
 export async function readSkillDetail(skills, skillName) {
-    const skill = skills.find(s => s.name === skillName);
+    const skill = skills.find((s) => s.name === skillName);
     if (skill === undefined) {
-        throw new UnknownSkillError(skillName, skills.map(s => s.name));
+        throw new UnknownSkillError(skillName, skills.map((s) => s.name));
     }
     // Null-prototype: authored keys (`defineSkill`) pass through
     // unvalidated, and `__proto__` would silently vanish on a plain object.

package/dist/internal/sleep.js

@@ -1,3 +1,3 @@
 export function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/internal/start-log-store.d.ts

@@ -15,6 +15,8 @@ export interface StartLogStore {
     read(startLogId: string): Promise<string | undefined>;
 }
 export declare function tailStartLogText(raw: string, maxBytes: number): string;
+/** Mask credential tokens before persisting a snapshot. */
+export declare function maskStartLogTokens(text: string): string;
 export declare function resolveEngineStartLogPath(env?: NodeJS.ProcessEnv): string;
 /**
  * Read the local engine tee. Missing/empty is `undefined` (no store write).
@@ -30,7 +32,9 @@ export declare function createStartLogStore(input: {
     logger?: (line: string) => void;
 }): StartLogStore;
 /**
- * Same selection as the session-run log: architecture-v2 hosted engines.
+ * Freeze pods only. A persistent slot writes one file per command under
+ * `/state/logs` and mirrors that directory; this store is the single
+ * `start.log` tee those pods do not produce.
  */
 export declare function selectStartLogStore(input: {
     project: AgentProject;

package/dist/internal/start-log-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start-log-store.d.ts","sourceRoot":"","sources":["../../src/internal/start-log-store.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKhD,gEAAgE;AAChE,eAAO,MAAM,yBAAyB,EAAE,MAAwB,CAAC;AAEjE,iCAAiC;AACjC,eAAO,MAAM,6BAA6B,sCAAsC,CAAC;AAEjF,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7D,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CACvD;AAMD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMtE;AA0BD,wBAAgB,yBAAyB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAKtF;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,CAAC,EAAE;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAoB9B;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC,GAAG,aAAa,CAqChB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC1C,GAAG,aAAa,GAAG,SAAS,CAgB5B;AAQD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,IAAI,CAAC,CAchB"}
+{"version":3,"file":"start-log-store.d.ts","sourceRoot":"","sources":["../../src/internal/start-log-store.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKhD,gEAAgE;AAChE,eAAO,MAAM,yBAAyB,EAAE,MAAwB,CAAC;AAEjE,iCAAiC;AACjC,eAAO,MAAM,6BAA6B,sCAAsC,CAAC;AAEjF,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7D,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CACvD;AAMD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMtE;AAqBD,2DAA2D;AAC3D,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,yBAAyB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAKtF;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,CAAC,EAAE;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAoB9B;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC,GAAG,aAAa,CAqChB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC1C,GAAG,aAAa,GAAG,SAAS,CAgB5B;AAQD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,IAAI,CAAC,CAchB"}

package/dist/internal/start-log-store.js

@@ -26,7 +26,7 @@ export function tailStartLogText(raw, maxBytes) {
 }
 /** Each character literally or percent-encoded, as tokens appear in URLs. */
 function encodable(text) {
-    return Array.from(text, char => {
+    return Array.from(text, (char) => {
         const lower = char.charCodeAt(0).toString(16).padStart(2, "0");
         const upper = char.toUpperCase().charCodeAt(0).toString(16).padStart(2, "0");
         return lower === upper ? `(?:${char}|%${lower})` : `(?:${char}|%${lower}|%${upper})`;
@@ -41,7 +41,7 @@ const TOKEN_MASKS = [
     [/\bxox[baprs]-[A-Za-z0-9-]+\b/g, "xox…"],
 ];
 /** Mask credential tokens before persisting a snapshot. */
-function maskStartLogTokens(text) {
+export function maskStartLogTokens(text) {
     return TOKEN_MASKS.reduce((masked, [pattern, mask]) => masked.replace(pattern, mask), text);
 }
 export function resolveEngineStartLogPath(env = process.env) {
@@ -113,7 +113,9 @@ export function createStartLogStore(input) {
     };
 }
 /**
- * Same selection as the session-run log: architecture-v2 hosted engines.
+ * Freeze pods only. A persistent slot writes one file per command under
+ * `/state/logs` and mirrors that directory; this store is the single
+ * `start.log` tee those pods do not produce.
  */
 export function selectStartLogStore(input) {
     const hosting = resolveAgentV2Hosting({

package/dist/internal/storage-coordinator.js

@@ -74,8 +74,8 @@ function resumeProjectionJson(record) {
 /** Session records out of raw sink entries; rows without a usable id are dropped. */
 function sessionRecordsOf(entries) {
     return entries
-        .map(entry => entry.value)
-        .filter(record => record != null && typeof record.sessionId === "string" && record.sessionId !== "");
+        .map((entry) => entry.value)
+        .filter((record) => record != null && typeof record.sessionId === "string" && record.sessionId !== "");
 }
 export class StorageCoordinator {
     constructor(options) {
@@ -186,7 +186,7 @@ export class StorageCoordinator {
         // A terminal event can arrive through a debounce-policy timer flush,
         // where eventDispatched never ran: detect it from the buffered events
         // so a finished session's record is exact under either policy.
-        const exact = exactRecord || events.some(event => TERMINAL_SESSION_EVENTS.has(event.type));
+        const exact = exactRecord || events.some((event) => TERMINAL_SESSION_EVENTS.has(event.type));
         // Exact flushes repair earlier volatile-only skips: when the buffer no
         // longer holds a record, the newest skipped one still gets written.
         const record = buffer?.record ??
@@ -272,7 +272,7 @@ export class StorageCoordinator {
         const putMany = this.definition.putMany?.bind(this.definition);
         if (putMany !== undefined) {
             return {
-                label: `putMany(${puts.map(entry => entry.key).join(", ")})`,
+                label: `putMany(${puts.map((entry) => entry.key).join(", ")})`,
                 run: async (ctx) => {
                     const results = await putMany(puts, ctx);
                     let recordFailed = false;
@@ -290,7 +290,7 @@ export class StorageCoordinator {
             };
         }
         return {
-            label: `put(${puts.map(entry => entry.key).join(", ")})`,
+            label: `put(${puts.map((entry) => entry.key).join(", ")})`,
             run: async (ctx) => {
                 let recordFailed = false;
                 for (const entry of puts) {
@@ -334,14 +334,14 @@ export class StorageCoordinator {
     putOp(key, value) {
         return {
             label: `put(${key})`,
-            run: ctx => this.definition.put(key, value, ctx),
+            run: (ctx) => this.definition.put(key, value, ctx),
         };
     }
     /** KV delete op on the sink's `delete` (skipped when the hook is absent). */
     deleteOp(key) {
         return {
             label: `delete(${key})`,
-            run: ctx => this.definition.delete?.(key, ctx),
+            run: (ctx) => this.definition.delete?.(key, ctx),
         };
     }
     // ==========================================================================
@@ -366,8 +366,8 @@ export class StorageCoordinator {
     async listSessions() {
         const entries = await this.tryList(this.keys.sessionPrefix(this.agentName));
         return entries
-            .map(entry => entry.value)
-            .filter(record => record != null);
+            .map((entry) => entry.value)
+            .filter((record) => record != null);
     }
     /**
      * Session records from the sink for the sessions API. Unlike
@@ -537,7 +537,7 @@ export class StorageCoordinator {
                 this.enqueue([
                     {
                         label: `evals.put(${run.runId})`,
-                        run: ctx => table.put(snapshot, ctx),
+                        run: (ctx) => table.put(snapshot, ctx),
                     },
                 ], "policy");
             },
@@ -545,7 +545,7 @@ export class StorageCoordinator {
                 this.enqueue([
                     {
                         label: `evals.delete(${runId})`,
-                        run: ctx => table.delete(runId, ctx),
+                        run: (ctx) => table.delete(runId, ctx),
                     },
                 ], "policy");
             },
@@ -586,7 +586,7 @@ export class StorageCoordinator {
         let timer;
         const drained = await Promise.race([
             this.queue.then(() => true),
-            new Promise(resolve => {
+            new Promise((resolve) => {
                 timer = setTimeout(() => resolve(false), CLOSE_DRAIN_TIMEOUT_MS);
                 timer.unref?.();
             }),