opencode-swarm 6.21.3 → 6.22.1

package/dist/index.js

@@ -14549,7 +14549,7 @@ async function loadEvidence(directory, taskId) {
       return { status: "found", bundle: validated };
     } catch (error49) {
       warn(`Wrapped flat retrospective failed validation for task ${sanitizedTaskId}: ${error49 instanceof Error ? error49.message : String(error49)}`);
-      const errors3 = error49 instanceof ZodError ? error49.issues.map((e) => e.path.join(".") + ": " + e.message) : [String(error49)];
+      const errors3 = error49 instanceof ZodError ? error49.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [String(error49)];
       return { status: "invalid_schema", errors: errors3 };
     }
   }
@@ -14558,7 +14558,7 @@ async function loadEvidence(directory, taskId) {
     return { status: "found", bundle: validated };
   } catch (error49) {
     warn(`Evidence bundle validation failed for task ${sanitizedTaskId}: ${error49 instanceof Error ? error49.message : String(error49)}`);
-    const errors3 = error49 instanceof ZodError ? error49.issues.map((e) => e.path.join(".") + ": " + e.message) : [String(error49)];
+    const errors3 = error49 instanceof ZodError ? error49.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [String(error49)];
     return { status: "invalid_schema", errors: errors3 };
   }
 }
@@ -36296,8 +36296,8 @@ var init_tree_sitter = __esm(() => {
         bytes = Promise.resolve(input);
       } else {
         if (globalThis.process?.versions.node) {
-          const fs25 = await import("fs/promises");
-          bytes = fs25.readFile(input);
+          const fs27 = await import("fs/promises");
+          bytes = fs27.readFile(input);
         } else {
           bytes = fetch(input).then((response) => response.arrayBuffer().then((buffer) => {
             if (response.ok) {
@@ -36352,11 +36352,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path36) {
+      function locateFile(path39) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path36, scriptDirectory);
+          return Module["locateFile"](path39, scriptDirectory);
         }
-        return scriptDirectory + path36;
+        return scriptDirectory + path39;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -38104,7 +38104,7 @@ var init_runtime = __esm(() => {
 });
 
 // src/index.ts
-import * as path45 from "path";
+import * as path48 from "path";
 
 // src/tools/tool-names.ts
 var TOOL_NAMES = [
@@ -38763,6 +38763,16 @@ var KnowledgeConfigSchema = exports_external.object({
   min_retrievals_for_utility: exports_external.number().min(1).max(100).default(3),
   schema_version: exports_external.number().int().min(1).default(1)
 });
+var CuratorConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  init_enabled: exports_external.boolean().default(true),
+  phase_enabled: exports_external.boolean().default(true),
+  max_summary_tokens: exports_external.number().min(500).max(8000).default(2000),
+  min_knowledge_confidence: exports_external.number().min(0).max(1).default(0.7),
+  compliance_report: exports_external.boolean().default(true),
+  suppress_warnings: exports_external.boolean().default(true),
+  drift_inject_max_chars: exports_external.number().min(100).max(2000).default(500)
+});
 var PluginConfigSchema = exports_external.object({
   agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
   swarms: exports_external.record(exports_external.string(), SwarmConfigSchema).optional(),
@@ -38790,6 +38800,7 @@ var PluginConfigSchema = exports_external.object({
   checkpoint: CheckpointConfigSchema.optional(),
   automation: AutomationConfigSchema.optional(),
   knowledge: KnowledgeConfigSchema.optional(),
+  curator: CuratorConfigSchema.optional(),
   tool_output: exports_external.object({
     truncation_enabled: exports_external.boolean().default(true),
     max_lines: exports_external.number().min(10).max(500).default(150),
@@ -42540,7 +42551,7 @@ async function readRejectedLessons(directory) {
 }
 async function appendKnowledge(filePath, entry) {
   await mkdir(path9.dirname(filePath), { recursive: true });
-  await appendFile(filePath, JSON.stringify(entry) + `
+  await appendFile(filePath, `${JSON.stringify(entry)}
 `, "utf-8");
 }
 async function rewriteKnowledge(filePath, entries) {
@@ -43123,7 +43134,7 @@ async function checkPhaseBoundaries(plan) {
   for (const phase of plan.phases) {
     for (const task of phase.tasks) {
       const taskPhaseNum = parseInt(task.id.split(".")[0], 10);
-      if (isNaN(taskPhaseNum)) {
+      if (Number.isNaN(taskPhaseNum)) {
         mismatches.push(`Task ${task.id} has invalid phase number`);
       } else if (taskPhaseNum !== phase.id) {
         mismatches.push(`Task ${task.id} found under Phase ${phase.id}`);
@@ -43935,7 +43946,7 @@ function sanitizeString(str, maxLength) {
     return "";
   const sanitized = String(str).replace(RTL_OVERRIDE_PATTERN, "");
   if (sanitized.length > maxLength) {
-    return sanitized.substring(0, maxLength - 3) + "...";
+    return `${sanitized.substring(0, maxLength - 3)}...`;
   }
   return sanitized;
 }
@@ -44106,7 +44117,7 @@ async function getHandoffData(directory) {
       const phaseMatch = planMdContent.match(/^## Phase (\d+):?\s*(.+)?$/m);
       const taskMatch = planMdContent.match(/^- \[ \] (\d+\.\d+)/g);
       if (phaseMatch) {
-        planInfo.currentPhase = sanitizeString(`Phase ${phaseMatch[1]}${phaseMatch[2] ? ": " + phaseMatch[2] : ""}`, MAX_TASK_ID_LENGTH);
+        planInfo.currentPhase = sanitizeString(`Phase ${phaseMatch[1]}${phaseMatch[2] ? `: ${phaseMatch[2]}` : ""}`, MAX_TASK_ID_LENGTH);
       }
       if (taskMatch) {
         const rawTasks = taskMatch.map((t) => t.replace("- [ ] ", ""));
@@ -44273,7 +44284,8 @@ function serializeAgentSession(s) {
     lastPhaseCompletePhase: s.lastPhaseCompletePhase ?? 0,
     phaseAgentsDispatched,
     qaSkipCount: s.qaSkipCount ?? 0,
-    qaSkipTaskIds: s.qaSkipTaskIds ?? []
+    qaSkipTaskIds: s.qaSkipTaskIds ?? [],
+    taskWorkflowStates: Object.fromEntries(s.taskWorkflowStates ?? new Map)
   };
 }
 async function writeSnapshot(directory, state) {
@@ -46135,7 +46147,7 @@ No plan content available. Start by creating a .swarm/plan.md file.
       if (incompleteTasks.length > 0) {
         const truncateTask = (task) => {
           const text = task.replace("- [ ] ", "");
-          return text.length > 60 ? text.slice(0, 57) + "..." : text;
+          return text.length > 60 ? `${text.slice(0, 57)}...` : text;
         };
         compactResult.push(`- Current: ${truncateTask(incompleteTasks[0])}`);
         const lookahead = incompleteTasks.slice(1, 1 + Math.min(lookaheadCount, 1));
@@ -47201,7 +47213,7 @@ function shouldMaskToolOutput(msg, index, totalMessages, recentWindowSize, thres
   const age = totalMessages - 1 - index;
   return age > recentWindowSize || text.length > threshold;
 }
-function maskToolOutput(msg, threshold) {
+function maskToolOutput(msg, _threshold) {
   if (!msg?.parts)
     return 0;
   let freedTokens = 0;
@@ -48322,6 +48334,416 @@ function consolidateSystemMessages(messages) {
 }
 // src/hooks/phase-monitor.ts
 init_manager2();
+
+// src/hooks/curator.ts
+init_event_bus();
+import * as fs14 from "fs";
+import * as path26 from "path";
+init_utils2();
+async function readCuratorSummary(directory) {
+  const content = await readSwarmFileAsync(directory, "curator-summary.json");
+  if (content === null) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed.schema_version !== 1) {
+      console.warn(`Curator summary has unsupported schema version: ${parsed.schema_version}. Expected 1.`);
+      return null;
+    }
+    return parsed;
+  } catch {
+    console.warn("Failed to parse curator-summary.json: invalid JSON");
+    return null;
+  }
+}
+async function writeCuratorSummary(directory, summary) {
+  const resolvedPath = validateSwarmPath(directory, "curator-summary.json");
+  fs14.mkdirSync(path26.dirname(resolvedPath), { recursive: true });
+  await Bun.write(resolvedPath, JSON.stringify(summary, null, 2));
+}
+function normalizeAgentName(name2) {
+  return name2.toLowerCase().replace(/^(mega|paid|local|lowtier|modelrelay)_/, "");
+}
+function filterPhaseEvents(eventsJsonl, phase, sinceTimestamp) {
+  const lines = eventsJsonl.split(`
+`);
+  const filtered = [];
+  for (const line of lines) {
+    if (!line.trim())
+      continue;
+    try {
+      const event = JSON.parse(line);
+      if (sinceTimestamp) {
+        if (event.timestamp > sinceTimestamp) {
+          filtered.push(event);
+        }
+      } else {
+        if (event.phase === phase) {
+          filtered.push(event);
+        }
+      }
+    } catch {
+      console.warn("filterPhaseEvents: skipping malformed line");
+    }
+  }
+  return filtered;
+}
+function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, phase) {
+  const observations = [];
+  const timestamp = new Date().toISOString();
+  for (const agent of requiredAgents) {
+    const normalizedAgent = normalizeAgentName(agent);
+    const isDispatched = agentsDispatched.some((a) => normalizeAgentName(a) === normalizedAgent);
+    if (!isDispatched) {
+      observations.push({
+        phase,
+        timestamp,
+        type: "workflow_deviation",
+        severity: "warning",
+        description: `Agent '${agent}' required but not dispatched in phase ${phase}`
+      });
+    }
+  }
+  const coderDelegations = [];
+  const reviewerDelegations = [];
+  for (let i2 = 0;i2 < phaseEvents.length; i2++) {
+    const e = phaseEvents[i2];
+    try {
+      if (e.type === "agent.delegation") {
+        const agent = e.agent;
+        if (agent && typeof agent === "string") {
+          const normalized = normalizeAgentName(agent);
+          if (normalized === "coder") {
+            coderDelegations.push({ event: e, index: i2 });
+          } else if (normalized === "reviewer") {
+            reviewerDelegations.push({ event: e, index: i2 });
+          }
+        }
+      }
+    } catch {}
+  }
+  for (const coderEvent of coderDelegations) {
+    const hasSubsequentReviewer = reviewerDelegations.some((r) => r.index > coderEvent.index);
+    if (!hasSubsequentReviewer) {
+      observations.push({
+        phase,
+        timestamp,
+        type: "missing_reviewer",
+        severity: "warning",
+        description: `Coder delegation in phase ${phase} has no subsequent reviewer delegation`
+      });
+    }
+  }
+  let phaseCompleteIndex = -1;
+  let retroIndex = -1;
+  for (let i2 = 0;i2 < phaseEvents.length; i2++) {
+    const e = phaseEvents[i2];
+    try {
+      const eventType = e.type;
+      const evidenceType = e.evidence_type;
+      if (typeof eventType === "string" && (eventType === "phase_complete" || eventType === "phase.complete")) {
+        phaseCompleteIndex = i2;
+      }
+      if (typeof eventType === "string" && eventType === "retrospective.written" || typeof evidenceType === "string" && evidenceType === "retrospective") {
+        retroIndex = i2;
+      }
+    } catch {}
+  }
+  if (phaseCompleteIndex !== -1 && retroIndex === -1) {
+    observations.push({
+      phase,
+      timestamp,
+      type: "missing_retro",
+      severity: "warning",
+      description: `Phase ${phase} completed without retrospective evidence`
+    });
+  }
+  const domainDetectionEvents = [];
+  const smeDelegations = [];
+  for (let i2 = 0;i2 < phaseEvents.length; i2++) {
+    const e = phaseEvents[i2];
+    try {
+      if (e.type === "domains.detected") {
+        domainDetectionEvents.push({ event: e, index: i2 });
+      }
+      if (e.type === "agent.delegation" && e.agent) {
+        const agent = e.agent;
+        if (agent && typeof agent === "string") {
+          const normalized = normalizeAgentName(agent);
+          if (normalized === "sme") {
+            smeDelegations.push({ event: e, index: i2 });
+          }
+        }
+      }
+    } catch {}
+  }
+  for (const domainEvent of domainDetectionEvents) {
+    const hasSubsequentSme = smeDelegations.some((s) => s.index > domainEvent.index);
+    if (!hasSubsequentSme) {
+      observations.push({
+        phase,
+        timestamp,
+        type: "missing_sme",
+        severity: "info",
+        description: `Domains detected in phase ${phase} but no SME consultation found`
+      });
+    }
+  }
+  return observations;
+}
+async function runCuratorInit(directory, config3) {
+  try {
+    const priorSummary = await readCuratorSummary(directory);
+    const knowledgePath = resolveSwarmKnowledgePath(directory);
+    const allEntries = await readKnowledge(knowledgePath);
+    const highConfidenceEntries = allEntries.filter((e) => typeof e.confidence === "number" && e.confidence >= config3.min_knowledge_confidence);
+    const contextMd = await readSwarmFileAsync(directory, "context.md");
+    const briefingParts = [];
+    if (priorSummary) {
+      briefingParts.push(`## Prior Session Summary (Phase ${priorSummary.last_phase_covered})`);
+      briefingParts.push(priorSummary.digest);
+      if (priorSummary.compliance_observations.length > 0 && !config3.suppress_warnings) {
+        briefingParts.push(`
+## Compliance Observations`);
+        for (const obs of priorSummary.compliance_observations) {
+          briefingParts.push(`- [${obs.severity.toUpperCase()}] Phase ${obs.phase}: ${obs.description}`);
+        }
+      }
+      if (priorSummary.knowledge_recommendations.length > 0) {
+        briefingParts.push(`
+## Knowledge Recommendations`);
+        for (const rec of priorSummary.knowledge_recommendations) {
+          briefingParts.push(`- ${rec.action}: ${rec.lesson} (${rec.reason})`);
+        }
+      }
+    } else {
+      briefingParts.push("## First Session \u2014 No Prior Summary");
+      briefingParts.push("This is the first curator run for this project. No prior phase data available.");
+    }
+    if (highConfidenceEntries.length > 0) {
+      briefingParts.push(`
+## High-Confidence Knowledge`);
+      for (const entry of highConfidenceEntries.slice(0, 10)) {
+        const lesson = typeof entry.lesson === "string" ? entry.lesson : JSON.stringify(entry.lesson);
+        briefingParts.push(`- ${lesson}`);
+      }
+    }
+    if (contextMd) {
+      briefingParts.push(`
+## Context Summary`);
+      const maxContextChars = config3.max_summary_tokens * 2;
+      briefingParts.push(contextMd.slice(0, maxContextChars));
+    }
+    const contradictions = allEntries.filter((e) => Array.isArray(e.tags) && e.tags.some((t) => t.includes("contradiction"))).map((e) => typeof e.lesson === "string" ? e.lesson : JSON.stringify(e.lesson));
+    const result = {
+      briefing: briefingParts.join(`
+`),
+      contradictions,
+      knowledge_entries_reviewed: allEntries.length,
+      prior_phases_covered: priorSummary ? priorSummary.last_phase_covered : 0
+    };
+    getGlobalEventBus().publish("curator.init.completed", {
+      prior_phases_covered: result.prior_phases_covered,
+      knowledge_entries_reviewed: result.knowledge_entries_reviewed,
+      contradictions_found: contradictions.length
+    });
+    return result;
+  } catch (err2) {
+    getGlobalEventBus().publish("curator.error", {
+      operation: "init",
+      error: String(err2)
+    });
+    return {
+      briefing: `## Curator Init Failed
+Could not load prior session context.`,
+      contradictions: [],
+      knowledge_entries_reviewed: 0,
+      prior_phases_covered: 0
+    };
+  }
+}
+async function runCuratorPhase(directory, phase, agentsDispatched, _config, _knowledgeConfig) {
+  try {
+    const priorSummary = await readCuratorSummary(directory);
+    const eventsJsonlContent = await readSwarmFileAsync(directory, "events.jsonl");
+    const phaseEvents = eventsJsonlContent ? filterPhaseEvents(eventsJsonlContent, phase) : [];
+    const contextMd = await readSwarmFileAsync(directory, "context.md");
+    const requiredAgents = ["reviewer", "test_engineer"];
+    const complianceObservations = checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, phase);
+    const tasksCompleted = phaseEvents.filter((e) => e.type === "task.completed").length;
+    const keyDecisions = [];
+    if (contextMd) {
+      const decisionSection = contextMd.match(/## Decisions\r?\n([\s\S]*?)(?:\r?\n##|$)/);
+      if (decisionSection) {
+        const lines = decisionSection[1].split(`
+`);
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed.startsWith("- ")) {
+            keyDecisions.push(trimmed.slice(2));
+          }
+        }
+      }
+    }
+    const phaseDigest = {
+      phase,
+      timestamp: new Date().toISOString(),
+      summary: `Phase ${phase} completed. ${tasksCompleted} tasks recorded. ${complianceObservations.length} compliance observations.`,
+      agents_used: [...new Set(agentsDispatched.map(normalizeAgentName))],
+      tasks_completed: tasksCompleted,
+      tasks_total: tasksCompleted,
+      key_decisions: keyDecisions.slice(0, 5),
+      blockers_resolved: []
+    };
+    const knowledgeRecommendations = [];
+    const sessionId = `session-${Date.now()}`;
+    const now = new Date().toISOString();
+    let updatedSummary;
+    if (priorSummary) {
+      updatedSummary = {
+        ...priorSummary,
+        last_updated: now,
+        last_phase_covered: Math.max(priorSummary.last_phase_covered, phase),
+        digest: priorSummary.digest + `
+
+### Phase ${phase}
+${phaseDigest.summary}`,
+        phase_digests: [...priorSummary.phase_digests, phaseDigest],
+        compliance_observations: [
+          ...priorSummary.compliance_observations,
+          ...complianceObservations
+        ],
+        knowledge_recommendations: knowledgeRecommendations
+      };
+    } else {
+      updatedSummary = {
+        schema_version: 1,
+        session_id: sessionId,
+        last_updated: now,
+        last_phase_covered: phase,
+        digest: `### Phase ${phase}
+${phaseDigest.summary}`,
+        phase_digests: [phaseDigest],
+        compliance_observations: complianceObservations,
+        knowledge_recommendations: knowledgeRecommendations
+      };
+    }
+    await writeCuratorSummary(directory, updatedSummary);
+    const eventsPath = path26.join(directory, ".swarm", "events.jsonl");
+    for (const obs of complianceObservations) {
+      await appendKnowledge(eventsPath, {
+        type: "curator_compliance",
+        timestamp: obs.timestamp,
+        phase: obs.phase,
+        observation_type: obs.type,
+        severity: obs.severity,
+        description: obs.description
+      });
+    }
+    const result = {
+      phase,
+      digest: phaseDigest,
+      compliance: complianceObservations,
+      knowledge_recommendations: knowledgeRecommendations,
+      summary_updated: true
+    };
+    getGlobalEventBus().publish("curator.phase.completed", {
+      phase,
+      compliance_count: complianceObservations.length,
+      summary_updated: true
+    });
+    return result;
+  } catch (err2) {
+    getGlobalEventBus().publish("curator.error", {
+      operation: "phase",
+      phase,
+      error: String(err2)
+    });
+    return {
+      phase,
+      digest: {
+        phase,
+        timestamp: new Date().toISOString(),
+        summary: `Phase ${phase} curator run failed: ${String(err2)}`,
+        agents_used: [],
+        tasks_completed: 0,
+        tasks_total: 0,
+        key_decisions: [],
+        blockers_resolved: []
+      },
+      compliance: [],
+      knowledge_recommendations: [],
+      summary_updated: false
+    };
+  }
+}
+async function applyCuratorKnowledgeUpdates(directory, recommendations, _knowledgeConfig) {
+  let applied = 0;
+  let skipped = 0;
+  if (recommendations.length === 0) {
+    return { applied, skipped };
+  }
+  const knowledgePath = resolveSwarmKnowledgePath(directory);
+  const entries = await readKnowledge(knowledgePath);
+  let modified = false;
+  const appliedIds = new Set;
+  const updatedEntries = entries.map((entry) => {
+    const rec = recommendations.find((r) => r.entry_id === entry.id);
+    if (!rec)
+      return entry;
+    switch (rec.action) {
+      case "promote":
+        appliedIds.add(entry.id);
+        applied++;
+        modified = true;
+        return {
+          ...entry,
+          hive_eligible: true,
+          confidence: Math.min(1, (entry.confidence ?? 0) + 0.1),
+          updated_at: new Date().toISOString()
+        };
+      case "archive":
+        appliedIds.add(entry.id);
+        applied++;
+        modified = true;
+        return {
+          ...entry,
+          status: "archived",
+          updated_at: new Date().toISOString()
+        };
+      case "flag_contradiction":
+        appliedIds.add(entry.id);
+        applied++;
+        modified = true;
+        return {
+          ...entry,
+          tags: [
+            ...entry.tags ?? [],
+            `contradiction:${(rec.reason ?? "").slice(0, 50)}`
+          ],
+          updated_at: new Date().toISOString()
+        };
+      default:
+        return entry;
+    }
+  });
+  for (const rec of recommendations) {
+    if (rec.entry_id !== undefined && !appliedIds.has(rec.entry_id)) {
+      const found = entries.some((e) => e.id === rec.entry_id);
+      if (!found) {
+        console.warn(`[curator] applyCuratorKnowledgeUpdates: entry_id '${rec.entry_id}' not found \u2014 skipping`);
+      }
+      skipped++;
+    }
+  }
+  if (modified) {
+    await rewriteKnowledge(knowledgePath, updatedEntries);
+  }
+  return { applied, skipped };
+}
+
+// src/hooks/phase-monitor.ts
 init_utils2();
 function createPhaseMonitorHook(directory, preflightManager) {
   let lastKnownPhase = null;
@@ -48332,6 +48754,12 @@ function createPhaseMonitorHook(directory, preflightManager) {
     const currentPhase = plan.current_phase ?? 1;
     if (lastKnownPhase === null) {
       lastKnownPhase = currentPhase;
+      try {
+        const curatorConfig = CuratorConfigSchema.parse({});
+        if (curatorConfig.enabled && curatorConfig.init_enabled) {
+          await runCuratorInit(directory, curatorConfig);
+        }
+      } catch {}
       return;
     }
     if (currentPhase !== lastKnownPhase) {
@@ -48432,7 +48860,7 @@ ${originalText}`;
   };
 }
 // src/hooks/system-enhancer.ts
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 init_manager();
 init_detector();
 init_manager2();
@@ -48440,8 +48868,8 @@ init_manager2();
 // src/services/decision-drift-analyzer.ts
 init_utils2();
 init_manager2();
-import * as fs14 from "fs";
-import * as path26 from "path";
+import * as fs15 from "fs";
+import * as path27 from "path";
 var DEFAULT_DRIFT_CONFIG = {
   staleThresholdPhases: 1,
   detectContradictions: true,
@@ -48595,11 +49023,11 @@ async function analyzeDecisionDrift(directory, config3 = {}) {
         currentPhase = legacyPhase;
       }
     }
-    const contextPath = path26.join(directory, ".swarm", "context.md");
+    const contextPath = path27.join(directory, ".swarm", "context.md");
     let contextContent = "";
     try {
-      if (fs14.existsSync(contextPath)) {
-        contextContent = fs14.readFileSync(contextPath, "utf-8");
+      if (fs15.existsSync(contextPath)) {
+        contextContent = fs15.readFileSync(contextPath, "utf-8");
       }
     } catch {
       return {
@@ -49064,7 +49492,7 @@ ${top5.map((d) => `- [${d.category}] ${d.directive}`).join(`
             continue;
           const ts = retro.timestamp ?? b.bundle.created_at;
           const ageMs = now - new Date(ts).getTime();
-          if (isNaN(ageMs) || ageMs > cutoffMs)
+          if (Number.isNaN(ageMs) || ageMs > cutoffMs)
             continue;
           allRetros.push({ entry: retro, timestamp: ts });
         }
@@ -49076,11 +49504,11 @@ ${top5.map((d) => `- [${d.category}] ${d.directive}`).join(`
     allRetros.sort((a, b) => {
       const ta = new Date(a.timestamp).getTime();
       const tb = new Date(b.timestamp).getTime();
-      if (isNaN(ta) && isNaN(tb))
+      if (Number.isNaN(ta) && Number.isNaN(tb))
         return 0;
-      if (isNaN(ta))
+      if (Number.isNaN(ta))
         return 1;
-      if (isNaN(tb))
+      if (Number.isNaN(tb))
         return -1;
       return tb - ta;
     });
@@ -49125,7 +49553,7 @@ async function buildCoderRetroInjection(directory, currentPhaseNumber) {
     if (!retroEntry || retroEntry.verdict === "fail")
       return null;
     const lessons = retroEntry.lessons_learned ?? [];
-    const summaryLine = `[SWARM RETROSPECTIVE] From Phase ${prevPhase}:${retroEntry.summary ? " " + retroEntry.summary : ""}`;
+    const summaryLine = `[SWARM RETROSPECTIVE] From Phase ${prevPhase}:${retroEntry.summary ? ` ${retroEntry.summary}` : ""}`;
     const allLines = [summaryLine, ...lessons];
     const text = allLines.join(`
 `);
@@ -49242,11 +49670,11 @@ function createSystemEnhancerHook(config3, directory) {
               if (handoffContent) {
                 const handoffPath = validateSwarmPath(directory, "handoff.md");
                 const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-                if (fs15.existsSync(consumedPath)) {
+                if (fs16.existsSync(consumedPath)) {
                   warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                  fs15.unlinkSync(consumedPath);
+                  fs16.unlinkSync(consumedPath);
                 }
-                fs15.renameSync(handoffPath, consumedPath);
+                fs16.renameSync(handoffPath, consumedPath);
                 const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -49522,11 +49950,11 @@ ${budgetWarning}`);
             if (handoffContent) {
               const handoffPath = validateSwarmPath(directory, "handoff.md");
               const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-              if (fs15.existsSync(consumedPath)) {
+              if (fs16.existsSync(consumedPath)) {
                 warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                fs15.unlinkSync(consumedPath);
+                fs16.unlinkSync(consumedPath);
               }
-              fs15.renameSync(handoffPath, consumedPath);
+              fs16.renameSync(handoffPath, consumedPath);
               const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -50204,7 +50632,7 @@ function createDarkMatterDetectorHook(directory) {
 // src/hooks/knowledge-reader.ts
 import { existsSync as existsSync18 } from "fs";
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import * as path27 from "path";
+import * as path28 from "path";
 var JACCARD_THRESHOLD = 0.6;
 var HIVE_TIER_BOOST = 0.05;
 var SAME_PROJECT_PENALTY = -0.05;
@@ -50252,7 +50680,7 @@ function inferCategoriesFromPhase(phaseDescription) {
   return ["process", "tooling"];
 }
 async function recordLessonsShown(directory, lessonIds, currentPhase) {
-  const shownFile = path27.join(directory, ".swarm", ".knowledge-shown.json");
+  const shownFile = path28.join(directory, ".swarm", ".knowledge-shown.json");
   try {
     let shownData = {};
     if (existsSync18(shownFile)) {
@@ -50260,7 +50688,7 @@ async function recordLessonsShown(directory, lessonIds, currentPhase) {
       shownData = JSON.parse(content);
     }
     shownData[currentPhase] = lessonIds;
-    await mkdir4(path27.dirname(shownFile), { recursive: true });
+    await mkdir4(path28.dirname(shownFile), { recursive: true });
     await writeFile4(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
   } catch {
     console.warn("[swarm] Knowledge: failed to record shown lessons");
@@ -50355,7 +50783,7 @@ async function readMergedKnowledge(directory, config3, context) {
   return topN;
 }
 async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
-  const shownFile = path27.join(directory, ".swarm", ".knowledge-shown.json");
+  const shownFile = path28.join(directory, ".swarm", ".knowledge-shown.json");
   try {
     if (!existsSync18(shownFile)) {
       return;
@@ -50823,6 +51251,160 @@ Use this data to avoid repeating known failure patterns.`;
   return prefix + summaryText + suffix;
 }
 
+// src/hooks/curator-drift.ts
+init_event_bus();
+init_utils2();
+import * as fs17 from "fs";
+import * as path29 from "path";
+var DRIFT_REPORT_PREFIX = "drift-report-phase-";
+async function readPriorDriftReports(directory) {
+  const swarmDir = path29.join(directory, ".swarm");
+  const entries = await fs17.promises.readdir(swarmDir).catch(() => null);
+  if (entries === null)
+    return [];
+  const reportFiles = entries.filter((name2) => name2.startsWith(DRIFT_REPORT_PREFIX) && name2.endsWith(".json")).sort();
+  const reports = [];
+  for (const filename of reportFiles) {
+    const content = await readSwarmFileAsync(directory, filename);
+    if (content === null)
+      continue;
+    try {
+      const report = JSON.parse(content);
+      if (typeof report.phase !== "number" || typeof report.alignment !== "string") {
+        console.warn(`[curator-drift] Skipping corrupt drift report: ${filename}`);
+        continue;
+      }
+      reports.push(report);
+    } catch {
+      console.warn(`[curator-drift] Skipping unreadable drift report: ${filename}`);
+    }
+  }
+  reports.sort((a, b) => a.phase - b.phase);
+  return reports;
+}
+async function writeDriftReport(directory, report) {
+  const filename = `${DRIFT_REPORT_PREFIX}${report.phase}.json`;
+  const filePath = validateSwarmPath(directory, filename);
+  const swarmDir = path29.dirname(filePath);
+  await fs17.promises.mkdir(swarmDir, { recursive: true });
+  try {
+    await fs17.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
+  } catch (err2) {
+    throw new Error(`[curator-drift] Failed to write drift report to ${filePath}: ${String(err2)}`);
+  }
+  return filePath;
+}
+async function runCriticDriftCheck(directory, phase, curatorResult, config3) {
+  try {
+    const planMd = await readSwarmFileAsync(directory, "plan.md");
+    const specMd = await readSwarmFileAsync(directory, "spec.md");
+    const priorReports = await readPriorDriftReports(directory);
+    const complianceCount = curatorResult.compliance.length;
+    const warningCompliance = curatorResult.compliance.filter((obs) => obs.severity === "warning");
+    let alignment = "ALIGNED";
+    let driftScore = 0;
+    if (!planMd) {
+      alignment = "MINOR_DRIFT";
+      driftScore = 0.3;
+    } else if (warningCompliance.length >= 3) {
+      alignment = "MAJOR_DRIFT";
+      driftScore = Math.min(0.9, 0.5 + warningCompliance.length * 0.1);
+    } else if (warningCompliance.length >= 1 || complianceCount >= 3) {
+      alignment = "MINOR_DRIFT";
+      driftScore = Math.min(0.49, 0.2 + complianceCount * 0.05);
+    }
+    const priorSummaries = priorReports.map((r) => r.injection_summary).filter(Boolean);
+    const keyCorrections = warningCompliance.map((obs) => obs.description);
+    const firstDeviation = warningCompliance.length > 0 ? {
+      phase,
+      task: "unknown",
+      description: warningCompliance[0]?.description ?? ""
+    } : null;
+    const payloadLines = [
+      `CURATOR_DIGEST: ${JSON.stringify(curatorResult.digest)}`,
+      `CURATOR_COMPLIANCE: ${JSON.stringify(curatorResult.compliance)}`,
+      `PLAN: ${planMd ?? "none"}`,
+      `SPEC: ${specMd ?? "none"}`,
+      `PRIOR_DRIFT_REPORTS: ${JSON.stringify(priorSummaries)}`
+    ];
+    const payload = payloadLines.join(`
+`);
+    const requirementsChecked = curatorResult.digest.tasks_total;
+    const requirementsSatisfied = curatorResult.digest.tasks_completed;
+    const injectionSummaryRaw = `Phase ${phase}: ${alignment} (${driftScore.toFixed(2)}) \u2014 ${firstDeviation ? firstDeviation.description : "all requirements on track"}.${keyCorrections.length > 0 ? `Correction: ${keyCorrections[0] ?? ""}.` : ""}`;
+    const injectionSummary = injectionSummaryRaw.slice(0, config3.drift_inject_max_chars);
+    const report = {
+      schema_version: 1,
+      phase,
+      timestamp: new Date().toISOString(),
+      alignment,
+      drift_score: driftScore,
+      first_deviation: firstDeviation,
+      compounding_effects: priorReports.filter((r) => r.alignment !== "ALIGNED").map((r) => `Phase ${r.phase}: ${r.alignment}`).slice(0, 5),
+      corrections: keyCorrections.slice(0, 5),
+      requirements_checked: requirementsChecked,
+      requirements_satisfied: requirementsSatisfied,
+      scope_additions: [],
+      injection_summary: injectionSummary
+    };
+    const reportPath = await writeDriftReport(directory, report);
+    getGlobalEventBus().publish("curator.drift.completed", {
+      phase,
+      alignment,
+      drift_score: driftScore,
+      report_path: reportPath
+    });
+    const injectionText = injectionSummary;
+    return {
+      phase,
+      report,
+      report_path: reportPath,
+      injection_text: injectionText
+    };
+  } catch (err2) {
+    getGlobalEventBus().publish("curator.error", {
+      operation: "drift",
+      phase,
+      error: String(err2)
+    });
+    const defaultReport = {
+      schema_version: 1,
+      phase,
+      timestamp: new Date().toISOString(),
+      alignment: "ALIGNED",
+      drift_score: 0,
+      first_deviation: null,
+      compounding_effects: [],
+      corrections: [],
+      requirements_checked: 0,
+      requirements_satisfied: 0,
+      scope_additions: [],
+      injection_summary: `Phase ${phase}: drift analysis unavailable (${String(err2)})`
+    };
+    return {
+      phase,
+      report: defaultReport,
+      report_path: "",
+      injection_text: ""
+    };
+  }
+}
+function buildDriftInjectionText(report, maxChars) {
+  if (maxChars <= 0) {
+    return "";
+  }
+  let text;
+  if (report.alignment === "ALIGNED" && report.drift_score < 0.1) {
+    text = `<drift_report>Phase ${report.phase}: ALIGNED, all requirements on track.</drift_report>`;
+  } else {
+    const keyFinding = report.first_deviation?.description ?? "no deviation recorded";
+    const score = report.drift_score ?? 0;
+    const correctionClause = report.corrections?.[0] ? `Correction: ${report.corrections[0]}.` : "";
+    text = `<drift_report>Phase ${report.phase}: ${report.alignment} (${score.toFixed(2)}) \u2014 ${keyFinding}. ${correctionClause}</drift_report>`;
+  }
+  return text.slice(0, maxChars);
+}
+
 // src/hooks/knowledge-injector.ts
 init_utils2();
 function formatStars(confidence) {
@@ -50924,9 +51506,9 @@ function createKnowledgeInjectorHook(directory, config3) {
     ].join(`
 `);
     if (runMemory) {
-      cachedInjectionText = runMemory + `
+      cachedInjectionText = `${runMemory}
 
-` + knowledgeSection;
+${knowledgeSection}`;
     } else {
       cachedInjectionText = knowledgeSection;
     }
@@ -50940,13 +51522,25 @@ function createKnowledgeInjectorHook(directory, config3) {
 ` + rejectedLines.join(`
 `);
     }
+    try {
+      const driftReports = await readPriorDriftReports(directory);
+      if (driftReports.length > 0 && cachedInjectionText !== null) {
+        const latestReport = driftReports[driftReports.length - 1];
+        const driftText = buildDriftInjectionText(latestReport, 500);
+        if (driftText) {
+          cachedInjectionText = `${driftText}
+
+${cachedInjectionText}`;
+        }
+      }
+    } catch {}
     injectKnowledgeMessage(output, cachedInjectionText);
   });
 }
 
 // src/hooks/steering-consumed.ts
 init_utils2();
-import * as fs16 from "fs";
+import * as fs18 from "fs";
 function recordSteeringConsumed(directory, directiveId) {
   try {
     const eventsPath = validateSwarmPath(directory, "events.jsonl");
@@ -50955,7 +51549,7 @@ function recordSteeringConsumed(directory, directiveId) {
       directiveId,
       timestamp: new Date().toISOString()
     };
-    fs16.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs18.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch {}
 }
@@ -51000,6 +51594,27 @@ init_config_doctor();
 
 // src/session/snapshot-reader.ts
 init_utils2();
+import path30 from "path";
+var VALID_TASK_WORKFLOW_STATES = [
+  "idle",
+  "coder_delegated",
+  "pre_check_passed",
+  "reviewer_run",
+  "tests_run",
+  "complete"
+];
+function deserializeTaskWorkflowStates(raw) {
+  const m = new Map;
+  if (!raw || typeof raw !== "object") {
+    return m;
+  }
+  for (const [taskId, stateVal] of Object.entries(raw)) {
+    if (VALID_TASK_WORKFLOW_STATES.includes(stateVal)) {
+      m.set(taskId, stateVal);
+    }
+  }
+  return m;
+}
 function deserializeAgentSession(s) {
   const gateLog = new Map;
   if (s.gateLog) {
@@ -51042,7 +51657,7 @@ function deserializeAgentSession(s) {
     phaseAgentsDispatched,
     qaSkipCount: s.qaSkipCount ?? 0,
     qaSkipTaskIds: s.qaSkipTaskIds ?? [],
-    taskWorkflowStates: new Map,
+    taskWorkflowStates: deserializeTaskWorkflowStates(s.taskWorkflowStates),
     lastGateOutcome: null,
     declaredCoderScope: null,
     lastScopeViolation: null,
@@ -51096,11 +51711,53 @@ function rehydrateState(snapshot) {
     }
   }
 }
+async function reconcileTaskStatesFromPlan(directory) {
+  let raw;
+  try {
+    raw = await Bun.file(path30.join(directory, ".swarm/plan.json")).text();
+  } catch {
+    return;
+  }
+  let plan;
+  try {
+    plan = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (!plan?.phases || !Array.isArray(plan.phases)) {
+    return;
+  }
+  for (const phase of plan.phases) {
+    if (!phase?.tasks || !Array.isArray(phase.tasks)) {
+      continue;
+    }
+    for (const task of phase.tasks) {
+      if (!task?.id || typeof task.id !== "string") {
+        continue;
+      }
+      const taskId = task.id;
+      const planStatus = task.status;
+      for (const session of swarmState.agentSessions.values()) {
+        const currentState = getTaskState(session, taskId);
+        if (planStatus === "completed" && currentState !== "tests_run" && currentState !== "complete") {
+          try {
+            advanceTaskState(session, taskId, "tests_run");
+          } catch {}
+        } else if (planStatus === "in_progress" && currentState === "idle") {
+          try {
+            advanceTaskState(session, taskId, "coder_delegated");
+          } catch {}
+        }
+      }
+    }
+  }
+}
 async function loadSnapshot(directory) {
   try {
     const snapshot = await readSnapshot(directory);
     if (snapshot !== null) {
       rehydrateState(snapshot);
+      await reconcileTaskStatesFromPlan(directory);
     }
   } catch {}
 }
@@ -51280,8 +51937,8 @@ var build_check = createSwarmTool({
 init_tool();
 init_create_tool();
 import { spawnSync } from "child_process";
-import * as fs17 from "fs";
-import * as path28 from "path";
+import * as fs19 from "fs";
+import * as path31 from "path";
 var CHECKPOINT_LOG_PATH = ".swarm/checkpoints.json";
 var MAX_LABEL_LENGTH = 100;
 var GIT_TIMEOUT_MS = 30000;
@@ -51332,13 +51989,13 @@ function validateLabel(label) {
   return null;
 }
 function getCheckpointLogPath(directory) {
-  return path28.join(directory, CHECKPOINT_LOG_PATH);
+  return path31.join(directory, CHECKPOINT_LOG_PATH);
 }
 function readCheckpointLog(directory) {
   const logPath = getCheckpointLogPath(directory);
   try {
-    if (fs17.existsSync(logPath)) {
-      const content = fs17.readFileSync(logPath, "utf-8");
+    if (fs19.existsSync(logPath)) {
+      const content = fs19.readFileSync(logPath, "utf-8");
       const parsed = JSON.parse(content);
       if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
         return { version: 1, checkpoints: [] };
@@ -51350,13 +52007,13 @@ function readCheckpointLog(directory) {
 }
 function writeCheckpointLog(log2, directory) {
   const logPath = getCheckpointLogPath(directory);
-  const dir = path28.dirname(logPath);
-  if (!fs17.existsSync(dir)) {
-    fs17.mkdirSync(dir, { recursive: true });
+  const dir = path31.dirname(logPath);
+  if (!fs19.existsSync(dir)) {
+    fs19.mkdirSync(dir, { recursive: true });
   }
   const tempPath = `${logPath}.tmp`;
-  fs17.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
-  fs17.renameSync(tempPath, logPath);
+  fs19.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
+  fs19.renameSync(tempPath, logPath);
 }
 function gitExec(args2) {
   const result = spawnSync("git", args2, {
@@ -51557,8 +52214,8 @@ var checkpoint = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_dist();
 init_create_tool();
-import * as fs18 from "fs";
-import * as path29 from "path";
+import * as fs20 from "fs";
+import * as path32 from "path";
 var MAX_FILE_SIZE_BYTES2 = 256 * 1024;
 var DEFAULT_DAYS = 90;
 var DEFAULT_TOP_N = 20;
@@ -51687,11 +52344,11 @@ function estimateComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat2 = fs18.statSync(filePath);
+    const stat2 = fs20.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES2) {
       return null;
     }
-    const content = fs18.readFileSync(filePath, "utf-8");
+    const content = fs20.readFileSync(filePath, "utf-8");
     return estimateComplexity(content);
   } catch {
     return null;
@@ -51702,7 +52359,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 = path29.extname(file3).toLowerCase();
+    const ext = path32.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -51712,8 +52369,8 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs18.existsSync(fullPath)) {
-      fullPath = path29.join(cwd, file3);
+    if (!fs20.existsSync(fullPath)) {
+      fullPath = path32.join(cwd, file3);
     }
     const complexity = getComplexityForFile(fullPath);
     if (complexity !== null) {
@@ -51860,8 +52517,8 @@ var complexity_hotspots = createSwarmTool({
 });
 // src/tools/declare-scope.ts
 init_tool();
-import * as fs19 from "fs";
-import * as path30 from "path";
+import * as fs21 from "fs";
+import * as path33 from "path";
 init_create_tool();
 function validateTaskIdFormat(taskId) {
   const taskIdPattern = /^\d+\.\d+(\.\d+)*$/;
@@ -51940,8 +52597,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path30.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path30.sep);
+    normalizedDir = path33.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path33.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -51951,11 +52608,11 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path30.resolve(normalizedDir);
+    const resolvedDir = path33.resolve(normalizedDir);
     try {
-      const realPath = fs19.realpathSync(resolvedDir);
-      const planPath2 = path30.join(realPath, ".swarm", "plan.json");
-      if (!fs19.existsSync(planPath2)) {
+      const realPath = fs21.realpathSync(resolvedDir);
+      const planPath2 = path33.join(realPath, ".swarm", "plan.json");
+      if (!fs21.existsSync(planPath2)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -51975,8 +52632,8 @@ async function executeDeclareScope(args2, fallbackDir) {
     }
   }
   const directory = normalizedDir ?? fallbackDir ?? process.cwd();
-  const planPath = path30.resolve(directory, ".swarm", "plan.json");
-  if (!fs19.existsSync(planPath)) {
+  const planPath = path33.resolve(directory, ".swarm", "plan.json");
+  if (!fs21.existsSync(planPath)) {
     return {
       success: false,
       message: "No plan found",
@@ -51985,7 +52642,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   let planContent;
   try {
-    planContent = JSON.parse(fs19.readFileSync(planPath, "utf-8"));
+    planContent = JSON.parse(fs21.readFileSync(planPath, "utf-8"));
   } catch {
     return {
       success: false,
@@ -52065,20 +52722,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path31 of paths) {
-    if (!path31 || path31.length === 0) {
+  for (const path34 of paths) {
+    if (!path34 || path34.length === 0) {
       return "empty path not allowed";
     }
-    if (path31.length > MAX_PATH_LENGTH) {
+    if (path34.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path31)) {
+    if (SHELL_METACHARACTERS2.test(path34)) {
       return "path contains shell metacharacters";
     }
-    if (path31.startsWith("-")) {
+    if (path34.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path31)) {
+    if (CONTROL_CHAR_PATTERN2.test(path34)) {
       return "path contains control characters";
     }
   }
@@ -52158,8 +52815,8 @@ var diff = tool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path31 = parts2[2];
-          files.push({ path: path31, additions, deletions });
+          const path34 = parts2[2];
+          files.push({ path: path34, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -52388,8 +53045,8 @@ Use these as DOMAIN values when delegating to @sme.`;
 // src/tools/evidence-check.ts
 init_dist();
 init_create_tool();
-import * as fs20 from "fs";
-import * as path31 from "path";
+import * as fs22 from "fs";
+import * as path34 from "path";
 var MAX_FILE_SIZE_BYTES3 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR = ".swarm/evidence";
@@ -52412,9 +53069,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm(filePath, cwd) {
-  const normalizedCwd = path31.resolve(cwd);
-  const swarmPath = path31.join(normalizedCwd, ".swarm");
-  const normalizedPath = path31.resolve(filePath);
+  const normalizedCwd = path34.resolve(cwd);
+  const swarmPath = path34.join(normalizedCwd, ".swarm");
+  const normalizedPath = path34.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -52430,12 +53087,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs20.existsSync(evidenceDir) || !fs20.statSync(evidenceDir).isDirectory()) {
+  if (!fs22.existsSync(evidenceDir) || !fs22.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs20.readdirSync(evidenceDir);
+    files = fs22.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -52444,14 +53101,14 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path31.join(evidenceDir, filename);
+    const filePath = path34.join(evidenceDir, filename);
     try {
-      const resolvedPath = path31.resolve(filePath);
-      const evidenceDirResolved = path31.resolve(evidenceDir);
+      const resolvedPath = path34.resolve(filePath);
+      const evidenceDirResolved = path34.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat2 = fs20.lstatSync(filePath);
+      const stat2 = fs22.lstatSync(filePath);
       if (!stat2.isFile()) {
         continue;
       }
@@ -52460,7 +53117,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs20.statSync(filePath);
+      fileStat = fs22.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES3) {
         continue;
       }
@@ -52469,7 +53126,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs20.readFileSync(filePath, "utf-8");
+      content = fs22.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -52554,7 +53211,7 @@ var evidence_check = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
-    const planPath = path31.join(cwd, PLAN_FILE);
+    const planPath = path34.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -52568,7 +53225,7 @@ var evidence_check = createSwarmTool({
     }
     let planContent;
     try {
-      planContent = fs20.readFileSync(planPath, "utf-8");
+      planContent = fs22.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -52586,7 +53243,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path31.join(cwd, EVIDENCE_DIR);
+    const evidenceDir = path34.join(cwd, EVIDENCE_DIR);
     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;
@@ -52603,8 +53260,8 @@ var evidence_check = createSwarmTool({
 // src/tools/file-extractor.ts
 init_tool();
 init_create_tool();
-import * as fs21 from "fs";
-import * as path32 from "path";
+import * as fs23 from "fs";
+import * as path35 from "path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -52666,8 +53323,8 @@ var extract_code_blocks = createSwarmTool({
   execute: async (args2, directory) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || directory;
-    if (!fs21.existsSync(targetDir)) {
-      fs21.mkdirSync(targetDir, { recursive: true });
+    if (!fs23.existsSync(targetDir)) {
+      fs23.mkdirSync(targetDir, { recursive: true });
     }
     if (!content) {
       return "Error: content is required";
@@ -52685,16 +53342,16 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path32.join(targetDir, filename);
-      const base = path32.basename(filepath, path32.extname(filepath));
-      const ext = path32.extname(filepath);
+      let filepath = path35.join(targetDir, filename);
+      const base = path35.basename(filepath, path35.extname(filepath));
+      const ext = path35.extname(filepath);
       let counter = 1;
-      while (fs21.existsSync(filepath)) {
-        filepath = path32.join(targetDir, `${base}_${counter}${ext}`);
+      while (fs23.existsSync(filepath)) {
+        filepath = path35.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs21.writeFileSync(filepath, code.trim(), "utf-8");
+        fs23.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -52802,8 +53459,8 @@ var gitingest = tool({
 });
 // src/tools/imports.ts
 init_dist();
-import * as fs22 from "fs";
-import * as path33 from "path";
+import * as fs24 from "fs";
+import * as path36 from "path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES4 = 1024 * 1024;
@@ -52857,7 +53514,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path33.extname(filePath).toLowerCase();
+  const ext = path36.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -52881,15 +53538,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path33.resolve(targetFile);
+    _resolvedTarget = path36.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path33.basename(targetFile, path33.extname(targetFile));
+  const targetBasename = path36.basename(targetFile, path36.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path33.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path33.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path36.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path36.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];
@@ -52912,9 +53569,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path33.dirname(targetFile);
-    const targetExt = path33.extname(targetFile);
-    const targetBasenameNoExt = path33.basename(targetFile, targetExt);
+    const _targetDir = path36.dirname(targetFile);
+    const targetExt = path36.extname(targetFile);
+    const targetBasenameNoExt = path36.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, "");
@@ -52971,7 +53628,7 @@ var SKIP_DIRECTORIES2 = new Set([
 function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs22.readdirSync(dir);
+    entries = fs24.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -52982,13 +53639,13 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
     if (SKIP_DIRECTORIES2.has(entry)) {
-      stats.skippedDirs.push(path33.join(dir, entry));
+      stats.skippedDirs.push(path36.join(dir, entry));
       continue;
     }
-    const fullPath = path33.join(dir, entry);
+    const fullPath = path36.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs22.statSync(fullPath);
+      stat2 = fs24.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -52999,7 +53656,7 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
     if (stat2.isDirectory()) {
       findSourceFiles2(fullPath, files, stats);
     } else if (stat2.isFile()) {
-      const ext = path33.extname(fullPath).toLowerCase();
+      const ext = path36.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -53055,8 +53712,8 @@ var imports = tool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path33.resolve(file3);
-      if (!fs22.existsSync(targetFile)) {
+      const targetFile = path36.resolve(file3);
+      if (!fs24.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -53066,7 +53723,7 @@ var imports = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs22.statSync(targetFile);
+      const targetStat = fs24.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -53077,7 +53734,7 @@ var imports = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path33.dirname(targetFile);
+      const baseDir = path36.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -53092,12 +53749,12 @@ var imports = tool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat2 = fs22.statSync(filePath);
+          const stat2 = fs24.statSync(filePath);
           if (stat2.size > MAX_FILE_SIZE_BYTES4) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs22.readFileSync(filePath);
+          const buffer = fs24.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -53166,8 +53823,8 @@ init_lint();
 
 // src/tools/phase-complete.ts
 init_dist();
-import * as fs23 from "fs";
-import * as path34 from "path";
+import * as fs25 from "fs";
+import * as path37 from "path";
 init_manager();
 init_utils2();
 init_create_tool();
@@ -53357,7 +54014,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path34.basename(dir);
+      const projectName = path37.basename(dir);
       const knowledgeConfig = {
         enabled: true,
         swarm_max_entries: 100,
@@ -53380,6 +54037,16 @@ async function executePhaseComplete(args2, workingDirectory) {
       console.warn("[phase_complete] Failed to curate lessons from retrospective:", error93);
     }
   }
+  try {
+    const curatorConfig = CuratorConfigSchema.parse(config3.curator ?? {});
+    if (curatorConfig.enabled && curatorConfig.phase_enabled) {
+      const curatorResult = await runCuratorPhase(dir, phase, agentsDispatched, curatorConfig, {});
+      await applyCuratorKnowledgeUpdates(dir, curatorResult.knowledge_recommendations, {});
+      await runCriticDriftCheck(dir, phase, curatorResult, curatorConfig);
+    }
+  } catch (curatorError) {
+    console.warn("[phase_complete] Curator pipeline error (non-blocking):", curatorError);
+  }
   const effectiveRequired = [...phaseCompleteConfig.required_agents];
   if (phaseCompleteConfig.require_docs && !effectiveRequired.includes("docs")) {
     effectiveRequired.push("docs");
@@ -53418,7 +54085,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   };
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs23.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs25.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch (writeError) {
     warnings.push(`Warning: failed to write phase complete event: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
@@ -53476,8 +54143,8 @@ init_dist();
 init_discovery();
 init_utils();
 init_create_tool();
-import * as fs24 from "fs";
-import * as path35 from "path";
+import * as fs26 from "fs";
+import * as path38 from "path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -53495,28 +54162,28 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs24.existsSync(path35.join(cwd, "package.json"))) {
+  if (fs26.existsSync(path38.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs24.existsSync(path35.join(cwd, "pyproject.toml")) || fs24.existsSync(path35.join(cwd, "requirements.txt"))) {
+  if (fs26.existsSync(path38.join(cwd, "pyproject.toml")) || fs26.existsSync(path38.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs24.existsSync(path35.join(cwd, "Cargo.toml"))) {
+  if (fs26.existsSync(path38.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs24.existsSync(path35.join(cwd, "go.mod"))) {
+  if (fs26.existsSync(path38.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs24.readdirSync(cwd);
+    const files = fs26.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs24.existsSync(path35.join(cwd, "Gemfile")) || fs24.existsSync(path35.join(cwd, "Gemfile.lock"))) {
+  if (fs26.existsSync(path38.join(cwd, "Gemfile")) || fs26.existsSync(path38.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs24.existsSync(path35.join(cwd, "pubspec.yaml"))) {
+  if (fs26.existsSync(path38.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
   return ecosystems;
@@ -54577,8 +55244,8 @@ var SUPPORTED_PARSER_EXTENSIONS = new Set([
 ]);
 // src/tools/pre-check-batch.ts
 init_dist();
-import * as fs27 from "fs";
-import * as path38 from "path";
+import * as fs29 from "fs";
+import * as path41 from "path";
 
 // node_modules/yocto-queue/index.js
 class Node2 {
@@ -54723,8 +55390,8 @@ function pLimit(concurrency) {
     },
     map: {
       async value(iterable, function_) {
-        const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-        return Promise.all(promises);
+        const promises2 = Array.from(iterable, (value, index) => this(function_, value, index));
+        return Promise.all(promises2);
       }
     }
   });
@@ -54745,8 +55412,8 @@ init_lint();
 init_manager();
 
 // src/quality/metrics.ts
-import * as fs25 from "fs";
-import * as path36 from "path";
+import * as fs27 from "fs";
+import * as path39 from "path";
 var MAX_FILE_SIZE_BYTES5 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -54784,11 +55451,11 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat2 = fs25.statSync(filePath);
+    const stat2 = fs27.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES5) {
       return null;
     }
-    const content = fs25.readFileSync(filePath, "utf-8");
+    const content = fs27.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -54798,8 +55465,8 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path36.isAbsolute(file3) ? file3 : path36.join(workingDir, file3);
-    if (!fs25.existsSync(fullPath)) {
+    const fullPath = path39.isAbsolute(file3) ? file3 : path39.join(workingDir, file3);
+    if (!fs27.existsSync(fullPath)) {
       continue;
     }
     const complexity = getComplexityForFile2(fullPath);
@@ -54920,8 +55587,8 @@ function countGoExports(content) {
 }
 function getExportCountForFile(filePath) {
   try {
-    const content = fs25.readFileSync(filePath, "utf-8");
-    const ext = path36.extname(filePath).toLowerCase();
+    const content = fs27.readFileSync(filePath, "utf-8");
+    const ext = path39.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -54947,8 +55614,8 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path36.isAbsolute(file3) ? file3 : path36.join(workingDir, file3);
-    if (!fs25.existsSync(fullPath)) {
+    const fullPath = path39.isAbsolute(file3) ? file3 : path39.join(workingDir, file3);
+    if (!fs27.existsSync(fullPath)) {
       continue;
     }
     const exports = getExportCountForFile(fullPath);
@@ -54981,16 +55648,16 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path36.isAbsolute(file3) ? file3 : path36.join(workingDir, file3);
-    if (!fs25.existsSync(fullPath)) {
+    const fullPath = path39.isAbsolute(file3) ? file3 : path39.join(workingDir, file3);
+    if (!fs27.existsSync(fullPath)) {
       continue;
     }
     try {
-      const stat2 = fs25.statSync(fullPath);
+      const stat2 = fs27.statSync(fullPath);
       if (stat2.size > MAX_FILE_SIZE_BYTES5) {
         continue;
       }
-      const content = fs25.readFileSync(fullPath, "utf-8");
+      const content = fs27.readFileSync(fullPath, "utf-8");
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length < MIN_DUPLICATION_LINES) {
@@ -55014,8 +55681,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename8 = path36.basename(filePath);
-  const _ext = path36.extname(filePath).toLowerCase();
+  const basename8 = path39.basename(filePath);
+  const _ext = path39.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -55096,8 +55763,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path37, glob) {
-  const normalizedPath = path37.replace(/\\/g, "/");
+function matchesGlobSegment(path40, glob) {
+  const normalizedPath = path40.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -55128,8 +55795,8 @@ function simpleGlobToRegex(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path37, glob) {
-  const normalizedPath = path37.replace(/\\/g, "/");
+function globMatches(path40, glob) {
+  const normalizedPath = path40.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -55165,31 +55832,31 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path36.join(workingDir, "src");
-  if (fs25.existsSync(srcDir)) {
+  const srcDir = path39.join(workingDir, "src");
+  if (fs27.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
     });
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path36.join(workingDir, dir);
-    if (fs25.existsSync(dirPath)) {
+    const dirPath = path39.join(workingDir, dir);
+    if (fs27.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path36.join(workingDir, "tests");
-  if (fs25.existsSync(testsDir)) {
+  const testsDir = path39.join(workingDir, "tests");
+  if (fs27.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
     });
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path36.join(workingDir, dir);
-    if (fs25.existsSync(dirPath) && dirPath !== testsDir) {
+    const dirPath = path39.join(workingDir, dir);
+    if (fs27.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
       });
@@ -55201,9 +55868,9 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
 }
 async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTestScan, callback) {
   try {
-    const entries = fs25.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs27.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path36.join(dirPath, entry.name);
+      const fullPath = path39.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -55211,7 +55878,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
         await scanDirectoryForLines(fullPath, includeGlobs, excludeGlobs, isTestScan, callback);
       } else if (entry.isFile()) {
         const relativePath = fullPath.replace(`${process.cwd()}/`, "");
-        const ext = path36.extname(entry.name).toLowerCase();
+        const ext = path39.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -55247,7 +55914,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
             continue;
         }
         try {
-          const content = fs25.readFileSync(fullPath, "utf-8");
+          const content = fs27.readFileSync(fullPath, "utf-8");
           const lines = countCodeLines(content);
           callback(lines);
         } catch {}
@@ -55461,8 +56128,8 @@ async function qualityBudget(input, directory) {
 init_dist();
 init_manager();
 init_detector();
-import * as fs26 from "fs";
-import * as path37 from "path";
+import * as fs28 from "fs";
+import * as path40 from "path";
 import { extname as extname9 } from "path";
 
 // src/sast/rules/c.ts
@@ -56329,17 +56996,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs26.statSync(filePath);
+    const stats = fs28.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE_BYTES6) {
       return { skip: true, reason: "file too large" };
     }
     if (stats.size === 0) {
       return { skip: true, reason: "empty file" };
     }
-    const fd = fs26.openSync(filePath, "r");
+    const fd = fs28.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs26.readSync(fd, buffer, 0, 8192, 0);
-    fs26.closeSync(fd);
+    const bytesRead = fs28.readSync(fd, buffer, 0, 8192, 0);
+    fs28.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -56378,7 +57045,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs26.readFileSync(filePath, "utf-8");
+    const content = fs28.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -56425,8 +57092,8 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path37.isAbsolute(filePath) ? filePath : path37.resolve(directory, filePath);
-    if (!fs26.existsSync(resolvedPath)) {
+    const resolvedPath = path40.isAbsolute(filePath) ? filePath : path40.resolve(directory, filePath);
+    if (!fs28.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -56624,18 +57291,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path38.win32.resolve(inputPath);
-  } else if (path38.isAbsolute(inputPath)) {
-    resolved = path38.resolve(inputPath);
+    resolved = path41.win32.resolve(inputPath);
+  } else if (path41.isAbsolute(inputPath)) {
+    resolved = path41.resolve(inputPath);
   } else {
-    resolved = path38.resolve(baseDir, inputPath);
+    resolved = path41.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path38.resolve(workspaceDir);
+  const workspaceResolved = path41.resolve(workspaceDir);
   let relative4;
   if (isWinAbs) {
-    relative4 = path38.win32.relative(workspaceResolved, resolved);
+    relative4 = path41.win32.relative(workspaceResolved, resolved);
   } else {
-    relative4 = path38.relative(workspaceResolved, resolved);
+    relative4 = path41.relative(workspaceResolved, resolved);
   }
   if (relative4.startsWith("..")) {
     return "path traversal detected";
@@ -56696,13 +57363,13 @@ async function runLintWrapped(files, directory, _config) {
 }
 async function runLintOnFiles(linter, files, workspaceDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path38.join(workspaceDir, "node_modules", ".bin");
+  const binDir = path41.join(workspaceDir, "node_modules", ".bin");
   const validatedFiles = [];
   for (const file3 of files) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path38.resolve(file3);
+    const resolvedPath = path41.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -56720,10 +57387,10 @@ async function runLintOnFiles(linter, files, workspaceDir) {
   }
   let command;
   if (linter === "biome") {
-    const biomeBin = isWindows ? path38.join(binDir, "biome.EXE") : path38.join(binDir, "biome");
+    const biomeBin = isWindows ? path41.join(binDir, "biome.EXE") : path41.join(binDir, "biome");
     command = [biomeBin, "check", ...validatedFiles];
   } else {
-    const eslintBin = isWindows ? path38.join(binDir, "eslint.cmd") : path38.join(binDir, "eslint");
+    const eslintBin = isWindows ? path41.join(binDir, "eslint.cmd") : path41.join(binDir, "eslint");
     command = [eslintBin, ...validatedFiles];
   }
   try {
@@ -56860,7 +57527,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path38.resolve(file3);
+      const resolvedPath = path41.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -56878,14 +57545,14 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path38.extname(file3).toLowerCase();
+      const ext = path41.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
       }
       let stat2;
       try {
-        stat2 = fs27.statSync(file3);
+        stat2 = fs29.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -56896,7 +57563,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs27.readFileSync(file3);
+        const buffer = fs29.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -57037,7 +57704,7 @@ async function runPreCheckBatch(input, workspaceDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path38.resolve(directory, file3));
+    changedFiles.push(path41.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -57188,7 +57855,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path38.resolve(typedArgs.directory);
+    const resolvedDirectory = path41.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory3(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -57295,8 +57962,8 @@ ${paginatedContent}`;
 init_tool();
 init_manager2();
 init_create_tool();
-import * as fs28 from "fs";
-import * as path39 from "path";
+import * as fs30 from "fs";
+import * as path42 from "path";
 function detectPlaceholderContent(args2) {
   const issues = [];
   const placeholderPattern = /^\[\w[\w\s]*\]$/;
@@ -57400,19 +58067,19 @@ async function executeSavePlan(args2, fallbackDir) {
   try {
     await savePlan(dir, plan);
     try {
-      const markerPath = path39.join(dir, ".swarm", ".plan-write-marker");
+      const markerPath = path42.join(dir, ".swarm", ".plan-write-marker");
       const marker = JSON.stringify({
         source: "save_plan",
         timestamp: new Date().toISOString(),
         phases_count: plan.phases.length,
         tasks_count: tasksCount
       });
-      await fs28.promises.writeFile(markerPath, marker, "utf8");
+      await fs30.promises.writeFile(markerPath, marker, "utf8");
     } catch {}
     return {
       success: true,
       message: "Plan saved successfully",
-      plan_path: path39.join(dir, ".swarm", "plan.json"),
+      plan_path: path42.join(dir, ".swarm", "plan.json"),
       phases_count: plan.phases.length,
       tasks_count: tasksCount
     };
@@ -57450,8 +58117,8 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_dist();
 init_manager();
-import * as fs29 from "fs";
-import * as path40 from "path";
+import * as fs31 from "fs";
+import * as path43 from "path";
 
 // src/sbom/detectors/dart.ts
 function parsePubspecLock(content) {
@@ -58297,9 +58964,9 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs29.readdirSync(dir, { withFileTypes: true });
+      const entries = fs31.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path40.join(dir, entry.name);
+        const fullPath = path43.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -58309,7 +58976,7 @@ function findManifestFiles(rootDir) {
           for (const pattern of patterns) {
             const regex = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
             if (new RegExp(regex, "i").test(entry.name)) {
-              manifestFiles.push(path40.relative(cwd, fullPath));
+              manifestFiles.push(path43.relative(cwd, fullPath));
               break;
             }
           }
@@ -58326,14 +58993,14 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs29.readdirSync(dir, { withFileTypes: true });
+      const entries = fs31.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path40.join(dir, entry.name);
+        const fullPath = path43.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             const regex = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
             if (new RegExp(regex, "i").test(entry.name)) {
-              found.push(path40.relative(workingDir, fullPath));
+              found.push(path43.relative(workingDir, fullPath));
               break;
             }
           }
@@ -58346,11 +59013,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path40.dirname(file3);
+    let currentDir = path43.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path40.sep) {
-        dirs.add(path40.join(workingDir, currentDir));
-        const parent = path40.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path43.sep) {
+        dirs.add(path43.join(workingDir, currentDir));
+        const parent = path43.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -58364,7 +59031,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs29.mkdirSync(outputDir, { recursive: true });
+    fs31.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -58456,11 +59123,11 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path40.isAbsolute(manifestFile) ? manifestFile : path40.join(workingDir, manifestFile);
-        if (!fs29.existsSync(fullPath)) {
+        const fullPath = path43.isAbsolute(manifestFile) ? manifestFile : path43.join(workingDir, manifestFile);
+        if (!fs31.existsSync(fullPath)) {
           continue;
         }
-        const content = fs29.readFileSync(fullPath, "utf-8");
+        const content = fs31.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -58473,8 +59140,8 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path40.join(outputDir, filename);
-    fs29.writeFileSync(outputPath, bomJson, "utf-8");
+    const outputPath = path43.join(outputDir, filename);
+    fs31.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -58516,8 +59183,8 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_dist();
 init_create_tool();
-import * as fs30 from "fs";
-import * as path41 from "path";
+import * as fs32 from "fs";
+import * as path44 from "path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -58549,28 +59216,28 @@ function normalizePath2(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path41.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path41.sep) ? cwd : cwd + path41.sep;
+    const resolvedPath = path44.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path44.sep) ? cwd : cwd + path44.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path41.extname(resolvedPath).toLowerCase();
+    const ext = path44.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
-    const stats = fs30.statSync(resolvedPath);
+    const stats = fs32.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs30.existsSync(resolvedPath)) {
+    if (!fs32.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path41.resolve(cwd, candidate);
-    if (fs30.existsSync(candidatePath)) {
-      const stats = fs30.statSync(candidatePath);
+    const candidatePath = path44.resolve(cwd, candidate);
+    if (fs32.existsSync(candidatePath)) {
+      const stats = fs32.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -58579,8 +59246,8 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs30.readFileSync(specFile, "utf-8");
-  const ext = path41.extname(specFile).toLowerCase();
+  const content = fs32.readFileSync(specFile, "utf-8");
+  const ext = path44.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -58646,12 +59313,12 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs30.readdirSync(dir, { withFileTypes: true });
+      entries = fs32.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path41.join(dir, entry.name);
+      const fullPath = path44.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -58661,7 +59328,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path41.extname(entry.name).toLowerCase();
+        const ext = path44.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -58679,7 +59346,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs30.readFileSync(filePath, "utf-8");
+  const content = fs32.readFileSync(filePath, "utf-8");
   const lines = content.split(/\r?\n/);
   const expressRegex = /(?:app|router|server|express)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/g;
   const flaskRegex = /@(?:app|blueprint|bp)\.route\s*\(\s*['"]([^'"]+)['"]/g;
@@ -58830,8 +59497,8 @@ init_secretscan();
 // src/tools/symbols.ts
 init_tool();
 init_create_tool();
-import * as fs31 from "fs";
-import * as path42 from "path";
+import * as fs33 from "fs";
+import * as path45 from "path";
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsControlCharacters(str) {
@@ -58860,11 +59527,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path42.resolve(workspace, filePath);
-    const realWorkspace = fs31.realpathSync(workspace);
-    const realResolvedPath = fs31.realpathSync(resolvedPath);
-    const relativePath = path42.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path42.isAbsolute(relativePath)) {
+    const resolvedPath = path45.resolve(workspace, filePath);
+    const realWorkspace = fs33.realpathSync(workspace);
+    const realResolvedPath = fs33.realpathSync(resolvedPath);
+    const relativePath = path45.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path45.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -58876,17 +59543,17 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path42.join(cwd, filePath);
+  const fullPath = path45.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs31.statSync(fullPath);
+    const stats = fs33.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs31.readFileSync(fullPath, "utf-8");
+    content = fs33.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -59028,17 +59695,17 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path42.join(cwd, filePath);
+  const fullPath = path45.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs31.statSync(fullPath);
+    const stats = fs33.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs31.readFileSync(fullPath, "utf-8");
+    content = fs33.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -59111,7 +59778,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path42.extname(file3);
+    const ext = path45.extname(file3);
     if (containsControlCharacters(file3)) {
       return JSON.stringify({
         file: file3,
@@ -59181,8 +59848,8 @@ init_test_runner();
 // src/tools/todo-extract.ts
 init_dist();
 init_create_tool();
-import * as fs32 from "fs";
-import * as path43 from "path";
+import * as fs34 from "fs";
+import * as path46 from "path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS2 = new Set([
@@ -59253,9 +59920,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path43.resolve(paths);
-    const normalizedCwd = path43.resolve(cwd);
-    const normalizedResolved = path43.resolve(resolvedPath);
+    const resolvedPath = path46.resolve(paths);
+    const normalizedCwd = path46.resolve(cwd);
+    const normalizedResolved = path46.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -59271,13 +59938,13 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path43.extname(filePath).toLowerCase();
+  const ext = path46.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS2.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
   let entries;
   try {
-    entries = fs32.readdirSync(dir);
+    entries = fs34.readdirSync(dir);
   } catch {
     return files;
   }
@@ -59286,10 +59953,10 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES3.has(entry)) {
       continue;
     }
-    const fullPath = path43.join(dir, entry);
+    const fullPath = path46.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs32.statSync(fullPath);
+      stat2 = fs34.statSync(fullPath);
     } catch {
       continue;
     }
@@ -59382,7 +60049,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs32.existsSync(scanPath)) {
+    if (!fs34.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -59392,13 +60059,13 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat2 = fs32.statSync(scanPath);
+    const stat2 = fs34.statSync(scanPath);
     if (stat2.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path43.extname(scanPath)}`,
+          error: `unsupported file extension: ${path46.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -59411,11 +60078,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs32.statSync(filePath);
+        const fileStat = fs34.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES8) {
           continue;
         }
-        const content = fs32.readFileSync(filePath, "utf-8");
+        const content = fs34.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -59443,8 +60110,8 @@ var todo_extract = createSwarmTool({
 // src/tools/update-task-status.ts
 init_tool();
 init_manager2();
-import * as fs33 from "fs";
-import * as path44 from "path";
+import * as fs35 from "fs";
+import * as path47 from "path";
 init_create_tool();
 var VALID_STATUSES = [
   "pending",
@@ -59481,6 +60148,10 @@ function checkReviewerGate(taskId) {
       const state = getTaskState(session, taskId);
       stateEntries.push(`${sessionId}: ${state}`);
     }
+    const allIdle = stateEntries.length > 0 && stateEntries.every((e) => e.endsWith(": idle"));
+    if (allIdle) {
+      console.warn(`[update-task-status] Issue #81 regression detected for task ${taskId}: all ${stateEntries.length} session(s) show idle state. taskWorkflowStates may not be persisting across sessions.`);
+    }
     const currentStateStr = stateEntries.length > 0 ? stateEntries.join(", ") : "no active sessions";
     return {
       blocked: true,
@@ -59544,8 +60215,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path44.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path44.sep);
+    normalizedDir = path47.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path47.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -59555,11 +60226,11 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path44.resolve(normalizedDir);
+    const resolvedDir = path47.resolve(normalizedDir);
     try {
-      const realPath = fs33.realpathSync(resolvedDir);
-      const planPath = path44.join(realPath, ".swarm", "plan.json");
-      if (!fs33.existsSync(planPath)) {
+      const realPath = fs35.realpathSync(resolvedDir);
+      const planPath = path47.join(realPath, ".swarm", "plan.json");
+      if (!fs35.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -59629,10 +60300,10 @@ function truncateToolOutput(output, maxLines, toolName) {
     footerLines.push(`Tool: ${toolName}`);
   }
   footerLines.push("Use /swarm retrieve <id> to get the full content");
-  return truncated.join(`
-`) + `
-` + footerLines.join(`
-`);
+  return `${truncated.join(`
+`)}
+${footerLines.join(`
+`)}`;
 }
 
 // src/index.ts
@@ -59690,7 +60361,7 @@ var OpenCodeSwarm = async (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 = path45.resolve(ctx.directory, ".swarm");
+    const swarmDir = path48.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {