@cursor/july 0.1.80 → 0.1.83

package/dist/internal/session-engine.js

@@ -22,7 +22,8 @@ import { SLACK_CHANNEL_ID } from "../channels/slack/constants.js";
 import { materializeSlackNudgeCarrier } from "../channels/slack/nudge-carrier.js";
 import { SlackAskDedupeStore, SlackNudgeStore, } from "../channels/slack/nudge-store.js";
 import { resolveDedicatedSlackHostBinding } from "../channels/slack/slack-channel.js";
-import { isCursorHostedFilesAvailable } from "../files-backends/cursor-hosted.js";
+import { AGENT_SERVE_USER_STORE_FILES_SOURCE_ID, agentStoreKeys, } from "../files.js";
+import { cursorHostedFiles, isCursorHostedFilesAvailable, isCursorUserStoreFilesAvailable, } from "../files-backends/cursor-hosted.js";
 import { DEFAULT_MODEL, DIRECT_TOOL_CALL_CHANNEL_ID, isHostOauthConnectionTransport, isSymbolicConnectionTransport, } from "../types.js";
 import { ABCollector } from "./ab-collector.js";
 import { foldABStream } from "./ab-fold.js";
@@ -33,6 +34,8 @@ import { ArtifactsStore } from "./artifacts-store.js";
 import { SessionAuthError, samePrincipal } from "./auth.js";
 import { mergeCloudOptions, resolveSessionRuntime } from "./cloud-merge.js";
 import { applyCloudUsageToEvents, cloudSdkAgentIdFromEvents, isUnpricedCompletedTurn, mapSdkTokenUsage, } from "./cloud-turn-cost.js";
+import { applyAgentContinuationDefaults, channelContinuationIdentity, httpContinuationIdentity, } from "./continuation-channel.js";
+import { continuationSource, resolveV2Key, V2EngineError, } from "./continuation-identity.js";
 import { isDevMode } from "./dev-mode.js";
 import { EventLogStore } from "./event-log.js";
 import { TurnEventMapper } from "./event-mapper.js";
@@ -49,6 +52,7 @@ import { buildSessionContextBlock, SCHEDULE_CHANNEL_PREFIX, } from "./prompt-con
 import { assertCloudCanHonorAccountServersFilters } from "./resolved-connections.js";
 import { sessionExternalLinks } from "./session-links.js";
 import { SessionStore } from "./session-store.js";
+import { syncSkillsToStore } from "./skills-sync.js";
 import { StorageCoordinator } from "./storage-coordinator.js";
 import { normalizeToolResult, toolCallErrorMessage } from "./tool-result.js";
 import { estimateTurnCostFromApi, roundCostUsd, } from "./turn-cost.js";
@@ -152,6 +156,7 @@ export class SessionEngine {
         /** Deduped in-flight cloud cost backfills, keyed by session id. */
         this.cloudCostBackfill = new Map();
         this.project = options.project;
+        applyAgentContinuationDefaults(this.project);
         this.stateRoot = options.stateRoot;
         this.runner = options.runner;
         this.logger = (_a = options.logger) !== null && _a !== void 0 ? _a : (() => { });
@@ -454,19 +459,37 @@ export class SessionEngine {
      * Start or resume a session on a channel. When `continuationToken`
      * addresses an existing session this is a follow-up turn; otherwise a new
      * session is created (keyed by the provided token, or a fresh one).
+     *
+     * v2 (`/v2` selectors) refuses `continuationToken` and looks
+     * up `(agentId, cKey)` from a mailbox stamp or structured claim.
      */
     send(channelId_1, message_1) {
         return __awaiter(this, arguments, void 0, function* (channelId, message, options = {}) {
             var _a;
             var _b, _c, _d, _e, _f;
-            const auth = (_b = options.auth) !== null && _b !== void 0 ? _b : null;
-            let existing = options.continuationToken === undefined
+            const identity = channelId === HTTP_CHANNEL_ID
+                ? httpContinuationIdentity(this.project.httpChannel)
+                : channelContinuationIdentity(this.channelsById.get(channelId));
+            let sendOptions = options;
+            let skipContinuationLookup = false;
+            if (continuationSource(identity) === "control-plane") {
+                if (options.continuationToken !== undefined) {
+                    throw new V2EngineError("v2: do not pass continuationToken; use mailboxContinuation or claim");
+                }
+                const cKey = resolveV2Key(identity, options);
+                sendOptions = Object.assign(Object.assign({}, options), { continuationToken: cKey });
+                skipContinuationLookup = cKey.startsWith("evt:");
+            }
+            const auth = (_b = sendOptions.auth) !== null && _b !== void 0 ? _b : null;
+            let existing = skipContinuationLookup || sendOptions.continuationToken === undefined
                 ? undefined
-                : yield this.sessions.findByContinuation(channelId, options.continuationToken);
-            if (existing === undefined && options.continuationToken !== undefined) {
+                : yield this.sessions.findByContinuation(channelId, sendOptions.continuationToken);
+            if (existing === undefined &&
+                !skipContinuationLookup &&
+                sendOptions.continuationToken !== undefined) {
                 // Local miss: the session may live only in the storage sink (it
                 // fell outside the startup restore window, or restore is lazy-only).
-                existing = yield this.restoreSessionByContinuation(channelId, options.continuationToken);
+                existing = yield this.restoreSessionByContinuation(channelId, sendOptions.continuationToken);
             }
             if (existing !== undefined) {
                 if (!samePrincipal(existing.auth, auth)) {
@@ -475,51 +498,52 @@ export class SessionEngine {
                 // Refresh harness cwd when the caller supplies a newer worktree (e.g. PR
                 // synchronize). Leave the durable continuation key unchanged.
                 let record = existing;
-                const refreshWorkspace = options.workspaceDir !== undefined &&
-                    options.workspaceDir !== existing.workspaceOverride;
+                const refreshWorkspace = sendOptions.workspaceDir !== undefined &&
+                    sendOptions.workspaceDir !== existing.workspaceOverride;
                 if (refreshWorkspace ||
-                    options.workspaceFiles !== undefined ||
-                    options.images !== undefined) {
+                    sendOptions.workspaceFiles !== undefined ||
+                    sendOptions.images !== undefined) {
                     record = yield this.updateRecord(existing.sessionId, (current) => (Object.assign(Object.assign({}, current), { workspaceOverride: refreshWorkspace
-                            ? options.workspaceDir
-                            : current.workspaceOverride, pendingWorkspaceFiles: mergePendingWorkspaceFiles(current.pendingWorkspaceFiles, options.workspaceFiles), pendingImages: mergePendingImages(current.pendingImages, options.images) })));
+                            ? sendOptions.workspaceDir
+                            : current.workspaceOverride, pendingWorkspaceFiles: mergePendingWorkspaceFiles(current.pendingWorkspaceFiles, sendOptions.workspaceFiles), pendingImages: mergePendingImages(current.pendingImages, sendOptions.images) })));
                 }
                 // Refresh the cloud attach the same way: a follow-up send carries the
                 // caller's CURRENT cloud options (e.g. a PR attach re-derived per wake),
                 // and the first send's snapshot must not pin this session's turns to a
                 // stale repo/prUrl for the session's lifetime.
-                if (options.cloud !== undefined &&
-                    JSON.stringify(options.cloud) !== JSON.stringify(record.cloudOverride)) {
-                    record = yield this.updateRecord(record.sessionId, (current) => (Object.assign(Object.assign({}, current), { cloudOverride: options.cloud })));
+                if (sendOptions.cloud !== undefined &&
+                    JSON.stringify(sendOptions.cloud) !==
+                        JSON.stringify(record.cloudOverride)) {
+                    record = yield this.updateRecord(record.sessionId, (current) => (Object.assign(Object.assign({}, current), { cloudOverride: sendOptions.cloud })));
                 }
                 // Refresh wake-derived channel state (GitHub headSha / refs) without
                 // wiping sticky fields. Null patch values are skipped.
-                if (options.refreshState !== undefined) {
-                    record = yield this.updateRecord(record.sessionId, (current) => (Object.assign(Object.assign({}, current), { channelState: mergeChannelStateSkipNull(current.channelState, options.refreshState) })));
+                if (sendOptions.refreshState !== undefined) {
+                    record = yield this.updateRecord(record.sessionId, (current) => (Object.assign(Object.assign({}, current), { channelState: mergeChannelStateSkipNull(current.channelState, sendOptions.refreshState) })));
                 }
                 const since = (yield this.logs.get(record.sessionId)).count;
-                const coalesced = yield this.startTurn(record.sessionId, message, Object.assign({ admission: (_c = options.admission) !== null && _c !== void 0 ? _c : "preempt" }, (options.coalesceSourceTs === undefined
+                const coalesced = yield this.startTurn(record.sessionId, message, Object.assign({ admission: (_c = sendOptions.admission) !== null && _c !== void 0 ? _c : "preempt" }, (sendOptions.coalesceSourceTs === undefined
                     ? {}
-                    : { sourceTs: options.coalesceSourceTs })));
+                    : { sourceTs: sendOptions.coalesceSourceTs })));
                 return this.channelSession(record.sessionId, record, false, coalesced, since);
             }
             const now = new Date().toISOString();
-            const channelState = this.initialChannelState(channelId, options.state);
-            const purpose = options.purpose === "eval" ? "eval" : "live";
+            const channelState = this.initialChannelState(channelId, sendOptions.state);
+            const purpose = sendOptions.purpose === "eval" ? "eval" : "live";
             let record = {
                 sessionId: newSessionId(),
                 channelId,
-                mode: (_d = options.mode) !== null && _d !== void 0 ? _d : "chat",
+                mode: (_d = sendOptions.mode) !== null && _d !== void 0 ? _d : "chat",
                 purpose,
-                continuationKey: (_e = options.continuationToken) !== null && _e !== void 0 ? _e : newContinuationKey(),
+                continuationKey: (_e = sendOptions.continuationToken) !== null && _e !== void 0 ? _e : newContinuationKey(),
                 auth,
-                title: options.title,
+                title: sendOptions.title,
                 channelState,
-                workspaceOverride: options.workspaceDir,
-                pendingWorkspaceFiles: options.workspaceFiles,
-                pendingImages: options.images,
-                cloudOverride: options.cloud,
-                sdkAgentId: options.sdkAgentId,
+                workspaceOverride: sendOptions.workspaceDir,
+                pendingWorkspaceFiles: sendOptions.workspaceFiles,
+                pendingImages: sendOptions.images,
+                cloudOverride: sendOptions.cloud,
+                sdkAgentId: sendOptions.sdkAgentId,
                 turnCount: 0,
                 createdAt: now,
                 updatedAt: now,
@@ -532,9 +556,9 @@ export class SessionEngine {
             });
             record = yield this.enrollABs(record);
             const since = (yield this.logs.get(record.sessionId)).count;
-            yield this.startTurn(record.sessionId, message, Object.assign({ admission: (_f = options.admission) !== null && _f !== void 0 ? _f : "preempt" }, (options.coalesceSourceTs === undefined
+            yield this.startTurn(record.sessionId, message, Object.assign({ admission: (_f = sendOptions.admission) !== null && _f !== void 0 ? _f : "preempt" }, (sendOptions.coalesceSourceTs === undefined
                 ? {}
-                : { sourceTs: options.coalesceSourceTs })));
+                : { sourceTs: sendOptions.coalesceSourceTs })));
             return this.channelSession(record.sessionId, record, true, false, since);
         });
     }
@@ -1270,6 +1294,75 @@ export class SessionEngine {
             return Object.assign(Object.assign(Object.assign({}, outcome), (finalResult === undefined ? {} : { result: finalResult })), (finalUsage === undefined ? {} : { usage: finalUsage }));
         });
     }
+    /**
+     * Sync authored skills onto the Agent Store at `skills/<name>/…` (hosted)
+     * or `agent-serve/<agent>/skills/<name>/…` (personal-key local+cloud)
+     * before the first cloud prompt, so `--agent-store-skills-dir` and the
+     * first-turn S3 scan can discover them. False when the sync fails: the
+     * turn then runs without store skills rather than pointing discovery at
+     * paths that do not exist.
+     *
+     * With skills authored, every first cloud turn re-copies the authored
+     * bytes and the memo only dedupes concurrent first turns. The mount is
+     * writable from cloud sessions, so a once-per-process copy would let one
+     * session's edits masquerade as agent definition for every later session
+     * until the engine restarts; re-syncing keeps the store true to discovery
+     * the same way local materialization always rewrites skills. Without
+     * skills the sync is best-effort stale cleanup and one attempt per
+     * process is enough, success or not — a deployment without the files
+     * surface must not fail and log on every new session for a feature it
+     * does not use.
+     */
+    ensureCloudSkillsSynced() {
+        if (this.cloudSkillsSync !== undefined) {
+            return this.cloudSkillsSync;
+        }
+        const target = this.cloudSkillsStore();
+        if (target === undefined) {
+            this.cloudSkillsSync = Promise.resolve(false);
+            return this.cloudSkillsSync;
+        }
+        const skills = this.project.agent.skills;
+        let sync = syncSkillsToStore({
+            sink: target.sink,
+            agentName: this.project.name,
+            skills,
+            skillsPrefix: target.skillsPrefix,
+        }).then(() => true, (error) => {
+            this.logger(`[skills] ${target.label} sync failed: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        });
+        if (skills.length > 0) {
+            sync = sync.finally(() => {
+                this.cloudSkillsSync = undefined;
+            });
+        }
+        this.cloudSkillsSync = sync;
+        return sync;
+    }
+    /**
+     * Hosted deployments own the deployment store. Local `serve`/`run` with
+     * a personal API key writes into the USER store under `agent-serve/`.
+     */
+    cloudSkillsStore() {
+        if (isCursorHostedFilesAvailable()) {
+            return {
+                sink: cursorHostedFiles(),
+                skillsPrefix: agentStoreKeys.skillsPrefix(),
+                label: "deployment store",
+            };
+        }
+        if (isCursorUserStoreFilesAvailable()) {
+            return {
+                sink: cursorHostedFiles({
+                    storeSourceId: AGENT_SERVE_USER_STORE_FILES_SOURCE_ID,
+                }),
+                skillsPrefix: agentStoreKeys.userSkillsPrefix(this.project.name),
+                label: "user store",
+            };
+        }
+        return undefined;
+    }
     buildTurnRequest(record, agent, turnId, prompt, isFirstTurn, instructionsInvisibleToHarness, emit, onUpdate, signal, images) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
@@ -1315,8 +1408,9 @@ export class SessionEngine {
             if (isFirstTurn) {
                 if (runtime === "cloud") {
                     // Cloud VMs have no materialized workspace: ship the full context,
-                    // including agent tool script bodies. On hosted deployments the
-                    // shared memory journal is on the store mount — say where. When the
+                    // including agent tool script bodies. On hosted deployments authored
+                    // skills land on the store mount for native discovery, and the
+                    // shared memory journal is on that mount too — say where. When the
                     // turn carries the session-bound server-tool MCP endpoint, the
                     // preamble catalogs server tools under that MCP server name *before*
                     // the agent-tool "write the script if missing" recipe, so a model
@@ -1327,7 +1421,15 @@ export class SessionEngine {
                             ? undefined
                             : SERVER_TOOLS_MCP_SERVER_NAME,
                     });
-                    const memorySection = isCursorHostedFilesAvailable()
+                    const hosted = isCursorHostedFilesAvailable();
+                    // Synced whenever a store is reachable, not just when skills exist:
+                    // removing the last skill has to delete its store copies too.
+                    // Discovery is native (`--agent-store-skills-dir`); this only has
+                    // to land the bytes.
+                    if (hosted || isCursorUserStoreFilesAvailable()) {
+                        yield this.ensureCloudSkillsSynced();
+                    }
+                    const memorySection = hosted
                         ? `\n\n${buildCloudMemorySection(this.project.name)}`
                         : "";
                     turnPrompt = `${preamble}${memorySection}\n\n${turnPrompt}`;
@@ -1342,11 +1444,13 @@ export class SessionEngine {
                     turnPrompt = `${preamble}\n\n${turnPrompt}`;
                 }
             }
-            return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ sessionId: record.sessionId }, (record.sdkAgentId === undefined
+            return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ sessionId: record.sessionId }, (record.sdkAgentId === undefined
                 ? {}
                 : { sdkAgentId: record.sdkAgentId })), { workspaceDir: this.harnessCwd(record), sandbox: ((_c = this.project.agent.local) === null || _c === void 0 ? void 0 : _c.sandbox) === true }), (runtime === "local" && agent.allowedTools !== undefined
                 ? { tools: agent.allowedTools }
-                : {})), { runnerStateDir: join(this.stateRoot, "runner"), prompt: turnPrompt, isFirstTurn }), (images !== undefined && images.length > 0 ? { images } : {})), (agent.model === undefined ? {} : { model: agent.model })), { runtime }), (mergedCloud === undefined ? {} : { cloud: mergedCloud })), { customTools: runtime === "local"
+                : {})), { runnerStateDir: join(this.stateRoot, "runner"), prompt: turnPrompt, isFirstTurn }), (images !== undefined && images.length > 0 ? { images } : {})), (agent.model === undefined ? {} : { model: agent.model })), { runtime }), (mergedCloud === undefined ? {} : { cloud: mergedCloud })), (runtime === "cloud" && !isCursorHostedFilesAvailable()
+                ? { agentServeAgent: this.project.name }
+                : {})), { customTools: runtime === "local"
                     ? yield this.buildCustomTools(record, agent, turnId, emit)
                     : {}, mcpServers: this.buildMcpServers(runtime, record.sessionId, yield this.evaluateConnectionAuth(record)) }), (runtime === "local" && this.hasAttachedAuthedConnections()
                 ? { perSendMcpServers: true }

package/dist/internal/session-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../src/internal/session-store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,qBAAa,YAAY;IAKX,OAAO,CAAC,QAAQ,CAAC,WAAW;IAJxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAC1D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6B;IAC/D,OAAO,CAAC,QAAQ,CAA4B;IAE5C,YAA6B,WAAW,EAAE,MAAM,EAAI;IAEpD,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKpC;IAED,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtC;IAED,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvC;IAED,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,iBAAiB;YAIX,OAAO;YAmBP,cAAc;YAKd,UAAU;IAcxB,OAAO,CAAC,WAAW;IASb,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAc/D;IAEK,IAAI,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC,CAKrC;IAEK,kBAAkB,CACtB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAMpC;IAEK,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAoB/C;CACF"}
+{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../src/internal/session-store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD,qBAAa,YAAY;IAKX,OAAO,CAAC,QAAQ,CAAC,WAAW;IAJxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAC1D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6B;IAC/D,OAAO,CAAC,QAAQ,CAA4B;IAE5C,YAA6B,WAAW,EAAE,MAAM,EAAI;IAEpD,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKpC;IAED,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtC;IAED,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvC;IAED,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,iBAAiB;YASX,OAAO;YAmBP,cAAc;YAKd,UAAU;IAcxB,OAAO,CAAC,WAAW;IASb,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAc/D;IAEK,IAAI,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC,CAKrC;IAEK,kBAAkB,CACtB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAMpC;IAEK,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAoB/C;CACF"}

package/dist/internal/session-store.js

@@ -18,6 +18,7 @@ import { randomBytes } from "node:crypto";
 import { mkdir, readdir, readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { isSafeSessionId } from "./auth.js";
+import { isV2DurableContinuationKey } from "./continuation-identity.js";
 export class SessionStore {
     constructor(sessionsDir) {
         this.sessionsDir = sessionsDir;
@@ -40,6 +41,11 @@ export class SessionStore {
         return join(this.sessionDir(sessionId), "session.json");
     }
     continuationKeyOf(channelId, key) {
+        // 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}`;
     }
     hydrate() {

package/dist/internal/skills-sync.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { type FileSink } from "../files.js";
+import type { DiscoveredSkill } from "../types.js";
+/**
+ * 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, and writes
+ * land before stale deletes, so a failed sync never leaves a gap a
+ * concurrent cloud reader could see.
+ */
+export declare 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>;
+//# sourceMappingURL=skills-sync.d.ts.map

package/dist/internal/skills-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills-sync.d.ts","sourceRoot":"","sources":["../../src/internal/skills-sync.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAAqC,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE/E,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,aAAa,CAAC;AAQpE;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAC5C,IAAI,EAAE,QAAQ,CAAC;IACf,qFAAqF;IACrF,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IACnC,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBhB"}

package/dist/internal/skills-sync.js

@@ -0,0 +1,98 @@
+/**
+ * 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.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { readFile } from "node:fs/promises";
+import { posix } from "node:path";
+import { agentStoreKeys, FileConflictError } from "../files.js";
+import { STORAGE_KEY_ROOT } from "../storage.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) {
+    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, and writes
+ * land before stale deletes, so a failed sync never leaves a gap a
+ * concurrent cloud reader could see.
+ */
+export function syncSkillsToStore(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const skillsPrefix = (_a = args.skillsPrefix) !== null && _a !== void 0 ? _a : agentStoreKeys.skillsPrefix();
+        const desired = new Map();
+        for (const skill of args.skills) {
+            const key = (relPath) => 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)), yield sourceBytes(source));
+            }
+        }
+        yield Promise.all([...desired].map(([key, body]) => putLastWriterWins(args.sink, key, body)));
+        const [existing, leftover] = yield Promise.all([
+            args.sink.list(skillsPrefix),
+            args.sink.list(legacySkillsPrefix(args.agentName)),
+        ]);
+        yield Promise.all([...existing.filter((entry) => !desired.has(entry.key)), ...leftover].map((entry) => args.sink.delete(entry.key)));
+    });
+}
+/**
+ * Same refusals as local materialization's `resolveInside`: a rel that
+ * escapes the skill directory or would not round-trip through the FUSE
+ * mount (`..`, `.`, `//`, absolute) fails the sync, exactly as it fails a
+ * local turn's workspace write. Backslashes are refused too — the store
+ * normalizes `\` to `/` on write, so the stored key would differ from the
+ * desired one and the stale pass would delete the file it just wrote.
+ */
+function storeRelPath(relPath) {
+    if (relPath.includes("\0") ||
+        relPath.includes("\\") ||
+        posix.isAbsolute(relPath) ||
+        relPath.endsWith("/") ||
+        relPath.split("/").some((seg) => seg === ".." || seg === ".") ||
+        posix.normalize(relPath) !== relPath) {
+        throw new Error(`Refusing skill file path "${relPath}" (must be a normalized relative path)`);
+    }
+    return relPath;
+}
+/**
+ * Last writer wins. A raced conditional put (dual engine pods during a
+ * deploy rollover) clears the sink's cached etag, so one retry re-learns
+ * the current version and lands.
+ */
+function putLastWriterWins(sink, key, body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield sink.put(key, body);
+        }
+        catch (error) {
+            if (!(error instanceof FileConflictError)) {
+                throw error;
+            }
+            yield sink.put(key, body);
+        }
+    });
+}
+function sourceBytes(source) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return "contents" in source
+            ? Buffer.from(source.contents, "utf8")
+            : readFile(source.sourcePath);
+    });
+}