@cursor/bdk 0.2.2 → 0.2.4

package/src/internal/session-store.ts

@@ -1,307 +0,0 @@
-/**
- * Persisted session registry. Each session lives at
- * `<stateRoot>/sessions/<sessionId>/` with a `session.json` record, an
- * `events.ndjson` log, and a `workspace/` directory. Continuation keys are
- * indexed in memory so channels can address sessions by their channel-local
- * token.
- *
- * The directory is the source of truth and the in-memory maps are a cache:
- * another process may create and update sessions behind this one's back (the
- * two version containers of a persistent deployment during a redeploy, or an
- * old process still exiting after a restart). A lookup that would otherwise
- * conclude "no such session" rescans the directory first, listings pick up
- * new directories, and a cached record is re-read when its file changed.
- */
-
-import { randomBytes } from "node:crypto";
-import { mkdir, readdir, readFile, rename, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import type { SessionRecord } from "../types.js";
-import { isSafeSessionId } from "./auth.js";
-import { isV2DurableContinuationKey } from "./continuation-identity.js";
-
-export class SessionStore {
-  private readonly cache = new Map<string, SessionRecord>();
-  private readonly continuationIndex = new Map<string, string>();
-  /**
-   * Identity of the `session.json` each cached record was read from, to
-   * notice a peer's writes. Absent while our own `save` is still writing.
-   */
-  private readonly stamps = new Map<string, string>();
-  private hydrated: Promise<void> | undefined;
-  private scanning: Promise<void> | undefined;
-
-  constructor(private readonly sessionsDir: string) {}
-
-  sessionDir(sessionId: string): string {
-    if (!isSafeSessionId(sessionId)) {
-      throw new Error(`Invalid session id: ${sessionId}`);
-    }
-    return join(this.sessionsDir, sessionId);
-  }
-
-  workspaceDir(sessionId: string): string {
-    return join(this.sessionDir(sessionId), "workspace");
-  }
-
-  eventFilePath(sessionId: string): string {
-    return join(this.sessionDir(sessionId), "events.ndjson");
-  }
-
-  private recordPath(sessionId: string): string {
-    return join(this.sessionDir(sessionId), "session.json");
-  }
-
-  private continuationKeyOf(channelId: string, key: string): string {
-    // v2 index is (agentId, cKey). This store is already per-agent, so drop
-    // channelId for `cont:` / `evt:` keys. v1 stays `{channelId}\n{token}`.
-    if (isV2DurableContinuationKey(key)) {
-      return `\0v2\n${key}`;
-    }
-    return `${channelId}\n${key}`;
-  }
-
-  /**
-   * Bring the cache in line with the directory: load records for session
-   * directories not seen yet, drop records whose file is gone, and re-read
-   * records whose file changed. Callers arriving while a scan is running
-   * share it rather than queueing another.
-   */
-  private scan(): Promise<void> {
-    if (this.scanning === undefined) {
-      this.scanning = this.rescan().finally(() => {
-        this.scanning = undefined;
-      });
-      this.hydrated ??= this.scanning;
-    }
-    return this.scanning;
-  }
-
-  private async rescan(): Promise<void> {
-    let entries: string[];
-    try {
-      entries = await readdir(this.sessionsDir);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-        // Unreadable for a reason other than absence: keep what we have
-        // rather than forgetting sessions we cannot currently list.
-        return;
-      }
-      // No directory means no sessions; the cache must not outlive it.
-      entries = [];
-    }
-    const present = new Set<string>();
-    for (const sessionId of entries) {
-      if (!isSafeSessionId(sessionId)) {
-        continue;
-      }
-      present.add(sessionId);
-      if (this.cache.has(sessionId)) {
-        await this.refreshIfChanged(sessionId);
-        continue;
-      }
-      await this.load(sessionId);
-    }
-    // The listing is a snapshot: a session saved since it was taken is not
-    // in `present` but is on disk, so ask the file rather than the listing.
-    for (const sessionId of [...this.cache.keys()]) {
-      if (!present.has(sessionId)) {
-        await this.refreshIfChanged(sessionId);
-      }
-    }
-  }
-
-  private async ensureHydrated(): Promise<void> {
-    await (this.hydrated ?? this.scan());
-  }
-
-  private async readRecord(sessionId: string): Promise<SessionRecord | undefined> {
-    if (!isSafeSessionId(sessionId)) {
-      return undefined;
-    }
-    try {
-      const raw = await readFile(this.recordPath(sessionId), "utf8");
-      return JSON.parse(raw) as SessionRecord;
-    } catch {
-      return undefined;
-    }
-  }
-
-  /**
-   * Identity of the file at `path`: inode plus mtime, so two renames within
-   * one clock tick still read as different. Undefined when there is no
-   * file; any other failure propagates.
-   */
-  private async stampOf(path: string): Promise<string | undefined> {
-    try {
-      const info = await stat(path);
-      return `${info.ino}:${info.mtimeMs}`;
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return undefined;
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Read a record from disk into the cache; returns it when present. The
-   * stamp is taken before the read so a write landing in between leaves a
-   * stale stamp, and the next lookup re-reads, rather than a fresh stamp on
-   * stale bytes.
-   */
-  private async load(sessionId: string): Promise<SessionRecord | undefined> {
-    if (!isSafeSessionId(sessionId)) {
-      return undefined;
-    }
-    const stamp = await this.stampOf(this.recordPath(sessionId)).catch(() => undefined);
-    if (stamp === undefined) {
-      return undefined;
-    }
-    const record = await this.readRecord(sessionId);
-    if (record === undefined) {
-      return undefined;
-    }
-    this.remember(record, stamp);
-    return record;
-  }
-
-  private async refreshIfChanged(sessionId: string): Promise<void> {
-    let stamp: string | undefined;
-    try {
-      stamp = await this.stampOf(this.recordPath(sessionId));
-    } catch {
-      // Unreadable for a reason other than absence: keep what we have.
-      return;
-    }
-    if (stamp === undefined) {
-      // No file for a record we never stamped is our own `save` still
-      // writing it, not a deletion.
-      if (this.stamps.has(sessionId)) {
-        this.evict(sessionId);
-      }
-      return;
-    }
-    if (stamp !== this.stamps.get(sessionId)) {
-      await this.load(sessionId);
-    }
-  }
-
-  private remember(record: SessionRecord, stamp: string | undefined): void {
-    const previous = this.cache.get(record.sessionId);
-    this.cache.set(record.sessionId, record);
-    if (stamp !== undefined) {
-      this.stamps.set(record.sessionId, stamp);
-    }
-    if (
-      previous !== undefined &&
-      previous.continuationKey !== null &&
-      previous.continuationKey !== record.continuationKey
-    ) {
-      this.unindex(previous);
-    }
-    this.indexRecord(record);
-  }
-
-  private evict(sessionId: string): void {
-    const previous = this.cache.get(sessionId);
-    this.cache.delete(sessionId);
-    this.stamps.delete(sessionId);
-    if (previous?.continuationKey != null) {
-      this.unindex(previous);
-    }
-  }
-
-  /**
-   * Drop `record`'s claim on its continuation key. The index holds one
-   * session per key; if another cached session still carries the same key
-   * (a replacement created before the old one was re-keyed, or a peer's
-   * write we learned of in this order), it takes the slot so the key does
-   * not go dark until a restart.
-   */
-  private unindex(record: SessionRecord): void {
-    if (record.continuationKey === null) {
-      return;
-    }
-    const indexKey = this.continuationKeyOf(record.channelId, record.continuationKey);
-    if (this.continuationIndex.get(indexKey) !== record.sessionId) {
-      return;
-    }
-    this.continuationIndex.delete(indexKey);
-    for (const other of this.cache.values()) {
-      if (
-        other.sessionId !== record.sessionId &&
-        other.continuationKey !== null &&
-        this.continuationKeyOf(other.channelId, other.continuationKey) === indexKey
-      ) {
-        this.continuationIndex.set(indexKey, other.sessionId);
-        return;
-      }
-    }
-  }
-
-  private indexRecord(record: SessionRecord): void {
-    if (record.continuationKey !== null) {
-      this.continuationIndex.set(
-        this.continuationKeyOf(record.channelId, record.continuationKey),
-        record.sessionId,
-      );
-    }
-  }
-
-  async get(sessionId: string): Promise<SessionRecord | undefined> {
-    if (!isSafeSessionId(sessionId)) {
-      return undefined;
-    }
-    if (this.cache.has(sessionId)) {
-      await this.refreshIfChanged(sessionId);
-      return this.cache.get(sessionId);
-    }
-    return this.load(sessionId);
-  }
-
-  async list(): Promise<SessionRecord[]> {
-    await this.scan();
-    return [...this.cache.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-  }
-
-  async findByContinuation(channelId: string, key: string): Promise<SessionRecord | undefined> {
-    await this.ensureHydrated();
-    const indexKey = this.continuationKeyOf(channelId, key);
-    const lookup = async (): Promise<SessionRecord | undefined> => {
-      const sessionId = this.continuationIndex.get(indexKey);
-      if (sessionId === undefined) {
-        return undefined;
-      }
-      const record = await this.get(sessionId);
-      // `get` may have re-read the record and found its continuation moved,
-      // or evicted it; either way this hit is stale.
-      return record?.continuationKey === key ? record : undefined;
-    };
-    const found = await lookup();
-    if (found !== undefined) {
-      return found;
-    }
-    // A miss or a stale hit: another process may have created or re-keyed a
-    // session since the last scan. Rescan once and retry.
-    await this.scan();
-    return lookup();
-  }
-
-  async save(record: SessionRecord): Promise<void> {
-    this.remember(record, undefined);
-
-    const dir = this.sessionDir(record.sessionId);
-    await mkdir(dir, { recursive: true });
-    const finalPath = this.recordPath(record.sessionId);
-    const tmpPath = `${finalPath}.${randomBytes(4).toString("hex")}.tmp`;
-    await writeFile(tmpPath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
-    // Stamp the bytes we wrote, not whatever is at `finalPath` afterwards:
-    // rename keeps inode and mtime, and a peer landing right behind us must
-    // read as a change. Remember again so a concurrent read that loaded the
-    // peer's earlier file does not leave the cache pointing at it.
-    const stamp = await this.stampOf(tmpPath);
-    await rename(tmpPath, finalPath);
-    this.remember(record, stamp);
-  }
-}

package/src/internal/session-urls.ts

@@ -1,32 +0,0 @@
-/** Absolute playground deep-link for a session on this agent mount. */
-export function playgroundUrlForSession(request: Request, base: string, sessionId: string): string {
-  const url = new URL(request.url);
-  const mount = normalizeMountBase(base);
-  return `${url.origin}${mount}/playground?sessionId=${encodeURIComponent(sessionId)}`;
-}
-
-/** Absolute NDJSON event-trace URL for a session on this agent mount. */
-export function eventsUrlForSession(requestUrl: string, base: string, sessionId: string): string {
-  const url = new URL(requestUrl);
-  const mount = normalizeMountBase(base);
-  return `${url.origin}${mount}/v1/session/${encodeURIComponent(sessionId)}/events`;
-}
-
-/** Playground + trace URLs for a custom channel response body. */
-export function sessionUrlsForRequest(
-  request: Request,
-  base: string,
-  sessionId: string,
-): { playgroundUrl: string; traceUrl: string } {
-  return {
-    playgroundUrl: playgroundUrlForSession(request, base, sessionId),
-    traceUrl: eventsUrlForSession(request.url, base, sessionId),
-  };
-}
-
-function normalizeMountBase(base: string): string {
-  if (base === "") {
-    return "";
-  }
-  return base.startsWith("/") ? base : `/${base}`;
-}

package/src/internal/sessions-client.ts

@@ -1,239 +0,0 @@
-/**
- * Session list / event fetch for CLI (`sessions`, `session`, chat reattach).
- *
- * Customer-facing errors never include hosting URLs or infra jargon.
- */
-
-import type { SessionEvent, SessionListSource, SessionSummary } from "../types.js";
-import { sanitizeCustomerError } from "./logs-client.js";
-import { mergeRequestHeaders, type RequestAuth } from "./request-headers.js";
-
-export interface ListedSessions {
-  sessions: SessionSummary[];
-  /** Present when the server reports which store answered. */
-  source?: SessionListSource;
-}
-
-export interface ListSessionsArgs {
-  baseUrl: string;
-  auth?: RequestAuth;
-  fetchImpl?: typeof fetch;
-  /**
-   * Ask for only the newest visible session (`?latest=1`). The server
-   * answers from memory where it can instead of scanning durable storage.
-   */
-  latest?: boolean;
-}
-
-export async function listSessions(args: ListSessionsArgs): Promise<SessionSummary[]> {
-  return (await listSessionsWithSource(args)).sessions;
-}
-
-export async function listSessionsWithSource(args: ListSessionsArgs): Promise<ListedSessions> {
-  const baseUrl = args.baseUrl.replace(/\/$/, "");
-  const fetchImpl = args.fetchImpl ?? fetch;
-  const query = args.latest === true ? "?latest=1" : "";
-  let resp: Response;
-  try {
-    resp = await fetchImpl(`${baseUrl}/v1/sessions${query}`, {
-      headers: mergeRequestHeaders(args.auth),
-    });
-  } catch (error) {
-    throw new Error(
-      sanitizeCustomerError(error instanceof Error ? error.message : "Could not list sessions."),
-    );
-  }
-  if (!resp.ok) {
-    throw new Error(`Could not list sessions (HTTP ${resp.status}).`);
-  }
-  const body = (await resp.json()) as { sessions?: unknown; source?: unknown };
-  const sessions: SessionSummary[] = [];
-  if (Array.isArray(body.sessions)) {
-    for (const row of body.sessions) {
-      const parsed = parseSessionSummary(row);
-      if (parsed !== undefined) {
-        sessions.push(parsed);
-      }
-    }
-  }
-  const source =
-    body.source === "cursor-hosted" || body.source === "local" ? body.source : undefined;
-  return source === undefined ? { sessions } : { sessions, source };
-}
-
-export async function fetchSessionEvents(args: {
-  baseUrl: string;
-  sessionId: string;
-  auth?: RequestAuth;
-  fetchImpl?: typeof fetch;
-}): Promise<SessionEvent[]> {
-  const baseUrl = args.baseUrl.replace(/\/$/, "");
-  const fetchImpl = args.fetchImpl ?? fetch;
-  const path = `/v1/session/${encodeURIComponent(args.sessionId)}/events`;
-
-  try {
-    const jsonResp = await fetchImpl(`${baseUrl}${path}?format=json`, {
-      headers: mergeRequestHeaders(args.auth),
-    });
-    if (jsonResp.ok) {
-      const body = (await jsonResp.json()) as { events?: unknown };
-      if (Array.isArray(body.events)) {
-        return body.events as SessionEvent[];
-      }
-    } else if (jsonResp.status === 404) {
-      throw new Error(`Session ${args.sessionId} not found.`);
-    } else if (jsonResp.status === 403) {
-      throw new Error(`Session ${args.sessionId} is not readable by this caller.`);
-    }
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith("Session ")) {
-      throw error;
-    }
-    // Fall through to NDJSON.
-  }
-
-  try {
-    const resp = await fetchImpl(`${baseUrl}${path}`, {
-      headers: mergeRequestHeaders(args.auth),
-    });
-    if (resp.status === 404) {
-      throw new Error(`Session ${args.sessionId} not found.`);
-    }
-    if (resp.status === 403) {
-      throw new Error(`Session ${args.sessionId} is not readable by this caller.`);
-    }
-    if (!resp.ok) {
-      throw new Error(`Could not fetch session events (HTTP ${resp.status}).`);
-    }
-    const text = await resp.text();
-    const events: SessionEvent[] = [];
-    for (const line of text.split("\n")) {
-      if (line.trim() === "") {
-        continue;
-      }
-      try {
-        events.push(JSON.parse(line) as SessionEvent);
-      } catch {
-        // skip malformed lines
-      }
-    }
-    return events;
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith("Session ")) {
-      throw error;
-    }
-    if (error instanceof Error && error.message.startsWith("Could not fetch")) {
-      throw new Error(sanitizeCustomerError(error.message));
-    }
-    throw new Error(
-      sanitizeCustomerError(
-        error instanceof Error ? error.message : "Could not fetch session events.",
-      ),
-    );
-  }
-}
-
-/** Lenient parse so partial stubs / older servers still list by sessionId. */
-function parseSessionSummary(value: unknown): SessionSummary | undefined {
-  if (typeof value !== "object" || value === null) {
-    return undefined;
-  }
-  const row = value as Record<string, unknown>;
-  if (typeof row.sessionId !== "string" || row.sessionId === "") {
-    return undefined;
-  }
-  const continuationToken =
-    typeof row.continuationToken === "string"
-      ? row.continuationToken
-      : row.continuationToken === null
-        ? null
-        : null;
-  return {
-    sessionId: row.sessionId,
-    channelId: typeof row.channelId === "string" ? row.channelId : "",
-    mode: row.mode === "task" ? "task" : "chat",
-    title: typeof row.title === "string" ? row.title : undefined,
-    turnCount: typeof row.turnCount === "number" ? row.turnCount : 0,
-    running: row.running === true,
-    queued: typeof row.queued === "boolean" ? row.queued : undefined,
-    createdAt: typeof row.createdAt === "string" ? row.createdAt : "",
-    updatedAt: typeof row.updatedAt === "string" ? row.updatedAt : "",
-    dryRun: row.dryRun === true ? true : undefined,
-    continuationToken,
-    externalUrl: typeof row.externalUrl === "string" ? row.externalUrl : undefined,
-    prUrl: typeof row.prUrl === "string" ? row.prUrl : undefined,
-  };
-}
-
-/**
- * Pick the previous (most recently updated) followable session for
- * `resume` / `chat --resume` when no session id was passed.
- * Followable = has a non-empty continuation token (task sessions without
- * one are skipped).
- */
-export function pickPreviousSession(
-  sessions: readonly SessionSummary[],
-): SessionSummary | undefined {
-  const followable = sessions.filter(
-    s => typeof s.continuationToken === "string" && s.continuationToken !== "",
-  );
-  if (followable.length === 0) {
-    return undefined;
-  }
-  return [...followable].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0];
-}
-
-/** Look up the most recently updated followable session id. */
-export async function resolvePreviousSessionId(args: {
-  baseUrl: string;
-  auth?: RequestAuth;
-  fetchImpl?: typeof fetch;
-}): Promise<string | undefined> {
-  const sessions = await listSessions({
-    baseUrl: args.baseUrl,
-    auth: args.auth,
-    fetchImpl: args.fetchImpl,
-  });
-  return pickPreviousSession(sessions)?.sessionId;
-}
-
-/** Human label for {@link SessionListSource} in CLI output. */
-export function formatSessionListSource(source: SessionListSource): string {
-  return source === "cursor-hosted"
-    ? "Listing from cursor-hosted storage (durable DB)."
-    : "Listing from local session store.";
-}
-
-/** Format a sessions table (id, channel, mode, turns, running, updated). */
-export function formatSessionsTable(
-  sessions: SessionSummary[],
-  options?: { source?: SessionListSource },
-): string {
-  const sourceLine =
-    options?.source === undefined ? "" : `${formatSessionListSource(options.source)}\n`;
-  if (sessions.length === 0) {
-    return `${sourceLine}No sessions.\n`;
-  }
-  const header = ["SESSION", "CHANNEL", "MODE", "TURNS", "RUNNING", "UPDATED"];
-  const rows = sessions.map(s => [
-    s.sessionId,
-    s.channelId,
-    s.mode,
-    String(s.turnCount),
-    s.queued === true ? "queued" : s.running ? "yes" : "no",
-    s.updatedAt,
-  ]);
-  return `${sourceLine}${renderTable(header, rows)}\n`;
-}
-
-function renderTable(header: string[], rows: string[][]): string {
-  const widths = header.map((h, i) =>
-    Math.max(h.length, ...rows.map(row => (row[i] ?? "").length)),
-  );
-  const renderRow = (row: string[]): string =>
-    row
-      .map((cell, i) => cell.padEnd(widths[i] ?? 0))
-      .join("  ")
-      .trimEnd();
-  return [renderRow(header), ...rows.map(renderRow)].join("\n");
-}

package/src/internal/skill-catalog.ts

@@ -1,66 +0,0 @@
-/**
- * Deterministic skill reads (`GET /v1/skills`, `GET /v1/skills/:name`,
- * `agent-sdk skill <name>`): the skill body exactly as the harness would
- * receive it, plus resolved sibling files. No model turn, no session.
- */
-
-import { readFile } from "node:fs/promises";
-import type { DiscoveredSkill } from "../types.js";
-import { buildSkillMd } from "./workspace.js";
-
-export class UnknownSkillError extends Error {
-  constructor(
-    skillName: string,
-    readonly availableSkillNames: string[],
-  ) {
-    super(`Unknown skill "${skillName}"`);
-    this.name = "UnknownSkillError";
-  }
-}
-
-/** Light listing entry: routing hint only, like `info` shows. */
-export interface SkillListEntry {
-  name: string;
-  description: string;
-}
-
-/** Full read behind `GET /v1/skills/:name`. */
-export interface SkillDetailEntry extends SkillListEntry {
-  /** SKILL.md body without generated frontmatter. */
-  markdown: string;
-  /** Rendered SKILL.md the harness reads (frontmatter + body). */
-  skillMd: string;
-  /** Sibling files by package-relative path, with contents resolved. */
-  files: Record<string, string>;
-  extension?: string;
-}
-
-export function skillListEntry(skill: DiscoveredSkill): SkillListEntry {
-  return { name: skill.name, description: skill.description };
-}
-
-export async function readSkillDetail(
-  skills: readonly DiscoveredSkill[],
-  skillName: string,
-): Promise<SkillDetailEntry> {
-  const skill = skills.find(s => s.name === skillName);
-  if (skill === undefined) {
-    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.
-  const files: Record<string, string> = Object.create(null);
-  for (const [rel, source] of Object.entries(skill.files)) {
-    files[rel] = "contents" in source ? source.contents : await readFile(source.sourcePath, "utf8");
-  }
-  return {
-    ...skillListEntry(skill),
-    markdown: skill.markdown,
-    skillMd: buildSkillMd(skill),
-    files,
-    extension: skill.extension,
-  };
-}

package/src/internal/skills-sync.ts

@@ -1,55 +0,0 @@
-/**
- * Sync authored skills onto an Agent Store so cloud-runtime turns discover
- * them natively. Hosted deployments write store-root `skills/<name>/…` (the
- * VM's `--agent-store-skills-dir /cursor/stores/deployment/skills`). Local
- * `serve`/`run` with `runtime: "cloud"` writes
- * `agent-serve/<agent>/skills/<name>/…` on the USER store.
- */
-
-import { readFile } from "node:fs/promises";
-import { agentStoreKeys, type FileSink } from "../files.js";
-import { STORAGE_KEY_ROOT } from "../storage.js";
-import type { DiscoveredSkill, SkillFileSource } from "../types.js";
-import { mirrorToStore, storeRelPath } from "./store-mirror.js";
-import { buildSkillMd } from "./workspace.js";
-
-/** Pre-native layout. Deleted on every sync so a rolled-forward deploy does not leave undiscoverable copies. */
-function legacySkillsPrefix(agent: string): string {
-  return `${STORAGE_KEY_ROOT}/${agent}/skills/`;
-}
-
-/**
- * Mirror the agent's skills onto the store: write every SKILL.md (with the
- * same generated frontmatter local materialization uses) plus sibling files,
- * and delete keys no authored skill claims so redeploys drop removed skills.
- * Everything loads and validates before the store is touched.
- */
-export async function syncSkillsToStore(args: {
-  sink: FileSink;
-  /** Sweeps leftover keys from the pre-native `agentkit/v1/{agent}/skills/` prefix. */
-  agentName: string;
-  skills: readonly DiscoveredSkill[];
-  /** Store-root directory that holds SKILL.md files. Defaults to `skills/`. */
-  skillsPrefix?: string;
-}): Promise<void> {
-  const skillsPrefix = args.skillsPrefix ?? agentStoreKeys.skillsPrefix();
-  const desired = new Map<string, Uint8Array>();
-  for (const skill of args.skills) {
-    const key = (relPath: string): string =>
-      agentStoreKeys.skillFile(skill.name, relPath, skillsPrefix);
-    desired.set(key("SKILL.md"), Buffer.from(buildSkillMd(skill), "utf8"));
-    for (const [relPath, source] of Object.entries(skill.files)) {
-      desired.set(key(storeRelPath(relPath, "skill file")), await sourceBytes(source));
-    }
-  }
-  await mirrorToStore({
-    sink: args.sink,
-    prefix: skillsPrefix,
-    desired,
-    legacyPrefixes: [legacySkillsPrefix(args.agentName)],
-  });
-}
-
-async function sourceBytes(source: SkillFileSource): Promise<Uint8Array> {
-  return "contents" in source ? Buffer.from(source.contents, "utf8") : readFile(source.sourcePath);
-}