opencode-swarm 6.13.1 → 6.13.3

package/dist/index.js

@@ -14001,7 +14001,23 @@ var init_evidence_schema = __esm(() => {
     task_count: exports_external.number().int().min(1),
     task_complexity: exports_external.enum(["trivial", "simple", "moderate", "complex"]),
     top_rejection_reasons: exports_external.array(exports_external.string()).default([]),
-    lessons_learned: exports_external.array(exports_external.string()).max(5).default([])
+    lessons_learned: exports_external.array(exports_external.string()).max(5).default([]),
+    user_directives: exports_external.array(exports_external.object({
+      directive: exports_external.string().min(1),
+      category: exports_external.enum([
+        "tooling",
+        "code_style",
+        "architecture",
+        "process",
+        "other"
+      ]),
+      scope: exports_external.enum(["session", "project", "global"])
+    })).default([]),
+    approaches_tried: exports_external.array(exports_external.object({
+      approach: exports_external.string().min(1),
+      result: exports_external.enum(["success", "failure", "partial"]),
+      abandoned_reason: exports_external.string().optional()
+    })).max(10).default([])
   });
   SyntaxEvidenceSchema = BaseEvidenceSchema.extend({
     type: exports_external.literal("syntax"),
@@ -31423,7 +31439,7 @@ var init_preflight_integration = __esm(() => {
 });
 
 // src/index.ts
-import * as path32 from "path";
+import * as path31 from "path";
 
 // src/tools/tool-names.ts
 var TOOL_NAMES = [
@@ -31449,7 +31465,8 @@ var TOOL_NAMES = [
   "detect_domains",
   "gitingest",
   "retrieve_summary",
-  "extract_code_blocks"
+  "extract_code_blocks",
+  "phase_complete"
 ];
 var TOOL_NAME_SET = new Set(TOOL_NAMES);
 
@@ -31785,12 +31802,19 @@ var GateConfigSchema = exports_external.object({
 var PipelineConfigSchema = exports_external.object({
   parallel_precheck: exports_external.boolean().default(true)
 });
+var PhaseCompleteConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  required_agents: exports_external.array(exports_external.enum(["coder", "reviewer", "test_engineer"])).default(["coder", "reviewer", "test_engineer"]),
+  require_docs: exports_external.boolean().default(true),
+  policy: exports_external.enum(["enforce", "warn"]).default("enforce")
+});
 var SummaryConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
   threshold_bytes: exports_external.number().min(1024).max(1048576).default(20480),
   max_summary_chars: exports_external.number().min(100).max(5000).default(1000),
   max_stored_bytes: exports_external.number().min(10240).max(104857600).default(10485760),
-  retention_days: exports_external.number().min(1).max(365).default(7)
+  retention_days: exports_external.number().min(1).max(365).default(7),
+  exempt_tools: exports_external.array(exports_external.string()).default(["retrieve_summary", "task"])
 });
 var ReviewPassesConfigSchema = exports_external.object({
   always_security_review: exports_external.boolean().default(false),
@@ -31804,6 +31828,11 @@ var ReviewPassesConfigSchema = exports_external.object({
     "**/token/**"
   ])
 });
+var AdversarialDetectionConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  policy: exports_external.enum(["warn", "gate", "ignore"]).default("warn"),
+  pairs: exports_external.array(exports_external.tuple([exports_external.string(), exports_external.string()])).default([["coder", "reviewer"]])
+});
 var IntegrationAnalysisConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true)
 });
@@ -32035,6 +32064,7 @@ var PluginConfigSchema = exports_external.object({
   swarms: exports_external.record(exports_external.string(), SwarmConfigSchema).optional(),
   max_iterations: exports_external.number().min(1).max(10).default(5),
   pipeline: PipelineConfigSchema.optional(),
+  phase_complete: PhaseCompleteConfigSchema.optional(),
   qa_retry_limit: exports_external.number().min(1).max(10).default(3),
   inject_phase_reminders: exports_external.boolean().default(true),
   hooks: HooksConfigSchema.optional(),
@@ -32046,6 +32076,7 @@ var PluginConfigSchema = exports_external.object({
   evidence: EvidenceConfigSchema.optional(),
   summaries: SummaryConfigSchema.optional(),
   review_passes: ReviewPassesConfigSchema.optional(),
+  adversarial_detection: AdversarialDetectionConfigSchema.optional(),
   integration_analysis: IntegrationAnalysisConfigSchema.optional(),
   docs: DocsConfigSchema.optional(),
   ui_review: UIReviewConfigSchema.optional(),
@@ -32466,6 +32497,37 @@ Identify 1-3 relevant domains from the task requirements.
 Call {{AGENT_PREFIX}}sme once per domain, serially. Max 3 SME calls per project phase.
 Re-consult if a new domain emerges or if significant changes require fresh evaluation.
 Cache guidance in context.md.
+### MODE: PRE-PHASE BRIEFING (Required Before Starting Any Phase)
+
+Before creating or resuming any plan, you MUST read the previous phase's retrospective.
+
+**Phase 2+ (continuing a multi-phase project):**
+1. Check \`.swarm/evidence/retro-{N-1}/evidence.json\` for the previous phase's retrospective
+2. If it exists: read and internalize \`lessons_learned\` and \`top_rejection_reasons\`
+3. If it does NOT exist: note this as a process gap, but proceed
+4. Print a briefing acknowledgment:
+\`\`\`
+\u2192 BRIEFING: Read Phase {N-1} retrospective.
+Key lessons: {list 1-3 most relevant lessons}
+Applying to Phase {N}: {one sentence on how you'll apply them}
+\`\`\`
+
+**Phase 1 (starting any new project):**
+1. Scan \`.swarm/evidence/\` for any \`retro-*\` bundles from prior projects
+2. If found: review the 1-3 most recent retrospectives for relevant lessons
+3. Pay special attention to \`user_directives\` \u2014 these carry across projects
+4. Print a briefing acknowledgment:
+\`\`\`
+\u2192 BRIEFING: Reviewed {N} historical retrospectives from this workspace.
+Relevant lessons: {list applicable lessons}
+User directives carried forward: {list any persistent directives}
+\`\`\`
+   OR if no historical retros exist:
+\`\`\`
+\u2192 BRIEFING: No historical retrospectives found. Starting fresh.
+\`\`\`
+
+This briefing is a HARD REQUIREMENT for ALL phases. Skipping it is a process violation.
 
 ### MODE: PLAN
 
@@ -32482,6 +32544,15 @@ TASK GRANULARITY RULES:
 - NEVER write a task with compound verbs: "implement X and add Y and update Z" = 3 tasks, not 1. Split before writing to plan.
 - Coder receives ONE task. You make ALL scope decisions in the plan. Coder makes zero scope decisions.
 
+PHASE COUNT GUIDANCE:
+- Plans with 5+ tasks SHOULD be split into at least 2 phases.
+- Plans with 10+ tasks MUST be split into at least 3 phases.
+- Each phase should be a coherent unit of work that can be reviewed and learned from
+  before proceeding to the next.
+- Single-phase plans are acceptable ONLY for small projects (1-4 tasks).
+- Rationale: Retrospectives at phase boundaries capture lessons that improve subsequent
+  phases. A single-phase plan gets zero iterative learning benefit.
+
 Create .swarm/context.md
 - Decisions, patterns, SME cache, file map
 
@@ -32619,6 +32690,54 @@ PRE-COMMIT RULE \u2014 Before ANY commit or push:
 
     5o. Update plan.md [x], proceed to next task.
 
+## \u26D4 RETROSPECTIVE GATE
+
+**MANDATORY before calling phase_complete.** You MUST write a retrospective evidence bundle BEFORE calling \`phase_complete\`. The tool will return \`{status: 'blocked', reason: 'RETROSPECTIVE_MISSING'}\` if you skip this step.
+
+**How to write the retrospective:**
+
+Use the evidence manager tool to write a bundle at \`retro-{N}\` (where N is the phase number being completed):
+
+\`\`\`json
+{
+  "type": "retrospective",
+  "phase_number": <N>,
+  "verdict": "pass",
+  "reviewer_rejections": <count>,
+  "coder_revisions": <count>,
+  "test_failures": <count>,
+  "security_findings": <count>,
+  "lessons_learned": ["lesson 1 (max 5)", "lesson 2"],
+  "top_rejection_reasons": ["reason 1"],
+  "user_directives": [],
+  "approaches_tried": [],
+  "task_complexity": "low|medium|high",
+  "timestamp": "<ISO 8601>",
+  "agent": "architect",
+  "metadata": { "plan_id": "<current plan title from .swarm/plan.json>" }
+}
+\`\`\`
+
+**Required field rules:**
+- \`verdict\` MUST be \`"pass"\` \u2014 a verdict of \`"fail"\` or missing verdict blocks phase_complete
+- \`phase_number\` MUST match the phase number you are completing
+- \`lessons_learned\` should be 3-5 concrete, actionable items from this phase
+- Write the bundle as task_id \`retro-{N}\` (e.g., \`retro-1\` for Phase 1, \`retro-2\` for Phase 2)
+- \`metadata.plan_id\` should be set to the current project's plan title (from \`.swarm/plan.json\` header). This enables cross-project filtering in the retrospective injection system.
+
+### Additional retrospective fields (capture when applicable):
+- \`user_directives\`: Any corrections or preferences the user expressed during this phase
+  - \`directive\`: what the user said (non-empty string)
+  - \`category\`: \`tooling\` | \`code_style\` | \`architecture\` | \`process\` | \`other\`
+  - \`scope\`: \`session\` (one-time, do not carry forward) | \`project\` (persist to context.md) | \`global\` (user preference)
+- \`approaches_tried\`: Approaches attempted during this phase (max 10)
+  - \`approach\`: what was tried (non-empty string)
+  - \`result\`: \`success\` | \`failure\` | \`partial\`
+  - \`abandoned_reason\`: why it was abandoned (required when result is \`failure\` or \`partial\`)
+
+**\u26A0\uFE0F WARNING:** Calling \`phase_complete(N)\` without a valid \`retro-N\` bundle will be BLOCKED. The error response will be:
+\`{ "status": "blocked", "reason": "RETROSPECTIVE_MISSING" }\`
+
 ### MODE: PHASE-WRAP
 1. {{AGENT_PREFIX}}explorer - Rescan
 2. {{AGENT_PREFIX}}docs - Update documentation for all changes in this phase. Provide:
@@ -34451,7 +34570,10 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000) {
     lastGateFailure: null,
     partialGateWarningIssued: false,
     selfFixAttempted: false,
-    catastrophicPhaseWarnings: new Set
+    catastrophicPhaseWarnings: new Set,
+    lastPhaseCompleteTimestamp: 0,
+    lastPhaseCompletePhase: 0,
+    phaseAgentsDispatched: new Set
   };
   swarmState.agentSessions.set(sessionId, sessionState);
   swarmState.activeAgent.set(sessionId, agentName);
@@ -34502,6 +34624,15 @@ function ensureAgentSession(sessionId, agentName) {
     if (!session.catastrophicPhaseWarnings) {
       session.catastrophicPhaseWarnings = new Set;
     }
+    if (session.lastPhaseCompleteTimestamp === undefined) {
+      session.lastPhaseCompleteTimestamp = 0;
+    }
+    if (session.lastPhaseCompletePhase === undefined) {
+      session.lastPhaseCompletePhase = 0;
+    }
+    if (!session.phaseAgentsDispatched) {
+      session.phaseAgentsDispatched = new Set;
+    }
     session.lastToolCallTime = now;
     return session;
   }
@@ -34570,6 +34701,17 @@ function pruneOldWindows(sessionId, maxAgeMs = 24 * 60 * 60 * 1000, maxWindows =
   const toKeep = sorted.slice(0, maxWindows);
   session.windows = Object.fromEntries(toKeep);
 }
+function recordPhaseAgentDispatch(sessionId, agentName) {
+  const session = swarmState.agentSessions.get(sessionId);
+  if (!session) {
+    return;
+  }
+  if (!session.phaseAgentsDispatched) {
+    session.phaseAgentsDispatched = new Set;
+  }
+  const normalizedName = stripKnownSwarmPrefix(agentName);
+  session.phaseAgentsDispatched.add(normalizedName);
+}
 
 // src/commands/benchmark.ts
 init_utils();
@@ -36680,6 +36822,7 @@ function createDelegationTrackerHook(config3, guardrailsEnabled = true) {
     const isArchitect = strippedAgent === ORCHESTRATOR_NAME;
     const session = ensureAgentSession(input.sessionID, agentName);
     session.delegationActive = !isArchitect;
+    recordPhaseAgentDispatch(input.sessionID, agentName);
     if (!isArchitect && guardrailsEnabled) {
       beginInvocation(input.sessionID, agentName);
     }
@@ -37131,8 +37274,8 @@ function hashArgs(args2) {
 // src/hooks/messages-transform.ts
 function consolidateSystemMessages(messages) {
   if (messages.length > 0 && messages[0].role === "system" && messages[0].content !== undefined && typeof messages[0].content === "string" && messages[0].content.trim().length > 0) {
-    const systemMessageCount = messages.filter((m) => m.role === "system" && typeof m.content === "string" && m.content.trim().length > 0 && m.tool_call_id === undefined && m.name === undefined).length;
-    if (systemMessageCount === 1) {
+    const totalSystemCount = messages.filter((m) => m.role === "system").length;
+    if (totalSystemCount === 1) {
       return [...messages];
     }
   }
@@ -37140,34 +37283,31 @@ function consolidateSystemMessages(messages) {
   const systemContents = [];
   for (let i2 = 0;i2 < messages.length; i2++) {
     const message = messages[i2];
-    if (message.role !== "system") {
+    if (message.role !== "system")
       continue;
-    }
-    if (message.tool_call_id !== undefined || message.name !== undefined) {
-      continue;
-    }
-    if (typeof message.content !== "string") {
-      continue;
-    }
-    const trimmedContent = message.content.trim();
-    if (trimmedContent.length === 0) {
+    if (message.tool_call_id !== undefined || message.name !== undefined)
       continue;
+    let textContent = null;
+    if (typeof message.content === "string") {
+      const trimmed = message.content.trim();
+      if (trimmed.length > 0)
+        textContent = trimmed;
+    } else if (Array.isArray(message.content)) {
+      const texts = message.content.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text.trim()).filter((t) => t.length > 0);
+      if (texts.length > 0)
+        textContent = texts.join(`
+`);
     }
     systemMessageIndices.push(i2);
-    systemContents.push(trimmedContent);
+    if (textContent) {
+      systemContents.push(textContent);
+    }
   }
   if (systemContents.length === 0) {
-    return messages.filter((m) => {
-      if (m.role !== "system") {
-        return true;
-      }
-      if (typeof m.content !== "string" || m.name !== undefined || m.tool_call_id !== undefined) {
+    return messages.filter((m, idx) => {
+      if (m.role !== "system")
         return true;
-      }
-      if (m.content.trim().length > 0) {
-        return true;
-      }
-      return false;
+      return idx === 0;
     });
   }
   const mergedSystemContent = systemContents.join(`
@@ -37178,7 +37318,7 @@ function consolidateSystemMessages(messages) {
   result.push({
     role: "system",
     content: mergedSystemContent,
-    ...Object.fromEntries(Object.entries(firstSystemMessage).filter(([key]) => key !== "role" && key !== "content"))
+    ...Object.fromEntries(Object.entries(firstSystemMessage).filter(([key]) => key !== "role" && key !== "content" && key !== "name" && key !== "tool_call_id"))
   });
   for (let i2 = 0;i2 < messages.length; i2++) {
     const message = messages[i2];
@@ -37190,7 +37330,11 @@ function consolidateSystemMessages(messages) {
     }
     result.push({ ...message });
   }
-  return result;
+  return result.filter((msg, idx) => {
+    if (idx === 0)
+      return true;
+    return msg.role !== "system";
+  });
 }
 // src/hooks/phase-monitor.ts
 init_manager2();
@@ -37304,8 +37448,7 @@ ${originalText}`;
   };
 }
 // src/hooks/system-enhancer.ts
-import * as fs11 from "fs";
-import * as path17 from "path";
+init_manager();
 init_manager2();
 
 // src/services/decision-drift-analyzer.ts
@@ -37585,6 +37728,39 @@ init_preflight_service();
 // src/hooks/system-enhancer.ts
 init_utils();
 
+// src/hooks/adversarial-detector.ts
+function safeGet(obj, key) {
+  if (!obj || !Object.hasOwn(obj, key))
+    return;
+  return obj[key];
+}
+function resolveAgentModel(agentName, config3) {
+  const baseName = stripKnownSwarmPrefix(agentName).toLowerCase();
+  const agentOverride = safeGet(config3.agents, baseName)?.model;
+  if (agentOverride)
+    return agentOverride;
+  if (config3.swarms) {
+    for (const swarm of Object.values(config3.swarms)) {
+      const swarmModel = safeGet(swarm.agents, baseName)?.model;
+      if (swarmModel)
+        return swarmModel;
+    }
+  }
+  const defaultModel = safeGet(DEFAULT_MODELS, baseName);
+  return defaultModel ?? DEFAULT_MODELS.default;
+}
+function detectAdversarialPair(agentA, agentB, config3) {
+  const modelA = resolveAgentModel(agentA, config3).toLowerCase();
+  const modelB = resolveAgentModel(agentB, config3).toLowerCase();
+  return modelA === modelB ? modelA : null;
+}
+function formatAdversarialWarning(agentA, agentB, sharedModel, policy) {
+  if (policy === "gate") {
+    return `\u26A0\uFE0F GATE POLICY: Same-model adversarial pair detected. Agent ${agentA} and checker ${agentB} both use model ${sharedModel}. This requires extra scrutiny \u2014 escalate if issues are found.`;
+  }
+  return `\u26A0\uFE0F Same-model adversarial pair detected. Agent ${agentA} and checker ${agentB} both use model ${sharedModel}. Review may lack independence.`;
+}
+
 // src/hooks/context-scoring.ts
 function calculateAgeFactor(ageHours, config3) {
   if (ageHours <= 0) {
@@ -37649,6 +37825,170 @@ function estimateContentType(text) {
   }
   return "prose";
 }
+async function buildRetroInjection(directory, currentPhaseNumber, currentPlanTitle) {
+  try {
+    const prevPhase = currentPhaseNumber - 1;
+    if (prevPhase >= 1) {
+      const bundle = await loadEvidence(directory, `retro-${prevPhase}`);
+      if (bundle && bundle.entries.length > 0) {
+        const retroEntry = bundle.entries.find((entry) => entry.type === "retrospective");
+        if (retroEntry && retroEntry.verdict !== "fail") {
+          const lessons = retroEntry.lessons_learned ?? [];
+          const rejections = retroEntry.top_rejection_reasons ?? [];
+          const nonSessionDirectives = (retroEntry.user_directives ?? []).filter((d) => d.scope !== "session");
+          let block = `## Previous Phase Retrospective (Phase ${prevPhase})
+**Outcome:** ${retroEntry.summary ?? "Phase completed."}
+**Rejection reasons:** ${rejections.join(", ") || "None"}
+**Lessons learned:**
+${lessons.map((l) => `- ${l}`).join(`
+`)}
+
+\u26A0\uFE0F Apply these lessons to the current phase. Do not repeat the same mistakes.`;
+          if (nonSessionDirectives.length > 0) {
+            const top5 = nonSessionDirectives.slice(0, 5);
+            block += `
+
+## User Directives (from Phase ${prevPhase})
+${top5.map((d) => `- [${d.category}] ${d.directive}`).join(`
+`)}`;
+          }
+          return block;
+        }
+      }
+      const taskIds = await listEvidenceTaskIds(directory);
+      const retroIds = taskIds.filter((id) => id.startsWith("retro-"));
+      let latestRetro = null;
+      for (const taskId of retroIds) {
+        const b = await loadEvidence(directory, taskId);
+        if (b && b.entries.length > 0) {
+          for (const entry of b.entries) {
+            if (entry.type === "retrospective") {
+              const retro = entry;
+              if (retro.verdict !== "fail") {
+                if (latestRetro === null || retro.phase_number > latestRetro.phase) {
+                  latestRetro = { entry: retro, phase: retro.phase_number };
+                }
+              }
+            }
+          }
+        }
+      }
+      if (latestRetro) {
+        const { entry, phase } = latestRetro;
+        const lessons = entry.lessons_learned ?? [];
+        const rejections = entry.top_rejection_reasons ?? [];
+        const nonSessionDirectives = (entry.user_directives ?? []).filter((d) => d.scope !== "session");
+        let block = `## Previous Phase Retrospective (Phase ${phase})
+**Outcome:** ${entry.summary ?? "Phase completed."}
+**Rejection reasons:** ${rejections.join(", ") || "None"}
+**Lessons learned:**
+${lessons.map((l) => `- ${l}`).join(`
+`)}
+
+\u26A0\uFE0F Apply these lessons to the current phase. Do not repeat the same mistakes.`;
+        if (nonSessionDirectives.length > 0) {
+          const top5 = nonSessionDirectives.slice(0, 5);
+          block += `
+
+## User Directives (from Phase ${phase})
+${top5.map((d) => `- [${d.category}] ${d.directive}`).join(`
+`)}`;
+        }
+        return block;
+      }
+      return null;
+    }
+    const allTaskIds = await listEvidenceTaskIds(directory);
+    const allRetroIds = allTaskIds.filter((id) => id.startsWith("retro-"));
+    if (allRetroIds.length === 0) {
+      return null;
+    }
+    const allRetros = [];
+    const cutoffMs = 30 * 24 * 60 * 60 * 1000;
+    const now = Date.now();
+    for (const taskId of allRetroIds) {
+      const b = await loadEvidence(directory, taskId);
+      if (!b)
+        continue;
+      for (const e of b.entries) {
+        if (e.type === "retrospective") {
+          const retro = e;
+          if (retro.verdict === "fail")
+            continue;
+          if (currentPlanTitle && typeof retro.metadata === "object" && retro.metadata !== null && "plan_id" in retro.metadata && retro.metadata.plan_id === currentPlanTitle)
+            continue;
+          const ts = retro.timestamp ?? b.created_at;
+          const ageMs = now - new Date(ts).getTime();
+          if (isNaN(ageMs) || ageMs > cutoffMs)
+            continue;
+          allRetros.push({ entry: retro, timestamp: ts });
+        }
+      }
+    }
+    if (allRetros.length === 0) {
+      return null;
+    }
+    allRetros.sort((a, b) => {
+      const ta = new Date(a.timestamp).getTime();
+      const tb = new Date(b.timestamp).getTime();
+      if (isNaN(ta) && isNaN(tb))
+        return 0;
+      if (isNaN(ta))
+        return 1;
+      if (isNaN(tb))
+        return -1;
+      return tb - ta;
+    });
+    const top3 = allRetros.slice(0, 3);
+    const lines = [
+      "## Historical Lessons (from recent prior projects)"
+    ];
+    lines.push("Most recent retrospectives in this workspace:");
+    const allCarriedDirectives = [];
+    for (const { entry, timestamp } of top3) {
+      const date9 = timestamp.split("T")[0] ?? "unknown";
+      const summary = entry.summary ?? `Phase ${entry.phase_number} completed`;
+      const topLesson = entry.lessons_learned?.[0] ?? "No lessons recorded";
+      lines.push(`- Phase ${entry.phase_number} (${date9}): ${summary}`);
+      lines.push(`  Key lesson: ${topLesson}`);
+      const nonSession = (entry.user_directives ?? []).filter((d) => d.scope !== "session");
+      allCarriedDirectives.push(...nonSession);
+    }
+    if (allCarriedDirectives.length > 0) {
+      const top5 = allCarriedDirectives.slice(0, 5);
+      lines.push("User directives carried forward:");
+      for (const d of top5) {
+        lines.push(`- [${d.category}] ${d.directive}`);
+      }
+    }
+    const tier2Block = lines.join(`
+`);
+    return tier2Block.length <= 800 ? tier2Block : `${tier2Block.substring(0, 797)}...`;
+  } catch {
+    return null;
+  }
+}
+async function buildCoderRetroInjection(directory, currentPhaseNumber) {
+  try {
+    const prevPhase = currentPhaseNumber - 1;
+    if (prevPhase < 1)
+      return null;
+    const bundle = await loadEvidence(directory, `retro-${prevPhase}`);
+    if (!bundle || bundle.entries.length === 0)
+      return null;
+    const retroEntry = bundle.entries.find((entry) => entry.type === "retrospective");
+    if (!retroEntry || retroEntry.verdict === "fail")
+      return null;
+    const lessons = retroEntry.lessons_learned ?? [];
+    const summaryLine = `[SWARM RETROSPECTIVE] From Phase ${prevPhase}:${retroEntry.summary ? " " + retroEntry.summary : ""}`;
+    const allLines = [summaryLine, ...lessons];
+    const text = allLines.join(`
+`);
+    return text.length <= 400 ? text : `${text.substring(0, 397)}...`;
+  } catch {
+    return null;
+  }
+}
 function createSystemEnhancerHook(config3, directory) {
   const enabled = config3.hooks?.system_enhancer !== false;
   if (!enabled) {
@@ -37727,6 +38067,35 @@ function createSystemEnhancerHook(config3, directory) {
           if (config3.secretscan?.enabled === false) {
             tryInject("[SWARM CONFIG] Secretscan gate is DISABLED. Skip secretscan in QA sequence.");
           }
+          const activeAgent_hf1 = swarmState.activeAgent.get(_input.sessionID ?? "");
+          const baseRole = activeAgent_hf1 ? stripKnownSwarmPrefix(activeAgent_hf1) : null;
+          if (baseRole === "coder" || baseRole === "test_engineer") {
+            tryInject("[SWARM CONFIG] You must NOT run build, test, lint, or type-check commands (npm run build, bun test, npx tsc, eslint, etc.). Make ONLY the code changes specified in your task. Verification is handled by the reviewer agent \u2014 do not self-verify. If your task explicitly asks you to run a specific command, that is the only exception.");
+          }
+          if (baseRole === "architect" || baseRole === null) {
+            tryInject("[SWARM CONFIG] You must NEVER run the full test suite or batch test files. If you need to verify changes, run ONLY the specific test files for code YOU modified in this session \u2014 one file at a time, strictly serial. Do not run tests from directories or files unrelated to your changes. Do not run bun test without an explicit file path. When possible, delegate test execution to the test_engineer agent instead of running tests yourself.");
+          }
+          if (config3.adversarial_detection?.enabled !== false) {
+            const activeAgent_adv = swarmState.activeAgent.get(_input.sessionID ?? "");
+            if (activeAgent_adv) {
+              const baseRole_adv = stripKnownSwarmPrefix(activeAgent_adv);
+              const pairs_adv = config3.adversarial_detection?.pairs ?? [
+                ["coder", "reviewer"]
+              ];
+              const policy_adv = config3.adversarial_detection?.policy ?? "warn";
+              for (const [agentA, agentB] of pairs_adv) {
+                if (baseRole_adv === agentB) {
+                  const sharedModel = detectAdversarialPair(agentA, agentB, config3);
+                  if (sharedModel) {
+                    const warningText = formatAdversarialWarning(agentA, agentB, sharedModel, policy_adv);
+                    if (policy_adv !== "ignore") {
+                      tryInject(`[SWARM CONFIG] ${warningText}`);
+                    }
+                  }
+                }
+              }
+            }
+          }
           if (mode !== "DISCOVER") {
             const sessionId_preflight = _input.sessionID;
             const activeAgent_preflight = swarmState.activeAgent.get(sessionId_preflight ?? "");
@@ -37739,43 +38108,27 @@ function createSystemEnhancerHook(config3, directory) {
               }
             }
           }
+          if (baseRole === "coder") {
+            try {
+              const currentPhaseNum_coder = plan2?.current_phase ?? 1;
+              const coderRetro = await buildCoderRetroInjection(directory, currentPhaseNum_coder);
+              if (coderRetro) {
+                tryInject(coderRetro);
+              }
+            } catch {}
+          }
           const sessionId_retro = _input.sessionID;
           const activeAgent_retro = swarmState.activeAgent.get(sessionId_retro ?? "");
           const isArchitect2 = !activeAgent_retro || stripKnownSwarmPrefix(activeAgent_retro) === "architect";
           if (isArchitect2) {
             try {
-              const evidenceDir = path17.join(directory, ".swarm", "evidence");
-              if (fs11.existsSync(evidenceDir)) {
-                const files = fs11.readdirSync(evidenceDir).filter((f) => f.endsWith(".json")).sort().reverse();
-                for (const file3 of files.slice(0, 5)) {
-                  let content;
-                  try {
-                    content = JSON.parse(fs11.readFileSync(path17.join(evidenceDir, file3), "utf-8"));
-                  } catch {
-                    continue;
-                  }
-                  if (content !== null && typeof content === "object" && content.type === "retrospective") {
-                    const retro = content;
-                    const hints = [];
-                    if (retro.reviewer_rejections > 2) {
-                      hints.push(`Phase ${retro.phase_number} had ${retro.reviewer_rejections} reviewer rejections.`);
-                    }
-                    if (retro.top_rejection_reasons.length > 0) {
-                      hints.push(`Common rejection reasons: ${retro.top_rejection_reasons.join(", ")}.`);
-                    }
-                    if (retro.lessons_learned.length > 0) {
-                      hints.push(`Lessons: ${retro.lessons_learned.join("; ")}.`);
-                    }
-                    if (hints.length > 0) {
-                      const retroHint = `[SWARM RETROSPECTIVE] From Phase ${retro.phase_number}: ${hints.join(" ")}`;
-                      if (retroHint.length <= 800) {
-                        tryInject(retroHint);
-                      } else {
-                        tryInject(`${retroHint.substring(0, 800)}...`);
-                      }
-                    }
-                    break;
-                  }
+              const currentPhaseNum = plan2?.current_phase ?? 1;
+              const retroText = await buildRetroInjection(directory, currentPhaseNum, plan2?.title ?? undefined);
+              if (retroText) {
+                if (retroText.length <= 1600) {
+                  tryInject(retroText);
+                } else {
+                  tryInject(`${retroText.substring(0, 1600)}...`);
                 }
               }
             } catch {}
@@ -37988,6 +38341,34 @@ function createSystemEnhancerHook(config3, directory) {
             metadata: { contentType: "prose" }
           });
         }
+        if (config3.adversarial_detection?.enabled !== false) {
+          const activeAgent_adv_b = swarmState.activeAgent.get(_input.sessionID ?? "");
+          if (activeAgent_adv_b) {
+            const baseRole_adv_b = stripKnownSwarmPrefix(activeAgent_adv_b);
+            const pairs_adv_b = config3.adversarial_detection?.pairs ?? [
+              ["coder", "reviewer"]
+            ];
+            const policy_adv_b = config3.adversarial_detection?.policy ?? "warn";
+            for (const [agentA_b, agentB_b] of pairs_adv_b) {
+              if (baseRole_adv_b === agentB_b) {
+                const sharedModel_b = detectAdversarialPair(agentA_b, agentB_b, config3);
+                if (sharedModel_b) {
+                  const warningText_b = formatAdversarialWarning(agentA_b, agentB_b, sharedModel_b, policy_adv_b);
+                  if (policy_adv_b !== "ignore") {
+                    candidates.push({
+                      id: `candidate-${idCounter++}`,
+                      kind: "agent_context",
+                      text: `[SWARM CONFIG] ${warningText_b}`,
+                      tokens: estimateTokens(warningText_b),
+                      priority: 2,
+                      metadata: { contentType: "prose" }
+                    });
+                  }
+                }
+              }
+            }
+          }
+        }
         const sessionId_preflight_b = _input.sessionID;
         const activeAgent_preflight_b = swarmState.activeAgent.get(sessionId_preflight_b ?? "");
         const isArchitectForPreflight_b = !activeAgent_preflight_b || stripKnownSwarmPrefix(activeAgent_preflight_b) === "architect";
@@ -38007,43 +38388,18 @@ function createSystemEnhancerHook(config3, directory) {
         const isArchitect_b = !activeAgent_retro_b || stripKnownSwarmPrefix(activeAgent_retro_b) === "architect";
         if (isArchitect_b) {
           try {
-            const evidenceDir_b = path17.join(directory, ".swarm", "evidence");
-            if (fs11.existsSync(evidenceDir_b)) {
-              const files_b = fs11.readdirSync(evidenceDir_b).filter((f) => f.endsWith(".json")).sort().reverse();
-              for (const file3 of files_b.slice(0, 5)) {
-                let content_b;
-                try {
-                  content_b = JSON.parse(fs11.readFileSync(path17.join(evidenceDir_b, file3), "utf-8"));
-                } catch {
-                  continue;
-                }
-                if (content_b !== null && typeof content_b === "object" && content_b.type === "retrospective") {
-                  const retro_b = content_b;
-                  const hints_b = [];
-                  if (retro_b.reviewer_rejections > 2) {
-                    hints_b.push(`Phase ${retro_b.phase_number} had ${retro_b.reviewer_rejections} reviewer rejections.`);
-                  }
-                  if (retro_b.top_rejection_reasons.length > 0) {
-                    hints_b.push(`Common rejection reasons: ${retro_b.top_rejection_reasons.join(", ")}.`);
-                  }
-                  if (retro_b.lessons_learned.length > 0) {
-                    hints_b.push(`Lessons: ${retro_b.lessons_learned.join("; ")}.`);
-                  }
-                  if (hints_b.length > 0) {
-                    const retroHint_b = `[SWARM RETROSPECTIVE] From Phase ${retro_b.phase_number}: ${hints_b.join(" ")}`;
-                    const retroText = retroHint_b.length <= 800 ? retroHint_b : `${retroHint_b.substring(0, 800)}...`;
-                    candidates.push({
-                      id: `candidate-${idCounter++}`,
-                      kind: "phase",
-                      text: retroText,
-                      tokens: estimateTokens(retroText),
-                      priority: 2,
-                      metadata: { contentType: "prose" }
-                    });
-                  }
-                  break;
-                }
-              }
+            const currentPhaseNum_b = plan?.current_phase ?? 1;
+            const retroText_b = await buildRetroInjection(directory, currentPhaseNum_b, plan?.title ?? undefined);
+            if (retroText_b) {
+              const text = retroText_b.length <= 1600 ? retroText_b : `${retroText_b.substring(0, 1597)}...`;
+              candidates.push({
+                id: `candidate-${idCounter++}`,
+                kind: "phase",
+                text,
+                tokens: estimateTokens(text),
+                priority: 2,
+                metadata: { contentType: "prose" }
+              });
             }
           } catch {}
           if (mode_b !== "DISCOVER") {
@@ -38081,6 +38437,24 @@ function createSystemEnhancerHook(config3, directory) {
             }
           }
         }
+        const activeAgent_coder_b = swarmState.activeAgent.get(_input.sessionID ?? "");
+        const isCoder_b = activeAgent_coder_b && stripKnownSwarmPrefix(activeAgent_coder_b) === "coder";
+        if (isCoder_b) {
+          try {
+            const currentPhaseNum_coder_b = plan?.current_phase ?? 1;
+            const coderRetro_b = await buildCoderRetroInjection(directory, currentPhaseNum_coder_b);
+            if (coderRetro_b) {
+              candidates.push({
+                id: `candidate-${idCounter++}`,
+                kind: "agent_context",
+                text: coderRetro_b,
+                tokens: estimateTokens(coderRetro_b),
+                priority: 2,
+                metadata: { contentType: "prose" }
+              });
+            }
+          } catch {}
+        }
         const automationCapabilities_b = config3.automation?.capabilities;
         if (automationCapabilities_b?.decision_drift_detection === true && sessionId_retro_b) {
           const activeAgentForDrift_b = swarmState.activeAgent.get(sessionId_retro_b ?? "");
@@ -38306,6 +38680,10 @@ function createToolSummarizerHook(config3, directory) {
     if (typeof output.output !== "string" || output.output.length === 0) {
       return;
     }
+    const exemptTools = config3.exempt_tools ?? ["retrieve_summary", "task"];
+    if (exemptTools.includes(input.tool)) {
+      return;
+    }
     if (!shouldSummarize(output.output, config3.threshold_bytes)) {
       return;
     }
@@ -38331,8 +38709,8 @@ init_dist();
 
 // src/build/discovery.ts
 init_dist();
-import * as fs12 from "fs";
-import * as path18 from "path";
+import * as fs11 from "fs";
+import * as path17 from "path";
 var ECOSYSTEMS = [
   {
     ecosystem: "node",
@@ -38444,18 +38822,18 @@ function findBuildFiles(workingDir, patterns) {
     if (pattern.includes("*")) {
       const dir = workingDir;
       try {
-        const files = fs12.readdirSync(dir);
+        const files = fs11.readdirSync(dir);
         const matches = files.filter((f) => {
           const regex = new RegExp(`^${pattern.replace(/\*/g, ".*")}$`);
           return regex.test(f);
         });
         if (matches.length > 0) {
-          return path18.join(dir, matches[0]);
+          return path17.join(dir, matches[0]);
         }
       } catch {}
     } else {
-      const filePath = path18.join(workingDir, pattern);
-      if (fs12.existsSync(filePath)) {
+      const filePath = path17.join(workingDir, pattern);
+      if (fs11.existsSync(filePath)) {
         return filePath;
       }
     }
@@ -38463,12 +38841,12 @@ function findBuildFiles(workingDir, patterns) {
   return null;
 }
 function getRepoDefinedScripts(workingDir, scripts) {
-  const packageJsonPath = path18.join(workingDir, "package.json");
-  if (!fs12.existsSync(packageJsonPath)) {
+  const packageJsonPath = path17.join(workingDir, "package.json");
+  if (!fs11.existsSync(packageJsonPath)) {
     return [];
   }
   try {
-    const content = fs12.readFileSync(packageJsonPath, "utf-8");
+    const content = fs11.readFileSync(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.scripts || typeof pkg.scripts !== "object") {
       return [];
@@ -38504,8 +38882,8 @@ function findAllBuildFiles(workingDir) {
         const regex = new RegExp(`^${pattern.replace(/\*/g, ".*")}$`);
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
-        const filePath = path18.join(workingDir, pattern);
-        if (fs12.existsSync(filePath)) {
+        const filePath = path17.join(workingDir, pattern);
+        if (fs11.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
       }
@@ -38515,9 +38893,9 @@ function findAllBuildFiles(workingDir) {
 }
 function findFilesRecursive(dir, regex, results) {
   try {
-    const entries = fs12.readdirSync(dir, { withFileTypes: true });
+    const entries = fs11.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path18.join(dir, entry.name);
+      const fullPath = path17.join(dir, entry.name);
       if (entry.isDirectory() && !["node_modules", ".git", "dist", "build", "target"].includes(entry.name)) {
         findFilesRecursive(fullPath, regex, results);
       } else if (entry.isFile() && regex.test(entry.name)) {
@@ -38758,8 +39136,8 @@ var build_check = tool({
 // src/tools/checkpoint.ts
 init_tool();
 import { spawnSync } from "child_process";
-import * as fs13 from "fs";
-import * as path19 from "path";
+import * as fs12 from "fs";
+import * as path18 from "path";
 var CHECKPOINT_LOG_PATH = ".swarm/checkpoints.json";
 var MAX_LABEL_LENGTH = 100;
 var GIT_TIMEOUT_MS = 30000;
@@ -38810,13 +39188,13 @@ function validateLabel(label) {
   return null;
 }
 function getCheckpointLogPath() {
-  return path19.join(process.cwd(), CHECKPOINT_LOG_PATH);
+  return path18.join(process.cwd(), CHECKPOINT_LOG_PATH);
 }
 function readCheckpointLog() {
   const logPath = getCheckpointLogPath();
   try {
-    if (fs13.existsSync(logPath)) {
-      const content = fs13.readFileSync(logPath, "utf-8");
+    if (fs12.existsSync(logPath)) {
+      const content = fs12.readFileSync(logPath, "utf-8");
       const parsed = JSON.parse(content);
       if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
         return { version: 1, checkpoints: [] };
@@ -38828,13 +39206,13 @@ function readCheckpointLog() {
 }
 function writeCheckpointLog(log2) {
   const logPath = getCheckpointLogPath();
-  const dir = path19.dirname(logPath);
-  if (!fs13.existsSync(dir)) {
-    fs13.mkdirSync(dir, { recursive: true });
+  const dir = path18.dirname(logPath);
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
   }
   const tempPath = `${logPath}.tmp`;
-  fs13.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
-  fs13.renameSync(tempPath, logPath);
+  fs12.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
+  fs12.renameSync(tempPath, logPath);
 }
 function gitExec(args2) {
   const result = spawnSync("git", args2, {
@@ -39034,8 +39412,8 @@ var checkpoint = tool({
 });
 // src/tools/complexity-hotspots.ts
 init_dist();
-import * as fs14 from "fs";
-import * as path20 from "path";
+import * as fs13 from "fs";
+import * as path19 from "path";
 var MAX_FILE_SIZE_BYTES2 = 256 * 1024;
 var DEFAULT_DAYS = 90;
 var DEFAULT_TOP_N = 20;
@@ -39163,11 +39541,11 @@ function estimateComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat = fs14.statSync(filePath);
+    const stat = fs13.statSync(filePath);
     if (stat.size > MAX_FILE_SIZE_BYTES2) {
       return null;
     }
-    const content = fs14.readFileSync(filePath, "utf-8");
+    const content = fs13.readFileSync(filePath, "utf-8");
     return estimateComplexity(content);
   } catch {
     return null;
@@ -39178,7 +39556,7 @@ async function analyzeHotspots(days, topN, extensions) {
   const extSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
   const filteredChurn = new Map;
   for (const [file3, count] of churnMap) {
-    const ext = path20.extname(file3).toLowerCase();
+    const ext = path19.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -39188,8 +39566,8 @@ async function analyzeHotspots(days, topN, extensions) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs14.existsSync(fullPath)) {
-      fullPath = path20.join(cwd, file3);
+    if (!fs13.existsSync(fullPath)) {
+      fullPath = path19.join(cwd, file3);
     }
     const complexity = getComplexityForFile(fullPath);
     if (complexity !== null) {
@@ -39347,14 +39725,14 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path21 of paths) {
-    if (!path21 || path21.length === 0) {
+  for (const path20 of paths) {
+    if (!path20 || path20.length === 0) {
       return "empty path not allowed";
     }
-    if (path21.length > MAX_PATH_LENGTH) {
+    if (path20.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path21)) {
+    if (SHELL_METACHARACTERS2.test(path20)) {
       return "path contains shell metacharacters";
     }
   }
@@ -39417,8 +39795,8 @@ var diff = tool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path21 = parts2[2];
-          files.push({ path: path21, additions, deletions });
+          const path20 = parts2[2];
+          files.push({ path: path20, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -39646,8 +40024,8 @@ Use these as DOMAIN values when delegating to @sme.`;
 });
 // src/tools/evidence-check.ts
 init_dist();
-import * as fs15 from "fs";
-import * as path21 from "path";
+import * as fs14 from "fs";
+import * as path20 from "path";
 var MAX_FILE_SIZE_BYTES3 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR = ".swarm/evidence";
@@ -39670,9 +40048,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm(filePath, cwd) {
-  const normalizedCwd = path21.resolve(cwd);
-  const swarmPath = path21.join(normalizedCwd, ".swarm");
-  const normalizedPath = path21.resolve(filePath);
+  const normalizedCwd = path20.resolve(cwd);
+  const swarmPath = path20.join(normalizedCwd, ".swarm");
+  const normalizedPath = path20.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -39688,12 +40066,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs15.existsSync(evidenceDir) || !fs15.statSync(evidenceDir).isDirectory()) {
+  if (!fs14.existsSync(evidenceDir) || !fs14.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs15.readdirSync(evidenceDir);
+    files = fs14.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -39702,14 +40080,14 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path21.join(evidenceDir, filename);
+    const filePath = path20.join(evidenceDir, filename);
     try {
-      const resolvedPath = path21.resolve(filePath);
-      const evidenceDirResolved = path21.resolve(evidenceDir);
+      const resolvedPath = path20.resolve(filePath);
+      const evidenceDirResolved = path20.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat = fs15.lstatSync(filePath);
+      const stat = fs14.lstatSync(filePath);
       if (!stat.isFile()) {
         continue;
       }
@@ -39718,7 +40096,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs15.statSync(filePath);
+      fileStat = fs14.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES3) {
         continue;
       }
@@ -39727,7 +40105,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs15.readFileSync(filePath, "utf-8");
+      content = fs14.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -39812,7 +40190,7 @@ var evidence_check = tool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
-    const planPath = path21.join(cwd, PLAN_FILE);
+    const planPath = path20.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -39826,7 +40204,7 @@ var evidence_check = tool({
     }
     let planContent;
     try {
-      planContent = fs15.readFileSync(planPath, "utf-8");
+      planContent = fs14.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -39844,7 +40222,7 @@ var evidence_check = tool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path21.join(cwd, EVIDENCE_DIR);
+    const evidenceDir = path20.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;
@@ -39860,8 +40238,8 @@ var evidence_check = tool({
 });
 // src/tools/file-extractor.ts
 init_tool();
-import * as fs16 from "fs";
-import * as path22 from "path";
+import * as fs15 from "fs";
+import * as path21 from "path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -39923,8 +40301,8 @@ var extract_code_blocks = tool({
   execute: async (args2) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || process.cwd();
-    if (!fs16.existsSync(targetDir)) {
-      fs16.mkdirSync(targetDir, { recursive: true });
+    if (!fs15.existsSync(targetDir)) {
+      fs15.mkdirSync(targetDir, { recursive: true });
     }
     const pattern = /```(\w*)\n([\s\S]*?)```/g;
     const matches = [...content.matchAll(pattern)];
@@ -39939,16 +40317,16 @@ var extract_code_blocks = tool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path22.join(targetDir, filename);
-      const base = path22.basename(filepath, path22.extname(filepath));
-      const ext = path22.extname(filepath);
+      let filepath = path21.join(targetDir, filename);
+      const base = path21.basename(filepath, path21.extname(filepath));
+      const ext = path21.extname(filepath);
       let counter = 1;
-      while (fs16.existsSync(filepath)) {
-        filepath = path22.join(targetDir, `${base}_${counter}${ext}`);
+      while (fs15.existsSync(filepath)) {
+        filepath = path21.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs16.writeFileSync(filepath, code.trim(), "utf-8");
+        fs15.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -40056,8 +40434,8 @@ var gitingest = tool({
 });
 // src/tools/imports.ts
 init_dist();
-import * as fs17 from "fs";
-import * as path23 from "path";
+import * as fs16 from "fs";
+import * as path22 from "path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES4 = 1024 * 1024;
@@ -40111,7 +40489,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path23.extname(filePath).toLowerCase();
+  const ext = path22.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -40135,15 +40513,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path23.resolve(targetFile);
+    _resolvedTarget = path22.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path23.basename(targetFile, path23.extname(targetFile));
+  const targetBasename = path22.basename(targetFile, path22.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path23.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path23.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path22.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path22.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];
@@ -40166,9 +40544,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path23.dirname(targetFile);
-    const targetExt = path23.extname(targetFile);
-    const targetBasenameNoExt = path23.basename(targetFile, targetExt);
+    const _targetDir = path22.dirname(targetFile);
+    const targetExt = path22.extname(targetFile);
+    const targetBasenameNoExt = path22.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, "");
@@ -40225,7 +40603,7 @@ var SKIP_DIRECTORIES2 = new Set([
 function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs17.readdirSync(dir);
+    entries = fs16.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -40236,13 +40614,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(path23.join(dir, entry));
+      stats.skippedDirs.push(path22.join(dir, entry));
       continue;
     }
-    const fullPath = path23.join(dir, entry);
+    const fullPath = path22.join(dir, entry);
     let stat;
     try {
-      stat = fs17.statSync(fullPath);
+      stat = fs16.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -40253,7 +40631,7 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
     if (stat.isDirectory()) {
       findSourceFiles2(fullPath, files, stats);
     } else if (stat.isFile()) {
-      const ext = path23.extname(fullPath).toLowerCase();
+      const ext = path22.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -40309,8 +40687,8 @@ var imports = tool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path23.resolve(file3);
-      if (!fs17.existsSync(targetFile)) {
+      const targetFile = path22.resolve(file3);
+      if (!fs16.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -40320,7 +40698,7 @@ var imports = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs17.statSync(targetFile);
+      const targetStat = fs16.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -40331,7 +40709,7 @@ var imports = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path23.dirname(targetFile);
+      const baseDir = path22.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -40346,12 +40724,12 @@ var imports = tool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat = fs17.statSync(filePath);
+          const stat = fs16.statSync(filePath);
           if (stat.size > MAX_FILE_SIZE_BYTES4) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs17.readFileSync(filePath);
+          const buffer = fs16.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -40418,10 +40796,208 @@ var imports = tool({
 // src/tools/index.ts
 init_lint();
 
+// src/tools/phase-complete.ts
+init_tool();
+import * as fs17 from "fs";
+init_manager();
+init_utils2();
+function getDelegationsSince(sessionID, sinceTimestamp) {
+  const chain = swarmState.delegationChains.get(sessionID);
+  if (!chain) {
+    return [];
+  }
+  if (sinceTimestamp === 0) {
+    return chain;
+  }
+  return chain.filter((entry) => entry.timestamp > sinceTimestamp);
+}
+function normalizeAgentsFromDelegations(delegations) {
+  const agents = new Set;
+  for (const delegation of delegations) {
+    const normalizedFrom = stripKnownSwarmPrefix(delegation.from);
+    const normalizedTo = stripKnownSwarmPrefix(delegation.to);
+    agents.add(normalizedFrom);
+    agents.add(normalizedTo);
+  }
+  return agents;
+}
+function isValidRetroEntry(entry, phase) {
+  return entry.type === "retrospective" && "phase_number" in entry && entry.phase_number === phase && "verdict" in entry && entry.verdict === "pass";
+}
+async function executePhaseComplete(args2) {
+  const phase = Number(args2.phase);
+  const summary = args2.summary;
+  const sessionID = args2.sessionID;
+  if (Number.isNaN(phase) || phase < 1) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: "Invalid phase number",
+      agentsDispatched: [],
+      warnings: ["Phase must be a positive number"]
+    }, null, 2);
+  }
+  if (!sessionID) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: "Session ID is required",
+      agentsDispatched: [],
+      warnings: [
+        "sessionID parameter is required for phase completion tracking"
+      ]
+    }, null, 2);
+  }
+  const session = ensureAgentSession(sessionID);
+  const lastCompletionTimestamp = session.lastPhaseCompleteTimestamp ?? 0;
+  const recentDelegations = getDelegationsSince(sessionID, lastCompletionTimestamp);
+  const delegationAgents = normalizeAgentsFromDelegations(recentDelegations);
+  const trackedAgents = session.phaseAgentsDispatched ?? new Set;
+  const allAgents = new Set([...delegationAgents, ...trackedAgents]);
+  const agentsDispatched = Array.from(allAgents).sort();
+  const directory = process.cwd();
+  const { config: config3 } = loadPluginConfigWithMeta(directory);
+  let phaseCompleteConfig;
+  try {
+    phaseCompleteConfig = PhaseCompleteConfigSchema.parse(config3.phase_complete ?? {});
+  } catch (parseError) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      status: "incomplete",
+      message: `Invalid phase_complete configuration: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+      agentsDispatched,
+      agentsMissing: [],
+      warnings: ["Configuration validation failed"]
+    }, null, 2);
+  }
+  if (phaseCompleteConfig.enabled === false) {
+    return JSON.stringify({
+      success: true,
+      phase,
+      status: "disabled",
+      message: `Phase ${phase} complete (enforcement disabled)`,
+      agentsDispatched,
+      agentsMissing: [],
+      warnings: []
+    }, null, 2);
+  }
+  const retroBundle = await loadEvidence(directory, `retro-${phase}`);
+  let retroFound = false;
+  if (retroBundle !== null) {
+    retroFound = retroBundle.entries?.some((entry) => isValidRetroEntry(entry, phase)) ?? false;
+  }
+  if (!retroFound) {
+    const allTaskIds = await listEvidenceTaskIds(directory);
+    const retroTaskIds = allTaskIds.filter((id) => id.startsWith("retro-"));
+    for (const taskId of retroTaskIds) {
+      const bundle = await loadEvidence(directory, taskId);
+      if (bundle === null)
+        continue;
+      retroFound = bundle.entries?.some((entry) => isValidRetroEntry(entry, phase)) ?? false;
+      if (retroFound)
+        break;
+    }
+  }
+  if (!retroFound) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      status: "blocked",
+      reason: "RETROSPECTIVE_MISSING",
+      message: `Phase ${phase} cannot be completed: no valid retrospective evidence found. Write a retrospective bundle at .swarm/evidence/retro-${phase}/evidence.json with type='retrospective', phase_number=${phase}, verdict='pass' before calling phase_complete.`,
+      agentsDispatched: [],
+      agentsMissing: [],
+      warnings: [
+        `Retrospective missing for phase ${phase}. Write a retro bundle with verdict='pass' at .swarm/evidence/retro-${phase}/evidence.json`
+      ]
+    }, null, 2);
+  }
+  const effectiveRequired = [...phaseCompleteConfig.required_agents];
+  if (phaseCompleteConfig.require_docs && !effectiveRequired.includes("docs")) {
+    effectiveRequired.push("docs");
+  }
+  const agentsMissing = effectiveRequired.filter((req) => !allAgents.has(req));
+  const warnings = [];
+  let success3 = true;
+  let status = "success";
+  const safeSummary = summary?.trim().slice(0, 500);
+  let message = safeSummary ? `Phase ${phase} completed: ${safeSummary}` : `Phase ${phase} completed`;
+  if (agentsMissing.length > 0) {
+    if (phaseCompleteConfig.policy === "enforce") {
+      success3 = false;
+      status = "incomplete";
+      message = `Phase ${phase} incomplete: missing required agents: ${agentsMissing.join(", ")}`;
+    } else {
+      status = "warned";
+      warnings.push(`Warning: phase ${phase} missing required agents: ${agentsMissing.join(", ")}`);
+    }
+  }
+  const now = Date.now();
+  const durationMs = now - lastCompletionTimestamp;
+  const event = {
+    event: "phase_complete",
+    phase,
+    timestamp: new Date(now).toISOString(),
+    agents_dispatched: agentsDispatched,
+    agents_missing: agentsMissing,
+    status,
+    summary: safeSummary ?? null
+  };
+  try {
+    const eventsPath = validateSwarmPath(directory, "events.jsonl");
+    fs17.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)}`);
+  }
+  if (success3) {
+    session.phaseAgentsDispatched = new Set;
+    session.lastPhaseCompleteTimestamp = now;
+    session.lastPhaseCompletePhase = phase;
+  }
+  const result = {
+    success: success3,
+    phase,
+    status,
+    message,
+    agentsDispatched,
+    agentsMissing,
+    warnings
+  };
+  return JSON.stringify({ ...result, timestamp: event.timestamp, duration_ms: durationMs }, null, 2);
+}
+var phase_complete = tool({
+  description: "Mark a phase as complete and track which agents were dispatched. " + "Used for phase completion gating and tracking. " + "Accepts phase number and optional summary. Returns list of agents that were dispatched.",
+  args: {
+    phase: tool.schema.number().describe("The phase number being completed (e.g., 1, 2, 3)"),
+    summary: tool.schema.string().optional().describe("Optional summary of what was accomplished in this phase"),
+    sessionID: tool.schema.string().optional().describe("Session ID for tracking state (auto-provided by plugin context)")
+  },
+  execute: async (args2) => {
+    let phaseCompleteArgs;
+    try {
+      phaseCompleteArgs = {
+        phase: Number(args2.phase),
+        summary: args2.summary !== undefined ? String(args2.summary) : undefined,
+        sessionID: args2.sessionID !== undefined ? String(args2.sessionID) : undefined
+      };
+    } catch {
+      return JSON.stringify({
+        success: false,
+        phase: 0,
+        message: "Invalid arguments",
+        agentsDispatched: [],
+        warnings: ["Failed to parse arguments"]
+      }, null, 2);
+    }
+    return executePhaseComplete(phaseCompleteArgs);
+  }
+});
 // src/tools/pkg-audit.ts
 init_dist();
 import * as fs18 from "fs";
-import * as path24 from "path";
+import * as path23 from "path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -40439,13 +41015,13 @@ function validateArgs3(args2) {
 function detectEcosystems() {
   const ecosystems = [];
   const cwd = process.cwd();
-  if (fs18.existsSync(path24.join(cwd, "package.json"))) {
+  if (fs18.existsSync(path23.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs18.existsSync(path24.join(cwd, "pyproject.toml")) || fs18.existsSync(path24.join(cwd, "requirements.txt"))) {
+  if (fs18.existsSync(path23.join(cwd, "pyproject.toml")) || fs18.existsSync(path23.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs18.existsSync(path24.join(cwd, "Cargo.toml"))) {
+  if (fs18.existsSync(path23.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
   return ecosystems;
@@ -42353,11 +42929,11 @@ var Module2 = (() => {
       throw toThrow;
     }, "quit_");
     var scriptDirectory = "";
-    function locateFile(path25) {
+    function locateFile(path24) {
       if (Module["locateFile"]) {
-        return Module["locateFile"](path25, scriptDirectory);
+        return Module["locateFile"](path24, scriptDirectory);
       }
-      return scriptDirectory + path25;
+      return scriptDirectory + path24;
     }
     __name(locateFile, "locateFile");
     var readAsync, readBinary;
@@ -44171,7 +44747,7 @@ var SUPPORTED_PARSER_EXTENSIONS = new Set([
 ]);
 // src/tools/pre-check-batch.ts
 init_dist();
-import * as path27 from "path";
+import * as path26 from "path";
 
 // node_modules/yocto-queue/index.js
 class Node2 {
@@ -44338,7 +44914,7 @@ init_manager();
 
 // src/quality/metrics.ts
 import * as fs19 from "fs";
-import * as path25 from "path";
+import * as path24 from "path";
 var MAX_FILE_SIZE_BYTES5 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -44390,7 +44966,7 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path25.isAbsolute(file3) ? file3 : path25.join(workingDir, file3);
+    const fullPath = path24.isAbsolute(file3) ? file3 : path24.join(workingDir, file3);
     if (!fs19.existsSync(fullPath)) {
       continue;
     }
@@ -44513,7 +45089,7 @@ function countGoExports(content) {
 function getExportCountForFile(filePath) {
   try {
     const content = fs19.readFileSync(filePath, "utf-8");
-    const ext = path25.extname(filePath).toLowerCase();
+    const ext = path24.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -44539,7 +45115,7 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path25.isAbsolute(file3) ? file3 : path25.join(workingDir, file3);
+    const fullPath = path24.isAbsolute(file3) ? file3 : path24.join(workingDir, file3);
     if (!fs19.existsSync(fullPath)) {
       continue;
     }
@@ -44573,7 +45149,7 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path25.isAbsolute(file3) ? file3 : path25.join(workingDir, file3);
+    const fullPath = path24.isAbsolute(file3) ? file3 : path24.join(workingDir, file3);
     if (!fs19.existsSync(fullPath)) {
       continue;
     }
@@ -44606,8 +45182,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename5 = path25.basename(filePath);
-  const _ext = path25.extname(filePath).toLowerCase();
+  const basename5 = path24.basename(filePath);
+  const _ext = path24.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -44649,7 +45225,7 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path25.join(workingDir, "src");
+  const srcDir = path24.join(workingDir, "src");
   if (fs19.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
@@ -44657,14 +45233,14 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path25.join(workingDir, dir);
+    const dirPath = path24.join(workingDir, dir);
     if (fs19.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path25.join(workingDir, "tests");
+  const testsDir = path24.join(workingDir, "tests");
   if (fs19.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
@@ -44672,7 +45248,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path25.join(workingDir, dir);
+    const dirPath = path24.join(workingDir, dir);
     if (fs19.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
@@ -44687,7 +45263,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
   try {
     const entries = fs19.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path25.join(dirPath, entry.name);
+      const fullPath = path24.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -44695,7 +45271,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 = path25.extname(entry.name).toLowerCase();
+        const ext = path24.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -44950,7 +45526,7 @@ async function qualityBudget(input, directory) {
 // src/tools/sast-scan.ts
 init_manager();
 import * as fs20 from "fs";
-import * as path26 from "path";
+import * as path25 from "path";
 import { extname as extname7 } from "path";
 
 // src/sast/rules/c.ts
@@ -45905,7 +46481,7 @@ async function sastScan(input, directory, config3) {
   const engine = semgrepAvailable ? "tier_a+tier_b" : "tier_a";
   const filesByLanguage = new Map;
   for (const filePath of changed_files) {
-    const resolvedPath = path26.isAbsolute(filePath) ? filePath : path26.resolve(directory, filePath);
+    const resolvedPath = path25.isAbsolute(filePath) ? filePath : path25.resolve(directory, filePath);
     if (!fs20.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
@@ -46014,10 +46590,10 @@ function validatePath(inputPath, baseDir) {
   if (!inputPath || inputPath.length === 0) {
     return "path is required";
   }
-  const resolved = path27.resolve(baseDir, inputPath);
-  const baseResolved = path27.resolve(baseDir);
-  const relative3 = path27.relative(baseResolved, resolved);
-  if (relative3.startsWith("..") || path27.isAbsolute(relative3)) {
+  const resolved = path26.resolve(baseDir, inputPath);
+  const baseResolved = path26.resolve(baseDir);
+  const relative3 = path26.relative(baseResolved, resolved);
+  if (relative3.startsWith("..") || path26.isAbsolute(relative3)) {
     return "path traversal detected";
   }
   return null;
@@ -46139,7 +46715,7 @@ async function runPreCheckBatch(input) {
         warn(`pre_check_batch: Invalid file path: ${file3}`);
         continue;
       }
-      changedFiles.push(path27.resolve(directory, file3));
+      changedFiles.push(path26.resolve(directory, file3));
     }
   } else {
     changedFiles = [];
@@ -46330,7 +46906,7 @@ var retrieve_summary = tool({
 init_dist();
 init_manager();
 import * as fs21 from "fs";
-import * as path28 from "path";
+import * as path27 from "path";
 
 // src/sbom/detectors/dart.ts
 function parsePubspecLock(content) {
@@ -47177,7 +47753,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs21.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path28.join(dir, entry.name);
+        const fullPath = path27.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -47187,7 +47763,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(path28.relative(cwd, fullPath));
+              manifestFiles.push(path27.relative(cwd, fullPath));
               break;
             }
           }
@@ -47206,12 +47782,12 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs21.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path28.join(dir, entry.name);
+        const fullPath = path27.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(path28.relative(workingDir, fullPath));
+              found.push(path27.relative(workingDir, fullPath));
               break;
             }
           }
@@ -47224,11 +47800,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path28.dirname(file3);
+    let currentDir = path27.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path28.sep) {
-        dirs.add(path28.join(workingDir, currentDir));
-        const parent = path28.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path27.sep) {
+        dirs.add(path27.join(workingDir, currentDir));
+        const parent = path27.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -47335,7 +47911,7 @@ var sbom_generate = tool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path28.isAbsolute(manifestFile) ? manifestFile : path28.join(workingDir, manifestFile);
+        const fullPath = path27.isAbsolute(manifestFile) ? manifestFile : path27.join(workingDir, manifestFile);
         if (!fs21.existsSync(fullPath)) {
           continue;
         }
@@ -47352,7 +47928,7 @@ var sbom_generate = tool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path28.join(outputDir, filename);
+    const outputPath = path27.join(outputDir, filename);
     fs21.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -47395,7 +47971,7 @@ var sbom_generate = tool({
 // src/tools/schema-drift.ts
 init_dist();
 import * as fs22 from "fs";
-import * as path29 from "path";
+import * as path28 from "path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -47427,12 +48003,12 @@ function normalizePath(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path29.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path29.sep) ? cwd : cwd + path29.sep;
+    const resolvedPath = path28.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path28.sep) ? cwd : cwd + path28.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path29.extname(resolvedPath).toLowerCase();
+    const ext = path28.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -47446,7 +48022,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path29.resolve(cwd, candidate);
+    const candidatePath = path28.resolve(cwd, candidate);
     if (fs22.existsSync(candidatePath)) {
       const stats = fs22.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
@@ -47458,7 +48034,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs22.readFileSync(specFile, "utf-8");
-  const ext = path29.extname(specFile).toLowerCase();
+  const ext = path28.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -47529,7 +48105,7 @@ function extractRoutes(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path29.join(dir, entry.name);
+      const fullPath = path28.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -47539,7 +48115,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path29.extname(entry.name).toLowerCase();
+        const ext = path28.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -47708,7 +48284,7 @@ init_secretscan();
 // src/tools/symbols.ts
 init_tool();
 import * as fs23 from "fs";
-import * as path30 from "path";
+import * as path29 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) {
@@ -47737,11 +48313,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path30.resolve(workspace, filePath);
+    const resolvedPath = path29.resolve(workspace, filePath);
     const realWorkspace = fs23.realpathSync(workspace);
     const realResolvedPath = fs23.realpathSync(resolvedPath);
-    const relativePath = path30.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path30.isAbsolute(relativePath)) {
+    const relativePath = path29.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path29.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -47753,7 +48329,7 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path30.join(cwd, filePath);
+  const fullPath = path29.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -47905,7 +48481,7 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path30.join(cwd, filePath);
+  const fullPath = path29.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -47987,7 +48563,7 @@ var symbols = tool({
       }, null, 2);
     }
     const cwd = process.cwd();
-    const ext = path30.extname(file3);
+    const ext = path29.extname(file3);
     if (containsControlCharacters(file3)) {
       return JSON.stringify({
         file: file3,
@@ -48056,7 +48632,7 @@ init_test_runner();
 // src/tools/todo-extract.ts
 init_dist();
 import * as fs24 from "fs";
-import * as path31 from "path";
+import * as path30 from "path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS2 = new Set([
@@ -48127,9 +48703,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path31.resolve(paths);
-    const normalizedCwd = path31.resolve(cwd);
-    const normalizedResolved = path31.resolve(resolvedPath);
+    const resolvedPath = path30.resolve(paths);
+    const normalizedCwd = path30.resolve(cwd);
+    const normalizedResolved = path30.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -48145,7 +48721,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path31.extname(filePath).toLowerCase();
+  const ext = path30.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS2.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
@@ -48160,7 +48736,7 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES3.has(entry)) {
       continue;
     }
-    const fullPath = path31.join(dir, entry);
+    const fullPath = path30.join(dir, entry);
     let stat;
     try {
       stat = fs24.statSync(fullPath);
@@ -48272,7 +48848,7 @@ var todo_extract = tool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path31.extname(scanPath)}`,
+          error: `unsupported file extension: ${path30.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -48387,7 +48963,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 = path32.resolve(ctx.directory, ".swarm");
+    const swarmDir = path31.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -48490,6 +49066,7 @@ var OpenCodeSwarm = async (ctx) => {
       lint,
       diff,
       pkg_audit,
+      phase_complete,
       pre_check_batch,
       retrieve_summary,
       schema_drift,
@@ -48507,7 +49084,7 @@ var OpenCodeSwarm = async (ctx) => {
       opencodeConfig.command = {
         ...opencodeConfig.command || {},
         swarm: {
-          template: 'The /swarm command has been processed by the plugin handler. Acknowledge with: "Done." Do not take any further action. User input was: $ARGUMENTS',
+          template: "/swarm $ARGUMENTS",
           description: "Swarm management commands"
         }
       };