opencode-swarm 7.32.3 → 7.33.1

package/dist/index.js

@@ -48,7 +48,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.32.3",
+    version: "7.33.1",
     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",
@@ -15539,8 +15539,12 @@ var init_schema = __esm(() => {
   });
   MemoryConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
-    provider: exports_external.literal("local-jsonl").default("local-jsonl"),
+    provider: exports_external.enum(["local-jsonl", "sqlite"]).default("local-jsonl"),
     storageDir: exports_external.string().default(".swarm/memory"),
+    sqlite: exports_external.object({
+      path: exports_external.string().default(".swarm/memory/memory.db"),
+      busyTimeoutMs: exports_external.number().int().min(0).max(60000).default(5000)
+    }).default({ path: ".swarm/memory/memory.db", busyTimeoutMs: 5000 }),
     recall: exports_external.object({
       defaultMaxItems: exports_external.number().int().min(1).max(20).default(8),
       defaultTokenBudget: exports_external.number().int().min(100).max(5000).default(1200),
@@ -17366,6 +17370,32 @@ async function appendLedgerEvent(directory, eventInput, options) {
   fs4.renameSync(tempPath, ledgerPath);
   return event;
 }
+async function takeSnapshotWithRetry(directory, plan, options) {
+  const MAX_RETRIES = 3;
+  const TOTAL_ATTEMPTS = 1 + MAX_RETRIES;
+  const telemetrySource = options?.source ?? "save_plan_tool";
+  const snapshotOptions = { planHashAfter: options?.planHashAfter };
+  let lastError;
+  for (let attempt = 1;attempt <= TOTAL_ATTEMPTS; attempt++) {
+    try {
+      await takeSnapshotEvent(directory, plan, snapshotOptions);
+      return;
+    } catch (err2) {
+      lastError = err2 instanceof Error ? err2 : new Error(String(err2));
+      if (attempt < TOTAL_ATTEMPTS) {
+        await new Promise((r) => setTimeout(r, 10 * 2 ** (attempt - 1)));
+      }
+    }
+  }
+  console.warn(`[takeSnapshotWithRetry] Snapshot failed after ${MAX_RETRIES} retries (${TOTAL_ATTEMPTS} attempts): ${lastError.message}`);
+  try {
+    emit("snapshot_failed", {
+      error: lastError.message,
+      retries: MAX_RETRIES,
+      source: telemetrySource
+    });
+  } catch {}
+}
 async function takeSnapshotEvent(directory, plan, options) {
   const payloadHash = computePlanHash(plan);
   const snapshotPayload = {
@@ -17599,6 +17629,7 @@ async function loadLastApprovedPlan(directory, expectedPlanId) {
 var LEDGER_SCHEMA_VERSION = "1.1.0", LEDGER_FILENAME = "plan-ledger.jsonl", PLAN_JSON_FILENAME = "plan.json", LedgerStaleWriterError;
 var init_ledger = __esm(() => {
   init_plan_schema();
+  init_telemetry();
   LedgerStaleWriterError = class LedgerStaleWriterError extends Error {
     constructor(message) {
       super(message);
@@ -17792,7 +17823,9 @@ async function loadPlan(directory) {
                 try {
                   const rebuilt = await replayFromLedger(directory);
                   if (rebuilt) {
-                    await rebuildPlan(directory, rebuilt);
+                    await rebuildPlan(directory, rebuilt, {
+                      reason: "ledger_hash_mismatch_recovery"
+                    });
                     warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at .swarm/SWARM_PLAN.md if it exists.");
                     return rebuilt;
                   }
@@ -17800,7 +17833,9 @@ async function loadPlan(directory) {
                   try {
                     const approved = await loadLastApprovedPlan(directory, currentPlanId);
                     if (approved) {
-                      await rebuildPlan(directory, approved.plan);
+                      await rebuildPlan(directory, approved.plan, {
+                        reason: "approved_snapshot_fallback"
+                      });
                       try {
                         await takeSnapshotEvent(directory, approved.plan, {
                           source: "recovery_from_approved_snapshot",
@@ -17877,7 +17912,9 @@ async function loadPlan(directory) {
           } else if (catchFirstEvent !== null && rawPlanId !== null) {
             const rebuilt = await replayFromLedger(directory);
             if (rebuilt) {
-              await rebuildPlan(directory, rebuilt);
+              await rebuildPlan(directory, rebuilt, {
+                reason: "validation_failure_recovery"
+              });
               warn("[loadPlan] Rebuilt plan from ledger after validation failure. Projection was stale.");
               return rebuilt;
             }
@@ -18238,12 +18275,9 @@ async function savePlan(directory, plan, options) {
   const SNAPSHOT_INTERVAL = 50;
   const latestSeq = await getLatestLedgerSeq(directory);
   if (latestSeq > 0 && latestSeq % SNAPSHOT_INTERVAL === 0) {
-    await takeSnapshotEvent(directory, validated, {
-      planHashAfter: hashAfter
-    }).catch((err2) => {
-      if (process.env.DEBUG_SWARM) {
-        warn(`[savePlan] Periodic snapshot write failed (non-fatal): ${err2 instanceof Error ? err2.message : String(err2)}`);
-      }
+    await takeSnapshotWithRetry(directory, validated, {
+      planHashAfter: hashAfter,
+      source: "savePlan_manager"
     });
   }
   const swarmDir = path6.resolve(directory, ".swarm");
@@ -18257,6 +18291,17 @@ async function savePlan(directory, plan, options) {
       unlinkSync(tempPath);
     } catch {}
   }
+  try {
+    const markerPath = path6.join(swarmDir, ".plan-write-marker");
+    const inProgressMarker = JSON.stringify({
+      source: "plan_manager",
+      timestamp: new Date().toISOString(),
+      phases_count: validated.phases.length,
+      tasks_count: validated.phases.reduce((sum, p) => sum + p.tasks.length, 0),
+      in_progress: true
+    });
+    await bunWrite(markerPath, inProgressMarker);
+  } catch {}
   try {
     const contentHash = computePlanContentHash(validated);
     const markdown = derivePlanMarkdown(validated);
@@ -18290,41 +18335,146 @@ ${markdown}`;
       source: "plan_manager",
       timestamp: new Date().toISOString(),
       phases_count: validated.phases.length,
-      tasks_count: tasksCount
+      tasks_count: tasksCount,
+      in_progress: false
     });
     await bunWrite(markerPath, marker);
   } catch {}
 }
-async function rebuildPlan(directory, plan) {
+async function rebuildPlan(directory, plan, options) {
   const targetPlan = plan ?? await replayFromLedger(directory);
   if (!targetPlan)
     return null;
   const swarmDir = path6.join(directory, ".swarm");
   const planPath = path6.join(swarmDir, "plan.json");
   const mdPath = path6.join(swarmDir, "plan.md");
-  const tempPlanPath = path6.join(swarmDir, `plan.json.rebuild.${Date.now()}`);
+  const tempPlanPath = path6.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(targetPlan, null, 2));
   renameSync3(tempPlanPath, planPath);
-  const contentHash = computePlanContentHash(targetPlan);
-  const markdown = derivePlanMarkdown(targetPlan);
-  const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
-${markdown}`;
-  const tempMdPath = path6.join(swarmDir, `plan.md.rebuild.${Date.now()}`);
-  await bunWrite(tempMdPath, markdownWithHash);
-  renameSync3(tempMdPath, mdPath);
   try {
     const markerPath = path6.join(swarmDir, ".plan-write-marker");
-    const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
-    const marker = JSON.stringify({
+    const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
       phases_count: targetPlan.phases.length,
-      tasks_count: tasksCount
+      tasks_count: targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0),
+      in_progress: true
     });
-    await bunWrite(markerPath, marker);
+    await bunWrite(markerPath, inProgressMarker);
+  } catch {}
+  try {
+    const contentHash = computePlanContentHash(targetPlan);
+    const markdown = derivePlanMarkdown(targetPlan);
+    const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
+${markdown}`;
+    const tempMdPath = path6.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    await bunWrite(tempMdPath, markdownWithHash);
+    renameSync3(tempMdPath, mdPath);
+  } finally {
+    try {
+      const markerPath = path6.join(swarmDir, ".plan-write-marker");
+      const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
+      const marker = JSON.stringify({
+        source: "plan_manager",
+        timestamp: new Date().toISOString(),
+        phases_count: targetPlan.phases.length,
+        tasks_count: tasksCount,
+        in_progress: false
+      });
+      await bunWrite(markerPath, marker);
+    } catch {}
+  }
+  try {
+    const planId = derivePlanId(targetPlan);
+    const planHashAfter = computePlanHash(targetPlan);
+    await appendLedgerEvent(directory, {
+      event_type: "plan_rebuilt",
+      source: "rebuildPlan",
+      plan_id: planId,
+      payload: {
+        reason: options?.reason ?? "ledger_replay_recovery",
+        phases_count: targetPlan.phases.length,
+        tasks_count: targetPlan.phases.reduce((sum, p) => sum + p.tasks.length, 0)
+      }
+    }, { planHashAfter });
   } catch {}
   return targetPlan;
 }
+async function closePlanTerminalState(directory, plan, options) {
+  const planId = derivePlanId(plan);
+  const validated = PlanSchema.parse(plan);
+  const hashAfter = computePlanHash(validated);
+  for (const taskId of options.closedTaskIds) {
+    let taskPhaseId;
+    for (const phase of validated.phases) {
+      if (phase.tasks.some((t) => t.id === taskId)) {
+        taskPhaseId = phase.id;
+        break;
+      }
+    }
+    const fromStatus = options.originalStatuses?.get(taskId) ?? "in_progress";
+    await appendLedgerEvent(directory, {
+      plan_id: planId,
+      event_type: "task_status_changed",
+      task_id: taskId,
+      phase_id: taskPhaseId,
+      from_status: fromStatus,
+      to_status: "closed",
+      source: "close_terminal"
+    }, { planHashAfter: hashAfter });
+  }
+  for (const phaseId of options.closedPhaseIds) {
+    await appendLedgerEvent(directory, {
+      plan_id: planId,
+      event_type: "phase_completed",
+      phase_id: phaseId,
+      source: "close_terminal"
+    }, { planHashAfter: hashAfter });
+  }
+  await takeSnapshotEvent(directory, validated, {
+    planHashAfter: hashAfter,
+    source: "close_terminal"
+  });
+  const swarmDir = path6.join(directory, ".swarm");
+  const planPath = path6.join(swarmDir, "plan.json");
+  const tempPlanPath = path6.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  await bunWrite(tempPlanPath, JSON.stringify(validated, null, 2));
+  renameSync3(tempPlanPath, planPath);
+  try {
+    const markerPath = path6.join(swarmDir, ".plan-write-marker");
+    const inProgressMarker = JSON.stringify({
+      source: "plan_manager_close",
+      timestamp: new Date().toISOString(),
+      phases_count: validated.phases.length,
+      tasks_count: validated.phases.reduce((sum, phase) => sum + phase.tasks.length, 0),
+      in_progress: true
+    });
+    await bunWrite(markerPath, inProgressMarker);
+  } catch {}
+  try {
+    const mdPath = path6.join(swarmDir, "plan.md");
+    const contentHash = computePlanContentHash(validated);
+    const markdown = derivePlanMarkdown(validated);
+    const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
+${markdown}`;
+    const mdTempPath = path6.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    await bunWrite(mdTempPath, markdownWithHash);
+    renameSync3(mdTempPath, mdPath);
+  } finally {
+    try {
+      const markerPath = path6.join(swarmDir, ".plan-write-marker");
+      const tasksCount = validated.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
+      const marker = JSON.stringify({
+        source: "plan_manager_close",
+        timestamp: new Date().toISOString(),
+        phases_count: validated.phases.length,
+        tasks_count: tasksCount,
+        in_progress: false
+      });
+      await bunWrite(markerPath, marker);
+    } catch {}
+  }
+}
 async function updateTaskStatus(directory, taskId, status) {
   const derivePhaseStatusFromTasks = (tasks) => {
     if (tasks.length > 0 && tasks.every((task) => task.status === "completed")) {
@@ -58840,6 +58990,12 @@ async function handleCloseCommand(directory, args2, options = {}) {
     }
   }
   if (planExists) {
+    const originalStatuses = new Map;
+    for (const phase of planData.phases ?? []) {
+      for (const task of phase.tasks ?? []) {
+        originalStatuses.set(task.id, task.status);
+      }
+    }
     const guaranteeResult = guaranteeAllPlansComplete(planData);
     for (const phaseId of guaranteeResult.closedPhaseIds) {
       if (!closedPhases.includes(phaseId)) {
@@ -58853,11 +59009,15 @@ async function handleCloseCommand(directory, args2, options = {}) {
     }
     if (!planAlreadyDone || guaranteeResult.closedPhaseIds.length > 0 || guaranteeResult.closedTaskIds.length > 0) {
       try {
-        await fs13.writeFile(planPath, JSON.stringify(planData, null, 2), "utf-8");
+        await closePlanTerminalState(directory, planData, {
+          closedPhaseIds: guaranteeResult.closedPhaseIds,
+          closedTaskIds: guaranteeResult.closedTaskIds,
+          originalStatuses
+        });
       } catch (error93) {
         const msg = error93 instanceof Error ? error93.message : String(error93);
-        warnings.push(`Failed to persist terminal plan.json state: ${msg}`);
-        console.warn("[close-command] Failed to write plan.json:", error93);
+        warnings.push(`Failed to persist terminal plan state: ${msg}`);
+        console.warn("[close-command] Failed to write terminal plan state:", error93);
       }
     }
   }
@@ -59145,6 +59305,7 @@ var init_close = __esm(() => {
   init_knowledge_curator();
   init_knowledge_store();
   init_utils2();
+  init_manager();
   init_scope_persistence();
   init_skill_improver();
   init_state();
@@ -59887,6 +60048,120 @@ function getPluginCachePaths() {
 }
 var init_cache_paths = () => {};
 
+// src/evidence/gate-bridge.ts
+async function readDurableGateEvidence(directory, taskId) {
+  try {
+    return await readTaskEvidence(directory, taskId);
+  } catch {
+    return null;
+  }
+}
+function getDurableGateEvidenceStatus(evidence) {
+  if (!evidence?.gates || typeof evidence.gates !== "object") {
+    return {
+      isComplete: false,
+      missingGates: [],
+      evidenceExists: evidence != null,
+      invalid: false
+    };
+  }
+  if (!Array.isArray(evidence.required_gates) || evidence.required_gates.length === 0) {
+    return {
+      isComplete: false,
+      missingGates: ["required_gates"],
+      evidenceExists: true,
+      invalid: false
+    };
+  }
+  const missingGates = evidence.required_gates.filter((gate) => evidence.gates[gate] == null);
+  return {
+    isComplete: missingGates.length === 0,
+    missingGates,
+    evidenceExists: true,
+    invalid: false
+  };
+}
+async function getDurableGateEvidenceStatusForTask(directory, taskId) {
+  if (!isValidTaskId(taskId)) {
+    return {
+      isComplete: false,
+      missingGates: [],
+      evidenceExists: false,
+      invalid: false
+    };
+  }
+  try {
+    return getDurableGateEvidenceStatus(readTaskEvidenceRaw(directory, taskId));
+  } catch {
+    return {
+      isComplete: false,
+      missingGates: ["invalid_gate_evidence"],
+      evidenceExists: true,
+      invalid: true
+    };
+  }
+}
+function gateEvidenceToEntry(taskId, gate, type, evidence) {
+  const gateRecord = evidence.gates[gate];
+  if (!gateRecord) {
+    return null;
+  }
+  const base = {
+    task_id: taskId,
+    timestamp: gateRecord.timestamp,
+    agent: gateRecord.agent || gate,
+    verdict: "pass",
+    summary: `Gate evidence recorded by ${gate}`,
+    metadata: { source: "durable_gate_evidence", gate }
+  };
+  if (type === "review") {
+    return {
+      ...base,
+      type,
+      risk: "low",
+      issues: []
+    };
+  }
+  if (type === "approval") {
+    return {
+      ...base,
+      type
+    };
+  }
+  return {
+    ...base,
+    type,
+    tests_passed: 0,
+    tests_failed: 0,
+    failures: []
+  };
+}
+function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
+  if (!evidence?.gates) {
+    return entries;
+  }
+  const merged = [...entries];
+  for (const gate of Object.keys(evidence.gates).sort()) {
+    const type = GATE_EVIDENCE_TYPE_BY_GATE[gate] ?? "approval";
+    if ((type === "review" || type === "test") && merged.some((entry2) => entry2.type === type)) {
+      continue;
+    }
+    const entry = gateEvidenceToEntry(taskId, gate, type, evidence);
+    if (entry) {
+      merged.push(entry);
+    }
+  }
+  return merged;
+}
+var GATE_EVIDENCE_TYPE_BY_GATE;
+var init_gate_bridge = __esm(() => {
+  init_gate_evidence();
+  GATE_EVIDENCE_TYPE_BY_GATE = {
+    reviewer: "review",
+    test_engineer: "test"
+  };
+});
+
 // src/services/version-check.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
@@ -60034,7 +60309,21 @@ async function checkEvidenceCompleteness(directory, plan) {
   }
   if (completedTaskIds.length > 0) {
     const evidenceTaskIds = new Set(await listEvidenceTaskIds(directory));
-    const missingEvidence = completedTaskIds.filter((id) => !evidenceTaskIds.has(id));
+    const missingEvidence = [];
+    for (const id of completedTaskIds) {
+      const gateStatus = await getDurableGateEvidenceStatusForTask(directory, id);
+      if (gateStatus.isComplete) {
+        continue;
+      }
+      if (gateStatus.evidenceExists && gateStatus.missingGates.length > 0) {
+        missingEvidence.push(id);
+        continue;
+      }
+      if (evidenceTaskIds.has(id)) {
+        continue;
+      }
+      missingEvidence.push(id);
+    }
     if (missingEvidence.length === 0) {
       return {
         name: "Evidence",
@@ -60789,6 +61078,7 @@ var init_diagnose_service = __esm(() => {
   init_package();
   init_cache_paths();
   init_loader();
+  init_gate_bridge();
   init_manager2();
   init_utils2();
   init_manager();
@@ -63355,8 +63645,7 @@ function getTaskStatus(task, bundle) {
   }
   return "pending";
 }
-function isEvidenceComplete(bundle) {
-  const entries = _internals20.normalizeBundleEntries(bundle);
+function evidenceCompleteFromEntries(entries) {
   if (entries.length === 0) {
     return {
       isComplete: false,
@@ -63375,6 +63664,9 @@ function isEvidenceComplete(bundle) {
     missingEvidence: missing
   };
 }
+function isEvidenceComplete(bundle) {
+  return evidenceCompleteFromEntries(_internals20.normalizeBundleEntries(bundle));
+}
 function getTaskBlockers(task, summary, status) {
   const blockers = [];
   if (task?.blocked_reason) {
@@ -63391,11 +63683,19 @@ function getTaskBlockers(task, summary, status) {
 async function buildTaskSummary(directory, task, taskId) {
   const result = await loadEvidence(directory, taskId);
   const bundle = result.status === "found" ? result.bundle : null;
+  const gateEvidence = await readDurableGateEvidence(directory, taskId);
   const phase = task?.phase ?? 0;
   const status = _internals20.getTaskStatus(task, bundle);
-  const evidenceCheck = _internals20.isEvidenceComplete(bundle);
+  const entries = mergeDurableGateEntriesFromEvidence(taskId, _internals20.normalizeBundleEntries(bundle), gateEvidence);
+  let evidenceCheck = _internals20.evidenceCompleteFromEntries(entries);
+  if (gateEvidence) {
+    const gateStatus = getDurableGateEvidenceStatus(gateEvidence);
+    evidenceCheck = gateStatus.isComplete ? { isComplete: true, missingEvidence: [] } : {
+      isComplete: false,
+      missingEvidence: gateStatus.missingGates.map((gate) => `gate:${gate}`)
+    };
+  }
   const blockers = _internals20.getTaskBlockers(task, evidenceCheck, status);
-  const entries = _internals20.normalizeBundleEntries(bundle);
   const hasReview = entries.some((e) => e.type === "review");
   const hasTest = entries.some((e) => e.type === "test");
   const hasApproval = entries.some((e) => e.type === "approval");
@@ -63573,6 +63873,7 @@ function isAutoSummaryEnabled(automationConfig) {
 }
 var VALID_EVIDENCE_TYPES2, REQUIRED_EVIDENCE_TYPES, EVIDENCE_SUMMARY_VERSION = "1.0.0", _internals20;
 var init_evidence_summary_service = __esm(() => {
+  init_gate_bridge();
   init_manager2();
   init_manager();
   init_utils();
@@ -63590,6 +63891,7 @@ var init_evidence_summary_service = __esm(() => {
     isAutoSummaryEnabled,
     normalizeBundleEntries,
     getTaskStatus,
+    evidenceCompleteFromEntries,
     isEvidenceComplete,
     getTaskBlockers,
     buildTaskSummary,
@@ -71200,7 +71502,22 @@ async function runEvidenceCheck(dir) {
       };
     }
     const evidenceTaskIds = new Set(await listEvidenceTaskIds(dir));
-    const missingEvidence = completedTaskIds.filter((id) => !evidenceTaskIds.has(id));
+    const missingEvidence = [];
+    for (const id of completedTaskIds) {
+      const gateStatus = await getDurableGateEvidenceStatusForTask(dir, id);
+      if (gateStatus.isComplete) {
+        continue;
+      }
+      if (gateStatus.evidenceExists && gateStatus.missingGates.length > 0) {
+        missingEvidence.push(id);
+        continue;
+      }
+      if (evidenceTaskIds.has(id)) {
+        continue;
+      }
+      missingEvidence.push(id);
+    }
+    const completedWithEvidence = completedTaskIds.length - missingEvidence.length;
     if (missingEvidence.length > 0) {
       return {
         type: "evidence",
@@ -71208,7 +71525,7 @@ async function runEvidenceCheck(dir) {
         message: `${missingEvidence.length} completed task(s) missing evidence`,
         details: {
           totalCompleted: completedTaskIds.length,
-          totalWithEvidence: evidenceTaskIds.size,
+          totalWithEvidence: completedWithEvidence,
           missingTasks: missingEvidence.slice(0, 10),
           missingCount: missingEvidence.length
         },
@@ -71221,7 +71538,7 @@ async function runEvidenceCheck(dir) {
       message: `All ${completedTaskIds.length} completed tasks have evidence`,
       details: {
         totalCompleted: completedTaskIds.length,
-        totalWithEvidence: evidenceTaskIds.size
+        totalWithEvidence: completedWithEvidence
       },
       durationMs: Date.now() - startTime
     };
@@ -71452,6 +71769,7 @@ async function handlePreflightCommand(directory, _args) {
 }
 var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals34;
 var init_preflight_service = __esm(() => {
+  init_gate_bridge();
   init_manager2();
   init_manager();
   init_lint();
@@ -76397,121 +76715,14 @@ Do NOT share other agents' responses at this stage.
 ### MODE: DEEP_DIVE
 Activates when: architect receives \`[MODE: DEEP_DIVE profile=X max_explorers=N output=X update_main=X allow_dirty=X] <scope>\` signal from the deep-dive command handler.
 
-Purpose: Perform a read-only deep audit of the specified codebase scope using parallel explorer waves, always 2 parallel reviewers, and sequential critic challenge. This mode does NOT mutate source code, does NOT delegate to coder, and does NOT call declare_scope.
-
-#### STEP 0 — PARSE HEADER
-Parse the MODE: DEEP_DIVE header to extract:
-- \`scope\`: the codebase area to audit (e.g., "auth", "payment flow", "src/hooks/")
-- \`profile\`: one of standard | security | ux | architecture | full (default: standard)
-- \`max_explorers\`: integer 1..8 (default: 6, or 8 for full profile)
-- \`output\`: markdown | json (default: markdown)
-- \`update_main\`: boolean (default: true) — whether to fetch/ff-only main before starting
-- \`allow_dirty\`: boolean (default: false) — whether to proceed with uncommitted changes
-
-If the header is malformed or missing required fields, report the error and stop.
-
-#### STEP 1 — REPO READINESS
-1. Check git working tree status. If dirty and \`allow_dirty\` is false, warn the user and ask whether to proceed. Do NOT proceed automatically.
-2. If \`update_main\` is true and tree is clean: check current branch. If not on \`main\`, report current branch to user and ASK FOR CONFIRMATION before switching. Only after explicit user approval: \`git fetch origin main && git checkout main && git merge --ff-only origin/main\`. If ff-only fails, warn the user and ask before proceeding.
-3. Record the current HEAD commit hash for the report.
-
-#### STEP 2 — SCOPE RESOLUTION
-Use the following tools to map the audit scope:
-1. \`repo_map\` with action "build" to establish the code graph
-2. \`repo_map\` with action "localization" for the scope target
-3. \`symbols\` and \`batch_symbols\` on key files identified by localization
-4. \`imports\` to trace dependency boundaries
-5. \`doc_scan\` if documentation coverage is relevant
-6. \`knowledge_recall\` with query matching the scope domain
-
-Produce a SCOPE MAP: list of files, modules, and interfaces within the audit boundary. Cap at 50 files total.
-
-#### STEP 3 — EXPLORER MISSIONS (Parallel Waves)
-Dispatch explorer waves using parallel Task calls. Each wave contains up to \`max_explorers\` missions.
-
-**File caps per mission:**
-- 8 files maximum per mission
-- ~3500 total lines across all files in a mission
-- Group files by import proximity (files that import each other go in the same mission)
-
-**Profile-based lane selection — each profile activates specific lanes:**
-
-| Lane | Template | standard | security | ux | architecture | full |
-|------|----------|----------|----------|----|-------------|------|
-| SCOPE_MAP | Map structure, exports, boundaries | ✓ | ✓ | ✓ | ✓ | ✓ |
-| WIRING_DATAFLOW | Trace data flow, API contracts, state propagation | ✓ | ✓ | | ✓ | ✓ |
-| RUNTIME_BEHAVIOR | Error handling, edge cases, lifecycle, async patterns | ✓ | | | ✓ | ✓ |
-| UX_FLOW | User-facing behavior, accessibility, responsiveness | | | ✓ | | ✓ |
-| SECURITY_TRUST | Auth boundaries, input validation, trust transitions | | ✓ | | | ✓ |
-| TEST_COVERAGE | Coverage gaps, flaky tests, missing assertions | ✓ | | | | ✓ |
-| PERFORMANCE_RELIABILITY | Resource leaks, N+1 queries, race conditions | | | | ✓ | ✓ |
-| DOCS_CONFIG_DEPLOYMENT | Config consistency, docs accuracy, deployment drift | | | | | ✓ |
-
-Each explorer mission receives:
-- Lane template name and description
-- Assigned files (8 max, grouped by import proximity)
-- The scope map context from Step 2
-- Instruction: "You are performing a [LANE] audit. Report findings as candidate observations with severity (INFO/LOW/MEDIUM/HIGH/CRITICAL), location, and evidence."
-
-Explorer missions are dispatched in parallel waves. Wait for ALL missions in a wave to complete before dispatching the next wave.
-
-Explorers generate CANDIDATE FINDINGS only — they do NOT make verdicts. All findings are unverified until Step 5.
-
-#### STEP 4 — NORMALIZE CANDIDATES
-1. Collect all candidate findings from all explorer missions.
-2. Deduplicate: merge findings that reference the same location and issue.
-3. Assign DD-C001 through DD-CNNN identifiers to unique findings.
-4. Cap at 10 findings per shard (see Step 5 for sharding).
-5. Sort by severity (CRITICAL → HIGH → MEDIUM → LOW → INFO).
-
-#### STEP 5 — ALWAYS 2 PARALLEL REVIEWERS
-Split the verified candidates into 2 shards of ≤10 candidates each. Dispatch 2 parallel \`{{AGENT_PREFIX}}reviewer\` calls.
-
-Each reviewer receives:
-- Their shard of candidates (up to 10)
-- The scope map context
-- The original scope description
-- Instruction: "Verify or reject each candidate finding. For each: verdict (VERIFIED / REJECTED / NEEDS_MORE_EVIDENCE), confidence (0-1), and brief reasoning."
-
-Reviewers MUST NOT suggest fixes — they verify findings only.
-
-#### STEP 5b — REVIEWER MERGE/DEDUP
-After both reviewers return, perform a lightweight sync pass:
-1. Cross-reference findings between reviewers — flag correlations
-2. Deduplicate any findings both reviewers verified independently
-3. For NEEDS_MORE_EVIDENCE findings: if the other reviewer verified a related finding, merge
-4. Produce a unified findings list with verified/rejected status
-
-#### STEP 6 — CRITIC CHALLENGE (HIGH/CRITICAL only)
-For verified findings rated HIGH or CRITICAL, dispatch sequential critic passes:
-
-**Pass 1 — False-positive / root-cause challenge:**
-- \`{{AGENT_PREFIX}}critic\` receives each HIGH/CRITICAL finding
-- Challenge: "Is this a false positive? Is the root cause correctly identified? Provide verdict: SURVIVES / DOWNGRADE / REJECT"
-- Only findings that SURVIVE proceed to Pass 2
-
-**Pass 2 — Impact / severity challenge:**
-- \`{{AGENT_PREFIX}}critic\` receives surviving findings
-- Challenge: "Is the severity correctly rated? Could this be lower impact than claimed? Provide verdict: SURVIVES / DOWNGRADE / REJECT"
-- Final severity is the critic's assessed severity
-
-CRITICAL: Do NOT challenge MEDIUM/LOW/INFO findings. Only HIGH and CRITICAL go through critic review.
-
-#### STEP 7 — FINAL REPORT
-Assemble and present the audit report:
-
-1. **Wiring Map**: Visual summary of the scope's module structure and data flow
-2. **Functionality Assessment**: High-level summary of what the scope does and how well
-3. **Verified Findings Table**: DD-ID, severity, location, description, evidence
-4. **Rejected Candidates**: Brief list with rejection reasons
-5. **Enhancements**: Non-blocking improvement suggestions
-6. **Recommended Implementation Phases**: If findings suggest follow-up work, outline phases
-7. **JSON Block** (when output=json): Structured machine-readable findings
-
-IMPORTANT CONSTRAINTS for MODE: DEEP_DIVE:
-- Do NOT mutate source code under any circumstances
+Purpose: Read-only deep audit of the specified codebase scope using parallel explorer waves, always 2 parallel reviewers, and sequential critic challenge. This mode does NOT mutate source code, does NOT delegate to coder, and does NOT call declare_scope.
+
+ACTION: Load skill \`file:.opencode/skills/deep-dive/SKILL.md\` immediately and follow its protocol.
+
+HARD CONSTRAINTS (apply regardless of skill load success):
 - Do NOT delegate to coder
 - Do NOT call declare_scope
+- Do NOT mutate source code
 - Do NOT create or modify any files outside .swarm/
 - No final finding may appear in the report without reviewer verification
 - Explorers generate candidate findings only — reviewers verify or reject
@@ -84599,7 +84810,7 @@ __export(exports_project_context, {
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs113 from "node:fs";
-import * as path147 from "node:path";
+import * as path148 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -84611,7 +84822,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs113.accessSync(path147.join(directory, pattern));
+    fs113.accessSync(path148.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -84620,7 +84831,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs113.readFileSync(path147.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs113.readFileSync(path148.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -84729,7 +84940,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path148 from "node:path";
+import * as path149 from "node:path";
 
 // src/background/index.ts
 init_event_bus();
@@ -84992,6 +85203,10 @@ class PlanSyncWorker {
       const planMtimeMs = Math.floor(planStats.mtimeMs);
       const markerContent = fs37.readFileSync(markerPath, "utf8");
       const marker = JSON.parse(markerContent);
+      if (marker.in_progress === true) {
+        log("[PlanSyncWorker] Skipping unauthorized-write check - plan write in progress");
+        return;
+      }
       const markerTimestampMs = new Date(marker.timestamp).getTime();
       if (planMtimeMs > markerTimestampMs + 5000) {
         log("[PlanSyncWorker] WARNING: plan.json may have been written outside save_plan/savePlan - unauthorized direct write suspected", { planMtimeMs, markerTimestampMs });
@@ -97595,6 +97810,10 @@ var DEFAULT_MEMORY_CONFIG = {
   enabled: false,
   provider: "local-jsonl",
   storageDir: ".swarm/memory",
+  sqlite: {
+    path: ".swarm/memory/memory.db",
+    busyTimeoutMs: 5000
+  },
   recall: {
     defaultMaxItems: 8,
     defaultTokenBudget: 1200,
@@ -97634,6 +97853,10 @@ function resolveMemoryConfig(input) {
   return {
     ...DEFAULT_MEMORY_CONFIG,
     ...input ?? {},
+    sqlite: {
+      ...DEFAULT_MEMORY_CONFIG.sqlite,
+      ...input?.sqlite ?? {}
+    },
     recall: {
       ...DEFAULT_MEMORY_CONFIG.recall,
       ...input?.recall ?? {},
@@ -97671,7 +97894,7 @@ class MemoryDisabledError extends Error {
 // src/memory/gateway.ts
 import { createHash as createHash9 } from "node:crypto";
 import { existsSync as existsSync50, readFileSync as readFileSync39 } from "node:fs";
-import * as path96 from "node:path";
+import * as path97 from "node:path";
 
 // src/memory/local-jsonl-provider.ts
 init_utils2();
@@ -98373,6 +98596,367 @@ function toRecallBundle(input) {
   };
 }
 
+// src/memory/sqlite-provider.ts
+init_utils2();
+import { randomUUID as randomUUID9 } from "node:crypto";
+import { mkdirSync as mkdirSync24 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import * as path96 from "node:path";
+var _DatabaseCtor2 = null;
+function loadDatabaseCtor2() {
+  if (_DatabaseCtor2)
+    return _DatabaseCtor2;
+  const req = createRequire3(import.meta.url);
+  _DatabaseCtor2 = req("bun:sqlite").Database;
+  return _DatabaseCtor2;
+}
+var MIGRATIONS2 = [
+  {
+    version: 1,
+    name: "create_memory_provider_tables",
+    sql: `
+			CREATE TABLE IF NOT EXISTS memory_items (
+				id TEXT PRIMARY KEY,
+				scope_key TEXT NOT NULL,
+				kind TEXT NOT NULL,
+				updated_at TEXT NOT NULL,
+				expires_at TEXT,
+				superseded_by TEXT,
+				deleted INTEGER NOT NULL DEFAULT 0,
+				record_json TEXT NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_memory_items_scope_kind
+				ON memory_items(scope_key, kind);
+			CREATE INDEX IF NOT EXISTS idx_memory_items_updated_at
+				ON memory_items(updated_at);
+
+			CREATE TABLE IF NOT EXISTS memory_proposals (
+				id TEXT PRIMARY KEY,
+				status TEXT NOT NULL,
+				created_at TEXT NOT NULL,
+				proposal_json TEXT NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_memory_proposals_status_created
+				ON memory_proposals(status, created_at);
+
+			CREATE TABLE IF NOT EXISTS memory_events (
+				id TEXT PRIMARY KEY,
+				operation TEXT NOT NULL,
+				target_id TEXT NOT NULL,
+				reason TEXT,
+				timestamp TEXT NOT NULL,
+				event_json TEXT
+			);
+
+			CREATE TABLE IF NOT EXISTS memory_recall_usage (
+				id TEXT PRIMARY KEY,
+				bundle_id TEXT NOT NULL,
+				timestamp TEXT NOT NULL,
+				usage_json TEXT NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_memory_recall_usage_bundle
+				ON memory_recall_usage(bundle_id);
+		`
+  }
+];
+
+class SQLiteMemoryProvider {
+  name = "sqlite";
+  rootDirectory;
+  config;
+  initialized = false;
+  db = null;
+  memories = new Map;
+  proposals = new Map;
+  constructor(rootDirectory, config3 = {}) {
+    this.rootDirectory = rootDirectory;
+    this.config = {
+      ...DEFAULT_MEMORY_CONFIG,
+      ...config3,
+      sqlite: {
+        ...DEFAULT_MEMORY_CONFIG.sqlite,
+        ...config3.sqlite ?? {}
+      },
+      recall: {
+        ...DEFAULT_MEMORY_CONFIG.recall,
+        ...config3.recall ?? {},
+        injection: {
+          ...DEFAULT_MEMORY_CONFIG.recall.injection,
+          ...config3.recall?.injection ?? {}
+        }
+      },
+      writes: {
+        ...DEFAULT_MEMORY_CONFIG.writes,
+        ...config3.writes ?? {}
+      },
+      redaction: {
+        ...DEFAULT_MEMORY_CONFIG.redaction,
+        ...config3.redaction ?? {}
+      }
+    };
+  }
+  databasePath() {
+    const relativePath = this.config.sqlite.path.replace(/^\.swarm[/\\]?/, "");
+    return validateSwarmPath(this.rootDirectory, relativePath);
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    const dbPath = this.databasePath();
+    mkdirSync24(path96.dirname(dbPath), { recursive: true });
+    const Db = loadDatabaseCtor2();
+    this.db = new Db(dbPath);
+    this.db.run("PRAGMA journal_mode = WAL;");
+    this.db.run("PRAGMA synchronous = NORMAL;");
+    const busyTimeoutMs = Math.min(60000, Math.max(0, Math.trunc(this.config.sqlite.busyTimeoutMs)));
+    this.db.run(`PRAGMA busy_timeout = ${busyTimeoutMs};`);
+    this.db.run("PRAGMA foreign_keys = ON;");
+    this.runMigrations();
+    const memoryLoad = this.loadMemories();
+    const proposalLoad = this.loadProposals();
+    this.memories = new Map(memoryLoad.records.map((record3) => [record3.id, record3]));
+    this.proposals = new Map(proposalLoad.records.map((proposal) => [proposal.id, proposal]));
+    this.initialized = true;
+    if (memoryLoad.invalidCount > 0) {
+      await this.event("invalid_load", "memory_items", `${memoryLoad.invalidCount} invalid SQLite memory row(s) skipped`);
+    }
+    if (proposalLoad.invalidCount > 0) {
+      await this.event("invalid_load", "memory_proposals", `${proposalLoad.invalidCount} invalid SQLite proposal row(s) skipped`);
+    }
+  }
+  async upsert(record3) {
+    await this.initialize();
+    const existing = this.memories.get(record3.id);
+    if (existing?.metadata.deleted === true) {
+      throw new MemoryValidationError("memory is tombstoned and cannot be upserted");
+    }
+    const next = validateMemoryRecordRules({
+      ...record3,
+      createdAt: existing?.createdAt ?? record3.createdAt
+    }, { rejectDurableSecrets: this.config.redaction.rejectDurableSecrets });
+    this.memories.set(next.id, next);
+    this.writeMemory(next);
+    await this.event("upsert", next.id);
+    return next;
+  }
+  async get(id) {
+    await this.initialize();
+    return this.memories.get(id) ?? null;
+  }
+  async delete(id, reason) {
+    await this.initialize();
+    const existing = this.memories.get(id);
+    if (!existing)
+      return;
+    if (this.config.hardDelete) {
+      this.memories.delete(id);
+      this.requireDb().run("DELETE FROM memory_items WHERE id = ?", [id]);
+    } else {
+      const tombstone = {
+        ...existing,
+        updatedAt: new Date().toISOString(),
+        metadata: { ...existing.metadata, deleted: true, deleteReason: reason }
+      };
+      this.memories.set(id, tombstone);
+      this.writeMemory(tombstone);
+    }
+    await this.event("delete", id, reason);
+  }
+  async recall(request) {
+    return (await this.recallWithDiagnostics(request)).items;
+  }
+  async recallWithDiagnostics(request) {
+    await this.initialize();
+    const records = await this.list({
+      scopes: request.scopes,
+      kinds: request.kinds,
+      includeExpired: request.includeExpired
+    });
+    const result = scoreMemoryRecordsWithDiagnostics(records, request);
+    return {
+      items: result.items.slice(0, request.maxItems),
+      diagnostics: {
+        ...result.diagnostics,
+        returnedCount: Math.min(result.diagnostics.returnedCount, request.maxItems)
+      }
+    };
+  }
+  async recordRecallUsage(event) {
+    await this.initialize();
+    this.requireDb().run(`INSERT INTO memory_recall_usage (
+				id,
+				bundle_id,
+				timestamp,
+				usage_json
+			) VALUES (?, ?, ?, ?)`, [randomUUID9(), event.bundleId, event.timestamp, JSON.stringify(event)]);
+    await this.event("recall", event.bundleId, JSON.stringify(event));
+  }
+  async list(filter = {}) {
+    await this.initialize();
+    let records = Array.from(this.memories.values());
+    if (filter.scopes && filter.scopes.length > 0) {
+      records = records.filter((record3) => scopeAllowed(record3.scope, filter.scopes ?? []));
+    }
+    if (filter.kinds && filter.kinds.length > 0) {
+      records = records.filter((record3) => filter.kinds?.includes(record3.kind));
+    }
+    if (!filter.includeExpired) {
+      const now = Date.now();
+      records = records.filter((record3) => {
+        if (!record3.expiresAt)
+          return true;
+        const expires = Date.parse(record3.expiresAt);
+        return !Number.isFinite(expires) || expires > now;
+      });
+    }
+    records = records.filter((record3) => !record3.supersededBy && record3.metadata.deleted !== true);
+    records.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    return records.slice(0, filter.limit ?? records.length);
+  }
+  async createProposal(proposal) {
+    await this.initialize();
+    const next = validateMemoryProposal(proposal);
+    if (next.proposedRecord) {
+      validateMemoryRecordRules(next.proposedRecord, {
+        rejectDurableSecrets: this.config.redaction.rejectDurableSecrets
+      });
+    }
+    this.proposals.set(next.id, next);
+    this.requireDb().run(`INSERT OR REPLACE INTO memory_proposals (
+				id,
+				status,
+				created_at,
+				proposal_json
+			) VALUES (?, ?, ?, ?)`, [next.id, next.status, next.createdAt, JSON.stringify(next)]);
+    await this.event("proposal", next.id);
+    return next;
+  }
+  async listProposals(filter = {}) {
+    await this.initialize();
+    let proposals = Array.from(this.proposals.values());
+    if (filter.status) {
+      proposals = proposals.filter((proposal) => proposal.status === filter.status);
+    }
+    proposals.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return proposals.slice(0, filter.limit ?? proposals.length);
+  }
+  close() {
+    if (!this.db)
+      return;
+    this.db.close();
+    this.db = null;
+    this.initialized = false;
+  }
+  runMigrations() {
+    const db = this.requireDb();
+    db.run(`CREATE TABLE IF NOT EXISTS schema_migrations (
+			version INTEGER PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+		)`);
+    const row = db.query("SELECT MAX(version) as version FROM schema_migrations").get();
+    const currentVersion = row?.version ?? 0;
+    for (const migration of MIGRATIONS2) {
+      if (migration.version <= currentVersion)
+        continue;
+      const apply = db.transaction(() => {
+        for (const statement of splitSql(migration.sql)) {
+          db.run(statement);
+        }
+        db.run("INSERT INTO schema_migrations (version, name) VALUES (?, ?)", [
+          migration.version,
+          migration.name
+        ]);
+        this.insertEvent("migration", String(migration.version), migration.name);
+      });
+      apply();
+    }
+  }
+  loadMemories() {
+    const rows = this.requireDb().query("SELECT id, record_json FROM memory_items ORDER BY updated_at ASC").all();
+    const records = [];
+    let invalidCount = 0;
+    for (const row of rows) {
+      try {
+        records.push(validateMemoryRecordRules(JSON.parse(row.record_json), {
+          rejectDurableSecrets: this.config.redaction.rejectDurableSecrets
+        }));
+      } catch {
+        invalidCount++;
+      }
+    }
+    return { records, invalidCount };
+  }
+  loadProposals() {
+    const rows = this.requireDb().query("SELECT id, proposal_json FROM memory_proposals ORDER BY created_at ASC").all();
+    const records = [];
+    let invalidCount = 0;
+    for (const row of rows) {
+      try {
+        const proposal = validateMemoryProposal(JSON.parse(row.proposal_json));
+        if (proposal.proposedRecord) {
+          validateMemoryRecordRules(proposal.proposedRecord, {
+            rejectDurableSecrets: this.config.redaction.rejectDurableSecrets
+          });
+        }
+        records.push(proposal);
+      } catch {
+        invalidCount++;
+      }
+    }
+    return { records, invalidCount };
+  }
+  writeMemory(record3) {
+    this.requireDb().run(`INSERT OR REPLACE INTO memory_items (
+				id,
+				scope_key,
+				kind,
+				updated_at,
+				expires_at,
+				superseded_by,
+				deleted,
+				record_json
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+      record3.id,
+      JSON.stringify(record3.scope),
+      record3.kind,
+      record3.updatedAt,
+      record3.expiresAt ?? null,
+      record3.supersededBy ?? null,
+      record3.metadata.deleted === true ? 1 : 0,
+      JSON.stringify(record3)
+    ]);
+  }
+  async event(operation, targetId, reason) {
+    this.insertEvent(operation, targetId, reason);
+  }
+  insertEvent(operation, targetId, reason) {
+    this.requireDb().run(`INSERT INTO memory_events (
+				id,
+				operation,
+				target_id,
+				reason,
+				timestamp,
+				event_json
+			) VALUES (?, ?, ?, ?, ?, ?)`, [
+      randomUUID9(),
+      operation,
+      targetId,
+      reason ?? null,
+      new Date().toISOString(),
+      reason ? JSON.stringify({ reason }) : null
+    ]);
+  }
+  requireDb() {
+    if (!this.db)
+      throw new Error("SQLite memory provider is not initialized");
+    return this.db;
+  }
+}
+function splitSql(sql) {
+  return sql.split(";").map((statement) => statement.trim()).filter(Boolean);
+}
+
 // src/memory/gateway.ts
 class MemoryGateway {
   context;
@@ -98382,16 +98966,19 @@ class MemoryGateway {
   constructor(context, options = {}) {
     this.context = context;
     this.config = resolveMemoryConfig(options.config ?? DEFAULT_MEMORY_CONFIG);
-    this.provider = options.provider ?? new LocalJsonlMemoryProvider(context.directory, this.config);
+    this.provider = options.provider ?? createConfiguredMemoryProvider(context.directory, this.config);
     this.now = options.now ?? (() => new Date);
   }
   isEnabled() {
     return this.config.enabled;
   }
+  async dispose() {
+    await this.provider.close?.();
+  }
   deriveAllowedScopes() {
-    const resolvedRoot = path96.resolve(this.context.directory);
-    const repoId = createStableId(readGitRemoteUrl(resolvedRoot) ?? path96.basename(resolvedRoot));
-    const workspaceId = createStableId(path96.dirname(resolvedRoot));
+    const resolvedRoot = path97.resolve(this.context.directory);
+    const repoId = createStableId(readGitRemoteUrl(resolvedRoot) ?? path97.basename(resolvedRoot));
+    const workspaceId = createStableId(path97.dirname(resolvedRoot));
     const scopes = [
       { type: "workspace", workspaceId },
       {
@@ -98591,6 +99178,12 @@ class MemoryGateway {
 function createMemoryGateway(context, options = {}) {
   return new MemoryGateway(context, options);
 }
+function createConfiguredMemoryProvider(directory, config3) {
+  if (config3.provider === "sqlite") {
+    return new SQLiteMemoryProvider(directory, config3);
+  }
+  return new LocalJsonlMemoryProvider(directory, config3);
+}
 function sourceFromEvidence(evidenceRefs, context) {
   const first = evidenceRefs[0];
   if (!first) {
@@ -98612,7 +99205,7 @@ var gitRemoteUrlCache = new Map;
 function readGitRemoteUrl(directory) {
   if (gitRemoteUrlCache.has(directory))
     return gitRemoteUrlCache.get(directory);
-  const gitConfigPath = path96.join(directory, ".git", "config");
+  const gitConfigPath = path97.join(directory, ".git", "config");
   if (!existsSync50(gitConfigPath)) {
     gitRemoteUrlCache.set(directory, undefined);
     return;
@@ -98660,7 +99253,7 @@ function scopeKey(scope) {
     workspaceId: scope.workspaceId,
     projectId: scope.projectId,
     repoId: scope.repoId,
-    repoRoot: scope.repoRoot ? path96.resolve(scope.repoRoot) : undefined,
+    repoRoot: scope.repoRoot ? path97.resolve(scope.repoRoot) : undefined,
     runId: scope.runId,
     agentId: scope.agentId
   });
@@ -98907,12 +99500,12 @@ function buildScopesFromInput(input) {
 // src/memory/run-log.ts
 init_utils2();
 import { appendFile as appendFile12, mkdir as mkdir19 } from "node:fs/promises";
-import * as path97 from "node:path";
+import * as path98 from "node:path";
 async function appendMemoryRunLog(directory, runId, event) {
   const safeRunId = sanitizeRunId(runId);
-  const relativePath = path97.join("runs", safeRunId, "memory.jsonl");
+  const relativePath = path98.join("runs", safeRunId, "memory.jsonl");
   const filePath = validateSwarmPath(directory, relativePath);
-  await mkdir19(path97.dirname(filePath), { recursive: true });
+  await mkdir19(path98.dirname(filePath), { recursive: true });
   await appendFile12(filePath, `${JSON.stringify({
     ...event,
     runId: safeRunId,
@@ -99690,16 +100283,16 @@ init_telemetry();
 
 // src/prm/replay.ts
 import { promises as fs68 } from "node:fs";
-import path98 from "node:path";
+import path99 from "node:path";
 function isPathSafe2(targetPath, basePath) {
-  const resolvedTarget = path98.resolve(targetPath);
-  const resolvedBase = path98.resolve(basePath);
-  const rel = path98.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path98.isAbsolute(rel);
+  const resolvedTarget = path99.resolve(targetPath);
+  const resolvedBase = path99.resolve(basePath);
+  const rel = path99.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path99.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path98.resolve(targetPath);
-  const parts2 = resolved.split(path98.sep);
+  const resolved = path99.resolve(targetPath);
+  const parts2 = resolved.split(path99.sep);
   for (let i2 = 0;i2 < parts2.length - 1; i2++) {
     if (parts2[i2] === ".swarm" && parts2[i2 + 1] === "replays") {
       return true;
@@ -99712,10 +100305,10 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path98.join(directory, ".swarm", "replays");
+    const replayDir = path99.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path98.join(replayDir, filename);
+    const filepath = path99.join(replayDir, filename);
     if (!isPathSafe2(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
@@ -100096,7 +100689,7 @@ init_telemetry();
 init_dist();
 init_create_tool();
 import * as fs69 from "node:fs";
-import * as path99 from "node:path";
+import * as path100 from "node:path";
 init_path_security();
 var WINDOWS_RESERVED_NAMES2 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks2(str) {
@@ -100113,14 +100706,14 @@ function containsWindowsAttacks2(str) {
 }
 function isPathInWorkspace2(filePath, workspace) {
   try {
-    const resolvedPath = path99.resolve(workspace, filePath);
+    const resolvedPath = path100.resolve(workspace, filePath);
     if (!fs69.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs69.realpathSync(workspace);
     const realResolvedPath = fs69.realpathSync(resolvedPath);
-    const relativePath = path99.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path99.isAbsolute(relativePath)) {
+    const relativePath = path100.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path100.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -100129,7 +100722,7 @@ function isPathInWorkspace2(filePath, workspace) {
   }
 }
 function processFile2(file3, cwd, exportedOnly) {
-  const ext = path99.extname(file3);
+  const ext = path100.extname(file3);
   if (containsControlChars(file3)) {
     return {
       file: file3,
@@ -100162,7 +100755,7 @@ function processFile2(file3, cwd, exportedOnly) {
       errorType: "path-outside-workspace"
     };
   }
-  const fullPath = path99.join(cwd, file3);
+  const fullPath = path100.join(cwd, file3);
   if (!fs69.existsSync(fullPath)) {
     return {
       file: file3,
@@ -100454,15 +101047,15 @@ init_task_id();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs70 from "node:fs";
-import * as path100 from "node:path";
+import * as path101 from "node:path";
 var EVIDENCE_DIR = ".swarm/evidence";
 function isValidTaskId3(taskId) {
   return isStrictTaskId(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path100.resolve(workspaceRoot);
-  const swarmPath = path100.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path100.resolve(filePath);
+  const normalizedWorkspace = path101.resolve(workspaceRoot);
+  const swarmPath = path101.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path101.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
@@ -100543,7 +101136,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path100.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path101.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -100640,7 +101233,7 @@ init_state();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs71 from "node:fs";
-import * as path101 from "node:path";
+import * as path102 from "node:path";
 function extractMatches(regex, text) {
   return Array.from(text.matchAll(regex));
 }
@@ -100792,10 +101385,10 @@ async function executeCompletionVerify(args2, directory) {
     let hasFileReadFailure = false;
     for (const filePath of fileTargets) {
       const normalizedPath = filePath.replace(/\\/g, "/");
-      const resolvedPath = path101.resolve(directory, normalizedPath);
-      const projectRoot = path101.resolve(directory);
-      const relative21 = path101.relative(projectRoot, resolvedPath);
-      const withinProject = relative21 === "" || !relative21.startsWith("..") && !path101.isAbsolute(relative21);
+      const resolvedPath = path102.resolve(directory, normalizedPath);
+      const projectRoot = path102.resolve(directory);
+      const relative21 = path102.relative(projectRoot, resolvedPath);
+      const withinProject = relative21 === "" || !relative21.startsWith("..") && !path102.isAbsolute(relative21);
       if (!withinProject) {
         blockedTasks.push({
           task_id: task.id,
@@ -100850,8 +101443,8 @@ async function executeCompletionVerify(args2, directory) {
     blockedTasks
   };
   try {
-    const evidenceDir = path101.join(directory, ".swarm", "evidence", `${phase}`);
-    const evidencePath = path101.join(evidenceDir, "completion-verify.json");
+    const evidenceDir = path102.join(directory, ".swarm", "evidence", `${phase}`);
+    const evidencePath = path102.join(evidenceDir, "completion-verify.json");
     fs71.mkdirSync(evidenceDir, { recursive: true });
     const evidenceBundle = {
       schema_version: "1.0.0",
@@ -100928,11 +101521,11 @@ var completion_verify = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_zod();
 import * as fs73 from "node:fs";
-import * as path103 from "node:path";
+import * as path104 from "node:path";
 
 // src/quality/metrics.ts
 import * as fs72 from "node:fs";
-import * as path102 from "node:path";
+import * as path103 from "node:path";
 var MAX_FILE_SIZE_BYTES4 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -100984,7 +101577,7 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path102.isAbsolute(file3) ? file3 : path102.join(workingDir, file3);
+    const fullPath = path103.isAbsolute(file3) ? file3 : path103.join(workingDir, file3);
     if (!fs72.existsSync(fullPath)) {
       continue;
     }
@@ -101107,7 +101700,7 @@ function countGoExports(content) {
 function getExportCountForFile(filePath) {
   try {
     const content = fs72.readFileSync(filePath, "utf-8");
-    const ext = path102.extname(filePath).toLowerCase();
+    const ext = path103.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -101133,7 +101726,7 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path102.isAbsolute(file3) ? file3 : path102.join(workingDir, file3);
+    const fullPath = path103.isAbsolute(file3) ? file3 : path103.join(workingDir, file3);
     if (!fs72.existsSync(fullPath)) {
       continue;
     }
@@ -101167,7 +101760,7 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path102.isAbsolute(file3) ? file3 : path102.join(workingDir, file3);
+    const fullPath = path103.isAbsolute(file3) ? file3 : path103.join(workingDir, file3);
     if (!fs72.existsSync(fullPath)) {
       continue;
     }
@@ -101200,8 +101793,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename15 = path102.basename(filePath);
-  const _ext = path102.extname(filePath).toLowerCase();
+  const basename15 = path103.basename(filePath);
+  const _ext = path103.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -101282,8 +101875,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path103, glob) {
-  const normalizedPath = path103.replace(/\\/g, "/");
+function matchesGlobSegment(path104, glob) {
+  const normalizedPath = path104.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -101314,8 +101907,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path103, glob) {
-  const normalizedPath = path103.replace(/\\/g, "/");
+function globMatches(path104, glob) {
+  const normalizedPath = path104.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -101351,7 +101944,7 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path102.join(workingDir, "src");
+  const srcDir = path103.join(workingDir, "src");
   if (fs72.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
@@ -101359,14 +101952,14 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path102.join(workingDir, dir);
+    const dirPath = path103.join(workingDir, dir);
     if (fs72.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path102.join(workingDir, "tests");
+  const testsDir = path103.join(workingDir, "tests");
   if (fs72.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
@@ -101374,7 +101967,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path102.join(workingDir, dir);
+    const dirPath = path103.join(workingDir, dir);
     if (fs72.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
@@ -101389,7 +101982,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
   try {
     const entries = fs72.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path102.join(dirPath, entry.name);
+      const fullPath = path103.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -101397,7 +101990,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
         await scanDirectoryForLines(fullPath, includeGlobs, excludeGlobs, isTestScan, callback);
       } else if (entry.isFile()) {
         const relativePath = fullPath.replace(`${dirPath}/`, "");
-        const ext = path102.extname(entry.name).toLowerCase();
+        const ext = path103.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -101648,7 +102241,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   const extSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
   const filteredChurn = new Map;
   for (const [file3, count] of churnMap) {
-    const ext = path103.extname(file3).toLowerCase();
+    const ext = path104.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -101659,7 +102252,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
     if (!fs73.existsSync(fullPath)) {
-      fullPath = path103.join(cwd, file3);
+      fullPath = path104.join(cwd, file3);
     }
     const complexity = getComplexityForFile2(fullPath);
     if (complexity !== null) {
@@ -101827,7 +102420,7 @@ ${body2}`);
 
 // src/council/council-evidence-writer.ts
 init_task_file();
-import { appendFileSync as appendFileSync12, existsSync as existsSync55, mkdirSync as mkdirSync25, readFileSync as readFileSync45 } from "node:fs";
+import { appendFileSync as appendFileSync12, existsSync as existsSync55, mkdirSync as mkdirSync26, readFileSync as readFileSync45 } from "node:fs";
 import { join as join88 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
@@ -101866,7 +102459,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
     throw new Error(`writeCouncilEvidence: invalid taskId "${synthesis.taskId}" — must match N.M or N.M.P format`);
   }
   const dir = join88(workingDir, EVIDENCE_DIR2);
-  mkdirSync25(dir, { recursive: true });
+  mkdirSync26(dir, { recursive: true });
   const filePath = taskEvidencePath(workingDir, synthesis.taskId);
   await _internals45.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
     const existingRoot = Object.create(null);
@@ -101904,7 +102497,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
   });
   try {
     const councilDir = join88(workingDir, ".swarm", "council");
-    mkdirSync25(councilDir, { recursive: true });
+    mkdirSync26(councilDir, { recursive: true });
     const auditLine = JSON.stringify({
       round: synthesis.roundNumber,
       verdict: synthesis.overallVerdict,
@@ -102233,12 +102826,12 @@ function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFi
 }
 
 // src/council/criteria-store.ts
-import { existsSync as existsSync56, mkdirSync as mkdirSync26, readFileSync as readFileSync46, writeFileSync as writeFileSync17 } from "node:fs";
+import { existsSync as existsSync56, mkdirSync as mkdirSync27, readFileSync as readFileSync46, writeFileSync as writeFileSync17 } from "node:fs";
 import { join as join89 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 function writeCriteria(workingDir, taskId, criteria) {
   const dir = join89(workingDir, COUNCIL_DIR);
-  mkdirSync26(dir, { recursive: true });
+  mkdirSync27(dir, { recursive: true });
   const payload = {
     taskId,
     criteria,
@@ -102400,7 +102993,7 @@ var submit_council_verdicts = createSwarmTool({
 init_zod();
 init_loader();
 import * as fs74 from "node:fs";
-import * as path104 from "node:path";
+import * as path105 from "node:path";
 
 // src/council/general-council-advisory.ts
 var ADVISORY_HEADER = "[general_council] (advisory; not blocking)";
@@ -102828,10 +103421,10 @@ var convene_general_council = createSwarmTool({
     const round1 = input.round1Responses;
     const round2 = input.round2Responses ?? [];
     const result = synthesizeGeneralCouncil(input.question, input.mode, round1, round2);
-    const evidenceDir = path104.join(workingDir, ".swarm", "council", "general");
+    const evidenceDir = path105.join(workingDir, ".swarm", "council", "general");
     const safeTimestamp = result.timestamp.replace(/[:.]/g, "-");
     const evidenceFile = `${safeTimestamp}-${input.mode}.json`;
-    const evidencePath = path104.join(evidenceDir, evidenceFile);
+    const evidencePath = path105.join(evidenceDir, evidenceFile);
     try {
       await fs74.promises.mkdir(evidenceDir, { recursive: true });
       await fs74.promises.writeFile(evidencePath, JSON.stringify(result, null, 2));
@@ -103076,7 +103669,7 @@ init_state();
 init_task_id();
 init_create_tool();
 import * as fs75 from "node:fs";
-import * as path105 from "node:path";
+import * as path106 from "node:path";
 function validateTaskIdFormat2(taskId) {
   return validateTaskIdFormat(taskId);
 }
@@ -103150,8 +103743,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path105.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path105.sep);
+    normalizedDir = path106.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path106.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -103161,10 +103754,10 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path105.resolve(normalizedDir);
+    const resolvedDir = path106.resolve(normalizedDir);
     try {
       const realPath = fs75.realpathSync(resolvedDir);
-      const planPath2 = path105.join(realPath, ".swarm", "plan.json");
+      const planPath2 = path106.join(realPath, ".swarm", "plan.json");
       if (!fs75.existsSync(planPath2)) {
         return {
           success: false,
@@ -103185,9 +103778,9 @@ async function executeDeclareScope(args2, fallbackDir) {
     }
     if (normalizedDir && fallbackDir) {
       try {
-        const canonicalWorkingDir = fs75.realpathSync(path105.resolve(normalizedDir));
-        const canonicalProjectRoot = fs75.realpathSync(path105.resolve(fallbackDir));
-        if (canonicalWorkingDir.startsWith(canonicalProjectRoot + path105.sep)) {
+        const canonicalWorkingDir = fs75.realpathSync(path106.resolve(normalizedDir));
+        const canonicalProjectRoot = fs75.realpathSync(path106.resolve(fallbackDir));
+        if (canonicalWorkingDir.startsWith(canonicalProjectRoot + path106.sep)) {
           return {
             success: false,
             message: `working_directory "${normalizedDir}" is a subdirectory of the project root. Use the project root "${fallbackDir}" instead.`,
@@ -103209,7 +103802,7 @@ async function executeDeclareScope(args2, fallbackDir) {
     };
   }
   const directory = normalizedDir || fallbackDir;
-  const planPath = path105.resolve(directory, ".swarm", "plan.json");
+  const planPath = path106.resolve(directory, ".swarm", "plan.json");
   if (!fs75.existsSync(planPath)) {
     return {
       success: false,
@@ -103249,8 +103842,8 @@ async function executeDeclareScope(args2, fallbackDir) {
   const normalizeErrors = [];
   const dir = directory;
   const mergedFiles = rawMergedFiles.map((file3) => {
-    if (path105.isAbsolute(file3)) {
-      const relativePath = path105.relative(dir, file3).replace(/\\/g, "/");
+    if (path106.isAbsolute(file3)) {
+      const relativePath = path106.relative(dir, file3).replace(/\\/g, "/");
       if (relativePath.startsWith("..")) {
         normalizeErrors.push(`Path '${file3}' resolves outside the project directory`);
         return file3;
@@ -103311,7 +103904,7 @@ var declare_scope = createSwarmTool({
 init_zod();
 import * as child_process7 from "node:child_process";
 import * as fs76 from "node:fs";
-import * as path106 from "node:path";
+import * as path107 from "node:path";
 init_create_tool();
 var MAX_DIFF_LINES = 500;
 var DIFF_TIMEOUT_MS = 30000;
@@ -103340,20 +103933,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path107 of paths) {
-    if (!path107 || path107.length === 0) {
+  for (const path108 of paths) {
+    if (!path108 || path108.length === 0) {
       return "empty path not allowed";
     }
-    if (path107.length > MAX_PATH_LENGTH) {
+    if (path108.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path107)) {
+    if (SHELL_METACHARACTERS2.test(path108)) {
       return "path contains shell metacharacters";
     }
-    if (path107.startsWith("-")) {
+    if (path108.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path107)) {
+    if (CONTROL_CHAR_PATTERN2.test(path108)) {
       return "path contains control characters";
     }
   }
@@ -103461,8 +104054,8 @@ var diff = createSwarmTool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path107 = parts2[2];
-          files.push({ path: path107, additions, deletions });
+          const path108 = parts2[2];
+          files.push({ path: path108, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -103502,7 +104095,7 @@ var diff = createSwarmTool({
           } else if (base === "unstaged") {
             const oldRef = `:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
-            newContent = fs76.readFileSync(path106.join(directory, file3.path), "utf-8");
+            newContent = fs76.readFileSync(path107.join(directory, file3.path), "utf-8");
           } else {
             const oldRef = `${base}:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
@@ -103577,7 +104170,7 @@ var diff = createSwarmTool({
 init_zod();
 import * as child_process8 from "node:child_process";
 import * as fs77 from "node:fs";
-import * as path107 from "node:path";
+import * as path108 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var diff_summary = createSwarmTool({
@@ -103630,7 +104223,7 @@ var diff_summary = createSwarmTool({
         }
         try {
           let oldContent;
-          const newContent = fs77.readFileSync(path107.join(workingDir, filePath), "utf-8");
+          const newContent = fs77.readFileSync(path108.join(workingDir, filePath), "utf-8");
           if (fileExistsInHead) {
             oldContent = child_process8.execFileSync("git", ["show", `HEAD:${filePath}`], {
               encoding: "utf-8",
@@ -103859,7 +104452,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs78 from "node:fs";
-import * as path108 from "node:path";
+import * as path109 from "node:path";
 var MAX_FILE_SIZE_BYTES6 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR3 = ".swarm/evidence";
@@ -103886,9 +104479,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path108.resolve(cwd);
-  const swarmPath = path108.join(normalizedCwd, ".swarm");
-  const normalizedPath = path108.resolve(filePath);
+  const normalizedCwd = path109.resolve(cwd);
+  const swarmPath = path109.join(normalizedCwd, ".swarm");
+  const normalizedPath = path109.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -103918,10 +104511,10 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path108.join(evidenceDir, filename);
+    const filePath = path109.join(evidenceDir, filename);
     try {
-      const resolvedPath = path108.resolve(filePath);
-      const evidenceDirResolved = path108.resolve(evidenceDir);
+      const resolvedPath = path109.resolve(filePath);
+      const evidenceDirResolved = path109.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
@@ -104039,7 +104632,7 @@ var evidence_check = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0).map(normalizeEvidenceType);
-    const planPath = path108.join(cwd, PLAN_FILE);
+    const planPath = path109.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -104071,7 +104664,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path108.join(cwd, EVIDENCE_DIR3);
+    const evidenceDir = path109.join(cwd, EVIDENCE_DIR3);
     const evidence = readEvidenceFiles(evidenceDir, cwd);
     const { tasksWithFullEvidence, gaps } = analyzeGaps(completedTasks, evidence, requiredTypes);
     const completeness = completedTasks.length > 0 ? Math.round(tasksWithFullEvidence.length / completedTasks.length * 100) / 100 : 1;
@@ -104089,7 +104682,7 @@ var evidence_check = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs79 from "node:fs";
-import * as path109 from "node:path";
+import * as path110 from "node:path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -104170,12 +104763,12 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path109.join(targetDir, filename);
-      const base = path109.basename(filepath, path109.extname(filepath));
-      const ext = path109.extname(filepath);
+      let filepath = path110.join(targetDir, filename);
+      const base = path110.basename(filepath, path110.extname(filepath));
+      const ext = path110.extname(filepath);
       let counter = 1;
       while (fs79.existsSync(filepath)) {
-        filepath = path109.join(targetDir, `${base}_${counter}${ext}`);
+        filepath = path110.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
@@ -104433,7 +105026,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs80 from "node:fs";
-import * as path110 from "node:path";
+import * as path111 from "node:path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
@@ -104481,7 +105074,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path110.extname(filePath).toLowerCase();
+  const ext = path111.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -104505,15 +105098,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path110.resolve(targetFile);
+    _resolvedTarget = path111.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path110.basename(targetFile, path110.extname(targetFile));
+  const targetBasename = path111.basename(targetFile, path111.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path110.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path110.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path111.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path111.normalize(targetWithoutExt).replace(/\\/g, "/");
   const importRegex = /import\s+(?:\{[\s\S]*?\}|(?:\*\s+as\s+\w+)|\w+)\s+from\s+['"`]([^'"`]+)['"`]|import\s+['"`]([^'"`]+)['"`]|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
   for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
     const modulePath = match[1] || match[2] || match[3];
@@ -104536,9 +105129,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path110.dirname(targetFile);
-    const targetExt = path110.extname(targetFile);
-    const targetBasenameNoExt = path110.basename(targetFile, targetExt);
+    const _targetDir = path111.dirname(targetFile);
+    const targetExt = path111.extname(targetFile);
+    const targetBasenameNoExt = path111.basename(targetFile, targetExt);
     const moduleNormalized = modulePath.replace(/\\/g, "/").replace(/^\.\//, "");
     const moduleName = modulePath.split(/[/\\]/).pop() || "";
     const moduleNameNoExt = moduleName.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
@@ -104606,10 +105199,10 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
     if (SKIP_DIRECTORIES4.has(entry)) {
-      stats.skippedDirs.push(path110.join(dir, entry));
+      stats.skippedDirs.push(path111.join(dir, entry));
       continue;
     }
-    const fullPath = path110.join(dir, entry);
+    const fullPath = path111.join(dir, entry);
     let stat8;
     try {
       stat8 = fs80.statSync(fullPath);
@@ -104623,7 +105216,7 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
     if (stat8.isDirectory()) {
       findSourceFiles2(fullPath, files, stats);
     } else if (stat8.isFile()) {
-      const ext = path110.extname(fullPath).toLowerCase();
+      const ext = path111.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS3.includes(ext)) {
         files.push(fullPath);
       }
@@ -104680,7 +105273,7 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path110.resolve(file3);
+      const targetFile = path111.resolve(file3);
       if (!fs80.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
@@ -104702,7 +105295,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path110.dirname(targetFile);
+      const baseDir = path111.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -104787,7 +105380,7 @@ var imports = createSwarmTool({
 });
 // src/tools/knowledge-ack.ts
 init_zod();
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 init_state();
 init_logger();
 init_create_tool();
@@ -104820,7 +105413,7 @@ var knowledge_ack = createSwarmTool({
     let sessionId = ctx?.sessionID;
     if (!sessionId) {
       warn("[knowledge-ack] No sessionID in tool context — dedup disabled for this acknowledgment");
-      sessionId = randomUUID9();
+      sessionId = randomUUID10();
     }
     const dedupKey = buildAckDedupKey(sessionId, a.id, a.result);
     if (swarmState.knowledgeAckDedup.has(dedupKey)) {
@@ -104850,7 +105443,7 @@ init_knowledge_store();
 init_knowledge_validator();
 init_manager();
 init_create_tool();
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 var VALID_CATEGORIES2 = [
   "process",
   "architecture",
@@ -104924,7 +105517,7 @@ var knowledge_add = createSwarmTool({
       project_name = plan?.title ?? "";
     } catch {}
     const entry = {
-      id: randomUUID10(),
+      id: randomUUID11(),
       tier: "swarm",
       lesson,
       category,
@@ -105327,22 +105920,22 @@ init_schema();
 init_qa_gate_profile();
 init_manager2();
 import * as fs85 from "node:fs";
-import * as path115 from "node:path";
+import * as path116 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
 init_logger();
 init_state2();
 import * as fs81 from "node:fs";
-import * as path111 from "node:path";
+import * as path112 from "node:path";
 var APPROVAL_TTL_MS = 24 * 60 * 60 * 1000;
 function readEvidenceDir(directory, phase) {
   try {
-    const dirPath = validateSwarmPath(directory, path111.posix.join("evidence", String(phase)));
+    const dirPath = validateSwarmPath(directory, path112.posix.join("evidence", String(phase)));
     if (!fs81.existsSync(dirPath))
       return [];
     const entries = fs81.readdirSync(dirPath);
-    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path111.join(dirPath, e));
+    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path112.join(dirPath, e));
   } catch {
     return [];
   }
@@ -105481,16 +106074,16 @@ init_plan_schema();
 init_ledger();
 init_manager();
 import * as fs82 from "node:fs";
-import * as path112 from "node:path";
+import * as path113 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const swarmDir = path112.join(directory, ".swarm");
+    const swarmDir = path113.join(directory, ".swarm");
     fs82.mkdirSync(swarmDir, { recursive: true });
-    const jsonPath = path112.join(swarmDir, "SWARM_PLAN.json");
-    const mdPath = path112.join(swarmDir, "SWARM_PLAN.md");
+    const jsonPath = path113.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path113.join(swarmDir, "SWARM_PLAN.md");
     fs82.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
     fs82.writeFileSync(mdPath, md, "utf8");
@@ -105509,15 +106102,15 @@ init_telemetry();
 // src/turbo/lean/phase-ready.ts
 init_file_locks();
 import * as fs84 from "node:fs";
-import * as path114 from "node:path";
+import * as path115 from "node:path";
 
 // src/turbo/lean/evidence.ts
 init_bun_compat();
 import { rmSync as rmSync6 } from "node:fs";
 import * as fs83 from "node:fs/promises";
-import * as path113 from "node:path";
+import * as path114 from "node:path";
 function leanTurboEvidenceDir(directory, phase) {
-  return path113.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  return path114.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
 }
 function validateLaneId(laneId) {
   if (laneId.length === 0) {
@@ -105539,16 +106132,16 @@ function validateLaneId(laneId) {
 function laneEvidencePath(directory, phase, laneId) {
   validateLaneId(laneId);
   const expectedDir = leanTurboEvidenceDir(directory, phase);
-  const resolvedPath = path113.resolve(path113.join(expectedDir, `${laneId}.json`));
-  const resolvedDir = path113.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path113.sep) && resolvedPath !== resolvedDir) {
+  const resolvedPath = path114.resolve(path114.join(expectedDir, `${laneId}.json`));
+  const resolvedDir = path114.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path114.sep) && resolvedPath !== resolvedDir) {
     throw new Error(`Invalid laneId: path traversal detected (got "${laneId}")`);
   }
   return resolvedPath;
 }
 async function atomicWriteJson(filePath, data) {
   const content = JSON.stringify(data, null, 2);
-  const dir = path113.dirname(filePath);
+  const dir = path114.dirname(filePath);
   await fs83.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
   try {
@@ -105562,7 +106155,7 @@ async function atomicWriteJson(filePath, data) {
   }
 }
 function phaseEvidencePath(directory, phase) {
-  return path113.join(leanTurboEvidenceDir(directory, phase), "lean-turbo-phase.json");
+  return path114.join(leanTurboEvidenceDir(directory, phase), "lean-turbo-phase.json");
 }
 async function writeLaneEvidence(directory, phase, evidence) {
   const targetPath = laneEvidencePath(directory, phase, evidence.laneId);
@@ -105606,7 +106199,7 @@ async function listLaneEvidence(directory, phase) {
     if (entry === "lean-turbo-phase.json") {
       continue;
     }
-    const filePath = path113.join(evidenceDir, entry);
+    const filePath = path114.join(evidenceDir, entry);
     let content;
     try {
       content = await fs83.readFile(filePath, "utf-8");
@@ -105630,7 +106223,7 @@ var DEFAULT_CONFIG2 = {
 };
 function defaultReadPlanJson(dir) {
   try {
-    const planPath = path114.join(dir, ".swarm", "plan.json");
+    const planPath = path115.join(dir, ".swarm", "plan.json");
     if (!fs84.existsSync(planPath))
       return null;
     const raw = fs84.readFileSync(planPath, "utf-8");
@@ -105645,7 +106238,7 @@ function defaultReadPlanJson(dir) {
 }
 function readReviewerEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path114.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
+    const evidencePath = path115.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
     if (!fs84.existsSync(evidencePath)) {
       return null;
     }
@@ -105665,7 +106258,7 @@ function readReviewerEvidenceFromFile(directory, phase) {
 }
 function readCriticEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path114.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
+    const evidencePath = path115.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
     if (!fs84.existsSync(evidencePath)) {
       return null;
     }
@@ -105684,7 +106277,7 @@ function readCriticEvidenceFromFile(directory, phase) {
   }
 }
 function listLaneEvidenceSync(directory, phase) {
-  const evidenceDir = path114.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const evidenceDir = path115.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
   let entries;
   try {
     entries = fs84.readdirSync(evidenceDir);
@@ -105754,7 +106347,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     ...DEFAULT_CONFIG2,
     ...actualConfig
   };
-  const statePath = path114.join(directory, ".swarm", "turbo-state.json");
+  const statePath = path115.join(directory, ".swarm", "turbo-state.json");
   if (!fs84.existsSync(statePath)) {
     return {
       ok: false,
@@ -105942,7 +106535,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (mergedConfig.integrated_diff_required) {
-    const evidencePath = path114.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
+    const evidencePath = path115.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
     let hasDiff = false;
     try {
       const content = fs84.readFileSync(evidencePath, "utf-8");
@@ -106237,7 +106830,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     let driftCheckEnabled = true;
     let driftHasSpecMd = false;
     try {
-      const specMdPath = path115.join(dir, ".swarm", "spec.md");
+      const specMdPath = path116.join(dir, ".swarm", "spec.md");
       driftHasSpecMd = fs85.existsSync(specMdPath);
       const gatePlan = await loadPlan(dir);
       if (gatePlan) {
@@ -106258,7 +106851,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     } else {
       let phaseType;
       try {
-        const planPath = path115.join(dir, ".swarm", "plan.json");
+        const planPath = path116.join(dir, ".swarm", "plan.json");
         if (fs85.existsSync(planPath)) {
           const planRaw = fs85.readFileSync(planPath, "utf-8");
           const plan = JSON.parse(planRaw);
@@ -106270,7 +106863,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
         warnings.push(`Phase ${phase} is annotated as 'non-code'. Drift verification was skipped per phase type annotation.`);
       } else {
         try {
-          const driftEvidencePath = path115.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+          const driftEvidencePath = path116.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
           let driftVerdictFound = false;
           let driftVerdictApproved = false;
           try {
@@ -106308,7 +106901,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
               let incompleteTaskCount = 0;
               let planParseable = false;
               try {
-                const planPath = path115.join(dir, ".swarm", "plan.json");
+                const planPath = path116.join(dir, ".swarm", "plan.json");
                 if (fs85.existsSync(planPath)) {
                   const planRaw = fs85.readFileSync(planPath, "utf-8");
                   const plan = JSON.parse(planRaw);
@@ -106375,7 +106968,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.hallucination_guard === true) {
-            const hgPath = path115.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+            const hgPath = path116.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
             let hgVerdictFound = false;
             let hgVerdictApproved = false;
             try {
@@ -106447,7 +107040,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.mutation_test === true) {
-            const mgPath = path115.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+            const mgPath = path116.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
             let mgVerdictFound = false;
             let mgVerdict;
             try {
@@ -106521,7 +107114,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const effective = getEffectiveGates(profile, overrides);
           if (effective.council_mode === true) {
             councilModeEnabled = true;
-            const pcPath = path115.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+            const pcPath = path116.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
             let pcVerdictFound = false;
             let _pcVerdict;
             let pcQuorumSize;
@@ -106729,7 +107322,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
             const effective = getEffectiveGates(profile, overrides);
             if (effective.final_council === true) {
               finalCouncilEnabled = true;
-              const fcPath = path115.join(dir, ".swarm", "evidence", "final-council.json");
+              const fcPath = path116.join(dir, ".swarm", "evidence", "final-council.json");
               let fcVerdictFound = false;
               let _fcVerdict;
               try {
@@ -106917,7 +107510,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path115.basename(dir);
+      const projectName = path116.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -107287,7 +107880,7 @@ init_utils();
 init_bun_compat();
 init_create_tool();
 import * as fs86 from "node:fs";
-import * as path116 from "node:path";
+import * as path117 from "node:path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -107315,16 +107908,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs86.existsSync(path116.join(cwd, "package.json"))) {
+  if (fs86.existsSync(path117.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs86.existsSync(path116.join(cwd, "pyproject.toml")) || fs86.existsSync(path116.join(cwd, "requirements.txt"))) {
+  if (fs86.existsSync(path117.join(cwd, "pyproject.toml")) || fs86.existsSync(path117.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs86.existsSync(path116.join(cwd, "Cargo.toml"))) {
+  if (fs86.existsSync(path117.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs86.existsSync(path116.join(cwd, "go.mod"))) {
+  if (fs86.existsSync(path117.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -107333,13 +107926,13 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs86.existsSync(path116.join(cwd, "Gemfile")) || fs86.existsSync(path116.join(cwd, "Gemfile.lock"))) {
+  if (fs86.existsSync(path117.join(cwd, "Gemfile")) || fs86.existsSync(path117.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs86.existsSync(path116.join(cwd, "pubspec.yaml"))) {
+  if (fs86.existsSync(path117.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs86.existsSync(path116.join(cwd, "composer.lock"))) {
+  if (fs86.existsSync(path117.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -108475,7 +109068,7 @@ var pkg_audit = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs87 from "node:fs";
-import * as path117 from "node:path";
+import * as path118 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -108598,7 +109191,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path117.basename(filePath);
+  const filename = path118.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -108615,7 +109208,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path117.basename(filePath);
+    const filename = path118.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -108624,7 +109217,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path117.extname(filePath).toLowerCase();
+  const ext = path118.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -108871,9 +109464,9 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path117.isAbsolute(filePath) ? filePath : path117.resolve(directory, filePath);
-    const resolvedDirectory = path117.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path117.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path118.isAbsolute(filePath) ? filePath : path118.resolve(directory, filePath);
+    const resolvedDirectory = path118.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path118.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
     if (!fs87.existsSync(fullPath)) {
@@ -108882,7 +109475,7 @@ async function placeholderScan(input, directory) {
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path117.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path118.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
@@ -108954,7 +109547,7 @@ var placeholder_scan = createSwarmTool({
 });
 // src/tools/pre-check-batch.ts
 import * as fs91 from "node:fs";
-import * as path121 from "node:path";
+import * as path122 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -109095,7 +109688,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs90 from "node:fs";
-import * as path120 from "node:path";
+import * as path121 from "node:path";
 import { extname as extname20 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -109811,7 +110404,7 @@ function executeRulesSync(filePath, content, language) {
 // src/sast/semgrep.ts
 import * as child_process9 from "node:child_process";
 import * as fs88 from "node:fs";
-import * as path118 from "node:path";
+import * as path119 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS3 = 30000;
@@ -109998,7 +110591,7 @@ async function runSemgrep(options) {
 }
 function getRulesDirectory(projectRoot) {
   if (projectRoot) {
-    return path118.resolve(projectRoot, DEFAULT_RULES_DIR);
+    return path119.resolve(projectRoot, DEFAULT_RULES_DIR);
   }
   return DEFAULT_RULES_DIR;
 }
@@ -110019,24 +110612,24 @@ init_create_tool();
 init_utils2();
 import * as crypto10 from "node:crypto";
 import * as fs89 from "node:fs";
-import * as path119 from "node:path";
+import * as path120 from "node:path";
 var BASELINE_SCHEMA_VERSION = "1.0.0";
 var MAX_BASELINE_FINDINGS = 2000;
 var MAX_BASELINE_BYTES = 2 * 1048576;
 var LOCK_RETRY_DELAYS_MS = [50, 100, 200, 400, 800];
 function normalizeFindingPath(directory, file3) {
-  const resolved = path119.isAbsolute(file3) ? file3 : path119.resolve(directory, file3);
-  const rel = path119.relative(path119.resolve(directory), resolved);
+  const resolved = path120.isAbsolute(file3) ? file3 : path120.resolve(directory, file3);
+  const rel = path120.relative(path120.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path119.join("evidence", String(phase), "sast-baseline.json");
+  return path120.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path119.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path120.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path119.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path120.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -110157,8 +110750,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs89.mkdirSync(path119.dirname(baselinePath), { recursive: true });
-  fs89.mkdirSync(path119.dirname(tempPath), { recursive: true });
+  fs89.mkdirSync(path120.dirname(baselinePath), { recursive: true });
+  fs89.mkdirSync(path120.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
@@ -110431,9 +111024,9 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path120.isAbsolute(filePath) ? filePath : path120.resolve(directory, filePath);
-    const resolvedDirectory = path120.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path120.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path121.isAbsolute(filePath) ? filePath : path121.resolve(directory, filePath);
+    const resolvedDirectory = path121.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path121.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
@@ -110748,18 +111341,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path121.win32.resolve(inputPath);
-  } else if (path121.isAbsolute(inputPath)) {
-    resolved = path121.resolve(inputPath);
+    resolved = path122.win32.resolve(inputPath);
+  } else if (path122.isAbsolute(inputPath)) {
+    resolved = path122.resolve(inputPath);
   } else {
-    resolved = path121.resolve(baseDir, inputPath);
+    resolved = path122.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path121.resolve(workspaceDir);
+  const workspaceResolved = path122.resolve(workspaceDir);
   let relative25;
   if (isWinAbs) {
-    relative25 = path121.win32.relative(workspaceResolved, resolved);
+    relative25 = path122.win32.relative(workspaceResolved, resolved);
   } else {
-    relative25 = path121.relative(workspaceResolved, resolved);
+    relative25 = path122.relative(workspaceResolved, resolved);
   }
   if (relative25.startsWith("..")) {
     return "path traversal detected";
@@ -110824,7 +111417,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path121.resolve(file3);
+    const resolvedPath = path122.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -110981,7 +111574,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path121.resolve(file3);
+      const resolvedPath = path122.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -110999,7 +111592,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path121.extname(file3).toLowerCase();
+      const ext = path122.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -111218,7 +111811,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path121.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path122.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -111269,7 +111862,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path121.resolve(directory, file3));
+    changedFiles.push(path122.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -111470,9 +112063,9 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path121.resolve(typedArgs.directory);
-    const workspaceAnchor = path121.resolve(directory);
-    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path121.sep)) {
+    const resolvedDirectory = path122.resolve(typedArgs.directory);
+    const workspaceAnchor = path122.resolve(directory);
+    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path122.sep)) {
       const subDirError = `directory "${typedArgs.directory}" is a subdirectory of the project root — pre_check_batch requires the project root directory "${workspaceAnchor}"`;
       const subDirResult = {
         gates_passed: false,
@@ -111523,7 +112116,7 @@ var pre_check_batch = createSwarmTool({
 });
 // src/tools/repo-map.ts
 init_zod();
-import * as path122 from "node:path";
+import * as path123 from "node:path";
 init_path_security();
 init_create_tool();
 var VALID_ACTIONS = [
@@ -111548,7 +112141,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path122.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path123.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -111571,8 +112164,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path122.isAbsolute(normalized)) {
-    const rel = path122.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path123.isAbsolute(normalized)) {
+    const rel = path123.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath2(rel);
   }
   return normalizeGraphPath2(normalized);
@@ -111717,7 +112310,7 @@ var repo_map = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs92 from "node:fs";
-import * as path123 from "node:path";
+import * as path124 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS = ["MUST", "SHOULD", "SHALL"];
@@ -111786,7 +112379,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path123.join(evidenceDir, entry);
+    const entryPath = path124.join(evidenceDir, entry);
     try {
       const stat8 = fs92.statSync(entryPath);
       if (!stat8.isDirectory()) {
@@ -111802,11 +112395,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path123.join(entryPath, "evidence.json");
+    const evidenceFilePath = path124.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path123.resolve(evidenceFilePath);
-      const evidenceDirResolved = path123.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path123.sep)) {
+      const resolvedPath = path124.resolve(evidenceFilePath);
+      const evidenceDirResolved = path124.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path124.sep)) {
         continue;
       }
       const stat8 = fs92.lstatSync(evidenceFilePath);
@@ -111840,7 +112433,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
             if (Array.isArray(diffEntry.files_changed)) {
               for (const file3 of diffEntry.files_changed) {
                 if (typeof file3 === "string") {
-                  touchedFiles.add(path123.resolve(cwd, file3));
+                  touchedFiles.add(path124.resolve(cwd, file3));
                 }
               }
             }
@@ -111853,8 +112446,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path123.resolve(filePath);
-    const cwdResolved = path123.resolve(cwd);
+    const resolvedPath = path124.resolve(filePath);
+    const cwdResolved = path124.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
@@ -111988,7 +112581,7 @@ var req_coverage = createSwarmTool({
       }, null, 2);
     }
     const cwd = inputDirectory || directory;
-    const specPath = path123.join(cwd, SPEC_FILE);
+    const specPath = path124.join(cwd, SPEC_FILE);
     let specContent;
     try {
       specContent = fs92.readFileSync(specPath, "utf-8");
@@ -112015,7 +112608,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path123.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path124.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -112041,7 +112634,7 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path123.join(evidenceDir, reportFilename);
+    const reportPath = path124.join(evidenceDir, reportFilename);
     try {
       if (!fs92.existsSync(evidenceDir)) {
         fs92.mkdirSync(evidenceDir, { recursive: true });
@@ -112129,11 +112722,14 @@ init_qa_gate_profile();
 init_file_locks();
 import * as crypto11 from "node:crypto";
 import * as fs93 from "node:fs";
-import * as path124 from "node:path";
+import * as path125 from "node:path";
 init_ledger();
 init_manager();
 init_state();
 init_create_tool();
+function executionProfilesEqual(a, b) {
+  return a.parallelization_enabled === b.parallelization_enabled && a.max_concurrent_tasks === b.max_concurrent_tasks && a.council_parallel === b.council_parallel && a.locked === b.locked;
+}
 function detectPlaceholderContent(args2) {
   const issues = [];
   const placeholderPattern = /^\[\w[\w\s]*\]$/;
@@ -112207,8 +112803,8 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path124.resolve(args2.working_directory);
-    const resolvedRoot = path124.resolve(fallbackDir);
+    const resolvedTarget = path125.resolve(args2.working_directory);
+    const resolvedRoot = path125.resolve(fallbackDir);
     let fallbackExists = false;
     try {
       fs93.accessSync(resolvedRoot, fs93.constants.F_OK);
@@ -112217,7 +112813,7 @@ async function executeSavePlan(args2, fallbackDir) {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path124.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path125.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -112233,7 +112829,7 @@ async function executeSavePlan(args2, fallbackDir) {
   let specMtime;
   let specHash;
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
-    const specPath = path124.join(targetWorkspace, ".swarm", "spec.md");
+    const specPath = path125.join(targetWorkspace, ".swarm", "spec.md");
     try {
       const stat8 = await fs93.promises.stat(specPath);
       specMtime = stat8.mtime.toISOString();
@@ -112249,7 +112845,7 @@ async function executeSavePlan(args2, fallbackDir) {
     }
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path124.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path125.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
       contextContent = await fs93.promises.readFile(contextPath, "utf8");
@@ -112298,18 +112894,51 @@ async function executeSavePlan(args2, fallbackDir) {
           }
         }
       }
-      if (existing.execution_profile?.locked) {
-        if (args2.execution_profile !== undefined && !args2.reset_statuses) {
+      if (args2.confirm_identity_change !== true) {
+        const existingId = derivePlanId(existing);
+        const incomingId = derivePlanId({
+          swarm: args2.swarm_id,
+          title: args2.title
+        });
+        if (existingId !== incomingId) {
           return {
             success: false,
-            message: "EXECUTION_PROFILE_LOCKED: The execution_profile for this plan is locked and cannot be changed.",
+            message: "PLAN_IDENTITY_MISMATCH: The incoming plan identity does not match the existing plan. " + "To overwrite with a new identity, set confirm_identity_change: true.",
             errors: [
-              "execution_profile.locked is true — to change the profile you must first unlock it via a separate plan revision that explicitly sets locked: false, or reset the plan with reset_statuses."
+              `Existing plan identity: ${existingId} (swarm: "${existing.swarm}", title: "${existing.title}")`,
+              `Incoming plan identity: ${incomingId} (swarm: "${args2.swarm_id}", title: "${args2.title}")`
             ],
-            recovery_guidance: "Remove the execution_profile field from this save_plan call to preserve the locked profile, " + "or use reset_statuses: true to start fresh (this clears the lock). " + "Never modify execution_profile directly in plan.json."
+            recovery_guidance: "Verify the title and swarm_id match the intended plan. " + "If the identity change is intentional, retry with confirm_identity_change: true. " + "Never write .swarm/plan.json or .swarm/plan.md directly."
           };
         }
-        if (!args2.reset_statuses) {
+      }
+      if (existing.execution_profile?.locked) {
+        if (args2.execution_profile !== undefined && !args2.reset_statuses) {
+          const requestedProfile = ExecutionProfileSchema.safeParse({
+            ...existing.execution_profile,
+            ...args2.execution_profile
+          });
+          if (!requestedProfile.success) {
+            return {
+              success: false,
+              message: "Invalid execution_profile: schema validation failed",
+              errors: requestedProfile.error.issues.map((i2) => `${i2.path.join(".")}: ${i2.message}`),
+              recovery_guidance: "Check execution_profile fields: parallelization_enabled (boolean), " + "max_concurrent_tasks (integer 1-64), council_parallel (boolean), locked (boolean)."
+            };
+          }
+          if (executionProfilesEqual(existing.execution_profile, requestedProfile.data)) {
+            preservedExecutionProfile = existing.execution_profile;
+          } else {
+            return {
+              success: false,
+              message: "EXECUTION_PROFILE_LOCKED: The execution_profile for this plan is locked and cannot be changed.",
+              errors: [
+                "execution_profile.locked is true — to change the profile you must first unlock it via a separate plan revision that explicitly sets locked: false, or reset the plan with reset_statuses."
+              ],
+              recovery_guidance: "Remove the execution_profile field from this save_plan call to preserve the locked profile, " + "or use reset_statuses: true to start fresh (this clears the lock). " + "Never modify execution_profile directly in plan.json."
+            };
+          }
+        } else if (!args2.reset_statuses) {
           preservedExecutionProfile = existing.execution_profile;
         }
       } else {
@@ -112481,7 +113110,7 @@ async function executeSavePlan(args2, fallbackDir) {
       });
       const savedPlan = await loadPlanJsonOnly(dir);
       if (savedPlan) {
-        await takeSnapshotEvent(dir, savedPlan).catch(() => {});
+        await takeSnapshotWithRetry(dir, savedPlan);
       }
       if (resolvedProfile !== undefined && savedPlan) {
         const planId = derivePlanId(plan);
@@ -112506,7 +113135,7 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path124.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path125.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
@@ -112529,7 +113158,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path124.join(dir, ".swarm", "plan.json"),
+        plan_path: path125.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -112579,6 +113208,7 @@ var save_plan = createSwarmTool({
     removed_task_ids: exports_external.array(exports_external.string()).optional().describe("Task IDs that are present in the prior plan but intentionally being " + "removed by this save. Every task missing from `phases` MUST be enumerated " + "here, otherwise save_plan rejects with PLAN_TASK_REMOVAL_NOT_ACKNOWLEDGED. " + "Tasks not yet finished (status pending/in_progress/blocked) MUST NOT be " + "removed without explicit user confirmation."),
     removal_reason: exports_external.string().optional().describe("Required when removed_task_ids is non-empty. Human-readable reason recorded " + "on each task_removed ledger event."),
     confirm_destructive_reset: exports_external.boolean().optional().describe("Required when reset_statuses is true AND at least one task is missing from " + "the new plan. Set true to acknowledge that the destructive reset drops " + "unfinished work. When set together with reset_statuses, save_plan auto-" + "populates removed_task_ids from the missing set."),
+    confirm_identity_change: exports_external.boolean().optional().describe("When true, allows overwriting an existing plan that has a different " + "identity (swarm_id + title). Without this flag, save_plan rejects " + "with PLAN_IDENTITY_MISMATCH if the identity differs."),
     execution_profile: exports_external.object({
       parallelization_enabled: exports_external.boolean().optional().describe("When true, enables parallel task dispatch for this plan. Default false (serial)."),
       max_concurrent_tasks: exports_external.number().int().min(1).max(64).optional().describe("Maximum tasks that may run concurrently when parallelization is enabled. Default 1."),
@@ -112594,7 +113224,7 @@ var save_plan = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs94 from "node:fs";
-import * as path125 from "node:path";
+import * as path126 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -113444,7 +114074,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs94.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path125.join(dir, entry.name);
+        const fullPath = path126.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -113453,7 +114083,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path125.relative(rootDir, fullPath));
+              manifestFiles.push(path126.relative(rootDir, fullPath));
               break;
             }
           }
@@ -113471,11 +114101,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs94.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path125.join(dir, entry.name);
+        const fullPath = path126.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path125.relative(workingDir, fullPath));
+              found.push(path126.relative(workingDir, fullPath));
               break;
             }
           }
@@ -113488,11 +114118,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path125.dirname(file3);
+    let currentDir = path126.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path125.sep) {
-        dirs.add(path125.join(workingDir, currentDir));
-        const parent = path125.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path126.sep) {
+        dirs.add(path126.join(workingDir, currentDir));
+        const parent = path126.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -113576,7 +114206,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path125.isAbsolute(relativeOutputDir) ? relativeOutputDir : path125.join(workingDir, relativeOutputDir);
+    const outputDir = path126.isAbsolute(relativeOutputDir) ? relativeOutputDir : path126.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -113599,7 +114229,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path125.isAbsolute(manifestFile) ? manifestFile : path125.join(workingDir, manifestFile);
+        const fullPath = path126.isAbsolute(manifestFile) ? manifestFile : path126.join(workingDir, manifestFile);
         if (!fs94.existsSync(fullPath)) {
           continue;
         }
@@ -113616,7 +114246,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path125.join(outputDir, filename);
+    const outputPath = path126.join(outputDir, filename);
     fs94.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -113660,7 +114290,7 @@ var sbom_generate = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs95 from "node:fs";
-import * as path126 from "node:path";
+import * as path127 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -113692,12 +114322,12 @@ function normalizePath4(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path126.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path126.sep) ? cwd : cwd + path126.sep;
+    const resolvedPath = path127.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path127.sep) ? cwd : cwd + path127.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path126.extname(resolvedPath).toLowerCase();
+    const ext = path127.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -113711,7 +114341,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path126.resolve(cwd, candidate);
+    const candidatePath = path127.resolve(cwd, candidate);
     if (fs95.existsSync(candidatePath)) {
       const stats = fs95.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
@@ -113723,7 +114353,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs95.readFileSync(specFile, "utf-8");
-  const ext = path126.extname(specFile).toLowerCase();
+  const ext = path127.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -113799,7 +114429,7 @@ function extractRoutes(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path126.join(dir, entry.name);
+      const fullPath = path127.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -113809,7 +114439,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path126.extname(entry.name).toLowerCase();
+        const ext = path127.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -113977,7 +114607,7 @@ init_bun_compat();
 init_path_security();
 init_create_tool();
 import * as fs96 from "node:fs";
-import * as path127 from "node:path";
+import * as path128 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -114013,11 +114643,11 @@ function containsWindowsAttacks3(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path127.resolve(workspace, filePath);
+    const resolvedPath = path128.resolve(workspace, filePath);
     const realWorkspace = fs96.realpathSync(workspace);
     const realResolvedPath = fs96.realpathSync(resolvedPath);
-    const relativePath = path127.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path127.isAbsolute(relativePath)) {
+    const relativePath = path128.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path128.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -114030,11 +114660,11 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path127.delimiter)) {
+  for (const dir of searchPath.split(path128.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path127.join(dir, isWindows ? "rg.exe" : "rg");
+    const candidate = path128.join(dir, isWindows ? "rg.exe" : "rg");
     if (fs96.existsSync(candidate))
       return candidate;
   }
@@ -114164,8 +114794,8 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
   try {
     const entries = fs96.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path127.join(dir, entry.name);
-      const relativePath = path127.relative(workspace, fullPath);
+      const fullPath = path128.join(dir, entry.name);
+      const relativePath = path128.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -114206,7 +114836,7 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path127.join(opts.workspace, file3);
+    const fullPath = path128.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
@@ -114574,7 +115204,7 @@ init_config();
 init_schema();
 init_create_tool();
 import { mkdir as mkdir21, rename as rename9, writeFile as writeFile16 } from "node:fs/promises";
-import * as path128 from "node:path";
+import * as path129 from "node:path";
 var MAX_SPEC_BYTES = 256 * 1024;
 var spec_write = createSwarmTool({
   description: "Write the canonical project spec to .swarm/spec.md. Atomic write, size-bounded (256 KiB), heading-required. Honors spec_writer.allow_spec_write.",
@@ -114615,8 +115245,8 @@ var spec_write = createSwarmTool({
         reason: 'spec must contain at least one top-level "# Heading"'
       }, null, 2);
     }
-    const target = path128.join(directory, ".swarm", "spec.md");
-    await mkdir21(path128.dirname(target), { recursive: true });
+    const target = path129.join(directory, ".swarm", "spec.md");
+    await mkdir21(path129.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
@@ -114645,13 +115275,13 @@ init_zod();
 init_loader();
 import {
   existsSync as existsSync74,
-  mkdirSync as mkdirSync32,
+  mkdirSync as mkdirSync33,
   readFileSync as readFileSync64,
   renameSync as renameSync20,
   unlinkSync as unlinkSync16,
   writeFileSync as writeFileSync24
 } from "node:fs";
-import path129 from "node:path";
+import path130 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var VerdictSchema2 = exports_external.object({
@@ -114781,7 +115411,7 @@ var submit_phase_council_verdicts = createSwarmTool({
   }
 });
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
-  const mutationGatePath = path129.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
+  const mutationGatePath = path130.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
     const raw = readFileSync64(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -114843,9 +115473,9 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   }
 }
 function writePhaseCouncilEvidence(workingDir, synthesis) {
-  const evidenceDir = path129.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
-  mkdirSync32(evidenceDir, { recursive: true });
-  const evidenceFile = path129.join(evidenceDir, "phase-council.json");
+  const evidenceDir = path130.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
+  mkdirSync33(evidenceDir, { recursive: true });
+  const evidenceFile = path130.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
       {
@@ -114998,16 +115628,20 @@ var swarm_memory_propose = createSwarmTool({
     }, {
       config: config3.memory
     });
-    const proposal = await gateway.propose(parsed.data);
-    return JSON.stringify({
-      success: proposal.status !== "rejected",
-      proposal_id: proposal.id,
-      status: proposal.status,
-      operation: proposal.operation,
-      memory_id: proposal.proposedRecord?.id,
-      rejection_reason: proposal.rejectionReason,
-      message: proposal.status === "pending" ? "Memory proposal created. Durable memory was not written." : "Memory proposal was captured with policy rejection metadata."
-    }, null, 2);
+    try {
+      const proposal = await gateway.propose(parsed.data);
+      return JSON.stringify({
+        success: proposal.status !== "rejected",
+        proposal_id: proposal.id,
+        status: proposal.status,
+        operation: proposal.operation,
+        memory_id: proposal.proposedRecord?.id,
+        rejection_reason: proposal.rejectionReason,
+        message: proposal.status === "pending" ? "Memory proposal created. Durable memory was not written." : "Memory proposal was captured with policy rejection metadata."
+      }, null, 2);
+    } finally {
+      await gateway.dispose();
+    }
   }
 });
 var _internals51 = {
@@ -115071,19 +115705,23 @@ var swarm_memory_recall = createSwarmTool({
     }, {
       config: config3.memory
     });
-    const bundle = await gateway.recall(parsed.data);
-    return JSON.stringify({
-      success: true,
-      bundle_id: bundle.id,
-      memory_ids: bundle.items.map((item) => item.record.id),
-      total: bundle.items.length,
-      token_estimate: bundle.tokenEstimate,
-      signals: bundle.items.map((item) => ({
-        memory_id: item.record.id,
-        ...item.signals
-      })),
-      prompt_block: bundle.promptBlock
-    }, null, 2);
+    try {
+      const bundle = await gateway.recall(parsed.data);
+      return JSON.stringify({
+        success: true,
+        bundle_id: bundle.id,
+        memory_ids: bundle.items.map((item) => item.record.id),
+        total: bundle.items.length,
+        token_estimate: bundle.tokenEstimate,
+        signals: bundle.items.map((item) => ({
+          memory_id: item.record.id,
+          ...item.signals
+        })),
+        prompt_block: bundle.promptBlock
+      }, null, 2);
+    } finally {
+      await gateway.dispose();
+    }
   }
 });
 var RecallArgsSchema = exports_external.object({
@@ -115106,7 +115744,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs97 from "node:fs";
-import * as path130 from "node:path";
+import * as path131 from "node:path";
 var WINDOWS_RESERVED_NAMES4 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks4(str) {
   if (/:[^\\/]/.test(str))
@@ -115120,14 +115758,14 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path130.resolve(workspace, filePath);
+    const resolvedPath = path131.resolve(workspace, filePath);
     if (!fs97.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs97.realpathSync(workspace);
     const realResolvedPath = fs97.realpathSync(resolvedPath);
-    const relativePath = path130.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path130.isAbsolute(relativePath)) {
+    const relativePath = path131.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path131.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -115335,7 +115973,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path130.resolve(directory, change.file);
+      const fullPath = path131.resolve(directory, change.file);
       if (!fs97.existsSync(fullPath)) {
         errors5.push({
           success: false,
@@ -115639,11 +116277,11 @@ var lean_turbo_acquire_locks = createSwarmTool({
 init_zod();
 init_constants();
 import * as fs99 from "node:fs";
-import * as path132 from "node:path";
+import * as path133 from "node:path";
 
 // src/turbo/lean/conflicts.ts
 import * as fs98 from "node:fs";
-import * as path131 from "node:path";
+import * as path132 from "node:path";
 var DEFAULT_GLOBAL_FILES = [
   "package.json",
   "package-lock.json",
@@ -115770,7 +116408,7 @@ function isProtectedPath2(normalizedPath) {
   return false;
 }
 function readTaskScopes(directory, taskId) {
-  const scopePath = path131.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
+  const scopePath = path132.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
   try {
     if (!fs98.existsSync(scopePath)) {
       return null;
@@ -116158,7 +116796,7 @@ function createEmptyPlan(phaseNumber, planId) {
 // src/tools/lean-turbo-plan-lanes.ts
 init_create_tool();
 function readPlanJson(directory) {
-  const planPath = path132.join(directory, ".swarm", "plan.json");
+  const planPath = path133.join(directory, ".swarm", "plan.json");
   if (!fs99.existsSync(planPath)) {
     return null;
   }
@@ -116213,7 +116851,7 @@ init_config();
 // src/turbo/lean/reviewer.ts
 init_state();
 import * as fs100 from "node:fs/promises";
-import * as path133 from "node:path";
+import * as path134 from "node:path";
 init_state3();
 var DEFAULT_CONFIG3 = {
   reviewerAgent: "",
@@ -116329,9 +116967,9 @@ function parseReviewerVerdict(responseText) {
   return { verdict, reason };
 }
 async function writeReviewerEvidence(directory, phase, verdict, reason) {
-  const evidenceDir = path133.join(directory, ".swarm", "evidence", String(phase));
+  const evidenceDir = path134.join(directory, ".swarm", "evidence", String(phase));
   await fs100.mkdir(evidenceDir, { recursive: true });
-  const evidencePath = path133.join(evidenceDir, "lean-turbo-reviewer.json");
+  const evidencePath = path134.join(evidenceDir, "lean-turbo-reviewer.json");
   const content = JSON.stringify({
     phase,
     verdict,
@@ -117136,7 +117774,7 @@ var lean_turbo_status = createSwarmTool({
 init_spec_schema();
 init_create_tool();
 import * as fs101 from "node:fs";
-import * as path134 from "node:path";
+import * as path135 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHALL", "SHOULD", "MAY"];
@@ -117189,7 +117827,7 @@ var lint_spec = createSwarmTool({
   async execute(_args, directory) {
     const errors5 = [];
     const warnings = [];
-    const specPath = path134.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
+    const specPath = path135.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
     if (!fs101.existsSync(specPath)) {
       const result2 = {
         valid: false,
@@ -117260,12 +117898,12 @@ var lint_spec = createSwarmTool({
 // src/tools/mutation-test.ts
 init_zod();
 import * as fs102 from "node:fs";
-import * as path136 from "node:path";
+import * as path137 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { unlinkSync as unlinkSync17, writeFileSync as writeFileSync25 } from "node:fs";
-import * as path135 from "node:path";
+import * as path136 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -117411,7 +118049,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path135.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path136.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
       writeFileSync25(patchFile, patch.patch);
     } catch (writeErr) {
@@ -117815,7 +118453,7 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path136.resolve(cwd, filePath);
+          const resolvedPath = path137.resolve(cwd, filePath);
           sourceFiles.set(filePath, fs102.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
@@ -117835,7 +118473,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs103 from "node:fs";
-import * as path137 from "node:path";
+import * as path138 from "node:path";
 init_create_tool();
 var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
 var BINARY_CHECK_BYTES = 8192;
@@ -117901,7 +118539,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path137.extname(file3.path).toLowerCase();
+      const ext = path138.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -117914,7 +118552,7 @@ async function syntaxCheck(input, directory, config3) {
   let skippedCount = 0;
   for (const fileInfo of filesToCheck) {
     const { path: filePath } = fileInfo;
-    const fullPath = path137.isAbsolute(filePath) ? filePath : path137.join(directory, filePath);
+    const fullPath = path138.isAbsolute(filePath) ? filePath : path138.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -117963,7 +118601,7 @@ async function syntaxCheck(input, directory, config3) {
         results.push(result);
         continue;
       }
-      const ext = path137.extname(filePath).toLowerCase();
+      const ext = path138.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -118061,7 +118699,7 @@ init_utils();
 init_create_tool();
 init_path_security();
 import * as fs104 from "node:fs";
-import * as path138 from "node:path";
+import * as path139 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -118127,9 +118765,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path138.resolve(paths);
-    const normalizedCwd = path138.resolve(cwd);
-    const normalizedResolved = path138.resolve(resolvedPath);
+    const resolvedPath = path139.resolve(paths);
+    const normalizedCwd = path139.resolve(cwd);
+    const normalizedResolved = path139.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -118145,7 +118783,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path138.extname(filePath).toLowerCase();
+  const ext = path139.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
@@ -118160,7 +118798,7 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES5.has(entry)) {
       continue;
     }
-    const fullPath = path138.join(dir, entry);
+    const fullPath = path139.join(dir, entry);
     let stat8;
     try {
       stat8 = fs104.statSync(fullPath);
@@ -118272,7 +118910,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path138.extname(scanPath)}`,
+          error: `unsupported file extension: ${path139.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -118321,17 +118959,17 @@ init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
 import * as fs108 from "node:fs";
-import * as path142 from "node:path";
+import * as path143 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
 import * as fs106 from "node:fs";
-import * as path140 from "node:path";
+import * as path141 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
 import * as fs105 from "node:fs";
-import * as path139 from "node:path";
+import * as path140 from "node:path";
 var _internals58 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
@@ -118405,10 +119043,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludeRelPath = excludePathRaw.trim();
     if (!excludeRelPath)
       return;
-    const excludePath = path139.isAbsolute(excludeRelPath) ? excludeRelPath : path139.join(directory, excludeRelPath);
+    const excludePath = path140.isAbsolute(excludeRelPath) ? excludeRelPath : path140.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs105.mkdirSync(path139.dirname(excludePath), { recursive: true });
+        fs105.mkdirSync(path140.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
           existing = fs105.readFileSync(excludePath, "utf8");
@@ -118452,7 +119090,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 var _internals59 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path140.join(directory, ".swarm", "plan.json");
+    const planPath = path141.join(directory, ".swarm", "plan.json");
     if (!fs106.existsSync(planPath))
       return null;
     const raw = fs106.readFileSync(planPath, "utf-8");
@@ -118558,7 +119196,7 @@ init_telemetry();
 // src/turbo/lean/task-completion.ts
 init_file_locks();
 import * as fs107 from "node:fs";
-import * as path141 from "node:path";
+import * as path142 from "node:path";
 var _internals60 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
@@ -118577,7 +119215,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path141.basename(file3);
+    const fileName = path142.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -118589,7 +119227,7 @@ function matchesTier3Pattern(files) {
 function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
-    const statePath = path141.join(directory, ".swarm", "turbo-state.json");
+    const statePath = path142.join(directory, ".swarm", "turbo-state.json");
     if (!fs107.existsSync(statePath)) {
       return {
         ok: false,
@@ -118673,11 +119311,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
     };
   }
   const phase = runState.phase ?? 0;
-  const evidencePath = path141.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
-  const expectedDir = path141.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
-  const resolvedPath = path141.resolve(evidencePath);
-  const resolvedDir = path141.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path141.sep) && resolvedPath !== resolvedDir) {
+  const evidencePath = path142.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path142.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path142.resolve(evidencePath);
+  const resolvedDir = path142.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path142.sep) && resolvedPath !== resolvedDir) {
     return {
       ok: false,
       reason: `Lane ID causes path traversal: ${lane.laneId}`,
@@ -118717,7 +119355,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   }
   let filesTouched = [];
   try {
-    const planPath = path141.join(directory, ".swarm", "plan.json");
+    const planPath = path142.join(directory, ".swarm", "plan.json");
     const planRaw = fs107.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
@@ -118801,7 +119439,7 @@ var TIER_3_PATTERNS2 = [
 ];
 function matchesTier3Pattern2(files) {
   for (const file3 of files) {
-    const fileName = path142.basename(file3);
+    const fileName = path143.basename(file3);
     for (const pattern of TIER_3_PATTERNS2) {
       if (pattern.test(fileName)) {
         return true;
@@ -118840,7 +119478,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (!skipStandardTurboBypass && hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path142.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path143.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs108.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -118918,7 +119556,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     if (resolvedDir) {
       try {
-        const planPath = path142.join(resolvedDir, ".swarm", "plan.json");
+        const planPath = path143.join(resolvedDir, ".swarm", "plan.json");
         const planRaw = fs108.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -119155,8 +119793,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
         };
       }
     }
-    normalizedDir = path142.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path142.sep);
+    normalizedDir = path143.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path143.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -119166,10 +119804,10 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
         ]
       };
     }
-    const resolvedDir = path142.resolve(normalizedDir);
+    const resolvedDir = path143.resolve(normalizedDir);
     try {
       const realPath = fs108.realpathSync(resolvedDir);
-      const planPath = path142.join(realPath, ".swarm", "plan.json");
+      const planPath = path143.join(realPath, ".swarm", "plan.json");
       if (!fs108.existsSync(planPath)) {
         return {
           success: false,
@@ -119200,9 +119838,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     directory = fallbackDir;
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs108.realpathSync(path142.resolve(directory));
-    const canonicalRoot = fs108.realpathSync(path142.resolve(fallbackDir));
-    if (canonicalDir.startsWith(canonicalRoot + path142.sep)) {
+    const canonicalDir = fs108.realpathSync(path143.resolve(directory));
+    const canonicalRoot = fs108.realpathSync(path143.resolve(fallbackDir));
+    if (canonicalDir.startsWith(canonicalRoot + path143.sep)) {
       return {
         success: false,
         message: `Invalid working_directory: "${directory}" is a subdirectory of ` + `the project root "${fallbackDir}". Pass the project root path or ` + `omit working_directory entirely.`,
@@ -119214,8 +119852,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path142.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs108.mkdirSync(path142.dirname(evidencePath), { recursive: true });
+      const evidencePath = path143.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs108.mkdirSync(path143.dirname(evidencePath), { recursive: true });
       const fd = fs108.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
@@ -119239,7 +119877,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
-      const planPath = path142.join(directory, ".swarm", "plan.json");
+      const planPath = path143.join(directory, ".swarm", "plan.json");
       const planRaw = fs108.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
@@ -119551,7 +120189,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs109 from "node:fs";
-import path143 from "node:path";
+import path144 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -119599,7 +120237,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path143.join("evidence", String(phase), filename);
+  const relativePath = path144.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -119610,10 +120248,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path143.dirname(validatedPath);
+  const evidenceDir = path144.dirname(validatedPath);
   try {
     await fs109.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path143.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path144.join(evidenceDir, `.${filename}.tmp`);
     await fs109.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs109.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -119709,7 +120347,7 @@ var write_drift_evidence = createSwarmTool({
 init_zod();
 init_loader();
 import fs110 from "node:fs";
-import path144 from "node:path";
+import path145 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -119797,7 +120435,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path144.join("evidence", filename);
+  const relativePath = path145.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -119811,10 +120449,10 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path144.dirname(validatedPath);
+  const evidenceDir = path145.dirname(validatedPath);
   try {
     await fs110.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path144.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path145.join(evidenceDir, `.${filename}.tmp`);
     await fs110.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs110.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -119873,7 +120511,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs111 from "node:fs";
-import path145 from "node:path";
+import path146 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -119921,7 +120559,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path145.join("evidence", String(phase), filename);
+  const relativePath = path146.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -119932,10 +120570,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path145.dirname(validatedPath);
+  const evidenceDir = path146.dirname(validatedPath);
   try {
     await fs111.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path145.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path146.join(evidenceDir, `.${filename}.tmp`);
     await fs111.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs111.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -119984,7 +120622,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs112 from "node:fs";
-import path146 from "node:path";
+import path147 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -120058,7 +120696,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path146.join("evidence", String(phase), filename);
+  const relativePath = path147.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -120069,10 +120707,10 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path146.dirname(validatedPath);
+  const evidenceDir = path147.dirname(validatedPath);
   try {
     await fs112.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path146.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path147.join(evidenceDir, `.${filename}.tmp`);
     await fs112.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs112.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -120422,7 +121060,7 @@ async function initializeOpenCodeSwarm(ctx) {
     const { PreflightTriggerManager: PTM } = await Promise.resolve().then(() => (init_trigger(), exports_trigger));
     preflightTriggerManager = new PTM(automationConfig);
     const { AutomationStatusArtifact: ASA } = await Promise.resolve().then(() => (init_status_artifact(), exports_status_artifact));
-    const swarmDir = path148.resolve(ctx.directory, ".swarm");
+    const swarmDir = path149.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -120601,30 +121239,29 @@ async function initializeOpenCodeSwarm(ctx) {
       swarm_command: createSwarmCommandTool(agentDefinitionMap)
     },
     config: async (opencodeConfig) => {
-      if (!opencodeConfig.agent || typeof opencodeConfig.agent !== "object") {
-        opencodeConfig.agent = {};
-      }
-      if (!opencodeConfig.agent) {
-        opencodeConfig.agent = { ...agents };
-      } else {
-        Object.assign(opencodeConfig.agent, agents);
+      const isObjectRecord = (value) => typeof value === "object" && value !== null;
+      const pluginConfig = opencodeConfig;
+      if (!isObjectRecord(pluginConfig.agent)) {
+        pluginConfig.agent = {};
       }
+      const agentConfig = pluginConfig.agent;
+      Object.assign(agentConfig, agents);
       const autoSelect = config3?.auto_select_architect;
       if (autoSelect) {
         const hasArchitect = Object.keys(agents).some((name2) => stripKnownSwarmPrefix(name2) === "architect");
         if (hasArchitect) {
           for (const builtin of ["build", "plan"]) {
-            const existing = opencodeConfig.agent?.[builtin];
-            if (existing && typeof existing === "object" && existing.disable === true) {
+            const existing = agentConfig[builtin];
+            if (isObjectRecord(existing) && existing.disable === true) {
               continue;
             }
-            opencodeConfig.agent[builtin] = {
-              ...existing && typeof existing === "object" ? existing : {},
+            agentConfig[builtin] = {
+              ...isObjectRecord(existing) ? existing : {},
               disable: true
             };
           }
           if (autoSelect === true) {
-            const primaryArchitects = Object.entries(agents).filter(([name2, cfg]) => stripKnownSwarmPrefix(name2) === "architect" && cfg.mode === "primary");
+            const primaryArchitects = Object.entries(agents).filter(([name2, cfg]) => stripKnownSwarmPrefix(name2) === "architect" && isObjectRecord(cfg) && cfg.mode === "primary");
             if (primaryArchitects.length > 1) {
               const names = primaryArchitects.map(([n]) => n).join(", ");
               addDeferredWarning(`[swarm] auto_select_architect is true but ${primaryArchitects.length} architect agents are primary (${names}). Consider setting auto_select_architect to a specific agent name.`);
@@ -120636,22 +121273,19 @@ async function initializeOpenCodeSwarm(ctx) {
             if (targetIsArchitect) {
               for (const [name2, cfg] of Object.entries(agents)) {
                 if (stripKnownSwarmPrefix(name2) === "architect" && name2 !== targetName) {
-                  if (opencodeConfig.agent && typeof opencodeConfig.agent === "object") {
-                    opencodeConfig.agent[name2] = {
-                      ...cfg && typeof cfg === "object" ? cfg : {},
-                      mode: "subagent"
-                    };
-                  }
+                  agentConfig[name2] = {
+                    ...isObjectRecord(cfg) ? cfg : {},
+                    mode: "subagent"
+                  };
                 }
               }
-              if (opencodeConfig.agent && typeof opencodeConfig.agent === "object") {
-                const targetExisting = opencodeConfig.agent[targetName];
-                opencodeConfig.agent[targetName] = {
-                  ...targetExisting && typeof targetExisting === "object" ? targetExisting : {},
-                  ...agents[targetName] && typeof agents[targetName] === "object" ? agents[targetName] : {},
-                  mode: "primary"
-                };
-              }
+              const targetExisting = agentConfig[targetName];
+              const targetAgent = agents[targetName];
+              agentConfig[targetName] = {
+                ...isObjectRecord(targetExisting) ? targetExisting : {},
+                ...isObjectRecord(targetAgent) ? targetAgent : {},
+                mode: "primary"
+              };
             } else {
               addDeferredWarning(`[swarm] auto_select_architect is set to "${targetName}" but that is not a known architect agent. No architect demotion applied.`);
             }
@@ -121006,7 +121640,7 @@ ${promptRaw}`;
                   "ci-failure-resolver": "CI/CD failure resolution"
                 };
                 const skillPaths = topSkills.map((s) => {
-                  const dirName = path148.basename(path148.dirname(s.skillPath));
+                  const dirName = path149.basename(path149.dirname(s.skillPath));
                   const desc = SKILL_DESCRIPTIONS[dirName] ?? dirName;
                   return `file:${s.skillPath} (-- ${desc})`;
                 }).join(", ");
@@ -121015,7 +121649,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path148.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path149.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {