opencode-swarm 7.100.0 → 7.101.0

package/dist/cli/{index-q5cae5d7.js → index-rmh6nqbp.js}

@@ -84,6 +84,7 @@ import {
   computeSpecHash,
   derivePlanId,
   derivePlanMarkdown,
+  detectSpeckit,
   disableEpicMode,
   enableEpicMode,
   getDurableGateEvidenceStatusForTask,
@@ -108,13 +109,15 @@ import {
   readTaskScopes,
   resetToMainAfterMerge,
   resetToRemoteBranch,
+  resolveSpeckitProjection,
   sanitizeTaskId,
   saveEvidence,
   savePlan,
   transientBackoff,
   validateProjectRoot,
+  validateSpeckit,
   writeProjectedSpecSync
-} from "./index-y3x3gvy6.js";
+} from "./index-bnkd9ejn.js";
 import {
   _internals as _internals2,
   _internals1 as _internals3,
@@ -909,7 +912,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.100.0",
+  version: "7.101.0",
   description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -13089,6 +13092,7 @@ var ACTIVE_STATE_TO_CLEAN = [
   "swarm.db-shm",
   "swarm.db-wal"
 ];
+var TERMINAL_STATE_FILES = ["plan.json", "plan-ledger.jsonl"];
 var KNOWLEDGE_FAMILY_ARTIFACTS = new Set([
   "knowledge.jsonl",
   "knowledge-rejected.jsonl"
@@ -13579,6 +13583,10 @@ async function runCleanStage(ctx) {
       }
       if (!ctx.archivedActiveStateFiles.has(artifact)) {
         const reason = ctx.archiveFailureReasons?.get(artifact);
+        if (TERMINAL_STATE_FILES.includes(artifact)) {
+          ctx.warnings.push(reason ? `${artifact} was not archived (${reason}); removing it anyway to prevent CLOSED-plan resurrection next session \u2014 no archive copy retained.` : `${artifact} was not archived; removing it anyway to prevent CLOSED-plan resurrection next session \u2014 no archive copy retained.`);
+          continue;
+        }
         ctx.warnings.push(reason ? `Preserved ${artifact} because it was not successfully archived: ${reason}.` : `Preserved ${artifact} because it was not successfully archived.`);
         continue;
       }
@@ -13686,6 +13694,20 @@ async function runCleanStage(ctx) {
   if (tmpFilesRemoved > 0) {
     cleanedFiles.push(`${tmpFilesRemoved} .tmp.* file(s)`);
   }
+  for (const terminalFile of TERMINAL_STATE_FILES) {
+    try {
+      await fs13.unlink(path26.join(ctx.swarmDir, terminalFile));
+      if (!cleanedFiles.includes(terminalFile)) {
+        cleanedFiles.push(terminalFile);
+      }
+    } catch (err) {
+      const errno = err?.code;
+      if (errno === "ENOENT") {} else {
+        const reason = err instanceof Error ? err.message : String(err);
+        ctx.warnings.push(`Failed to remove terminal-state file ${terminalFile} [${errno ?? "unknown"}]: ${reason}`);
+      }
+    }
+  }
   clearAllScopes(ctx.directory);
   const contextPath = path26.join(ctx.swarmDir, "context.md");
   const contextContent = [
@@ -16153,6 +16175,15 @@ async function checkKnowledgeHealth(directory) {
 // src/services/diagnose-service.ts
 var { version: version2 } = package_default;
 var sandboxCapabilityProbe = new SandboxCapabilityProbe;
+var REQUIRED_CACHE_GRAMMAR_ASSETS = [
+  "tree-sitter.wasm",
+  "tree-sitter-javascript.wasm",
+  "tree-sitter-typescript.wasm"
+];
+function resolveCachePackageRoot(cachePath) {
+  const nestedPackageRoot = path33.join(cachePath, "node_modules", "opencode-swarm");
+  return existsSync18(nestedPackageRoot) ? nestedPackageRoot : cachePath;
+}
 var _internals24 = {
   detectSandboxCapability: () => sandboxCapabilityProbe.detect(),
   getSandboxExecutor: getExecutor
@@ -16933,14 +16964,21 @@ async function getDiagnoseData(directory) {
         cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
         continue;
       }
-      const pkgJsonPath = path33.join(cachePath, "package.json");
+      const packageRoot = resolveCachePackageRoot(cachePath);
+      const cacheLabel = packageRoot === cachePath ? cachePath : `${cachePath} -> ${packageRoot}`;
+      const missingGrammarAssets = REQUIRED_CACHE_GRAMMAR_ASSETS.filter((file) => !existsSync18(path33.join(packageRoot, "dist", "lang", "grammars", file)));
+      const pkgJsonPath = path33.join(packageRoot, "package.json");
       try {
         const raw = readFileSync10(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         const installedVersion = typeof parsed.version === "string" ? parsed.version : "?";
-        cacheRows.push(`\u2705 ${cachePath} \u2014 v${installedVersion}`);
+        if (missingGrammarAssets.length > 0) {
+          cacheRows.push(`\u26A0\uFE0F ${cacheLabel} \u2014 v${installedVersion}, missing grammar assets: ${missingGrammarAssets.join(", ")}; run \`bunx opencode-swarm update\` and restart OpenCode`);
+          continue;
+        }
+        cacheRows.push(`\u2705 ${cacheLabel} \u2014 v${installedVersion}`);
       } catch {
-        cacheRows.push(`\u26A0\uFE0F ${cachePath} \u2014 present (package.json unreadable)`);
+        cacheRows.push(`\u26A0\uFE0F ${cacheLabel} \u2014 present (package.json unreadable)`);
       }
     } catch {
       cacheRows.push(`\u26A0\uFE0F ${cachePath} \u2014 status unknown (read error)`);
@@ -17967,7 +18005,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-ch74hb16.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-c4d1c2t3.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -31848,15 +31886,31 @@ async function handleRollbackCommand(directory, args) {
 }
 
 // src/commands/sdd.ts
+import * as fs31 from "fs";
+import * as path63 from "path";
+var SWARM_SPEC_REL = path63.join(".swarm", "spec.md");
 var USAGE9 = `Usage:
-  /swarm sdd status [--json]
-  /swarm sdd validate [--json] [--change <id>]
-  /swarm sdd project [--dry-run] [--json] [--change <id>]
+  /swarm sdd status [--json] [--source <provider>]
+  /swarm sdd validate [--json] [--change <id>] [--source <provider>] [--feature <id>]
+  /swarm sdd project [--dry-run] [--json] [--change <id>] [--source <provider>] [--feature <id>]
+
+Source options (required when both openspec and speckit are detected):
+  --source <swarm|openspec|speckit>  select the SDD provider explicitly
+  --feature <id>                     Spec-Kit feature directory name to project
+                                     (required when multiple Spec-Kit features exist)
 
 OpenSpec-compatible SDD support:
   - reads checked-in openspec/specs and openspec/changes artifacts
   - produces one effective Swarm spec for planning
-  - keeps tasks.md as proposal input; .swarm/plan-ledger.jsonl remains execution state`;
+  - keeps tasks.md as proposal input; .swarm/plan-ledger.jsonl remains execution state
+
+Spec-Kit SDD support:
+  - detects .specify/ marker + specs/NNN-feature-name/spec.md layout
+  - projects a single Spec-Kit feature into .swarm/spec.md via /swarm sdd project
+  - use --source speckit or --source openspec to disambiguate when both are present`;
+function isUnsafeId(value) {
+  return value.includes("/") || value.includes("\\") || value.includes("..") || value.includes("[") || value.includes("]") || containsControlChars(value);
+}
 function parseArgs10(args) {
   const parsed = { json: false, dryRun: false };
   for (let i = 0;i < args.length; i++) {
@@ -31870,13 +31924,37 @@ function parseArgs10(args) {
         return { ...parsed, error: "--change requires a value" };
       }
       const value = args[++i];
-      if (value.includes("/") || value.includes("\\") || value.includes("..") || value.includes("[") || value.includes("]")) {
+      if (isUnsafeId(value)) {
         return {
           ...parsed,
-          error: "--change must be a single OpenSpec change id with no path separators, traversal, or brackets"
+          error: "--change must be a single OpenSpec change id with no path separators, traversal, brackets, or control characters"
         };
       }
       parsed.changeId = value;
+    } else if (token === "--source") {
+      if (i + 1 >= args.length || args[i + 1].startsWith("--")) {
+        return { ...parsed, error: "--source requires a value" };
+      }
+      const value = args[++i];
+      if (value !== "swarm" && value !== "openspec" && value !== "speckit") {
+        return {
+          ...parsed,
+          error: `--source must be one of: swarm | openspec | speckit; got "${value}"`
+        };
+      }
+      parsed.source = value;
+    } else if (token === "--feature") {
+      if (i + 1 >= args.length || args[i + 1].startsWith("--")) {
+        return { ...parsed, error: "--feature requires a value" };
+      }
+      const value = args[++i];
+      if (isUnsafeId(value)) {
+        return {
+          ...parsed,
+          error: "--feature must be a single Spec-Kit feature directory name with no path separators, traversal, brackets, or control characters"
+        };
+      }
+      parsed.feature = value;
     } else {
       return { ...parsed, error: `Unknown flag "${token}"` };
     }
@@ -31887,16 +31965,73 @@ function formatList(items) {
   return items.length > 0 ? items.map((item) => `- ${item}`).join(`
 `) : "- none";
 }
+function formatSpeckitError(resolution) {
+  switch (resolution.kind) {
+    case "empty":
+      return "Spec-Kit layout detected (.specify/ marker present) but no feature directories found under specs/.";
+    case "ambiguous":
+      return [
+        `Multiple Spec-Kit features detected: ${resolution.features.join(", ")}.`,
+        "Use --feature <id> to select one."
+      ].join(`
+`);
+    case "unknown_feature":
+      return [
+        `Unknown Spec-Kit feature '${resolution.feature}'.`,
+        `Available features: ${resolution.available.join(", ")}.`
+      ].join(`
+`);
+    case "zero_requirements":
+      return `Spec-Kit feature '${resolution.feature}' contains no parsable functional requirements.`;
+    case "too_large":
+      return `Spec-Kit feature '${resolution.feature}' projected output exceeds the size limit (${resolution.bytes} bytes).`;
+    case "not_speckit":
+      return "No Spec-Kit layout detected (.specify/ marker not present).";
+    case "ok":
+      return "";
+  }
+}
 async function handleSddStatusCommand(directory, args) {
   const parsed = parseArgs10(args);
   if (parsed.error)
     return `Error: ${parsed.error}
 
 ${USAGE9}`;
-  const status = loadSddStatusSync(directory);
-  if (parsed.json)
-    return JSON.stringify(status, null, 2);
+  if (parsed.feature && parsed.source && parsed.source !== "speckit") {
+    return `Error: --feature is only valid with --source speckit
+
+${USAGE9}`;
+  }
+  const speckitDetection = detectSpeckit(directory);
+  const speckitPresent = speckitDetection.features.length > 0;
+  const nativeSpecExists = fs31.existsSync(path63.join(directory, SWARM_SPEC_REL));
+  if (speckitPresent && !parsed.source && !nativeSpecExists) {
+    const openspecProjection = buildOpenSpecProjectionSync(directory);
+    if (openspecProjection !== null) {
+      const errLines = [
+        "Error: Multiple SDD sources detected (openspec, speckit).",
+        "Pass --source openspec or --source speckit to select a provider."
+      ];
+      return parsed.json ? JSON.stringify({ error: errLines.join(" "), sources: ["openspec", "speckit"] }, null, 2) : errLines.join(`
+`);
+    }
+  }
+  const status = loadSddStatusSync(directory, {
+    source: parsed.source,
+    feature: parsed.feature
+  });
+  if (parsed.json) {
+    return JSON.stringify({ ...status, speckit: speckitDetection }, null, 2);
+  }
   const changes = status.changes.map((change) => `${change.id} (${change.specs.length} spec file${change.specs.length === 1 ? "" : "s"}, proposal=${change.proposal}, design=${change.design}, tasks=${change.tasks})`);
+  const speckitLines = [
+    "### Spec-Kit",
+    `Spec-Kit provider: ${speckitDetection.markerPresent ? "detected" : "not present"}`,
+    speckitDetection.features.length > 0 ? `Features:
+${speckitDetection.features.map((f) => `- ${f.featureId}`).join(`
+`)}` : "Features: none"
+  ].join(`
+`);
   return [
     "## SDD Status",
     "",
@@ -31906,6 +32041,8 @@ ${USAGE9}`;
     `Current OpenSpec specs: ${status.currentSpecs.length}`,
     `Active OpenSpec changes: ${status.changes.length}`,
     "",
+    speckitLines,
+    "",
     "### Changes",
     formatList(changes),
     "",
@@ -31931,7 +32068,114 @@ async function handleSddValidateCommand(directory, args) {
     return `Error: ${parsed.error}
 
 ${USAGE9}`;
-  const status = loadSddStatusSync(directory);
+  if (parsed.feature && parsed.source && parsed.source !== "speckit") {
+    return `Error: --feature is only valid with --source speckit
+
+${USAGE9}`;
+  }
+  let useSpeckit = false;
+  const nativeSpecExists = fs31.existsSync(path63.join(directory, SWARM_SPEC_REL));
+  if (parsed.source === "speckit") {
+    useSpeckit = true;
+  } else if (!parsed.source && !nativeSpecExists) {
+    const speckitDetection = detectSpeckit(directory);
+    if (speckitDetection.features.length > 0) {
+      const openspecProjection = buildOpenSpecProjectionSync(directory);
+      if (openspecProjection !== null) {
+        const errLines = [
+          "Error: Multiple SDD sources detected (openspec, speckit).",
+          "Pass --source openspec or --source speckit to select a provider."
+        ];
+        return parsed.json ? JSON.stringify({
+          valid: false,
+          error: errLines.join(" "),
+          sources: ["openspec", "speckit"]
+        }, null, 2) : errLines.join(`
+`);
+      }
+      useSpeckit = true;
+    } else if (speckitDetection.markerPresent) {
+      const openspecProjection = buildOpenSpecProjectionSync(directory);
+      if (openspecProjection === null) {
+        const resolution = resolveSpeckitProjection(directory);
+        return parsed.json ? JSON.stringify({ valid: false, error: formatSpeckitError(resolution) }, null, 2) : `Error: ${formatSpeckitError(resolution)}
+
+${USAGE9}`;
+      }
+    }
+  }
+  if (useSpeckit) {
+    const { resolution, problems } = validateSpeckit(directory, {
+      feature: parsed.feature
+    });
+    if (resolution.kind !== "ok" && resolution.kind !== "zero_requirements") {
+      return parsed.json ? JSON.stringify({ valid: false, error: formatSpeckitError(resolution) }, null, 2) : `Error: ${formatSpeckitError(resolution)}
+
+${USAGE9}`;
+    }
+    const spec = resolution.kind === "ok" ? resolution.spec : null;
+    const result2 = {
+      valid: problems.length === 0 && resolution.kind === "ok",
+      provider: "speckit_projection",
+      changeId: null,
+      sourcePaths: spec?.sourcePaths ?? [],
+      hash: spec?.hash ?? null,
+      errors: problems,
+      warnings: spec?.warnings ?? []
+    };
+    if (parsed.json)
+      return JSON.stringify(result2, null, 2);
+    return [
+      `SDD validation: ${result2.valid ? "valid" : "invalid"}`,
+      `Provider: ${result2.provider}`,
+      `Projected sources: ${result2.sourcePaths.length}`,
+      result2.errors.length > 0 ? `
+Errors:
+${formatList(result2.errors)}` : "",
+      result2.warnings.length > 0 ? `
+Warnings:
+${formatList(result2.warnings)}` : ""
+    ].join(`
+`);
+  }
+  if (parsed.source === "swarm") {
+    const status2 = loadSddStatusSync(directory, {
+      source: "swarm",
+      feature: parsed.feature
+    });
+    const filteredErrors = status2.errors.filter((e) => !e.includes("openspec/") && !e.includes("proposal.md") && !e.includes("tasks.md") && !e.includes("specs/**/spec.md"));
+    const filteredWarnings = status2.warnings.filter((w) => !w.includes("openspec/") && !w.includes("proposal.md") && !w.includes("tasks.md") && !w.includes("specs/**/spec.md"));
+    const result2 = {
+      valid: status2.effectiveSpec !== null && filteredErrors.length === 0,
+      provider: status2.provider,
+      changeId: null,
+      sourcePaths: status2.effectiveSpec?.sourcePaths ?? [],
+      hash: status2.effectiveSpec?.hash ?? null,
+      errors: filteredErrors,
+      warnings: [
+        ...filteredWarnings,
+        ...status2.effectiveSpec?.warnings ?? []
+      ]
+    };
+    if (parsed.json)
+      return JSON.stringify(result2, null, 2);
+    return [
+      `SDD validation: ${result2.valid ? "valid" : "invalid"}`,
+      `Provider: ${result2.provider}`,
+      `Projected sources: ${result2.sourcePaths.length}`,
+      result2.errors.length > 0 ? `
+Errors:
+${formatList(result2.errors)}` : "",
+      result2.warnings.length > 0 ? `
+Warnings:
+${formatList(result2.warnings)}` : ""
+    ].join(`
+`);
+  }
+  const status = loadSddStatusSync(directory, {
+    source: parsed.source,
+    feature: parsed.feature
+  });
   const projection = buildOpenSpecProjectionSync(directory, {
     changeId: parsed.changeId
   });
@@ -31973,6 +32217,86 @@ async function handleSddProjectCommand(directory, args) {
     return `Error: ${parsed.error}
 
 ${USAGE9}`;
+  if (parsed.feature && parsed.source && parsed.source !== "speckit") {
+    return `Error: --feature is only valid with --source speckit
+
+${USAGE9}`;
+  }
+  if (parsed.source === "swarm") {
+    return `Error: --source swarm selects the native .swarm/spec.md and does not generate a projection. Use --source openspec or --source speckit.
+
+${USAGE9}`;
+  }
+  let useSpeckit = false;
+  if (parsed.source === "speckit") {
+    useSpeckit = true;
+  } else if (!parsed.source) {
+    const speckitDetection = detectSpeckit(directory);
+    if (speckitDetection.features.length > 0) {
+      const openspecProjection = buildOpenSpecProjectionSync(directory);
+      if (openspecProjection !== null) {
+        return [
+          "Error: Multiple SDD sources detected (openspec, speckit).",
+          "Pass --source openspec or --source speckit to select a provider."
+        ].join(`
+`);
+      }
+      useSpeckit = true;
+    } else if (speckitDetection.markerPresent) {
+      const openspecProjection = buildOpenSpecProjectionSync(directory);
+      if (openspecProjection === null) {
+        const resolution = resolveSpeckitProjection(directory);
+        return `Error: ${formatSpeckitError(resolution)}
+
+${USAGE9}`;
+      }
+    }
+  }
+  if (useSpeckit) {
+    const resolution = resolveSpeckitProjection(directory, {
+      feature: parsed.feature
+    });
+    if (resolution.kind !== "ok") {
+      return `Error: ${formatSpeckitError(resolution)}
+
+${USAGE9}`;
+    }
+    const result2 = writeProjectedSpecSync(directory, {
+      source: "speckit",
+      feature: resolution.feature,
+      dryRun: parsed.dryRun
+    });
+    const response2 = {
+      written: result2.written,
+      dryRun: parsed.dryRun,
+      path: result2.path,
+      archivePath: result2.archivePath ?? null,
+      hash: result2.projection?.hash ?? null,
+      sourcePaths: result2.projection?.sourcePaths ?? [],
+      warnings: result2.projection?.warnings ?? []
+    };
+    if (parsed.json)
+      return JSON.stringify(response2, null, 2);
+    if (!result2.projection) {
+      return [
+        "SDD projection failed: no valid Spec-Kit projection could be built.",
+        "",
+        USAGE9
+      ].join(`
+`);
+    }
+    return [
+      parsed.dryRun ? "SDD projection preview" : "SDD projection written",
+      `Path: ${result2.path}`,
+      `Hash: ${result2.projection.hash}`,
+      `Sources: ${result2.projection.sourcePaths.length}`,
+      result2.archivePath ? `Archived previous spec: ${result2.archivePath}` : "",
+      result2.projection.warnings.length > 0 ? `
+Warnings:
+${formatList(result2.projection.warnings)}` : ""
+    ].join(`
+`);
+  }
   const result = writeProjectedSpecSync(directory, {
     changeId: parsed.changeId,
     dryRun: parsed.dryRun
@@ -32061,13 +32385,13 @@ Ensure this is a git repository with commit history.`;
   const report = reportLines.filter(Boolean).join(`
 `);
   try {
-    const fs31 = await import("fs/promises");
-    const path63 = await import("path");
-    const reportPath = path63.join(directory, ".swarm", "simulate-report.md");
-    await fs31.mkdir(path63.dirname(reportPath), { recursive: true });
-    const reportTempPath = path63.join(path63.dirname(reportPath), `${path63.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const fs32 = await import("fs/promises");
+    const path64 = await import("path");
+    const reportPath = path64.join(directory, ".swarm", "simulate-report.md");
+    await fs32.mkdir(path64.dirname(reportPath), { recursive: true });
+    const reportTempPath = path64.join(path64.dirname(reportPath), `${path64.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      await fs31.writeFile(reportTempPath, report, "utf-8");
+      await fs32.writeFile(reportTempPath, report, "utf-8");
       renameSync11(reportTempPath, reportPath);
     } catch (err) {
       try {
@@ -32094,20 +32418,20 @@ async function handleSpecifyCommand(_directory, args) {
 // src/services/status-service.ts
 import * as fsSync3 from "fs";
 import { readFile as readFile16 } from "fs/promises";
-import * as path64 from "path";
+import * as path65 from "path";
 
 // src/turbo/lean/state.ts
 init_logger();
-import * as fs31 from "fs";
-import * as path63 from "path";
+import * as fs32 from "fs";
+import * as path64 from "path";
 var STATE_FILE3 = "turbo-state.json";
 function nowISO3() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path63.resolve(directory, ".swarm");
-  if (!fs31.existsSync(swarmDir)) {
-    fs31.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path64.resolve(directory, ".swarm");
+  if (!fs32.existsSync(swarmDir)) {
+    fs32.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -32150,17 +32474,17 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path63.join(directory, ".swarm", STATE_FILE3);
-    if (!fs31.existsSync(filePath)) {
+    const filePath = path64.join(directory, ".swarm", STATE_FILE3);
+    if (!fs32.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
         ensureSwarmDir2(directory);
-        fs31.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs32.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs31.readFileSync(filePath, "utf-8");
+    const raw = fs32.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
       markStateUnreadable2(directory, `malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
@@ -32186,7 +32510,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path63.join(directory, ".swarm", STATE_FILE3);
+    filePath = path64.join(directory, ".swarm", STATE_FILE3);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO3();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -32197,14 +32521,14 @@ function writePersisted2(directory, persisted) {
     throw new Error(`Lean Turbo state persistence prepare failed: ${msg}`);
   }
   try {
-    fs31.writeFileSync(tmpPath, payload, "utf-8");
-    fs31.renameSync(tmpPath, filePath);
+    fs32.writeFileSync(tmpPath, payload, "utf-8");
+    fs32.renameSync(tmpPath, filePath);
   } catch (error2) {
     const msg = error2 instanceof Error ? error2.message : String(error2);
     error(`[turbo/lean/state] Failed to persist ${STATE_FILE3} atomically: ${msg}`);
     try {
-      if (fs31.existsSync(tmpPath)) {
-        fs31.unlinkSync(tmpPath);
+      if (fs32.existsSync(tmpPath)) {
+        fs32.unlinkSync(tmpPath);
       }
     } catch {}
     throw new Error(`Lean Turbo state persistence failed: ${msg}`);
@@ -32304,7 +32628,7 @@ var _internals45 = {
 };
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path64.join(directory, ".swarm", "spec-staleness.json");
+    const p = path65.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync3.existsSync(p))
       return { stale: false };
     const raw = fsSync3.readFileSync(p, "utf-8");
@@ -32836,13 +33160,13 @@ function buildStatusMessage2(session, directory, sessionID) {
 }
 
 // src/commands/unlink.ts
-import { existsSync as existsSync37 } from "fs";
-import * as path65 from "path";
+import { existsSync as existsSync38 } from "fs";
+import * as path66 from "path";
 var DEDUP_THRESHOLD2 = 0.6;
 async function copySharedKnowledgeToLocal(linkDir, localSwarmDir) {
-  const sharedPath = path65.join(linkDir, "knowledge.jsonl");
-  const localPath = path65.join(localSwarmDir, "knowledge.jsonl");
-  if (!existsSync37(sharedPath))
+  const sharedPath = path66.join(linkDir, "knowledge.jsonl");
+  const localPath = path66.join(localSwarmDir, "knowledge.jsonl");
+  if (!existsSync38(sharedPath))
     return 0;
   const sharedEntries = await readKnowledge(sharedPath);
   if (sharedEntries.length === 0)
@@ -32876,7 +33200,7 @@ async function handleUnlinkCommand(directory, args) {
   let copied = 0;
   if (copyBack) {
     try {
-      copied = await copySharedKnowledgeToLocal(linkDir, path65.join(directory, ".swarm"));
+      copied = await copySharedKnowledgeToLocal(linkDir, path66.join(directory, ".swarm"));
     } catch (error2) {
       return `\u274C Failed to copy shared knowledge back to local: ${error2 instanceof Error ? error2.message : String(error2)}`;
     }
@@ -33038,7 +33362,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-jg6m72g7.js");
+    const { buildHelpText } = await import("./index-mz3j0me8.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -33047,7 +33371,7 @@ async function handleHelpCommand(ctx) {
     return _internals47.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals47.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-jg6m72g7.js");
+  const { buildHelpText: fullHelp } = await import("./index-mz3j0me8.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -33180,7 +33504,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-q8pj9691.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-ma84cj3s.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -33953,24 +34277,24 @@ function validateAliases() {
         continue;
       }
       const visited = new Set;
-      const path66 = [];
+      const path67 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path66.indexOf(current);
+          const cycleStart = path67.indexOf(current);
           const fullChain = [
             name,
-            ...path66.slice(0, cycleStart > 0 ? cycleStart : path66.length),
+            ...path67.slice(0, cycleStart > 0 ? cycleStart : path67.length),
             current
           ].join(" \u2192 ");
           errors.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path66.push(current);
+        path67.push(current);
         current = currentEntry.aliasOf || "";
       }
     }

package/dist/cli/{index-tj0jek4p.js → index-wc8g49dp.js}

@@ -12,7 +12,7 @@ import {
   detectPosixWrites,
   detectWindowsWrites,
   resolveWriteTargets
-} from "./index-q5cae5d7.js";
+} from "./index-rmh6nqbp.js";
 import {
   checkFileAuthority,
   classifyFile,