@cursor/bdk 0.2.11 → 0.2.13

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

@@ -0,0 +1,48 @@
+/**
+ * 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). An event over the per-event cap
+ * keeps its envelope and `data` with long strings shortened, marked
+ * `liveTruncated`; when even that is too large, `data` keeps only the fields
+ * viewers need to place the event.
+ */
+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;AA8DD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG;IACtD,IAAI,EAAE,oBAAoB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;CACf,CA+BA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,2BAA2B,GACnC,oBAAoB,CAqStB"}

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

@@ -0,0 +1,415 @@
+/**
+ * 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");
+}
+/** Per-string length limits tried, longest first, until an event fits the cap. */
+const LIVE_TRUNCATION_STEPS = [4096, 1024, 256, 64];
+/**
+ * `data` fields viewers use to place an event (which tool card, which
+ * subagent, how the turn ended). They survive every truncation step.
+ */
+const LIVE_IDENTITY_KEYS = [
+    "callId",
+    "toolName",
+    "parentCallId",
+    "isError",
+    "finishReason",
+    "stepId",
+    "decision",
+    "sdkAgentId",
+];
+const LIVE_TRUNCATION_MARKER = "… [truncated in the live view]";
+function truncateStrings(value, maxChars) {
+    if (typeof value === "string") {
+        return value.length > maxChars ? `${value.slice(0, maxChars)}${LIVE_TRUNCATION_MARKER}` : value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => truncateStrings(item, maxChars));
+    }
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, truncateStrings(item, maxChars)]));
+    }
+    return value;
+}
+function identityData(data) {
+    const kept = {};
+    if (data === null || typeof data !== "object" || Array.isArray(data)) {
+        return kept;
+    }
+    for (const key of LIVE_IDENTITY_KEYS) {
+        const value = data[key];
+        if (typeof value === "number" || typeof value === "boolean") {
+            kept[key] = value;
+        }
+        else if (typeof value === "string") {
+            kept[key] = truncateStrings(value, 256);
+        }
+    }
+    // `actions.requested` places its tool cards from `calls`.
+    const calls = data.calls;
+    if (Array.isArray(calls)) {
+        kept.calls = calls.slice(0, 50).map((call) => identityData(call));
+    }
+    return kept;
+}
+/**
+ * The event as it crosses the live wire. Delta events drop the accumulated
+ * `text` (viewers rebuild it from deltas). An event over the per-event cap
+ * keeps its envelope and `data` with long strings shortened, marked
+ * `liveTruncated`; when even that is too large, `data` keeps only the fields
+ * viewers need to place the event.
+ */
+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 bytes = utf8Bytes(JSON.stringify(wire));
+    if (bytes <= SESSION_LIVE_MAX_EVENT_BYTES) {
+        return { wire, bytes };
+    }
+    for (const maxChars of LIVE_TRUNCATION_STEPS) {
+        const candidate = {
+            ...wire,
+            data: truncateStrings(wire.data, maxChars),
+            liveTruncated: true,
+        };
+        const candidateBytes = utf8Bytes(JSON.stringify(candidate));
+        if (candidateBytes <= SESSION_LIVE_MAX_EVENT_BYTES) {
+            return { wire: candidate, bytes: candidateBytes };
+        }
+    }
+    const minimal = { index: event.index, type: event.type };
+    if (typeof event.at === "string")
+        minimal.at = event.at;
+    if (typeof event.turnId === "string")
+        minimal.turnId = event.turnId;
+    if (typeof event.sessionId === "string")
+        minimal.sessionId = event.sessionId;
+    minimal.data = identityData(wire.data);
+    minimal.liveTruncated = true;
+    return { wire: minimal, bytes: utf8Bytes(JSON.stringify(minimal)) };
+}
+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({