deepline 0.3.113 → 0.3.114

package/dist/cli/index.js

@@ -1298,7 +1298,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.113",
+  version: "0.3.114",
   updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
   packageCapabilities: {
     updatePreferences: 1
@@ -1514,8 +1514,22 @@ function readPluginSkillsVersion() {
     return "";
   }
 }
+var KNOWN_SKILL_AGENTS = [
+  "antigravity",
+  "claude-code",
+  "cline",
+  "codex",
+  "cursor",
+  "gemini-cli",
+  "windsurf"
+];
+function skillsAgentPathSegment(agent) {
+  if (agent === "*") return "all";
+  const slug = agent.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "");
+  return slug || "agent";
+}
 function sdkSkillsVersionPath(baseUrl, agents = []) {
-  const suffix = agents.length > 0 ? `-${agents.join("-")}` : "";
+  const suffix = agents.length > 0 ? `-${agents.map(skillsAgentPathSegment).join("-")}` : "";
   return (0, import_node_path2.join)(sdkCliStateDirPath(baseUrl), `skills${suffix}-version`);
 }
 function legacySdkSkillsVersionPath(baseUrl) {
@@ -4847,7 +4861,7 @@ function resolveToolExecuteTimeoutMs(toolId, input2) {
   if (usesExtendedBetterContactLauncherBudget(normalized)) {
     return BETTERCONTACT_LAUNCHER_CLIENT_TIMEOUT_MS;
   }
-  return normalized === "deeplineagent" || normalized === "deeplineagent_deeplineagent" || normalized === "ai_inference" || normalized === "deeplineagent_ai_inference" || normalized === "aiinference" ? DEEPLINEAGENT_EXECUTE_TIMEOUT_MS : void 0;
+  return normalized === "deeplineagent" || normalized === "deeplineagent_deeplineagent" || normalized === "ai_inference" || normalized === "deeplineagent_ai_inference" || normalized === "ai_evaluate" || normalized === "deeplineagent_ai_evaluate" || normalized === "aiinference" ? DEEPLINEAGENT_EXECUTE_TIMEOUT_MS : void 0;
 }
 var RUNS_FAILED_LOG_LIMIT = 20;
 var RUN_LOGS_PAGE_LIMIT = 1e3;
@@ -8196,7 +8210,9 @@ var import_node_fs3 = require("fs");
 var import_node_os3 = require("os");
 var import_node_path3 = require("path");
 var CHECK_TIMEOUT_MS = 2e3;
-var SDK_COMPATIBILITY_CACHE_TTL_MS = 5 * 60 * 1e3;
+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 shouldSkipCompatibilityCheck() {
   const value = process.env.DEEPLINE_SKIP_SDK_COMPAT_CHECK?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes";
@@ -8225,7 +8241,29 @@ function legacyCompatibilityCacheKey(baseUrl, command) {
     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();
@@ -8238,14 +8276,31 @@ function readCachedCompatibility(baseUrl, command, skillsVersion) {
       (0, import_node_fs3.readFileSync)(cachePath, "utf8")
     );
     const entry = parsed.entries?.[compatibilityCacheKey(baseUrl, command, skillsVersion)] ?? (useLegacyCache ? parsed.entries?.[legacyCompatibilityCacheKey(baseUrl, command)] : void 0);
-    if (!entry || Date.now() - entry.savedAt > SDK_COMPATIBILITY_CACHE_TTL_MS) {
+    if (!entry || !isSavedWithin(entry.savedAt, SDK_COMPATIBILITY_CACHE_TTL_MS, Date.now())) {
       return null;
     }
-    return entry.response;
+    return entry;
   } catch {
     return null;
   }
 }
+function invalidateCachedCompatibility(baseUrl, command, skillsVersion) {
+  try {
+    const path = sdkCompatibilityCachePath(baseUrl);
+    const legacyPath = legacySdkCompatibilityCachePath();
+    const cachePath = !(0, import_node_fs3.existsSync)(path) && (0, import_node_fs3.existsSync)(legacyPath) ? legacyPath : path;
+    if (!(0, import_node_fs3.existsSync)(cachePath)) return;
+    const existing = JSON.parse(
+      (0, import_node_fs3.readFileSync)(cachePath, "utf8")
+    );
+    const entries = existing.entries ?? {};
+    delete entries[compatibilityCacheKey(baseUrl, command, skillsVersion)];
+    delete entries[legacyCompatibilityCacheKey(baseUrl, command)];
+    (0, import_node_fs3.writeFileSync)(cachePath, `${JSON.stringify({ entries }, null, 2)}
+`);
+  } catch {
+  }
+}
 function writeCachedCompatibility(baseUrl, command, skillsVersion, response) {
   try {
     const path = sdkCompatibilityCachePath(baseUrl);
@@ -8266,7 +8321,10 @@ async function checkSdkCompatibility(baseUrl, options = {}) {
     return { response: null, error: null };
   }
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
+  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);
@@ -8288,14 +8346,17 @@ async function checkSdkCompatibility(baseUrl, options = {}) {
       signal: controller.signal
     });
     const data = await response.json().catch(() => null);
-    if (data) {
-      writeCachedCompatibility(
-        baseUrl,
-        options.command,
-        options.skillsVersion,
-        data
+    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(
@@ -8304,6 +8365,13 @@ async function checkSdkCompatibility(baseUrl, options = {}) {
       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 {
@@ -35109,7 +35177,19 @@ function renderMonitorGet(payload) {
     const field = asRecord2(value);
     const path = asString(field?.path);
     const description = asString(field?.description);
-    return path ? [{ path, description }] : [];
+    const semantics = asString(field?.semantics);
+    const applicability = asString(field?.applicability);
+    const grammar = asRecord2(field?.grammar);
+    const grammarSyntax = asString(grammar?.syntax);
+    return path ? [
+      {
+        path,
+        description,
+        semantics,
+        applicability,
+        grammarSyntax
+      }
+    ] : [];
   }) : [];
   if (specFields.length > 0) {
     lines.push("", "Monitor spec:");
@@ -35117,6 +35197,15 @@ function renderMonitorGet(payload) {
       lines.push(
         `  ${field.path}${field.description ? ` \u2014 ${field.description}` : ""}`
       );
+      if (field.semantics && field.semantics !== field.description) {
+        lines.push(`    Behavior: ${field.semantics}`);
+      }
+      if (field.applicability) {
+        lines.push(`    Applies to: ${field.applicability}`);
+      }
+      if (field.grammarSyntax) {
+        lines.push(`    Format: ${field.grammarSyntax}`);
+      }
     }
   }
   lines.push("", `Current SQL listener consumers (${boundPlays.length}):`);
@@ -35881,8 +35970,10 @@ Notes:
   Read-only. Returns the exact editable definition, selected Deepline pricing,
   billing state, output streams, dependent published plays, and monitor_spec.
   When monitor_spec.available is true, its fields describe the deployed type's
-  editable fields and constraints; otherwise use the stored definition and check
-  before proposing an update so scope and downstream effects are visible.
+  editable fields, constraints, and provider-specific behavior. For TAMRadar,
+  this includes the effective updates_since precision and engagement timing
+  rules. Otherwise use the stored definition and check before proposing an
+  update so scope and downstream effects are visible.
 
 Examples:
   deepline monitors get my-monitor --json
@@ -38608,7 +38699,6 @@ async function maybeReportSdkCliFailure(input2) {
 
 // src/cli/skills-sync.ts
 var CHECK_TIMEOUT_MS2 = 3e3;
-var SKILLS_SYNC_CLAIM_MAX_AGE_MS = 60 * 60 * 1e3;
 function shouldSkipSkillsSync() {
   if (detectAgentRuntime() === "claude_cowork") {
     return true;
@@ -38619,65 +38709,286 @@ function shouldSkipSkillsSync() {
 function unavailableSkillsNoticePath(baseUrl) {
   return (0, import_node_path20.join)(sdkCliStateDirPath(baseUrl), "skills-sync-unavailable-version");
 }
-function failedSkillsSyncPath(baseUrl, agents) {
+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 (0, import_node_path20.join)(
     sdkCliStateDirPath(baseUrl),
-    `skills-sync-failed-${agents.join("-")}-version`
+    `skills-sync-in-progress-${agentLeaseSegment(agent)}`
   );
 }
-function inProgressSkillsSyncPath(baseUrl, agents) {
-  return (0, import_node_path20.join)(
-    sdkCliStateDirPath(baseUrl),
-    `skills-sync-in-progress-${agents.join("-")}`
+function readInProgressSkillsSyncLeaseFromDir(dir) {
+  const claim = readMarkedSkillsSyncVersion((0, import_node_path20.join)(dir, "claim"));
+  const [version = "", startedAt = ""] = claim.split(" ");
+  const pidRaw = readMarkedSkillsSyncVersion((0, import_node_path20.join)(dir, "pid"));
+  return {
+    claimToken: version && startedAt ? `${version} ${startedAt}` : "",
+    version,
+    startedAt: Number(startedAt),
+    pid: /^\d+$/.test(pidRaw) ? Number(pidRaw) : null,
+    owner: readMarkedSkillsSyncVersion((0, import_node_path20.join)(dir, "owner"))
+  };
+}
+function readInProgressSkillsSyncLease(baseUrl, agent) {
+  return readInProgressSkillsSyncLeaseFromDir(
+    inProgressSkillsSyncPath(baseUrl, agent)
   );
 }
-function removeSkillsSyncClaim(path, token) {
+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 {
-    (0, import_node_fs18.unlinkSync)((0, import_node_path20.join)(path, token));
-    (0, import_node_fs18.rmdirSync)(path);
-  } catch {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
   }
 }
-function claimSkillsSync(baseUrl, agents) {
-  const path = inProgressSkillsSyncPath(baseUrl, agents);
+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 {
-    (0, import_node_fs18.mkdirSync)((0, import_node_path20.dirname)(path), { recursive: true });
+    (0, import_node_fs18.renameSync)(path, holding);
+    return holding;
   } catch {
-    return { status: "unavailable" };
+    return null;
   }
-  const token = (0, import_node_crypto10.randomUUID)();
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    const pendingPath = `${path}-pending-${token}`;
+}
+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()}`;
+    (0, import_node_fs18.mkdirSync)(staging);
+    (0, import_node_fs18.writeFileSync)((0, import_node_path20.join)(staging, "claim"), `${claimToken}
+`, "utf-8");
+    (0, import_node_fs18.writeFileSync)((0, import_node_path20.join)(staging, "owner"), `${owner}
+`, "utf-8");
     try {
-      (0, import_node_fs18.mkdirSync)(pendingPath);
-      (0, import_node_fs18.writeFileSync)((0, import_node_path20.join)(pendingPath, token), "", { flag: "wx" });
-      (0, import_node_fs18.renameSync)(pendingPath, path);
-      return { status: "claimed", token };
-    } catch {
-      removeSkillsSyncClaim(pendingPath, token);
-      if (!(0, import_node_fs18.existsSync)(path)) continue;
+      (0, import_node_fs18.renameSync)(staging, dir);
+    } catch (error) {
+      (0, import_node_fs18.rmSync)(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 {
+    (0, import_node_fs18.mkdirSync)((0, import_node_path20.dirname)(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" };
+  }
+  (0, import_node_fs18.rmSync)(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 = (0, import_node_crypto10.randomUUID)();
+  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);
     }
-    if (attempt > 0) return { status: "held" };
+    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 {
-      if (Date.now() - (0, import_node_fs18.statSync)(path).mtimeMs <= SKILLS_SYNC_CLAIM_MAX_AGE_MS) {
-        return { status: "held" };
+      (0, import_node_fs18.writeFileSync)(
+        (0, import_node_path20.join)(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 {
+        (0, import_node_fs18.rmSync)(dir, { recursive: true, force: true });
+      } catch {
       }
-      const owners = (0, import_node_fs18.readdirSync)(path);
-      if (owners.length === 0) {
-        (0, import_node_fs18.rmdirSync)(path);
+      continue;
+    }
+    const tombstone = quarantine(dir, "release");
+    if (!tombstone) continue;
+    try {
+      if (readInProgressSkillsSyncLeaseFromDir(tombstone).claimToken !== claimToken) {
+        (0, import_node_fs18.renameSync)(tombstone, dir);
         continue;
       }
-      if (owners.length !== 1) return { status: "held" };
-      (0, import_node_fs18.renameSync)(path, `${path}-stale-${owners[0]}`);
     } catch {
-      return { status: "held" };
+    }
+    (0, import_node_fs18.rmSync)(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((resolve21) => setTimeout(resolve21, pollMs));
+  }
+}
+function skillsInstallLeasePath(baseUrl, agents) {
+  return sortedLeaseAgents(agents).map((agent) => inProgressSkillsSyncPath(baseUrl, agent)).join(", ");
+}
+function deferredSkillsNoticePath(baseUrl, agents) {
+  return (0, import_node_path20.join)(
+    sdkCliStateDirPath(baseUrl),
+    `skills-sync-notice-${sortedLeaseAgents(agents).map(agentLeaseSegment).join("-")}`
+  );
+}
+function deferSkillsNotice(baseUrl, agents) {
+  const path = deferredSkillsNoticePath(baseUrl, agents);
+  return (text) => {
+    try {
+      (0, import_node_fs18.mkdirSync)((0, import_node_path20.dirname)(path), { recursive: true });
+      (0, import_node_fs18.appendFileSync)(path, `${text.trimEnd()}
+`, "utf-8");
+    } catch {
+    }
+  };
+}
+function flushDeferredSkillsNotices(baseUrl, agents) {
+  const path = deferredSkillsNoticePath(baseUrl, agents);
+  if (!(0, import_node_fs18.existsSync)(path)) return;
+  const tombstone = quarantine(path, "consuming");
+  if (!tombstone) return;
+  let text = "";
+  try {
+    text = (0, import_node_fs18.readFileSync)(tombstone, "utf-8");
+  } catch {
+    return;
+  } finally {
+    try {
+      (0, import_node_fs18.unlinkSync)(tombstone);
+    } catch {
     }
   }
-  return { status: "held" };
+  if (text.trim()) writeSdkSkillsStatusLine(text.trimEnd());
 }
-function clearSkillsSyncClaim(baseUrl, agents, token) {
-  const path = inProgressSkillsSyncPath(baseUrl, agents);
-  removeSkillsSyncClaim(path, token);
+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 = (0, import_node_child_process2.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 (0, import_node_path20.join)(
+    sdkCliStateDirPath(baseUrl),
+    `skills-sync-failed-${agents.map(agentLeaseSegment).join("-")}-version`
+  );
 }
 function hasMarkedSkillsSyncVersion(path, version) {
   return Boolean(version) && readMarkedSkillsSyncVersion(path) === version;
@@ -38699,12 +39010,12 @@ function writeMarkedSkillsSyncVersion(path, version) {
     return false;
   }
 }
-function writeUnavailableSkillsNotice(baseUrl, remoteVersion, skillNames) {
+function writeUnavailableSkillsNotice(baseUrl, remoteVersion, skillNames, notice = writeSdkSkillsStatusLine) {
   const path = unavailableSkillsNoticePath(baseUrl);
   if (hasMarkedSkillsSyncVersion(path, remoteVersion)) return;
   writeMarkedSkillsSyncVersion(path, remoteVersion);
   const manualCommand = `npx ${buildSkillsInstallArgs(baseUrl, skillNames).join(" ")}`;
-  writeSdkSkillsStatusLine(
+  notice(
     `Deepline agent skills are out of date, but neither \`bunx\` nor \`npx\` is available. Install Node.js/npm or Bun, then run:
 ${manualCommand}`
   );
@@ -38889,7 +39200,7 @@ function runOneSkillsInstall(install) {
     });
   });
 }
-async function runSkillsInstall(installs, agents) {
+async function runSkillsInstall(installs, agents, notice = writeSdkSkillsStatusLine) {
   const failures = [];
   for (const install of installs) {
     const result = await runOneSkillsInstall(install);
@@ -38899,15 +39210,14 @@ async function runSkillsInstall(installs, agents) {
   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(
+  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()}
-`
+` : "") + `To temporarily suppress automatic skills sync: ${temporarySkillsSyncSkipCommand()}`
   );
   return {
     installed: false,
@@ -38982,72 +39292,132 @@ async function syncSdkSkillsIfNeeded(baseUrl, options = {}) {
   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)) {
+  if (options.mode === "detached" && agents.length > 0) {
+    flushDeferredSkillsNotices(baseUrl, agents);
+  }
+  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)
+      );
+      return;
+    }
+    if (options.mode === "detached" && agents.length > 0) {
+      const outcome = claimAndSpawnDetachedSkillsSync(
+        baseUrl,
+        agents,
+        update.remoteVersion,
+        options.spawnDetached ?? spawnDetachedSkillsSyncChild
+      );
+      if (outcome === "held") return;
+      if (outcome === "claimed") {
+        writeSdkSkillsStatusLine(
+          "Deepline skills changed; refreshing agent skills in the background."
+        );
+        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 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);
+    writeUnavailableSkillsNotice(
+      baseUrl,
+      update.remoteVersion,
+      skillNames,
+      notice
+    );
     return;
   }
   const installs = resolveSkillsInstallCommands(baseUrl, skillNames, agents);
   if (installs.length === 0) {
-    writeUnavailableSkillsNotice(baseUrl, update.remoteVersion, skillNames);
+    writeUnavailableSkillsNotice(
+      baseUrl,
+      update.remoteVersion,
+      skillNames,
+      notice
+    );
     return;
   }
-  const claim = claimSkillsSync(baseUrl, agents);
-  if (claim.status === "held") return;
-  try {
-    if (hasFailedSkillsSync(baseUrl, update.remoteVersion, agents) || readSdkSkillsLocalVersion(baseUrl) === update.remoteVersion) {
-      return;
-    }
+  if (notices === "print") {
     writeSdkSkillsStatusLine(
       "Deepline skills changed; syncing agent skills..."
     );
-    const installResult = await runSkillsInstall(installs, agents);
-    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
-      });
-      return;
-    }
-    runLegacySkillsCleanup(agents);
-    writeSdkSkillsLocalVersion(baseUrl, update.remoteVersion, agents);
-    clearUnavailableSkillsNotice(baseUrl);
-    clearFailedSkillsSync(baseUrl, agents);
-    writeSdkSkillsStatusLine("Deepline agent skills are up to date.");
-  } finally {
-    if (claim.status === "claimed") {
-      clearSkillsSyncClaim(baseUrl, agents, claim.token);
-    }
   }
+  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
+    });
+    return;
+  }
+  runLegacySkillsCleanup(agents);
+  writeSdkSkillsLocalVersion(baseUrl, update.remoteVersion, agents);
+  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",
@@ -39304,6 +39674,45 @@ async function runSkillsCommand(options, dependencies = {}) {
       )
     ]);
   }
+  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(input2) {
+  const { options, dependencies, baseUrl, scope, root, agents, plan } = input2;
   process.stderr.write(
     `Replacing Deepline skills for ${agents.join(", ")} (${scope})...
 `
@@ -39416,6 +39825,31 @@ Examples:
   ).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
+    });
+  });
 }
 
 // src/cli/commands/setup.ts
@@ -43439,14 +43873,15 @@ Examples:
   deepline tools describe hunter_email_verifier --json
   deepline tools describe deeplineagent --model openai/gpt-5.5 --json
   deepline tools describe ai_inference --estimate-payload @payload.json --json
+  deepline tools describe ai_evaluate --estimate-payload @payload.json --json
   deepline tools execute hunter_email_verifier --input '{"email":"a@b.com"}'
 `
   ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option(
     "--model <model>",
-    "For deeplineagent, include AI Gateway model/provider option metadata"
+    "For language tools, include AI Gateway metadata; for ai_evaluate, set the quote payload model"
   ).option(
     "--estimate-payload <payload>",
-    "Quote an ai_inference or deeplineagent JSON payload (inline or @file)"
+    "Quote an ai_evaluate, ai_inference, or deeplineagent JSON payload (inline or @file)"
   ).option("--pricing-only", "Only print pricing and billing semantics").option("--schema-only", "Only print input schema fields").option(
     "--examples-only",
     "Only print runnable examples and sample payloads"
@@ -43548,9 +43983,9 @@ async function getTool(toolId, options = {}) {
   }
   let inferenceQuote = null;
   if (options.estimatePayload) {
-    if (toolId !== "deeplineagent" && toolId !== "ai_inference") {
+    if (toolId !== "deeplineagent" && toolId !== "ai_inference" && toolId !== "ai_evaluate") {
       console.error(
-        "--estimate-payload is only supported for deeplineagent and ai_inference."
+        "--estimate-payload is only supported for ai_evaluate, deeplineagent, and ai_inference."
       );
       return 2;
     }
@@ -43564,7 +43999,7 @@ async function getTool(toolId, options = {}) {
     inferenceQuote = await client2.quoteInferenceTool(toolId, estimatePayload);
   }
   const modelDescription = options.model && (toolId === "deeplineagent" || toolId === "ai_inference") ? await client2.describeModel(options.model) : null;
-  if (options.model && !modelDescription) {
+  if (options.model && !modelDescription && toolId !== "ai_evaluate") {
     console.error(
       "--model is only supported for deeplineagent and ai_inference."
     );
@@ -46142,7 +46577,7 @@ Exit codes:
 `
   );
   program.hook("preAction", async (_thisCommand, actionCommand) => {
-    if (actionCommand.name() === "version" || actionCommand.name() === "update" || actionCommand.name() === "setup" || actionCommand.name() === "skills" || actionCommand.name() === "doctor" || isAutoUpdateSettingsInvocation() || isDeprecatedCommandInvocation()) {
+    if (actionCommand.name() === "version" || actionCommand.name() === "update" || actionCommand.name() === "setup" || actionCommand.name() === "skills" || actionCommand.name() === SKILLS_AUTO_SYNC_COMMAND || actionCommand.name() === "doctor" || isAutoUpdateSettingsInvocation() || isDeprecatedCommandInvocation()) {
       return;
     }
     const compatibilityCommand = compatibilityCommandPath(actionCommand) || actionCommand.name();
@@ -46150,18 +46585,42 @@ Exit codes:
       progress?.phase("checking sdk compatibility");
     }
     const baseUrl = autoDetectBaseUrl().replace(/\/$/, "");
+    flushDeferredSkillsSyncNotices(baseUrl);
     const shouldDeferSkillsSync = shouldDeferSkillsSyncForCommand();
     const skillsVersion = shouldDeferSkillsSync ? void 0 : readSdkSkillsLocalVersion(baseUrl);
-    const compatibility = await traceCliSpan(
+    const trusted = readTrustedCleanCompatibility(
+      baseUrl,
+      compatibilityCommand,
+      skillsVersion
+    );
+    const fastDeadline = trusted === null && readFreshCleanCompatibility(
+      baseUrl,
+      compatibilityCommand,
+      skillsVersion
+    ) !== null;
+    if (trusted) {
+      recordCliTrace({
+        phase: "cli.sdk_compatibility",
+        ms: 0,
+        ok: true,
+        baseUrl,
+        command: compatibilityCommand,
+        skillsVersion: skillsVersion ?? null,
+        source: "trusted_cache"
+      });
+    }
+    const compatibility = trusted ? { response: trusted, error: null } : await traceCliSpan(
       "cli.sdk_compatibility",
       {
         baseUrl,
         command: compatibilityCommand,
-        skillsVersion: skillsVersion ?? null
+        skillsVersion: skillsVersion ?? null,
+        fastDeadline
       },
       () => checkSdkCompatibility(baseUrl, {
         command: compatibilityCommand,
-        skillsVersion
+        skillsVersion,
+        ...fastDeadline ? { timeoutMs: SDK_COMPATIBILITY_FAST_DEADLINE_MS } : {}
       })
     );
     if (compatibility.error) {
@@ -46184,7 +46643,8 @@ Exit codes:
         "cli.sdk_skills_sync",
         { baseUrl },
         () => syncSdkSkillsIfNeeded(baseUrl, {
-          update: skillsUpdate
+          update: skillsUpdate,
+          mode: "detached"
         })
       );
     }