opencode-swarm 7.100.1 → 7.102.0

package/.opencode/skills/execute/SKILL.md

@@ -54,6 +54,7 @@ All other gates: failure → return to coder. No self-fixes. No workarounds.
     → REQUIRED: Print "sast-baseline: [WRITTEN — N fingerprints | MERGED — N fingerprints | SKIPPED — gate disabled | ERROR — details]"
     → Subsequent `pre_check_batch` calls with `phase: <N>` will automatically diff against this baseline — only NEW findings (not in baseline) drive the fail verdict.
 5b. the active swarm's coder agent - Implement (if designer scaffold produced, include it as INPUT).
+5b-bis. **CODER OUTPUT VERIFICATION**: After the coder reports completion, do NOT accept the self-report alone. Run `diff` (step 5c) and inspect at least one of the modified files yourself to confirm the change exists. The coder may report DONE without having produced any diff. A 30-second read of the changed file(s) catches this failure mode. This is NOT a separate explorer dispatch — the existing `diff` tool at step 5c is the verification mechanism; the key discipline is checking that `diff` returns actual changes before proceeding, rather than forwarding the coder's self-report to the next gate.
 5c. Run `diff` tool. If `hasContractChanges` → the active swarm's explorer agent integration analysis. If COMPATIBILITY SIGNALS=INCOMPATIBLE or MIGRATION_SURFACE=yes → coder retry. If COMPATIBILITY SIGNALS=COMPATIBLE and MIGRATION_SURFACE=no → proceed.
     → REQUIRED: Print "diff: [PASS | CONTRACT CHANGE — details]"
     5d. Run `syntax_check` tool. SYNTACTIC ERRORS → return to coder. NO ERRORS → proceed to placeholder_scan.

package/.opencode/skills/running-tests/SKILL.md

@@ -137,6 +137,7 @@ Get-Content "$env:TEMP\test_out.txt" | Select-Object -Last 50
 - `Select-String -Last N` — invalid parameter, use `Select-Object -Last N`
 - `2>&1 2>&1` — duplicate redirection, causes parse error; use `2>&1` once
 - `&&` — not supported in PowerShell 5.1; use `; if ($?) { cmd2 }` instead
+- `bun test --exec bash` — fails on Windows hosts with ENOENT (bash is not available in standard PowerShell). Use `bun test` directly or a PowerShell-based loop instead.
 - After `bun install --frozen-lockfile --force`, non-elevated Windows shells can hit `EPERM` while reading refreshed `node_modules` entries. Treat that as a host permission/access issue: rerun the same focused Bun command with approved/elevated access before diagnosing it as a code or test failure.
 
 ---

package/.opencode/skills/writing-tests/SKILL.md

@@ -736,6 +736,7 @@ The `--timeout 120000` flag sets per-test timeout to 120 seconds. Individual tes
 3. Verify no `process.cwd()` usage — use the `directory` parameter from `createSwarmTool` or hook constructor
 4. Verify no hardcoded paths (`/tmp/...`, `C:\...`) — use `os.tmpdir()` + `path.join()`
 5. Verify mocks are restored in `afterEach` if using `spyOn` or `mock.module`
+6. Run `bunx @biomejs/biome@2.3.14 check --write <touched-test-files>` to auto-format only the files you created or modified. Formatting issues are a common first-pass failure — scoping the command to touched files avoids accidental workspace-wide rewrites.
 
 ## Known Pre-existing Test Failures
 

package/dist/cli/{evidence-summary-service-vgw9vw3n.js → evidence-summary-service-c4d1c2t3.js}

@@ -6,7 +6,7 @@ import {
   loadPlanJsonOnly,
   mergeDurableGateEntriesFromEvidence,
   readDurableGateEvidence
-} from "./index-3emh7rny.js";
+} from "./index-bnkd9ejn.js";
 import"./index-r8f89sm9.js";
 import"./index-9b7qp18e.js";
 import"./index-7ztmmqpt.js";

package/dist/cli/{guardrail-explain-z37rtfz4.js → guardrail-explain-ea9ja7x8.js}

@@ -1,15 +1,15 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-4xqnktvr.js";
-import"./index-qvdxzjqt.js";
+} from "./index-72893pwd.js";
+import"./index-3v3rq2tq.js";
 import"./index-pj3a5fbt.js";
 import"./index-ydgy7vg5.js";
 import"./index-vwyjkzgs.js";
 import"./index-f7nma02k.js";
 import"./index-rpb763g8.js";
 import"./index-m0qshbr6.js";
-import"./index-3emh7rny.js";
+import"./index-bnkd9ejn.js";
 import"./index-adz3nk9b.js";
 import"./index-v4fcn4tr.js";
 import"./index-r8f89sm9.js";

package/dist/cli/{index-bcr2a549.js → index-2r26qngd.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-4xqnktvr.js";
+} from "./index-72893pwd.js";
 import {
   handleGuardrailLog
 } from "./index-5bstvpct.js";
@@ -79,7 +79,7 @@ import {
   handleWriteRetroCommand,
   normalizeSwarmCommandInput,
   resolveCommand
-} from "./index-qvdxzjqt.js";
+} from "./index-3v3rq2tq.js";
 import"./index-pj3a5fbt.js";
 import"./index-ydgy7vg5.js";
 import"./index-vwyjkzgs.js";
@@ -90,7 +90,7 @@ import {
   ORCHESTRATOR_NAME,
   stripKnownSwarmPrefix
 } from "./index-m0qshbr6.js";
-import"./index-3emh7rny.js";
+import"./index-bnkd9ejn.js";
 import"./index-adz3nk9b.js";
 import"./index-v4fcn4tr.js";
 import"./index-r8f89sm9.js";

package/dist/cli/{index-qvdxzjqt.js → index-3v3rq2tq.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-3emh7rny.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.1",
+  version: "7.102.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",
@@ -18002,7 +18005,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-vgw9vw3n.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.";
@@ -31883,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++) {
@@ -31905,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}"` };
     }
@@ -31922,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",
     "",
@@ -31941,6 +32041,8 @@ ${USAGE9}`;
     `Current OpenSpec specs: ${status.currentSpecs.length}`,
     `Active OpenSpec changes: ${status.changes.length}`,
     "",
+    speckitLines,
+    "",
     "### Changes",
     formatList(changes),
     "",
@@ -31966,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
   });
@@ -32008,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
@@ -32096,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 {
@@ -32129,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;
 }
@@ -32185,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})`);
@@ -32221,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)}
@@ -32232,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}`);
@@ -32339,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");
@@ -32871,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)
@@ -32911,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)}`;
     }
@@ -33073,7 +33362,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-bcr2a549.js");
+    const { buildHelpText } = await import("./index-2r26qngd.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -33082,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-bcr2a549.js");
+  const { buildHelpText: fullHelp } = await import("./index-2r26qngd.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -33215,7 +33504,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-z37rtfz4.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-ea9ja7x8.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -33988,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 || "";
       }
     }