@cursor/bdk 0.2.6 → 0.2.8

package/dist/internal/workspace.js

@@ -2,7 +2,7 @@
  * Session workspace materialization. Each session gets its own working
  * directory that the Cursor harness treats as the project: skills land in
  * `.cursor/skills/<name>/SKILL.md`, agent-side tools land in
- * `.agent-serve/tools/<name>.sh`, and `agent/sandbox/workspace/**` seed files
+ * `.agent-serve/tools/<name>.sh`, and `bot/sandbox/workspace/**` seed files
  * are mirrored in. The harness picks all of this up natively through its
  * project setting source. Instructions are not written here: local turns
  * deliver them as the harness system prompt ({@link buildAgentsMdContent}),
@@ -28,22 +28,20 @@ import { parseFrontmatter, serializeFrontmatter } from "./frontmatter.js";
 import { buildIdentitySection } from "./prompt-context.js";
 const execFileAsync = promisify(execFile);
 /**
- * First-turn preamble section for cloud-runtime sessions on hosted
- * deployments: cloud VMs read the memory journal from the store mount.
+ * First-turn preamble for cloud sessions that read managed memory.
  */
 export function buildCloudMemorySection(agentName) {
     const dir = `${DEPLOYMENT_STORE_MOUNT_PATH}/${agentStoreKeys.memoryDir(agentName)}`;
     return [
         "## Shared session memory",
         "",
-        `The cross-session memory journal (the \`memory/\` directory your instructions may reference) lives at \`${dir}\` on this machine — read \`${dir}/journal.jsonl\` with your normal file tools.`,
+        `The cross-session memory journal (the \`memory/\` directory your instructions may reference) is available at \`${dir}\` on this machine. Read \`${dir}/journal.jsonl\` with your normal file tools.`,
     ].join("\n");
 }
 /**
  * First-turn preamble section for cloud-runtime sessions with authored
- * `agent/sandbox/workspace/**` seeds. Cloud VMs get no materialized
- * workspace; the seeds are synced onto the store mount instead (see
- * `syncWorkspaceToStore`), so the model has to be told where they are.
+ * `bot/sandbox/workspace/**` seeds. The prompt names their managed storage
+ * path because cloud turns have no local materialized workspace.
  */
 export function buildCloudWorkspaceSection(dir) {
     return [
@@ -53,19 +51,16 @@ export function buildCloudWorkspaceSection(dir) {
     ].join("\n");
 }
 /**
- * Per-turn preamble for cloud `workspaceFiles` after they land on the
- * session store prefix (see `syncSessionWorkspaceFiles`). Omitted when
- * the sync did not land.
- *
- * Same shared Agent Store mount as authored seeds — the session path is
- * replace-per-send / task-end wipe lifetime, not a separate mount ACL.
+ * Per-turn preamble for cloud `workspaceFiles` after they reach
+ * session-scoped storage. Omitted when the sync did not land. The session
+ * path is replaced on each send and removed when a task session ends.
  */
 export function buildCloudSessionWorkspaceSection(dir, relPaths) {
     const listed = relPaths.map(path => `\`${path}\``).join(", ");
     return [
         "## Session workspace files",
         "",
-        `This turn's workspace files live at \`${dir}\` on this machine (${listed}). Read them with your normal file tools. They sit on the same shared Agent Store mount as authored workspace seeds; the session directory is replaced on the next send for this session, and task sessions remove it when they finish.`,
+        `This turn's workspace files are available at \`${dir}\` on this machine (${listed}). Read them with your normal file tools. The session directory is replaced on the next send for this session, and task sessions remove it when they finish.`,
     ].join("\n");
 }
 /** Relative path of an agent-side tool script inside the session workspace. */

package/dist/memory.d.ts

@@ -1,30 +1,22 @@
 /**
- * Session memory — a journal of what every session of this agent did, so
+ * Session memory is a journal of what every session of this agent did, so
  * later sessions can recall and build on past work.
  *
  * The write side is {@link memoryHook}, authored as a thin re-export at
- * `agent/hooks/memory.ts` (scaffolded by `agent-sdk init`): after each turn
- * it appends one record (timestamp, session, user message, final result,
- * usage) to `<stateRoot>/memory/journal.jsonl`.
+ * `bot/hooks/memory.ts`. After each turn it appends one record to
+ * `<stateRoot>/memory/journal.jsonl`.
  *
  * There is no read-side API. The framework symlinks `<stateRoot>/memory`
  * into every session workspace as `memory/`, so agents read the journal
  * with their normal file tools (`instructions.md` points them at it). That
  * filesystem visibility is why memory does not route through
  * `defineStorage` sinks, which are opaque to the model. A custom
- * {@link MemoryBackend} (database, vector store, …) supplies its own read
- * path — typically a server tool under `agent/tools/`, which can resolve
- * state via `ctx.stateRoot`.
+ * {@link MemoryBackend} supplies its own read path.
  *
  * On Cursor-managed hosting the default is {@link agentStoreMemoryBackend}:
- * the journal lives on the deployment's Agent Store (survives deploys,
- * visible on cloud VMs under the store mount), written exclusively through
- * the `memory.append` domain call — the server owns the journal pattern —
- * and mirrored to `<stateRoot>/memory/journal.jsonl` (hydrated per session
- * via `memory.read`, appended locally per turn) so the workspace symlink
- * read path keeps working for local-runtime turns. The
- * `factory-api-v1` pin file exists only on hosted pods — plain local dev
- * runs {@link fileMemoryBackend} and never sees the hosted lane.
+ * the journal survives deployment replacement and is mirrored locally so
+ * file tools keep the same read path. Local development uses
+ * {@link fileMemoryBackend}.
  */
 import { type CursorHostedFilesOptions } from "./files-backends/cursor-hosted.js";
 import { type StoreApiClient } from "./internal/cursor/store-api-client.js";
@@ -57,7 +49,7 @@ export interface MemoryBackend {
     /**
      * Optional session-start hook: bring the backend's local read path up to
      * date before the session's first turn reads it. A freshness upgrade, not
-     * a correctness gate — implementations soft-fail and keep whatever read
+     * a correctness gate; implementations soft-fail and keep whatever read
      * state already exists.
      */
     prepareSession?(ctx: {
@@ -74,45 +66,27 @@ export interface FileMemoryBackendOptions {
 }
 /**
  * Local default backend: append-only JSONL at `<stateRoot>/memory/journal.jsonl`
- * — the directory the framework symlinks into session workspaces. Rotated
+ * in the directory the framework symlinks into session workspaces. Rotated
  * segments stay alongside as `journal-<epoch-ms>.jsonl`.
  */
 export declare function fileMemoryBackend(options?: FileMemoryBackendOptions): MemoryBackend;
 export interface AgentStoreMemoryBackendOptions {
     /**
      * Local mirror rotation threshold, same meaning as
-     * {@link FileMemoryBackendOptions}. The durable journal's rotation is the
-     * server's (`memory.append` controller), not this.
+     * {@link FileMemoryBackendOptions}. Managed storage controls the durable
+     * journal's retention independently.
      */
     maxJournalBytes?: number;
-    /**
-     * Cursor-hosted transport overrides (tests): base URL, credential, store
-     * source id, protocol pin, fetch. Feeds the default
-     * {@link storeApiClient} and the lane-availability check.
-     */
+    /** Cursor-managed storage overrides. */
     hosted?: CursorHostedFilesOptions;
-    /**
-     * Domain-lane client override (tests). Defaults to
-     * {@link createStoreApiClient} over {@link hosted} — the module that owns
-     * the `memory.append` / `memory.read` transport, typed errors, and
-     * bounded backoff.
-     */
+    /** Managed storage client override. */
     storeApiClient?: StoreApiClient;
 }
 /**
- * Journal on the deployment's Agent Store — durable across deploys, visible
- * on cloud VMs under the store mount, written exclusively through the
- * `memory.append` domain call: the server owns the journal's storage
- * pattern (Redis-buffered flush, rotation), so a pathological pattern is
- * fixable in a backend deploy instead of a July release plus a rebake.
- *
- * There is no client-composed fallback. The read-modify-write CAS lane that
- * predated the domain call (and caused the 2026-09-18 Agent Store read
- * storm) was removed in 0.2.1 together with v2 hosting binding the
- * `factory-api-v1` pin unconditionally and refusing artifacts frozen on an
- * older July. A hosted pod without the pin is therefore a misconfiguration
- * (a server predating the pin change, or a local env naming a hosted store
- * without one): records are dropped loudly, never written client-side.
+ * Cursor-managed journal that survives deployment replacement. Managed
+ * storage owns append, read, and rotation. If managed storage is unavailable,
+ * records are dropped with an error instead of falling back to a second
+ * persistence path.
  */
 export declare function agentStoreMemoryBackend(options?: AgentStoreMemoryBackendOptions): MemoryBackend;
 export interface MemoryHookOptions {

package/dist/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAMH,OAAO,EACL,KAAK,wBAAwB,EAE9B,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAe,cAAc,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEzE,sEAAsE;AACtE,eAAO,MAAM,eAAe,WAAW,CAAC;AAExC,gDAAgD;AAChD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC/B,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF,kFAAkF;AAClF,MAAM,WAAW,aAAa;IAC5B,UAAU,CACR,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAC5C,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB;;;;;OAKG;IACH,cAAc,CAAC,CAAC,GAAG,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/E;AAED,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,GAAG,aAAa,CA6BvF;AAED,MAAM,WAAW,8BAA8B;IAC7C;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,MAAM,CAAC,EAAE,wBAAwB,CAAC;IAClC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,GAAE,8BAAmC,GAC3C,aAAa,CA0Lf;AAgBD,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,yEAAyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,cAAc,CAgG1E"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAMH,OAAO,EACL,KAAK,wBAAwB,EAE9B,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAe,cAAc,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEzE,sEAAsE;AACtE,eAAO,MAAM,eAAe,WAAW,CAAC;AAExC,gDAAgD;AAChD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC/B,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF,kFAAkF;AAClF,MAAM,WAAW,aAAa;IAC5B,UAAU,CACR,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAC5C,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB;;;;;OAKG;IACH,cAAc,CAAC,CAAC,GAAG,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/E;AAED,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,GAAG,aAAa,CA6BvF;AAED,MAAM,WAAW,8BAA8B;IAC7C;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wCAAwC;IACxC,MAAM,CAAC,EAAE,wBAAwB,CAAC;IAClC,uCAAuC;IACvC,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,GAAE,8BAAmC,GAC3C,aAAa,CA6Jf;AAgBD,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,yEAAyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,cAAc,CAgG1E"}

package/dist/memory.js

@@ -1,30 +1,22 @@
 /**
- * Session memory — a journal of what every session of this agent did, so
+ * Session memory is a journal of what every session of this agent did, so
  * later sessions can recall and build on past work.
  *
  * The write side is {@link memoryHook}, authored as a thin re-export at
- * `agent/hooks/memory.ts` (scaffolded by `agent-sdk init`): after each turn
- * it appends one record (timestamp, session, user message, final result,
- * usage) to `<stateRoot>/memory/journal.jsonl`.
+ * `bot/hooks/memory.ts`. After each turn it appends one record to
+ * `<stateRoot>/memory/journal.jsonl`.
  *
  * There is no read-side API. The framework symlinks `<stateRoot>/memory`
  * into every session workspace as `memory/`, so agents read the journal
  * with their normal file tools (`instructions.md` points them at it). That
  * filesystem visibility is why memory does not route through
  * `defineStorage` sinks, which are opaque to the model. A custom
- * {@link MemoryBackend} (database, vector store, …) supplies its own read
- * path — typically a server tool under `agent/tools/`, which can resolve
- * state via `ctx.stateRoot`.
+ * {@link MemoryBackend} supplies its own read path.
  *
  * On Cursor-managed hosting the default is {@link agentStoreMemoryBackend}:
- * the journal lives on the deployment's Agent Store (survives deploys,
- * visible on cloud VMs under the store mount), written exclusively through
- * the `memory.append` domain call — the server owns the journal pattern —
- * and mirrored to `<stateRoot>/memory/journal.jsonl` (hydrated per session
- * via `memory.read`, appended locally per turn) so the workspace symlink
- * read path keeps working for local-runtime turns. The
- * `factory-api-v1` pin file exists only on hosted pods — plain local dev
- * runs {@link fileMemoryBackend} and never sees the hosted lane.
+ * the journal survives deployment replacement and is mirrored locally so
+ * file tools keep the same read path. Local development uses
+ * {@link fileMemoryBackend}.
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -46,7 +38,7 @@ import { createStoreApiClient, isStoreApiLaneEnabled, } from "./internal/cursor/
 export const MEMORY_DIR_NAME = "memory";
 /**
  * Local default backend: append-only JSONL at `<stateRoot>/memory/journal.jsonl`
- * — the directory the framework symlinks into session workspaces. Rotated
+ * in the directory the framework symlinks into session workspaces. Rotated
  * segments stay alongside as `journal-<epoch-ms>.jsonl`.
  */
 export function fileMemoryBackend(options = {}) {
@@ -56,7 +48,7 @@ export function fileMemoryBackend(options = {}) {
     // sessions, so appends to the shared journal are chained per path. A
     // failed append must not poison the chain for later turns.
     const appendChains = new Map();
-    // Same-millisecond rotations must not reuse a segment name — POSIX
+    // Same-millisecond rotations must not reuse a segment name; POSIX
     // rename would silently replace the earlier archive.
     let rotationSeq = 0;
     return {
@@ -86,19 +78,10 @@ export function fileMemoryBackend(options = {}) {
     };
 }
 /**
- * Journal on the deployment's Agent Store — durable across deploys, visible
- * on cloud VMs under the store mount, written exclusively through the
- * `memory.append` domain call: the server owns the journal's storage
- * pattern (Redis-buffered flush, rotation), so a pathological pattern is
- * fixable in a backend deploy instead of a July release plus a rebake.
- *
- * There is no client-composed fallback. The read-modify-write CAS lane that
- * predated the domain call (and caused the 2026-09-18 Agent Store read
- * storm) was removed in 0.2.1 together with v2 hosting binding the
- * `factory-api-v1` pin unconditionally and refusing artifacts frozen on an
- * older July. A hosted pod without the pin is therefore a misconfiguration
- * (a server predating the pin change, or a local env naming a hosted store
- * without one): records are dropped loudly, never written client-side.
+ * Cursor-managed journal that survives deployment replacement. Managed
+ * storage owns append, read, and rotation. If managed storage is unavailable,
+ * records are dropped with an error instead of falling back to a second
+ * persistence path.
  */
 export function agentStoreMemoryBackend(options = {}) {
     var _a, _b, _c;
@@ -108,23 +91,13 @@ export function agentStoreMemoryBackend(options = {}) {
     // fileMemoryBackend): hydration and appends on one agent's mirror never
     // interleave, and a failed step must not poison the chain for later turns.
     const appendChains = new Map();
-    // Transport, envelope, typed errors, and bounded backoff all live in the
-    // client; this module only decides which lane an append takes.
+    // The client owns retries and typed errors; this module owns memory policy.
     const storeApiClient = (_c = options.storeApiClient) !== null && _c !== void 0 ? _c : createStoreApiClient(hosted);
     /**
-     * The domain lane still owes local-runtime sessions their read path:
-     * cloud-runtime turns read the journal through the store mount, but
-     * local-runtime turns on hosted pods (the default `runtime: "local"`)
-     * read `<stateRoot>/memory/journal.jsonl` via the workspace symlink, and
-     * on hosting the only writer of that file is this backend. So the lane
-     * keeps the mirror live without reintroducing the CAS read pattern:
-     * hydrate it once from the store when the file is absent (a fresh pod
-     * after a deploy), then append each successfully posted record locally,
-     * rotating at {@link maxJournalBytes} like {@link fileMemoryBackend}.
-     * Server-buffered records not yet flushed when a pod hydrates are the
-     * lane's documented staleness window (~30 s / 64 KiB), and other pods'
-     * appends surface on the next hydration — advisory memory, same envelope
-     * as the server side.
+     * Keep the local journal mirror available to file tools. Hydrate it when
+     * absent, then append each record only after managed storage accepts it.
+     * Memory is advisory, so another process's newest records may appear on
+     * the next hydration.
      */
     const hydratedMirrors = new Set();
     let mirrorRotationSeq = 0;
@@ -157,39 +130,30 @@ export function agentStoreMemoryBackend(options = {}) {
         yield appendFile(path, `${JSON.stringify(record)}\n`, "utf8");
     });
     /**
-     * One `memory.append` domain call; the server appends to the server-owned
-     * journal. On success the record is also appended to the local mirror so
-     * the workspace symlink read path stays live (see
-     * {@link maintainLocalMirror}).
+     * Append one record to managed storage, then update the local mirror.
      *
      * Failure policy: log and give up for this record. Memory is advisory and
      * the hook runner treats an append failure as non-fatal to the turn;
-     * falling back to the CAS path per-record would reintroduce the write
-     * storm under exactly the server brownout that makes this call fail. A
-     * failed POST also skips the mirror — the mirror must never show a record
-     * the durable journal will not have.
+     * a failed durable write also skips the mirror.
      */
     const appendViaStoreApi = (record, ctx) => __awaiter(this, void 0, void 0, function* () {
         try {
             yield storeApiClient.memoryAppend({ agent: ctx.agentName, record });
         }
         catch (error) {
-            console.warn(`[agent-serve] memory.append dropped one record for "${ctx.agentName}": ${error instanceof Error ? error.message : String(error)}`);
+            console.warn(`[bdk] memory.append dropped one record for "${ctx.agentName}": ${error instanceof Error ? error.message : String(error)}`);
             return;
         }
         try {
             yield maintainLocalMirror(record, ctx);
         }
         catch (error) {
-            console.warn(`[agent-serve] memory mirror update failed for "${ctx.agentName}" (journal record is durable): ${error instanceof Error ? error.message : String(error)}`);
+            console.warn(`[bdk] memory mirror update failed for "${ctx.agentName}" (journal record is durable): ${error instanceof Error ? error.message : String(error)}`);
         }
     });
     /**
-     * Session-start hydration: one `memory.read` (flush-on-read server-side,
-     * so the pending buffer — including a burst another pod appended — lands
-     * first) and the mirror is rewritten to global state; the session then
-     * reads everything appended before it started. Soft-fail: a failed
-     * hydration keeps the existing mirror.
+     * Refresh the local mirror at session start. Soft-fail so an unavailable
+     * store does not erase the existing mirror.
      */
     const hydrateMirror = (ctx) => __awaiter(this, void 0, void 0, function* () {
         var _a;
@@ -200,12 +164,8 @@ export function agentStoreMemoryBackend(options = {}) {
                 agent: ctx.agentName,
             });
             if (content !== undefined) {
-                // Never regress the read path: every mirrored record was
-                // server-acked before it was written locally, so a download SHORTER
-                // than the mirror means the server's flush-on-read was degraded (a
-                // busy lock, a Redis outage — the acked tail is still buffered) or
-                // the journal rotated. Keeping the richer mirror loses nothing;
-                // rewriting would hide records the agent has already seen.
+                // Never replace the local mirror with a shorter journal. Keeping the
+                // richer view avoids hiding records the agent has already seen.
                 const mirroredBytes = (_b = (_a = (yield stat(path).catch(() => undefined))) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0;
                 if (content.byteLength >= mirroredBytes) {
                     yield mirrorJournalLocally(ctx.stateRoot, content);
@@ -216,17 +176,12 @@ export function agentStoreMemoryBackend(options = {}) {
             hydratedMirrors.add(path);
         }
         catch (error) {
-            console.warn(`[agent-serve] memory hydration failed for "${ctx.agentName}" (keeping the existing mirror): ${error instanceof Error ? error.message : String(error)}`);
+            console.warn(`[bdk] memory hydration failed for "${ctx.agentName}" (keeping the existing mirror): ${error instanceof Error ? error.message : String(error)}`);
         }
     });
-    /**
-     * Hosted pods carry the pin and a provisioned store by construction (v2
-     * hosting binds `factory-api-v1` unconditionally and refuses pre-0.2.1
-     * artifacts). Reaching this without them means a misconfigured
-     * environment; there is no client-side write to fall back to.
-     */
+    /** Report a missing managed-storage binding without falling back locally. */
     const refuseMisconfiguredLane = (agentName, verb) => {
-        console.error(`[agent-serve] memory ${verb} for "${agentName}" dropped: the store API lane is unavailable (missing/foreign AGENT_SERVE_STORE_PROTOCOL pin or no provisioned store). This July has no client-side journal fallback; fix the hosting pin.`);
+        console.error(`[bdk] memory ${verb} for "${agentName}" dropped: the store API lane is unavailable (missing/foreign AGENT_SERVE_STORE_PROTOCOL pin or no provisioned store). This BDK version has no client-side journal fallback; fix the hosting pin.`);
     };
     return {
         prepareSession(ctx) {
@@ -254,9 +209,8 @@ export function agentStoreMemoryBackend(options = {}) {
                 var _a;
                 // Soft-fail by construction (appendViaStoreApi never throws), but
                 // still chained per journal key: the local mirror's hydrate-then-
-                // append must not interleave with itself. Lane availability is
-                // re-resolved lazily per append, so a pin bound after serve start
-                // takes effect without a restart.
+                // append must not interleave with itself. Availability is resolved
+                // lazily for each append.
                 const key = agentStoreKeys.memoryJournal(ctx.agentName);
                 const prior = (_a = appendChains.get(key)) !== null && _a !== void 0 ? _a : Promise.resolve();
                 const next = prior
@@ -274,7 +228,7 @@ export function agentStoreMemoryBackend(options = {}) {
         },
     };
 }
-/** Atomic full rewrite of the local mirror; also hydrates a fresh pod after a deploy. */
+/** Atomic full rewrite of the local mirror. */
 function mirrorJournalLocally(stateRoot, contents) {
     return __awaiter(this, void 0, void 0, function* () {
         const dir = join(stateRoot, MEMORY_DIR_NAME);
@@ -284,7 +238,7 @@ function mirrorJournalLocally(stateRoot, contents) {
         yield rename(tmp, join(dir, "journal.jsonl"));
     });
 }
-/** Hosted deployments journal to the Agent Store; local dev to plain files. */
+/** Cursor-managed deployments use durable memory; local development uses files. */
 function defaultMemoryBackend() {
     return isCursorHostedFilesAvailable() ? agentStoreMemoryBackend() : fileMemoryBackend();
 }
@@ -367,7 +321,7 @@ export function memoryHook(options = {}) {
                         });
                     }
                     catch (error) {
-                        console.warn(`[agent-serve] memory hydration at session start failed: ${error instanceof Error ? error.message : String(error)}`);
+                        console.warn(`[bdk] memory hydration at session start failed: ${error instanceof Error ? error.message : String(error)}`);
                     }
                 });
             },