@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-CBCW5R5J.js

@@ -0,0 +1,484 @@
+import {
+  contextConfigPath,
+  intervalElapsed,
+  loadContextConfig
+} from "./chunk-NQ7IQ5XT.js";
+import {
+  fileExists,
+  writeJson
+} from "./chunk-77V75A7O.js";
+
+// src/lifecycle/cursor-update-awareness.ts
+import { access, readFile } from "fs/promises";
+import path from "path";
+var DEFAULT_CURSOR_CHANGELOG_URL = "https://cursor.com/changelog";
+var CHANGELOG_FETCH_TIMEOUT_MS = 15e3;
+var CURSOR_VERSION_MAJOR_MAX = 20;
+var INVENTORY_REL = path.join("docs", "cursor-native-audit.md");
+var FEATURES_REL = path.join("docs", "cursor-3-features.md");
+async function resolveInventoryRoot(cwd) {
+  let dir = path.resolve(cwd);
+  for (; ; ) {
+    try {
+      await access(path.join(dir, INVENTORY_REL));
+      return dir;
+    } catch {
+    }
+    if (await fileExists(path.join(dir, ".git"))) break;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function missingInventoryMessage() {
+  return `Missing inventory at ${INVENTORY_REL}. Run from the kit/repo root that contains that file, or pass --cwd <path>.`;
+}
+var DEFAULT_PREFS = {
+  enabled: false,
+  intervalDays: 7,
+  lastCheckedAt: null,
+  lastSeenCursorVersion: null,
+  changelogUrl: DEFAULT_CURSOR_CHANGELOG_URL
+};
+var CONVEYOR_HINT = "Confirmed gaps: Ask HITL then `/backlog-add` or `/dogfood` (lane-aware). Never auto Field Reports. Native-audit version prose owned by parked Marketplace plan.";
+function readCursorUpdateCheckPrefs(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return { ...DEFAULT_PREFS };
+  }
+  const raw = config.cursorUpdateCheck;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { ...DEFAULT_PREFS };
+  }
+  const uc = raw;
+  const intervalDays = typeof uc.intervalDays === "number" && Number.isInteger(uc.intervalDays) && uc.intervalDays >= 1 ? uc.intervalDays : DEFAULT_PREFS.intervalDays;
+  const changelogUrl = typeof uc.changelogUrl === "string" && uc.changelogUrl.startsWith("https://") ? uc.changelogUrl : DEFAULT_PREFS.changelogUrl;
+  return {
+    enabled: uc.enabled === true,
+    intervalDays,
+    lastCheckedAt: typeof uc.lastCheckedAt === "string" ? uc.lastCheckedAt : null,
+    lastSeenCursorVersion: typeof uc.lastSeenCursorVersion === "string" ? uc.lastSeenCursorVersion : null,
+    changelogUrl
+  };
+}
+async function stampCursorUpdateCheck(cwd, patch) {
+  const existing = await loadContextConfig(cwd) ?? {};
+  const prev = existing.cursorUpdateCheck && typeof existing.cursorUpdateCheck === "object" ? { ...existing.cursorUpdateCheck } : {};
+  const nextSeen = patch.lastSeenCursorVersion !== void 0 ? patch.lastSeenCursorVersion : void 0;
+  if (nextSeen !== void 0 && nextSeen !== null && !isPlausibleCursorVersion(nextSeen)) {
+    existing.cursorUpdateCheck = {
+      ...DEFAULT_PREFS,
+      ...prev,
+      lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeJson(contextConfigPath(cwd), existing);
+    return;
+  }
+  existing.cursorUpdateCheck = {
+    ...DEFAULT_PREFS,
+    ...prev,
+    lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...nextSeen !== void 0 ? { lastSeenCursorVersion: nextSeen } : {}
+  };
+  await writeJson(contextConfigPath(cwd), existing);
+}
+function isPlausibleCursorVersion(version) {
+  const parts = String(version).split(".");
+  if (parts.length < 2 || parts.length > 3) return false;
+  const major = Number(parts[0]);
+  const minor = Number(parts[1]);
+  const patch = parts.length === 3 ? Number(parts[2]) : 0;
+  if ([major, minor, patch].some((n) => Number.isNaN(n) || n < 0)) return false;
+  if (major >= 2e3 || major > CURSOR_VERSION_MAJOR_MAX) return false;
+  if (minor > 999 || patch > 999) return false;
+  return true;
+}
+function extractLatestCursorVersion(changelogText) {
+  const text = String(changelogText ?? "");
+  const candidates = [];
+  const push = (major, minor, patch) => {
+    const version = patch !== void 0 ? `${major}.${minor}.${patch}` : `${major}.${minor}`;
+    if (isPlausibleCursorVersion(version)) candidates.push(version);
+  };
+  for (const m of text.matchAll(/<span class="label">(\d+)\.(\d+)(?:\.(\d+))?<\/span>/gi)) {
+    push(m[1] ?? "", m[2] ?? "", m[3]);
+  }
+  for (const m of text.matchAll(
+    /\b(\d+)\.(\d+)(?:\.(\d+))?\b(?=[^\n]{0,48}(?:Changelog|Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec))/gi
+  )) {
+    push(m[1] ?? "", m[2] ?? "", m[3]);
+  }
+  if (candidates.length === 0) {
+    for (const m of text.matchAll(/\b(\d+)\.(\d+)(?:\.(\d+))?\b/g)) {
+      push(m[1] ?? "", m[2] ?? "", m[3]);
+    }
+  }
+  let best = null;
+  let bestScore = -1;
+  for (const version of candidates) {
+    const parts = version.split(".").map(Number);
+    const score = (parts[0] ?? 0) * 1e6 + (parts[1] ?? 0) * 1e3 + (parts[2] ?? 0);
+    if (score > bestScore) {
+      bestScore = score;
+      best = version;
+    }
+  }
+  return best;
+}
+function compareCursorVersion(a, b) {
+  const pa = a.split(".").map((p) => Number(p));
+  const pb = b.split(".").map((p) => Number(p));
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const da = pa[i] ?? 0;
+    const db = pb[i] ?? 0;
+    if (Number.isNaN(da) || Number.isNaN(db)) return 0;
+    if (da !== db) return da < db ? -1 : 1;
+  }
+  return 0;
+}
+function parseInventoryRefreshed(markdown) {
+  const m = markdown.match(/last refreshed\s+\*\*(\d{4}-\d{2}-\d{2})\*\*/i);
+  return m?.[1] ?? null;
+}
+function parseOpenActionIds(markdown) {
+  const ids = [];
+  for (const line of markdown.split("\n")) {
+    const m = line.match(/^\|\s*([A-Z]\d+)\s*\|\s*Open\s*\|/i);
+    if (m?.[1]) ids.push(m[1]);
+  }
+  return ids;
+}
+function parseFeatureMapNames(markdown) {
+  const names = [];
+  let inTable = false;
+  for (const line of markdown.split("\n")) {
+    if (line.startsWith("| Feature |")) {
+      inTable = true;
+      continue;
+    }
+    if (inTable) {
+      if (!line.startsWith("|")) break;
+      if (line.includes("---")) continue;
+      const cells = line.split("|").map((c) => c.trim());
+      const name = cells[1];
+      if (name && name.toLowerCase() !== "feature") names.push(name);
+    }
+  }
+  return names;
+}
+var HEADING_NOISE = /* @__PURE__ */ new Set([
+  "changelog",
+  "improvements",
+  "bug fixes",
+  "get started",
+  "settings",
+  "powered by",
+  "powered by cloud agents",
+  "shared context",
+  "desktop improvements",
+  "desktop bug fixes",
+  "agents window improvements",
+  "agents window bug fixes",
+  "what's new in cursor",
+  "latest updates",
+  "release notes"
+]);
+var MAX_FEATURE_KEYWORD_GAPS = 12;
+function visibleTextFromHtml(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<svg[\s\S]*?<\/svg>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&#?\w+;/g, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeFeatureKeyword(raw) {
+  let value = raw.replace(/^#+\s*/, "").replace(/\s+/g, " ").trim();
+  value = value.replace(/[.,:;]+$/g, "");
+  value = value.replace(/\s+(improvements|bug fixes)$/i, "").trim();
+  if (!value) return null;
+  if (value.startsWith("/")) {
+    const cmd = value.match(/^\/[a-z][a-z0-9-]{1,32}$/i);
+    return cmd?.[0] ? cmd[0].toLowerCase() : null;
+  }
+  const lower = value.toLowerCase();
+  if (HEADING_NOISE.has(lower)) return null;
+  if (/^\d+(\.\d+){1,2}$/.test(value)) return null;
+  if (value.length < 4 || value.length > 80) return null;
+  return value;
+}
+function slugifyFeatureKeyword(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+}
+function extractChangelogFeatureKeywords(changelogText) {
+  const text = String(changelogText ?? "");
+  const buckets = {
+    slash: [],
+    h1: [],
+    h2: [],
+    h3: []
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const push = (raw, bucket) => {
+    const keyword = normalizeFeatureKeyword(raw);
+    if (!keyword) return;
+    const key = keyword.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    buckets[bucket].push(keyword);
+  };
+  for (const match of text.matchAll(/<h1[^>]*>([\s\S]*?)<\/h1>/gi)) {
+    push(visibleTextFromHtml(match[1] ?? ""), "h1");
+  }
+  for (const match of text.matchAll(/<h2[^>]*>([\s\S]*?)<\/h2>/gi)) {
+    push(visibleTextFromHtml(match[1] ?? ""), "h2");
+  }
+  for (const match of text.matchAll(/<h3[^>]*>([\s\S]*?)<\/h3>/gi)) {
+    push(visibleTextFromHtml(match[1] ?? ""), "h3");
+  }
+  for (const match of text.matchAll(/^#\s+(.+)$/gm)) {
+    push(match[1] ?? "", "h1");
+  }
+  for (const match of text.matchAll(/^##\s+(.+)$/gm)) {
+    push(match[1] ?? "", "h2");
+  }
+  for (const match of text.matchAll(/^###\s+(.+)$/gm)) {
+    push(match[1] ?? "", "h3");
+  }
+  for (const match of text.matchAll(/(^|[\s>`(])(\/[a-z][a-z0-9-]{1,32})(?![/\w-])/gi)) {
+    push(match[2] ?? "", "slash");
+  }
+  return [...buckets.slash, ...buckets.h1, ...buckets.h2, ...buckets.h3];
+}
+function findMissingInventoryKeywords(keywords, haystack) {
+  const lower = String(haystack ?? "").toLowerCase();
+  return keywords.filter((keyword) => {
+    const needle = keyword.toLowerCase();
+    if (lower.includes(needle)) return false;
+    if (needle.startsWith("/") && lower.includes(needle.slice(1))) return false;
+    return true;
+  });
+}
+async function defaultFetchText(url) {
+  if (!url.startsWith("https://")) {
+    throw new Error(`Refusing non-HTTPS changelog URL: ${url}`);
+  }
+  const res = await fetch(url, {
+    headers: { Accept: "text/html,text/plain;q=0.9,*/*;q=0.8" },
+    redirect: "follow",
+    signal: AbortSignal.timeout(CHANGELOG_FETCH_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    throw new Error(`Changelog fetch failed: HTTP ${res.status}`);
+  }
+  return res.text();
+}
+function baseResult(partial) {
+  return {
+    ...partial,
+    applyRecommended: false,
+    fieldReportRecommended: false,
+    conveyorHint: CONVEYOR_HINT
+  };
+}
+async function checkCursorUpdateAwareness(cwd, options = {}) {
+  const inventoryRoot = await resolveInventoryRoot(cwd);
+  const prefs = readCursorUpdateCheckPrefs(
+    inventoryRoot ? await loadContextConfig(inventoryRoot) : null
+  );
+  const changelogUrl = options.changelogUrl ?? prefs.changelogUrl;
+  if (options.respectPrefs) {
+    if (!prefs.enabled) {
+      return baseResult({
+        status: "skipped-disabled",
+        inventoryRoot,
+        inventoryPath: INVENTORY_REL,
+        featuresPath: FEATURES_REL,
+        changelogUrl,
+        latestCursorVersion: null,
+        lastSeenCursorVersion: prefs.lastSeenCursorVersion,
+        inventoryRefreshed: null,
+        openActionIds: [],
+        gaps: [],
+        message: "cursorUpdateCheck.enabled is false (opt-in). Set true in .cursor/context/config.json to nudge."
+      });
+    }
+    if (!intervalElapsed(prefs.lastCheckedAt, prefs.intervalDays)) {
+      return baseResult({
+        status: "skipped-interval",
+        inventoryRoot,
+        inventoryPath: INVENTORY_REL,
+        featuresPath: FEATURES_REL,
+        changelogUrl,
+        latestCursorVersion: null,
+        lastSeenCursorVersion: prefs.lastSeenCursorVersion,
+        inventoryRefreshed: null,
+        openActionIds: [],
+        gaps: [],
+        message: `Within cursorUpdateCheck.intervalDays (${prefs.intervalDays}); last check ${prefs.lastCheckedAt}.`
+      });
+    }
+  }
+  if (!inventoryRoot) {
+    return baseResult({
+      status: "error",
+      inventoryRoot: null,
+      inventoryPath: INVENTORY_REL,
+      featuresPath: FEATURES_REL,
+      changelogUrl,
+      latestCursorVersion: null,
+      lastSeenCursorVersion: prefs.lastSeenCursorVersion,
+      inventoryRefreshed: null,
+      openActionIds: [],
+      gaps: [],
+      message: missingInventoryMessage()
+    });
+  }
+  const inventoryPath = path.join(inventoryRoot, INVENTORY_REL);
+  const featuresPath = path.join(inventoryRoot, FEATURES_REL);
+  let inventoryMd;
+  try {
+    inventoryMd = await readFile(inventoryPath, "utf8");
+  } catch {
+    return baseResult({
+      status: "error",
+      inventoryRoot,
+      inventoryPath: INVENTORY_REL,
+      featuresPath: FEATURES_REL,
+      changelogUrl,
+      latestCursorVersion: null,
+      lastSeenCursorVersion: prefs.lastSeenCursorVersion,
+      inventoryRefreshed: null,
+      openActionIds: [],
+      gaps: [],
+      message: missingInventoryMessage()
+    });
+  }
+  const inventoryRefreshed = parseInventoryRefreshed(inventoryMd);
+  const openActionIds = parseOpenActionIds(inventoryMd);
+  const gaps = [];
+  let featuresMd = "";
+  for (const id of openActionIds) {
+    gaps.push({
+      id: `open-action-${id}`,
+      severity: "advisory",
+      path: INVENTORY_REL,
+      evidence: `Action item ${id} is Open in the native-audit inventory`,
+      suggestedRoute: "backlog-add"
+    });
+  }
+  if (inventoryRefreshed) {
+    const refreshedMs = Date.parse(inventoryRefreshed);
+    if (!Number.isNaN(refreshedMs)) {
+      const ageDays = (Date.now() - refreshedMs) / (24 * 60 * 60 * 1e3);
+      if (ageDays > 45) {
+        gaps.push({
+          id: "inventory-stale",
+          severity: "stale",
+          path: INVENTORY_REL,
+          evidence: `Inventory last refreshed ${inventoryRefreshed} (>45 days). Version-prose refresh owned by parked Marketplace plan; awareness reports only.`,
+          suggestedRoute: "none"
+        });
+      }
+    }
+  }
+  try {
+    featuresMd = await readFile(featuresPath, "utf8");
+    if (parseFeatureMapNames(featuresMd).length === 0) {
+      gaps.push({
+        id: "features-map-empty",
+        severity: "info",
+        path: FEATURES_REL,
+        evidence: "Secondary feature map has no Feature table rows",
+        suggestedRoute: "none"
+      });
+    }
+  } catch {
+    gaps.push({
+      id: "features-map-missing",
+      severity: "info",
+      path: FEATURES_REL,
+      evidence: "Secondary feature map missing; changelog/inventory check continues",
+      suggestedRoute: "none"
+    });
+  }
+  let latestCursorVersion = null;
+  if (!options.offline) {
+    try {
+      const body = options.changelogBody ?? await (options.fetchText ?? defaultFetchText)(changelogUrl);
+      latestCursorVersion = extractLatestCursorVersion(body);
+      const haystack = `${inventoryMd}
+${featuresMd}`;
+      const missingKeywords = findMissingInventoryKeywords(
+        extractChangelogFeatureKeywords(body),
+        haystack
+      );
+      for (const keyword of missingKeywords.slice(0, MAX_FEATURE_KEYWORD_GAPS)) {
+        const slug = slugifyFeatureKeyword(keyword);
+        if (!slug) continue;
+        gaps.push({
+          id: `feature-keyword-miss:${slug}`,
+          severity: "advisory",
+          path: FEATURES_REL,
+          evidence: `Changelog names "${keyword}" which is not listed in native-audit or cursor-3-features`,
+          suggestedRoute: "backlog-add"
+        });
+      }
+      if (latestCursorVersion && prefs.lastSeenCursorVersion && compareCursorVersion(latestCursorVersion, prefs.lastSeenCursorVersion) > 0) {
+        gaps.push({
+          id: "changelog-ahead",
+          severity: "advisory",
+          path: changelogUrl,
+          evidence: `Changelog latest ${latestCursorVersion} is ahead of lastSeenCursorVersion ${prefs.lastSeenCursorVersion}`,
+          suggestedRoute: "backlog-add"
+        });
+      } else if (latestCursorVersion && !prefs.lastSeenCursorVersion) {
+        gaps.push({
+          id: "changelog-baseline",
+          severity: "info",
+          path: changelogUrl,
+          evidence: `Changelog latest ${latestCursorVersion}; no lastSeenCursorVersion baseline yet (stamp to baseline)`,
+          suggestedRoute: "none"
+        });
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return baseResult({
+        status: "error",
+        inventoryRoot,
+        inventoryPath: INVENTORY_REL,
+        featuresPath: FEATURES_REL,
+        changelogUrl,
+        latestCursorVersion: null,
+        lastSeenCursorVersion: prefs.lastSeenCursorVersion,
+        inventoryRefreshed,
+        openActionIds,
+        gaps,
+        message: `Changelog fetch error: ${msg}`
+      });
+    }
+  }
+  if (options.stamp && inventoryRoot) {
+    await stampCursorUpdateCheck(inventoryRoot, {
+      lastSeenCursorVersion: latestCursorVersion ?? prefs.lastSeenCursorVersion
+    });
+  }
+  const status = gaps.length > 0 ? "gaps-found" : "current";
+  const message = status === "current" ? "No advisory Cursor-update gaps vs inventory (check-only)." : `Found ${gaps.length} advisory gap(s). ${CONVEYOR_HINT}`;
+  return baseResult({
+    status,
+    inventoryRoot,
+    inventoryPath: INVENTORY_REL,
+    featuresPath: FEATURES_REL,
+    changelogUrl: options.offline ? null : changelogUrl,
+    latestCursorVersion,
+    lastSeenCursorVersion: prefs.lastSeenCursorVersion,
+    inventoryRefreshed,
+    openActionIds,
+    gaps,
+    message
+  });
+}
+
+export {
+  CHANGELOG_FETCH_TIMEOUT_MS,
+  resolveInventoryRoot,
+  stampCursorUpdateCheck,
+  checkCursorUpdateAwareness
+};

package/dist/chunk-DE3LQFSJ.js

@@ -0,0 +1,18 @@
+// src/hooks/read-stdin-json.ts
+async function readStdinJson() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export {
+  readStdinJson
+};

package/dist/chunk-DQA434Y4.js

@@ -0,0 +1,106 @@
+import {
+  L0_ARTIFACTS
+} from "./chunk-N3HTJVBR.js";
+import {
+  copyRegistryFile,
+  emptyStats,
+  installPack,
+  installSkillsByIds,
+  loadManagedHashLedger,
+  loadRegistry,
+  mergeStats,
+  recordOutcome,
+  resolveProtectedGlobs,
+  saveManagedHashLedger
+} from "./chunk-AW74INUW.js";
+import {
+  fileExists
+} from "./chunk-77V75A7O.js";
+
+// src/lifecycle/onboard-migration.ts
+import { createHash } from "crypto";
+import { readFile, unlink } from "fs/promises";
+import path from "path";
+var LEGACY_ONBOARD_PATH = ".cursor/commands/onboard.md";
+var NAMESPACED_ONBOARD_PATH = ".cursor/commands/agent-kit-onboard.md";
+var MANAGED_LEGACY_HASHES = /* @__PURE__ */ new Set([
+  "b274a68941813f19b185893cb7c5561dff027f53270890029992f208e24992fe"
+]);
+async function migrateLegacyOnboardCommand(projectRoot, managedHashes = MANAGED_LEGACY_HASHES) {
+  const legacyPath = path.join(projectRoot, LEGACY_ONBOARD_PATH);
+  if (!await fileExists(legacyPath)) return "absent";
+  const namespacedPath = path.join(projectRoot, NAMESPACED_ONBOARD_PATH);
+  if (!await fileExists(namespacedPath)) return "preserved-customized";
+  const content = await readFile(legacyPath);
+  const hash = createHash("sha256").update(content).digest("hex");
+  if (!managedHashes.has(hash)) return "preserved-customized";
+  await unlink(legacyPath);
+  return "removed-managed";
+}
+
+// src/lifecycle/sync.ts
+async function installL0(registryRoot, projectRoot, protectedGlobs, ledger) {
+  const stats = emptyStats();
+  const managedHashes = ledger ?? await loadManagedHashLedger(projectRoot);
+  const copyOpts = { managedHashes, persistManagedHashes: false };
+  for (const artifact of L0_ARTIFACTS) {
+    const outcome = await copyRegistryFile(
+      registryRoot,
+      projectRoot,
+      artifact.source,
+      artifact.target,
+      protectedGlobs,
+      copyOpts
+    );
+    recordOutcome(stats, artifact.target, outcome);
+  }
+  if (!ledger) await saveManagedHashLedger(projectRoot, managedHashes);
+  const migration = await migrateLegacyOnboardCommand(projectRoot);
+  if (migration === "removed-managed") {
+    stats.removed.push(".cursor/commands/onboard.md");
+  } else if (migration === "preserved-customized") {
+    stats.collisions.push(".cursor/commands/onboard.md");
+  }
+  return stats;
+}
+async function syncFromManifest(registryRoot, projectRoot, manifest) {
+  const protectedGlobs = resolveProtectedGlobs(manifest);
+  const stats = emptyStats();
+  const managedHashes = await loadManagedHashLedger(projectRoot);
+  const installOpts = { protectedGlobs, managedHashes };
+  try {
+    mergeStats(stats, await installL0(registryRoot, projectRoot, protectedGlobs, managedHashes));
+    for (const packId of manifest.packs ?? []) {
+      mergeStats(stats, await installPack(registryRoot, projectRoot, packId, installOpts));
+    }
+    const skillIds = manifest.skills ?? [];
+    if (skillIds.length > 0) {
+      await loadRegistry(registryRoot);
+      mergeStats(stats, await installSkillsByIds(registryRoot, projectRoot, skillIds, installOpts));
+    }
+  } finally {
+    await saveManagedHashLedger(projectRoot, managedHashes);
+  }
+  return stats;
+}
+
+// src/commands/shared-args.ts
+var NON_INTERACTIVE_ROOT_ARGS = {
+  yes: {
+    type: "boolean",
+    alias: "y",
+    description: "Skip interactive prompts; use defaults (IDE-agnostic non-interactive mode)",
+    default: false
+  },
+  "force-root": {
+    type: "boolean",
+    description: "Bypass the ambiguous-root guard (use with caution)",
+    default: false
+  }
+};
+
+export {
+  installL0,
+  syncFromManifest,
+  NON_INTERACTIVE_ROOT_ARGS
+};