@cursor/july 0.1.29 → 0.1.31

package/src/internal/session-engine.ts

@@ -79,6 +79,7 @@ import {
 import { isDevMode } from "./dev-mode.js";
 import { EventLogStore } from "./event-log.js";
 import { TurnEventMapper } from "./event-mapper.js";
+import { createHostFilesApi } from "./host-files.js";
 import { createHostKvApi } from "./host-kv.js";
 import {
   createHostPlatforms,
@@ -93,7 +94,6 @@ import {
 } from "./ids.js";
 import { validateToolInput } from "./json-schema.js";
 import { McpHost } from "./mcp-host.js";
-import { estimateTurnCost } from "./model-pricing.js";
 import {
   buildSessionContextBlock,
   SCHEDULE_CHANNEL_PREFIX,
@@ -103,6 +103,11 @@ import type { AgentRunner } from "./sdk-runner.js";
 import { SessionStore } from "./session-store.js";
 import { StorageCoordinator } from "./storage-coordinator.js";
 import { normalizeToolResult, toolCallErrorMessage } from "./tool-result.js";
+import {
+  type EstimateTurnCostFn,
+  estimateTurnCostFromApi,
+  roundCostUsd,
+} from "./turn-cost.js";
 import { TurnGovernor } from "./turn-governor.js";
 import {
   buildAgentsMdContent,
@@ -200,6 +205,11 @@ export interface SessionEngineOptions {
    * usage/cost so the playground Trace tab can still show an estimate.
    */
   getCloudUsage?: (sdkAgentId: string) => Promise<CloudAgentUsage | undefined>;
+  /**
+   * Resolve turn cost via `POST /v1/models/estimate-cost`. Tests inject a
+   * stub; production uses billed usage events when an agent id is known.
+   */
+  estimateTurnCost?: EstimateTurnCostFn;
 }
 
 /**
@@ -303,6 +313,7 @@ export class SessionEngine {
   private reminderApi: HostContext["reminders"];
   private evalsApi: HostContext["evals"];
   private readonly kvApi: HostContext["kv"];
+  private readonly filesApi: HostContext["files"];
   /** Engine-owned artifacts service behind every `ctx.artifacts` facade. */
   private readonly artifactsStore: ArtifactsStore;
   /** Serve-time resolved connections (see {@link setResolvedConnections}). */
@@ -310,6 +321,7 @@ export class SessionEngine {
   private readonly getCloudUsage: (
     sdkAgentId: string
   ) => Promise<CloudAgentUsage | undefined>;
+  private readonly estimateTurnCost: EstimateTurnCostFn;
   /** Sessions whose completed turns are fully priced (no further backfill). */
   private readonly cloudCostBackfillDone = new Set<string>();
   /** Deduped in-flight cloud cost backfills, keyed by session id. */
@@ -321,6 +333,7 @@ export class SessionEngine {
     this.runner = options.runner;
     this.logger = options.logger ?? (() => {});
     this.getCloudUsage = options.getCloudUsage ?? defaultGetCloudUsage;
+    this.estimateTurnCost = options.estimateTurnCost ?? estimateTurnCostFromApi;
     this.turnGovernor = new TurnGovernor(options.project.agent.concurrency);
     this.sessions = new SessionStore(join(options.stateRoot, "sessions"));
     this.nudgeStore = new SlackNudgeStore(
@@ -333,7 +346,7 @@ export class SessionEngine {
       (sessionId) => this.sessions.eventFilePath(sessionId),
       (sessionId, error) =>
         this.logger(
-          `[agentkit] failed to persist events for ${sessionId}: ${describeError(error)}`
+          `[agent-sdk] failed to persist events for ${sessionId}: ${describeError(error)}`
         )
     );
     this.storage =
@@ -350,6 +363,10 @@ export class SessionEngine {
       stateRoot: options.stateRoot,
       ...(this.storage === undefined ? {} : { storage: this.storage }),
     });
+    this.filesApi = createHostFilesApi({
+      agentName: options.project.name,
+      stateRoot: options.stateRoot,
+    });
     this.artifactsStore = new ArtifactsStore({
       stateRoot: options.stateRoot,
       storage: this.storage,
@@ -419,10 +436,24 @@ export class SessionEngine {
       reminders: this.reminderApi,
       evals: this.evalsApi,
       kv: this.kvApi,
+      files: this.filesApi,
       slackNudges: this.slackNudgeHostApi(),
     };
   }
 
+  /**
+   * Host services with `files` bound to one session, so a relative path in a
+   * tool or hook resolves to that session's scope and can never be read as
+   * another session's. Unbound (no session) keeps `host.files` usable for
+   * `{ scope: "deployment" }` and fails loudly on session-scoped calls.
+   */
+  private hostForSession(sessionId: string | undefined): HostContext {
+    const host = this.host;
+    return sessionId === undefined
+      ? host
+      : { ...host, files: this.filesApi.forSession(sessionId) };
+  }
+
   /** Unbound `ctx.artifacts` facade (channel handlers, scratch tool calls). */
   get artifacts(): ArtifactsApi {
     return this.artifactsApi();
@@ -684,7 +715,7 @@ export class SessionEngine {
         }
       } catch (error) {
         this.logger(
-          `[agentkit] ab "${experiment.name}" enrollment failed (sticky skip): ${describeError(error)}`
+          `[agent-sdk] ab "${experiment.name}" enrollment failed (sticky skip): ${describeError(error)}`
         );
         variant = null;
       }
@@ -1165,12 +1196,12 @@ export class SessionEngine {
       // tell an operator the workspace is hot when nothing touched it.
       this.logger(
         outcome.warmed
-          ? `[agentkit] warmed ${workspaceDir} in ${Date.now() - startedAt}ms`
-          : `[agentkit] did not warm ${workspaceDir}: ${outcome.reason}`
+          ? `[agent-sdk] warmed ${workspaceDir} in ${Date.now() - startedAt}ms`
+          : `[agent-sdk] did not warm ${workspaceDir}: ${outcome.reason}`
       );
     } catch (error) {
       this.logger(
-        `[agentkit] could not warm ${workspaceDir}: ${describeError(error)}`
+        `[agent-sdk] could not warm ${workspaceDir}: ${describeError(error)}`
       );
     }
   }
@@ -1203,7 +1234,7 @@ export class SessionEngine {
         this.queueDispatch(sessionId, event);
       } catch (error) {
         this.logger(
-          `[agentkit] failed to record event for ${sessionId}: ${describeError(error)}`
+          `[agent-sdk] failed to record event for ${sessionId}: ${describeError(error)}`
         );
       }
     };
@@ -1306,15 +1337,15 @@ export class SessionEngine {
 
     const finalResult = outcome.result ?? mapper.finalText;
     const finalUsage = outcome.usage ?? mapper.usage;
-    // Estimated dollar cost of this loop pass, persisted alongside usage so
-    // traces / A/B metrics / the CLI can aggregate spend without re-pricing.
     const finalCost =
       finalUsage === undefined
         ? undefined
-        : estimateTurnCost(
-            this.project.agent.model ?? DEFAULT_MODEL,
-            finalUsage
-          );
+        : await this.estimateTurnCost({
+            model: this.project.agent.model ?? DEFAULT_MODEL,
+            usage: finalUsage,
+            agentId: record.sdkAgentId,
+            conversationId: record.sdkAgentId ?? sessionId,
+          });
     if (finalCost !== undefined) {
       outcome = { ...outcome, cost: finalCost };
     }
@@ -1561,7 +1592,7 @@ export class SessionEngine {
             session: this.sessionInfo(record),
             workspaceDir: this.harnessCwd(record),
             stateRoot: this.stateRoot,
-            host: this.host,
+            host: this.hostForSession(record.sessionId),
             artifacts: this.artifactsApi({
               sessionId: record.sessionId,
               turnId,
@@ -1887,7 +1918,7 @@ export class SessionEngine {
           session,
           workspaceDir,
           stateRoot: this.stateRoot,
-          host: this.host,
+          host: this.hostForSession(record?.sessionId),
           // Scratch calls have no real session; their facade stays unbound.
           artifacts:
             record === undefined
@@ -1977,7 +2008,7 @@ export class SessionEngine {
       .then(() => this.dispatchEvent(sessionId, event))
       .catch((error) => {
         this.logger(
-          `[agentkit] event dispatch failed for ${sessionId}: ${describeError(error)}`
+          `[agent-sdk] event dispatch failed for ${sessionId}: ${describeError(error)}`
         );
       })
       .then(() => {
@@ -2022,7 +2053,7 @@ export class SessionEngine {
           await handler(event, channelCtx, sessionCtx);
         } catch (error) {
           this.logger(
-            `[agentkit] channel "${record.channelId}" handler for ${event.type} threw: ${describeError(error)}`
+            `[agent-sdk] channel "${record.channelId}" handler for ${event.type} threw: ${describeError(error)}`
           );
         }
       }
@@ -2055,7 +2086,7 @@ export class SessionEngine {
           });
         } catch (error) {
           this.logger(
-            `[agentkit] hook "${hook.name}" handler for ${event.type} threw: ${describeError(error)}`
+            `[agent-sdk] hook "${hook.name}" handler for ${event.type} threw: ${describeError(error)}`
           );
         }
       }
@@ -2165,7 +2196,7 @@ export class SessionEngine {
         };
       } catch (error) {
         this.logger(
-          `[agentkit] cursor-hosted session list failed; falling back to local: ${describeError(error)}`
+          `[agent-sdk] cursor-hosted session list failed; falling back to local: ${describeError(error)}`
         );
       }
     }
@@ -2306,7 +2337,7 @@ export class SessionEngine {
     startIndex = 0
   ): Promise<ReadableStream<Uint8Array>> {
     // Playground Trace replays this stream; backfill before the snapshot
-    // so historical Sherlock-style cloud turns can show est. cost.
+    // so historical Sherlock-style cloud turns can show billed cost.
     await this.backfillCloudTurnCosts(sessionId);
     const log = await this.logs.get(sessionId);
     return log.stream(startIndex);
@@ -2355,6 +2386,84 @@ export class SessionEngine {
     });
   }
 
+  /**
+   * Billed/catalog cost for a session. Powers playground, traces, and
+   * `agent-sdk cost` via `GET /v1/session/:id/cost`.
+   */
+  async sessionCost(sessionId: string): Promise<{
+    sessionId: string;
+    source: "usage" | "catalog" | "unavailable";
+    cost: { rawCostCents: number; chargedCents: number };
+    costUsd: number;
+    rawCostUsd: number;
+    model?: string;
+  }> {
+    const record = await this.getOrRestoreSession(sessionId);
+    if (record === undefined) {
+      throw new Error(`Unknown session: ${sessionId}`);
+    }
+    await this.backfillCloudTurnCosts(sessionId);
+    const events = await this.listEvents(sessionId);
+    const sdkAgentId =
+      (record.sdkAgentId !== undefined && record.sdkAgentId !== ""
+        ? record.sdkAgentId
+        : undefined) ?? cloudSdkAgentIdFromEvents(events);
+    const model = this.project.agent.model ?? DEFAULT_MODEL;
+    const priced = await this.estimateTurnCost({
+      model,
+      agentId: sdkAgentId,
+      conversationId: sdkAgentId ?? sessionId,
+    });
+    if (
+      priced !== undefined &&
+      (priced.source === "usage" || priced.totalUsd > 0)
+    ) {
+      return {
+        sessionId,
+        source: priced.source,
+        cost: {
+          rawCostCents: priced.rawCostCents ?? priced.chargedCents ?? 0,
+          chargedCents: priced.chargedCents ?? priced.totalUsd * 100,
+        },
+        costUsd: priced.totalUsd,
+        rawCostUsd: roundCostUsd(
+          (priced.rawCostCents ??
+            priced.chargedCents ??
+            priced.totalUsd * 100) / 100
+        ),
+        model: priced.model,
+      };
+    }
+    let costUsd = 0;
+    let rawCostUsd = 0;
+    let source: "usage" | "catalog" | "unavailable" = "unavailable";
+    let modelId: string | undefined;
+    for (const event of events) {
+      if (event.type !== "turn.completed" || event.data.cost === undefined) {
+        continue;
+      }
+      costUsd = roundCostUsd(costUsd + event.data.cost.totalUsd);
+      const rawCents = event.data.cost.rawCostCents;
+      rawCostUsd = roundCostUsd(
+        rawCostUsd +
+          (rawCents !== undefined ? rawCents / 100 : event.data.cost.totalUsd)
+      );
+      source = event.data.cost.source;
+      modelId = event.data.cost.model;
+    }
+    return {
+      sessionId,
+      source,
+      cost: {
+        rawCostCents: rawCostUsd * 100,
+        chargedCents: costUsd * 100,
+      },
+      costUsd,
+      rawCostUsd,
+      model: modelId,
+    };
+  }
+
   /** Snapshot of recorded events (for download / offline trace). */
   async listEvents(
     sessionId: string,
@@ -2371,7 +2480,7 @@ export class SessionEngine {
   /**
    * Historical cloud turns may lack usage/cost on `turn.completed` (pre-0.1.29
    * engines, or getUsage still zero at turn end). Fill them from billed usage
-   * before the playground replays the stream so Trace can show est. cost.
+   * before the playground replays the stream so Trace can show cost.
    */
   private backfillCloudTurnCosts(sessionId: string): Promise<void> {
     if (this.cloudCostBackfillDone.has(sessionId)) {
@@ -2384,7 +2493,7 @@ export class SessionEngine {
     const work = this.runCloudTurnCostBackfill(sessionId)
       .catch((error) => {
         this.logger(
-          `[agentkit] cloud cost backfill failed for ${sessionId}: ${describeError(error)}`
+          `[agent-sdk] cloud cost backfill failed for ${sessionId}: ${describeError(error)}`
         );
       })
       .finally(() => {
@@ -2599,7 +2708,9 @@ export class SessionEngine {
     try {
       await this.runBulkRestore(storage, policy);
     } catch (error) {
-      this.logger(`[agentkit] session restore failed: ${describeError(error)}`);
+      this.logger(
+        `[agent-sdk] session restore failed: ${describeError(error)}`
+      );
     }
   }
 
@@ -2656,7 +2767,7 @@ export class SessionEngine {
             return { record, events };
           } catch (error) {
             this.logger(
-              `[agentkit] failed to restore session ${record.sessionId}: ${describeError(error)}`
+              `[agent-sdk] failed to restore session ${record.sessionId}: ${describeError(error)}`
             );
             return undefined;
           }
@@ -2675,7 +2786,7 @@ export class SessionEngine {
           (ndjson === undefined ? 0 : Buffer.byteLength(ndjson, "utf8"));
         if (bytes > budget) {
           this.logger(
-            `[agentkit] session restore stopped at the ${policy.maxTotalBytes}-byte budget after ${restored} session(s); remaining sessions restore lazily on resume`
+            `[agent-sdk] session restore stopped at the ${policy.maxTotalBytes}-byte budget after ${restored} session(s); remaining sessions restore lazily on resume`
           );
           break outer;
         }
@@ -2685,13 +2796,13 @@ export class SessionEngine {
           restored += 1;
         } catch (error) {
           this.logger(
-            `[agentkit] failed to restore session ${item.record.sessionId}: ${describeError(error)}`
+            `[agent-sdk] failed to restore session ${item.record.sessionId}: ${describeError(error)}`
           );
         }
       }
     }
     if (restored > 0) {
-      this.logger(`[agentkit] restored ${restored} session(s) from storage`);
+      this.logger(`[agent-sdk] restored ${restored} session(s) from storage`);
     }
   }
 
@@ -2805,7 +2916,7 @@ export class SessionEngine {
     const events = await storage.listSessionEvents(record.sessionId);
     await this.materializeSession(record, eventsNdjson(events));
     this.logger(
-      `[agentkit] lazily restored session ${record.sessionId} from storage`
+      `[agent-sdk] lazily restored session ${record.sessionId} from storage`
     );
     return record;
   }
@@ -2895,9 +3006,11 @@ async function defaultGetCloudUsage(
     const billed = await Agent.getUsage(sdkAgentId);
     return {
       usage: mapSdkTokenUsage(billed.usage),
+      cost: billed.cost,
       runs: billed.runs.map((run) => ({
         runId: run.runId,
         usage: mapSdkTokenUsage(run.usage),
+        cost: run.cost,
       })),
     };
   } catch {

package/src/internal/slack-provision-client.ts

@@ -381,7 +381,7 @@ function mapErrorResponse(
   switch (response.status) {
     case 401:
       return new SlackProvisionApiError(
-        "The Cursor API key was rejected. Run `agentkit login` again or update CURSOR_API_KEY.",
+        "The Cursor API key was rejected. Run `agent-sdk login` again or update CURSOR_API_KEY.",
         { status: 401 }
       );
     case 403:

package/src/internal/storage-coordinator.ts

@@ -399,7 +399,7 @@ export class StorageCoordinator {
       // under at-most-once). The session is unrecoverable; treat as a miss
       // so the conversation can continue rather than failing forever.
       this.logger(
-        `[agentkit] storage continuation entry points at missing session ${sessionId}; treating as a miss`
+        `[agent-sdk] storage continuation entry points at missing session ${sessionId}; treating as a miss`
       );
       return undefined;
     }
@@ -566,7 +566,7 @@ export class StorageCoordinator {
           return Array.isArray(runs) ? runs : [];
         } catch (error) {
           this.logger(
-            `[agentkit] storage evals.list() failed: ${describeError(error)}`
+            `[agent-sdk] storage evals.list() failed: ${describeError(error)}`
           );
           return [];
         }
@@ -628,7 +628,7 @@ export class StorageCoordinator {
       return value ?? undefined;
     } catch (error) {
       this.logger(
-        `[agentkit] storage abs.getSnapshot() failed: ${describeError(error)}`
+        `[agent-sdk] storage abs.getSnapshot() failed: ${describeError(error)}`
       );
       return undefined;
     }
@@ -661,7 +661,7 @@ export class StorageCoordinator {
     clearTimeout(timer);
     if (!drained) {
       this.logger(
-        `[agentkit] storage shutdown drain timed out after ${CLOSE_DRAIN_TIMEOUT_MS}ms with ${this.pending} write(s) undelivered`
+        `[agent-sdk] storage shutdown drain timed out after ${CLOSE_DRAIN_TIMEOUT_MS}ms with ${this.pending} write(s) undelivered`
       );
     }
   }
@@ -709,7 +709,7 @@ export class StorageCoordinator {
       return Array.isArray(entries) ? entries : [];
     } catch (error) {
       this.logger(
-        `[agentkit] storage list(${prefix}) failed: ${describeError(error)}`
+        `[agent-sdk] storage list(${prefix}) failed: ${describeError(error)}`
       );
       return [];
     }
@@ -723,7 +723,7 @@ export class StorageCoordinator {
       this.dropped += ops.length;
       if (this.dropped <= ops.length || this.dropped % 1_000 < ops.length) {
         this.logger(
-          `[agentkit] storage queue full (${MAX_PENDING_OPS} pending writes); dropped ${this.dropped} write(s) so far — the sink is too slow for the traffic`
+          `[agent-sdk] storage queue full (${MAX_PENDING_OPS} pending writes); dropped ${this.dropped} write(s) so far — the sink is too slow for the traffic`
         );
       }
       return;
@@ -736,7 +736,7 @@ export class StorageCoordinator {
           await op.run(ctx);
         } catch (error) {
           this.logger(
-            `[agentkit] storage ${op.label} failed: ${describeError(error)}`
+            `[agent-sdk] storage ${op.label} failed: ${describeError(error)}`
           );
         } finally {
           this.pending -= 1;

package/src/internal/trajectory.ts

@@ -355,7 +355,7 @@ export function formatTrajectoryText(trajectory: Trajectory): string {
     `turns: ${trajectory.turns.length}  tools=${trajectory.toolCallCount}  failed: ${trajectory.turnsFailed}${
       trajectory.totalCostUsd === undefined
         ? ""
-        : `  est. cost: ${formatCostUsd(trajectory.totalCostUsd)}`
+        : `  cost: ${formatCostUsd(trajectory.totalCostUsd)}`
     }`
   );
   for (const turn of trajectory.turns) {
@@ -397,7 +397,7 @@ export function formatTrajectoryText(trajectory: Trajectory): string {
         `  usage: in ${turn.usage.inputTokens} out ${turn.usage.outputTokens}${
           turn.cost === undefined
             ? ""
-            : `  est. cost: ${formatCostUsd(turn.cost.totalUsd)}`
+            : `  cost: ${formatCostUsd(turn.cost.totalUsd)}`
         }`
       );
     }

package/src/internal/turn-cost.ts

@@ -0,0 +1,110 @@
+/**
+ * Dollar cost for an agent turn, computed by the Cloud Agents
+ * `POST /v1/models/estimate-cost` endpoint (billed usage events when an
+ * agent/conversation id is known, otherwise live catalog pricing).
+ */
+
+import type { ModelSetting, TurnCost, TurnUsage } from "../types.js";
+import { cursorExternalApiUrl, resolveApiKey } from "./cursor/credentials.js";
+
+export interface UsageCostCents {
+  rawCostCents: number;
+  chargedCents: number;
+}
+
+export interface EstimateTurnCostInput {
+  model: ModelSetting;
+  usage?: TurnUsage;
+  agentId?: string;
+  conversationId?: string;
+  runId?: string;
+}
+
+export type EstimateTurnCostFn = (
+  input: EstimateTurnCostInput
+) => Promise<TurnCost | undefined>;
+
+export function modelSettingId(model: ModelSetting): string {
+  return typeof model === "string" ? model : model.id;
+}
+
+export function roundCostUsd(usd: number): number {
+  return Math.round(usd * 1e6) / 1e6;
+}
+
+export function turnCostFromCents(args: {
+  model: string | ModelSetting;
+  cost: UsageCostCents;
+  source: TurnCost["source"];
+}): TurnCost {
+  const totalUsd = roundCostUsd(args.cost.chargedCents / 100);
+  const model =
+    typeof args.model === "string" ? args.model : modelSettingId(args.model);
+  return {
+    totalUsd,
+    inputUsd: 0,
+    outputUsd: 0,
+    cacheReadUsd: 0,
+    cacheWriteUsd: 0,
+    model,
+    source: args.source,
+    rawCostCents: args.cost.rawCostCents,
+    chargedCents: args.cost.chargedCents,
+  };
+}
+
+interface EstimateCostApiResponse {
+  model?: string;
+  cost?: UsageCostCents;
+  source?: "usage" | "catalog";
+}
+
+export async function estimateTurnCostFromApi(
+  input: EstimateTurnCostInput
+): Promise<TurnCost | undefined> {
+  const resolved = await resolveApiKey();
+  if (resolved === undefined) {
+    return undefined;
+  }
+  const model = modelSettingId(input.model);
+  const response = await fetch(
+    `${cursorExternalApiUrl()}/v1/models/estimate-cost`,
+    {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${resolved.apiKey}`,
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        model,
+        inputTokens: input.usage?.inputTokens,
+        outputTokens: input.usage?.outputTokens,
+        cacheReadTokens: input.usage?.cacheReadTokens,
+        cacheWriteTokens: input.usage?.cacheWriteTokens,
+        agentId: input.agentId,
+        conversationId: input.conversationId,
+        runId: input.runId,
+      }),
+    }
+  );
+  if (!response.ok) {
+    return undefined;
+  }
+  let body: EstimateCostApiResponse;
+  try {
+    body = (await response.json()) as EstimateCostApiResponse;
+  } catch {
+    return undefined;
+  }
+  if (
+    typeof body.cost?.rawCostCents !== "number" ||
+    typeof body.cost.chargedCents !== "number"
+  ) {
+    return undefined;
+  }
+  return turnCostFromCents({
+    model: body.model ?? model,
+    cost: body.cost,
+    source: body.source === "usage" ? "usage" : "catalog",
+  });
+}

package/src/internal/update-check.ts

@@ -1,5 +1,5 @@
 /**
- * Outdated-version warning + `agentkit update`.
+ * Outdated-version warning + `agent-sdk update`.
  *
  * Every CLI run of a published install compares its own version against the
  * npm registry's `latest` dist-tag and warns on stderr when behind. The
@@ -8,7 +8,7 @@
  * network; a stale cache refreshes inline under a short timeout, and any
  * network failure is silent (the warning is best-effort, never a blocker).
  *
- * `agentkit update` re-runs the lookup fresh, figures out how this copy was
+ * `agent-sdk update` re-runs the lookup fresh, figures out how this copy was
  * installed (global npm/pnpm/yarn/bun, or a project dependency), and runs the
  * matching install command.
  */
@@ -36,7 +36,7 @@ const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 /** Inline refresh budget; a slow registry must not stall the command. */
 const WARN_FETCH_TIMEOUT_MS = 1500;
 
-/** `agentkit update` runs interactively, so it can afford a real timeout. */
+/** `agent-sdk update` runs interactively, so it can afford a real timeout. */
 const UPDATE_FETCH_TIMEOUT_MS = 10_000;
 
 // ============================================================================
@@ -276,7 +276,7 @@ function isTruthyEnv(value: string | undefined): boolean {
 }
 
 // ============================================================================
-// `agentkit update`
+// `agent-sdk update`
 // ============================================================================
 
 export interface UpdateCommand {
@@ -303,7 +303,7 @@ export async function detectUpdateCommand(args: {
   const spec = `${packageName}@latest`;
   const posixRoot = args.packageRoot.split(sep).join("/");
 
-  // npx / pnpm dlx caches are ephemeral; a fresh `npx agentkit` already
+  // npx / pnpm dlx caches are ephemeral; a fresh `npx agent-sdk` already
   // resolves latest, and upgrading the cache entry in place helps nobody.
   if (posixRoot.includes("/_npx/") || posixRoot.includes("/.pnpm-store/")) {
     return undefined;
@@ -457,7 +457,7 @@ export interface UpdateCliOptions {
   err?: (text: string) => void;
 }
 
-/** `agentkit update` — upgrade this install to the latest published version. */
+/** `agent-sdk update` — upgrade this install to the latest published version. */
 export async function cmdUpdate(options?: UpdateCliOptions): Promise<number> {
   const c = stderrPalette();
   const out =

package/src/memory.ts

@@ -3,7 +3,7 @@
  * 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 `agentkit init`): after each turn
+ * `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`.
  *

package/src/storage.ts

@@ -254,7 +254,7 @@ export function defineStorage(config: StorageConfig): StorageDefinition {
 
 /**
  * Framework-owned key root. All {@link storageKeys} values live under this
- * prefix so a shared store can route or namespace agentkit data.
+ * prefix so a shared store can route or namespace Agent SDK data.
  */
 export const STORAGE_KEY_ROOT = "agentkit/v1" as const;