opencode-swarm 7.111.0 → 7.112.0

package/dist/cli/{index-7xfh4k71.js → index-j5c98bd9.js}

@@ -7,7 +7,7 @@ import {
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-xddysq89.js";
+} from "./index-xehrmy76.js";
 import {
   AGENT_TOOL_MAP,
   ALL_SUBAGENT_NAMES,
@@ -23,7 +23,7 @@ import {
   getCanonicalAgentRole,
   resolveExternalSkillsConfig,
   stripKnownSwarmPrefix
-} from "./index-0g5xsrp4.js";
+} from "./index-cq2hgvd2.js";
 import {
   MAX_TRANSIENT_RETRIES,
   PlanSchema,
@@ -39,6 +39,7 @@ import {
   disableEpicMode,
   enableEpicMode,
   getAllWorktreeMergeFailures,
+  getDefaultBaseBranch,
   getDurableGateEvidenceStatusForTask,
   getExecutor,
   getGitRepositoryStatus,
@@ -67,7 +68,7 @@ import {
   savePlan,
   transientBackoff,
   validateProjectRoot
-} from "./index-j2v3w1ds.js";
+} from "./index-d0w40jm3.js";
 import {
   buildOpenSpecProjectionSync,
   detectSpeckit,
@@ -82,13 +83,13 @@ import {
   _internals1 as _internals2,
   isCommandAvailable,
   tool
-} from "./index-yw8qpf51.js";
+} from "./index-9fxs0rm1.js";
 import {
   buildCorrelationId,
   listActive,
   subscribe,
   unsubscribe
-} from "./index-85bacexr.js";
+} from "./index-q1jaeynn.js";
 import {
   DEFAULT_SKILL_MIN_CONFIDENCE,
   DEFAULT_SKILL_MIN_CONFIRMATIONS,
@@ -105,7 +106,7 @@ import {
   retireOrMarkStale,
   retireSkill,
   selectCandidateEntries
-} from "./index-cmjq1kg7.js";
+} from "./index-b83y9a7r.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -115,10 +116,10 @@ import {
   validateActionability,
   validateActionableFields,
   validateLesson
-} from "./index-c483hnn4.js";
+} from "./index-hg0pamsa.js";
 import {
   readRecentEscalations
-} from "./index-mvg66d9n.js";
+} from "./index-2aqs6daa.js";
 import {
   effectiveRetrievalOutcomes,
   readKnowledgeCounterRollups,
@@ -126,7 +127,7 @@ import {
   recordHiveKnowledgeEvent,
   recordKnowledgeEvent,
   resolveKnowledgeEventsPath
-} from "./index-yhmt3dw3.js";
+} from "./index-cye4g7zj.js";
 import {
   appendKnowledge,
   appendRejectedLesson,
@@ -148,7 +149,7 @@ import {
   rewriteKnowledge,
   transactFile,
   transactKnowledge
-} from "./index-v8pk35h7.js";
+} from "./index-t7efm8vz.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -162,7 +163,7 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-40h0yp9e.js";
+} from "./index-db1fh1fv.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -174,12 +175,12 @@ import {
 } from "./index-wvrj16f0.js";
 import {
   clearAllScopes
-} from "./index-vzzt3ygr.js";
+} from "./index-g55nzpwn.js";
 import {
   readSwarmFileAsync,
   safeHook,
   validateSwarmPath
-} from "./index-r3j3458j.js";
+} from "./index-1rga1vvb.js";
 import {
   deepMerge
 } from "./index-p0arc26j.js";
@@ -191,7 +192,7 @@ import {
 } from "./index-zgwm4ryv.js";
 import {
   atomicWriteFile
-} from "./index-1cn967sa.js";
+} from "./index-0dab9w37.js";
 import {
   exports_external
 } from "./index-293f68mj.js";
@@ -208,7 +209,7 @@ import {
   bunSpawn,
   bunWrite,
   mergeEnvForChild
-} from "./index-7xgqky26.js";
+} from "./index-h91bv3hy.js";
 import {
   __require,
   __toESM
@@ -472,7 +473,8 @@ var _internals4 = {
   platform: process.platform,
   sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
   cleanupOrphanedBranches,
-  startupOrphanRecovery
+  startupOrphanRecovery,
+  extractSessionId
 };
 var MERGE_TIMEOUT_MS = 30000;
 async function runGit(args, cwd, timeoutMs = MERGE_TIMEOUT_MS) {
@@ -5034,11 +5036,11 @@ var BUNDLED_PROJECT_SKILLS = [
   "running-tests",
   "engineering-conventions",
   "commit-pr",
-  "worktree-retry-cleanup",
-  "skill-edit-validation",
-  "merge-queue-readiness",
+  "ci-failure-batching",
   "gate-attribution",
-  "ci-failure-batching"
+  "merge-queue-readiness",
+  "skill-edit-validation",
+  "worktree-retry-cleanup"
 ];
 var MAX_SKILL_FILES = 64;
 var MAX_SKILL_BYTES = 512000;
@@ -6557,6 +6559,8 @@ async function handleList2(directory) {
 
 // src/commands/ci-simulate.ts
 import * as fs4 from "fs";
+import * as fsPromises2 from "fs/promises";
+import * as os5 from "os";
 import * as path13 from "path";
 
 // src/utils/external-tool-runner.ts
@@ -6719,148 +6723,254 @@ var _internals7 = {
 };
 
 // src/commands/ci-simulate.ts
-var DEFAULT_BASE = "origin/main";
-var DEFAULT_HEAD = "HEAD";
-var DEFAULT_CI_COMMANDS = [
-  ["bun", "run", "typecheck"],
-  ["bun", "run", "lint:ci"],
-  ["bun", "run", "build"],
-  ["bun", "run", "test:unit:ci"],
-  ["bun", "test", "tests/integration", "--timeout", "120000"],
-  ["bun", "test", "tests/security", "--timeout", "120000"],
-  ["bun", "test", "tests/smoke", "--timeout", "120000"],
-  ["bun", "run", "drift:check"]
-];
-var COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
-var GIT_TIMEOUT_MS2 = 60 * 1000;
-var OUTPUT_LIMIT = 12000;
-async function runCommand(cmd, cwd, timeout) {
+var GIT_TIMEOUT_MS2 = 30000;
+var VALIDATION_TIMEOUT_MS = 5 * 60 * 1000;
+var OUTPUT_LIMIT_BYTES = 12000;
+var _internals8 = {
+  runExternalTool,
+  getDefaultBaseBranch,
+  platform: process.platform,
+  osTmpdir: () => os5.tmpdir(),
+  fs: {
+    existsSync: fs4.existsSync,
+    rmSync: fs4.rmSync
+  }
+};
+async function runGit2(args, cwd, timeoutMs = GIT_TIMEOUT_MS2) {
+  const result = await _internals8.runExternalTool({
+    executable: "git",
+    args,
+    cwd,
+    timeoutMs,
+    maxStdoutBytes: OUTPUT_LIMIT_BYTES,
+    maxStderrBytes: OUTPUT_LIMIT_BYTES
+  });
+  return {
+    exitCode: result.exitCode ?? 1,
+    stdout: result.message ? [result.message, result.stdout].filter(Boolean).join(`
+`) : result.stdout,
+    stderr: result.stderr,
+    outputTruncated: result.stdoutTruncated || result.stderrTruncated
+  };
+}
+async function runValidationCommand(cmd, cwd, timeoutMs = VALIDATION_TIMEOUT_MS) {
   const [executable, ...args] = cmd;
-  const result = await runExternalTool({
+  const result = await _internals8.runExternalTool({
     executable,
     args,
     cwd,
-    timeoutMs: timeout,
-    maxStdoutBytes: OUTPUT_LIMIT,
-    maxStderrBytes: OUTPUT_LIMIT
+    timeoutMs,
+    maxStdoutBytes: OUTPUT_LIMIT_BYTES,
+    maxStderrBytes: OUTPUT_LIMIT_BYTES
   });
   return {
     exitCode: result.exitCode ?? 1,
     stdout: result.message ? [result.message, result.stdout].filter(Boolean).join(`
 `) : result.stdout,
     stderr: result.stderr,
-    stdoutTruncated: result.stdoutTruncated,
-    stderrTruncated: result.stderrTruncated
+    outputTruncated: result.stdoutTruncated || result.stderrTruncated
   };
 }
-function readOptionalFlag(args, name) {
-  const index = args.indexOf(name);
-  if (index < 0)
-    return null;
-  const value = args[index + 1];
-  return value && !value.startsWith("--") ? value : null;
+function isSafeGitRef(ref) {
+  return ref.length > 0 && ref.length <= 255 && /^[A-Za-z0-9][A-Za-z0-9._/@-]*$/.test(ref) && !ref.includes("..") && !ref.includes("//") && !ref.includes("@{") && !ref.endsWith(".");
 }
-function readFlag(args, name, fallback) {
-  return readOptionalFlag(args, name) ?? fallback;
+async function getCurrentBranchOrRef(directory) {
+  const result = await runGit2(["branch", "--show-current"], directory);
+  if (result.exitCode === 0 && result.stdout.trim()) {
+    return result.stdout.trim();
+  }
+  const hashResult = await runGit2(["rev-parse", "HEAD"], directory);
+  return hashResult.stdout.trim();
 }
-function hasUnsupportedArgs(args) {
-  const allowedWithValue = new Set(["--base", "--head"]);
-  for (let i = 0;i < args.length; i++) {
-    const arg = args[i];
-    if (!arg.startsWith("--"))
-      return `unexpected positional argument ${arg}`;
-    if (!allowedWithValue.has(arg))
-      return arg;
-    const value = args[i + 1];
-    if (!value || value.startsWith("--"))
-      return `missing value for ${arg}`;
-    i++;
+async function setupWorktree(projectRoot, prRef, baseBranch, onWorktreeCreated) {
+  const worktreeBase = path13.join(_internals8.osTmpdir(), "swarm-ci-simulate");
+  const worktreeName = `pr-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
+  const worktreePath = path13.join(worktreeBase, worktreeName);
+  await fsPromises2.mkdir(worktreeBase, { recursive: true });
+  const addResult = await runGit2(["worktree", "add", "--detach", worktreePath, baseBranch], projectRoot);
+  if (addResult.exitCode !== 0) {
+    throw new Error(`Failed to create worktree: ${addResult.stderr.trim() || addResult.stdout.trim()}`);
   }
-  return null;
+  onWorktreeCreated(worktreePath);
+  const mergeResult = await runGit2(["merge", "--no-ff", "--no-edit", "--", prRef], worktreePath, GIT_TIMEOUT_MS2 * 2);
+  if (mergeResult.exitCode !== 0) {
+    throw new Error(`Merge failed for '${prRef}': ${mergeResult.stderr.trim() || mergeResult.stdout.trim()}`);
+  }
+  return worktreePath;
 }
-var _internals8 = {
-  runCommand,
-  now: () => Date.now(),
-  mkdirSync: fs4.mkdirSync
-};
-function formatResult(prefix, result) {
-  const output = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join(`
-`);
-  const suffix = result.stdoutTruncated || result.stderrTruncated ? `
-
-[output truncated to bounded limit]` : "";
-  return output ? `${prefix}
-
-${output}${suffix}` : `${prefix}${suffix}`;
+async function cleanupWorktree(worktreePath, projectRoot) {
+  const removeResult = await runGit2(["worktree", "remove", "--force", worktreePath], projectRoot);
+  try {
+    if (_internals8.fs.existsSync(worktreePath)) {
+      _internals8.fs.rmSync(worktreePath, { recursive: true, force: true });
+    }
+  } catch {}
+  if (removeResult.exitCode !== 0) {
+    console.warn(`[ci-simulate] git worktree remove failed: ${removeResult.stderr.trim() || removeResult.stdout.trim()}`);
+  }
+}
+async function runValidationSuite(worktreePath) {
+  const steps = [];
+  const commands = [
+    { step: "typecheck", cmd: ["bun", "run", "typecheck"] },
+    { step: "lint", cmd: ["bun", "run", "lint"] },
+    { step: "build", cmd: ["bun", "run", "build"] },
+    { step: "test", cmd: ["bun", "test"] }
+  ];
+  for (const { step, cmd } of commands) {
+    const start = Date.now();
+    const result = await runValidationCommand(cmd, worktreePath);
+    const durationMs = Date.now() - start;
+    steps.push({
+      step,
+      command: cmd.join(" "),
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      durationMs,
+      outputTruncated: result.outputTruncated
+    });
+  }
+  return steps;
+}
+function formatStepOutput(stdout, stderr, outputTruncated, maxLength = 2000) {
+  let output = stdout;
+  if (stderr) {
+    output += output ? `
+${stderr}` : stderr;
+  }
+  if (output.length > maxLength) {
+    output = `${output.slice(0, maxLength)}
+... (output truncated)`;
+  }
+  if (outputTruncated) {
+    output = `${output}
+... (child output truncated to bounded limit)`;
+  }
+  return output;
+}
+function extractFileLineReferences(output) {
+  const lines = [];
+  const patterns = [
+    /([A-Za-z]:[\\/])?[^\s:]+\.(ts|tsx|js|jsx):(\d+):(\d+)/g,
+    /(?:error|Error|FAIL|Failed)[:\s]+([^\s]+\.(ts|tsx|js|jsx)?:?:\d+)/gi,
+    /FAIL\s+([^\s]+\.(test|spec)\.(ts|tsx|js|jsx))/gi
+  ];
+  for (const pattern of patterns) {
+    const matches = Array.from(output.matchAll(pattern));
+    for (const match of matches) {
+      if (match[0]) {
+        lines.push(match[0]);
+      }
+    }
+  }
+  return Array.from(new Set(lines));
 }
 async function handleCiSimulateCommand(directory, args) {
-  const unsupportedArg = hasUnsupportedArgs(args);
-  if (unsupportedArg) {
-    const reason = unsupportedArg.startsWith("--") ? `unsupported argument ${unsupportedArg}` : unsupportedArg;
-    return `CI simulation failed: ${reason}. Supported arguments: --base <ref> --head <ref>.`;
-  }
-  const base = readFlag(args, "--base", DEFAULT_BASE);
-  const headFlag = readOptionalFlag(args, "--head");
-  const ciCommands = DEFAULT_CI_COMMANDS;
-  let head2 = headFlag ?? DEFAULT_HEAD;
-  if (!headFlag) {
-    const currentHead = await _internals8.runCommand(["git", "-C", directory, "rev-parse", "HEAD"], directory, GIT_TIMEOUT_MS2);
-    if (currentHead.exitCode !== 0) {
-      return formatResult("CI simulation failed: could not resolve the current worktree HEAD.", currentHead);
-    }
-    head2 = currentHead.stdout.trim();
-  }
-  const worktreeBase = path13.join(directory, ".swarm", "ci-simulate");
-  const worktreePath = path13.join(worktreeBase, `merge-${_internals8.now()}-${Math.random().toString(36).slice(2)}`);
-  _internals8.mkdirSync(worktreeBase, { recursive: true });
-  let cleanupError;
-  let createdWorktree = false;
-  let response;
-  try {
-    const add = await _internals8.runCommand([
-      "git",
-      "-C",
-      directory,
-      "worktree",
-      "add",
-      "--detach",
-      worktreePath,
-      base
-    ], directory, GIT_TIMEOUT_MS2);
-    if (add.exitCode !== 0) {
-      response = formatResult(`CI simulation failed: could not create temp worktree from ${base}.`, add);
-    } else {
-      createdWorktree = true;
-      const merge = await _internals8.runCommand(["git", "-C", worktreePath, "merge", "--no-edit", head2], worktreePath, GIT_TIMEOUT_MS2);
-      if (merge.exitCode !== 0) {
-        response = formatResult(`CI simulation failed: ${head2} does not merge cleanly into ${base}.`, merge);
-      } else {
-        for (const ciCommand of ciCommands) {
-          const ci = await _internals8.runCommand(ciCommand, worktreePath, COMMAND_TIMEOUT_MS);
-          if (ci.exitCode !== 0) {
-            response = formatResult(`CI simulation failed after merging ${head2} into ${base}: ${ciCommand.join(" ")}`, ci);
-            break;
+  const prRef = args[0] ?? await getCurrentBranchOrRef(directory);
+  if (!isSafeGitRef(prRef)) {
+    return "CI simulation failed: PR ref must be a safe git branch or commit reference.";
+  }
+  const lines = [];
+  lines.push(`# CI Simulation Report`);
+  lines.push("");
+  lines.push(`PR ref: **${prRef}**`);
+  lines.push(`Started: ${new Date().toISOString()}`);
+  lines.push("");
+  let worktreePath;
+  const result = {
+    success: false,
+    worktreePath: "",
+    steps: []
+  };
+  try {
+    const baseBranch = _internals8.getDefaultBaseBranch(directory);
+    if (!isSafeGitRef(baseBranch)) {
+      throw new Error("Detected default branch is not a safe git reference.");
+    }
+    lines.push("## Setup");
+    lines.push("");
+    lines.push(`Creating temporary worktree from ${baseBranch}...`);
+    worktreePath = await setupWorktree(directory, prRef, baseBranch, (createdPath) => {
+      worktreePath = createdPath;
+    });
+    result.worktreePath = worktreePath;
+    lines.push(`Worktree: \`${worktreePath}\``);
+    lines.push("");
+    const mergeCheckResult = await runGit2(["log", "--oneline", "-1", "--format=%s"], worktreePath);
+    const lastCommit = mergeCheckResult.stdout.trim();
+    lines.push(`Last commit in worktree: \`${lastCommit}\``);
+    lines.push("");
+    lines.push("## Validation Suite");
+    lines.push("");
+    result.steps = await runValidationSuite(worktreePath);
+    for (const step of result.steps) {
+      const status = step.exitCode === 0 ? "\u2705 PASS" : "\u274C FAIL";
+      lines.push(`### ${status}: ${step.step}`);
+      lines.push("");
+      lines.push(`Command: \`${step.command}\``);
+      lines.push(`Duration: ${(step.durationMs / 1000).toFixed(1)}s`);
+      if (step.exitCode !== 0) {
+        lines.push(`Exit code: ${step.exitCode}`);
+        const fileRefs = extractFileLineReferences(`${step.stdout}
+${step.stderr}`);
+        if (fileRefs.length > 0) {
+          lines.push("");
+          lines.push("**Failure locations:**");
+          for (const ref of fileRefs.slice(0, 20)) {
+            lines.push(`  - \`${ref}\``);
           }
         }
-        response ??= `CI simulation passed after merging ${head2} into ${base}: ${ciCommands.map((cmd) => cmd.join(" ")).join(" && ")}`;
+        lines.push("");
+        lines.push("**Output:**");
+        lines.push("```");
+        lines.push(formatStepOutput(step.stdout, step.stderr, step.outputTruncated));
+        lines.push("```");
       }
+      lines.push("");
     }
-  } finally {
-    if (createdWorktree) {
-      const remove = await _internals8.runCommand(["git", "-C", directory, "worktree", "remove", "--force", worktreePath], directory, GIT_TIMEOUT_MS2);
-      if (remove.exitCode !== 0) {
-        cleanupError = remove.stderr.trim() || remove.stdout.trim();
+    const allPassed = result.steps.every((s) => s.exitCode === 0);
+    result.success = allPassed;
+    lines.push("## Summary");
+    lines.push("");
+    const passed = result.steps.filter((s) => s.exitCode === 0).length;
+    const failed = result.steps.filter((s) => s.exitCode !== 0).length;
+    lines.push(`Validation: ${passed}/${result.steps.length} steps passed, ${failed} failed`);
+    lines.push("");
+    if (allPassed) {
+      lines.push("\u2705 **All checks passed \u2014 CI simulation succeeded**");
+    } else {
+      lines.push(`\u274C **CI simulation failed \u2014 these failures would cause a merge-queue kick-out**`);
+      lines.push("");
+      lines.push("To reproduce locally, run in the worktree:");
+      lines.push(`\`\`\`bash`);
+      lines.push(`cd "${worktreePath}"`);
+      for (const step of result.steps.filter((s) => s.exitCode !== 0)) {
+        lines.push(`# ${step.step}: ${step.command}`);
       }
+      lines.push(`\`\`\``);
+    }
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    result.error = errMsg;
+    lines.push("");
+    lines.push("## Error");
+    lines.push("");
+    lines.push(`\`\`\``);
+    lines.push(errMsg);
+    lines.push(`\`\`\``);
+  } finally {
+    if (worktreePath) {
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+      lines.push("*Cleaning up temporary worktree...*");
+      await cleanupWorktree(worktreePath, directory);
+      lines.push(`Worktree removed: \`${worktreePath}\``);
     }
-    await _internals8.runCommand(["git", "-C", directory, "worktree", "prune"], directory, GIT_TIMEOUT_MS2);
-  }
-  if (cleanupError) {
-    const cleanupMessage = `CI simulation cleanup failed: ${cleanupError}`;
-    return response ? `${response}
-
-${cleanupMessage}` : cleanupMessage;
   }
-  return response ?? "CI simulation failed: no result was produced.";
+  return lines.join(`
+`);
 }
 
 // src/commands/clarify.ts
@@ -6879,7 +6989,7 @@ import { promises as fs10 } from "fs";
 import path30 from "path";
 
 // src/hooks/curator-postmortem.ts
-import { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
 import * as path18 from "path";
 
 // src/hooks/curator.ts
@@ -7298,8 +7408,8 @@ import { readFile as readFile5, rename as rename4, writeFile as writeFile5 } fro
 
 // src/services/skill-improver-quota.ts
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import { existsSync as existsSync7 } from "fs";
-import { mkdir as mkdir4, readFile as readFile4, rename as rename3, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { mkdir as mkdir5, readFile as readFile4, rename as rename3, writeFile as writeFile4 } from "fs/promises";
 import * as path14 from "path";
 var LOCK_ACQUIRE_TIMEOUT_MS = 1e4;
 var LOCK_RETRY_OPTS = {
@@ -7341,7 +7451,7 @@ function todayKey(window, now = new Date) {
   return `${yr}-${m}-${d}`;
 }
 async function readState(filePath) {
-  if (!existsSync7(filePath))
+  if (!existsSync8(filePath))
     return null;
   try {
     const raw = await readFile4(filePath, "utf-8");
@@ -7355,7 +7465,7 @@ async function readState(filePath) {
   }
 }
 async function writeState(filePath, state) {
-  await mkdir4(path14.dirname(filePath), { recursive: true });
+  await mkdir5(path14.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}`;
   await writeFile4(tmp, JSON.stringify(state, null, 2), "utf-8");
   await rename3(tmp, filePath);
@@ -7378,7 +7488,7 @@ async function getQuotaState(directory, opts) {
 }
 async function reserveQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir4(path14.dirname(filePath), { recursive: true });
+  await mkdir5(path14.dirname(filePath), { recursive: true });
   let release = null;
   try {
     release = await acquireLock(path14.dirname(filePath));
@@ -7408,7 +7518,7 @@ async function reserveQuota(directory, opts) {
 }
 async function releaseQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir4(path14.dirname(filePath), { recursive: true });
+  await mkdir5(path14.dirname(filePath), { recursive: true });
   let release = null;
   try {
     release = await acquireLock(path14.dirname(filePath));
@@ -9087,7 +9197,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     if (config.skill_generation_enabled === true && skillCandidates.length > 0) {
       try {
-        const skillModule = await import("./skill-generator-5rsjmmfq.js");
+        const skillModule = await import("./skill-generator-2tsqqaa2.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -9368,7 +9478,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-0dkkenp2.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-t1e2211j.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -9872,7 +9982,7 @@ async function repairPostMortemActions(llmOutput, diagnostics, options) {
 }
 function readJsonlFile(filePath, maxLines) {
   try {
-    if (!existsSync10(filePath))
+    if (!existsSync11(filePath))
       return [];
     const content = readFileSync6(filePath, "utf-8");
     const results = [];
@@ -9896,12 +10006,12 @@ function collectRetrospectives(directory) {
   const results = [];
   const evidenceDir = path18.join(directory, ".swarm", "evidence");
   try {
-    if (!existsSync10(evidenceDir))
+    if (!existsSync11(evidenceDir))
       return results;
     const retroDirs = readdirSync2(evidenceDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("retro-")).slice(0, MAX_RETROSPECTIVES);
     for (const entry of retroDirs) {
       const retroPath = path18.join(evidenceDir, entry.name, "evidence.json");
-      if (existsSync10(retroPath)) {
+      if (existsSync11(retroPath)) {
         try {
           results.push(readFileSync6(retroPath, "utf-8"));
         } catch {}
@@ -9921,7 +10031,7 @@ async function collectDriftReports(directory) {
 function collectPendingProposals(directory) {
   const results = [];
   const insightPath = path18.join(directory, ".swarm", "insight-candidates.jsonl");
-  if (existsSync10(insightPath)) {
+  if (existsSync11(insightPath)) {
     try {
       results.push({
         source: "insight-candidates",
@@ -9931,7 +10041,7 @@ function collectPendingProposals(directory) {
   }
   const proposalsDir = path18.join(directory, ".swarm", "skills", "proposals");
   try {
-    if (existsSync10(proposalsDir)) {
+    if (existsSync11(proposalsDir)) {
       const proposalFiles = readdirSync2(proposalsDir).filter((e) => e.endsWith(".md") || e.endsWith(".json")).slice(0, MAX_PROPOSALS);
       for (const entry of proposalFiles) {
         try {
@@ -9947,7 +10057,7 @@ function collectPendingProposals(directory) {
 }
 function isReportValid(reportPath) {
   try {
-    if (!existsSync10(reportPath))
+    if (!existsSync11(reportPath))
       return false;
     const content = readFileSync6(reportPath, "utf-8").trim();
     if (content.length === 0)
@@ -10270,8 +10380,8 @@ ${actionSummary}`;
       reportContent = _internals12.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
     }
     try {
-      const { mkdirSync: mkdirSync9 } = await import("fs");
-      mkdirSync9(path18.dirname(reportPath), { recursive: true });
+      const { mkdirSync: mkdirSync8 } = await import("fs");
+      mkdirSync8(path18.dirname(reportPath), { recursive: true });
       await atomicWriteFile(reportPath, reportContent);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -10325,15 +10435,15 @@ var _internals12 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async () => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-s48je8zt.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-2p15yrvn.js");
     return KnowledgeConfigSchema2.parse({});
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-2hm297yd.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-j7ty8k6t.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig);
   },
   checkHivePromotions: async (entries, knowledgeConfig) => {
-    const { checkHivePromotions } = await import("./hive-promoter-0f8xh2rn.js");
+    const { checkHivePromotions } = await import("./hive-promoter-y179n7wx.js");
     return checkHivePromotions(entries, knowledgeConfig);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -10342,7 +10452,7 @@ var _internals12 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-5rsjmmfq.js");
+    } = await import("./skill-generator-2tsqqaa2.js");
     const result = {
       approved: [],
       rejected: [],
@@ -10384,7 +10494,7 @@ var _internals12 = {
     return result;
   },
   readPriorDriftReports: async (directory) => {
-    const { readPriorDriftReports } = await import("./curator-drift-169wgaxn.js");
+    const { readPriorDriftReports } = await import("./curator-drift-jvs1v6em.js");
     return readPriorDriftReports(directory);
   },
   readSwarmKnowledge: (directory) => readKnowledge(resolveSwarmKnowledgePath(directory))
@@ -10673,14 +10783,14 @@ async function promoteFromSwarm(directory, lessonId) {
 
 // src/hooks/knowledge-curator.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync13 } from "fs";
-import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync14 } from "fs";
+import { appendFile as appendFile2, mkdir as mkdir7, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
 import * as path24 from "path";
 
 // src/services/synonym-map.ts
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
 import {
-  mkdir as mkdir5,
+  mkdir as mkdir6,
   readFile as readFile6,
   rename as rename5,
   stat as stat3,
@@ -10842,7 +10952,7 @@ async function readSynonymMap(directory, maxPairs = DEFAULT_MAX_PAIRS) {
   }
 }
 async function writeSynonymMapAtomic(filePath, map) {
-  await mkdir5(path20.dirname(filePath), { recursive: true });
+  await mkdir6(path20.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
     await writeFile6(tmp, JSON.stringify(map, null, 2), "utf-8");
@@ -10856,7 +10966,7 @@ async function writeSynonymMapAtomic(filePath, map) {
 async function rebuildSynonymMap(directory, entries, maxPairs = DEFAULT_MAX_PAIRS) {
   const filePath = resolveSynonymMapPath(directory);
   const dir = path20.dirname(filePath);
-  await mkdir5(dir, { recursive: true });
+  await mkdir6(dir, { recursive: true });
   let release = null;
   try {
     release = await import_proper_lockfile2.default.lock(dir, {
@@ -10913,7 +11023,7 @@ function reinforceSwarmKnowledgeEntry(entry, confirmation) {
 }
 
 // src/hooks/micro-reflector.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
 import * as path23 from "path";
 init_logger();
@@ -11948,7 +12058,7 @@ async function readTaskTrajectory(directory, taskId) {
   try {
     const rel = path23.join("evidence", sanitizeTaskId(taskId), "trajectory.jsonl");
     const filePath = validateSwarmPath(directory, rel);
-    if (!existsSync12(filePath))
+    if (!existsSync13(filePath))
       return [];
     const content = await readFile7(filePath, "utf-8");
     const out = [];
@@ -12377,7 +12487,7 @@ RETRY: your last output was missing ${result.missing.join("; ")}; produce valid
 async function appendCuratorSkippedEvent(directory, record) {
   try {
     const filePath = path24.join(directory, ".swarm", "events.jsonl");
-    await mkdir6(path24.dirname(filePath), { recursive: true });
+    await mkdir7(path24.dirname(filePath), { recursive: true });
     await appendFile2(filePath, `${JSON.stringify({
       timestamp: new Date().toISOString(),
       event: "curator_skipped",
@@ -12417,7 +12527,7 @@ function readInsightJsonl(content) {
 async function consumeInsightCandidates(directory, batchLimit = MESO_INSIGHT_BATCH_LIMIT) {
   try {
     const filePath = resolveInsightCandidatesPath(directory);
-    if (!existsSync13(filePath))
+    if (!existsSync14(filePath))
       return [];
     const consumed = [];
     await transactFile(filePath, async (p) => readInsightJsonl(await readFile8(p, "utf-8").catch(() => "")), async (p, data) => {
@@ -13342,13 +13452,13 @@ async function writeSessionReflection(directory, result) {
 }
 
 // src/services/skill-improver.ts
-import { existsSync as existsSync15 } from "fs";
-import { mkdir as mkdir8, readFile as readFile9, rename as rename6, writeFile as writeFile10 } from "fs/promises";
+import { existsSync as existsSync16 } from "fs";
+import { mkdir as mkdir9, readFile as readFile9, rename as rename6, writeFile as writeFile10 } from "fs/promises";
 import * as path27 from "path";
 init_logger();
 
 // src/services/trajectory-cluster.ts
-import { mkdir as mkdir7, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir8, writeFile as writeFile9 } from "fs/promises";
 import * as path26 from "path";
 init_logger();
 var MACRO_TRAJECTORY_WINDOW = 200;
@@ -13482,7 +13592,7 @@ async function writeMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const proposalsDir = validateSwarmPath(directory, path26.join("skills", "proposals"));
-    await mkdir7(proposalsDir, { recursive: true });
+    await mkdir8(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = `motif-${slugify(motif.signature)}`;
       const filePath = path26.join(proposalsDir, `${slug}.md`);
@@ -13627,7 +13737,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const proposalsDir = validateSwarmPath(directory, path26.join("skills", "proposals"));
-    await mkdir7(proposalsDir, { recursive: true });
+    await mkdir8(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = workflowSlug(motif.signature);
       const filePath = path26.join(proposalsDir, `${slug}.md`);
@@ -13642,14 +13752,14 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
 }
 
 // src/services/unactionable-hardening.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 init_logger();
 var HARDENING_BATCH_LIMIT = 5;
 async function hardenUnactionableEntries(params) {
   const result = { hardened: 0, retired: 0, remaining: 0 };
   try {
     const queuePath = resolveUnactionablePath(params.directory);
-    if (!existsSync14(queuePath))
+    if (!existsSync15(queuePath))
       return result;
     const limit = params.batchLimit ?? HARDENING_BATCH_LIMIT;
     const dedupThreshold = params.dedupThreshold ?? 0.6;
@@ -13753,7 +13863,7 @@ function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
 }
 async function atomicWrite(p, content) {
-  await mkdir8(path27.dirname(p), { recursive: true });
+  await mkdir9(path27.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   await writeFile10(tmp, content, "utf-8");
   await rename6(tmp, p);
@@ -13761,7 +13871,7 @@ async function atomicWrite(p, content) {
 async function gatherInventory(directory) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync15(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync16(hivePath) ? await readKnowledge(hivePath) : [];
   const archived = [...swarm, ...hive].filter((e) => e.status === "archived").length;
   const skills = await listSkills(directory);
   const knowledgeById = new Map([...swarm, ...hive].map((entry) => [entry.id, entry]));
@@ -14226,7 +14336,7 @@ var _internals17 = {
 };
 
 // src/session/session-start-store.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
 import * as path28 from "path";
 var SESSION_START_FILE = "session-start.jsonl";
 function recordSessionStart(directory, startMs) {
@@ -14235,7 +14345,7 @@ function recordSessionStart(directory, startMs) {
     const sessionDir = path28.join(swarmDir, "session");
     const filePath = path28.join(sessionDir, SESSION_START_FILE);
     const line = JSON.stringify({ startMs, ts: Date.now() });
-    mkdirSync10(sessionDir, { recursive: true });
+    mkdirSync9(sessionDir, { recursive: true });
     writeFileSync4(filePath, `${line}
 `, { flag: "a" });
   } catch {}
@@ -14243,7 +14353,7 @@ function recordSessionStart(directory, startMs) {
 function readEarliestSessionStart(directory) {
   try {
     const filePath = path28.join(directory, ".swarm", "session", SESSION_START_FILE);
-    if (!existsSync16(filePath))
+    if (!existsSync17(filePath))
       return null;
     const content = readFileSync8(filePath, "utf-8");
     const lines = content.split(`
@@ -14268,7 +14378,7 @@ function readEarliestSessionStart(directory) {
 }
 
 // src/tools/write-retro.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import path29 from "path";
 async function executeWriteRetro(args, directory) {
   if (/^(CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(:|$)/i.test(directory)) {
@@ -14277,7 +14387,7 @@ async function executeWriteRetro(args, directory) {
       message: "Invalid directory: reserved device name"
     }, null, 2);
   }
-  if (!existsSync17(path29.join(directory, ".swarm"))) {
+  if (!existsSync18(path29.join(directory, ".swarm"))) {
     return JSON.stringify({
       success: false,
       message: `Cannot write evidence in "${directory}" \u2014 no .swarm/ folder was found. Run write_retro from an initialized project root.`
@@ -15042,7 +15152,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-s48je8zt.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-2p15yrvn.js");
     const { config: pmLoadedConfig } = _internals19.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -16021,10 +16131,10 @@ function buildStatusMessage(session, plan) {
 }
 
 // src/commands/config.ts
-import * as os5 from "os";
+import * as os6 from "os";
 import * as path31 from "path";
 function getUserConfigDir2() {
-  return process.env.XDG_CONFIG_HOME || path31.join(os5.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path31.join(os6.homedir(), ".config");
 }
 async function handleConfigCommand(directory, _args) {
   const config = loadPluginConfig(directory);
@@ -16047,8 +16157,8 @@ async function handleConfigCommand(directory, _args) {
 }
 
 // src/services/skill-consolidation.ts
-import { existsSync as existsSync19 } from "fs";
-import { mkdir as mkdir9, readFile as readFile10, rename as rename7, writeFile as writeFile11 } from "fs/promises";
+import { existsSync as existsSync20 } from "fs";
+import { mkdir as mkdir10, readFile as readFile10, rename as rename7, writeFile as writeFile11 } from "fs/promises";
 import * as path32 from "path";
 
 // src/utils/timeout.ts
@@ -16078,7 +16188,7 @@ function consolidationStatePath(directory) {
 }
 async function readState2(directory) {
   const filePath = consolidationStatePath(directory);
-  if (!existsSync19(filePath))
+  if (!existsSync20(filePath))
     return {};
   try {
     const parsed = JSON.parse(await readFile10(filePath, "utf-8"));
@@ -16090,7 +16200,7 @@ async function readState2(directory) {
   }
 }
 async function atomicWrite2(filePath, content) {
-  await mkdir9(path32.dirname(filePath), { recursive: true });
+  await mkdir10(path32.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
   await writeFile11(tmp, content, "utf-8");
   await rename7(tmp, filePath);
@@ -17155,9 +17265,9 @@ var _internals23 = {
   readSwarmFileAsync,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-s48je8zt.js"),
-      import("./curator-2hm297yd.js"),
-      import("./curator-llm-factory-19s0r5v6.js")
+      import("./schema-2p15yrvn.js"),
+      import("./curator-j7ty8k6t.js"),
+      import("./curator-llm-factory-8rnk2083.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -17647,13 +17757,13 @@ ${USAGE5}`;
 
 // src/services/diagnose-service.ts
 import * as child_process5 from "child_process";
-import { existsSync as existsSync22, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
+import { existsSync as existsSync23, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
 import * as path37 from "path";
 import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.111.0",
+  version: "7.112.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",
@@ -17722,11 +17832,13 @@ var package_default = {
     ".opencode/skills/running-tests",
     ".opencode/skills/engineering-conventions",
     ".opencode/skills/commit-pr",
-    ".opencode/skills/worktree-retry-cleanup",
-    ".opencode/skills/skill-edit-validation",
-    ".opencode/skills/merge-queue-readiness",
-    ".opencode/skills/gate-attribution",
     ".opencode/skills/ci-failure-batching",
+    ".opencode/skills/gate-attribution",
+    ".opencode/skills/merge-queue-readiness",
+    ".opencode/skills/skill-edit-validation",
+    ".opencode/skills/swarm",
+    ".opencode/skills/swarm-ci-monitor",
+    ".opencode/skills/worktree-retry-cleanup",
     "tests/fixtures/memory-recall",
     "README.md",
     "LICENSE"
@@ -17770,13 +17882,13 @@ var package_default = {
 };
 
 // src/config/cache-paths.ts
-import * as os6 from "os";
+import * as os7 from "os";
 import * as path36 from "path";
 function getPluginConfigDir() {
-  return path36.join(process.env.XDG_CONFIG_HOME || path36.join(os6.homedir(), ".config"), "opencode");
+  return path36.join(process.env.XDG_CONFIG_HOME || path36.join(os7.homedir(), ".config"), "opencode");
 }
 function getPluginCachePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path36.join(os6.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path36.join(os7.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
     path36.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
@@ -17784,18 +17896,18 @@ function getPluginCachePaths() {
     path36.join(configDir, "node_modules", "opencode-swarm")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path36.join(os6.homedir(), "Library", "Caches");
+    const libCaches = path36.join(os7.homedir(), "Library", "Caches");
     paths.push(path36.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path36.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path36.join(os6.homedir(), "AppData", "Local");
-    const appData = process.env.APPDATA || path36.join(os6.homedir(), "AppData", "Roaming");
+    const localAppData = process.env.LOCALAPPDATA || path36.join(os7.homedir(), "AppData", "Local");
+    const appData = process.env.APPDATA || path36.join(os7.homedir(), "AppData", "Roaming");
     paths.push(path36.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path36.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path36.join(appData, "opencode", "node_modules", "opencode-swarm"));
   }
   return paths;
 }
 function getPluginLockFilePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path36.join(os6.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path36.join(os7.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
     path36.join(cacheBase, "opencode", "bun.lock"),
@@ -17803,11 +17915,11 @@ function getPluginLockFilePaths() {
     path36.join(configDir, "package-lock.json")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path36.join(os6.homedir(), "Library", "Caches");
+    const libCaches = path36.join(os7.homedir(), "Library", "Caches");
     paths.push(path36.join(libCaches, "opencode", "bun.lock"), path36.join(libCaches, "opencode", "bun.lockb"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path36.join(os6.homedir(), "AppData", "Local");
+    const localAppData = process.env.LOCALAPPDATA || path36.join(os7.homedir(), "AppData", "Local");
     paths.push(path36.join(localAppData, "opencode", "bun.lock"), path36.join(localAppData, "opencode", "bun.lockb"));
   }
   return paths;
@@ -17818,11 +17930,11 @@ init_capability_probe();
 init_executor();
 
 // src/services/knowledge-diagnostics.ts
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import { readFile as readFile12 } from "fs/promises";
 
 // src/services/version-check.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join31 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
@@ -17839,7 +17951,7 @@ function cacheFile() {
 function readVersionCache() {
   try {
     const path37 = cacheFile();
-    if (!existsSync20(path37))
+    if (!existsSync21(path37))
       return null;
     const raw = readFileSync9(path37, "utf-8");
     const parsed = JSON.parse(raw);
@@ -17893,7 +18005,7 @@ var SEVEN_DAYS_MS2 = 7 * 24 * 60 * 60 * 1000;
 var UNACTIONABLE_BACKLOG_WARN = 100;
 var INSIGHT_BACKLOG_WARN = 50;
 async function readRawLines(filePath) {
-  if (!existsSync21(filePath))
+  if (!existsSync22(filePath))
     return { entries: [], corrupt: 0 };
   const content = await readFile12(filePath, "utf-8");
   const entries = [];
@@ -18018,7 +18130,7 @@ async function computeKnowledgeDebug(directory) {
   };
 }
 async function safeJsonlCount(filePath) {
-  if (!filePath || !existsSync21(filePath))
+  if (!filePath || !existsSync22(filePath))
     return 0;
   try {
     const content = await readFile12(filePath, "utf-8");
@@ -18097,7 +18209,7 @@ var REQUIRED_CACHE_GRAMMAR_ASSETS = [
 ];
 function resolveCachePackageRoot(cachePath) {
   const nestedPackageRoot = path37.join(cachePath, "node_modules", "opencode-swarm");
-  return existsSync22(nestedPackageRoot) ? nestedPackageRoot : cachePath;
+  return existsSync23(nestedPackageRoot) ? nestedPackageRoot : cachePath;
 }
 var _internals24 = {
   detectSandboxCapability: () => sandboxCapabilityProbe.detect(),
@@ -18348,7 +18460,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync22(directory) || !statSync6(directory).isDirectory()) {
+    if (!existsSync23(directory) || !statSync6(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "\u274C",
@@ -18413,7 +18525,7 @@ async function checkSpecStaleness(directory, plan) {
 }
 async function checkConfigParseability(directory) {
   const configPath = path37.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync22(configPath)) {
+  if (!existsSync23(configPath)) {
     return {
       name: "Config Parseability",
       status: "\u2705",
@@ -18468,11 +18580,11 @@ async function checkGrammarWasmFiles() {
   const thisDir = path37.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync22(path37.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync23(path37.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file of grammarFiles) {
-    if (!existsSync22(path37.join(grammarDir, file))) {
+    if (!existsSync23(path37.join(grammarDir, file))) {
       missing.push(file);
     }
   }
@@ -18491,7 +18603,7 @@ async function checkGrammarWasmFiles() {
 }
 async function checkCheckpointManifest(directory) {
   const manifestPath = path37.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync22(manifestPath)) {
+  if (!existsSync23(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "\u2705",
@@ -18543,7 +18655,7 @@ async function checkCheckpointManifest(directory) {
 }
 async function checkEventStreamIntegrity(directory) {
   const eventsPath = path37.join(directory, ".swarm/events.jsonl");
-  if (!existsSync22(eventsPath)) {
+  if (!existsSync23(eventsPath)) {
     return {
       name: "Event Stream",
       status: "\u2705",
@@ -18584,7 +18696,7 @@ async function checkEventStreamIntegrity(directory) {
 }
 async function checkSteeringDirectives(directory) {
   const eventsPath = path37.join(directory, ".swarm/events.jsonl");
-  if (!existsSync22(eventsPath)) {
+  if (!existsSync23(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "\u2705",
@@ -18640,7 +18752,7 @@ async function checkCurator(directory) {
       };
     }
     const summaryPath = path37.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync22(summaryPath)) {
+    if (!existsSync23(summaryPath)) {
       return {
         name: "Curator",
         status: "\u2705",
@@ -18842,7 +18954,7 @@ async function getDiagnoseData(directory) {
   checks.push(await checkKnowledgeHealth(directory));
   try {
     const evidenceDir = path37.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync22(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const snapshotFiles = existsSync23(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks.push({
@@ -18875,13 +18987,13 @@ async function getDiagnoseData(directory) {
   const cacheRows = [];
   for (const cachePath of cachePaths) {
     try {
-      if (!existsSync22(cachePath)) {
+      if (!existsSync23(cachePath)) {
         cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
         continue;
       }
       const packageRoot = resolveCachePackageRoot(cachePath);
       const cacheLabel = packageRoot === cachePath ? cachePath : `${cachePath} -> ${packageRoot}`;
-      const missingGrammarAssets = REQUIRED_CACHE_GRAMMAR_ASSETS.filter((file) => !existsSync22(path37.join(packageRoot, "dist", "lang", "grammars", file)));
+      const missingGrammarAssets = REQUIRED_CACHE_GRAMMAR_ASSETS.filter((file) => !existsSync23(path37.join(packageRoot, "dist", "lang", "grammars", file)));
       const pkgJsonPath = path37.join(packageRoot, "package.json");
       try {
         const raw = readFileSync10(pkgJsonPath, "utf-8");
@@ -19107,7 +19219,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-q5e9yzn6.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-mmw4c50z.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true);
     output = formatDoctorMarkdown(fixResult.result);
   } else {
@@ -19920,7 +20032,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-8tasw2tt.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-j6fnsfeq.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -20007,7 +20119,8 @@ function emptyCounters() {
     reviewerRejections: 0,
     testFailures: 0,
     oversightChecks: 0,
-    consecutiveNoProgressTurns: 0
+    consecutiveNoProgressTurns: 0,
+    consecutiveOversightFailures: 0
   };
 }
 var VALID_RUN_MODES = new Set(["assisted", "supervised", "strict"]);
@@ -20237,6 +20350,11 @@ function startFullAutoRun(directory, sessionID, config, options = {}) {
       denialCounters: {
         consecutive: 0,
         total: existing.denialCounters.total
+      },
+      consecutiveOversightFailures: 0,
+      counters: {
+        ...existing.counters,
+        consecutiveOversightFailures: 0
       }
     } : {
       ...emptyState(sessionID, mode),
@@ -20804,7 +20922,7 @@ var _internals27 = {
 };
 
 // src/session/snapshot-writer.ts
-import { closeSync as closeSync5, fsyncSync as fsyncSync2, mkdirSync as mkdirSync17, openSync as openSync5, renameSync as renameSync8 } from "fs";
+import { closeSync as closeSync5, fsyncSync as fsyncSync2, mkdirSync as mkdirSync16, openSync as openSync5, renameSync as renameSync8 } from "fs";
 import * as path42 from "path";
 var _writeInFlight = Promise.resolve();
 function serializeAgentSession(s) {
@@ -20919,7 +21037,7 @@ async function writeSnapshot(directory, state) {
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
     const dir = path42.dirname(resolvedPath);
-    mkdirSync17(dir, { recursive: true });
+    mkdirSync16(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
     try {
@@ -21443,9 +21561,9 @@ import { join as join37 } from "path";
 // src/hooks/knowledge-migrator.ts
 init_logger();
 import { randomUUID as randomUUID7 } from "crypto";
-import { existsSync as existsSync27, readFileSync as readFileSync15 } from "fs";
-import { mkdir as mkdir10, readFile as readFile13, writeFile as writeFile12 } from "fs/promises";
-import * as os7 from "os";
+import { existsSync as existsSync28, readFileSync as readFileSync15 } from "fs";
+import { mkdir as mkdir11, readFile as readFile13, writeFile as writeFile12 } from "fs/promises";
+import * as os8 from "os";
 import * as path43 from "path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   const externalSentinelPath = path43.join(_directory, ".swarm", ".knowledge-external-migrated");
@@ -21507,17 +21625,17 @@ var _internals30 = {
   inferProjectName,
   writeSentinel,
   resolveLegacyHiveKnowledgePath,
-  existsSync: existsSync27,
+  existsSync: existsSync28,
   readFileSync: readFileSync15,
   readFile: readFile13,
-  mkdir: mkdir10,
+  mkdir: mkdir11,
   writeFile: writeFile12
 };
 async function migrateContextToKnowledge(directory, config) {
   const sentinelPath = path43.join(directory, ".swarm", ".knowledge-migrated");
   const contextPath = path43.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync27(sentinelPath)) {
+  if (existsSync28(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -21526,7 +21644,7 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync27(contextPath)) {
+  if (!existsSync28(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -21618,7 +21736,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   const legacyHivePath = _internals30.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
   const sentinelPath = path43.join(path43.dirname(canonicalHivePath), ".hive-knowledge-migrated");
-  if (existsSync27(sentinelPath)) {
+  if (existsSync28(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -21627,7 +21745,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync27(legacyHivePath)) {
+  if (!existsSync28(legacyHivePath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -21829,7 +21947,7 @@ function truncateLesson2(text) {
 }
 function inferProjectName(directory) {
   const packageJsonPath = path43.join(directory, "package.json");
-  if (existsSync27(packageJsonPath)) {
+  if (existsSync28(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync15(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
@@ -21854,7 +21972,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
 }
 function resolveLegacyHiveKnowledgePath() {
   const platform = process.platform;
-  const home = process.env.HOME || os7.homedir();
+  const home = process.env.HOME || os8.homedir();
   let dataDir;
   if (platform === "win32") {
     dataDir = path43.join(process.env.LOCALAPPDATA || path43.join(home, "AppData", "Local"), "opencode-swarm", "Data");
@@ -22293,7 +22411,7 @@ var _internals31 = {
 };
 
 // src/commands/link.ts
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import * as path45 from "path";
 
 // src/knowledge/identity.ts
@@ -22323,7 +22441,7 @@ var DEDUP_THRESHOLD = 0.6;
 async function mergeLocalKnowledgeIntoLink(localSwarmDir, linkDir) {
   const localPath = path45.join(localSwarmDir, "knowledge.jsonl");
   const sharedPath = path45.join(linkDir, "knowledge.jsonl");
-  if (!existsSync28(localPath))
+  if (!existsSync29(localPath))
     return { merged: 0, skipped: 0 };
   let merged = 0;
   let skipped = 0;
@@ -22616,12 +22734,12 @@ ${USAGE7}`;
 }
 
 // src/commands/memory.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import * as path48 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 // src/memory/evaluation.ts
 import * as fs16 from "fs/promises";
-import * as os8 from "os";
+import * as os9 from "os";
 import * as path46 from "path";
 var DEFAULT_PROVIDERS = [
   "local-jsonl",
@@ -22643,7 +22761,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs16.realpath(await fs16.mkdtemp(path46.join(os8.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs16.realpath(await fs16.mkdtemp(path46.join(os9.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -22976,7 +23094,7 @@ var CuratorOutputMemoryDecisionSchema = exports_external.object({
   curatorMemoryDecisions: exports_external.array(CuratorMemoryDecisionSchema).max(20).optional()
 }).passthrough();
 // src/memory/consolidation-log.ts
-import { appendFile as appendFile3, mkdir as mkdir11, readFile as readFile15 } from "fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir12, readFile as readFile15 } from "fs/promises";
 import * as path47 from "path";
 var LOG_RELATIVE_PATH = path47.join("memory", "consolidation-log.jsonl");
 async function readConsolidationLog(directory) {
@@ -23060,7 +23178,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Provider: \`${config.provider}\``,
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
-    `- SQLite database exists: \`${existsSync29(sqlitePath)}\``,
+    `- SQLite database exists: \`${existsSync30(sqlitePath)}\``,
     `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
@@ -23962,8 +24080,21 @@ async function listMergeGroupRuns(directory, repoFullName, prNumber) {
   }
   return { runs: parseMergeGroupRuns(result.stdout, prNumber) };
 }
+function formatMergeGroupStatus(status, conclusion, htmlUrl) {
+  if (!status)
+    return "Merge group: unknown";
+  const parts = [`Merge group: ${status}`];
+  if (conclusion) {
+    parts.push(conclusion);
+  }
+  if (htmlUrl) {
+    parts.push(`(${htmlUrl})`);
+  }
+  return parts.join(" ");
+}
 var _internals35 = {
   formatRelativeTime,
+  formatMergeGroupStatus,
   listActive,
   listMergeGroupRuns,
   parseMergeGroupRuns
@@ -24007,6 +24138,7 @@ async function handlePrMonitorStatusCommand(directory, _args, sessionID, source)
     }
     lines.push(`     Last checked: ${formatRelativeTime(sub.lastCheckedAt)}`);
     lines.push(`     Watching: ${sub.isWatching ? "yes" : "no"}`);
+    lines.push(`     ${formatMergeGroupStatus(sub.mergeGroupRunStatus, sub.mergeGroupRunConclusion, sub.mergeGroupRunHtmlUrl)}`);
     lines.push(`     Errors: ${sub.errorCount}`);
     if (i < subs.length - 1) {
       lines.push("");
@@ -26698,7 +26830,7 @@ var DISPATCH_FRAMEWORK_MAP = {
 };
 async function detectTestFrameworkViaDispatch(cwd) {
   try {
-    const { pickBackend } = await import("./dispatch-zr1xja4t.js");
+    const { pickBackend } = await import("./dispatch-wst7bypk.js");
     const backend = await pickBackend(cwd);
     if (!backend?.selectTestFramework)
       return "none";
@@ -26714,7 +26846,7 @@ async function buildTestCommandViaDispatch(framework, scope, files, coverage, ba
   if (framework === "none")
     return null;
   try {
-    const { pickBackend } = await import("./dispatch-zr1xja4t.js");
+    const { pickBackend } = await import("./dispatch-wst7bypk.js");
     const backend = await pickBackend(baseDir);
     if (backend?.buildTestCommand) {
       const cmd = backend.buildTestCommand(framework, files, baseDir, {
@@ -26734,7 +26866,7 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
   if (framework === "none")
     return null;
   try {
-    const { pickBackend } = await import("./dispatch-zr1xja4t.js");
+    const { pickBackend } = await import("./dispatch-wst7bypk.js");
     const backend = await pickBackend(baseDir);
     if (!backend?.parseTestOutput)
       return null;
@@ -32266,13 +32398,13 @@ function buildStatusMessage2(session, directory, sessionID) {
 }
 
 // src/commands/unlink.ts
-import { existsSync as existsSync40 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 import * as path65 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 (!existsSync40(sharedPath))
+  if (!existsSync41(sharedPath))
     return 0;
   const sharedEntries = await readKnowledge(sharedPath);
   if (sharedEntries.length === 0)
@@ -32468,7 +32600,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-kf2h31c7.js");
+    const { buildHelpText } = await import("./index-c3h3d8kh.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -32477,7 +32609,7 @@ async function handleHelpCommand(ctx) {
     return _internals48.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals48.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-kf2h31c7.js");
+  const { buildHelpText: fullHelp } = await import("./index-c3h3d8kh.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -32610,7 +32742,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-8w9rkdjx.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-2j0gw8f0.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -32620,7 +32752,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-973nan7m.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-xjgr00eq.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -34589,6 +34721,18 @@ Every listed directive ID MUST appear exactly once. If a directive carries a ver
 FIXES: required changes if rejected
 Use INFO only inside ISSUES for non-blocking suggestions. RISK reflects the highest blocking severity, so it never uses INFO.
 
+## MULTI-TASK COVERAGE (FR-007)
+When you are asked to review multiple tasks in a single dispatch (set-dispatch), emit one structured verdict line PER TASK at the END of your output (after all other output fields). This enables per-task attribution in the gate tracker:
+
+[REVIEWED] | task-<taskId> | APPROVED | <brief summary>
+[REVIEWED] | task-<taskId> | REJECTED | <brief summary>
+
+Example:
+[REVIEWED] | task-2.1 | APPROVED | No issues found in src/foo.ts
+[REVIEWED] | task-2.2 | REJECTED | Missing null check in bar() at line 42
+
+If covering a single task only, you do not need to emit the structured verdict line.
+
 ## OUTPUT ORDER FOR SKILL COMPLIANCE (when applicable)
 When SKILLS_USED_BY_CODER is provided, output TASK: immediately followed by SKILL_COMPLIANCE to ensure proper attribution:
 TASK: <task-id-or-unknown>
@@ -37564,7 +37708,7 @@ function hasActiveEpicMode(sessionID) {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-vv8byxe6.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-p8g2rzxd.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)