deepline 0.3.293 → 0.3.295

package/dist/cli/chunk-GHRQQPW2.mjs

@@ -0,0 +1,2240 @@
+import {
+  getActiveCliProgress
+} from "./chunk-GAMFK2ZP.mjs";
+import {
+  printCommandEnvelope
+} from "./chunk-6O5YZOVN.mjs";
+import {
+  DEFAULT_SKILL_AGENTS,
+  KNOWN_SKILL_AGENTS,
+  SDK_API_CONTRACT,
+  SDK_API_MAJOR,
+  SDK_VERSION,
+  autoDetectBaseUrl,
+  deploymentProtectionHeaders,
+  detectAgentRuntime,
+  ensureProjectPrivatePathsIgnored,
+  hasActivePluginSkills,
+  readSdkSkillsLocalVersion,
+  resolveApiKeyForBaseUrl,
+  resolveAutoSyncSkillAgents,
+  resolveProjectPinTarget,
+  sdkCliStateDirPath,
+  skillsAgentPathSegment,
+  writeSdkSkillsLocalVersion
+} from "./chunk-EACVZI6N.mjs";
+import {
+  DeeplineError
+} from "./chunk-NXGCO4JB.mjs";
+
+// src/cli/commands/skills.ts
+import { spawn as spawn2 } from "child_process";
+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";
+
+// contracts/install-commands.json
+var install_commands_default = {
+  skills: {
+    index_path: "/.well-known/skills/index.json",
+    default_agents: [
+      "codex",
+      "claude-code",
+      "cursor",
+      "gemini-cli",
+      "antigravity"
+    ],
+    npx_binary: "npx",
+    npx_add_args_template: [
+      "--yes",
+      "skills@1.5.15",
+      "add",
+      "{skills_source_url}",
+      "--agent",
+      "{agents}",
+      "--global",
+      "--yes",
+      "--skill",
+      "{skill_name}",
+      "--full-depth"
+    ]
+  },
+  cli: {
+    sdk_npm_global: "npm install -g deepline@latest"
+  }
+};
+
+// src/cli/install-commands.ts
+var INSTALL_COMMANDS = install_commands_default;
+var skillsNpxPackage = INSTALL_COMMANDS.skills.npx_add_args_template.find(
+  (arg) => /^skills@\d+\.\d+\.\d+$/.test(arg)
+);
+if (!skillsNpxPackage) {
+  throw new Error(
+    "shared_libs/cli/install-commands.json must pin an exact skills package version."
+  );
+}
+var SKILLS_NPX_PACKAGE = skillsNpxPackage;
+var DEFAULT_V1_SKILL_NAMES = [
+  "build-tam",
+  "clay-to-deepline",
+  "deepline-analytics",
+  "deepline-engine",
+  "deepline-feedback",
+  "deepline-gtm",
+  "deepline-plays",
+  "deepline-quickstart",
+  "deepline-scoring",
+  "find-qualified-titles",
+  "linkedin-url-lookup",
+  // Deprecated alias for `deepline-scoring`, kept installable so saved prompts
+  // and scripts using `/niche-signal-discovery` keep routing to the renamed
+  // skill. Move to LEGACY_SKILL_NAMES_TO_REMOVE once the window closes.
+  "niche-signal-discovery",
+  "portfolio-prospecting"
+];
+var DEFAULT_SDK_SKILL_NAMES = [...DEFAULT_V1_SKILL_NAMES];
+var LEGACY_SKILL_NAMES_TO_REMOVE = [
+  "deepline-plays-feedback",
+  "deepline-plays-quickstart",
+  "workflow-hello-world"
+];
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/$/, "");
+}
+function renderTemplate(template, values) {
+  return template.replace(/\{([a-z_]+)\}/g, (match, key) => {
+    return values[key] ?? match;
+  });
+}
+function skillsIndexUrl(baseUrl) {
+  return `${normalizeBaseUrl(baseUrl)}${INSTALL_COMMANDS.skills.index_path}`;
+}
+function skillsSourceUrl(baseUrl) {
+  return normalizeBaseUrl(baseUrl);
+}
+function buildSkillsAddArgs(baseUrl, skillName, options = {}) {
+  const skillNames = Array.isArray(skillName) ? skillName : [skillName];
+  const [firstSkillName, ...extraSkillNames] = skillNames;
+  const agents = options.agents ?? DEFAULT_SKILL_AGENTS;
+  const values = {
+    skills_index_url: skillsIndexUrl(baseUrl),
+    skills_source_url: skillsSourceUrl(baseUrl),
+    agents: agents.join(" "),
+    skill_name: firstSkillName ?? ""
+  };
+  const rendered = INSTALL_COMMANDS.skills.npx_add_args_template.flatMap(
+    (arg, index) => {
+      const next = index === 0 && options.firstArg ? options.firstArg : arg;
+      const value = renderTemplate(next, values);
+      if (arg === "{agents}") {
+        return agents;
+      }
+      if (arg === "{skill_name}") {
+        return [
+          value,
+          ...extraSkillNames.flatMap((name) => ["--skill", name])
+        ];
+      }
+      return value;
+    }
+  );
+  return rendered;
+}
+
+// src/cli/skills-sync.ts
+import { spawn, spawnSync } from "child_process";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { homedir as homedir2 } from "os";
+import { gunzipSync } from "zlib";
+import {
+  appendFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/compat.ts
+import { randomUUID } from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var CHECK_TIMEOUT_MS = 2e3;
+var SDK_COMPATIBILITY_TRUST_MS = 10 * 60 * 1e3;
+var SDK_COMPATIBILITY_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var SDK_COMPATIBILITY_FAST_DEADLINE_MS = 400;
+function writeCompatibilityCacheFile(path, cache) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tempPath, `${JSON.stringify(cache, null, 2)}
+`);
+    renameSync(tempPath, path);
+  } finally {
+    rmSync(tempPath, { force: true });
+  }
+}
+function shouldSkipCompatibilityCheck() {
+  const value = process.env.DEEPLINE_SKIP_SDK_COMPAT_CHECK?.trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes";
+}
+function sdkCompatibilityCachePath(baseUrl, homeDir = homedir()) {
+  return join(sdkCliStateDirPath(baseUrl, homeDir), "compat-cache.json");
+}
+function legacySdkCompatibilityCachePath(homeDir = homedir()) {
+  return join(homeDir, ".cache", "deepline", "sdk-compat-cache.json");
+}
+function compatibilityCacheKey(baseUrl, command, skillsVersion) {
+  return JSON.stringify({
+    baseUrl: baseUrl.replace(/\/$/, ""),
+    version: SDK_VERSION,
+    apiContract: SDK_API_CONTRACT,
+    apiMajor: SDK_API_MAJOR,
+    command: command?.trim() || null,
+    skillsVersion: skillsVersion ?? null
+  });
+}
+function legacyCompatibilityCacheKey(baseUrl, command) {
+  return JSON.stringify({
+    baseUrl: baseUrl.replace(/\/$/, ""),
+    version: SDK_VERSION,
+    apiContract: SDK_API_CONTRACT,
+    command: command?.trim() || null
+  });
+}
+function isCleanCompatibilityPolicy(response) {
+  if (!response) return false;
+  return response.ok === true && response.update_required !== true && response.status !== "unsupported" && !response.auto_update?.should_auto_update && !response.cli_family;
+}
+function readFreshCleanCompatibility(baseUrl, command, skillsVersion) {
+  const cached = readCachedCompatibility(baseUrl, command, skillsVersion);
+  return isCleanCompatibilityPolicy(cached) ? cached : null;
+}
+function readTrustedCleanCompatibility(baseUrl, command, skillsVersion, now = Date.now()) {
+  const entry = readCachedCompatibilityEntry(baseUrl, command, skillsVersion);
+  if (!entry || !isSavedWithin(entry.savedAt, SDK_COMPATIBILITY_TRUST_MS, now))
+    return null;
+  return isCleanCompatibilityPolicy(entry.response) ? entry.response : null;
+}
+function isSavedWithin(savedAt, windowMs, now) {
+  if (typeof savedAt !== "number") return false;
+  const age = now - savedAt;
+  return Number.isFinite(age) && age >= 0 && age <= windowMs;
+}
+function readCachedCompatibility(baseUrl, command, skillsVersion) {
+  return readCachedCompatibilityEntry(baseUrl, command, skillsVersion)?.response ?? null;
+}
+function readCachedCompatibilityEntry(baseUrl, command, skillsVersion) {
+  try {
+    const path = sdkCompatibilityCachePath(baseUrl);
+    const legacyPath = legacySdkCompatibilityCachePath();
+    const useLegacyCache = !existsSync(path) && existsSync(legacyPath);
+    const cachePath = useLegacyCache ? legacyPath : path;
+    if (!existsSync(cachePath)) {
+      return null;
+    }
+    const parsed = JSON.parse(
+      readFileSync(cachePath, "utf8")
+    );
+    const entry = parsed.entries?.[compatibilityCacheKey(baseUrl, command, skillsVersion)] ?? (useLegacyCache ? parsed.entries?.[legacyCompatibilityCacheKey(baseUrl, command)] : void 0);
+    if (!entry || !isSavedWithin(entry.savedAt, SDK_COMPATIBILITY_CACHE_TTL_MS, Date.now())) {
+      return null;
+    }
+    return entry;
+  } catch {
+    return null;
+  }
+}
+function invalidateCachedCompatibility(baseUrl, command, skillsVersion) {
+  try {
+    const path = sdkCompatibilityCachePath(baseUrl);
+    const legacyPath = legacySdkCompatibilityCachePath();
+    const cachePath = !existsSync(path) && existsSync(legacyPath) ? legacyPath : path;
+    if (!existsSync(cachePath)) return;
+    const existing = JSON.parse(
+      readFileSync(cachePath, "utf8")
+    );
+    const entries = existing.entries ?? {};
+    delete entries[compatibilityCacheKey(baseUrl, command, skillsVersion)];
+    delete entries[legacyCompatibilityCacheKey(baseUrl, command)];
+    writeCompatibilityCacheFile(cachePath, { entries });
+  } catch {
+  }
+}
+function writeCachedCompatibility(baseUrl, command, skillsVersion, response) {
+  try {
+    const path = sdkCompatibilityCachePath(baseUrl);
+    let existing = {};
+    if (existsSync(path)) {
+      try {
+        existing = JSON.parse(readFileSync(path, "utf8"));
+      } catch {
+      }
+    }
+    const entries = existing.entries ?? {};
+    entries[compatibilityCacheKey(baseUrl, command, skillsVersion)] = {
+      savedAt: Date.now(),
+      response
+    };
+    writeCompatibilityCacheFile(path, { entries });
+  } catch {
+  }
+}
+async function checkSdkCompatibility(baseUrl, options = {}) {
+  if (shouldSkipCompatibilityCheck()) {
+    return { response: null, error: null };
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(
+    () => controller.abort(),
+    options.timeoutMs ?? CHECK_TIMEOUT_MS
+  );
+  try {
+    const url = new URL("/api/v2/sdk/compat", baseUrl);
+    url.searchParams.set("version", SDK_VERSION);
+    if (options.command?.trim()) {
+      url.searchParams.set("command", options.command.trim());
+    }
+    if (options.skillsVersion !== void 0) {
+      url.searchParams.set("skills_version", options.skillsVersion ?? "");
+    }
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        ...deploymentProtectionHeaders(),
+        "User-Agent": `deepline-ts-sdk/${SDK_VERSION}`,
+        "X-Deepline-SDK-Version": SDK_VERSION,
+        "X-Deepline-API-Major": String(SDK_API_MAJOR),
+        "X-Deepline-API-Contract": SDK_API_CONTRACT,
+        "X-Deepline-CLI-Update-Preferences": "1"
+      },
+      signal: controller.signal
+    });
+    const data = await response.json().catch(() => null);
+    if (!data || typeof data.ok !== "boolean" || typeof data.status !== "string") {
+      throw new Error(
+        `SDK compatibility endpoint returned a non-policy response (HTTP ${response.status}).`
+      );
+    }
+    writeCachedCompatibility(
+      baseUrl,
+      options.command,
+      options.skillsVersion,
+      data
+    );
+    return { response: data, error: null };
+  } catch (error) {
+    const cached = readCachedCompatibility(
+      baseUrl,
+      options.command,
+      options.skillsVersion
+    );
+    if (cached) {
+      if (options.timeoutMs !== void 0 && options.timeoutMs < CHECK_TIMEOUT_MS) {
+        invalidateCachedCompatibility(
+          baseUrl,
+          options.command,
+          options.skillsVersion
+        );
+      }
+      return { response: cached, error: null };
+    }
+    return {
+      response: null,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function isCiEnvironment() {
+  return ["CI", "GITHUB_ACTIONS"].some((name) => {
+    const value = process.env[name]?.trim().toLowerCase();
+    return value === "1" || value === "true" || value === "yes";
+  });
+}
+function enforceSdkCompatibilityResponse(response, options = {}) {
+  if (!response) {
+    return;
+  }
+  if (response.update_required) {
+    throw new Error(response.message);
+  }
+  if ((response.status === "deprecated" || response.status === "update_available") && !isCiEnvironment() && options.quietAdvisory !== true) {
+    process.stderr.write(`${response.message}
+`);
+  }
+}
+
+// src/cli/windows-arg-escape.ts
+var CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
+function escapeCmdArgument(arg, forBatchFile = true) {
+  let escaped = arg.replace(/(\\*)"/g, '$1$1\\"');
+  escaped = escaped.replace(/(\\*)$/, "$1$1");
+  escaped = `"${escaped}"`;
+  escaped = escaped.replace(CMD_META_CHARS, "^$1");
+  return forBatchFile ? escaped.replace(CMD_META_CHARS, "^$1") : escaped;
+}
+function escapeCmdCommand(command) {
+  return command.replace(CMD_META_CHARS, "^$1");
+}
+function resolveShellSpawn(command, args, platform2 = process.platform) {
+  if (platform2 !== "win32") {
+    return { command, args: [...args], shell: false };
+  }
+  return {
+    command: escapeCmdCommand(command),
+    args: args.map((arg) => escapeCmdArgument(arg)),
+    shell: true
+  };
+}
+
+// src/cli/failure-reporting.ts
+import { hostname, platform, release } from "os";
+var FAILURE_REPORT_DISABLE_ENV = "DEEPLINE_DISABLE_FAILURE_REPORTING";
+var REPORT_FAILURE_TIMEOUT_MS = 1e4;
+var BACKGROUND_REPORT_FAILURE_TIMEOUT_MS = 2e3;
+var MAX_FAILURE_TEXT_CHARS = 4e3;
+var MAX_COMMAND_TOKENS = 3;
+var REPORTABLE_EXIT_CODES = /* @__PURE__ */ new Set([4, 5]);
+var EMAIL_RE = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+var UNIX_PATH_RE = /(?:\/Users\/|\/home\/|\/var\/folders\/|\/tmp\/|\/sessions\/)[^"'\n\r`]+/g;
+var WINDOWS_PATH_RE = /[A-Za-z]:(?:\\{1,2})(?:Users|Temp|tmp)(?:\\{1,2})[^"'\n\r`]+/g;
+var ASSIGNMENT_SECRET_RE = /\b(access[_-]?token|api[_-]?key|apikey|auth(?:orization)?|bearer|password|secret|session)\b(\s*[:=]\s*)(?!Bearer\s+\[redacted-secret\])([^\s,;]+)/gi;
+var BEARER_SECRET_RE = /\b(bearer)\s+([A-Za-z0-9._-]+)/gi;
+var GENERIC_TOKEN_RE = /\b(?:dlp|sk|ghp|xox[baprs])[-_A-Za-z0-9]{8,}\b/g;
+var SECRET_OPTION_RE = /^--?(?:access[-_]?token|api[-_]?key|apikey|auth(?:orization)?|bearer|password|secret|session|token)$/i;
+function truthyEnv(name) {
+  return ["1", "true", "yes", "on"].includes(
+    String(process.env[name] ?? "").trim().toLowerCase()
+  );
+}
+function isFailureReportingDisabled() {
+  return truthyEnv(FAILURE_REPORT_DISABLE_ENV);
+}
+function redactFailureText(value, maxChars = MAX_FAILURE_TEXT_CHARS) {
+  const home = process.env.HOME?.trim();
+  let text = String(value ?? "");
+  if (!text) return "";
+  if (home && home !== "/") {
+    text = text.split(home).join("~");
+  }
+  return text.replace(EMAIL_RE, "[redacted-email]").replace(UNIX_PATH_RE, "[redacted-path]").replace(WINDOWS_PATH_RE, "[redacted-path]").replace(BEARER_SECRET_RE, "$1 [redacted-secret]").replace(ASSIGNMENT_SECRET_RE, "$1$2[redacted-secret]").replace(GENERIC_TOKEN_RE, "[redacted-secret]").slice(0, maxChars);
+}
+function sanitizeCommand(argv, prefix = "deepline") {
+  const tokens = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const value = String(arg ?? "").trim();
+    if (!value) continue;
+    if (value.startsWith("-")) {
+      if (!value.includes("=") && SECRET_OPTION_RE.test(value)) {
+        index += 1;
+      }
+      continue;
+    }
+    tokens.push(redactFailureText(value, 200));
+    if (tokens.length >= MAX_COMMAND_TOKENS) break;
+  }
+  return tokens.length > 0 ? [prefix, ...tokens].join(" ") : prefix;
+}
+function errorMessage(error) {
+  if (error instanceof Error) return `${error.name}: ${error.message}`;
+  return String(error ?? "");
+}
+function errorStack(error) {
+  if (error instanceof Error && error.stack) {
+    return redactFailureText(error.stack);
+  }
+  return null;
+}
+function classifyNetworkFailure(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    const record = typeof current === "object" && current !== null ? current : {};
+    const code = String(record.code ?? "").toLowerCase();
+    const name = current instanceof Error ? current.name.toLowerCase() : "";
+    const text = String(
+      current instanceof Error ? current.message : current
+    ).toLowerCase();
+    const combined = `${code} ${name} ${text}`;
+    if (combined.includes("aborterror") || combined.includes("timeout") || combined.includes("timed out") || combined.includes("etimedout")) {
+      return "network_timeout";
+    }
+    if (combined.includes("enotfound") || combined.includes("eai_again") || combined.includes("getaddrinfo") || combined.includes("name or service not known") || combined.includes("temporary failure in name resolution")) {
+      return "network_dns_resolution_failed";
+    }
+    if (combined.includes("econnrefused") || combined.includes("connection refused")) {
+      return "network_connection_refused";
+    }
+    if (combined.includes("econnreset") || combined.includes("connection reset")) {
+      return "network_connection_reset";
+    }
+    if (combined.includes("incompleteread") || combined.includes("incomplete read")) {
+      return "network_incomplete_read";
+    }
+    if (combined.includes("remotedisconnected") || combined.includes("remote end closed connection") || combined.includes("other side closed") || combined.includes("socket hang up")) {
+      return "network_remote_disconnected";
+    }
+    if (combined.includes("ssl") || combined.includes("tls") || combined.includes("unexpected_eof_while_reading")) {
+      return "network_ssl_error";
+    }
+    current = record.cause ?? record.context;
+  }
+  return "network_error";
+}
+function classifyNetworkCauseCategory(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let cause = error;
+  while (cause && typeof cause === "object" && !seen.has(cause)) {
+    seen.add(cause);
+    const record = cause;
+    if (record.code === "UND_ERR_CONNECT_TIMEOUT") return "connect_timeout";
+    cause = record.cause;
+  }
+  switch (classifyNetworkFailure(error)) {
+    case "network_dns_resolution_failed":
+      return "dns";
+    case "network_ssl_error":
+      return "tls";
+    case "network_connection_reset":
+      return "reset";
+    case "network_timeout":
+      return "timeout";
+    default:
+      return "unknown";
+  }
+}
+function isNetworkFailure(error) {
+  if (!(error instanceof Error)) return false;
+  if (error instanceof DeeplineError && error.statusCode) return false;
+  const code = classifyNetworkFailure(error);
+  return code !== "network_error" || /unable to connect|unable to stream/i.test(error.message);
+}
+function buildEnvironmentContext() {
+  const context = {
+    os: platform(),
+    os_release: release(),
+    platform: `${platform()}-${release()}-${process.arch}`,
+    node_version: process.version,
+    runtime: "Node.js",
+    hostname: hostname(),
+    agent_runtime: detectAgentRuntime()
+  };
+  for (const key of ["CLAUDE_CODE_REMOTE", "DEEPLINE_PLUGIN_MODE"]) {
+    const normalized = process.env[key]?.trim();
+    if (normalized) context[key.toLowerCase()] = normalized;
+  }
+  if (process.env.CLAUDE_PROJECT_DIR?.trim()) {
+    context.claude_project_dir_present = "true";
+  }
+  if (process.env.DEEPLINE_PLUGIN_ROOT?.trim()) {
+    context.deepline_plugin_root_present = "true";
+  }
+  if (process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim()) {
+    context.deepline_plugin_skills_dir_present = "true";
+  }
+  if (process.env.HOME?.trim().startsWith("/sessions/")) {
+    context.home_scope = "sessions";
+  }
+  return context;
+}
+function failureReportHeaders(apiKey) {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    "User-Agent": `deepline-ts-sdk/${SDK_VERSION}`,
+    "X-Deepline-Client-Family": "sdk",
+    "X-Deepline-CLI-Family": "sdk",
+    "X-Deepline-Agent-Runtime": detectAgentRuntime(),
+    "X-Deepline-CLI-Version": SDK_VERSION,
+    "X-Deepline-SDK-Version": SDK_VERSION
+  };
+}
+async function postFailureReport(input) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
+  if (input.background) timeout.unref();
+  try {
+    await fetch(new URL("/api/v2/cli/report-failure", input.baseUrl), {
+      method: "POST",
+      headers: failureReportHeaders(input.apiKey),
+      body: JSON.stringify(input.body),
+      signal: controller.signal
+    });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function boundedTelemetryString(value, maxChars) {
+  return redactFailureText(value.trim(), maxChars);
+}
+async function maybeReportAutomaticSkillsSyncFailure(input) {
+  if (isFailureReportingDisabled()) return false;
+  let apiKey = "";
+  try {
+    apiKey = resolveApiKeyForBaseUrl(input.baseUrl);
+  } catch {
+    return false;
+  }
+  if (!apiKey) return false;
+  const attempts = input.attempts.slice(0, 2).map((attempt) => ({
+    installer: attempt.installer,
+    outcome: attempt.outcome,
+    exit_code: typeof attempt.exitCode === "number" && Number.isFinite(attempt.exitCode) ? Math.trunc(attempt.exitCode) : null
+  }));
+  const agents = input.agents.slice(0, 8).map((agent) => boundedTelemetryString(agent, 100)).filter(Boolean);
+  const baseUrl = input.baseUrl.replace(/\/$/, "");
+  const failureKind = "background_warning";
+  const failureCode2 = "SKILLS_AUTO_SYNC_FAILED";
+  const failureStage = "skills_install";
+  return postFailureReport({
+    baseUrl,
+    apiKey,
+    timeoutMs: BACKGROUND_REPORT_FAILURE_TIMEOUT_MS,
+    background: true,
+    body: {
+      command: "deepline skills",
+      subcommand: "skills",
+      failure_kind: failureKind,
+      failure_code: failureCode2,
+      failure_stage: failureStage,
+      error_body: "Automatic Deepline skills installation failed.",
+      cli_version: SDK_VERSION,
+      context: {
+        environment: buildEnvironmentContext(),
+        skills_sync: {
+          skills_package: boundedTelemetryString(input.skillsPackage, 100),
+          remote_skills_version: boundedTelemetryString(
+            input.remoteSkillsVersion,
+            200
+          ),
+          agents,
+          target_skill_count: Math.max(
+            0,
+            Math.trunc(
+              Number.isFinite(input.targetSkillCount) ? input.targetSkillCount : 0
+            )
+          ),
+          marker_written: input.markerWritten,
+          attempts
+        }
+      }
+    }
+  });
+}
+function subcommandFromArgv(argv) {
+  return argv.find((arg) => arg && !arg.startsWith("-")) ?? null;
+}
+function commandTokens(argv) {
+  return argv.map((arg) => String(arg ?? "").trim()).filter((arg) => arg && !arg.startsWith("-"));
+}
+function isServerLoggedPlayRunStartFailure(input) {
+  const [subcommand, command] = commandTokens(input.argv);
+  return subcommand === "plays" && command === "run" && input.error instanceof DeeplineError && typeof input.error.statusCode === "number";
+}
+function shouldReport(input) {
+  if (input.error !== void 0) return true;
+  return input.exitCode !== null && REPORTABLE_EXIT_CODES.has(input.exitCode);
+}
+function failureCode(input) {
+  if (input.error !== void 0) {
+    if (isNetworkFailure(input.error))
+      return classifyNetworkFailure(input.error);
+    if (input.error instanceof DeeplineError && input.error.code) {
+      return input.error.code;
+    }
+    if (input.error instanceof Error && input.error.name)
+      return input.error.name;
+    return "CLI_FAILURE";
+  }
+  return input.exitCode === 4 ? "network_error" : "command_exit";
+}
+function resolvedExitCode(input) {
+  if (typeof input.exitCode === "number" && Number.isFinite(input.exitCode)) {
+    return Math.trunc(input.exitCode);
+  }
+  if (input.error === void 0) return null;
+  return isNetworkFailure(input.error) ? 4 : 5;
+}
+function resolveSdkCliFailureExitCode(error) {
+  return isNetworkFailure(error) ? 4 : 1;
+}
+function resolvedFailureKind(input) {
+  return input.error === void 0 ? "command_exit" : "uncaught_exception";
+}
+function safeRequestDiagnostics(error) {
+  if (!(error instanceof DeeplineError)) return null;
+  const request = error.details?.request;
+  if (!request || typeof request !== "object" || Array.isArray(request))
+    return null;
+  const value = request;
+  const result = {};
+  if (typeof value.phase === "string" && [
+    "before_request",
+    "retry_wait",
+    "awaiting_headers",
+    "reading_body"
+  ].includes(value.phase))
+    result.phase = value.phase;
+  if (typeof value.method === "string" && /^(GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS)$/.test(value.method))
+    result.method = value.method;
+  if (typeof value.url === "string") {
+    try {
+      const url = new URL(value.url);
+      if (url.protocol === "https:" || url.protocol === "http:") {
+        result.url = redactFailureText(`${url.origin}${url.pathname}`, 1e3);
+      }
+    } catch {
+    }
+  }
+  if (typeof value.failedAtUtc === "string" && Number.isFinite(Date.parse(value.failedAtUtc))) {
+    result.failedAtUtc = new Date(value.failedAtUtc).toISOString();
+  }
+  for (const key of ["elapsedMs", "attempts"]) {
+    const number = value[key];
+    if (typeof number === "number" && Number.isSafeInteger(number) && number >= 0)
+      result[key] = number;
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function buildFailureReport(input) {
+  const durationMs = Math.max(0, Date.now() - input.startedAtMs);
+  const request = safeRequestDiagnostics(input.error);
+  const failureKind = resolvedFailureKind({
+    exitCode: input.exitCode,
+    error: input.error
+  });
+  const code = failureCode({ exitCode: input.exitCode, error: input.error });
+  const errorBody = input.error === void 0 ? `SDK CLI command exited ${input.exitCode ?? "unknown"}` : errorMessage(input.error);
+  const networkCauseCategory = input.error !== void 0 && isNetworkFailure(input.error) ? classifyNetworkCauseCategory(input.error) : null;
+  return {
+    command: sanitizeCommand(input.argv),
+    subcommand: subcommandFromArgv(input.argv),
+    error_status: input.exitCode,
+    error_body: redactFailureText(errorBody),
+    exit_code: input.exitCode,
+    duration_ms: durationMs,
+    error_class: input.error instanceof Error ? input.error.name : null,
+    stack_trace: errorStack(input.error),
+    failure_kind: failureKind,
+    failure_code: code,
+    failure_stage: input.error === void 0 ? "command_exit" : "cli_main",
+    cli_version: SDK_VERSION,
+    context: {
+      base_url: redactFailureText(input.baseUrl, 400),
+      command_summary: sanitizeCommand(input.argv),
+      environment: buildEnvironmentContext(),
+      ...request ? { request } : {},
+      failure_kind: failureKind,
+      failure_code: code,
+      failure_stage: input.error === void 0 ? "command_exit" : "cli_main",
+      duration_ms: durationMs,
+      ...input.exitCode !== null ? { exit_code: input.exitCode } : {},
+      ...networkCauseCategory ? { network_cause_category: networkCauseCategory } : {}
+    }
+  };
+}
+async function maybeReportSdkCliFailure(input) {
+  if (isFailureReportingDisabled()) return false;
+  if (isServerLoggedPlayRunStartFailure(input)) return false;
+  const exitCode = resolvedExitCode(input);
+  if (!shouldReport({ exitCode, error: input.error })) return false;
+  const baseUrl = autoDetectBaseUrl().replace(/\/$/, "");
+  const apiKey = resolveApiKeyForBaseUrl(baseUrl);
+  if (!apiKey) return false;
+  return postFailureReport({
+    baseUrl,
+    apiKey,
+    timeoutMs: REPORT_FAILURE_TIMEOUT_MS,
+    body: buildFailureReport({
+      argv: input.argv,
+      startedAtMs: input.startedAtMs,
+      error: input.error,
+      exitCode,
+      baseUrl
+    })
+  });
+}
+
+// src/cli/skills-sync.ts
+var CHECK_TIMEOUT_MS2 = 3e3;
+var INSTALLER_PROBE_TIMEOUT_MS = 1500;
+var PUBLISHED_VERIFICATION_RETRY_MS = 5 * 6e4;
+function shouldSkipSkillsSync() {
+  if (detectAgentRuntime() === "claude_cowork" || isCiEnvironment()) {
+    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 join2(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
+}
+var SKILLS_SYNC_IN_PROGRESS_TTL_MS = 10 * 60 * 1e3;
+var SKILLS_SYNC_IN_PROGRESS_PID_CAP_MS = 6 * 60 * 60 * 1e3;
+var agentLeaseSegment = skillsAgentPathSegment;
+function sortedLeaseAgents(agents) {
+  const expanded = agents.includes("*") ? [...agents, ...KNOWN_SKILL_AGENTS] : agents;
+  return [...new Set(expanded)].sort((a, b) => a.localeCompare(b));
+}
+function inProgressSkillsSyncPath(baseUrl, agent) {
+  return join2(
+    sdkCliStateDirPath(baseUrl),
+    `skills-sync-in-progress-${agentLeaseSegment(agent)}`
+  );
+}
+function readInProgressSkillsSyncLeaseFromDir(dir) {
+  const claim = readMarkedSkillsSyncVersion(join2(dir, "claim"));
+  const [version = "", startedAt = ""] = claim.split(" ");
+  const pidRaw = readMarkedSkillsSyncVersion(join2(dir, "pid"));
+  return {
+    claimToken: version && startedAt ? `${version} ${startedAt}` : "",
+    version,
+    startedAt: Number(startedAt),
+    pid: /^\d+$/.test(pidRaw) ? Number(pidRaw) : null,
+    owner: readMarkedSkillsSyncVersion(join2(dir, "owner"))
+  };
+}
+function readInProgressSkillsSyncLease(baseUrl, agent) {
+  return readInProgressSkillsSyncLeaseFromDir(
+    inProgressSkillsSyncPath(baseUrl, agent)
+  );
+}
+function readInProgressSkillsSyncLeases(baseUrl, agents) {
+  return new Map(
+    sortedLeaseAgents(agents).map((agent) => [
+      agent,
+      readInProgressSkillsSyncLease(baseUrl, agent)
+    ])
+  );
+}
+var UNRESOLVED_SKILLS_CLAIM_VERSION = "unresolved";
+function claimedSkillsVersion(leases) {
+  for (const lease of leases.values()) {
+    if (lease.version && lease.version !== UNRESOLVED_SKILLS_CLAIM_VERSION) {
+      return lease.version;
+    }
+  }
+  return "";
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function isFreshInProgressSkillsSync(lease, now = Date.now()) {
+  if (!Number.isFinite(lease.startedAt)) return false;
+  const age = now - lease.startedAt;
+  if (age < 0) return false;
+  if (lease.pid !== null && isProcessAlive(lease.pid)) {
+    return age < SKILLS_SYNC_IN_PROGRESS_PID_CAP_MS;
+  }
+  return age < SKILLS_SYNC_IN_PROGRESS_TTL_MS;
+}
+function quarantine(path, tag) {
+  const holding = `${path}.${tag}-${process.pid}-${Date.now()}`;
+  try {
+    renameSync2(path, holding);
+    return holding;
+  } catch {
+    return null;
+  }
+}
+function claimOneInProgressSkillsSync(baseUrl, remoteVersion, agent, owner) {
+  const dir = inProgressSkillsSyncPath(baseUrl, agent);
+  const errorCode = (error) => error.code;
+  const create = () => {
+    const claimToken = `${remoteVersion} ${Date.now()}`;
+    const staging = `${dir}.staging-${process.pid}-${Date.now()}`;
+    mkdirSync2(staging);
+    writeFileSync2(join2(staging, "claim"), `${claimToken}
+`, "utf-8");
+    writeFileSync2(join2(staging, "owner"), `${owner}
+`, "utf-8");
+    try {
+      renameSync2(staging, dir);
+    } catch (error) {
+      rmSync2(staging, { recursive: true, force: true });
+      const code = errorCode(error);
+      const err = new Error("lease directory already exists");
+      err.code = code === "EEXIST" || code === "ENOTEMPTY" ? "EEXIST" : String(code ?? "");
+      throw err;
+    }
+    return { state: "claimed", claimToken };
+  };
+  try {
+    mkdirSync2(dirname2(dir), { recursive: true });
+    return create();
+  } catch (error) {
+    if (errorCode(error) !== "EEXIST") return { state: "unavailable" };
+  }
+  if (isFreshInProgressSkillsSync(readInProgressSkillsSyncLease(baseUrl, agent))) {
+    return { state: "held" };
+  }
+  const tombstone = quarantine(dir, "stale");
+  if (!tombstone) {
+    return { state: "held" };
+  }
+  rmSync2(tombstone, { recursive: true, force: true });
+  try {
+    return create();
+  } catch (error) {
+    return errorCode(error) === "EEXIST" ? { state: "held" } : { state: "unavailable" };
+  }
+}
+function claimInProgressSkillsSync(baseUrl, remoteVersion, agents) {
+  const claimTokens = /* @__PURE__ */ new Map();
+  const owner = randomUUID2();
+  for (const agent of sortedLeaseAgents(agents)) {
+    const claim = claimOneInProgressSkillsSync(
+      baseUrl,
+      remoteVersion,
+      agent,
+      owner
+    );
+    if (claim.state !== "claimed") {
+      releaseInProgressSkillsSync(baseUrl, claimTokens);
+      return { state: claim.state };
+    }
+    claimTokens.set(agent, claim.claimToken);
+  }
+  return { state: "claimed", claimTokens, owner };
+}
+function claimAndSpawnDetachedSkillsSync(baseUrl, agents, remoteVersion, spawnDetached) {
+  const claim = claimInProgressSkillsSync(baseUrl, remoteVersion, agents);
+  if (claim.state !== "claimed") return claim.state;
+  const { claimTokens, owner } = claim;
+  spawnDetached([SKILLS_AUTO_SYNC_COMMAND, "--claim", owner], () => {
+    releaseInProgressSkillsSync(baseUrl, claimTokens);
+    if (remoteVersion !== UNRESOLVED_SKILLS_CLAIM_VERSION) {
+      markFailedSkillsSync(baseUrl, remoteVersion, agents);
+    }
+    deferSkillsNotice(
+      baseUrl,
+      agents
+    )(
+      "Deepline skills refresh failed to start; run `deepline skills` to retry."
+    );
+  });
+  return "claimed";
+}
+function recordOwnPidOnInProgressSkillsSync(baseUrl, leases) {
+  for (const [agent, lease] of leases) {
+    if (!lease.claimToken) continue;
+    try {
+      writeFileSync2(
+        join2(inProgressSkillsSyncPath(baseUrl, agent), "pid"),
+        `${process.pid}
+`,
+        "utf-8"
+      );
+    } catch {
+    }
+  }
+}
+function releaseInProgressSkillsSync(baseUrl, claimTokens) {
+  for (const [agent, claimToken] of claimTokens) {
+    const dir = inProgressSkillsSyncPath(baseUrl, agent);
+    if (!claimToken) {
+      try {
+        rmSync2(dir, { recursive: true, force: true });
+      } catch {
+      }
+      continue;
+    }
+    const tombstone = quarantine(dir, "release");
+    if (!tombstone) continue;
+    try {
+      if (readInProgressSkillsSyncLeaseFromDir(tombstone).claimToken !== claimToken) {
+        renameSync2(tombstone, dir);
+        continue;
+      }
+    } catch {
+    }
+    rmSync2(tombstone, { recursive: true, force: true });
+  }
+}
+function claimTokensOf(leases) {
+  return new Map(
+    [...leases].map(([agent, lease]) => [agent, lease.claimToken])
+  );
+}
+async function acquireSkillsInstallLease(baseUrl, agents, version, options = {
+  waitMs: 9e4
+}) {
+  const pollMs = options.pollMs ?? 250;
+  const deadline = Date.now() + options.waitMs;
+  let waited = false;
+  for (; ; ) {
+    const claim = claimInProgressSkillsSync(baseUrl, version, agents);
+    if (claim.state === "unavailable") {
+      return { release: () => {
+      } };
+    }
+    if (claim.state === "claimed") {
+      recordOwnPidOnInProgressSkillsSync(
+        baseUrl,
+        readInProgressSkillsSyncLeases(baseUrl, agents)
+      );
+      return {
+        release: () => releaseInProgressSkillsSync(baseUrl, claim.claimTokens)
+      };
+    }
+    if (Date.now() >= deadline) return null;
+    if (!waited) {
+      waited = true;
+      options.onWait?.();
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+}
+function skillsInstallLeasePath(baseUrl, agents) {
+  return sortedLeaseAgents(agents).map((agent) => inProgressSkillsSyncPath(baseUrl, agent)).join(", ");
+}
+function deferredSkillsNoticePath(baseUrl, agents) {
+  return join2(
+    sdkCliStateDirPath(baseUrl),
+    `skills-sync-notice-${sortedLeaseAgents(agents).map(agentLeaseSegment).join("-")}`
+  );
+}
+function deferSkillsNotice(baseUrl, agents) {
+  const path = deferredSkillsNoticePath(baseUrl, agents);
+  return (text) => {
+    try {
+      mkdirSync2(dirname2(path), { recursive: true });
+      appendFileSync(path, `${text.trimEnd()}
+`, "utf-8");
+    } catch {
+    }
+  };
+}
+function flushDeferredSkillsNotices(baseUrl, agents) {
+  const path = deferredSkillsNoticePath(baseUrl, agents);
+  if (!existsSync2(path)) return;
+  const tombstone = quarantine(path, "consuming");
+  if (!tombstone) return;
+  let text = "";
+  try {
+    text = readFileSync2(tombstone, "utf-8");
+  } catch {
+    return;
+  } finally {
+    try {
+      unlinkSync(tombstone);
+    } catch {
+    }
+  }
+  if (text.trim()) writeSdkSkillsStatusLine(text.trimEnd());
+}
+function flushDeferredSkillsSyncNotices(baseUrl) {
+  if (shouldSkipSkillsSync() || hasActivePluginSkills()) return;
+  const agents = resolveAutoSyncSkillAgents();
+  if (agents.length === 0) return;
+  flushDeferredSkillsNotices(baseUrl, agents);
+}
+var SKILLS_AUTO_SYNC_COMMAND = "skills-auto-sync";
+function spawnDetachedSkillsSyncChild(argv, onSpawnError) {
+  const child = spawn(process.execPath, [process.argv[1] ?? "", ...argv], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  child.on("error", () => onSpawnError?.());
+  child.unref();
+}
+function failedSkillsSyncPath(baseUrl, agents) {
+  return join2(
+    sdkCliStateDirPath(baseUrl),
+    `skills-sync-failed-${sortedLeaseAgents(agents).map(agentLeaseSegment).join("-")}-version`
+  );
+}
+function hasMarkedSkillsSyncVersion(path, version) {
+  return Boolean(version) && readMarkedSkillsSyncVersion(path) === version;
+}
+function readMarkedSkillsSyncVersion(path) {
+  try {
+    return existsSync2(path) ? readFileSync2(path, "utf-8").trim() : "";
+  } catch {
+    return "";
+  }
+}
+function writeMarkedSkillsSyncVersion(path, version) {
+  try {
+    mkdirSync2(dirname2(path), { recursive: true });
+    writeFileSync2(path, `${version}
+`, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeUnavailableSkillsNotice(baseUrl, remoteVersion, skillNames, reason, notice = writeSdkSkillsStatusLine, knownProbes) {
+  const path = unavailableSkillsNoticePath(baseUrl);
+  if (hasMarkedSkillsSyncVersion(path, remoteVersion)) return;
+  writeMarkedSkillsSyncVersion(path, remoteVersion);
+  const probes = reason === "no-installer" ? knownProbes ?? probeInstallers() : null;
+  const manualCommand = probes?.npx === "missing" && probes.bunx !== "missing" ? `bunx ${buildBunxSkillsInstallArgs(baseUrl, skillNames, DEFAULT_SKILL_AGENTS).map(shellQuote).join(" ")}` : `npx ${buildSkillsInstallArgs(baseUrl, skillNames).join(" ")}`;
+  const explanation = reason === "unsupported-agent" ? "the detected agent has no automatic skills sync target. Automatic sync was skipped." : probes?.bunx === "missing" && probes.npx === "missing" ? "neither `bunx` nor `npx` was found on PATH. Make one available." : `installer version check failed for ${Object.entries(probes ?? {}).filter(([, result]) => result === "failed").map(([command]) => `\`${command}\``).join(" and ")}. Check those commands with --version.`;
+  notice(
+    `Deepline agent skills are out of date, but ${explanation} To install manually, run:
+${manualCommand}`
+  );
+}
+function clearUnavailableSkillsNotice(baseUrl) {
+  try {
+    unlinkSync(unavailableSkillsNoticePath(baseUrl));
+  } catch {
+  }
+}
+function hasFailedSkillsSync(baseUrl, remoteVersion, agents) {
+  const marked = readMarkedSkillsSyncVersion(
+    failedSkillsSyncPath(baseUrl, agents)
+  );
+  if (marked === remoteVersion) return true;
+  try {
+    const retry = JSON.parse(marked);
+    const now = Date.now();
+    return retry.version === remoteVersion && typeof retry.retryAfter === "number" && retry.retryAfter > now && retry.retryAfter <= now + PUBLISHED_VERIFICATION_RETRY_MS;
+  } catch {
+    return false;
+  }
+}
+function hasFailedAutomaticSkillsSync(baseUrl, agents) {
+  return existsSync2(failedSkillsSyncPath(baseUrl, agents));
+}
+function markFailedSkillsSync(baseUrl, remoteVersion, agents) {
+  return writeMarkedSkillsSyncVersion(
+    failedSkillsSyncPath(baseUrl, agents),
+    remoteVersion
+  );
+}
+function deferPublishedVerificationRetry(baseUrl, remoteVersion, agents) {
+  return writeMarkedSkillsSyncVersion(
+    failedSkillsSyncPath(baseUrl, agents),
+    JSON.stringify({
+      version: remoteVersion,
+      retryAfter: Date.now() + PUBLISHED_VERIFICATION_RETRY_MS
+    })
+  );
+}
+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 fetchV1SkillIndex(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 null;
+    const data = await response.json().catch(() => null);
+    return data;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function v1SkillNames(index) {
+  const skills = Array.isArray(index?.skills) ? index.skills : [];
+  return sortedUniqueSkillNames(
+    skills.filter((skill) => skill && skill.install_surface === "v1").map((skill) => skill.name).filter(
+      (name) => typeof name === "string" && name.length > 0
+    )
+  );
+}
+function buildSdkSkillNames(v1SkillNames2) {
+  return sortedUniqueSkillNames(v1SkillNames2);
+}
+function isDefaultAgentSet(agents) {
+  return agents.length === DEFAULT_SKILL_AGENTS.length && agents.every((agent, index) => agent === DEFAULT_SKILL_AGENTS[index]);
+}
+function safeSkillFilePath(value) {
+  if (typeof value !== "string" || !value) return false;
+  return value.split("/").every(
+    (part) => /^[a-zA-Z0-9._-]+$/.test(part) && part !== "." && part !== ".."
+  );
+}
+function installedSkillFiles(root, prefix = "") {
+  const files = [];
+  for (const entry of readdirSync(join2(root, prefix), {
+    withFileTypes: true
+  })) {
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...installedSkillFiles(root, relativePath));
+    } else if (entry.isFile()) {
+      files.push(relativePath);
+    } else {
+      throw new Error(`unexpected installed entry in ${root}`);
+    }
+  }
+  return files.sort((a, b) => a.localeCompare(b));
+}
+function publishedArchiveFiles(bytes, expectedFiles, name) {
+  const tar = gunzipSync(bytes, { maxOutputLength: 128 * 1024 * 1024 });
+  const expected = new Set(expectedFiles);
+  const files = /* @__PURE__ */ new Map();
+  let offset = 0;
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) {
+      if (!tar.subarray(offset).every((byte) => byte === 0)) {
+        throw new Error(`invalid published archive for ${name}`);
+      }
+      break;
+    }
+    const file = header.toString("utf8", 0, 100).split("\0", 1)[0] ?? "";
+    const sizeText = header.toString("ascii", 124, 136).replace(/\0/g, "").trim();
+    const size = /^[0-7]+$/.test(sizeText) ? Number.parseInt(sizeText, 8) : NaN;
+    const type = header[156];
+    if (!safeSkillFilePath(file) || !expected.has(file) || files.has(file) || !Number.isSafeInteger(size) || size < 0 || type !== 0 && type !== 48 || header.subarray(345, 500).some((byte) => byte !== 0)) {
+      throw new Error(`invalid published archive entry for ${name}`);
+    }
+    const start = offset + 512;
+    const end = start + size;
+    if (end > tar.length) {
+      throw new Error(`incomplete published archive for ${name}`);
+    }
+    files.set(file, tar.subarray(start, end));
+    offset = start + Math.ceil(size / 512) * 512;
+  }
+  if (files.size !== expected.size) {
+    throw new Error(`published archive file list differs for ${name}`);
+  }
+  return files;
+}
+var PublishedSkillsVerificationError = class extends Error {
+};
+async function verifyDefaultAgentSkillsInstall(baseUrl, remoteVersion, skillNames, index) {
+  if (index?.version !== remoteVersion) {
+    throw new PublishedSkillsVerificationError(
+      "the published skill index version does not match the server version"
+    );
+  }
+  const published = /* @__PURE__ */ new Map();
+  const entries = Array.isArray(index.skills) ? index.skills : [];
+  for (const name of skillNames) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+      throw new PublishedSkillsVerificationError(
+        `unsafe published skill name: ${name}`
+      );
+    }
+    const entry = entries.find(
+      (skill) => skill && skill.name === name && skill.install_surface === "v1"
+    );
+    if (!Array.isArray(entry?.files) || !entry.files.length || !entry.files.every(safeSkillFilePath) || new Set(entry.files).size !== entry.files.length || !entry.files.includes("SKILL.md") || entry.type !== "archive" || entry.url !== `./archives/${name}.tar.gz` || typeof entry.digest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(entry.digest)) {
+      throw new PublishedSkillsVerificationError(
+        `invalid published file list for ${name}`
+      );
+    }
+    published.set(name, {
+      files: [...entry.files].sort((a, b) => a.localeCompare(b)),
+      digest: entry.digest
+    });
+  }
+  const expected = /* @__PURE__ */ new Map();
+  const jobs = [...published];
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 12e4);
+  let cursor = 0;
+  try {
+    await Promise.all(
+      Array.from({ length: Math.min(8, jobs.length) }, async () => {
+        while (cursor < jobs.length) {
+          const job = jobs[cursor++];
+          if (!job) break;
+          const [name, publishedSkill] = job;
+          const url = new URL(
+            `/.well-known/skills/archives/${name}.tar.gz`,
+            baseUrl
+          );
+          const response = await fetch(url, { signal: controller.signal });
+          if (!response.ok) {
+            throw new Error(`published archive is unavailable: ${name}`);
+          }
+          const bytes = Buffer.from(await response.arrayBuffer());
+          const digest = `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+          if (digest !== publishedSkill.digest) {
+            throw new Error(`published archive digest differs for ${name}`);
+          }
+          for (const [file, content] of publishedArchiveFiles(
+            bytes,
+            publishedSkill.files,
+            name
+          )) {
+            expected.set(`${name}/${file}`, content);
+          }
+        }
+      })
+    );
+  } catch (error) {
+    throw new PublishedSkillsVerificationError(
+      error instanceof Error ? error.message : String(error)
+    );
+  } finally {
+    clearTimeout(timeout);
+    controller.abort();
+  }
+  const home = homedir2();
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim() || join2(home, ".claude");
+  for (const [name, { files }] of published) {
+    for (const root of [
+      join2(home, ".agents", "skills", name),
+      join2(claudeConfigDir, "skills", name)
+    ]) {
+      const installed = installedSkillFiles(root);
+      if (installed.length !== files.length || installed.some((file, index2) => file !== files[index2])) {
+        throw new Error(`installed file tree differs for ${name}`);
+      }
+      for (const file of files) {
+        const publishedContent = expected.get(`${name}/${file}`);
+        if (!publishedContent || !readFileSync2(join2(root, file)).equals(publishedContent)) {
+          throw new Error(`installed content differs for ${name}/${file}`);
+        }
+      }
+    }
+  }
+}
+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
+  });
+}
+var NEGATIVE_INSTALLER_PROBE_TTL_MS = 5 * 60 * 1e3;
+function probeInstallers(timeoutMs) {
+  return {
+    bunx: probeCommand("bunx", timeoutMs),
+    npx: probeCommand("npx", timeoutMs)
+  };
+}
+function noInstallerProbePath(baseUrl) {
+  return join2(
+    sdkCliStateDirPath(baseUrl),
+    "skills-sync-no-installer-unknown.json"
+  );
+}
+function dueUnknownInstallerProbes(baseUrl, remoteVersion) {
+  const path = noInstallerProbePath(baseUrl);
+  try {
+    const cached = JSON.parse(readFileSync2(path, "utf-8"));
+    if (cached.version === remoteVersion && typeof cached.checkedAt === "number" && cached.checkedAt <= Date.now() && Date.now() - cached.checkedAt < NEGATIVE_INSTALLER_PROBE_TTL_MS && (cached.probes?.bunx === "missing" || cached.probes?.bunx === "failed") && (cached.probes?.npx === "missing" || cached.probes?.npx === "failed")) {
+      return cached.probes;
+    }
+  } catch {
+  }
+  const probes = probeInstallers(INSTALLER_PROBE_TIMEOUT_MS);
+  if (probes.bunx !== "available" && probes.npx !== "available") {
+    try {
+      mkdirSync2(dirname2(path), { recursive: true });
+      writeFileSync2(
+        path,
+        JSON.stringify({
+          version: remoteVersion,
+          checkedAt: Date.now(),
+          probes
+        }),
+        "utf-8"
+      );
+    } catch {
+    }
+  }
+  return probes;
+}
+function probeCommand(command, timeoutMs) {
+  const plan = resolveShellSpawn(command, ["--version"]);
+  const result = spawnSync(plan.command, plan.args, {
+    stdio: "ignore",
+    shell: plan.shell,
+    timeout: timeoutMs
+  });
+  if (result.status === 0) return "available";
+  return result.error?.code === "ENOENT" ? "missing" : "failed";
+}
+function hasCommand(command) {
+  return probeCommand(command) === "available";
+}
+function shellQuote(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, platform2 = process.platform) {
+  return resolveShellSpawn(install.command, install.args, platform2);
+}
+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(shellQuote).join(" ")}`
+    });
+  }
+  if (hasCommand("npx")) {
+    const npxArgs = buildSkillsInstallArgs(baseUrl, skillNames, agents);
+    commands.push({
+      command: "npx",
+      args: npxArgs,
+      manualCommand: `npx ${npxArgs.map(shellQuote).join(" ")}`
+    });
+  }
+  return commands;
+}
+function runOneSkillsInstall(install) {
+  return new Promise((resolve) => {
+    const plan = resolveSkillsInstallSpawn(install);
+    const child = spawn(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) => {
+      resolve({
+        ok: false,
+        detail: `failed to start ${install.command}: ${error.message}`,
+        manualCommand: install.manualCommand,
+        attempt: {
+          installer: install.command,
+          outcome: "spawn_error",
+          exitCode: null
+        }
+      });
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({ ok: true });
+        return;
+      }
+      const detail = stderr.trim();
+      resolve({
+        ok: false,
+        detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
+        manualCommand: install.manualCommand,
+        attempt: {
+          installer: install.command,
+          outcome: code === null ? "terminated" : "exit",
+          exitCode: code
+        }
+      });
+    });
+  });
+}
+async function runSkillsInstall(installs, agents, notice = writeSdkSkillsStatusLine) {
+  const failures = [];
+  for (const install of installs) {
+    const result = await runOneSkillsInstall(install);
+    if (result.ok) return { installed: 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.length === 1 ? agents[0] : void 0;
+  notice(
+    `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 {
+    installed: false,
+    attempts: failures.map(({ attempt }) => attempt)
+  };
+}
+function runLegacySkillsCleanup(agents) {
+  const candidates = hasCommand("bunx") ? [
+    {
+      command: "bunx",
+      args: [
+        "--bun",
+        SKILLS_NPX_PACKAGE,
+        "remove",
+        "--global",
+        "--agent",
+        ...agents,
+        "-y",
+        ...LEGACY_SKILL_NAMES_TO_REMOVE
+      ]
+    },
+    {
+      command: "npx",
+      args: [
+        "--yes",
+        SKILLS_NPX_PACKAGE,
+        "remove",
+        "--global",
+        "--agent",
+        ...agents,
+        "-y",
+        ...LEGACY_SKILL_NAMES_TO_REMOVE
+      ]
+    }
+  ] : [
+    {
+      command: "npx",
+      args: [
+        "--yes",
+        SKILLS_NPX_PACKAGE,
+        "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 agents = resolveAutoSyncSkillAgents();
+  if (options.mode === "detached" && agents.length > 0) {
+    flushDeferredSkillsNotices(baseUrl, agents);
+  }
+  if (options.mode === "detached" && options.update === void 0 && isDefaultAgentSet(agents)) {
+    return;
+  }
+  const ownsInProgressMarker = options.mode !== "detached" && agents.length > 0 && Boolean(options.claim);
+  const leases = ownsInProgressMarker ? readInProgressSkillsSyncLeases(baseUrl, agents) : null;
+  if (leases && [...leases.values()].some((lease) => lease.owner !== options.claim)) {
+    return;
+  }
+  if (leases) recordOwnPidOnInProgressSkillsSync(baseUrl, leases);
+  const claimedVersion = leases ? claimedSkillsVersion(leases) : "";
+  if (options.mode === "detached" && agents.length > 0 && options.update === void 0 && !claimedVersion) {
+    const outcome = claimAndSpawnDetachedSkillsSync(
+      baseUrl,
+      agents,
+      UNRESOLVED_SKILLS_CLAIM_VERSION,
+      options.spawnDetached ?? spawnDetachedSkillsSyncChild
+    );
+    if (outcome !== "unavailable") return;
+  }
+  try {
+    const localVersion = readSdkSkillsLocalVersion(baseUrl);
+    const update = options.update === void 0 ? claimedVersion ? { needsUpdate: true, remoteVersion: claimedVersion } : await fetchSkillsUpdate(baseUrl, localVersion) : options.update ? {
+      needsUpdate: options.update.needs_update,
+      remoteVersion: options.update.remote.version
+    } : null;
+    if (!update?.needsUpdate || !update.remoteVersion) {
+      return;
+    }
+    if (agents.length > 0 && hasFailedSkillsSync(baseUrl, update.remoteVersion, agents)) {
+      return;
+    }
+    if (options.mode === "detached" && agents.length === 0) {
+      writeUnavailableSkillsNotice(
+        baseUrl,
+        update.remoteVersion,
+        buildSdkSkillNames(DEFAULT_SDK_SKILL_NAMES),
+        "unsupported-agent"
+      );
+      return;
+    }
+    if (options.mode === "detached" && agents.length > 0) {
+      if (isDefaultAgentSet(agents)) {
+        if (agents.some(
+          (agent) => isFreshInProgressSkillsSync(
+            readInProgressSkillsSyncLease(baseUrl, agent)
+          )
+        )) {
+          return;
+        }
+        const probes = dueUnknownInstallerProbes(baseUrl, update.remoteVersion);
+        if (probes.bunx !== "available" && probes.npx !== "available") {
+          writeUnavailableSkillsNotice(
+            baseUrl,
+            update.remoteVersion,
+            buildSdkSkillNames(DEFAULT_SDK_SKILL_NAMES),
+            "no-installer",
+            writeSdkSkillsStatusLine,
+            probes
+          );
+          return;
+        }
+      }
+      const outcome = claimAndSpawnDetachedSkillsSync(
+        baseUrl,
+        agents,
+        update.remoteVersion,
+        options.spawnDetached ?? spawnDetachedSkillsSyncChild
+      );
+      if (outcome === "held") return;
+      if (outcome === "claimed") {
+        writeSdkSkillsStatusLine(
+          "Deepline skills are out of date; updating in the background."
+        );
+        return;
+      }
+      if (isDefaultAgentSet(agents)) return;
+    }
+    await runInlineSkillsSync(
+      baseUrl,
+      update.remoteVersion,
+      agents,
+      options.notices ?? "print"
+    );
+  } finally {
+    if (leases) {
+      releaseInProgressSkillsSync(baseUrl, claimTokensOf(leases));
+    }
+  }
+}
+async function runInlineSkillsSync(baseUrl, remoteVersion, agents, notices) {
+  const update = { remoteVersion };
+  const notice = notices === "defer" ? deferSkillsNotice(baseUrl, agents) : writeSdkSkillsStatusLine;
+  const index = await fetchV1SkillIndex(baseUrl);
+  const remoteSkillNames = v1SkillNames(index);
+  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,
+      "unsupported-agent",
+      notice
+    );
+    return;
+  }
+  const installs = resolveSkillsInstallCommands(baseUrl, skillNames, agents);
+  if (installs.length === 0) {
+    writeUnavailableSkillsNotice(
+      baseUrl,
+      update.remoteVersion,
+      skillNames,
+      "no-installer",
+      notice
+    );
+    return;
+  }
+  if (notices === "print") {
+    writeSdkSkillsStatusLine(
+      "Deepline skills changed; syncing agent skills..."
+    );
+  }
+  const installResult = await runSkillsInstall(installs, agents, notice);
+  if (!installResult.installed) {
+    const markerWritten = markFailedSkillsSync(
+      baseUrl,
+      update.remoteVersion,
+      agents
+    );
+    void maybeReportAutomaticSkillsSyncFailure({
+      baseUrl,
+      remoteSkillsVersion: update.remoteVersion,
+      agents,
+      skillsPackage: SKILLS_NPX_PACKAGE,
+      targetSkillCount: skillNames.length,
+      markerWritten,
+      attempts: installResult.attempts
+    });
+    if (isDefaultAgentSet(agents)) {
+      notice(
+        `After fixing the installer, remove ${failedSkillsSyncPath(baseUrl, agents)} to retry this skills version automatically.`
+      );
+    }
+    return;
+  }
+  if (isDefaultAgentSet(agents)) {
+    try {
+      await verifyDefaultAgentSkillsInstall(
+        baseUrl,
+        update.remoteVersion,
+        skillNames,
+        index
+      );
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      const publishedFailure = error instanceof PublishedSkillsVerificationError;
+      const markerWritten = publishedFailure ? deferPublishedVerificationRetry(baseUrl, update.remoteVersion, agents) : markFailedSkillsSync(baseUrl, update.remoteVersion, agents);
+      notice(
+        publishedFailure ? `Deepline could not verify the published skills: ${detail}. The local version remains stale; it will retry automatically on a later command.` : `Deepline agent-skills refresh could not verify the five installed targets: ${detail}. The local version remains stale. After fixing the install, remove ${failedSkillsSyncPath(baseUrl, agents)} to retry this version automatically.`
+      );
+      void maybeReportAutomaticSkillsSyncFailure({
+        baseUrl,
+        remoteSkillsVersion: update.remoteVersion,
+        agents,
+        skillsPackage: SKILLS_NPX_PACKAGE,
+        targetSkillCount: skillNames.length,
+        markerWritten,
+        attempts: []
+      });
+      return;
+    }
+  }
+  runLegacySkillsCleanup(agents);
+  if (!writeSdkSkillsLocalVersion(baseUrl, update.remoteVersion, agents)) {
+    notice(
+      "Deepline agent skills installed, but the local skills version could not be recorded. A later command will retry the refresh."
+    );
+    return;
+  }
+  clearUnavailableSkillsNotice(baseUrl);
+  clearFailedSkillsSync(baseUrl, agents);
+  notice("Deepline agent skills are up to date.");
+}
+
+// src/cli/commands/skills.ts
+var SKILLS_INSTALL_LEASE_WAIT_MS = 9e4;
+var SKILLS_PROCESS_TIMEOUT_MS = 45e3;
+var RUNTIME_TO_SKILLS_AGENT = {
+  antigravity: "antigravity",
+  claude_code: "claude-code",
+  claude_cowork: "claude-code",
+  cline: "cline",
+  codex: "codex",
+  cursor: "cursor",
+  gemini: "gemini-cli",
+  windsurf: "windsurf"
+};
+var AGENT_MARKERS = [
+  { agent: "codex", paths: [".codex"] },
+  { agent: "claude-code", paths: [".claude"] },
+  { agent: "cursor", paths: [".cursor"] },
+  { agent: "gemini-cli", paths: [".gemini", ".gemini-cli"] },
+  { agent: "antigravity", paths: [".antigravity"] }
+];
+var WORKSPACE_SKILL_ROOTS_BY_AGENT = {
+  antigravity: [".agents"],
+  "claude-code": [".claude"],
+  cline: [".agents"],
+  codex: [".agents"],
+  cursor: [".agents"],
+  "gemini-cli": [".agents"],
+  windsurf: [".windsurf"],
+  "*": [".agents", ".claude", ".windsurf"]
+};
+function workspaceSkillRootsForAgents(agents) {
+  return [
+    ...new Set(
+      agents.flatMap((agent) => WORKSPACE_SKILL_ROOTS_BY_AGENT[agent] ?? [])
+    )
+  ].sort((a, b) => a.localeCompare(b));
+}
+function normalizeScope(value) {
+  if (value === "global") return "global";
+  if (value === "local") return "local";
+  if (!value) return inferActiveSkillsScope();
+  throw new Error("--scope must be one of: global, local");
+}
+function inferActiveSkillsScope(entrypoint = process.argv[1] ?? "") {
+  return /[\\/]\.deepline[\\/]runtime[\\/]/.test(entrypoint) ? "local" : "global";
+}
+function resolveLocalRoot() {
+  const target = resolveProjectPinTarget();
+  if (!target.ok) {
+    throw new Error(
+      `Cowork project folder is ambiguous. Candidate folders: ${target.candidates.join(
+        ", "
+      )}. Set CLAUDE_PROJECT_DIR or cd into the intended project folder.`
+    );
+  }
+  return target.dir;
+}
+function detectSkillsAgents(input) {
+  const runtime = input.runtime ?? detectAgentRuntime();
+  const knownAgent = RUNTIME_TO_SKILLS_AGENT[runtime];
+  if (knownAgent) return [knownAgent];
+  const roots = [
+    ...input.scope === "local" && input.root ? [input.root] : [],
+    input.homeDir ?? homedir3()
+  ];
+  const detected = AGENT_MARKERS.filter(
+    (marker) => roots.some(
+      (root) => marker.paths.some((path) => existsSync3(join3(root, path)))
+    )
+  ).map((marker) => marker.agent);
+  return detected.length > 0 ? detected : ["*"];
+}
+function skillsStatePathForScope(baseUrl, scope, root) {
+  return scope === "local" && root ? join3(root, ".deepline", "setup", "skills.json") : join3(sdkCliStateDirPath(baseUrl), "skills-install.json");
+}
+function buildSkillsPlan(input) {
+  const scopeArgs = input.scope === "global" ? ["--global"] : [];
+  const legacyNames = [...LEGACY_SKILL_NAMES_TO_REMOVE].sort(
+    (a, b) => a.localeCompare(b)
+  );
+  return {
+    scope: input.scope,
+    root: input.root,
+    agents: input.agents,
+    skillNames: input.skillNames,
+    version: input.version,
+    remove: {
+      command: "npm",
+      args: [
+        "exec",
+        "--yes",
+        `--package=${SKILLS_NPX_PACKAGE}`,
+        "--",
+        "skills",
+        "remove",
+        ...scopeArgs,
+        "--agent",
+        ...input.agents,
+        "-y",
+        ...legacyNames
+      ]
+    },
+    install: {
+      command: "npm",
+      args: [
+        "exec",
+        "--yes",
+        `--package=${SKILLS_NPX_PACKAGE}`,
+        "--",
+        "skills",
+        "add",
+        skillsSourceUrl(input.baseUrl),
+        "--agent",
+        ...input.agents,
+        ...scopeArgs,
+        "--yes",
+        ...input.skillNames.flatMap((name) => ["--skill", name]),
+        "--full-depth"
+      ]
+    },
+    statePath: skillsStatePathForScope(input.baseUrl, input.scope, input.root)
+  };
+}
+function sortedStrings(value) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    return null;
+  }
+  return [...value].sort((a, b) => a.localeCompare(b));
+}
+function isSkillsPlanCurrent(plan, state) {
+  if (!state || state.scope !== plan.scope || state.skillsVersion !== plan.version) {
+    return false;
+  }
+  const installedAgents = sortedStrings(state.agents);
+  const installedSkillNames = sortedStrings(state.skillNames);
+  if (!installedAgents || !installedSkillNames) return false;
+  return installedAgents.join("\0") === [...plan.agents].sort((a, b) => a.localeCompare(b)).join("\0") && installedSkillNames.join("\0") === [...plan.skillNames].sort((a, b) => a.localeCompare(b)).join("\0");
+}
+function readSkillsInstallState(path) {
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function runProcess(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const plan = resolveShellSpawn(command, args);
+    const child = spawn2(plan.command, plan.args, {
+      cwd,
+      env: process.env,
+      stdio: ["ignore", "ignore", "pipe"],
+      shell: plan.shell
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+      process.stderr.write(chunk);
+    });
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(
+        new Error(
+          `${SKILLS_NPX_PACKAGE} timed out after ${SKILLS_PROCESS_TIMEOUT_MS}ms.`
+        )
+      );
+    }, SKILLS_PROCESS_TIMEOUT_MS);
+    child.once("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timeout);
+      if (code && stderr.trim()) {
+        process.stderr.write(`${SKILLS_NPX_PACKAGE} exited ${code}.
+`);
+      }
+      resolve(code ?? 1);
+    });
+  });
+}
+async function runSkillsCommand(options, dependencies = {}) {
+  let scope;
+  let root;
+  try {
+    scope = normalizeScope(options.scope);
+    root = scope === "local" ? resolveLocalRoot() : null;
+  } catch (error) {
+    printCommandEnvelope(
+      {
+        ok: false,
+        status: "failed",
+        code: "INVALID_SKILLS_SCOPE",
+        exitCode: 2,
+        message: error instanceof Error ? error.message : String(error)
+      },
+      { json: options.json }
+    );
+    return 2;
+  }
+  const baseUrl = autoDetectBaseUrl().replace(/\/$/, "");
+  const catalog = {
+    skillNames: [...DEFAULT_SDK_SKILL_NAMES],
+    version: SDK_VERSION
+  };
+  const agents = options.agent ? [options.agent] : detectSkillsAgents({ scope, root });
+  const plan = buildSkillsPlan({ baseUrl, scope, root, agents, ...catalog });
+  if (options.dryRun) {
+    printCommandEnvelope(
+      { ok: true, status: "planned", dryRun: true, ...plan },
+      { json: options.json }
+    );
+    return 0;
+  }
+  if (isSkillsPlanCurrent(plan, readSkillsInstallState(plan.statePath)) && !hasFailedAutomaticSkillsSync(baseUrl, agents)) {
+    printCommandEnvelope(
+      {
+        ok: true,
+        status: "current",
+        complete: true,
+        changed: false,
+        skipped: true,
+        skipReason: "skills_version_current",
+        scope,
+        agents,
+        skillsVersion: plan.version,
+        skillCount: plan.skillNames.length,
+        statePath: plan.statePath,
+        render: {
+          sections: [
+            {
+              title: "skills",
+              lines: [
+                `Scope: ${scope}`,
+                `Agents: ${agents.join(", ")}`,
+                `Current: ${plan.skillNames.length}`
+              ]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+    return 0;
+  }
+  if (scope === "local" && root) {
+    const managedNames = [
+      .../* @__PURE__ */ new Set([...plan.skillNames, ...LEGACY_SKILL_NAMES_TO_REMOVE])
+    ];
+    const agentRoots = workspaceSkillRootsForAgents(plan.agents);
+    ensureProjectPrivatePathsIgnored(root, [
+      ".deepline/",
+      ...agentRoots.flatMap(
+        (agentRoot) => managedNames.map((name) => `${agentRoot}/skills/${name}/`)
+      )
+    ]);
+  }
+  const lease = scope === "global" ? await acquireSkillsInstallLease(baseUrl, agents, plan.version, {
+    waitMs: dependencies.installLeaseWaitMs ?? SKILLS_INSTALL_LEASE_WAIT_MS,
+    onWait: () => process.stderr.write(
+      "Waiting for a background Deepline skills refresh to finish...\n"
+    )
+  }) : { release: () => {
+  } };
+  if (!lease) {
+    printCommandEnvelope(
+      {
+        ok: false,
+        status: "failed",
+        code: "SKILLS_SYNC_IN_PROGRESS",
+        exitCode: 7,
+        scope,
+        agents,
+        message: "A background Deepline skills refresh is still running for these agents.",
+        next: `Retry in a moment: deepline skills --scope ${scope} --json. If no refresh is running, remove ${skillsInstallLeasePath(baseUrl, agents)}`
+      },
+      { json: options.json }
+    );
+    return 7;
+  }
+  try {
+    return await runSkillsInstallWithLease({
+      options,
+      dependencies,
+      baseUrl,
+      scope,
+      root,
+      agents,
+      plan
+    });
+  } finally {
+    lease.release();
+  }
+}
+async function runSkillsInstallWithLease(input) {
+  const { options, dependencies, baseUrl, scope, root, agents, plan } = input;
+  process.stderr.write(
+    `Replacing Deepline skills for ${agents.join(", ")} (${scope})...
+`
+  );
+  const execute = dependencies.runProcess ?? runProcess;
+  try {
+    const installCode = await execute(
+      plan.install.command,
+      plan.install.args,
+      root ?? void 0
+    );
+    if (installCode !== 0) {
+      throw new Error("Could not install the current Deepline skills.");
+    }
+  } catch (error) {
+    printCommandEnvelope(
+      {
+        ok: false,
+        status: "failed",
+        code: "SKILLS_INSTALL_FAILED",
+        exitCode: 5,
+        scope,
+        agents,
+        message: error instanceof Error ? error.message : String(error),
+        next: `deepline skills --scope ${scope} --json`
+      },
+      { json: options.json }
+    );
+    return 5;
+  }
+  try {
+    const removeCode = await execute(
+      plan.remove.command,
+      plan.remove.args,
+      root ?? void 0
+    );
+    if (removeCode !== 0) {
+      process.stderr.write(
+        "Current Deepline skills installed, but legacy skill cleanup failed. The installed skills remain usable.\n"
+      );
+    }
+  } catch (error) {
+    process.stderr.write(
+      `Current Deepline skills installed, but legacy skill cleanup failed: ${error instanceof Error ? error.message : String(error)}. The installed skills remain usable.
+`
+    );
+  }
+  mkdirSync3(dirname3(plan.statePath), { recursive: true });
+  writeFileSync3(
+    plan.statePath,
+    `${JSON.stringify(
+      {
+        schemaVersion: 1,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        cliVersion: SDK_VERSION,
+        scope,
+        agents,
+        skillsVersion: plan.version,
+        skillNames: plan.skillNames
+      },
+      null,
+      2
+    )}
+`,
+    "utf8"
+  );
+  if (scope === "global") {
+    clearFailedAutomaticSkillsSync(baseUrl, agents);
+  }
+  printCommandEnvelope(
+    {
+      ok: true,
+      status: "complete",
+      scope,
+      agents,
+      skillsVersion: plan.version,
+      skillCount: plan.skillNames.length,
+      statePath: plan.statePath,
+      render: {
+        sections: [
+          {
+            title: "skills",
+            lines: [
+              `Scope: ${scope}`,
+              `Agents: ${agents.join(", ")}`,
+              `Installed: ${plan.skillNames.length}`
+            ]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+  return 0;
+}
+function registerSkillsCommand(program) {
+  program.command("skills").description("Replace Deepline agent skills with the current release.").option("--scope <scope>", "Install scope: global or local").option("--agent <agent>", "Override the detected agent target").option("--dry-run", "Print the install plan without changing files").option("--json", "Emit one JSON result envelope").addHelpText(
+    "after",
+    `
+Notes:
+  This command reinstalls current Deepline-managed skills using ${SKILLS_NPX_PACKAGE},
+  then removes legacy Deepline skill names. Local scope writes into the resolved
+  persistent project.
+
+Examples:
+  deepline skills --json
+  deepline skills --scope local --json
+  deepline skills --agent codex --dry-run --json
+`
+  ).action(async (options) => {
+    process.exitCode = await runSkillsCommand(options);
+  });
+  program.command(SKILLS_AUTO_SYNC_COMMAND, { hidden: true }).description("Refresh Deepline agent skills in the background.").option(
+    "--claim <token>",
+    "Owner token of the leases this child was started for."
+  ).action(async (options) => {
+    const claim = options.claim?.trim();
+    if (!claim) {
+      printCommandEnvelope(
+        {
+          ok: false,
+          status: "failed",
+          code: "SKILLS_AUTO_SYNC_CLAIM_REQUIRED",
+          exitCode: 2,
+          message: "skills-auto-sync is started by ordinary deepline commands and requires the lease token they pass; run `deepline skills` to install skills yourself."
+        },
+        { json: true }
+      );
+      process.exitCode = 2;
+      return;
+    }
+    await syncSdkSkillsIfNeeded(autoDetectBaseUrl().replace(/\/$/, ""), {
+      mode: "inline",
+      notices: "defer",
+      claim
+    });
+  });
+}
+
+export {
+  SDK_COMPATIBILITY_FAST_DEADLINE_MS,
+  readFreshCleanCompatibility,
+  readTrustedCleanCompatibility,
+  checkSdkCompatibility,
+  isCiEnvironment,
+  enforceSdkCompatibilityResponse,
+  resolveShellSpawn,
+  resolveSdkCliFailureExitCode,
+  maybeReportSdkCliFailure,
+  flushDeferredSkillsSyncNotices,
+  SKILLS_AUTO_SYNC_COMMAND,
+  syncSdkSkillsIfNeeded,
+  workspaceSkillRootsForAgents,
+  inferActiveSkillsScope,
+  detectSkillsAgents,
+  skillsStatePathForScope,
+  buildSkillsPlan,
+  isSkillsPlanCurrent,
+  runSkillsCommand,
+  registerSkillsCommand
+};