opencode-swarm 7.114.7 → 7.114.9

package/dist/cli/{index-vjvdvjd3.js → index-x12hvfpf.js}

@@ -2,18 +2,18 @@
 import {
   ALLOWED_SKILL_PATH_PREFIXES,
   validateSkillPath
-} from "./index-qrnhvhmg.js";
+} from "./index-n18yy0z1.js";
 import {
   effectiveRetrievalOutcomes,
   readKnowledgeCounterRollups
-} from "./index-kjbfry6m.js";
+} from "./index-8f2270hc.js";
 import {
   computeOutcomeSignal,
   readKnowledge,
   resolveHiveKnowledgePath,
   resolveSwarmKnowledgePath,
   transactKnowledge
-} from "./index-91qesget.js";
+} from "./index-rk6qhyng.js";
 import {
   isActiveStatus
 } from "./index-bfwt3abw.js";

package/dist/cli/{index-f6y341yk.js → index-yrrqs4b0.js}

@@ -845,11 +845,16 @@ var init_executor = __esm(() => {
 
 // src/plan/manager.ts
 import {
+  closeSync as closeSync2,
   copyFileSync,
   existsSync as existsSync5,
-  readdirSync,
+  fsyncSync as fsyncSync2,
+  mkdirSync as mkdirSync5,
+  openSync as openSync2,
+  readdirSync as readdirSync2,
   renameSync as renameSync4,
-  unlinkSync as unlinkSync3
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync6
 } from "fs";
 import * as fsPromises from "fs/promises";
 import * as path9 from "path";
@@ -2144,6 +2149,16 @@ function getLedgerPath(directory) {
 function getPlanJsonPath(directory) {
   return path8.join(directory, ".swarm", PLAN_JSON_FILENAME);
 }
+function writeFileFsyncedThenRename(tempPath, targetPath, data) {
+  const fd = fs5.openSync(tempPath, "w");
+  try {
+    fs5.writeFileSync(fd, data, "utf8");
+    fs5.fsyncSync(fd);
+  } finally {
+    fs5.closeSync(fd);
+  }
+  fs5.renameSync(tempPath, targetPath);
+}
 function computePlanHash(plan) {
   const normalized = {
     schema_version: plan.schema_version,
@@ -2277,8 +2292,7 @@ async function initLedger(directory, planId, initialPlanHash, initialPlan) {
   const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   const line = `${JSON.stringify(event)}
 `;
-  fs5.writeFileSync(tempPath, line, "utf8");
-  fs5.renameSync(tempPath, ledgerPath);
+  writeFileFsyncedThenRename(tempPath, ledgerPath, line);
 }
 async function appendLedgerEvent(directory, eventInput, options) {
   return withEvidenceLock(directory, LEDGER_LOCK_PATH, "plan-ledger", "append-ledger-event", async () => {
@@ -2305,13 +2319,11 @@ async function appendLedgerEvent(directory, eventInput, options) {
     const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
     const line = `${JSON.stringify(event)}
 `;
-    if (fs5.existsSync(ledgerPath)) {
-      const existingContent = fs5.readFileSync(ledgerPath, "utf8");
-      fs5.writeFileSync(tempPath, existingContent + line, "utf8");
-    } else {
+    if (!fs5.existsSync(ledgerPath)) {
       throw new Error("Ledger not initialized. Call initLedger() first.");
     }
-    fs5.renameSync(tempPath, ledgerPath);
+    const existingContent = fs5.readFileSync(ledgerPath, "utf8");
+    writeFileFsyncedThenRename(tempPath, ledgerPath, existingContent + line);
     return event;
   });
 }
@@ -2358,14 +2370,22 @@ async function takeSnapshotEvent(directory, plan, options) {
     payload: snapshotPayload
   }, { planHashAfter: options?.planHashAfter });
 }
-async function replayFromLedger(directory, _options) {
+async function replayFromLedger(directory, options) {
+  const { plan } = await replayFromLedgerWithStatus(directory, options);
+  return plan;
+}
+async function replayFromLedgerWithStatus(directory, _options) {
   const { events, truncated, badSuffix } = await readLedgerEventsWithIntegrity(directory);
   if (events.length === 0) {
-    return null;
+    return { plan: null, truncated, badSuffix };
   }
   if (truncated && badSuffix !== null) {
     await quarantineLedgerSuffix(directory, badSuffix);
   }
+  const plan = reconstructPlanFromEvents(directory, events);
+  return { plan, truncated, badSuffix };
+}
+function reconstructPlanFromEvents(directory, events) {
   const targetPlanId = events[0].plan_id;
   const relevantEvents = events.filter((e) => e.plan_id === targetPlanId);
   {
@@ -2531,11 +2551,35 @@ async function readLedgerEventsWithIntegrity(directory) {
   }
 }
 async function quarantineLedgerSuffix(directory, badSuffix) {
+  let salvagedCount = 0;
+  for (const line of badSuffix.split(`
+`)) {
+    if (line.trim() === "")
+      continue;
+    try {
+      JSON.parse(line);
+      salvagedCount++;
+    } catch {}
+  }
   try {
-    const quarantinePath = path8.join(directory, ".swarm", "plan-ledger.quarantine");
+    const hash = crypto2.createHash("sha256").update(badSuffix, "utf8").digest("hex").slice(0, 12);
+    const swarmDir = path8.join(directory, ".swarm");
+    try {
+      const existing = fs5.readdirSync(swarmDir).filter((name) => name.startsWith("plan-ledger.quarantine.") && name.endsWith(`.${hash}`));
+      for (const name of existing) {
+        const existingPath = path8.join(swarmDir, name);
+        if (fs5.readFileSync(existingPath, "utf8") === badSuffix) {
+          return { path: existingPath, salvagedCount };
+        }
+      }
+    } catch {}
+    const quarantinePath = path8.join(swarmDir, `plan-ledger.quarantine.${Date.now()}.${hash}`);
     fs5.writeFileSync(quarantinePath, badSuffix, "utf8");
-    console.warn(`[ledger] Corrupted suffix quarantined to ${path8.relative(directory, quarantinePath)}`);
-  } catch {}
+    console.warn(`[ledger] Corrupted suffix quarantined to ${path8.relative(directory, quarantinePath)} (salvageable events: ${salvagedCount})`);
+    return { path: quarantinePath, salvagedCount };
+  } catch {
+    return { path: null, salvagedCount };
+  }
 }
 async function loadLastApprovedPlan(directory, expectedPlanId) {
   const events = await readLedgerEvents(directory);
@@ -2868,7 +2912,15 @@ async function loadPlan(directory, cache) {
                 } else {
                   warn("[loadPlan] plan.json is stale (hash mismatch with ledger) \u2014 rebuilding from ledger. If this recurs, run /swarm reset-session to clear stale session state.");
                   try {
-                    const rebuilt = await replayFromLedger(directory);
+                    const { plan: rebuilt, truncated } = await replayFromLedgerWithStatus(directory);
+                    if (truncated) {
+                      const runtimeStale = validated;
+                      runtimeStale._ledgerReplayStale = true;
+                      runtimeStale._ledgerReplayStaleReason = "Ledger truncated: a malformed line stopped replay before the tail, so the ledger could only be reconstructed up to the corruption. plan.json was PRESERVED (not rolled back to the prefix-only projection) and the corrupted suffix was quarantined to .swarm/plan-ledger.quarantine.*. Verify state, then run /swarm reset-session if this persists.";
+                      ledgerStaleWorkspaces.add(resolvedWorkspace);
+                      criticalWarn("[loadPlan] Ledger truncated (poison line detected) \u2014 preserving plan.json instead of rolling back to the prefix-only ledger projection. Durable post-poison events remain in plan.json. Corrupted suffix quarantined to .swarm/plan-ledger.quarantine.*. Run /swarm reset-session after verifying state if this persists.");
+                      return runtimeStale;
+                    }
                     if (rebuilt) {
                       await rebuildPlan(directory, rebuilt, {
                         reason: "ledger_hash_mismatch_recovery"
@@ -3190,7 +3242,7 @@ async function savePlan(directory, plan, options) {
       }
       const MAX_ARCHIVED_SIBLINGS = 5;
       try {
-        const allFiles = readdirSync(swarmDir2);
+        const allFiles = readdirSync2(swarmDir2);
         const archivedSiblings = allFiles.filter((f) => f.startsWith("plan-ledger.archived-") && f.endsWith(".jsonl")).sort();
         if (archivedSiblings.length > MAX_ARCHIVED_SIBLINGS) {
           const toRemove = archivedSiblings.slice(0, archivedSiblings.length - MAX_ARCHIVED_SIBLINGS);
@@ -3407,8 +3459,17 @@ async function rebuildPlan(directory, plan, options) {
   const swarmDir = path9.join(directory, ".swarm");
   const planPath = path9.join(swarmDir, "plan.json");
   const mdPath = path9.join(swarmDir, "plan.md");
+  mkdirSync5(swarmDir, { recursive: true });
   const tempPlanPath = path9.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
-  await bunWrite(tempPlanPath, JSON.stringify(targetPlan, null, 2));
+  {
+    const fd = openSync2(tempPlanPath, "w");
+    try {
+      writeFileSync6(fd, JSON.stringify(targetPlan, null, 2), "utf8");
+      fsyncSync2(fd);
+    } finally {
+      closeSync2(fd);
+    }
+  }
   renameSync4(tempPlanPath, planPath);
   try {
     const markerPath = path9.join(swarmDir, ".plan-write-marker");
@@ -3805,8 +3866,8 @@ function migrateLegacyPlan(planContent, swarmId) {
 
 // src/evidence/manager.ts
 import {
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync2,
+  mkdirSync as mkdirSync6,
+  readdirSync as readdirSync3,
   realpathSync,
   rmSync,
   statSync as statSync2
@@ -4244,7 +4305,7 @@ async function saveEvidence(directory, taskId, evidence) {
     if (bundleJson.length > EVIDENCE_MAX_JSON_BYTES) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
-    mkdirSync5(evidenceDir, { recursive: true });
+    mkdirSync6(evidenceDir, { recursive: true });
     const tempPath = path10.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
@@ -4351,7 +4412,7 @@ async function listEvidenceTaskIds(directory) {
   }
   let entries;
   try {
-    entries = readdirSync2(evidenceBasePath);
+    entries = readdirSync3(evidenceBasePath);
   } catch {
     return [];
   }

package/dist/cli/index.d.ts

@@ -15,6 +15,40 @@ export declare function isSafeCachePath(p: string): boolean;
  * grandparent structure validation to prevent misconfigured nested paths.
  */
 export declare function isSafeLockFilePath(p: string): boolean;
+/**
+ * Safety guard for the `uninstall --clean` deletion of PROMPTS_DIR
+ * (`<CONFIG_DIR>/opencode-swarm`, a DIRECTORY removed recursively).
+ *
+ * This is a SEPARATE guard from isSafeCachePath — it is NOT reused because
+ * isSafeCachePath's layer-4 requires parent ∈ {packages, node_modules} and
+ * grandparent === 'opencode', which the prompts directory (parent basename is
+ * the config dir's basename, typically 'opencode') does not satisfy, so
+ * isSafeCachePath would false-REJECT a legitimate PROMPTS_DIR.
+ *
+ * Defense in depth:
+ *   1. Canonicalize via safeRealpathSync (realpathSync with ENOENT→fallback)
+ *      so the path a symlinked leaf actually resolves to is what we validate.
+ *   2. Refuse root, home, or shorter-than-home paths.
+ *   3. Require ≥ 3 non-empty segments (rejects pathological
+ *      XDG_CONFIG_HOME='/' which yields '/opencode/opencode-swarm', 2 segments).
+ *   4. Require basename === 'opencode-swarm' AND the parent directory's
+ *      basename to equal the config dir's basename (canonical layout is
+ *      `<CONFIG_DIR>/opencode-swarm`).
+ */
+export declare function isSafePromptsDir(p: string): boolean;
+/**
+ * Safety guard for the `uninstall --clean` deletion of PLUGIN_CONFIG_PATH
+ * (`<CONFIG_DIR>/opencode-swarm.json`, a FILE removed with unlinkSync).
+ *
+ * File-oriented sibling of isSafePromptsDir. isSafePromptsDir would
+ * false-REJECT this path because the leaf here is the `.json` FILE, not the
+ * `opencode-swarm` directory — hence a dedicated guard.
+ *
+ * Defense in depth: canonicalize via safeRealpathSync; refuse root/home/
+ * shorter-than-home; require basename === 'opencode-swarm.json' AND the
+ * parent directory's basename to equal the config dir's basename.
+ */
+export declare function isSafePluginConfigPath(p: string): boolean;
 /**
  * Recursively delete every known opencode plugin cache location for
  * opencode-swarm. Returns paths actually cleared and paths that errored.

package/dist/cli/index.js

@@ -7,22 +7,22 @@ import {
   getPluginLockFilePaths,
   package_default,
   resolveCommand
-} from "./index-6ctejje2.js";
+} from "./index-typ408f4.js";
 import"./index-yfedche9.js";
 import"./index-c8s9a3zh.js";
 import"./index-9bsmzfk3.js";
 import {
   DEFAULT_AGENT_CONFIGS
 } from "./index-a45jq4b7.js";
-import"./index-f6y341yk.js";
+import"./index-yrrqs4b0.js";
 import"./index-scww5b77.js";
 import"./index-ga4ta3cr.js";
 import"./index-80jkseqw.js";
-import"./index-vjvdvjd3.js";
-import"./index-qrnhvhmg.js";
-import"./index-7stsmndb.js";
-import"./index-kjbfry6m.js";
-import"./index-91qesget.js";
+import"./index-x12hvfpf.js";
+import"./index-n18yy0z1.js";
+import"./index-6f6y2rbp.js";
+import"./index-8f2270hc.js";
+import"./index-rk6qhyng.js";
 import"./index-bfwt3abw.js";
 import"./index-g40r5d08.js";
 import"./index-vxv732ex.js";
@@ -49,6 +49,21 @@ import"./index-a76rekgs.js";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
+
+// src/tools/repo-graph/safe-realpath.ts
+import { realpathSync } from "fs";
+function safeRealpathSync(targetPath, fallback, realpathResolver = realpathSync) {
+  try {
+    return realpathResolver(targetPath);
+  } catch (error) {
+    if (error instanceof Error && error.code === "ENOENT") {
+      return fallback;
+    }
+    return null;
+  }
+}
+
+// src/cli/index.ts
 var { version } = package_default;
 var CONFIG_DIR = getPluginConfigDir();
 var OPENCODE_CONFIG_PATH = path.join(CONFIG_DIR, "opencode.json");
@@ -56,14 +71,17 @@ var PLUGIN_CONFIG_PATH = path.join(CONFIG_DIR, "opencode-swarm.json");
 var PROMPTS_DIR = path.join(CONFIG_DIR, "opencode-swarm");
 var OPENCODE_PLUGIN_CACHE_PATHS = getPluginCachePaths();
 var OPENCODE_PLUGIN_LOCK_FILE_PATHS = getPluginLockFilePaths();
+function segmentDepthBelowRoot(resolved) {
+  const { root } = path.parse(resolved);
+  return resolved.slice(root.length).split(path.sep).filter((s) => s.length > 0).length;
+}
 function isSafeCachePath(p) {
   const resolved = path.resolve(p);
   const home = path.resolve(os.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path.sep).filter((s) => s.length > 0);
-  if (segments.length < 4) {
+  if (segmentDepthBelowRoot(resolved) < 4) {
     return false;
   }
   const leaf = path.basename(resolved);
@@ -86,8 +104,7 @@ function isSafeLockFilePath(p) {
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path.sep).filter((s) => s.length > 0);
-  if (segments.length < 4) {
+  if (segmentDepthBelowRoot(resolved) < 4) {
     return false;
   }
   const leaf = path.basename(resolved);
@@ -104,6 +121,48 @@ function isSafeLockFilePath(p) {
   }
   return true;
 }
+function isSafePromptsDir(p) {
+  const canonical = safeRealpathSync(p, p);
+  if (canonical === null) {
+    return false;
+  }
+  const resolved = path.resolve(canonical);
+  const home = path.resolve(os.homedir());
+  if (resolved === "/" || resolved === home || resolved.length <= home.length) {
+    return false;
+  }
+  if (segmentDepthBelowRoot(resolved) < 3) {
+    return false;
+  }
+  if (path.basename(resolved) !== "opencode-swarm") {
+    return false;
+  }
+  if (path.basename(path.dirname(resolved)) !== path.basename(CONFIG_DIR)) {
+    return false;
+  }
+  return true;
+}
+function isSafePluginConfigPath(p) {
+  const canonical = safeRealpathSync(p, p);
+  if (canonical === null) {
+    return false;
+  }
+  const resolved = path.resolve(canonical);
+  const home = path.resolve(os.homedir());
+  if (resolved === "/" || resolved === home || resolved.length <= home.length) {
+    return false;
+  }
+  if (segmentDepthBelowRoot(resolved) < 3) {
+    return false;
+  }
+  if (path.basename(resolved) !== "opencode-swarm.json") {
+    return false;
+  }
+  if (path.basename(path.dirname(resolved)) !== path.basename(CONFIG_DIR)) {
+    return false;
+  }
+  return true;
+}
 function ensureDir(dir) {
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
@@ -270,15 +329,18 @@ function evictPluginCaches() {
   for (const cachePath of OPENCODE_PLUGIN_CACHE_PATHS) {
     if (!fs.existsSync(cachePath))
       continue;
-    if (!isSafeCachePath(cachePath)) {
-      failed.push(`${cachePath} (refused: failed safety check)`);
+    const canonical = safeRealpathSync(cachePath, cachePath);
+    if (canonical === null || !fs.existsSync(canonical))
+      continue;
+    if (!isSafeCachePath(canonical)) {
+      failed.push(`${canonical} (refused: failed safety check)`);
       continue;
     }
     try {
-      fs.rmSync(cachePath, { recursive: true, force: true });
-      cleared.push(cachePath);
+      fs.rmSync(canonical, { recursive: true, force: true });
+      cleared.push(canonical);
     } catch (err) {
-      failed.push(`${cachePath} (${err instanceof Error ? err.message : String(err)})`);
+      failed.push(`${canonical} (${err instanceof Error ? err.message : String(err)})`);
     }
   }
   return { cleared, failed };
@@ -289,19 +351,22 @@ function evictLockFiles() {
   for (const lockPath of OPENCODE_PLUGIN_LOCK_FILE_PATHS) {
     if (!fs.existsSync(lockPath))
       continue;
-    if (!isSafeLockFilePath(lockPath)) {
-      failed.push(`${lockPath} (refused: failed safety check)`);
+    const canonical = safeRealpathSync(lockPath, lockPath);
+    if (canonical === null || !fs.existsSync(canonical))
+      continue;
+    if (!isSafeLockFilePath(canonical)) {
+      failed.push(`${canonical} (refused: failed safety check)`);
       continue;
     }
     try {
-      fs.unlinkSync(lockPath);
-      cleared.push(lockPath);
+      fs.unlinkSync(canonical);
+      cleared.push(canonical);
     } catch (err) {
       const code = err?.code;
       if (code === "EISDIR") {
-        failed.push(`${lockPath} (path is a directory, not a file)`);
+        failed.push(`${canonical} (path is a directory, not a file)`);
       } else {
-        failed.push(`${lockPath} (${err instanceof Error ? err.message : String(err)})`);
+        failed.push(`${canonical} (${err instanceof Error ? err.message : String(err)})`);
       }
     }
   }
@@ -346,14 +411,24 @@ async function uninstall() {
     if (process.argv.includes("--clean")) {
       let cleaned = false;
       if (fs.existsSync(PLUGIN_CONFIG_PATH)) {
-        fs.unlinkSync(PLUGIN_CONFIG_PATH);
-        console.log(`\u2713 Removed plugin config: ${PLUGIN_CONFIG_PATH}`);
-        cleaned = true;
+        const canonical = safeRealpathSync(PLUGIN_CONFIG_PATH, PLUGIN_CONFIG_PATH);
+        if (canonical === null || !isSafePluginConfigPath(canonical)) {
+          console.log(`\u2717 Refused to remove plugin config (failed safety check): ${canonical ?? PLUGIN_CONFIG_PATH}`);
+        } else {
+          fs.unlinkSync(canonical);
+          console.log(`\u2713 Removed plugin config: ${canonical}`);
+          cleaned = true;
+        }
       }
       if (fs.existsSync(PROMPTS_DIR)) {
-        fs.rmSync(PROMPTS_DIR, { recursive: true });
-        console.log(`\u2713 Removed custom prompts: ${PROMPTS_DIR}`);
-        cleaned = true;
+        const canonical = safeRealpathSync(PROMPTS_DIR, PROMPTS_DIR);
+        if (canonical === null || !isSafePromptsDir(canonical)) {
+          console.log(`\u2717 Refused to remove custom prompts (failed safety check): ${canonical ?? PROMPTS_DIR}`);
+        } else {
+          fs.rmSync(canonical, { recursive: true });
+          console.log(`\u2713 Removed custom prompts: ${canonical}`);
+          cleaned = true;
+        }
       }
       if (!cleaned) {
         console.log("\u2713 No config files to clean up");
@@ -474,6 +549,8 @@ Valid commands: ${VALID_COMMANDS.join(", ")}`);
 }
 export {
   run,
+  isSafePromptsDir,
+  isSafePluginConfigPath,
   isSafeLockFilePath,
   isSafeCachePath,
   evictPluginCaches,

package/dist/cli/{knowledge-escalator-qn7ew687.js → knowledge-escalator-5gwp1ar8.js}

@@ -8,9 +8,9 @@ import {
   maybeEscalateOnViolation,
   maybeQuarantineOnContradiction,
   readRecentEscalations
-} from "./index-7stsmndb.js";
-import"./index-kjbfry6m.js";
-import"./index-91qesget.js";
+} from "./index-6f6y2rbp.js";
+import"./index-8f2270hc.js";
+import"./index-rk6qhyng.js";
 import"./index-bfwt3abw.js";
 import"./index-g40r5d08.js";
 import"./index-jtqkh8jf.js";

package/dist/cli/{knowledge-events-k2xsz5bh.js → knowledge-events-m304swh6.js}

@@ -25,7 +25,7 @@ import {
   resolveKnowledgeCounterBaselinePath,
   resolveKnowledgeEventsPath,
   resolveLegacyApplicationLogPath
-} from "./index-kjbfry6m.js";
+} from "./index-8f2270hc.js";
 import"./index-g40r5d08.js";
 import"./index-zgwm4ryv.js";
 import"./index-0p660a87.js";

package/dist/cli/{knowledge-store-ksa1dr2z.js → knowledge-store-9babt8rd.js}

@@ -34,7 +34,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-91qesget.js";
+} from "./index-rk6qhyng.js";
 import"./index-bfwt3abw.js";
 import"./index-g40r5d08.js";
 import"./index-jtqkh8jf.js";

package/dist/cli/{knowledge-validator-2knz0d2t.js → knowledge-validator-t9sym59g.js}

@@ -16,14 +16,15 @@ import {
   quarantineEntry,
   resolveUnactionablePath,
   restoreEntry,
+  scanContentSafety,
   unarchiveEntry,
   validateActionability,
   validateActionableFields,
   validateLesson,
   validateSkillCandidatePath,
   validateSkillPath
-} from "./index-qrnhvhmg.js";
-import"./index-91qesget.js";
+} from "./index-n18yy0z1.js";
+import"./index-rk6qhyng.js";
 import"./index-bfwt3abw.js";
 import"./index-g40r5d08.js";
 import"./index-jtqkh8jf.js";
@@ -41,6 +42,7 @@ export {
   validateActionableFields,
   validateActionability,
   unarchiveEntry,
+  scanContentSafety,
   restoreEntry,
   resolveUnactionablePath,
   quarantineEntry,

package/dist/cli/{skill-generator-w6qd9mde.js → skill-generator-tav44xpm.js}

@@ -33,10 +33,10 @@ import {
   sanitizeSlug,
   selectCandidateEntries,
   writeEvalStub
-} from "./index-vjvdvjd3.js";
-import"./index-qrnhvhmg.js";
-import"./index-kjbfry6m.js";
-import"./index-91qesget.js";
+} from "./index-x12hvfpf.js";
+import"./index-n18yy0z1.js";
+import"./index-8f2270hc.js";
+import"./index-rk6qhyng.js";
 import"./index-bfwt3abw.js";
 import"./index-g40r5d08.js";
 import"./index-jtqkh8jf.js";

package/dist/commands/ci-monitor.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Handle /swarm ci-monitor command.
+ *
+ * Triggers the architect to enter MODE: CI_MONITOR — drives an already
+ * human-reviewed, approved PR to green and merged. Accepts a PR reference in
+ * the same three formats as /swarm pr-review and /swarm pr-feedback (full
+ * URL, owner/repo#N, or a bare PR number resolved against the origin
+ * remote). No free-text instructions are accepted: this is a mechanical,
+ * deliberately-invoked closeout flow, not a review or feedback session, and
+ * it performs a merge — trailing tokens after the PR reference are rejected
+ * with an explicit error rather than silently forwarded into the MODE
+ * signal, closing off any accidental or injected free-text channel into a
+ * merge-capable mode.
+ *
+ * PR-reference parsing and sanitization are shared with /swarm pr-review and
+ * /swarm pr-feedback via ./pr-ref.ts.
+ */
+export declare function handleCiMonitorCommand(directory: string, args: string[]): string;

package/dist/commands/registry.d.ts

@@ -512,6 +512,14 @@ export declare const COMMAND_REGISTRY: {
         readonly category: "agent";
         readonly toolPolicy: "none";
     };
+    readonly 'ci-monitor': {
+        readonly handler: (ctx: CommandContext) => CommandResult;
+        readonly description: "Drive an already-reviewed, approved PR to green and merged (monitor CI, fix, merge) [pr]";
+        readonly args: "<pr-url|owner/repo#N|N>";
+        readonly details: "Triggers MODE: CI_MONITOR — takes an already human-reviewed, approved PR, exhaustively researches every CI failure, fixes it end-to-end, iterates until all required checks are green (max 5 fix cycles), then merges via `gh pr merge` with no merge-strategy flag. Invoke only after human review is complete; the skill re-verifies reviewDecision: APPROVED and mergeable state before doing anything destructive. Distinct from /swarm pr-subscribe, which passively watches a PR without a merge terminal. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolved against origin).";
+        readonly category: "agent";
+        readonly toolPolicy: "none";
+    };
     readonly 'pr subscribe': {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Subscribe the current session to PR state-change notifications";

package/dist/config/skill-mirrors.d.ts

@@ -82,12 +82,33 @@ export declare const OPENCODE_ONLY_ARCHITECT_MODE_SKILLS: Array<{
  *    byte-identity contract to additional runtime mirrors when present.
  *  - `divergent`: both must exist; content intentionally differs per runtime.
  *  - `opencode-only`: `.opencode` exists; no `.claude` mirror expected.
+ *  - `adapter`: a non-architect-MODE skill whose `.opencode` copy is
+ *    canonical and has no `.claude` copy at all, but does have one or more
+ *    thin adapter shims (e.g. `.agents/skills/<slug>/`) that reference the
+ *    canonical file by a fixed substring (`expectedCanonicalRef`). Mirrors
+ *    the `ADAPTER_ARCHITECT_MODE_SKILLS` check, generalized to skills that
+ *    are not architect MODE skills (so `identical`/`divergent`, which both
+ *    require a `.claude` copy to exist, do not fit).
  */
 export declare const ADDITIONAL_SKILL_MIRROR_CONTRACTS: Array<{
     slug: string;
-    kind: 'identical' | 'divergent' | 'opencode-only';
+    kind: 'identical' | 'divergent' | 'opencode-only' | 'adapter';
     canonical?: '.claude' | '.opencode';
     extraIdenticalPaths?: string[];
+    /**
+     * For `divergent` pairs only: a set of Markdown section headings that must be
+     * present in BOTH trees (`.opencode` and `.claude`). Divergence is still
+     * allowed for genuinely runtime-specific prose (title line, `effort:`
+     * frontmatter, "(Claude Code)" phrasing), but these designated safety
+     * sections are parity-enforced by scripts/drift-check.ts so a whole safety
+     * guard cannot silently exist in one tree and be absent from the other.
+     * Match is a substring test, so a heading may omit a trailing parenthetical.
+     * Fixes the M13 skill-mirror safety-drift defect: the divergent branch
+     * previously did existence-only checks with no content comparison.
+     */
+    sharedSafetyHeadings?: string[];
+    adapterPaths?: string[];
+    expectedCanonicalRef?: string;
     reason: string;
 }>;
 /**

package/dist/hooks/adversarial-detector.d.ts

@@ -38,6 +38,12 @@ export declare function handleDebuggingSpiral(match: AdversarialPatternMatch, ta
     checkpointCreated: boolean;
     message: string;
 }>;
+/**
+ * Test seam: current number of distinct sessions tracked for spiral detection.
+ * Used by unit tests to assert the FIFO key-count cap holds; the map itself stays
+ * module-private so production callers cannot mutate it.
+ */
+export declare function recentToolCallSessionCount(): number;
 /**
  * Record a tool call for debugging spiral detection.
  * Call this from toolAfter to track repetitive patterns.