@cursor/july 0.1.75 → 0.1.78

package/src/internal/review-comments.ts

@@ -110,6 +110,43 @@ export type ReviewCommentReaderImplementation = {
   ) => Promise<ExistingReviewComment[]>;
 };
 
+export type ResolveReviewThreadsArgs = {
+  target: ScmReviewTarget;
+  /** REST comment ids whose threads should be resolved. */
+  commentIds: readonly number[];
+  signal?: AbortSignal;
+};
+
+/**
+ * Outcome of resolving review threads for a set of comment ids. Callers
+ * treat this as best-effort actuation: a failed resolve must not fail the
+ * review that already posted.
+ */
+export type ResolveReviewThreadsResult = {
+  requested: number;
+  resolved: number;
+  alreadyResolved: number;
+  notFound: number;
+  failed: number;
+  detail: string;
+};
+
+/**
+ * Write side of thread resolution, the counterpart of
+ * {@link ReviewCommentReaderImplementation}. Bugbot's equivalent is
+ * `IGitProvider.resolveReviewThreadForComment` / `resolveThreads`.
+ *
+ * GitHub only exposes resolve via GraphQL (`resolveReviewThread`). REST
+ * has no equivalent. The mutation runs as whatever identity minted the
+ * bound GitHub client — for `githubChannel({ cursorAccount })` that is
+ * the Cursor installation, the same identity that posted the comments.
+ */
+export type ReviewThreadResolverImplementation = {
+  resolveReviewThreadsForComments: (
+    args: ResolveReviewThreadsArgs
+  ) => Promise<ResolveReviewThreadsResult>;
+};
+
 /** Parse a PR URL into the SCM target to read comments from. */
 export function resolveScmReviewTarget(
   prUrl: string
@@ -141,9 +178,65 @@ export function createReviewCommentReader(args: {
   }
 }
 
+/**
+ * Resolver for a resolved target. Returns undefined when the host cannot
+ * serve that provider, so callers degrade instead of throwing.
+ */
+export function createReviewThreadResolver(args: {
+  target: ScmReviewTarget;
+  github?: HostGitHubClient;
+}): ReviewThreadResolverImplementation | undefined {
+  switch (args.target.provider) {
+    case "github":
+      return args.github === undefined
+        ? undefined
+        : createHostGithubReviewThreadResolver(args.github);
+  }
+}
+
+/**
+ * Resolve the review threads that own `commentIds` on `prUrl`.
+ *
+ * No-ops (never throws) when the PR is on an SCM this host cannot write,
+ * no client is bound, or `commentIds` is empty. Same degrade-don't-fail
+ * posture as {@link createReviewCommentReader}.
+ */
+export async function resolveReviewThreadsForComments(args: {
+  prUrl: string;
+  commentIds: readonly number[];
+  github?: HostGitHubClient;
+  resolver?: ReviewThreadResolverImplementation;
+  signal?: AbortSignal;
+}): Promise<ResolveReviewThreadsResult> {
+  if (args.commentIds.length === 0) {
+    return skippedResolve("no comments to resolve");
+  }
+  const target = resolveScmReviewTarget(args.prUrl);
+  if (target === undefined) {
+    return skippedResolve("no SCM resolver for this PR URL");
+  }
+  const resolver =
+    args.resolver ??
+    createReviewThreadResolver({
+      target,
+      github: args.github,
+    });
+  if (resolver === undefined) {
+    return skippedResolve("no GitHub client bound to resolve threads");
+  }
+  return resolver.resolveReviewThreadsForComments({
+    target,
+    commentIds: args.commentIds,
+    signal: args.signal,
+  });
+}
+
 /** Cap on pages pulled per PR; GitHub serves 100 comments per page. */
 const REVIEW_COMMENTS_MAX_PAGES = 5;
 const REVIEW_COMMENTS_PAGE_SIZE = 100;
+/** Cap on review-thread pages when mapping comment ids to GraphQL thread ids. */
+const REVIEW_THREADS_MAX_PAGES = 20;
+const REVIEW_THREADS_PAGE_SIZE = 100;
 
 /**
  * Reads inline review comments through the host GitHub client (Cursor
@@ -182,6 +275,188 @@ export function createHostGithubReviewCommentReader(
   };
 }
 
+type GithubReviewThreadNode = {
+  id?: string;
+  isResolved?: boolean;
+  comments?: {
+    nodes?: Array<{ databaseId?: number | null } | null>;
+  };
+};
+
+type GithubReviewThreadsQuery = {
+  repository?: {
+    pullRequest?: {
+      reviewThreads?: {
+        nodes?: Array<GithubReviewThreadNode | null>;
+        pageInfo?: { hasNextPage?: boolean; endCursor?: string | null };
+      };
+    } | null;
+  } | null;
+};
+
+type GithubResolveThreadMutation = {
+  resolveReviewThread?: {
+    thread?: { isResolved?: boolean };
+  };
+};
+
+/**
+ * Resolves inline review threads through the host GitHub client (Cursor
+ * account lease, App installation token, or PAT). GitHub GraphQL has no
+ * comment→thread field, so this pages the PR's review threads and matches
+ * each REST comment id by `databaseId` — the same approach as Bugbot's
+ * `resolveReviewThreadForComment`.
+ */
+export function createHostGithubReviewThreadResolver(
+  github: HostGitHubClient
+): ReviewThreadResolverImplementation {
+  return {
+    async resolveReviewThreadsForComments({ target, commentIds, signal }) {
+      const uniqueIds = [...new Set(commentIds.filter((id) => id > 0))];
+      if (uniqueIds.length === 0) {
+        return skippedResolve("no comments to resolve");
+      }
+      const [owner, repo] = target.repo.split("/", 2);
+      if (owner === undefined || repo === undefined || repo === "") {
+        return skippedResolve("unparseable owner/repo from PR URL");
+      }
+
+      try {
+        const octokit = await github.getOctokit();
+        const wanted = new Set(uniqueIds);
+        const matched = new Map<
+          number,
+          { threadId: string; isResolved: boolean }
+        >();
+
+        let cursor: string | null = null;
+        for (let page = 0; page < REVIEW_THREADS_MAX_PAGES; page++) {
+          signal?.throwIfAborted();
+          const response = (await octokit.graphql(REVIEW_THREADS_FOR_PR_QUERY, {
+            owner,
+            repo,
+            number: target.prNumber,
+            cursor,
+          })) as GithubReviewThreadsQuery;
+          const reviewThreads = response.repository?.pullRequest?.reviewThreads;
+          for (const thread of reviewThreads?.nodes ?? []) {
+            if (thread?.id === undefined || thread.id === "") {
+              continue;
+            }
+            for (const comment of thread.comments?.nodes ?? []) {
+              const databaseId = comment?.databaseId;
+              if (
+                databaseId !== undefined &&
+                databaseId !== null &&
+                wanted.has(databaseId) &&
+                !matched.has(databaseId)
+              ) {
+                matched.set(databaseId, {
+                  threadId: thread.id,
+                  isResolved: thread.isResolved === true,
+                });
+              }
+            }
+          }
+          if (matched.size === wanted.size) {
+            break;
+          }
+          const pageInfo = reviewThreads?.pageInfo;
+          if (pageInfo?.hasNextPage !== true || !pageInfo.endCursor) {
+            break;
+          }
+          cursor = pageInfo.endCursor;
+        }
+
+        const toResolve = [
+          ...new Map(
+            [...matched.values()]
+              .filter((thread) => !thread.isResolved)
+              .map((thread) => [thread.threadId, thread.threadId])
+          ).values(),
+        ];
+        let resolved = 0;
+        let failed = 0;
+        for (const threadId of toResolve) {
+          signal?.throwIfAborted();
+          try {
+            const mutation = (await octokit.graphql(
+              RESOLVE_REVIEW_THREAD_MUTATION,
+              { threadId }
+            )) as GithubResolveThreadMutation;
+            if (mutation.resolveReviewThread?.thread?.isResolved === true) {
+              resolved += 1;
+            } else {
+              failed += 1;
+            }
+          } catch {
+            failed += 1;
+          }
+        }
+
+        const alreadyResolved = new Set(
+          [...matched.values()]
+            .filter((thread) => thread.isResolved)
+            .map((thread) => thread.threadId)
+        ).size;
+        const notFound = wanted.size - matched.size;
+        return {
+          requested: uniqueIds.length,
+          resolved,
+          alreadyResolved,
+          notFound,
+          failed,
+          detail: `resolved ${resolved} of ${toResolve.length} open thread(s) for ${uniqueIds.length} comment(s) via host GitHub (${alreadyResolved} already resolved, ${notFound} not found, ${failed} failed)`,
+        };
+      } catch (error) {
+        if (signal?.aborted) {
+          throw error;
+        }
+        return {
+          requested: uniqueIds.length,
+          resolved: 0,
+          alreadyResolved: 0,
+          notFound: 0,
+          failed: uniqueIds.length,
+          detail: `host GitHub thread resolve failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+      }
+    },
+  };
+}
+
+const REVIEW_THREADS_FOR_PR_QUERY = `
+query ReviewThreadsForPr(
+  $owner: String!
+  $repo: String!
+  $number: Int!
+  $cursor: String
+) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      reviewThreads(first: ${REVIEW_THREADS_PAGE_SIZE}, after: $cursor) {
+        nodes {
+          id
+          isResolved
+          comments(first: ${REVIEW_THREADS_PAGE_SIZE}) {
+            nodes { databaseId }
+          }
+        }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+}
+`;
+
+const RESOLVE_REVIEW_THREAD_MUTATION = `
+mutation ResolveReviewThread($threadId: ID!) {
+  resolveReviewThread(input: { threadId: $threadId }) {
+    thread { isResolved }
+  }
+}
+`;
+
 type GithubReviewCommentLike = {
   id: number;
   path: string;
@@ -504,6 +779,17 @@ function skippedHost(detail: string): ReviewCommentPostResult {
   };
 }
 
+function skippedResolve(detail: string): ResolveReviewThreadsResult {
+  return {
+    requested: 0,
+    resolved: 0,
+    alreadyResolved: 0,
+    notFound: 0,
+    failed: 0,
+    detail,
+  };
+}
+
 function parseGithubPrUrl(
   prUrl: string
 ):

package/src/internal/session-engine.ts

@@ -25,12 +25,6 @@ import {
 } from "../channels/slack/nudge-store.js";
 import { resolveDedicatedSlackHostBinding } from "../channels/slack/slack-channel.js";
 import { isCursorHostedFilesAvailable } from "../files-backends/cursor-hosted.js";
-import {
-  SessionLedger,
-  type SessionLedgerKv,
-  supportsSessionLedgerKv,
-} from "../ledger/session-ledger.js";
-import { fileKv } from "../storage-backends/file-kv.js";
 import {
   type AgentProject,
   type ApprovalDecision,
@@ -48,7 +42,6 @@ import {
   DIRECT_TOOL_CALL_CHANNEL_ID,
   type HookHandler,
   type HostContext,
-  type HostKvApi,
   type HttpChannelDefinition,
   isHostOauthConnectionTransport,
   isSymbolicConnectionTransport,
@@ -88,11 +81,6 @@ import {
   mapSdkTokenUsage,
 } from "./cloud-turn-cost.js";
 import { isDevMode } from "./dev-mode.js";
-import {
-  ledgerKeyPrefix,
-  namespacedKv,
-  storageCasKv,
-} from "./durable-session-store.js";
 import { type EventLogMemoryStats, EventLogStore } from "./event-log.js";
 import { TurnEventMapper } from "./event-mapper.js";
 import { selectFrameworkStorageDefinition } from "./framework-storage-selection.js";
@@ -111,7 +99,6 @@ import {
   newToolCallId,
 } from "./ids.js";
 import { validateToolInput } from "./json-schema.js";
-import { LedgerServing, newLedgerPodId } from "./ledger-serving.js";
 import { McpHost } from "./mcp-host.js";
 import type { OtelCollector } from "./otel/collector.js";
 import {
@@ -158,7 +145,7 @@ export class SessionBusyError extends Error {
   }
 }
 
-// Defined in auth.js (the ledger pump needs it without importing this
+// Defined in auth.js (HTTP/session-store callers import it without this
 // module); re-exported here because this is its historical public home.
 export { SessionAuthError } from "./auth.js";
 
@@ -235,22 +222,6 @@ export interface SessionEngineOptions {
    * stub; production uses billed usage events when an agent id is known.
    */
   estimateTurnCost?: EstimateTurnCostFn;
-  /**
-   * Explicit durable-session store for `serving: "ledger"` agents — a KV
-   * dedicated to the ledger (session identity, leases, commit heads),
-   * separate from agent state. Must implement the full CAS-capable KV
-   * surface (`HostKvCasApi`: the CAS trio plus `get`/`put`/`delete` for
-   * mailbox payload blobs and `listKeys` for the janitor scan);
-   * construction fails fast otherwise. Supply the **raw** store: the
-   * engine owns key scoping and namespaces every ledger key under
-   * `agentkit/v1/<agent>/durable-session/` itself — a self-hoster never
-   * writes prefixes. Default when omitted: the authored storage backend
-   * (`agent/storage.ts`) when it implements the `cas` group, else — with
-   * no authored storage — a file store under `<stateRoot>/ledger-kv`
-   * (single-process correctness only). An authored storage backend
-   * *without* `cas` fails fast. Ignored for resident-mode agents.
-   */
-  durableSessionStore?: HostKvApi;
   /** Process-level OTel collector; observe-only, never fatal. */
   otel?: OtelCollector;
   /** Process-level meter for {@link HostContext.otel}. Absent → no-op counters. */
@@ -290,14 +261,6 @@ interface ActiveToolContext {
 
 export interface EngineSendOptions extends SendMessageOptions {
   mode?: "chat" | "task";
-  /**
-   * Internal (ledger serving): set only by the ledger pump when it
-   * executes an already-parked event under its lease, so the call must
-   * run the resident path. Without the flag, every send on a
-   * `serving: "ledger"` agent routes through the ledger (append → claim
-   * → drain → turn → commit) and the pump would recurse into itself.
-   */
-  fromLedgerPump?: boolean;
 }
 
 interface CoalescedQueuedTurn {
@@ -400,12 +363,6 @@ export class SessionEngine {
   private readonly cloudCostBackfillDone = new Set<string>();
   /** Deduped in-flight cloud cost backfills, keyed by session id. */
   private readonly cloudCostBackfill = new Map<string, Promise<void>>();
-  /**
-   * Ledger-mode delivery seam; set only when the agent declares
-   * `serving: "ledger"`. When present, {@link send} routes every
-   * non-delivery call through the ledger's claim → turn → commit.
-   */
-  private readonly ledgerServing: LedgerServing | undefined;
 
   constructor(options: SessionEngineOptions) {
     this.project = options.project;
@@ -499,8 +456,6 @@ export class SessionEngine {
     for (const channel of options.project.channels) {
       this.channelsById.set(channel.id, channel.definition);
     }
-    this.ledgerServing = this.buildLedgerServing(options);
-    this.ledgerServing?.start();
     this.stopMemoryTelemetry = shouldStartProcessMemoryTelemetry()
       ? startProcessMemoryTelemetry({
           agentName: options.project.name,
@@ -511,113 +466,6 @@ export class SessionEngine {
       : undefined;
   }
 
-  /**
-   * Ledger-mode wiring (`serving: "ledger"`): resolve a CAS-capable
-   * durable-session store and build the event pump. Resident agents
-   * (the default) return undefined and never touch ledger keys.
-   */
-  private buildLedgerServing(
-    options: SessionEngineOptions
-  ): LedgerServing | undefined {
-    if (options.project.agent.serving !== "ledger") {
-      return undefined;
-    }
-    // The handle is already agent-scoped (resolveDurableSessionStore):
-    // two ledger-mode agents sharing one backend never resolve to each
-    // other's sessions or janitor-claim each other's parked envelopes.
-    const ledgerKv = this.resolveDurableSessionStore(options);
-    return new LedgerServing({
-      ledger: new SessionLedger({ kv: ledgerKv, podId: newLedgerPodId() }),
-      deliverTurn: (envelope) =>
-        this.send(envelope.channelId, envelope.message, {
-          continuationToken: envelope.continuationToken,
-          auth: envelope.auth,
-          ...(envelope.title === undefined ? {} : { title: envelope.title }),
-          ...(envelope.state === undefined ? {} : { state: envelope.state }),
-          ...(envelope.mode === undefined ? {} : { mode: envelope.mode }),
-          ...(envelope.purpose === undefined
-            ? {}
-            : { purpose: envelope.purpose }),
-          // Isolation overrides ride the envelope: without them the
-          // drained turn would run local with the default harness cwd
-          // instead of the cloud VM / channel worktree the sender bound.
-          ...(envelope.workspaceDir === undefined
-            ? {}
-            : { workspaceDir: envelope.workspaceDir }),
-          ...(envelope.cloud === undefined ? {} : { cloud: envelope.cloud }),
-          fromLedgerPump: true,
-        }),
-      findSession: async (channelId, continuationToken) => {
-        let record = await this.sessions.findByContinuation(
-          channelId,
-          continuationToken
-        );
-        if (record === undefined) {
-          record = await this.restoreSessionByContinuation(
-            channelId,
-            continuationToken
-          );
-        }
-        return record === undefined
-          ? undefined
-          : this.channelSession(record.sessionId, record, false);
-      },
-      logger: this.logger,
-    });
-  }
-
-  /**
-   * Pick the KV the ledger coordinates on, in precedence order:
-   *
-   * 1. `options.durableSessionStore` — an explicit store separate from
-   *    agent state (advanced deployments, tests).
-   * 2. The authored storage backend (`agent/storage.ts`) when it
-   *    implements the `cas` group — one backend serves both the storage
-   *    API and the durable session API.
-   * 3. No authored storage: a file store under `<stateRoot>/ledger-kv`
-   *    (same place resident state lives; single-process only).
-   *
-   * An authored backend without `cas` fails fast: silently falling back
-   * to local files would fork coordination away from the deployment's
-   * durable store. The check demands the full surface the inbox uses —
-   * the CAS trio plus `get`/`put`/`delete` for mailbox payload blobs and
-   * `listKeys` for the janitor scan and the orphan sweep.
-   *
-   * Whatever store wins, the returned handle is scoped here — once —
-   * under `agentkit/v1/<agent>/durable-session/`. The ledger speaks bare
-   * `session/…` / `ledger/…` / `mailbox/…` keys; namespacing is this
-   * boundary's job, exactly like `host.kv`'s agent scoping.
-   */
-  private resolveDurableSessionStore(
-    options: SessionEngineOptions
-  ): SessionLedgerKv {
-    const namespace = ledgerKeyPrefix(options.project.name);
-    const explicit = options.durableSessionStore;
-    if (explicit !== undefined) {
-      if (!supportsSessionLedgerKv(explicit)) {
-        throw new Error(
-          `Agent "${options.project.name}" declares serving: "ledger", but the configured durableSessionStore is not CAS-capable (getWithVersion / putIfAbsent / putIfVersion / listKeys). Provide a store implementing HostKvCasApi (see @cursor/july/kv).`
-        );
-      }
-      return namespacedKv(explicit, namespace);
-    }
-    const casArgs = {
-      agentName: options.project.name,
-      projectRoot: options.project.rootDir,
-    };
-    const authored = options.project.storage;
-    if (authored !== undefined) {
-      if (authored.cas === undefined) {
-        throw new Error(
-          `Agent "${options.project.name}" declares serving: "ledger", which needs conditional writes, but the storage backend in agent/storage.ts does not implement the cas group. Add cas: {...} to defineStorage (fileKv and cursorHostedStorage already include it), or pass an explicit durableSessionStore.`
-        );
-      }
-      return namespacedKv(storageCasKv(authored, casArgs), namespace);
-    }
-    const fallback = fileKv({ dir: join(options.stateRoot, "ledger-kv") });
-    return namespacedKv(storageCasKv(fallback, casArgs), namespace);
-  }
-
   /**
    * Attach serve-time resolved connections (peers, Cursor account bridge).
    * They join the per-turn SDK `mcpServers` map (loopback URL for local
@@ -892,12 +740,6 @@ export class SessionEngine {
     message: string,
     options: EngineSendOptions = {}
   ): Promise<ChannelSession> {
-    // Ledger-mode agents park the event durably and coordinate through
-    // the session lease before any turn runs; only the pump's own
-    // lease-holding deliveries fall through to the resident path.
-    if (this.ledgerServing !== undefined && options.fromLedgerPump !== true) {
-      return this.ledgerServing.deliver(channelId, message, options);
-    }
     const auth = options.auth ?? null;
     let existing =
       options.continuationToken === undefined
@@ -1008,13 +850,6 @@ export class SessionEngine {
     };
     await this.sessions.save(record);
     this.storage?.sessionRecord(record);
-    // Ledger serving: another pod can follow up mid-turn, so the session
-    // identity (record + continuation index) must hit the shared store
-    // before we return a session id. Default turnEnd flush is too late.
-    if (this.ledgerServing !== undefined && this.storage !== undefined) {
-      this.storage.flushSession(record.sessionId);
-      await this.storage.whenIdle();
-    }
     await this.appendEvent(record.sessionId, {
       type: "session.started",
       data: { channelId },
@@ -3841,8 +3676,6 @@ export class SessionEngine {
   async close(): Promise<void> {
     this.stopMemoryTelemetry?.();
     this.approvals.cancelAll("deny");
-    // Ledger deliveries spawn turns, so settle them before activeTurns.
-    await this.ledgerServing?.close();
     await Promise.allSettled([...this.activeTurns.values()]);
     await Promise.allSettled([...this.backgroundWork]);
     await Promise.allSettled([...this.dispatchChains.values()]);

package/src/kv/memory-kv.ts

@@ -4,8 +4,7 @@
  * `@cursor/july/kv/memory`.
  *
  * The memory KV *is* the dev shim: tests and local runs exercise the
- * same CAS coordination paths that hosted serving uses, not a mock of an
- * RPC. Values are deep-copied on both write and
+ * CAS contract, not a mock of an RPC. Values are deep-copied on both write and
  * read so callers can never observe (or cause) shared-reference mutation.
  */
 
@@ -86,14 +85,6 @@ export function createMemoryKv(): HostKvCasApi {
  * fixtures, an off-hosting no-op sink). Non-durable and process-local by
  * construction; a real deployment backend should implement CAS against
  * its own store instead.
- *
- * **Never pair this with `serving: "ledger"` on a real backend.** The
- * ledger derives its coordination store from the whole storage config,
- * so a durable plain backend with a memory `cas` group silently voids
- * ack-after-durable: leases, heads, and pending indexes live only in
- * this process and vanish on restart while payload blobs go through the
- * plain methods. Ledger state must live in the same durable store as
- * the blobs.
  */
 export function memoryCasTable(): StorageCasTable {
   const kv = createMemoryKv();

package/src/kv.ts

@@ -2,9 +2,8 @@
  * The CAS-capable KV **interface** — `@cursor/july/kv`.
  *
  * This module is implementation-free on purpose: it is the contract a
- * bring-your-own KV implements so coordination protocols (conditional
- * writes are the substrate for the upcoming session ledger) can run on
- * it. {@link HostKvCasApi} is the conditional-write superset of the plain
+ * bring-your-own KV implements so conditional writes can run on it.
+ * {@link HostKvCasApi} is the conditional-write superset of the plain
  * {@link HostKvApi}; {@link supportsKvCas} is the runtime probe for
  * stores of unknown provenance — a `defineStorage` backend declares CAS
  * through its `cas` group instead, so it never needs probing.

package/src/storage-backends/cursor-hosted.ts

@@ -313,9 +313,9 @@ export function cursorHostedStorage(
           { prefix }
         );
         if (result.truncated === true) {
-          // Callers (the ledger janitor above all) treat the result as
-          // the complete key set; a silently capped scan means silently
-          // unrecovered sessions. Fail loudly until pagination lands.
+          // Callers treat the result as the complete key set; a silently
+          // capped scan hides missing keys. Fail loudly until pagination
+          // lands.
           throw new Error(
             `cursorHostedStorage: listKeys("${prefix}") exceeded the server's row cap and was truncated; the result is incomplete`
           );

package/src/storage-protocol.ts

@@ -4,9 +4,7 @@
  * `backend/server/src/agentServe/durableSessionProtocol.ts`) so a dashboard
  * list can read Bugbot KV without importing `@cursor/july`.
  *
- * Additive JSON only — unknown fields are ignored. Do not put ledger
- * (`durable-session/`) types here; those are coordination-only and must not
- * appear in the CP session list.
+ * Additive JSON only — unknown fields are ignored.
  */
 
 import { createHash } from "node:crypto";
@@ -19,8 +17,7 @@ export const STORAGE_KEY_ROOT = "agentkit/v1" as const;
 
 /**
  * Exact session-record keys: `agentkit/v1/{agent}/session/{sessionId}`.
- * Rejects `session-events/`, `durable-session/`, and the CP-owned `_cp`
- * agent name.
+ * Rejects `session-events/` and the CP-owned `_cp` agent name.
  */
 const DURABLE_SESSION_RECORD_KEY_RE =
   /^agentkit\/v1\/([^/]+)\/session\/([^/]+)$/;
@@ -109,9 +106,6 @@ export const MAX_KEY_SEGMENT_BYTES = 256;
  * digest of the raw value when the encoding exceeds
  * {@link MAX_KEY_SEGMENT_BYTES}. Deterministic, so key construction on the
  * write path and the continuation-lookup path always agree.
- *
- * Exported for the session ledger, which builds its `session/` and
- * `ledger/` keys with the same encoding rules.
  */
 export function keySegment(raw: string): string {
   const encoded = encodeURIComponent(raw);
@@ -163,8 +157,8 @@ function stringValue(value: unknown): string | undefined {
 }
 
 /**
- * Tolerant `SessionRecord` decoder. Extra fields (`auth`, `purpose`, ledger
- * extras, future keys) are ignored. Returns undefined when required list
+ * Tolerant `SessionRecord` decoder. Extra fields (`auth`, `purpose`,
+ * future keys) are ignored. Returns undefined when required list
  * fields are missing or the wrong type.
  */
 export function parseDurableSessionRecord(