deepline 0.3.23 → 0.3.25

package/dist/cli/index.mjs

@@ -164,7 +164,7 @@ configureProxyFromEnv();
 
 // src/cli/index.ts
 import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile6 } from "fs/promises";
-import { join as join22 } from "path";
+import { join as join21 } from "path";
 import { tmpdir as tmpdir6 } from "os";
 import { Command as Command4 } from "commander";
 
@@ -980,11 +980,6 @@ function getActiveProjectAuthSource(startDir = process.cwd()) {
   return loadProjectEnvCandidates(startDir)[0] ?? null;
 }
 
-// src/http.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join2 } from "path";
-
 // ../shared_libs/plays/artifact-contract-version.ts
 var CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION = 2;
 
@@ -1033,7 +1028,7 @@ var SDK_RELEASE = {
   // 0.3.0 introduces raw-v2: complete scrubbed provider responses are
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
-  version: "0.3.23",
+  version: "0.3.25",
   updateSummary: "New raw-v2 tool responses preserve complete scrubbed provider envelopes at toolResponse.rawV2, including JSON:API included resources, links, cursors, and totals. Existing toolResponse.raw and declared getters keep working unchanged.",
   contracts: {
     api: {
@@ -1222,6 +1217,88 @@ function detectAgentRuntime(options = {}) {
   return options.defaultRuntime ?? "unknown";
 }
 
+// src/skills-version.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+function activePluginSkillsDir() {
+  const pluginMode = process.env.DEEPLINE_PLUGIN_MODE?.trim().toLowerCase();
+  if (pluginMode !== "true" && pluginMode !== "1" && pluginMode !== "yes" && pluginMode !== "on") {
+    return "";
+  }
+  const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
+  return dir && existsSync2(dir) ? dir : "";
+}
+function hasActivePluginSkills() {
+  return Boolean(activePluginSkillsDir());
+}
+function readPluginSkillsVersion() {
+  const dir = activePluginSkillsDir();
+  if (!dir) return "";
+  try {
+    return readFileSync2(join2(dir, ".version"), "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+function sdkSkillsVersionPath(baseUrl, agents = []) {
+  const suffix = agents.length > 0 ? `-${agents.join("-")}` : "";
+  return join2(sdkCliStateDirPath(baseUrl), `skills${suffix}-version`);
+}
+function legacySdkSkillsVersionPath(baseUrl) {
+  return join2(dirname2(sdkCliStateDirPath(baseUrl)), "sdk-skills", ".version");
+}
+function resolveAutoSyncSkillAgents() {
+  switch (detectAgentRuntime()) {
+    case "codex":
+      return ["codex"];
+    case "claude_code":
+      return ["claude-code"];
+    case "cursor":
+      return ["cursor"];
+    case "gemini":
+      return ["gemini-cli"];
+    case "antigravity":
+      return ["antigravity"];
+    default:
+      return [];
+  }
+}
+function readSdkSkillsLocalVersion(baseUrl) {
+  const pluginVersion = readPluginSkillsVersion();
+  if (pluginVersion) return pluginVersion;
+  const agents = resolveAutoSyncSkillAgents();
+  const scopedPath = sdkSkillsVersionPath(baseUrl, agents);
+  if (agents.length > 0 && existsSync2(scopedPath)) {
+    try {
+      return readFileSync2(scopedPath, "utf-8").trim();
+    } catch {
+      return "";
+    }
+  }
+  if (agents.length > 0) {
+    const legacyPath = legacySdkSkillsVersionPath(baseUrl);
+    if (!existsSync2(legacyPath)) return "";
+    try {
+      return readFileSync2(legacyPath, "utf-8").trim();
+    } catch {
+      return "";
+    }
+  }
+  const path = existsSync2(sdkSkillsVersionPath(baseUrl)) ? sdkSkillsVersionPath(baseUrl) : legacySdkSkillsVersionPath(baseUrl);
+  if (!existsSync2(path)) return "";
+  try {
+    return readFileSync2(path, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+function writeSdkSkillsLocalVersion(baseUrl, version, agents) {
+  const path = sdkSkillsVersionPath(baseUrl, agents);
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, `${version}
+`, "utf-8");
+}
+
 // ../shared_libs/play-runtime/coordinator-headers.ts
 var COORDINATOR_INTERNAL_TOKEN_HEADER = "x-deepline-internal-token";
 var COORDINATOR_URL_OVERRIDE_HEADER = "x-deepline-coordinator-url";
@@ -1558,21 +1635,9 @@ var HttpClient = class {
     );
     if (explicit) return explicit;
     try {
-      const versionPath = join2(
-        sdkCliStateDirPath(this.config.baseUrl),
-        "skills-version"
-      );
-      const legacyVersionPath = join2(
-        process.env.HOME?.trim() || homedir3(),
-        ".local",
-        "deepline",
-        baseUrlSlug(this.config.baseUrl),
-        "sdk-skills",
-        ".version"
+      return this.cleanDiagnosticHeader(
+        readSdkSkillsLocalVersion(this.config.baseUrl)
       );
-      const resolvedPath = existsSync2(versionPath) ? versionPath : legacyVersionPath;
-      if (!existsSync2(resolvedPath)) return null;
-      return this.cleanDiagnosticHeader(readFileSync2(resolvedPath, "utf-8"));
     } catch {
       return null;
     }
@@ -6977,19 +7042,19 @@ var DeeplineClient = class {
 };
 
 // src/compat.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname2, join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname3, join as join3 } from "path";
 var CHECK_TIMEOUT_MS = 2e3;
 var SDK_COMPATIBILITY_CACHE_TTL_MS = 5 * 60 * 1e3;
 function shouldSkipCompatibilityCheck() {
   const value = process.env.DEEPLINE_SKIP_SDK_COMPAT_CHECK?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes";
 }
-function sdkCompatibilityCachePath(baseUrl, homeDir2 = homedir4()) {
+function sdkCompatibilityCachePath(baseUrl, homeDir2 = homedir3()) {
   return join3(sdkCliStateDirPath(baseUrl, homeDir2), "compat-cache.json");
 }
-function legacySdkCompatibilityCachePath(homeDir2 = homedir4()) {
+function legacySdkCompatibilityCachePath(homeDir2 = homedir3()) {
   return join3(homeDir2, ".cache", "deepline", "sdk-compat-cache.json");
 }
 function compatibilityCacheKey(baseUrl, command, skillsVersion) {
@@ -7040,8 +7105,8 @@ function writeCachedCompatibility(baseUrl, command, skillsVersion, response) {
       savedAt: Date.now(),
       response
     };
-    mkdirSync2(dirname2(path), { recursive: true });
-    writeFileSync2(path, `${JSON.stringify({ entries }, null, 2)}
+    mkdirSync3(dirname3(path), { recursive: true });
+    writeFileSync3(path, `${JSON.stringify({ entries }, null, 2)}
 `);
   } catch {
   }
@@ -7114,26 +7179,26 @@ function enforceSdkCompatibilityResponse(response) {
 // src/cli/commands/auth.ts
 import {
   existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readFileSync as readFileSync5,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
 import { hostname } from "os";
-import { dirname as dirname4, join as join5 } from "path";
+import { dirname as dirname5, join as join5 } from "path";
 
 // src/cli/utils.ts
 import { createHash } from "crypto";
 import {
   existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   readFileSync as readFileSync4,
   rmSync,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
 import { mkdir, writeFile } from "fs/promises";
-import { homedir as homedir5, tmpdir, userInfo } from "os";
-import { dirname as dirname3, join as join4, resolve as resolve2 } from "path";
+import { homedir as homedir4, tmpdir, userInfo } from "os";
+import { dirname as dirname4, join as join4, resolve as resolve2 } from "path";
 import * as childProcess from "child_process";
 import { parse } from "csv-parse/sync";
 import { stringify } from "csv-stringify/sync";
@@ -7179,9 +7244,9 @@ function claimBrowserOpen(now = Date.now(), stateDir, targetUrl) {
   const targetKey = browserOpenTargetKey(targetUrl);
   let locked = false;
   try {
-    mkdirSync3(dirname3(statePath), { recursive: true, mode: 448 });
+    mkdirSync4(dirname4(statePath), { recursive: true, mode: 448 });
     try {
-      mkdirSync3(lockPath, { mode: 448 });
+      mkdirSync4(lockPath, { mode: 448 });
       locked = true;
     } catch {
       return false;
@@ -7203,7 +7268,7 @@ function claimBrowserOpen(now = Date.now(), stateDir, targetUrl) {
         return false;
       }
     }
-    writeFileSync3(
+    writeFileSync4(
       statePath,
       JSON.stringify({
         lastOpenedAt: now,
@@ -7264,7 +7329,7 @@ function readMacosUserHome(runner = defaultBrowserCommandRunner) {
     } catch {
     }
   }
-  return homedir5();
+  return homedir4();
 }
 function readDefaultMacBrowserBundleId(runner = defaultBrowserCommandRunner) {
   try {
@@ -7452,9 +7517,7 @@ function openUrlMacos(targetUrl, allowFocus, runner = defaultBrowserCommandRunne
   }
 }
 function browserOpeningDisabled() {
-  const value = String(
-    process.env.DEEPLINE_NO_BROWSER ?? process.env.PLAYGROUND_HEADLESS ?? ""
-  ).trim().toLowerCase();
+  const value = String(process.env.DEEPLINE_NO_BROWSER ?? "").trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
 function openInBrowser(url, options = {}) {
@@ -7486,7 +7549,7 @@ function sleep3(ms) {
   return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
 }
 function collectLocalEnvInfo() {
-  const homeDir2 = process.env.HOME?.trim() || homedir5();
+  const homeDir2 = process.env.HOME?.trim() || homedir4();
   const info = {
     os: `${process.platform} ${process.arch}`,
     node_version: process.version,
@@ -7864,11 +7927,11 @@ function legacyPendingClaimTokenPath(baseUrl) {
 }
 function savePendingClaim(baseUrl, claim) {
   const filePath = pendingClaimPath(baseUrl, claim.scope);
-  const dir = dirname4(filePath);
+  const dir = dirname5(filePath);
   if (!existsSync5(dir)) {
-    mkdirSync4(dir, { recursive: true });
+    mkdirSync5(dir, { recursive: true });
   }
-  writeFileSync4(filePath, `${JSON.stringify(claim, null, 2)}
+  writeFileSync5(filePath, `${JSON.stringify(claim, null, 2)}
 `, {
     encoding: "utf-8",
     mode: 384
@@ -8580,7 +8643,7 @@ Examples:
 import { Command } from "commander";
 import { randomUUID } from "crypto";
 import { appendFile, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname5, resolve as resolve3 } from "path";
+import { dirname as dirname6, resolve as resolve3 } from "path";
 import { stringify as stringify2 } from "csv-stringify/sync";
 var SUBSCRIPTION_STATUS_NEXT_COMMAND = "deepline billing subscription status --json";
 var SUBSCRIPTION_CANCEL_PATH = "/api/v2/billing/subscription/cancel";
@@ -9039,7 +9102,7 @@ async function handleLedgerExportAll(options) {
     const entries = Array.isArray(payload.entries) ? payload.entries : [];
     const rows = entries.map(ledgerApiEntryToRow);
     if (!initializedOutput) {
-      await mkdir2(dirname5(outputPath), { recursive: true });
+      await mkdir2(dirname6(outputPath), { recursive: true });
       await writeFile2(outputPath, ledgerRowsToCsv([], true), "utf-8");
       initializedOutput = true;
     }
@@ -9991,17 +10054,17 @@ import { randomUUID as randomUUID2 } from "crypto";
 import {
   closeSync,
   existsSync as existsSync6,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   openSync,
   readFileSync as readFileSync6,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir5 } from "os";
 import { join as join6, resolve as resolve5 } from "path";
 
 // src/cli/dataset-stats.ts
-import { writeFileSync as writeFileSync5 } from "fs";
+import { writeFileSync as writeFileSync6 } from "fs";
 import { resolve as resolve4 } from "path";
 
 // ../shared_libs/plays/dataset-summary.ts
@@ -10656,7 +10719,7 @@ function writeCanonicalRowsCsv(rowsInfo, outPath) {
   const rows = dataExportRows(sanitized.rows);
   const columns = dataExportColumns(rows, sanitized.columns);
   const resolved = resolve4(outPath);
-  writeFileSync5(resolved, csvStringFromRows(rows, columns), "utf-8");
+  writeFileSync6(resolved, csvStringFromRows(rows, columns), "utf-8");
   return resolved;
 }
 
@@ -10764,13 +10827,13 @@ async function handleCsvShow(options) {
   );
 }
 function csvRenderStatePath() {
-  return join6(homedir6(), ".local", "deepline", "runtime", "csv-render.json");
+  return join6(homedir5(), ".local", "deepline", "runtime", "csv-render.json");
 }
 function csvRenderLogPath() {
-  return join6(homedir6(), ".local", "deepline", "runtime", "csv-render.log");
+  return join6(homedir5(), ".local", "deepline", "runtime", "csv-render.log");
 }
 function ensureCsvRenderStateDir() {
-  mkdirSync5(join6(homedir6(), ".local", "deepline", "runtime"), {
+  mkdirSync6(join6(homedir5(), ".local", "deepline", "runtime"), {
     recursive: true
   });
 }
@@ -10784,7 +10847,7 @@ function readCsvRenderState() {
 }
 function writeCsvRenderState(state) {
   ensureCsvRenderStateDir();
-  writeFileSync6(csvRenderStatePath(), `${JSON.stringify(state, null, 2)}
+  writeFileSync7(csvRenderStatePath(), `${JSON.stringify(state, null, 2)}
 `);
 }
 function parseCsvRenderPort(raw) {
@@ -10936,7 +10999,7 @@ async function handleCsvRenderStart(options) {
       rmSync3(csvRenderStatePath(), { force: true });
     } else if (existingOwned) {
       process.stdout.write(
-        "Playground render is already running; reusing current process.\n"
+        "CSV render is already running; reusing current process.\n"
       );
       process.stdout.write(`Render URL: ${existing.url}
 `);
@@ -10952,20 +11015,16 @@ async function handleCsvRenderStart(options) {
   const logPath = csvRenderLogPath();
   const logFd = openSync(logPath, "w");
   const token = randomUUID2();
-  const child = spawn(
-    process.execPath,
-    ["-e", CSV_RENDER_SERVER_SOURCE],
-    {
-      detached: true,
-      stdio: ["ignore", logFd, logFd],
-      env: {
-        ...process.env,
-        DEEPLINE_CSV_RENDER_PORT: String(port),
-        DEEPLINE_CSV_RENDER_CSV: csvPath,
-        DEEPLINE_CSV_RENDER_TOKEN: token
-      }
+  const child = spawn(process.execPath, ["-e", CSV_RENDER_SERVER_SOURCE], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: {
+      ...process.env,
+      DEEPLINE_CSV_RENDER_PORT: String(port),
+      DEEPLINE_CSV_RENDER_CSV: csvPath,
+      DEEPLINE_CSV_RENDER_TOKEN: token
     }
-  );
+  });
   closeSync(logFd);
   child.unref();
   const state = {
@@ -10997,12 +11056,12 @@ ${clip(log, 2e3)}`;
     );
   }
   writeCsvRenderState(state);
-  writeFileSync6(
+  writeFileSync7(
     logPath,
     `CSV render started at ${state.startedAt} on ${url}
 `
   );
-  process.stdout.write("Playground render is running.\n");
+  process.stdout.write("CSV render is running.\n");
   process.stdout.write(`Render PID: ${child.pid}
 `);
   process.stdout.write(`Render URL: ${url}
@@ -11073,8 +11132,8 @@ async function handleCsvRenderStop(options) {
     stopped_pids: stopped,
     failed_pids: failed
   };
-  const text = stopped.length > 0 ? `Stopped playground render process(es): ${stopped.join(" ")}
-` : "No running playground render process found.\n";
+  const text = stopped.length > 0 ? `Stopped CSV render process(es): ${stopped.join(" ")}
+` : "No running CSV render process found.\n";
   printCommandEnvelope(payload, { json: options.json, text });
 }
 async function handleCsvRender(action, options) {
@@ -11124,7 +11183,7 @@ Examples:
 }
 
 // src/cli/commands/db.ts
-import { writeFileSync as writeFileSync7 } from "fs";
+import { writeFileSync as writeFileSync8 } from "fs";
 import { resolve as resolve6 } from "path";
 var CUSTOMER_DB_QUERY_FORMATS = /* @__PURE__ */ new Set(["table", "json", "csv", "markdown"]);
 var CUSTOMER_DB_QUERY_MAX_ROWS = 1e3;
@@ -11271,7 +11330,7 @@ function dbRepairPlainText(result) {
 }
 function writeCustomerDbCsv(result, outPath) {
   const resolved = resolve6(outPath);
-  writeFileSync7(
+  writeFileSync8(
     resolved,
     dataExportCsvString(customerDbRows(result), customerDbColumnNames(result)),
     "utf-8"
@@ -11384,7 +11443,7 @@ async function handleDbQuery(args) {
     );
     if (outPath) {
       const exportedPath = resolve6(outPath);
-      writeFileSync7(exportedPath, content, "utf-8");
+      writeFileSync8(exportedPath, content, "utf-8");
       printCommandEnvelope(
         dbQueryExportEnvelope({
           result,
@@ -11567,20 +11626,20 @@ import {
   stat as stat3,
   writeFile as writeFile4
 } from "fs/promises";
-import { homedir as homedir7, tmpdir as tmpdir4 } from "os";
-import { basename as basename4, dirname as dirname10, extname as extname3, join as join11, resolve as resolve12 } from "path";
+import { homedir as homedir6, tmpdir as tmpdir4 } from "os";
+import { basename as basename4, dirname as dirname11, extname as extname3, join as join11, resolve as resolve12 } from "path";
 import { Option } from "commander";
 
 // src/cli/commands/play.ts
 import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
 import {
   existsSync as existsSync9,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   readFileSync as readFileSync8,
   readdirSync as readdirSync2,
   realpathSync as realpathSync2,
   statSync as statSync3,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "fs";
 import {
   lstat,
@@ -11591,7 +11650,7 @@ import {
 } from "fs/promises";
 import {
   basename as basename3,
-  dirname as dirname9,
+  dirname as dirname10,
   isAbsolute as isAbsolute5,
   join as join10,
   relative as relative4,
@@ -11605,7 +11664,7 @@ import {
   openSync as openSync2,
   readSync,
   statSync as statSync2,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "fs";
 import { isAbsolute as isAbsolute2, relative, resolve as resolve7 } from "path";
 import { parse as parseCsvSync } from "csv-parse/sync";
@@ -13167,7 +13226,7 @@ function renderPlayBootstrapError(error) {
 }
 function writeBootstrapSource(source, out) {
   if (out) {
-    writeFileSync8(resolve7(out), source, "utf-8");
+    writeFileSync9(resolve7(out), source, "utf-8");
     process.stdout.write(`Wrote ${resolve7(out)}
 `);
     return 0;
@@ -13305,7 +13364,7 @@ Examples:
 
 // src/plays/bundle-play-file.ts
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname8, join as join9, resolve as resolve10 } from "path";
+import { dirname as dirname9, join as join9, resolve as resolve10 } from "path";
 import { fileURLToPath } from "url";
 import { existsSync as existsSync8 } from "fs";
 import { realpath as realpath2 } from "fs/promises";
@@ -13317,7 +13376,7 @@ import { mkdir as mkdir3, readFile, realpath, stat, writeFile as writeFile3 } fr
 import { tmpdir as tmpdir2 } from "os";
 import {
   basename,
-  dirname as dirname6,
+  dirname as dirname7,
   extname,
   isAbsolute as isAbsolute3,
   join as join7,
@@ -18165,7 +18224,7 @@ import { createHash as createHash3 } from "crypto";
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import {
   basename as basename2,
-  dirname as dirname7,
+  dirname as dirname8,
   extname as extname2,
   isAbsolute as isAbsolute4,
   join as join8,
@@ -18174,7 +18233,7 @@ import {
 } from "path";
 
 // src/plays/bundle-play-file.ts
-var MODULE_DIR = dirname8(fileURLToPath(import.meta.url));
+var MODULE_DIR = dirname9(fileURLToPath(import.meta.url));
 var SDK_PACKAGE_ROOT = resolve10(MODULE_DIR, "..", "..");
 var SOURCE_REPO_ROOT = resolve10(SDK_PACKAGE_ROOT, "..");
 var HAS_SOURCE_BUNDLING_SOURCES = existsSync8(
@@ -19027,7 +19086,7 @@ async function pathExistsIncludingSymlink(path) {
 }
 function runIdFileTempPath(destination) {
   return join10(
-    dirname9(destination),
+    dirname10(destination),
     `.${basename3(destination)}.${process.pid}.${randomUUID3()}.tmp`
   );
 }
@@ -19104,7 +19163,7 @@ async function writePlayRunIdFile(destination, runId) {
     try {
       await link(tempPath, destination);
       if (process.platform !== "win32") {
-        const directory = await open(dirname9(destination), "r");
+        const directory = await open(dirname10(destination), "r");
         try {
           await directory.sync();
         } finally {
@@ -19445,12 +19504,12 @@ function materializeRemotePlaySource(input2) {
           `Refusing to materialize unsafe Play source path ${JSON.stringify(logicalPath)}.`
         );
       }
-      mkdirSync6(dirname9(outputPath2), { recursive: true });
+      mkdirSync7(dirname10(outputPath2), { recursive: true });
       if (!existsSync9(outputPath2)) {
-        writeFileSync9(outputPath2, sourceCode, "utf-8");
+        writeFileSync10(outputPath2, sourceCode, "utf-8");
         created += 1;
       } else if (readFileSync8(outputPath2, "utf-8") !== sourceCode) {
-        writeFileSync9(outputPath2, sourceCode, "utf-8");
+        writeFileSync10(outputPath2, sourceCode, "utf-8");
         updated += 1;
       }
     }
@@ -19467,10 +19526,10 @@ function materializeRemotePlaySource(input2) {
     if (existingSource === entrySource) {
       return { path: outputPath, status: "unchanged", created: false };
     }
-    writeFileSync9(outputPath, entrySource, "utf-8");
+    writeFileSync10(outputPath, entrySource, "utf-8");
     return { path: outputPath, status: "updated", created: false };
   }
-  writeFileSync9(outputPath, entrySource, "utf-8");
+  writeFileSync10(outputPath, entrySource, "utf-8");
   return { path: outputPath, status: "created", created: true };
 }
 function formatLoadedPlayMessage(materializedFile) {
@@ -19622,7 +19681,9 @@ function stringMetadata(metadata, key) {
 }
 function inputFieldFromCsvArg(csvArg) {
   if (typeof csvArg !== "string") return null;
-  const match = /^input\.([A-Za-z_$][\w$]*)$/.exec(csvArg.trim());
+  const match = /^\(?\s*input\.([A-Za-z_$][\w$]*)\s*\)?(?:\s*\?\?[\s\S]+)?$/.exec(
+    csvArg.trim()
+  );
   return match?.[1] ?? null;
 }
 function fileInputBindingsFromPlaySchema(inputSchema) {
@@ -23395,6 +23456,21 @@ function printPlayCheckLimits(limits) {
   console.log(
     `  bundle: ${formatByteBudget(limits.bundle.usedBytes, limits.bundle.limitBytes)}`
   );
+  if (limits.activeScheduledPlays) {
+    const { used, limit, remaining } = limits.activeScheduledPlays;
+    console.log(
+      `  scheduled plays: ${used} / ${limit} active (${remaining} available)`
+    );
+  }
+}
+function formatPlayRuntimeLimit(runtimeLimit) {
+  if (!runtimeLimit || !Number.isFinite(runtimeLimit.timeoutSeconds)) {
+    return null;
+  }
+  const seconds = runtimeLimit.timeoutSeconds;
+  if (seconds % 3600 === 0) return `${seconds / 3600}h`;
+  if (seconds % 60 === 0) return `${seconds / 60}m`;
+  return `${seconds}s`;
 }
 function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -23889,6 +23965,8 @@ function printPlayCheckOutcome(outcome, target, prefix) {
   if (result.sourceHash) {
     console.log(`  source: ${result.sourceHash.slice(0, 12)}`);
   }
+  const runtimeLimit = formatPlayRuntimeLimit(result.runtimeLimit);
+  if (runtimeLimit) console.log(`  runtime limit: ${runtimeLimit}`);
   printPlayCheckLimits(result.limits);
   if (result.artifactHash && outcome.exportName === PLAY_DEFAULT_EXPORT) {
     console.log(
@@ -24328,7 +24406,7 @@ async function handlePlayRun(args, hooks) {
     }
     const resolved = resolve11(options.target.path);
     console.error(`File not found: ${resolved}`);
-    const dir = dirname9(resolved);
+    const dir = dirname10(resolved);
     if (existsSync9(dir)) {
       const base = basename3(resolved);
       try {
@@ -24615,7 +24693,7 @@ async function handleRunLogs(args) {
   if (outPath) {
     const result2 = await client2.runs.logs(runId, { all: true });
     const logs = result2.entries;
-    writeFileSync9(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
+    writeFileSync10(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
     printCommandEnvelope(
       {
         runId: result2.runId,
@@ -24829,7 +24907,7 @@ async function handleRunExport(args) {
     }
   };
   if (metadataOutPath) {
-    writeFileSync9(
+    writeFileSync10(
       metadataOutPath,
       `${JSON.stringify(payload, null, 2)}
 `,
@@ -28587,10 +28665,10 @@ function expandAtFilePath(rawPath) {
     (_match, bareName, bracedName) => process.env[bareName ?? bracedName ?? ""] ?? ""
   );
   if (expanded === "~") {
-    return homedir7();
+    return homedir6();
   }
   if (expanded.startsWith("~/") || expanded.startsWith("~\\")) {
-    return join11(homedir7(), expanded.slice(2));
+    return join11(homedir6(), expanded.slice(2));
   }
   return expanded;
 }
@@ -30972,7 +31050,7 @@ function sidecarEnrichRowsExportPath(outputPath) {
   const resolved = resolve12(outputPath);
   const ext = extname3(resolved) || ".csv";
   const stem = basename4(resolved, ext);
-  return join11(dirname10(resolved), `${stem}.deepline-enrich-rows${ext}`);
+  return join11(dirname11(resolved), `${stem}.deepline-enrich-rows${ext}`);
 }
 function collectDatasetFollowUpCommands(value, state) {
   if (state.depth > 12 || !value || typeof value !== "object" || state.commands.length >= 8) {
@@ -31053,7 +31131,7 @@ async function persistEnrichFailureReport(input2) {
   if (input2.jobs.length === 0 && input2.issues.length === 0) {
     return null;
   }
-  const stateDir = join11(homedir7(), ".local", "deepline", "runtime", "state");
+  const stateDir = join11(homedir6(), ".local", "deepline", "runtime", "state");
   const reportPrefix = input2.jobs.length > 0 ? "run-block-failures" : "enrich-issues";
   await mkdir4(stateDir, { recursive: true });
   const reportPath = join11(
@@ -32016,7 +32094,7 @@ function registerEnrichCommand(program) {
       }
       inPlaceTempDir = await mkdtemp(
         join11(
-          dirname10(inPlaceCommitOutputPath ?? resolve12(inputCsv)),
+          dirname11(inPlaceCommitOutputPath ?? resolve12(inputCsv)),
           ".deepline-enrich-in-place-"
         )
       );
@@ -32297,14 +32375,14 @@ Examples:
 // src/cli/commands/sessions.ts
 import {
   existsSync as existsSync10,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync8,
   readdirSync as readdirSync3,
   readFileSync as readFileSync9,
   statSync as statSync4,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "fs";
-import { homedir as homedir8, platform } from "os";
-import { basename as basename5, dirname as dirname11, join as join12, resolve as resolve13 } from "path";
+import { homedir as homedir7, platform } from "os";
+import { basename as basename5, dirname as dirname12, join as join12, resolve as resolve13 } from "path";
 import { gzipSync } from "zlib";
 import { randomUUID as randomUUID4 } from "crypto";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -32318,7 +32396,7 @@ var MAX_EVENT_OBJECT_KEYS = 80;
 var TRUNCATION_MARKER = "...[truncated]";
 var NOISE_EVENT_TYPES = /* @__PURE__ */ new Set(["progress", "file-history-snapshot"]);
 function homeDir() {
-  return process.env.HOME?.trim() || homedir8();
+  return process.env.HOME?.trim() || homedir7();
 }
 function detectShellContext() {
   const shellPath = process.env.SHELL?.trim() || process.env.ComSpec?.trim() || process.env.COMSPEC?.trim() || "";
@@ -32853,9 +32931,9 @@ function loadViewerAssets() {
   const cliEntry = process.argv[1]?.trim() ? resolve13(process.argv[1]) : null;
   const candidateRoots2 = [
     ...cliEntry ? [
-      join12(dirname11(dirname11(cliEntry)), "viewer"),
+      join12(dirname12(dirname12(cliEntry)), "viewer"),
       join12(
-        dirname11(dirname11(dirname11(cliEntry))),
+        dirname12(dirname12(dirname12(cliEntry))),
         "src",
         "lib",
         "cli",
@@ -32898,13 +32976,13 @@ async function handleSessionsRender(options) {
   let outputPath = options.output ? resolve13(options.output) : "";
   if (!outputPath) {
     const outputDir = join12(process.cwd(), "deepline", "data");
-    mkdirSync7(outputDir, { recursive: true });
+    mkdirSync8(outputDir, { recursive: true });
     outputPath = join12(
       outputDir,
       targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
     );
   } else {
-    mkdirSync7(dirname11(outputPath), { recursive: true });
+    mkdirSync8(dirname12(outputPath), { recursive: true });
   }
   const sessions = targets.map((target) => ({
     label: target.label,
@@ -32934,7 +33012,7 @@ ${refreshMeta}
 <script>${js}</script>
 </body>
 </html>`;
-  writeFileSync10(outputPath, html, "utf8");
+  writeFileSync11(outputPath, html, "utf8");
   printCommandEnvelope(
     {
       ok: true,
@@ -33041,30 +33119,31 @@ var BACKEND_SUBCOMMANDS = [
   "refresh-runtime",
   "sync-runtime"
 ];
-function legacyNoopEnvelope(input2) {
+function deprecatedCommandEnvelope(input2) {
   const command = ["deepline", input2.family, input2.subcommand].filter(Boolean).join(" ");
-  const subject = input2.family === "session" ? "Legacy Session UI/playground command" : "Legacy local playground backend command";
-  const note = input2.family === "session" ? "The SDK CLI does not manage the legacy Python Session UI. This command is accepted for backwards compatibility and intentionally does nothing." : "The SDK CLI does not start or stop the legacy Python local playground backend. This command is accepted for backwards compatibility and intentionally does nothing.";
+  const commandLabel = input2.family === "session" ? "Legacy session command" : "Legacy backend command";
+  const note = input2.family === "session" ? "This command was retired with the legacy Python Session UI. Use `deepline sessions send` or `deepline sessions render`." : "This command was retired with the legacy local backend. Use `deepline-admin dev start`, `deepline-admin dev status`, or `deepline-admin dev stop`.";
   return {
-    ok: true,
-    noop: true,
+    ok: false,
     command,
-    compatibility: {
-      family: "legacy_python_cli",
-      sdk_behavior: "noop"
-    },
+    code: "DEPRECATED_COMMAND",
+    error: `${commandLabel} is deprecated. ${note}`,
+    next: input2.family === "session" ? "deepline sessions send --current-session --json" : "deepline-admin dev status --json",
     render: {
       sections: [
         {
-          title: subject,
+          title: `${commandLabel} deprecated`,
           lines: [note]
         }
       ]
     }
   };
 }
-function printLegacyNoop(input2) {
-  printCommandEnvelope(legacyNoopEnvelope(input2), { json: input2.options.json });
+function printDeprecatedCommand(input2) {
+  printCommandEnvelope(deprecatedCommandEnvelope(input2), {
+    json: input2.options.json
+  });
+  process.exitCode = 2;
 }
 function legacySubcommandFromArgv(family) {
   const args = process.argv.slice(2);
@@ -33072,18 +33151,18 @@ function legacySubcommandFromArgv(family) {
   const nextToken = familyIndex >= 0 ? args[familyIndex + 1] : void 0;
   return nextToken && !nextToken.startsWith("-") ? nextToken : void 0;
 }
-function addLegacyNoopSubcommand(parent, family, subcommand, description) {
+function addDeprecatedSubcommand(parent, family, subcommand, description) {
   parent.command(subcommand).description(description).allowUnknownOption(true).allowExcessArguments(true).option("--json", "Emit JSON output").argument("[args...]").action((_args, options) => {
-    printLegacyNoop({ family, subcommand, options });
+    printDeprecatedCommand({ family, subcommand, options });
   });
 }
-function registerLegacyNoopCommands(program) {
-  const session = program.command("session").description("Compatibility no-ops for legacy Python Session UI commands.").allowUnknownOption(true).allowExcessArguments(true).option("--json", "Emit JSON output").argument("[args...]").addHelpText(
+function registerDeprecatedCommands(program) {
+  const session = program.command("session").description("Deprecated legacy session command namespace.").allowUnknownOption(true).allowExcessArguments(true).option("--json", "Emit JSON output").argument("[args...]").addHelpText(
     "after",
     `
 Notes:
-  The SDK CLI accepts singular session commands from older agent skills so they
-  do not fail, but it does not manage the legacy Python Session UI.
+  The legacy Python Session UI was retired. Legacy session commands now fail
+  with a migration instruction; they no longer report a successful no-op.
   Use "deepline sessions send" or "deepline sessions render" for real SDK
   transcript workflows. "deepline session send" and "deepline session render"
   are accepted aliases for those real SDK workflows.
@@ -33095,7 +33174,7 @@ Examples:
 	`
   ).action((args, options) => {
     void args;
-    printLegacyNoop({
+    printDeprecatedCommand({
       family: "session",
       subcommand: legacySubcommandFromArgv("session"),
       options
@@ -33103,21 +33182,19 @@ Examples:
   });
   registerSessionSendRenderCommands(session, "session");
   for (const subcommand of SESSION_SUBCOMMANDS) {
-    addLegacyNoopSubcommand(
+    addDeprecatedSubcommand(
       session,
       "session",
       subcommand,
-      `Accept legacy "deepline session ${subcommand}" as an SDK no-op.`
+      `Deprecated legacy "deepline session ${subcommand}" command.`
     );
   }
-  const backend = program.command("backend").description(
-    "Compatibility no-ops for legacy Python local backend commands."
-  ).allowUnknownOption(true).allowExcessArguments(true).option("--json", "Emit JSON output").argument("[args...]").addHelpText(
+  const backend = program.command("backend").description("Deprecated legacy local backend command namespace.").allowUnknownOption(true).allowExcessArguments(true).option("--json", "Emit JSON output").argument("[args...]").addHelpText(
     "after",
     `
 Notes:
-  The SDK CLI uses the configured Deepline host and V2 play runtime. It does not
-  start, stop, or refresh the legacy Python local playground backend.
+  The legacy local backend was retired. Use deepline-admin for local runtime
+  lifecycle operations.
 
 Examples:
   deepline backend start
@@ -33126,18 +33203,18 @@ Examples:
 	`
   ).action((args, options) => {
     void args;
-    printLegacyNoop({
+    printDeprecatedCommand({
       family: "backend",
       subcommand: legacySubcommandFromArgv("backend"),
       options
     });
   });
   for (const subcommand of BACKEND_SUBCOMMANDS) {
-    addLegacyNoopSubcommand(
+    addDeprecatedSubcommand(
       backend,
       "backend",
       subcommand,
-      `Accept legacy "deepline backend ${subcommand}" as an SDK no-op.`
+      `Deprecated legacy "deepline backend ${subcommand}" command.`
     );
   }
 }
@@ -34205,6 +34282,11 @@ Notes:
   Deploy is a full desired definition for its key: omitting a previously stored
   field removes it and can replace the upstream resource. Use \`monitors update\`
   for a patch-style change.
+  Repeating the exact saved definition resumes an incomplete deploy cleanup:
+  Deepline keeps the replacement, removes only the stored previous binding after
+  provider confirmation, and never creates or charges another monitor. Deepline
+  also retries eligible incomplete deploy cleanups automatically in bounded
+  background passes; no separate repair command is required.
   For a bounded urgent Deepline Native preview, set
   controls.execution_type="priority". Deepline injects the provider custom
   field and enforces a ten-slot per-org cap; do not use it for regular or bulk
@@ -35176,24 +35258,24 @@ Examples:
 }
 
 // src/cli/commands/setup.ts
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   lstatSync,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync12,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync13,
   realpathSync as realpathSync3,
   rmSync as rmSync4,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync14
 } from "fs";
-import { homedir as homedir10 } from "os";
-import { basename as basename6, dirname as dirname13, join as join14, relative as relative5, resolve as resolve14 } from "path";
+import { homedir as homedir9 } from "os";
+import { basename as basename6, dirname as dirname15, join as join15, relative as relative5, resolve as resolve14 } from "path";
 
 // src/cli/commands/skills.ts
-import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "fs";
-import { homedir as homedir9 } from "os";
-import { dirname as dirname12, join as join13 } from "path";
+import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync12, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname14, join as join14 } from "path";
 
 // ../shared_libs/cli/install-commands.json
 var install_commands_default = {
@@ -35222,7 +35304,6 @@ var install_commands_default = {
     ]
   },
   cli: {
-    legacy_python_shell_template: "curl -s {base_url}/api/v2/cli/install | bash",
     sdk_npm_global: "npm install -g deepline@latest"
   }
 };
@@ -35261,9 +35342,6 @@ function renderTemplate(template, values) {
     return values[key] ?? match;
   });
 }
-function shellJoin(args) {
-  return args.join(" ");
-}
 function skillsIndexUrl(baseUrl) {
   return `${normalizeBaseUrl2(baseUrl)}${INSTALL_COMMANDS.skills.index_path}`;
 }
@@ -35298,19 +35376,17 @@ function buildSkillsAddArgs(baseUrl, skillName, options = {}) {
   );
   return rendered;
 }
-function skillsInstallCommand(baseUrl, skillName) {
-  return `${INSTALL_COMMANDS.skills.npx_binary} ${shellJoin(
-    buildSkillsAddArgs(baseUrl, skillName)
-  )}`;
-}
-function legacyPythonInstallCommand(baseUrl) {
-  return renderTemplate(INSTALL_COMMANDS.cli.legacy_python_shell_template, {
-    base_url: normalizeBaseUrl2(baseUrl)
-  });
-}
-function sdkNpmGlobalInstallCommand() {
-  return INSTALL_COMMANDS.cli.sdk_npm_global;
-}
+
+// src/cli/skills-sync.ts
+import { spawn as spawn2, spawnSync } from "child_process";
+import {
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync11,
+  unlinkSync,
+  writeFileSync as writeFileSync12
+} from "fs";
+import { dirname as dirname13, join as join13 } from "path";
 
 // src/cli/windows-arg-escape.ts
 var CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
@@ -35335,6 +35411,351 @@ function resolveShellSpawn(command, args, platform3 = process.platform) {
   };
 }
 
+// src/cli/skills-sync.ts
+var CHECK_TIMEOUT_MS2 = 3e3;
+function shouldSkipSkillsSync() {
+  if (detectAgentRuntime() === "claude_cowork") {
+    return true;
+  }
+  const value = process.env.DEEPLINE_SKIP_SKILLS_SYNC?.trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+function unavailableSkillsNoticePath(baseUrl) {
+  return join13(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
+}
+function failedSkillsSyncPath(baseUrl, agents) {
+  return join13(
+    sdkCliStateDirPath(baseUrl),
+    `skills-sync-failed-${agents.join("-")}-version`
+  );
+}
+function hasMarkedSkillsSyncVersion(path, version) {
+  return Boolean(version) && readMarkedSkillsSyncVersion(path) === version;
+}
+function readMarkedSkillsSyncVersion(path) {
+  try {
+    return existsSync11(path) ? readFileSync11(path, "utf-8").trim() : "";
+  } catch {
+    return "";
+  }
+}
+function writeMarkedSkillsSyncVersion(path, version) {
+  try {
+    mkdirSync9(dirname13(path), { recursive: true });
+    writeFileSync12(path, `${version}
+`, "utf-8");
+  } catch {
+  }
+}
+function writeUnavailableSkillsNotice(baseUrl, remoteVersion, skillNames) {
+  const path = unavailableSkillsNoticePath(baseUrl);
+  if (hasMarkedSkillsSyncVersion(path, remoteVersion)) return;
+  writeMarkedSkillsSyncVersion(path, remoteVersion);
+  const manualCommand = `npx ${buildSkillsInstallArgs(baseUrl, skillNames).join(" ")}`;
+  writeSdkSkillsStatusLine(
+    `Deepline agent skills are out of date, but neither \`bunx\` nor \`npx\` is available. Install Node.js/npm or Bun, then run:
+${manualCommand}`
+  );
+}
+function clearUnavailableSkillsNotice(baseUrl) {
+  try {
+    unlinkSync(unavailableSkillsNoticePath(baseUrl));
+  } catch {
+  }
+}
+function hasFailedSkillsSync(baseUrl, remoteVersion, agents) {
+  return hasMarkedSkillsSyncVersion(
+    failedSkillsSyncPath(baseUrl, agents),
+    remoteVersion
+  );
+}
+function hasFailedAutomaticSkillsSync(baseUrl, agents) {
+  return existsSync11(failedSkillsSyncPath(baseUrl, agents));
+}
+function markFailedSkillsSync(baseUrl, remoteVersion, agents) {
+  writeMarkedSkillsSyncVersion(
+    failedSkillsSyncPath(baseUrl, agents),
+    remoteVersion
+  );
+}
+function clearFailedSkillsSync(baseUrl, agents) {
+  try {
+    unlinkSync(failedSkillsSyncPath(baseUrl, agents));
+  } catch {
+  }
+}
+function clearFailedAutomaticSkillsSync(baseUrl, agents) {
+  clearFailedSkillsSync(baseUrl, agents);
+}
+function sortedUniqueSkillNames(names) {
+  return [...new Set(names.map((name) => name.trim()).filter(Boolean))].sort(
+    (a, b) => a.localeCompare(b)
+  );
+}
+async function fetchV1SkillNames(baseUrl) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS2);
+  try {
+    const response = await fetch(
+      new URL("/.well-known/skills/index.json", baseUrl),
+      { signal: controller.signal }
+    );
+    if (!response.ok) return [];
+    const data = await response.json().catch(() => null);
+    const names = (data?.skills ?? []).filter((skill) => skill.install_surface === "v1").map((skill) => skill.name).filter(
+      (name) => typeof name === "string" && name.length > 0
+    );
+    return sortedUniqueSkillNames(names);
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function buildSdkSkillNames(v1SkillNames) {
+  return sortedUniqueSkillNames(v1SkillNames);
+}
+async function fetchSkillsUpdate(baseUrl, localVersion) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS2);
+  try {
+    const response = await fetch(new URL("/api/v2/cli/update-check", baseUrl), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        skills: {
+          version: localVersion
+        }
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) return null;
+    const data = await response.json().catch(() => null);
+    const skills = data?.skills;
+    if (!skills) return null;
+    return {
+      needsUpdate: skills.needs_update === true,
+      remoteVersion: typeof skills.remote?.version === "string" ? skills.remote.version.trim() : ""
+    };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function buildSkillsInstallArgs(baseUrl, skillNames = DEFAULT_SDK_SKILL_NAMES, agents) {
+  return buildSkillsAddArgs(baseUrl, sortedUniqueSkillNames(skillNames), {
+    agents
+  });
+}
+function buildBunxSkillsInstallArgs(baseUrl, skillNames, agents) {
+  return buildSkillsAddArgs(baseUrl, sortedUniqueSkillNames(skillNames), {
+    firstArg: "--bun",
+    agents
+  });
+}
+function hasCommand(command) {
+  const plan = resolveShellSpawn(command, ["--version"]);
+  const result = spawnSync(plan.command, plan.args, {
+    stdio: "ignore",
+    shell: plan.shell
+  });
+  return result.status === 0;
+}
+function shellQuote3(arg) {
+  return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+function temporarySkillsSyncSkipCommand() {
+  if (process.platform === "win32") {
+    return "set DEEPLINE_SKIP_SKILLS_SYNC=1 && deepline <command> (cmd), or $env:DEEPLINE_SKIP_SKILLS_SYNC='1'; deepline <command> (PowerShell)";
+  }
+  return "DEEPLINE_SKIP_SKILLS_SYNC=1 deepline <command>";
+}
+function resolveSkillsInstallSpawn(install, platform3 = process.platform) {
+  return resolveShellSpawn(install.command, install.args, platform3);
+}
+function resolveSkillsInstallCommands(baseUrl, skillNames = DEFAULT_SDK_SKILL_NAMES, agents = DEFAULT_SKILL_AGENTS) {
+  const commands = [];
+  if (hasCommand("bunx")) {
+    const bunxArgs = buildBunxSkillsInstallArgs(baseUrl, skillNames, agents);
+    commands.push({
+      command: "bunx",
+      args: bunxArgs,
+      manualCommand: `bunx ${bunxArgs.map(shellQuote3).join(" ")}`
+    });
+  }
+  if (hasCommand("npx")) {
+    const npxArgs = buildSkillsInstallArgs(baseUrl, skillNames, agents);
+    commands.push({
+      command: "npx",
+      args: npxArgs,
+      manualCommand: `npx ${npxArgs.map(shellQuote3).join(" ")}`
+    });
+  }
+  return commands;
+}
+function runOneSkillsInstall(install) {
+  return new Promise((resolve19) => {
+    const plan = resolveSkillsInstallSpawn(install);
+    const child = spawn2(plan.command, plan.args, {
+      stdio: ["ignore", "ignore", "pipe"],
+      env: process.env,
+      shell: plan.shell
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("error", (error) => {
+      resolve19({
+        ok: false,
+        detail: `failed to start ${install.command}: ${error.message}`,
+        manualCommand: install.manualCommand
+      });
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve19({ ok: true, detail: "", manualCommand: install.manualCommand });
+        return;
+      }
+      const detail = stderr.trim();
+      resolve19({
+        ok: false,
+        detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
+        manualCommand: install.manualCommand
+      });
+    });
+  });
+}
+async function runSkillsInstall(installs, agents) {
+  const failures = [];
+  for (const install of installs) {
+    const result = await runOneSkillsInstall(install);
+    if (result.ok) return true;
+    failures.push(result);
+  }
+  const details = failures.map((failure) => failure.detail).filter(Boolean).join("\n");
+  const attemptedCommands = failures.map((failure) => `  ${failure.manualCommand}`).join("\n");
+  const retryAgent = agents.at(0);
+  process.stderr.write(
+    `Deepline agent-skills refresh failed for ${agents.join(", ")}. The Deepline command will continue; this only affects optional local agent instructions, not authentication, data, or billing.
+` + (attemptedCommands ? `Attempted installer command${failures.length === 1 ? "" : "s"}:
+${attemptedCommands}
+` : "") + (details ? `Installer output:
+${details}
+` : "") + (retryAgent ? `To retry with full installer output: deepline skills --agent ${retryAgent} --json
+` : "") + `To temporarily suppress automatic skills sync: ${temporarySkillsSyncSkipCommand()}
+`
+  );
+  return false;
+}
+function runLegacySkillsCleanup(agents) {
+  const candidates = hasCommand("bunx") ? [
+    {
+      command: "bunx",
+      args: [
+        "--bun",
+        "skills",
+        "remove",
+        "--global",
+        "--agent",
+        ...agents,
+        "-y",
+        ...LEGACY_SKILL_NAMES_TO_REMOVE
+      ]
+    },
+    {
+      command: "npx",
+      args: [
+        "--yes",
+        "skills",
+        "remove",
+        "--global",
+        "--agent",
+        ...agents,
+        "-y",
+        ...LEGACY_SKILL_NAMES_TO_REMOVE
+      ]
+    }
+  ] : [
+    {
+      command: "npx",
+      args: [
+        "--yes",
+        "skills",
+        "remove",
+        "--global",
+        "--agent",
+        ...agents,
+        "-y",
+        ...LEGACY_SKILL_NAMES_TO_REMOVE
+      ]
+    }
+  ];
+  for (const candidate of candidates) {
+    const plan = resolveShellSpawn(candidate.command, candidate.args);
+    const result = spawnSync(plan.command, plan.args, {
+      stdio: "ignore",
+      env: process.env,
+      shell: plan.shell
+    });
+    if (result.status === 0) return;
+  }
+}
+function writeSdkSkillsStatusLine(line) {
+  const progress = getActiveCliProgress();
+  if (progress) {
+    progress.writeLine(line);
+    return;
+  }
+  process.stderr.write(`${line}
+`);
+}
+async function syncSdkSkillsIfNeeded(baseUrl, options = {}) {
+  if (shouldSkipSkillsSync()) return;
+  const usingPluginSkills = hasActivePluginSkills();
+  if (usingPluginSkills) {
+    return;
+  }
+  const localVersion = readSdkSkillsLocalVersion(baseUrl);
+  const update = options.update === void 0 ? await fetchSkillsUpdate(baseUrl, localVersion) : options.update ? {
+    needsUpdate: options.update.needs_update,
+    remoteVersion: options.update.remote.version
+  } : null;
+  if (!update?.needsUpdate || !update.remoteVersion) {
+    return;
+  }
+  const agents = resolveAutoSyncSkillAgents();
+  if (agents.length > 0 && hasFailedSkillsSync(baseUrl, update.remoteVersion, agents)) {
+    return;
+  }
+  const remoteSkillNames = await fetchV1SkillNames(baseUrl);
+  const skillNames = buildSdkSkillNames(
+    remoteSkillNames.length > 0 ? remoteSkillNames : DEFAULT_SDK_SKILL_NAMES
+  );
+  if (skillNames.length === 0) return;
+  if (agents.length === 0) {
+    writeUnavailableSkillsNotice(baseUrl, update.remoteVersion, skillNames);
+    return;
+  }
+  const installs = resolveSkillsInstallCommands(baseUrl, skillNames, agents);
+  if (installs.length === 0) {
+    writeUnavailableSkillsNotice(baseUrl, update.remoteVersion, skillNames);
+    return;
+  }
+  writeSdkSkillsStatusLine("Deepline skills changed; syncing agent skills...");
+  const installed = await runSkillsInstall(installs, agents);
+  if (!installed) {
+    markFailedSkillsSync(baseUrl, update.remoteVersion, agents);
+    return;
+  }
+  runLegacySkillsCleanup(agents);
+  writeSdkSkillsLocalVersion(baseUrl, update.remoteVersion, agents);
+  clearUnavailableSkillsNotice(baseUrl);
+  clearFailedSkillsSync(baseUrl, agents);
+  writeSdkSkillsStatusLine("Deepline agent skills are up to date.");
+}
+
 // src/cli/commands/skills.ts
 var RUNTIME_TO_SKILLS_AGENT = {
   antigravity: "antigravity",
@@ -35396,17 +35817,17 @@ function detectSkillsAgents(input2) {
   if (knownAgent) return [knownAgent];
   const roots = [
     ...input2.scope === "local" && input2.root ? [input2.root] : [],
-    input2.homeDir ?? homedir9()
+    input2.homeDir ?? homedir8()
   ];
   const detected = AGENT_MARKERS.filter(
     (marker) => roots.some(
-      (root) => marker.paths.some((path) => existsSync11(join13(root, path)))
+      (root) => marker.paths.some((path) => existsSync12(join14(root, path)))
     )
   ).map((marker) => marker.agent);
   return detected.length > 0 ? detected : ["*"];
 }
 function skillsStatePathForScope(baseUrl, scope, root) {
-  return scope === "local" && root ? join13(root, ".deepline", "setup", "skills.json") : join13(sdkCliStateDirPath(baseUrl), "skills-install.json");
+  return scope === "local" && root ? join14(root, ".deepline", "setup", "skills.json") : join14(sdkCliStateDirPath(baseUrl), "skills-install.json");
 }
 function buildSkillsPlan(input2) {
   const scopeArgs = input2.scope === "global" ? ["--global"] : [];
@@ -35473,7 +35894,7 @@ function isSkillsPlanCurrent(plan, state) {
 }
 function readSkillsInstallState(path) {
   try {
-    const parsed = JSON.parse(readFileSync11(path, "utf8"));
+    const parsed = JSON.parse(readFileSync12(path, "utf8"));
     return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -35482,7 +35903,7 @@ function readSkillsInstallState(path) {
 function runProcess(command, args, cwd) {
   return new Promise((resolve19, reject) => {
     const plan = resolveShellSpawn(command, args);
-    const child = spawn2(plan.command, plan.args, {
+    const child = spawn3(plan.command, plan.args, {
       cwd,
       env: process.env,
       stdio: ["ignore", "ignore", "pipe"],
@@ -35536,7 +35957,7 @@ async function runSkillsCommand(options, dependencies = {}) {
     );
     return 0;
   }
-  if (isSkillsPlanCurrent(plan, readSkillsInstallState(plan.statePath))) {
+  if (isSkillsPlanCurrent(plan, readSkillsInstallState(plan.statePath)) && !hasFailedAutomaticSkillsSync(baseUrl, agents)) {
     printCommandEnvelope(
       {
         ok: true,
@@ -35617,8 +36038,8 @@ async function runSkillsCommand(options, dependencies = {}) {
     );
     return 5;
   }
-  mkdirSync8(dirname12(plan.statePath), { recursive: true });
-  writeFileSync11(
+  mkdirSync10(dirname14(plan.statePath), { recursive: true });
+  writeFileSync13(
     plan.statePath,
     `${JSON.stringify(
       {
@@ -35636,6 +36057,9 @@ async function runSkillsCommand(options, dependencies = {}) {
 `,
     "utf8"
   );
+  if (scope === "global") {
+    clearFailedAutomaticSkillsSync(baseUrl, agents);
+  }
   printCommandEnvelope(
     {
       ok: true,
@@ -35752,7 +36176,7 @@ function phasesFromLegacyStatus(status) {
 function readSetupState(input2) {
   try {
     const parsed = JSON.parse(
-      readFileSync12(
+      readFileSync13(
         setupStatePath(input2.baseUrl, input2.scope, input2.root),
         "utf8"
       )
@@ -35828,7 +36252,7 @@ function buildPendingAuthorizationOutput(input2) {
   };
 }
 function setupStatePath(baseUrl, scope, root) {
-  return scope === "local" && root ? join14(root, ".deepline", "setup", "state.json") : join14(sdkCliStateDirPath(baseUrl), "setup.json");
+  return scope === "local" && root ? join15(root, ".deepline", "setup", "state.json") : join15(sdkCliStateDirPath(baseUrl), "setup.json");
 }
 async function captureStdout2(run) {
   let stdout = "";
@@ -35857,14 +36281,14 @@ function asRecord3(value) {
 }
 function safeRead(path) {
   try {
-    return readFileSync12(path, "utf8");
+    return readFileSync13(path, "utf8");
   } catch {
     return "";
   }
 }
 function isNpmManagedDeeplinePath(path) {
   try {
-    return realpathSync3(path).includes(`${join14("node_modules", "deepline")}`);
+    return realpathSync3(path).includes(`${join15("node_modules", "deepline")}`);
   } catch {
     return false;
   }
@@ -35874,11 +36298,11 @@ function isInstallerManagedLegacyLauncher(path) {
   return content.includes("DEEPLINE_REAL_BINARY") && content.includes("DEEPLINE_ACTIVE_FILE");
 }
 function removeKnownLegacyPaths(baseUrl) {
-  const home = homedir10();
-  const hostDir = join14(home, ".local", "deepline", baseUrlSlug(baseUrl));
-  const legacyLauncherPath = join14(home, ".local", "bin", "deepline");
+  const home = homedir9();
+  const hostDir = join15(home, ".local", "deepline", baseUrlSlug(baseUrl));
+  const legacyLauncherPath = join15(home, ".local", "bin", "deepline");
   const installerCommandPath = safeRead(
-    join14(hostDir, "sdk", ".command-path")
+    join15(hostDir, "sdk", ".command-path")
   ).trim();
   const relativeInstallerCommandPath = installerCommandPath ? relative5(resolve14(hostDir), resolve14(installerCommandPath)) : "";
   const isOwnedInstallerCommand = Boolean(installerCommandPath) && relativeInstallerCommandPath !== "" && !relativeInstallerCommandPath.startsWith(
@@ -35886,21 +36310,21 @@ function removeKnownLegacyPaths(baseUrl) {
   ) && relativeInstallerCommandPath !== ".." && basename6(installerCommandPath) === "deepline";
   const candidates = [
     ...isInstallerManagedLegacyLauncher(legacyLauncherPath) ? [legacyLauncherPath] : [],
-    join14(home, ".local", "bin", "deepline-real"),
-    join14(hostDir, "bin", "deepline"),
-    join14(hostDir, "bin", "deepline-real"),
-    join14(hostDir, "cli", ".install-method"),
-    join14(hostDir, "cli", ".version"),
-    join14(hostDir, "sdk", ".install-method"),
-    join14(hostDir, "sdk", ".command-path"),
+    join15(home, ".local", "bin", "deepline-real"),
+    join15(hostDir, "bin", "deepline"),
+    join15(hostDir, "bin", "deepline-real"),
+    join15(hostDir, "cli", ".install-method"),
+    join15(hostDir, "cli", ".version"),
+    join15(hostDir, "sdk", ".install-method"),
+    join15(hostDir, "sdk", ".command-path"),
     ...isOwnedInstallerCommand ? [
       installerCommandPath,
-      join14(dirname13(installerCommandPath), "deepline-sdk")
+      join15(dirname15(installerCommandPath), "deepline-sdk")
     ] : []
   ];
   const removed = [];
   for (const path of candidates) {
-    if (!existsSync12(path)) continue;
+    if (!existsSync13(path)) continue;
     if (path === installerCommandPath && isNpmManagedDeeplinePath(path)) {
       continue;
     }
@@ -35910,7 +36334,7 @@ function removeKnownLegacyPaths(baseUrl) {
   return removed;
 }
 function resolvePathCommands(command) {
-  const lookup = spawnSync(
+  const lookup = spawnSync2(
     process.platform === "win32" ? "where" : "which",
     process.platform === "win32" ? [command] : ["-a", command],
     { encoding: "utf8", shell: process.platform === "win32" }
@@ -35937,8 +36361,8 @@ function isHomebrewFormulaCommand(path) {
 }
 function resolvePersistentGlobalCommand(dependencies = {}) {
   const platform3 = dependencies.platform ?? process.platform;
-  const run = dependencies.spawn ?? spawnSync;
-  const pathExists = dependencies.exists ?? existsSync12;
+  const run = dependencies.spawn ?? spawnSync2;
+  const pathExists = dependencies.exists ?? existsSync13;
   const pathClis = dependencies.pathClis ?? resolvePathCommands("deepline");
   const homebrewCommand = pathClis.find(isHomebrewFormulaCommand);
   if (homebrewCommand) return homebrewCommand;
@@ -35950,7 +36374,7 @@ function resolvePersistentGlobalCommand(dependencies = {}) {
   if (prefix.status !== 0) return null;
   const root = String(prefix.stdout ?? "").trim();
   if (!root) return null;
-  const candidates = platform3 === "win32" ? [join14(root, "deepline.cmd"), join14(root, "deepline")] : [join14(root, "bin", "deepline")];
+  const candidates = platform3 === "win32" ? [join15(root, "deepline.cmd"), join15(root, "deepline")] : [join15(root, "bin", "deepline")];
   return candidates.find((candidate) => pathExists(candidate)) ?? null;
 }
 function inspectGlobalCliAvailability(input2) {
@@ -35976,7 +36400,7 @@ function isKnownDeeplineCommand(path) {
   } catch {
   }
   if (entrypoint && resolvedPath === entrypoint) return true;
-  if (resolvedPath.includes(`${join14("node_modules", "deepline")}`)) return true;
+  if (resolvedPath.includes(`${join15("node_modules", "deepline")}`)) return true;
   const content = safeRead(path);
   return content.includes("node_modules/deepline") || content.includes("node_modules\\deepline") || content.includes("DEEPLINE_CONFIG_SCOPE") || content.includes("deepline-real");
 }
@@ -35986,7 +36410,7 @@ function inspectPathConflict() {
   try {
     if (lstatSync(commandPath).isSymbolicLink()) {
       const target = realpathSync3(commandPath);
-      if (target.includes(`${join14("node_modules", "deepline")}`)) return null;
+      if (target.includes(`${join15("node_modules", "deepline")}`)) return null;
     }
   } catch {
   }
@@ -35994,8 +36418,8 @@ function inspectPathConflict() {
 }
 function writeSetupState(input2) {
   const path = setupStatePath(input2.baseUrl, input2.scope, input2.root);
-  mkdirSync9(dirname13(path), { recursive: true });
-  writeFileSync12(
+  mkdirSync11(dirname15(path), { recursive: true });
+  writeFileSync14(
     path,
     `${JSON.stringify(
       {
@@ -36035,7 +36459,7 @@ function failSetupPhase(phases, phase, code) {
   phases[phase] = { status: "failed", code };
 }
 function rollbackCommand(scope, root) {
-  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify(join14(root, ".deepline", "runtime"))}` : "";
+  const prefix = scope === "local" && root ? ` --prefix ${JSON.stringify(join15(root, ".deepline", "runtime"))}` : "";
   return `npm install -g${prefix} --no-audit --no-fund --include=optional --allow-scripts=esbuild deepline@${SDK_VERSION}`;
 }
 function setupResumeCommand(baseUrl, scope) {
@@ -36127,7 +36551,7 @@ function buildDoctorAssessment(input2) {
   const pathGlobalCli = globalCli?.path ?? null;
   const cliPath = input2.scope === "global" ? pathGlobalCli : runningCliPath;
   const cliScopeOk = input2.scope === "global" ? Boolean(pathGlobalCli) : Boolean(
-    input2.root && runningCliPath?.includes(join14(input2.root, ".deepline", "runtime"))
+    input2.root && runningCliPath?.includes(join15(input2.root, ".deepline", "runtime"))
   );
   const checks = {
     cli: {
@@ -37282,165 +37706,6 @@ chooses the connected Slack channel or member and the events it receives.
   });
 }
 
-// src/cli/commands/switch.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir11 } from "os";
-import { dirname as dirname14, join as join15 } from "path";
-function hostSlugFromBaseUrl(baseUrl) {
-  try {
-    const url = new URL(baseUrl);
-    const port = url.port ? Number.parseInt(url.port, 10) : null;
-    let slug = (url.hostname || "unknown").replace(/[^a-zA-Z0-9]/g, "-");
-    if (port && port !== 80 && port !== 443) {
-      slug = `${slug}-${port}`;
-    }
-    return slug.toLowerCase().replace(/^-+|-+$/g, "") || "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-function resolveConfigScope() {
-  const explicit = (process.env.DEEPLINE_CONFIG_SCOPE || "").trim();
-  if (explicit) return explicit;
-  return hostSlugFromBaseUrl(autoDetectBaseUrl());
-}
-function activeFamilyPath() {
-  const home = process.env.HOME || process.env.USERPROFILE || homedir11();
-  return join15(
-    home,
-    ".local",
-    "deepline",
-    resolveConfigScope(),
-    "cli",
-    ".active-family"
-  );
-}
-function readActiveFamily() {
-  const path = activeFamilyPath();
-  try {
-    return readFileSync13(path, "utf-8").trim() || "sdk";
-  } catch {
-    return "sdk";
-  }
-}
-function writeActiveFamily(family) {
-  const path = activeFamilyPath();
-  mkdirSync10(dirname14(path), { recursive: true });
-  writeFileSync13(path, `${family}
-`, "utf-8");
-  return path;
-}
-function forcePythonCliFamily() {
-  return writeActiveFamily("python");
-}
-function handleSwitch(action, options) {
-  const normalized = (action || "status").trim().toLowerCase();
-  if (normalized === "status") {
-    const path = activeFamilyPath();
-    const activeFamily = readActiveFamily();
-    printCommandEnvelope(
-      {
-        ok: true,
-        active_family: activeFamily,
-        active_family_path: path,
-        active_family_file_exists: existsSync13(path),
-        render: {
-          sections: [
-            {
-              title: "cli switch",
-              lines: [
-                `Active CLI family: ${activeFamily}`,
-                `Active family file: ${path}`
-              ]
-            }
-          ]
-        }
-      },
-      { json: options.json }
-    );
-    return 0;
-  }
-  if (normalized === "python" || normalized === "rollback") {
-    const path = writeActiveFamily("python");
-    printCommandEnvelope(
-      {
-        ok: true,
-        active_family: "python",
-        active_family_path: path,
-        render: {
-          sections: [
-            {
-              title: "cli switch",
-              lines: [
-                "Switched installer-managed `deepline` to the Python CLI."
-              ]
-            }
-          ]
-        }
-      },
-      { json: options.json }
-    );
-    return 0;
-  }
-  if (normalized === "sdk") {
-    const path = writeActiveFamily("sdk");
-    printCommandEnvelope(
-      {
-        ok: true,
-        active_family: "sdk",
-        active_family_path: path,
-        render: {
-          sections: [
-            {
-              title: "cli switch",
-              lines: ["Switched installer-managed `deepline` to the SDK CLI."]
-            }
-          ]
-        }
-      },
-      { json: options.json }
-    );
-    return 0;
-  }
-  const message = `Unknown switch target: ${action}. Use one of: status, sdk, python, rollback.`;
-  const envelope = {
-    ok: false,
-    error: message,
-    code: "usage_error",
-    render: {
-      sections: [{ title: "cli switch", lines: [message] }]
-    }
-  };
-  const wantsJson = options.json === true;
-  if (wantsJson) {
-    printCommandEnvelope(envelope, { json: true });
-  } else {
-    process.stderr.write(`${message}
-`);
-  }
-  return 2;
-}
-function registerSwitchCommands(program) {
-  program.command("switch [target]").description(
-    "Switch the installer-managed Deepline CLI between SDK and Python families."
-  ).option("--json", "Emit JSON output").addHelpText(
-    "after",
-    `
-Notes:
-  This command changes only the local installer-managed wrapper state. It does
-  not re-authenticate, reinstall packages, or contact Deepline servers.
-
-Examples:
-  deepline switch status
-  deepline switch python
-  deepline switch rollback
-  deepline switch sdk
-`
-  ).action((target, options) => {
-    process.exitCode = handleSwitch(target, options);
-  });
-}
-
 // src/cli/commands/tools.ts
 import { Option as Option2 } from "commander";
 import {
@@ -37448,7 +37713,7 @@ import {
   existsSync as existsSync14,
   mkdtempSync,
   readFileSync as readFileSync14,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync16
 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
 import { join as join17, resolve as resolve15 } from "path";
@@ -37456,13 +37721,13 @@ import { join as join17, resolve as resolve15 } from "path";
 // src/tool-output.ts
 import {
   closeSync as closeSync3,
-  mkdirSync as mkdirSync11,
+  mkdirSync as mkdirSync12,
   openSync as openSync3,
-  writeFileSync as writeFileSync14,
+  writeFileSync as writeFileSync15,
   writeSync
 } from "fs";
-import { homedir as homedir12 } from "os";
-import { dirname as dirname15, join as join16 } from "path";
+import { homedir as homedir10 } from "os";
+import { dirname as dirname16, join as join16 } from "path";
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -37589,19 +37854,19 @@ function projectRowOutput(conversion) {
   };
 }
 function ensureOutputDir() {
-  const outputDir = join16(homedir12(), ".local", "share", "deepline", "data");
-  mkdirSync11(outputDir, { recursive: true });
+  const outputDir = join16(homedir10(), ".local", "share", "deepline", "data");
+  mkdirSync12(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
   const outputPath = join16(outputDir, `${stem}_${Date.now()}.json`);
-  writeFileSync14(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  writeFileSync15(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem, options) {
   const outputPath = options?.outPath ? options.outPath : join16(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
-  mkdirSync11(dirname15(outputPath), { recursive: true });
+  mkdirSync12(dirname16(outputPath), { recursive: true });
   const columns = columnsForRows(rows);
   const escapeCell = (value) => {
     const normalized = value == null ? "" : typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
@@ -37677,6 +37942,9 @@ var TOOL_CATEGORY_DESCRIPTIONS = {
   premium: "Higher-cost tools with premium provider coverage.",
   free: "Free tools that do not spend Deepline credits."
 };
+var WELL_KNOWN_TOOL_CATEGORIES = Object.freeze(
+  Object.keys(TOOL_CATEGORY_DESCRIPTIONS)
+);
 function describeToolCategory(category) {
   return TOOL_CATEGORY_DESCRIPTIONS[category] ?? null;
 }
@@ -38661,17 +38929,7 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
   const extractedValues = extractionContractEntries(
     arrayField2(toolExecutionResult, "extractedValues", "extracted_values")
   );
-  const cost = recordField2(tool, "cost");
-  const deeplineCredits = numberField2(
-    tool,
-    "deeplineCreditsPerPricingUnit",
-    "deepline_credits_per_pricing_unit"
-  );
-  const deeplineUsdPerPricingUnit = numberField2(
-    tool,
-    "deeplineUsdPerPricingUnit",
-    "deepline_usd_per_pricing_unit"
-  );
+  const pricing = toolPricingContractForDescribe(tool);
   const deprecation = recordField2(tool, "deprecation");
   const replacementToolId = stringField2(
     deprecation,
@@ -38713,12 +38971,7 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
       ...Object.prototype.hasOwnProperty.call(field, "default") ? { default: field.default } : {}
     })),
     inputSchema,
-    cost: {
-      pricingModel: stringField2(cost, "pricingModel", "pricing_model") || null,
-      billingMode: stringField2(cost, "billingMode", "billing_mode") || null,
-      deeplineCreditsPerPricingUnit: deeplineCredits,
-      deeplineUsdPerPricingUnit
-    },
+    cost: pricing,
     getters: {
       extractedLists,
       extractedValues
@@ -38727,6 +38980,38 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
     ...starterScript ? { starterScript } : {}
   };
 }
+function toolPricingContractForDescribe(tool) {
+  const legacyCost = recordField2(tool, "cost");
+  const pricingValue = tool.pricing;
+  const hasCanonicalPricing = isRecord12(pricingValue);
+  const canonicalPricing = hasCanonicalPricing ? pricingValue : {};
+  const unit = stringField2(canonicalPricing, "unit");
+  const legacyPricingModel = stringField2(
+    legacyCost,
+    "pricingModel",
+    "pricing_model"
+  );
+  const pricingModel = unit === "call" ? "fixed" : unit === "result" || unit === "page" ? `per_${unit}` : unit === "usage" ? "provider_usage" : legacyPricingModel;
+  return {
+    pricingModel: pricingModel || null,
+    unit: unit || null,
+    displayText: stringField2(canonicalPricing, "displayText", "display_text") || null,
+    summary: stringField2(canonicalPricing, "summary") || null,
+    billingMode: stringField2(legacyCost, "billingMode", "billing_mode") || null,
+    billingSource: stringField2(tool, "billingSource", "billing_source") || null,
+    billingSourceLabel: stringField2(tool, "billingSourceLabel", "billing_source_label") || null,
+    deeplineCreditsPerPricingUnit: hasCanonicalPricing ? numberField2(canonicalPricing, "creditsPerUnit", "credits_per_unit") : numberField2(
+      tool,
+      "deeplineCreditsPerPricingUnit",
+      "deepline_credits_per_pricing_unit"
+    ),
+    deeplineUsdPerPricingUnit: hasCanonicalPricing ? numberField2(canonicalPricing, "usdPerUnit", "usd_per_unit") : numberField2(
+      tool,
+      "deeplineUsdPerPricingUnit",
+      "deepline_usd_per_pricing_unit"
+    )
+  };
+}
 function extractionContractEntries(entries) {
   return entries.flatMap((entry) => {
     if (!isRecord12(entry)) return [];
@@ -38956,13 +39241,16 @@ function printToolPricingOnly(tool, requestedToolId, options = {}) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
   const cost = isRecord12(contract.cost) ? contract.cost : {};
   const pricingModel = stringField2(cost, "pricingModel") || "unknown";
-  const billingMode = stringField2(cost, "billingMode") || "unknown";
-  const unit = pricingModel === "per_page" ? "page" : pricingModel === "per_result" ? "result" : pricingModel === "fixed" ? "call" : pricingModel.replace(/^per_/, "") || "unit";
+  const billing = stringField2(cost, "billingMode") || stringField2(cost, "billingSourceLabel") || stringField2(cost, "billingSource") || "unknown";
+  const explicitUnit = stringField2(cost, "unit");
+  const unit = explicitUnit || (pricingModel === "per_page" ? "page" : pricingModel === "per_result" ? "result" : pricingModel === "fixed" ? "call" : pricingModel.replace(/^per_/, "") || "unit");
   const credits = numberField2(cost, "deeplineCreditsPerPricingUnit");
   const usd = numberField2(cost, "deeplineUsdPerPricingUnit");
-  const price = credits !== null ? `${formatDecimal(credits)} Deepline credits${usd !== null ? ` / ${formatUsd(usd)}` : ""} per ${unit}` : "pricing unavailable";
+  const displayText = stringField2(cost, "displayText");
+  const summary = stringField2(cost, "summary");
+  const price = displayText || summary || (credits !== null ? `${formatDecimal(credits)} Deepline credits${usd !== null ? ` / ${formatUsd(usd)}` : ""} per ${unit}` : "pricing unavailable");
   console.log(`${options.heading ?? `Pricing: ${contract.toolId}`}: ${price}`);
-  console.log(`Billing: ${billingMode}`);
+  console.log(`Billing: ${billing}`);
 }
 function printToolSchemaOnly(tool, requestedToolId) {
   if (isMonitorTypeTool(tool)) {
@@ -39433,9 +39721,9 @@ function apifySyncRecoveryNext(rawResponse) {
   const getDatasetItemsTool = stringField2(getDatasetItems, "tool");
   const getDatasetItemsPayload = recordField2(getDatasetItems, "payload");
   return {
-    getActorRun: `deepline tools execute ${getActorRunTool} --input ${shellQuote3(JSON.stringify(getActorRunPayload))} --json`,
+    getActorRun: `deepline tools execute ${getActorRunTool} --input ${shellQuote4(JSON.stringify(getActorRunPayload))} --json`,
     ...getDatasetItemsTool && Object.keys(getDatasetItemsPayload).length > 0 ? {
-      getDatasetItems: `deepline tools execute ${getDatasetItemsTool} --input ${shellQuote3(JSON.stringify(getDatasetItemsPayload))} --json`
+      getDatasetItems: `deepline tools execute ${getDatasetItemsTool} --input ${shellQuote4(JSON.stringify(getDatasetItemsPayload))} --json`
     } : {}
   };
 }
@@ -39608,7 +39896,7 @@ function parseExecuteOptions(args) {
 function safeFileStem(value) {
   return value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "tool";
 }
-function shellQuote3(value) {
+function shellQuote4(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function powerShellQuote(value) {
@@ -39673,12 +39961,12 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
   description: ${JSON.stringify(`Seed ${input2.toolId} rows into a Deepline workflow-ready dataset.`)},
 });
 `;
-  writeFileSync15(scriptPath, script, { encoding: "utf-8", mode: 384 });
+  writeFileSync16(scriptPath, script, { encoding: "utf-8", mode: 384 });
   return {
     path: scriptPath,
     sourceCode: script,
     projectDir,
-    macCopyCommand: `mkdir -p ${shellQuote3(projectDir)} && cp ${shellQuote3(scriptPath)} ${shellQuote3(`${projectDir}/${fileName}`)}`,
+    macCopyCommand: `mkdir -p ${shellQuote4(projectDir)} && cp ${shellQuote4(scriptPath)} ${shellQuote4(`${projectDir}/${fileName}`)}`,
     windowsCopyCommand: `New-Item -ItemType Directory -Force -Path ${powerShellQuote(projectDir.replace(/\//g, "\\"))} | Out-Null; Copy-Item -LiteralPath ${powerShellQuote(scriptPath)} -Destination ${powerShellQuote(`${projectDir.replace(/\//g, "\\")}\\${fileName}`)}`
   };
 }
@@ -39705,7 +39993,7 @@ function buildToolExecuteBaseEnvelope(input2) {
     envelope,
     "output"
   );
-  const inspectCommand = `deepline tools execute ${input2.toolId} --input ${shellQuote3(JSON.stringify(input2.params))} --json`;
+  const inspectCommand = `deepline tools execute ${input2.toolId} --input ${shellQuote4(JSON.stringify(input2.params))} --json`;
   const actions = input2.listConversion ? [
     {
       label: "next",
@@ -40098,19 +40386,19 @@ Examples:
 }
 
 // src/cli/commands/update.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import {
   existsSync as existsSync16,
-  mkdirSync as mkdirSync12,
+  mkdirSync as mkdirSync13,
   realpathSync as realpathSync4,
   readFileSync as readFileSync16,
   renameSync,
   rmSync as rmSync5,
-  unlinkSync,
-  writeFileSync as writeFileSync16
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync17
 } from "fs";
-import { homedir as homedir13 } from "os";
-import { dirname as dirname16, isAbsolute as isAbsolute7, join as join19, relative as relative7, resolve as resolve17 } from "path";
+import { homedir as homedir11 } from "os";
+import { dirname as dirname17, isAbsolute as isAbsolute7, join as join19, relative as relative7, resolve as resolve17 } from "path";
 
 // src/cli/install-integrity.ts
 import { createRequire } from "module";
@@ -40302,14 +40590,14 @@ function posixShellQuote(value) {
 function windowsCmdQuote(value) {
   return `"${value.replace(/"/g, '""')}"`;
 }
-function shellQuote4(value) {
+function shellQuote5(value) {
   if (process.platform === "win32") {
     return /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : windowsCmdQuote(value);
   }
   return posixShellQuote(value);
 }
 function buildSourceUpdateCommand(sourceRoot) {
-  const quotedRoot = shellQuote4(sourceRoot);
+  const quotedRoot = shellQuote5(sourceRoot);
   const cdCommand = process.platform === "win32" ? `cd /d ${quotedRoot}` : `cd ${quotedRoot}`;
   return `${cdCommand} && git fetch origin main --tags && git merge --ff-only origin/main`;
 }
@@ -40321,7 +40609,7 @@ function buildSidecarProjectConfigCommand(versionDir, nodeBin) {
     "fs.mkdirSync(dir,{recursive:true});",
     `fs.writeFileSync(path.join(dir,'package.json'),${JSON.stringify(NPM_SDK_SIDECAR_PACKAGE_JSON)});`
   ].join("");
-  return `${shellQuote4(nodeBin)} -e ${shellQuote4(script)} ${shellQuote4(versionDir)}`;
+  return `${shellQuote5(nodeBin)} -e ${shellQuote5(script)} ${shellQuote5(versionDir)}`;
 }
 function sidecarStateDir(input2) {
   const scope = input2.env.DEEPLINE_CONFIG_SCOPE?.trim();
@@ -40384,7 +40672,7 @@ function resolvePythonSidecarUpdatePlan(options) {
   const npmCommand = "npm";
   const registryUrl = sidecarRegistryUrl(hostUrl);
   const versionDir = join19(stateDir, "versions", "<version>");
-  const manualCommand = `${buildSidecarProjectConfigCommand(versionDir, nodeBin)} && ${npmCommand} install --prefix ${shellQuote4(versionDir)} --registry ${shellQuote4(registryUrl)} ${NPM_SDK_INSTALL_COMMON_FLAGS.map(shellQuote4).join(" ")} ${shellQuote4(packageSpec)}`;
+  const manualCommand = `${buildSidecarProjectConfigCommand(versionDir, nodeBin)} && ${npmCommand} install --prefix ${shellQuote5(versionDir)} --registry ${shellQuote5(registryUrl)} ${NPM_SDK_INSTALL_COMMON_FLAGS.map(shellQuote5).join(" ")} ${shellQuote5(packageSpec)}`;
   return {
     kind: "python-sidecar",
     stateDir,
@@ -40404,7 +40692,7 @@ function findRepoBackedSdkRoot(startPath) {
     if (existsSync16(join19(current, "sdk", "package.json")) && existsSync16(join19(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = dirname16(current);
+    const parent = dirname17(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -40444,9 +40732,9 @@ function isHomebrewFormulaEntrypoint(entrypoint) {
 }
 function resolveUpdatePlan(options = {}) {
   const env = options.env ?? process.env;
-  const homeDir2 = options.homeDir ?? homedir13();
+  const homeDir2 = options.homeDir ?? homedir11();
   const entrypoint = options.entrypoint ?? (process.argv[1] ? resolve17(process.argv[1]) : "");
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname16(entrypoint)) : null;
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname17(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -40486,7 +40774,7 @@ function resolveUpdatePlan(options = {}) {
     fallbackRegistryUrl: publicNpmFallbackRegistryUrl(
       env.DEEPLINE_HOST_URL?.trim() || autoDetectBaseUrl()
     ),
-    manualCommand: `${command} ${args.map(shellQuote4).join(" ")}`
+    manualCommand: `${command} ${args.map(shellQuote5).join(" ")}`
   };
 }
 var AUTO_UPDATE_FAILURE_FILE = ".auto-update-failure.json";
@@ -40496,7 +40784,7 @@ function autoUpdateFailurePath(plan) {
     return join19(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
   }
   return join19(
-    homedir13(),
+    homedir11(),
     ".local",
     "deepline",
     "sdk-cli",
@@ -40534,8 +40822,8 @@ function writeAutoUpdateFailure(plan, exitCode) {
     manualCommand: plan.manualCommand
   };
   try {
-    mkdirSync12(dirname16(path), { recursive: true });
-    writeFileSync16(path, `${JSON.stringify(marker, null, 2)}
+    mkdirSync13(dirname17(path), { recursive: true });
+    writeFileSync17(path, `${JSON.stringify(marker, null, 2)}
 `, "utf8");
   } catch {
   }
@@ -40544,7 +40832,7 @@ function clearAutoUpdateFailure(plan) {
   const path = autoUpdateFailurePath(plan);
   if (!path) return;
   try {
-    unlinkSync(path);
+    unlinkSync2(path);
   } catch {
   }
 }
@@ -40626,7 +40914,7 @@ function runCommand(command, args, env = process.env) {
   return new Promise((resolveResult) => {
     let output2 = "";
     const plan = resolveShellSpawn(command, args);
-    const child = spawn3(plan.command, plan.args, {
+    const child = spawn4(plan.command, plan.args, {
       stdio: ["inherit", "pipe", "pipe"],
       shell: plan.shell,
       env
@@ -40714,9 +41002,9 @@ async function runNpmInstallWithRegistryFallback(input2) {
   return first.exitCode;
 }
 function writeSidecarLauncher(input2) {
-  mkdirSync12(dirname16(input2.path), { recursive: true });
-  const packageRoot = dirname16(dirname16(dirname16(input2.entryPath)));
-  const versionDir = dirname16(dirname16(packageRoot));
+  mkdirSync13(dirname17(input2.path), { recursive: true });
+  const packageRoot = dirname17(dirname17(dirname17(input2.entryPath)));
+  const versionDir = dirname17(dirname17(packageRoot));
   const esbuildProbe = "const {createRequire}=require('node:module');const path=require('node:path');const req=createRequire(path.join(process.argv[1],'package.json'));const result=req('esbuild').transformSync('const value: number = 1;',{loader:'ts'});if(!result||typeof result.code!=='string')process.exit(3);";
   const criticalPaths = [
     ...SDK_SIDECAR_CRITICAL_PACKAGE_FILES.map(
@@ -40727,7 +41015,7 @@ function writeSidecarLauncher(input2) {
     )
   ];
   if (process.platform === "win32") {
-    writeFileSync16(
+    writeFileSync17(
       input2.path,
       [
         `@set DEEPLINE_HOST_URL=${input2.hostUrl.replace(/\r?\n/g, "")}`,
@@ -40750,27 +41038,27 @@ function writeSidecarLauncher(input2) {
     );
     return;
   }
-  writeFileSync16(
+  writeFileSync17(
     input2.path,
     [
       "#!/usr/bin/env sh",
-      `export DEEPLINE_HOST_URL=${shellQuote4(input2.hostUrl)}`,
-      `export DEEPLINE_CONFIG_SCOPE=${shellQuote4(input2.scope)}`,
-      `if ${criticalPaths.map((path) => `[ ! -f ${shellQuote4(path)} ]`).join(" || ")}; then`,
+      `export DEEPLINE_HOST_URL=${shellQuote5(input2.hostUrl)}`,
+      `export DEEPLINE_CONFIG_SCOPE=${shellQuote5(input2.scope)}`,
+      `if ${criticalPaths.map((path) => `[ ! -f ${shellQuote5(path)} ]`).join(" || ")}; then`,
       '  if [ -n "${DEEPLINE_REAL_BINARY:-}" ] && [ -x "$DEEPLINE_REAL_BINARY" ]; then',
       '    exec "$DEEPLINE_REAL_BINARY" --version=v2 "$@"',
       "  fi",
       '  printf "%s\\n" "Deepline SDK CLI install is incomplete. Run \\`deepline update\\` to repair it." >&2',
       "  exit 1",
       "fi",
-      `if ! ${shellQuote4(input2.nodeBin)} -e ${shellQuote4(esbuildProbe)} ${shellQuote4(versionDir)} >/dev/null 2>&1; then`,
+      `if ! ${shellQuote5(input2.nodeBin)} -e ${shellQuote5(esbuildProbe)} ${shellQuote5(versionDir)} >/dev/null 2>&1; then`,
       '  if [ -n "${DEEPLINE_REAL_BINARY:-}" ] && [ -x "$DEEPLINE_REAL_BINARY" ]; then',
       '    exec "$DEEPLINE_REAL_BINARY" --version=v2 "$@"',
       "  fi",
       '  printf "%s\\n" "Deepline SDK CLI install is incomplete. Run \\`deepline update\\` to repair it." >&2',
       "  exit 1",
       "fi",
-      `exec ${shellQuote4(input2.nodeBin)} ${shellQuote4(input2.entryPath)} "$@"`,
+      `exec ${shellQuote5(input2.nodeBin)} ${shellQuote5(input2.entryPath)} "$@"`,
       ""
     ].join("\n"),
     { encoding: "utf8", mode: 493 }
@@ -40783,11 +41071,11 @@ async function runPythonSidecarUpdatePlan(plan) {
     `.tmp-sdk-update-${process.pid}-${Date.now()}`
   );
   rmSync5(tempDir, { recursive: true, force: true });
-  mkdirSync12(tempDir, { recursive: true });
-  writeFileSync16(join19(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
+  mkdirSync13(tempDir, { recursive: true });
+  writeFileSync17(join19(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
   const env = {
     ...process.env,
-    PATH: `${dirname16(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
+    PATH: `${dirname17(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
   };
   const installResult = await runCommand(
     plan.npmCommand,
@@ -40907,27 +41195,27 @@ async function runPythonSidecarUpdatePlan(plan) {
     nodeBin: plan.nodeBin,
     entryPath: finalEntryPath
   });
-  writeFileSync16(
+  writeFileSync17(
     join19(plan.stateDir, ".version"),
     `${installedVersion}
 `,
     "utf8"
   );
-  writeFileSync16(
+  writeFileSync17(
     join19(plan.stateDir, ".install-method"),
     "python-sidecar\n",
     "utf8"
   );
-  writeFileSync16(
+  writeFileSync17(
     join19(plan.stateDir, ".command-path"),
     `${plan.sidecarPath}
 `,
     "utf8"
   );
-  writeFileSync16(join19(plan.stateDir, ".runner"), "node\n", "utf8");
-  writeFileSync16(join19(plan.stateDir, ".node-bin"), `${plan.nodeBin}
+  writeFileSync17(join19(plan.stateDir, ".runner"), "node\n", "utf8");
+  writeFileSync17(join19(plan.stateDir, ".node-bin"), `${plan.nodeBin}
 `, "utf8");
-  writeFileSync16(
+  writeFileSync17(
     join19(plan.stateDir, ".entry-path"),
     `${finalEntryPath}
 `,
@@ -41023,7 +41311,17 @@ async function runUpdateCommand(options, dependencies = {}) {
   if (updateExitCode !== 0) {
     return updateExitCode;
   }
-  await syncSkills(normalizeBaseUrl3(detectBaseUrl()));
+  try {
+    await syncSkills(normalizeBaseUrl3(detectBaseUrl()));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    stderr.write(
+      `Deepline SDK/CLI update completed, but the optional local agent-skills refresh failed. Your CLI update succeeded; this does not affect authentication, data, billing, or the command result.
+Skills refresh detail: ${detail}
+To retry with full installer output, run: deepline skills --json
+`
+    );
+  }
   return 0;
 }
 function registerUpdateCommand(program) {
@@ -41051,7 +41349,7 @@ Examples:
 
 // src/cli/commands/workflow.ts
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname17, join as join20, resolve as resolve18 } from "path";
+import { dirname as dirname18, join as join20, resolve as resolve18 } from "path";
 
 // src/cli/workflow-to-play.ts
 import { createHash as createHash5 } from "crypto";
@@ -41303,7 +41601,7 @@ async function transformOne(api, workflowId, outDir, publish) {
       { workflowName: workflow.name, version: revision.version }
     );
     const file = join20(resolve18(outDir), `${compiled.playName}.play.ts`);
-    await mkdir5(dirname17(file), { recursive: true });
+    await mkdir5(dirname18(file), { recursive: true });
     await writeFile5(file, compiled.sourceCode, "utf8");
     let published = false;
     if (publish) {
@@ -41574,108 +41872,15 @@ function registerDeeplineCommandGroups(program) {
   registerCsvCommands(program);
   registerDbCommands(program);
   registerFeedbackCommands(program);
-  registerLegacyNoopCommands(program);
+  registerDeprecatedCommands(program);
   registerUpdateCommand(program);
   registerSkillsCommand(program);
   registerSetupCommands(program);
   registerQuickstartCommands(program);
-  registerSwitchCommands(program);
-}
-
-// ../shared_libs/cli/command-compatibility.json
-var command_compatibility_default = {
-  enrich: {
-    family: "python",
-    label: "a legacy Python CLI enrichment command",
-    sdk_alternative: "Use `deepline plays ...` for durable workflows or `deepline tools execute ...` for one tool call."
-  },
-  session: {
-    family: "python",
-    label: "a legacy Python CLI session/playground command",
-    sdk_alternative: "Use `deepline sessions send ...` or `deepline sessions render ...` for transcript workflows."
-  },
-  workflows: {
-    family: "python",
-    label: "a legacy Python CLI workflow command",
-    sdk_alternative: "Use `deepline plays ...` in the SDK CLI."
-  },
-  events: {
-    family: "python",
-    label: "a legacy Python CLI event command"
-  },
-  plays: {
-    family: "sdk",
-    label: "an SDK CLI play command",
-    python_alternative: "Use `deepline workflows ...` only for legacy workflows."
-  },
-  runs: {
-    family: "sdk",
-    label: "an SDK CLI run inspection command"
-  },
-  sessions: {
-    family: "sdk",
-    label: "an SDK CLI session transcript command"
-  },
-  health: {
-    family: "sdk",
-    label: "an SDK CLI health command"
-  }
-};
-
-// src/cli/command-compatibility.ts
-var COMMAND_COMPATIBILITY = command_compatibility_default;
-function cliFamilyLabel(family) {
-  return family === "sdk" ? "SDK CLI" : "legacy Python CLI";
-}
-function commandCompatibilityHint(currentFamily, commandName, baseUrl) {
-  const compatibility = COMMAND_COMPATIBILITY[commandName];
-  if (!compatibility || compatibility.family === currentFamily) {
-    return null;
-  }
-  const expectedFamily = compatibility.family;
-  const currentLabel = cliFamilyLabel(currentFamily);
-  const expectedLabel = cliFamilyLabel(expectedFamily);
-  const lines = [
-    "",
-    "Command compatibility:",
-    `  \`deepline ${commandName}\` is ${compatibility.label}.`,
-    `  Current binary: ${currentLabel}. Required binary: ${expectedLabel}.`,
-    "  If this came from an agent skill, the installed skill likely targets the other Deepline CLI."
-  ];
-  if (currentFamily === "sdk") {
-    lines.push(
-      "",
-      "  To stay on the SDK CLI, refresh the Deepline agent skills:",
-      `    ${skillsInstallCommand(baseUrl, DEFAULT_SDK_SKILL_NAMES)}`,
-      "  To use the legacy Python CLI instead:",
-      `    ${legacyPythonInstallCommand(baseUrl)}`,
-      "  `deepline update` updates this SDK CLI, but it will not switch CLI families."
-    );
-    if (compatibility.sdk_alternative) {
-      lines.push(`  SDK alternative: ${compatibility.sdk_alternative}`);
-    }
-  } else {
-    lines.push(
-      "",
-      "  To use SDK commands, install the SDK CLI and refresh Deepline agent skills:",
-      `    ${sdkNpmGlobalInstallCommand()}`,
-      `    ${skillsInstallCommand(baseUrl, DEFAULT_SDK_SKILL_NAMES)}`,
-      "  `deepline update` updates this Python CLI and its skills, but it will not switch CLI families."
-    );
-    if (compatibility.python_alternative) {
-      lines.push(`  Python alternative: ${compatibility.python_alternative}`);
-    }
-  }
-  return lines.join("\n");
-}
-function unknownCommandNameFromMessage(message) {
-  const match = message.match(/unknown command ['"]([^'"]+)['"]/i);
-  const command = match?.[1]?.trim();
-  return command ? command : null;
 }
 
 // src/cli/self-update.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 function envTruthy(name) {
   const value = process.env[name]?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes";
@@ -41722,7 +41927,7 @@ function relaunchCurrentCommand(plan) {
   return new Promise((resolve19) => {
     const command = plan.kind === "python-sidecar" ? plan.sidecarPath : process.execPath;
     const args = plan.kind === "python-sidecar" ? process.argv.slice(2) : process.argv.slice(1);
-    const child = spawn4(command, args, {
+    const child = spawn5(command, args, {
       stdio: "inherit",
       shell: process.platform === "win32",
       env: {
@@ -41791,357 +41996,6 @@ What changed in ${response.update_summary.version}: ${response.update_summary.su
   return true;
 }
 
-// src/cli/skills-sync.ts
-import { spawn as spawn5, spawnSync as spawnSync2 } from "child_process";
-import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync13,
-  readFileSync as readFileSync17,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync17
-} from "fs";
-import { dirname as dirname18, join as join21 } from "path";
-var CHECK_TIMEOUT_MS2 = 3e3;
-function shouldSkipSkillsSync() {
-  if (detectAgentRuntime() === "claude_cowork") {
-    return true;
-  }
-  const value = process.env.DEEPLINE_SKIP_SKILLS_SYNC?.trim().toLowerCase();
-  return value === "1" || value === "true" || value === "yes" || value === "on";
-}
-function activePluginSkillsDir() {
-  const pluginMode = process.env.DEEPLINE_PLUGIN_MODE?.trim().toLowerCase();
-  if (pluginMode !== "true" && pluginMode !== "1" && pluginMode !== "yes" && pluginMode !== "on") {
-    return "";
-  }
-  const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
-  return dir && existsSync17(dir) ? dir : "";
-}
-function readPluginSkillsVersion() {
-  const dir = activePluginSkillsDir();
-  if (!dir) return "";
-  try {
-    return readFileSync17(join21(dir, ".version"), "utf-8").trim();
-  } catch {
-    return "";
-  }
-}
-function sdkSkillsVersionPath(baseUrl) {
-  return join21(sdkCliStateDirPath(baseUrl), "skills-version");
-}
-function legacySdkSkillsVersionPath(baseUrl) {
-  return join21(dirname18(sdkCliStateDirPath(baseUrl)), "sdk-skills", ".version");
-}
-function unavailableSkillsNoticePath(baseUrl) {
-  return join21(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
-}
-function readSdkSkillsLocalVersion(baseUrl) {
-  const pluginVersion = readPluginSkillsVersion();
-  if (pluginVersion) return pluginVersion;
-  const path = existsSync17(sdkSkillsVersionPath(baseUrl)) ? sdkSkillsVersionPath(baseUrl) : legacySdkSkillsVersionPath(baseUrl);
-  if (!existsSync17(path)) return "";
-  try {
-    return readFileSync17(path, "utf-8").trim();
-  } catch {
-    return "";
-  }
-}
-function writeLocalSkillsVersion(baseUrl, version) {
-  const path = sdkSkillsVersionPath(baseUrl);
-  mkdirSync13(dirname18(path), { recursive: true });
-  writeFileSync17(path, `${version}
-`, "utf-8");
-}
-function writeUnavailableSkillsNotice(baseUrl, remoteVersion, skillNames) {
-  const path = unavailableSkillsNoticePath(baseUrl);
-  try {
-    if (existsSync17(path) && readFileSync17(path, "utf-8").trim() === remoteVersion) {
-      return;
-    }
-    mkdirSync13(dirname18(path), { recursive: true });
-    writeFileSync17(path, `${remoteVersion}
-`, "utf-8");
-  } catch {
-  }
-  const manualCommand = `npx ${buildSkillsInstallArgs(baseUrl, skillNames).join(" ")}`;
-  writeSdkSkillsStatusLine(
-    `Deepline agent skills are out of date, but neither \`bunx\` nor \`npx\` is available. Install Node.js/npm or Bun, then run:
-${manualCommand}`
-  );
-}
-function clearUnavailableSkillsNotice(baseUrl) {
-  try {
-    unlinkSync2(unavailableSkillsNoticePath(baseUrl));
-  } catch {
-  }
-}
-function sortedUniqueSkillNames(names) {
-  return [...new Set(names.map((name) => name.trim()).filter(Boolean))].sort(
-    (a, b) => a.localeCompare(b)
-  );
-}
-async function fetchV1SkillNames(baseUrl) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS2);
-  try {
-    const response = await fetch(
-      new URL("/.well-known/skills/index.json", baseUrl),
-      { signal: controller.signal }
-    );
-    if (!response.ok) return [];
-    const data = await response.json().catch(() => null);
-    const names = (data?.skills ?? []).filter((skill) => skill.install_surface === "v1").map((skill) => skill.name).filter(
-      (name) => typeof name === "string" && name.length > 0
-    );
-    return sortedUniqueSkillNames(names);
-  } catch {
-    return [];
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-function buildSdkSkillNames(v1SkillNames) {
-  return sortedUniqueSkillNames(v1SkillNames);
-}
-async function fetchSkillsUpdate(baseUrl, localVersion) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS2);
-  try {
-    const response = await fetch(new URL("/api/v2/cli/update-check", baseUrl), {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        skills: {
-          version: localVersion
-        }
-      }),
-      signal: controller.signal
-    });
-    if (!response.ok) return null;
-    const data = await response.json().catch(() => null);
-    const skills = data?.skills;
-    if (!skills) return null;
-    return {
-      needsUpdate: skills.needs_update === true,
-      remoteVersion: typeof skills.remote?.version === "string" ? skills.remote.version.trim() : ""
-    };
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-function buildSkillsInstallArgs(baseUrl, skillNames = DEFAULT_SDK_SKILL_NAMES, agents) {
-  return buildSkillsAddArgs(baseUrl, sortedUniqueSkillNames(skillNames), {
-    agents
-  });
-}
-function buildBunxSkillsInstallArgs(baseUrl, skillNames, agents) {
-  return buildSkillsAddArgs(baseUrl, sortedUniqueSkillNames(skillNames), {
-    firstArg: "--bun",
-    agents
-  });
-}
-function resolveAutoSyncSkillAgents() {
-  switch (detectAgentRuntime()) {
-    case "codex":
-      return ["codex"];
-    case "claude_code":
-      return ["claude-code"];
-    case "cursor":
-      return ["cursor"];
-    case "gemini":
-      return ["gemini-cli"];
-    case "antigravity":
-      return ["antigravity"];
-    default:
-      return [];
-  }
-}
-function hasCommand(command) {
-  const plan = resolveShellSpawn(command, ["--version"]);
-  const result = spawnSync2(plan.command, plan.args, {
-    stdio: "ignore",
-    shell: plan.shell
-  });
-  return result.status === 0;
-}
-function shellQuote5(arg) {
-  return `'${arg.replace(/'/g, `'\\''`)}'`;
-}
-function resolveSkillsInstallSpawn(install, platform3 = process.platform) {
-  return resolveShellSpawn(install.command, install.args, platform3);
-}
-function resolveSkillsInstallCommands(baseUrl, skillNames = DEFAULT_SDK_SKILL_NAMES, agents = DEFAULT_SKILL_AGENTS) {
-  const commands = [];
-  if (hasCommand("bunx")) {
-    const bunxArgs = buildBunxSkillsInstallArgs(baseUrl, skillNames, agents);
-    commands.push({
-      command: "bunx",
-      args: bunxArgs,
-      manualCommand: `bunx ${bunxArgs.map(shellQuote5).join(" ")}`
-    });
-  }
-  if (hasCommand("npx")) {
-    const npxArgs = buildSkillsInstallArgs(baseUrl, skillNames, agents);
-    commands.push({
-      command: "npx",
-      args: npxArgs,
-      manualCommand: `npx ${npxArgs.map(shellQuote5).join(" ")}`
-    });
-  }
-  return commands;
-}
-function runOneSkillsInstall(install) {
-  return new Promise((resolve19) => {
-    const plan = resolveSkillsInstallSpawn(install);
-    const child = spawn5(plan.command, plan.args, {
-      stdio: ["ignore", "ignore", "pipe"],
-      env: process.env,
-      shell: plan.shell
-    });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString("utf-8");
-    });
-    child.on("error", (error) => {
-      resolve19({
-        ok: false,
-        detail: `failed to start ${install.command}: ${error.message}`,
-        manualCommand: install.manualCommand
-      });
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve19({ ok: true, detail: "", manualCommand: install.manualCommand });
-        return;
-      }
-      const detail = stderr.trim();
-      resolve19({
-        ok: false,
-        detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
-        manualCommand: install.manualCommand
-      });
-    });
-  });
-}
-async function runSkillsInstall(installs) {
-  const failures = [];
-  for (const install of installs) {
-    const result = await runOneSkillsInstall(install);
-    if (result.ok) return true;
-    failures.push(result);
-  }
-  const details = failures.map((failure) => failure.detail).filter(Boolean).join("\n");
-  const manualCommand = failures.at(-1)?.manualCommand;
-  process.stderr.write(
-    `SDK skills sync failed${details ? `:
-${details}` : ""}
-` + (manualCommand ? `Run manually: ${manualCommand}
-` : "")
-  );
-  return false;
-}
-function runLegacySkillsCleanup(agents) {
-  const candidates = hasCommand("bunx") ? [
-    {
-      command: "bunx",
-      args: [
-        "--bun",
-        "skills",
-        "remove",
-        "--global",
-        "--agent",
-        ...agents,
-        "-y",
-        ...LEGACY_SKILL_NAMES_TO_REMOVE
-      ]
-    },
-    {
-      command: "npx",
-      args: [
-        "--yes",
-        "skills",
-        "remove",
-        "--global",
-        "--agent",
-        ...agents,
-        "-y",
-        ...LEGACY_SKILL_NAMES_TO_REMOVE
-      ]
-    }
-  ] : [
-    {
-      command: "npx",
-      args: [
-        "--yes",
-        "skills",
-        "remove",
-        "--global",
-        "--agent",
-        ...agents,
-        "-y",
-        ...LEGACY_SKILL_NAMES_TO_REMOVE
-      ]
-    }
-  ];
-  for (const candidate of candidates) {
-    const plan = resolveShellSpawn(candidate.command, candidate.args);
-    const result = spawnSync2(plan.command, plan.args, {
-      stdio: "ignore",
-      env: process.env,
-      shell: plan.shell
-    });
-    if (result.status === 0) return;
-  }
-}
-function writeSdkSkillsStatusLine(line) {
-  const progress = getActiveCliProgress();
-  if (progress) {
-    progress.writeLine(line);
-    return;
-  }
-  process.stderr.write(`${line}
-`);
-}
-async function syncSdkSkillsIfNeeded(baseUrl, options = {}) {
-  if (shouldSkipSkillsSync()) return;
-  const usingPluginSkills = Boolean(activePluginSkillsDir());
-  if (usingPluginSkills) {
-    return;
-  }
-  const localVersion = readSdkSkillsLocalVersion(baseUrl);
-  const update = options.update === void 0 ? await fetchSkillsUpdate(baseUrl, localVersion) : options.update ? {
-    needsUpdate: options.update.needs_update,
-    remoteVersion: options.update.remote.version
-  } : null;
-  if (!update?.needsUpdate || !update.remoteVersion) {
-    return;
-  }
-  const remoteSkillNames = await fetchV1SkillNames(baseUrl);
-  const skillNames = buildSdkSkillNames(
-    remoteSkillNames.length > 0 ? remoteSkillNames : DEFAULT_SDK_SKILL_NAMES
-  );
-  if (skillNames.length === 0) return;
-  const agents = resolveAutoSyncSkillAgents();
-  if (agents.length === 0) {
-    writeUnavailableSkillsNotice(baseUrl, update.remoteVersion, skillNames);
-    return;
-  }
-  const installs = resolveSkillsInstallCommands(baseUrl, skillNames, agents);
-  if (installs.length === 0) {
-    writeUnavailableSkillsNotice(baseUrl, update.remoteVersion, skillNames);
-    return;
-  }
-  writeSdkSkillsStatusLine("Deepline skills changed; syncing agent skills...");
-  const installed = await runSkillsInstall(installs);
-  if (!installed) return;
-  runLegacySkillsCleanup(agents);
-  writeLocalSkillsVersion(baseUrl, update.remoteVersion);
-  clearUnavailableSkillsNotice(baseUrl);
-  writeSdkSkillsStatusLine("Deepline agent skills are up to date.");
-}
-
 // src/cli/failure-reporting.ts
 import { hostname as hostname2, platform as platform2, release } from "os";
 var FAILURE_REPORT_DISABLE_ENV = "DEEPLINE_DISABLE_FAILURE_REPORTING";
@@ -42420,7 +42274,7 @@ function shouldDeferSkillsSyncForCommand() {
   if (command === "providers" && subcommand === "list") return true;
   return (command === "play" || command === "plays") && subcommand === "run" && args.includes("--json");
 }
-function isLegacyNoopInvocation() {
+function isDeprecatedCommandInvocation() {
   const command = process.argv.slice(2)[0];
   return command === "session" || command === "backend";
 }
@@ -42444,8 +42298,8 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await mkdtemp2(join22(tmpdir6(), "deepline-health-play-"));
-  const file = join22(dir, "health-check.play.ts");
+  const dir = await mkdtemp2(join21(tmpdir6(), "deepline-health-play-"));
+  const file = join21(dir, "health-check.play.ts");
   try {
     await writeFile6(
       file,
@@ -42687,7 +42541,7 @@ Exit codes:
 `
   );
   program.hook("preAction", async (_thisCommand, actionCommand) => {
-    if (actionCommand.name() === "version" || actionCommand.name() === "update" || actionCommand.name() === "switch" || actionCommand.name() === "setup" || actionCommand.name() === "skills" || actionCommand.name() === "doctor" || isLegacyNoopInvocation()) {
+    if (actionCommand.name() === "version" || actionCommand.name() === "update" || actionCommand.name() === "setup" || actionCommand.name() === "skills" || actionCommand.name() === "doctor" || isDeprecatedCommandInvocation()) {
       return;
     }
     if (printStartupPhase) {
@@ -42716,18 +42570,6 @@ Exit codes:
     if (relaunched) {
       return;
     }
-    if (compatibility.response?.cli_family?.action === "force_python") {
-      forcePythonCliFamily();
-      process.stderr.write(
-        "Deepline SDK CLI rollback is active; switched installer-managed `deepline` back to the Python CLI. Re-run your command.\n"
-      );
-      const error = new Error(
-        "SDK CLI rollback is active"
-      );
-      error.code = "deepline.sdk_cli_rollback";
-      error.exitCode = 7;
-      throw error;
-    }
     enforceSdkCompatibilityResponse(compatibility.response);
     if (printStartupPhase) {
       progress?.phase("checking sdk skills");
@@ -42855,14 +42697,6 @@ Examples:
       process.exitCode = 2;
       return;
     }
-    const hint = commandCompatibilityHint(
-      "sdk",
-      requestedTopLevelCommand,
-      baseUrl
-    );
-    if (hint && !process.argv.includes("--json")) {
-      console.error(hint);
-    }
     process.exitCode = 2;
     return;
   }
@@ -42890,19 +42724,6 @@ Examples:
     const wantsJson = process.argv.includes("--json");
     if (commanderError) {
       if (commanderError.code === "commander.unknownCommand") {
-        const commandName = unknownCommandNameFromMessage(
-          commanderError.message
-        );
-        if (commandName && !wantsJson) {
-          const hint = commandCompatibilityHint(
-            "sdk",
-            commandName,
-            autoDetectBaseUrl()
-          );
-          if (hint) {
-            console.error(hint);
-          }
-        }
       }
       process.exitCode = commanderError.code === "commander.unknownCommand" && !wantsJson ? 2 : commanderError.exitCode ?? 1;
       return;