opencode-swarm 6.30.2 → 6.31.1

package/dist/index.js

@@ -14437,7 +14437,7 @@ function resolveGuardrailsConfig(config2, agentName) {
   };
   return resolved;
 }
-var KNOWN_SWARM_PREFIXES, SEPARATORS, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, CuratorConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PluginConfigSchema;
+var KNOWN_SWARM_PREFIXES, SEPARATORS, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, CuratorConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PluginConfigSchema;
 var init_schema = __esm(() => {
   init_zod();
   init_constants();
@@ -14807,6 +14807,15 @@ var init_schema = __esm(() => {
     }).optional(),
     profiles: exports_external.record(exports_external.string(), GuardrailsProfileSchema).optional()
   });
+  WatchdogConfigSchema = exports_external.object({
+    scope_guard: exports_external.boolean().default(true),
+    skip_in_turbo: exports_external.boolean().default(false),
+    delegation_ledger: exports_external.boolean().default(true)
+  });
+  SelfReviewConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(true),
+    skip_in_turbo: exports_external.boolean().default(true)
+  });
   ToolFilterConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
     overrides: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).default({})
@@ -14878,7 +14887,8 @@ var init_schema = __esm(() => {
     enabled: exports_external.boolean().default(true),
     classThreshold: exports_external.number().int().min(1).default(3),
     commentStripThreshold: exports_external.number().int().min(1).default(5),
-    diffLineThreshold: exports_external.number().int().min(10).default(200)
+    diffLineThreshold: exports_external.number().int().min(10).default(200),
+    importHygieneThreshold: exports_external.number().int().min(1).default(2)
   });
   IncrementalVerifyConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
@@ -14905,6 +14915,8 @@ var init_schema = __esm(() => {
     gates: GateConfigSchema.optional(),
     context_budget: ContextBudgetConfigSchema.optional(),
     guardrails: GuardrailsConfigSchema.optional(),
+    watchdog: WatchdogConfigSchema.optional(),
+    self_review: SelfReviewConfigSchema.optional(),
     tool_filter: ToolFilterConfigSchema.optional(),
     plan_cursor: PlanCursorConfigSchema.optional(),
     evidence: EvidenceConfigSchema.optional(),
@@ -33414,14 +33426,14 @@ function detectAdditionalLinter(cwd) {
   return null;
 }
 async function detectAvailableLinter(directory) {
-  const DETECT_TIMEOUT = 2000;
-  const projectDir = directory ?? process.cwd();
+  const _DETECT_TIMEOUT = 2000;
+  const projectDir = directory || process.cwd();
   const isWindows = process.platform === "win32";
   const biomeBin = isWindows ? path22.join(projectDir, "node_modules", ".bin", "biome.EXE") : path22.join(projectDir, "node_modules", ".bin", "biome");
   const eslintBin = isWindows ? path22.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path22.join(projectDir, "node_modules", ".bin", "eslint");
   return _detectAvailableLinter(projectDir, biomeBin, eslintBin);
 }
-async function _detectAvailableLinter(projectDir, biomeBin, eslintBin) {
+async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
   const DETECT_TIMEOUT = 2000;
   try {
     const biomeProc = Bun.spawn(["npx", "biome", "--version"], {
@@ -33962,6 +33974,7 @@ async function runSecretscan(directory) {
 var MAX_FILE_PATH_LENGTH = 500, MAX_FILE_SIZE_BYTES, MAX_FILES_SCANNED = 1000, MAX_FINDINGS = 100, MAX_OUTPUT_BYTES2 = 512000, MAX_LINE_LENGTH = 1e4, MAX_CONTENT_BYTES, BINARY_SIGNATURES, BINARY_PREFIX_BYTES = 4, BINARY_NULL_CHECK_BYTES = 8192, BINARY_NULL_THRESHOLD = 0.1, DEFAULT_EXCLUDE_DIRS, DEFAULT_EXCLUDE_EXTENSIONS, SECRET_PATTERNS, O_NOFOLLOW, secretscan;
 var init_secretscan = __esm(() => {
   init_dist();
+  init_create_tool();
   MAX_FILE_SIZE_BYTES = 512 * 1024;
   MAX_CONTENT_BYTES = 50 * 1024;
   BINARY_SIGNATURES = [
@@ -34134,19 +34147,20 @@ var init_secretscan = __esm(() => {
     }
   ];
   O_NOFOLLOW = process.platform !== "win32" ? fs11.constants.O_NOFOLLOW : undefined;
-  secretscan = tool({
+  secretscan = createSwarmTool({
     description: "Scan directory for potential secrets (API keys, tokens, passwords) using regex patterns and entropy heuristics. Returns metadata-only findings with redacted previews - NEVER returns raw secrets. Excludes common directories (node_modules, .git, dist, etc.) by default. Supports glob patterns (e.g. **/.svelte-kit/**, **/*.test.ts) and reads .secretscanignore at the scan root.",
     args: {
       directory: tool.schema.string().describe('Directory to scan for secrets (e.g., "." or "./src")'),
       exclude: tool.schema.array(tool.schema.string()).optional().describe("Patterns to exclude: plain directory names (e.g. node_modules), relative paths, or globs (e.g. **/.svelte-kit/**, **/*.test.ts). Added to default exclusions.")
     },
-    async execute(args2, _context) {
+    async execute(args2, _directory, _ctx) {
+      const typedArgs = args2;
       let directory;
       let exclude;
       try {
-        if (args2 && typeof args2 === "object") {
-          directory = args2.directory;
-          exclude = args2.exclude;
+        if (typedArgs && typeof typedArgs === "object") {
+          directory = typedArgs.directory;
+          exclude = typedArgs.exclude;
         }
       } catch {}
       if (directory === undefined) {
@@ -35001,7 +35015,7 @@ function parseTestOutput(framework, output) {
   return { totals, coveragePercent };
 }
 async function runTests(framework, scope, files, coverage, timeout_ms, cwd) {
-  const command = buildTestCommand(framework, scope, files, coverage, cwd ?? process.cwd());
+  const command = buildTestCommand(framework, scope, files, coverage, cwd);
   if (!command) {
     return {
       success: false,
@@ -35026,7 +35040,7 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd) {
     const proc = Bun.spawn(command, {
       stdout: "pipe",
       stderr: "pipe",
-      cwd: cwd || process.cwd()
+      cwd
     });
     const exitPromise = proc.exited;
     const timeoutPromise = new Promise((resolve8) => setTimeout(() => {
@@ -35558,7 +35572,7 @@ async function runLintCheck(dir, linter, timeoutMs) {
 async function runTestsCheck(_dir, scope, timeoutMs) {
   const startTime = Date.now();
   try {
-    const result = await runTests("none", scope, [], false, timeoutMs);
+    const result = await runTests("none", scope, [], false, timeoutMs, _dir);
     if (!result.success) {
       return {
         type: "tests",
@@ -37581,8 +37595,8 @@ ${JSON.stringify(symbolNames, null, 2)}`);
       var moduleRtn;
       var Module = moduleArg;
       var readyPromiseResolve, readyPromiseReject;
-      var readyPromise = new Promise((resolve15, reject) => {
-        readyPromiseResolve = resolve15;
+      var readyPromise = new Promise((resolve16, reject) => {
+        readyPromiseResolve = resolve16;
         readyPromiseReject = reject;
       });
       var ENVIRONMENT_IS_WEB = typeof window == "object";
@@ -37604,11 +37618,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path46) {
+      function locateFile(path47) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path46, scriptDirectory);
+          return Module["locateFile"](path47, scriptDirectory);
         }
-        return scriptDirectory + path46;
+        return scriptDirectory + path47;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -37662,13 +37676,13 @@ ${JSON.stringify(symbolNames, null, 2)}`);
           }
           readAsync = /* @__PURE__ */ __name(async (url3) => {
             if (isFileURI(url3)) {
-              return new Promise((resolve15, reject) => {
+              return new Promise((resolve16, reject) => {
                 var xhr = new XMLHttpRequest;
                 xhr.open("GET", url3, true);
                 xhr.responseType = "arraybuffer";
                 xhr.onload = () => {
                   if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                    resolve15(xhr.response);
+                    resolve16(xhr.response);
                     return;
                   }
                   reject(xhr.status);
@@ -37888,10 +37902,10 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         __name(receiveInstantiationResult, "receiveInstantiationResult");
         var info2 = getWasmImports();
         if (Module["instantiateWasm"]) {
-          return new Promise((resolve15, reject) => {
+          return new Promise((resolve16, reject) => {
             Module["instantiateWasm"](info2, (mod, inst) => {
               receiveInstance(mod, inst);
-              resolve15(mod.exports);
+              resolve16(mod.exports);
             });
           });
         }
@@ -39356,7 +39370,7 @@ var init_runtime = __esm(() => {
 });
 
 // src/index.ts
-import * as path56 from "path";
+import * as path57 from "path";
 
 // src/agents/index.ts
 init_config();
@@ -39664,8 +39678,6 @@ function planStatusToWorkflowState(status) {
       return "coder_delegated";
     case "completed":
       return "complete";
-    case "pending":
-    case "blocked":
     default:
       return "idle";
   }
@@ -39679,10 +39691,10 @@ function evidenceToWorkflowState(evidence) {
       return "complete";
     }
   }
-  if (gates["test_engineer"] != null) {
+  if (gates.test_engineer != null) {
     return "tests_run";
   }
-  if (gates["reviewer"] != null) {
+  if (gates.reviewer != null) {
     return "reviewer_run";
   }
   if (Object.keys(gates).length > 0) {
@@ -42765,7 +42777,10 @@ class PlanSyncWorker {
   lastStat = null;
   disposed = false;
   constructor(options = {}) {
-    this.directory = options.directory ?? process.cwd();
+    if (!options.directory) {
+      console.warn("[plan-sync-worker] No directory provided, falling back to process.cwd()");
+    }
+    this.directory = options.directory || process.cwd();
     this.debounceMs = options.debounceMs ?? 300;
     this.pollIntervalMs = options.pollIntervalMs ?? 2000;
     this.syncTimeoutMs = options.syncTimeoutMs ?? 30000;
@@ -49210,6 +49225,7 @@ function createCompactionCustomizerHook(config3, directory) {
           output.context.push(`[SWARM PATTERNS] ${patterns}`);
         }
       }
+      output.context.push("[KNOWLEDGE TOOLS] You have persistent knowledge tools: knowledge_recall (search for relevant past decisions), knowledge_add (store a new lesson), knowledge_remove (delete outdated entries). Use knowledge_recall when past context would help.");
     })
   };
 }
@@ -49870,10 +49886,11 @@ function createGuardrailsHooks(directoryOrConfig, config3) {
   let directory;
   let guardrailsConfig;
   if (directoryOrConfig && typeof directoryOrConfig === "object" && "enabled" in directoryOrConfig) {
+    console.warn("[guardrails] Legacy call without directory, falling back to process.cwd()");
     directory = process.cwd();
     guardrailsConfig = directoryOrConfig;
   } else {
-    directory = directoryOrConfig ?? process.cwd();
+    directory = directoryOrConfig || process.cwd();
     guardrailsConfig = config3;
   }
   if (guardrailsConfig?.enabled === false) {
@@ -49925,9 +49942,27 @@ function createGuardrailsHooks(directoryOrConfig, config3) {
           const agentName2 = typeof loopArgs?.subagent_type === "string" ? loopArgs.subagent_type : "agent";
           const loopSession = swarmState.agentSessions.get(input.sessionID);
           if (loopSession) {
+            const loopPattern = loopResult.pattern;
+            const modifiedFiles = loopSession.modifiedFilesThisCoderTask ?? [];
+            const accomplishmentSummary = modifiedFiles.length > 0 ? `Modified ${modifiedFiles.length} file(s): ${modifiedFiles.slice(0, 3).join(", ")}${modifiedFiles.length > 3 ? "..." : ""}` : "No files modified yet";
+            const alternativeSuggestions = {
+              coder: "Try a different task spec, simplify the constraint, or escalate to user",
+              reviewer: "Try a different review dimension or escalate to user",
+              test_engineer: "Run a specific test file with targeted scope",
+              explorer: "Narrow the search scope or check a specific file directly"
+            };
+            const cleanAgent = stripKnownSwarmPrefix(agentName2).toLowerCase();
+            const suggestion = alternativeSuggestions[cleanAgent] ?? "Try a different agent, different instructions, or escalate to the user";
             loopSession.loopWarningPending = {
               agent: agentName2,
-              message: `LOOP DETECTED: You have delegated to ${agentName2} with the same pattern 3 times. Change your approach \u2014 try a different agent, different instructions, or escalate to the user.`,
+              message: [
+                `LOOP DETECTED: Pattern "${loopPattern}" repeated 3 times.`,
+                `Agent: ${agentName2}`,
+                `Accomplished: ${accomplishmentSummary}`,
+                `Suggested action: ${suggestion}`,
+                `If still stuck after trying alternatives, escalate to the user.`
+              ].join(`
+`),
               timestamp: Date.now()
             };
           }
@@ -50326,7 +50361,7 @@ ${pending.message}
 ${joined}
 [/ADVISORIES]
 
-` + textPart2.text;
+${textPart2.text}`;
         }
         session.pendingAdvisoryMessages = [];
       } else if (!isArchitectSession && session && (session.pendingAdvisoryMessages?.length ?? 0) > 0) {
@@ -51346,7 +51381,7 @@ function createPipelineTrackerHook(config3, directory) {
         return;
       let phaseNumber = null;
       try {
-        const plan = await loadPlan(directory ?? process.cwd());
+        const plan = await loadPlan(directory || process.cwd());
         if (plan) {
           const phaseString = extractCurrentPhaseFromPlan2(plan);
           phaseNumber = parsePhaseNumber(phaseString);
@@ -52993,6 +53028,97 @@ function createDarkMatterDetectorHook(directory) {
   return safeHook(hook);
 }
 
+// src/hooks/delegation-ledger.ts
+var ledgerBySession = new Map;
+var callStartTimes = new Map;
+function createDelegationLedgerHook(config3, _directory, injectAdvisory) {
+  const enabled = config3.enabled ?? true;
+  return {
+    toolAfter: async (input, output) => {
+      if (!enabled)
+        return;
+      const sessionId = input.sessionID;
+      const startKey = `${sessionId}:${input.callID}`;
+      const startTime = callStartTimes.get(startKey) ?? Date.now();
+      callStartTimes.delete(startKey);
+      const duration_ms = Date.now() - startTime;
+      const args2 = input.args ?? {};
+      const file3 = typeof args2.path === "string" ? args2.path : typeof args2.filePath === "string" ? args2.filePath : typeof args2.file === "string" ? args2.file : undefined;
+      const session = swarmState.agentSessions.get(sessionId);
+      const agentName = swarmState.activeAgent?.get(sessionId) ?? session?.agentName ?? "unknown";
+      const outputStr = String(output.output ?? "");
+      const success3 = !outputStr.startsWith("Error:") && !outputStr.startsWith("error: ");
+      const entry = {
+        agent: agentName,
+        tool: input.tool,
+        file: file3,
+        duration_ms,
+        success: success3,
+        timestamp: Date.now()
+      };
+      const existing = ledgerBySession.get(sessionId) ?? [];
+      existing.push(entry);
+      ledgerBySession.set(sessionId, existing);
+    },
+    onArchitectResume: (architectSessionId) => {
+      if (!enabled)
+        return;
+      const allEntries = [];
+      for (const [sessionId, entries] of ledgerBySession) {
+        if (sessionId === architectSessionId)
+          continue;
+        allEntries.push(...entries);
+      }
+      if (allEntries.length === 0)
+        return;
+      for (const sessionId of ledgerBySession.keys()) {
+        if (sessionId !== architectSessionId) {
+          ledgerBySession.delete(sessionId);
+        }
+      }
+      const toolCallCount = allEntries.length;
+      const filesModified = [
+        ...new Set(allEntries.filter((e) => isWriteTool2(e.tool) && e.file).map((e) => e.file))
+      ];
+      const filesRead = [
+        ...new Set(allEntries.filter((e) => isReadTool(e.tool) && e.file).map((e) => e.file))
+      ];
+      const failedCalls = allEntries.filter((e) => !e.success).length;
+      const scopeViolations = allEntries.filter((e) => e.tool.includes("scope")).length;
+      const summary = [
+        `DELEGATION SUMMARY:`,
+        `  Tool calls: ${toolCallCount}${failedCalls > 0 ? ` (${failedCalls} failed)` : ""}`,
+        filesModified.length > 0 ? `  Files modified: ${filesModified.slice(0, 5).join(", ")}${filesModified.length > 5 ? ` (+${filesModified.length - 5} more)` : ""}` : null,
+        filesRead.length > 0 ? `  Files read: ${filesRead.slice(0, 5).join(", ")}${filesRead.length > 5 ? ` (+${filesRead.length - 5} more)` : ""}` : null,
+        scopeViolations > 0 ? `  \u26A0\uFE0F  ${scopeViolations} scope violation(s) detected` : null
+      ].filter(Boolean).join(`
+`);
+      try {
+        injectAdvisory(architectSessionId, summary);
+      } catch {}
+    }
+  };
+}
+var WRITE_TOOL_PATTERNS = [
+  "write",
+  "edit",
+  "patch",
+  "create",
+  "insert",
+  "replace",
+  "append",
+  "prepend"
+];
+function isWriteTool2(toolName) {
+  const normalized = toolName.replace(/^[^:]+[:.]/, "").toLowerCase();
+  return WRITE_TOOL_PATTERNS.some((p) => normalized.includes(p));
+}
+var READ_TOOL_PATTERNS = ["read", "cat", "view", "fetch", "get"];
+function isReadTool(toolName) {
+  const normalized = toolName.replace(/^[^:]+[:.]/, "").toLowerCase();
+  return READ_TOOL_PATTERNS.some((p) => normalized.includes(p));
+}
+
 // src/hooks/incremental-verify.ts
 import * as fs21 from "fs";
 import * as path34 from "path";
@@ -53851,7 +53977,7 @@ async function writeDriftReport(directory, report) {
   }
   return filePath;
 }
-async function runCriticDriftCheck(directory, phase, curatorResult, config3) {
+async function runCriticDriftCheck(directory, phase, curatorResult, config3, injectAdvisory) {
   try {
     const planMd = await readSwarmFileAsync(directory, "plan.md");
     const specMd = await readSwarmFileAsync(directory, "spec.md");
@@ -53911,6 +54037,12 @@ async function runCriticDriftCheck(directory, phase, curatorResult, config3) {
       drift_score: driftScore,
       report_path: reportPath
     });
+    if (injectAdvisory && alignment !== "ALIGNED" && driftScore > 0) {
+      try {
+        const advisoryText = `CURATOR DRIFT DETECTED (phase ${phase}, score ${driftScore.toFixed(2)}): ${injectionSummary.slice(0, 300)}. Review .swarm/${DRIFT_REPORT_PREFIX}${phase}.json and address spec alignment before proceeding.`;
+        injectAdvisory(advisoryText);
+      } catch {}
+    }
     const injectionText = injectionSummary;
     return {
       phase,
@@ -54110,9 +54242,127 @@ ${injectionText}`;
   });
 }
 
+// src/hooks/scope-guard.ts
+init_constants();
+init_schema();
+import * as path37 from "path";
+var WRITE_TOOLS = new Set([
+  "write",
+  "edit",
+  "patch",
+  "apply_patch",
+  "create_file",
+  "insert",
+  "replace",
+  "append",
+  "prepend"
+]);
+function createScopeGuardHook(config3, _directory, injectAdvisory) {
+  const enabled = config3.enabled ?? true;
+  const _skipInTurbo = config3.skip_in_turbo ?? false;
+  return {
+    toolBefore: async (input, output) => {
+      if (!enabled)
+        return;
+      const toolName = input.tool.replace(/^[^:]+[:.]/, "");
+      if (!WRITE_TOOLS.has(toolName))
+        return;
+      const sessionId = input.sessionID;
+      const activeAgent = swarmState.activeAgent.get(sessionId);
+      const session = swarmState.agentSessions.get(sessionId);
+      const agentName = activeAgent ?? session?.agentName ?? "unknown";
+      const isArchitect2 = stripKnownSwarmPrefix(agentName) === ORCHESTRATOR_NAME;
+      if (isArchitect2)
+        return;
+      const declaredScope = session?.declaredCoderScope;
+      if (!declaredScope || declaredScope.length === 0)
+        return;
+      const argsObj = output.args;
+      const rawFilePath = argsObj?.path ?? argsObj?.filePath ?? argsObj?.file;
+      if (typeof rawFilePath !== "string" || !rawFilePath)
+        return;
+      const filePath = rawFilePath.replace(/[\r\n\t]/g, "_").split(String.fromCharCode(27)).join("_").replace(/\[[\d;]*m/g, "");
+      if (!isFileInScope(filePath, declaredScope)) {
+        const taskId = session?.currentTaskId ?? "unknown";
+        const violationMessage = `SCOPE VIOLATION: ${agentName} attempted to modify '${filePath}' which is not in declared scope for task ${taskId}. Declared scope: [${declaredScope.slice(0, 3).join(", ")}${declaredScope.length > 3 ? "..." : ""}]`;
+        if (session) {
+          session.lastScopeViolation = violationMessage;
+          session.scopeViolationDetected = true;
+        }
+        if (injectAdvisory) {
+          for (const [archSessionId, archSession] of swarmState.agentSessions) {
+            const archAgent = swarmState.activeAgent.get(archSessionId) ?? archSession.agentName;
+            if (stripKnownSwarmPrefix(archAgent) === ORCHESTRATOR_NAME) {
+              try {
+                injectAdvisory(archSessionId, `[SCOPE GUARD] ${violationMessage}`);
+              } catch {}
+              break;
+            }
+          }
+        }
+        throw new Error(violationMessage);
+      }
+    }
+  };
+}
+function isFileInScope(filePath, scopeEntries) {
+  const resolvedFile = path37.resolve(filePath);
+  return scopeEntries.some((scope) => {
+    const resolvedScope = path37.resolve(scope);
+    if (resolvedFile === resolvedScope)
+      return true;
+    const rel = path37.relative(resolvedScope, resolvedFile);
+    return rel.length > 0 && !rel.startsWith("..") && !path37.isAbsolute(rel);
+  });
+}
+
+// src/hooks/self-review.ts
+init_constants();
+init_schema();
+function createSelfReviewHook(config3, injectAdvisory) {
+  const enabled = config3.enabled ?? true;
+  const skipInTurbo = config3.skip_in_turbo ?? true;
+  return {
+    toolAfter: async (input, output) => {
+      if (!enabled)
+        return;
+      const toolName = input.tool.replace(/^[^:]+[:.]/, "");
+      if (toolName !== "update_task_status")
+        return;
+      const args2 = output.args;
+      if (args2?.status !== "in_progress")
+        return;
+      const taskId = typeof args2?.task_id === "string" ? args2.task_id : "unknown";
+      const sessionId = input.sessionID;
+      const agentName = swarmState.activeAgent.get(sessionId) ?? swarmState.agentSessions.get(sessionId)?.agentName ?? "";
+      if (stripKnownSwarmPrefix(agentName) !== ORCHESTRATOR_NAME)
+        return;
+      if (skipInTurbo) {
+        const session = swarmState.agentSessions.get(sessionId);
+        if (session && session.turboMode === true)
+          return;
+      }
+      const advisory = [
+        `[SELF-REVIEW] Task ${taskId} is now delegated to coder.`,
+        `After coder completes, review for:`,
+        `  \u2022 Broken conditionals (inverted if/else, wrong comparisons)`,
+        `  \u2022 Off-by-one errors (array bounds, loop indices)`,
+        `  \u2022 Assumptions contradicting existing codebase patterns`,
+        `  \u2022 Missing error handling (uncaught exceptions, unhandled promises)`,
+        `  \u2022 Scope creep (changes outside the declared task spec)`,
+        `Delegate to critic with self-review focus before marking complete.`
+      ].join(`
+`);
+      try {
+        injectAdvisory(sessionId, advisory);
+      } catch {}
+    }
+  };
+}
+
 // src/hooks/slop-detector.ts
 import * as fs23 from "fs";
-import * as path37 from "path";
+import * as path38 from "path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
   "edit",
@@ -54162,7 +54412,7 @@ function walkFiles(dir, exts, deadline) {
         break;
       if (entry.isSymbolicLink())
         continue;
-      const full = path37.join(dir, entry.name);
+      const full = path38.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git")
           continue;
@@ -54177,7 +54427,7 @@ function walkFiles(dir, exts, deadline) {
   return results;
 }
 function checkDeadExports(content, projectDir, startTime) {
-  const hasPackageJson = fs23.existsSync(path37.join(projectDir, "package.json"));
+  const hasPackageJson = fs23.existsSync(path38.join(projectDir, "package.json"));
   if (!hasPackageJson)
     return null;
   const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
@@ -54217,6 +54467,61 @@ function checkDeadExports(content, projectDir, startTime) {
     detail: `New exports not found in any import: ${deadExports.slice(0, 3).join(", ")}. Verify these are intentionally exported.`
   };
 }
+function checkStaleImports(content, threshold) {
+  const lines = content.split(`
+`);
+  const importLines = [];
+  const importIdentifiers = [];
+  const namedImportRe = /^(?:\+)?import\s*\{([^}]+)\}\s*from\s*['"][^'"]+['"]/;
+  const defaultImportRe = /^(?:\+)?import\s+(\w+)\s+from\s*['"][^'"]+['"]/;
+  const nsImportRe = /^(?:\+)?import\s+\*\s+as\s+(\w+)\s+from\s*['"][^'"]+['"]/;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const line = lines[i2].replace(/^[+-]/, "");
+    const trimmed = line.trim();
+    if (trimmed.startsWith("export {") || trimmed.startsWith("export type {"))
+      continue;
+    const named = namedImportRe.exec(trimmed);
+    if (named) {
+      importLines.push(i2);
+      for (const part of named[1].split(",")) {
+        const cleaned = part.trim().replace(/^type\s+/, "").split(/\s+as\s+/).pop()?.trim();
+        if (cleaned && /^\w+$/.test(cleaned) && cleaned.length >= 2) {
+          importIdentifiers.push(cleaned);
+        }
+      }
+      continue;
+    }
+    const ns = nsImportRe.exec(trimmed);
+    if (ns?.[1]) {
+      importLines.push(i2);
+      importIdentifiers.push(ns[1]);
+      continue;
+    }
+    const def = defaultImportRe.exec(trimmed);
+    if (def?.[1] && def[1] !== "type") {
+      importLines.push(i2);
+      importIdentifiers.push(def[1]);
+    }
+  }
+  if (importIdentifiers.length === 0)
+    return null;
+  const bodyLines = lines.filter((_, i2) => !importLines.includes(i2));
+  const body2 = bodyLines.join(`
+`);
+  const staleImports = [];
+  for (const id of importIdentifiers) {
+    const usageRe = new RegExp(`\\b${id}\\b`);
+    if (!usageRe.test(body2)) {
+      staleImports.push(id);
+    }
+  }
+  if (staleImports.length < threshold)
+    return null;
+  return {
+    type: "stale_import",
+    detail: `${staleImports.length} unused import identifier(s): ${staleImports.slice(0, 3).join(", ")}${staleImports.length > 3 ? "..." : ""}. Remove stale imports.`
+  };
+}
 function createSlopDetectorHook(config3, projectDir, injectSystemMessage) {
   return {
     toolAfter: async (input, output) => {
@@ -54259,6 +54564,11 @@ function createSlopDetectorHook(config3, projectDir, injectSystemMessage) {
             findings.push(dead);
         } catch {}
       }
+      try {
+        const stale = checkStaleImports(content, config3.importHygieneThreshold ?? 2);
+        if (stale)
+          findings.push(stale);
+      } catch {}
       if (findings.length === 0)
         return;
       const findingText = findings.map((f) => `  \u2022 ${f.type}: ${f.detail}`).join(`
@@ -54640,7 +54950,7 @@ var build_check = createSwarmTool({
 init_dist();
 init_create_tool();
 import * as fs25 from "fs";
-import * as path38 from "path";
+import * as path39 from "path";
 var EVIDENCE_DIR = ".swarm/evidence";
 var TASK_ID_PATTERN2 = /^\d+\.\d+(\.\d+)*$/;
 function isValidTaskId3(taskId) {
@@ -54657,9 +54967,9 @@ function isValidTaskId3(taskId) {
   return TASK_ID_PATTERN2.test(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path38.resolve(workspaceRoot);
-  const swarmPath = path38.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path38.resolve(filePath);
+  const normalizedWorkspace = path39.resolve(workspaceRoot);
+  const swarmPath = path39.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path39.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
@@ -54720,7 +55030,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path38.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path39.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -54780,7 +55090,7 @@ var check_gate_status = createSwarmTool({
 init_dist();
 init_create_tool();
 import * as fs26 from "fs";
-import * as path39 from "path";
+import * as path40 from "path";
 var MAX_FILE_SIZE_BYTES2 = 256 * 1024;
 var DEFAULT_DAYS = 90;
 var DEFAULT_TOP_N = 20;
@@ -54924,7 +55234,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 = path39.extname(file3).toLowerCase();
+    const ext = path40.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -54935,7 +55245,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
     if (!fs26.existsSync(fullPath)) {
-      fullPath = path39.join(cwd, file3);
+      fullPath = path40.join(cwd, file3);
     }
     const complexity = getComplexityForFile(fullPath);
     if (complexity !== null) {
@@ -55080,10 +55390,71 @@ var complexity_hotspots = createSwarmTool({
     }
   }
 });
+// src/tools/curator-analyze.ts
+init_dist();
+init_config();
+init_schema();
+init_create_tool();
+var curator_analyze = createSwarmTool({
+  description: "Run curator phase analysis and optionally apply knowledge recommendations. " + "Call this after reviewing a phase to apply knowledge updates. " + "If recommendations is provided, applies them via applyCuratorKnowledgeUpdates.",
+  args: {
+    phase: tool.schema.number().int().min(1).describe("Phase number to analyze"),
+    recommendations: tool.schema.array(tool.schema.object({
+      action: tool.schema.enum([
+        "promote",
+        "archive",
+        "flag_contradiction"
+      ]),
+      entry_id: tool.schema.string().optional(),
+      lesson: tool.schema.string(),
+      reason: tool.schema.string()
+    })).optional().describe("Knowledge recommendations to apply. If omitted, only collects digest data.")
+  },
+  execute: async (args2, directory) => {
+    const typedArgs = args2;
+    try {
+      if (!Number.isInteger(typedArgs.phase) || typedArgs.phase < 1) {
+        return JSON.stringify({ error: "phase must be a positive integer >= 1" }, null, 2);
+      }
+      if (typedArgs.recommendations) {
+        const validActions = ["promote", "archive", "flag_contradiction"];
+        for (const rec of typedArgs.recommendations) {
+          if (!validActions.includes(rec.action)) {
+            return JSON.stringify({
+              error: `Invalid recommendation action: ${rec.action}`
+            }, null, 2);
+          }
+        }
+      }
+      const { config: config3 } = loadPluginConfigWithMeta(directory);
+      const curatorConfig = CuratorConfigSchema.parse(config3.curator ?? {});
+      const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
+      const curatorResult = await runCuratorPhase(directory, typedArgs.phase, [], curatorConfig, {});
+      let applied = 0;
+      let skipped = 0;
+      if (typedArgs.recommendations && typedArgs.recommendations.length > 0) {
+        const result = await applyCuratorKnowledgeUpdates(directory, typedArgs.recommendations, knowledgeConfig);
+        applied = result.applied;
+        skipped = result.skipped;
+      }
+      return JSON.stringify({
+        phase_digest: curatorResult.digest,
+        compliance_count: curatorResult.compliance.length,
+        applied,
+        skipped
+      }, null, 2);
+    } catch (error93) {
+      return JSON.stringify({
+        error: String(error93),
+        phase: typedArgs.phase
+      }, null, 2);
+    }
+  }
+});
 // src/tools/declare-scope.ts
 init_tool();
 import * as fs27 from "fs";
-import * as path40 from "path";
+import * as path41 from "path";
 init_create_tool();
 function validateTaskIdFormat(taskId) {
   const taskIdPattern = /^\d+\.\d+(\.\d+)*$/;
@@ -55162,8 +55533,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path40.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path40.sep);
+    normalizedDir = path41.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path41.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -55173,10 +55544,10 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path40.resolve(normalizedDir);
+    const resolvedDir = path41.resolve(normalizedDir);
     try {
       const realPath = fs27.realpathSync(resolvedDir);
-      const planPath2 = path40.join(realPath, ".swarm", "plan.json");
+      const planPath2 = path41.join(realPath, ".swarm", "plan.json");
       if (!fs27.existsSync(planPath2)) {
         return {
           success: false,
@@ -55196,8 +55567,11 @@ async function executeDeclareScope(args2, fallbackDir) {
       };
     }
   }
-  const directory = normalizedDir ?? fallbackDir ?? process.cwd();
-  const planPath = path40.resolve(directory, ".swarm", "plan.json");
+  if (!fallbackDir) {
+    console.warn("[declare-scope] fallbackDir is undefined, falling back to process.cwd()");
+  }
+  const directory = normalizedDir || fallbackDir || process.cwd();
+  const planPath = path41.resolve(directory, ".swarm", "plan.json");
   if (!fs27.existsSync(planPath)) {
     return {
       success: false,
@@ -55260,6 +55634,7 @@ var declare_scope = createSwarmTool({
 });
 // src/tools/diff.ts
 init_dist();
+init_create_tool();
 import { execFileSync } from "child_process";
 var MAX_DIFF_LINES = 500;
 var DIFF_TIMEOUT_MS = 30000;
@@ -55287,34 +55662,35 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path41 of paths) {
-    if (!path41 || path41.length === 0) {
+  for (const path42 of paths) {
+    if (!path42 || path42.length === 0) {
       return "empty path not allowed";
     }
-    if (path41.length > MAX_PATH_LENGTH) {
+    if (path42.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path41)) {
+    if (SHELL_METACHARACTERS2.test(path42)) {
       return "path contains shell metacharacters";
     }
-    if (path41.startsWith("-")) {
+    if (path42.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path41)) {
+    if (CONTROL_CHAR_PATTERN2.test(path42)) {
       return "path contains control characters";
     }
   }
   return null;
 }
-var diff = tool({
+var diff = createSwarmTool({
   description: "Analyze git diff for changed files, exports, interfaces, and function signatures. Returns structured output with contract change detection.",
   args: {
     base: tool.schema.string().optional().describe('Base ref to diff against (default: HEAD). Use "staged" for staged changes, "unstaged" for working tree changes.'),
     paths: tool.schema.array(tool.schema.string()).optional().describe("Optional file paths to restrict diff scope.")
   },
-  async execute(args2, context) {
+  async execute(args2, directory, _ctx) {
+    const typedArgs = args2;
     try {
-      if (!context.directory || typeof context.directory !== "string" || context.directory.trim() === "") {
+      if (!directory || typeof directory !== "string" || directory.trim() === "") {
         const errorResult = {
           error: "project directory is required but was not provided",
           files: [],
@@ -55323,7 +55699,7 @@ var diff = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const base = args2.base ?? "HEAD";
+      const base = typedArgs.base ?? "HEAD";
       const baseValidationError = validateBase(base);
       if (baseValidationError) {
         const errorResult = {
@@ -55334,7 +55710,7 @@ var diff = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const pathsValidationError = validatePaths(args2.paths);
+      const pathsValidationError = validatePaths(typedArgs.paths);
       if (pathsValidationError) {
         const errorResult = {
           error: `invalid paths: ${pathsValidationError}`,
@@ -55354,21 +55730,21 @@ var diff = tool({
       }
       const numstatArgs = [...gitArgs, "--numstat"];
       const fullDiffArgs = [...gitArgs, "-U3"];
-      if (args2.paths?.length) {
-        numstatArgs.push("--", ...args2.paths);
-        fullDiffArgs.push("--", ...args2.paths);
+      if (typedArgs.paths?.length) {
+        numstatArgs.push("--", ...typedArgs.paths);
+        fullDiffArgs.push("--", ...typedArgs.paths);
       }
       const numstatOutput = execFileSync("git", numstatArgs, {
         encoding: "utf-8",
         timeout: DIFF_TIMEOUT_MS,
         maxBuffer: MAX_BUFFER_BYTES,
-        cwd: context.directory
+        cwd: directory
       });
       const fullDiffOutput = execFileSync("git", fullDiffArgs, {
         encoding: "utf-8",
         timeout: DIFF_TIMEOUT_MS,
         maxBuffer: MAX_BUFFER_BYTES,
-        cwd: context.directory
+        cwd: directory
       });
       const files = [];
       const numstatLines = numstatOutput.split(`
@@ -55380,8 +55756,8 @@ var diff = tool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path41 = parts2[2];
-          files.push({ path: path41, additions, deletions });
+          const path42 = parts2[2];
+          files.push({ path: path42, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -55611,7 +55987,7 @@ Use these as DOMAIN values when delegating to @sme.`;
 init_dist();
 init_create_tool();
 import * as fs28 from "fs";
-import * as path41 from "path";
+import * as path42 from "path";
 var MAX_FILE_SIZE_BYTES3 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR2 = ".swarm/evidence";
@@ -55641,9 +56017,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path41.resolve(cwd);
-  const swarmPath = path41.join(normalizedCwd, ".swarm");
-  const normalizedPath = path41.resolve(filePath);
+  const normalizedCwd = path42.resolve(cwd);
+  const swarmPath = path42.join(normalizedCwd, ".swarm");
+  const normalizedPath = path42.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -55673,10 +56049,10 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path41.join(evidenceDir, filename);
+    const filePath = path42.join(evidenceDir, filename);
     try {
-      const resolvedPath = path41.resolve(filePath);
-      const evidenceDirResolved = path41.resolve(evidenceDir);
+      const resolvedPath = path42.resolve(filePath);
+      const evidenceDirResolved = path42.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
@@ -55794,7 +56170,7 @@ var evidence_check = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0).map(normalizeEvidenceType);
-    const planPath = path41.join(cwd, PLAN_FILE);
+    const planPath = path42.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -55826,7 +56202,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path41.join(cwd, EVIDENCE_DIR2);
+    const evidenceDir = path42.join(cwd, EVIDENCE_DIR2);
     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;
@@ -55844,7 +56220,7 @@ var evidence_check = createSwarmTool({
 init_tool();
 init_create_tool();
 import * as fs29 from "fs";
-import * as path42 from "path";
+import * as path43 from "path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -55925,12 +56301,12 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path42.join(targetDir, filename);
-      const base = path42.basename(filepath, path42.extname(filepath));
-      const ext = path42.extname(filepath);
+      let filepath = path43.join(targetDir, filename);
+      const base = path43.basename(filepath, path43.extname(filepath));
+      const ext = path43.extname(filepath);
       let counter = 1;
       while (fs29.existsSync(filepath)) {
-        filepath = path42.join(targetDir, `${base}_${counter}${ext}`);
+        filepath = path43.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
@@ -55960,10 +56336,11 @@ Errors:
 });
 // src/tools/gitingest.ts
 init_dist();
+init_create_tool();
 var GITINGEST_TIMEOUT_MS = 1e4;
 var GITINGEST_MAX_RESPONSE_BYTES = 5242880;
 var GITINGEST_MAX_RETRIES = 2;
-var delay = (ms) => new Promise((resolve14) => setTimeout(resolve14, ms));
+var delay = (ms) => new Promise((resolve15) => setTimeout(resolve15, ms));
 async function fetchGitingest(args2) {
   for (let attempt = 0;attempt <= GITINGEST_MAX_RETRIES; attempt++) {
     try {
@@ -56033,7 +56410,7 @@ ${data.content}`;
   }
   throw new Error("gitingest request failed after retries");
 }
-var gitingest = tool({
+var gitingest = createSwarmTool({
   description: "Fetch a GitHub repository's full content via gitingest.com. Returns summary, directory tree, and file contents optimized for LLM analysis. Use when you need to understand an external repository's structure or code.",
   args: {
     url: tool.schema.string().describe("GitHub repository URL (e.g., https://github.com/owner/repo)"),
@@ -56041,14 +56418,16 @@ var gitingest = tool({
     pattern: tool.schema.string().optional().describe("Glob pattern to filter files (e.g., '*.ts' or 'src/**/*.py')"),
     patternType: tool.schema.enum(["include", "exclude"]).optional().describe("Whether pattern includes or excludes matching files (default: exclude)")
   },
-  async execute(args2, _context) {
-    return fetchGitingest(args2);
+  async execute(args2, _directory, _ctx) {
+    const typedArgs = args2;
+    return fetchGitingest(typedArgs);
   }
 });
 // src/tools/imports.ts
 init_dist();
+init_create_tool();
 import * as fs30 from "fs";
-import * as path43 from "path";
+import * as path44 from "path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES4 = 1024 * 1024;
@@ -56102,7 +56481,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path43.extname(filePath).toLowerCase();
+  const ext = path44.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -56126,15 +56505,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path43.resolve(targetFile);
+    _resolvedTarget = path44.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path43.basename(targetFile, path43.extname(targetFile));
+  const targetBasename = path44.basename(targetFile, path44.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path43.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path43.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path44.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path44.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];
@@ -56157,9 +56536,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path43.dirname(targetFile);
-    const targetExt = path43.extname(targetFile);
-    const targetBasenameNoExt = path43.basename(targetFile, targetExt);
+    const _targetDir = path44.dirname(targetFile);
+    const targetExt = path44.extname(targetFile);
+    const targetBasenameNoExt = path44.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, "");
@@ -56227,10 +56606,10 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
     if (SKIP_DIRECTORIES2.has(entry)) {
-      stats.skippedDirs.push(path43.join(dir, entry));
+      stats.skippedDirs.push(path44.join(dir, entry));
       continue;
     }
-    const fullPath = path43.join(dir, entry);
+    const fullPath = path44.join(dir, entry);
     let stat2;
     try {
       stat2 = fs30.statSync(fullPath);
@@ -56244,7 +56623,7 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
     if (stat2.isDirectory()) {
       findSourceFiles(fullPath, files, stats);
     } else if (stat2.isFile()) {
-      const ext = path43.extname(fullPath).toLowerCase();
+      const ext = path44.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -56252,19 +56631,20 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
   }
   return files;
 }
-var imports = tool({
+var imports = createSwarmTool({
   description: "Find all consumers that import from a given file. Returns JSON with file path, line numbers, and import metadata for each consumer. Useful for understanding dependency relationships.",
   args: {
     file: tool.schema.string().describe('Source file path to find importers for (e.g., "./src/utils.ts")'),
     symbol: tool.schema.string().optional().describe('Optional specific symbol to filter imports (e.g., "MyClass")')
   },
-  async execute(args2, _context) {
+  async execute(args2, _directory, _ctx) {
+    const typedArgs = args2;
     let file3;
     let symbol3;
     try {
-      if (args2 && typeof args2 === "object") {
-        file3 = args2.file;
-        symbol3 = args2.symbol;
+      if (typedArgs && typeof typedArgs === "object") {
+        file3 = typedArgs.file;
+        symbol3 = typedArgs.symbol;
       }
     } catch {}
     if (file3 === undefined) {
@@ -56300,7 +56680,7 @@ var imports = tool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path43.resolve(file3);
+      const targetFile = path44.resolve(file3);
       if (!fs30.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
@@ -56322,7 +56702,7 @@ var imports = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path43.dirname(targetFile);
+      const baseDir = path44.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -56405,13 +56785,120 @@ var imports = tool({
     }
   }
 });
+// src/tools/knowledge-add.ts
+init_dist();
+init_create_tool();
+var VALID_CATEGORIES2 = [
+  "process",
+  "architecture",
+  "tooling",
+  "security",
+  "testing",
+  "debugging",
+  "performance",
+  "integration",
+  "other"
+];
+var knowledgeAdd = createSwarmTool({
+  description: "Store a new lesson in the knowledge base for future reference. The lesson will be available for retrieval via knowledge_recall.",
+  args: {
+    lesson: tool.schema.string().min(15).max(280).describe("The lesson to store (15-280 characters)"),
+    category: tool.schema.enum(VALID_CATEGORIES2).describe("Knowledge category for the lesson"),
+    tags: tool.schema.array(tool.schema.string()).optional().describe("Optional tags for better searchability"),
+    scope: tool.schema.string().optional().describe("Scope of the lesson (global or stack:<name>)")
+  },
+  execute: async (args2, directory) => {
+    let lessonInput;
+    let categoryInput;
+    let tagsInput;
+    let scopeInput;
+    try {
+      if (args2 && typeof args2 === "object") {
+        const obj = args2;
+        lessonInput = obj.lesson;
+        categoryInput = obj.category;
+        tagsInput = obj.tags;
+        scopeInput = obj.scope;
+      }
+    } catch {}
+    if (typeof lessonInput !== "string") {
+      return JSON.stringify({
+        success: false,
+        error: "lesson must be a string"
+      });
+    }
+    const lesson = lessonInput;
+    if (lesson.length < 15 || lesson.length > 280) {
+      return JSON.stringify({
+        success: false,
+        error: "lesson must be between 15 and 280 characters"
+      });
+    }
+    if (typeof categoryInput !== "string") {
+      return JSON.stringify({
+        success: false,
+        error: "category must be a string"
+      });
+    }
+    const category = categoryInput;
+    if (!VALID_CATEGORIES2.includes(category)) {
+      return JSON.stringify({
+        success: false,
+        error: `category must be one of: ${VALID_CATEGORIES2.join(", ")}`
+      });
+    }
+    let tags = [];
+    if (tagsInput !== undefined) {
+      if (Array.isArray(tagsInput)) {
+        tags = tagsInput.filter((t) => typeof t === "string").slice(0, 20);
+      }
+    }
+    const scope = typeof scopeInput === "string" && scopeInput.length > 0 ? scopeInput : "global";
+    const entry = {
+      id: crypto.randomUUID(),
+      tier: "swarm",
+      lesson,
+      category,
+      tags,
+      scope,
+      confidence: 0.5,
+      status: "candidate",
+      confirmed_by: [],
+      project_name: "",
+      retrieval_outcomes: {
+        applied_count: 0,
+        succeeded_after_count: 0,
+        failed_after_count: 0
+      },
+      schema_version: 1,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      auto_generated: true,
+      hive_eligible: false
+    };
+    try {
+      await appendKnowledge(resolveSwarmKnowledgePath(directory), entry);
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : "Unknown error";
+      return JSON.stringify({
+        success: false,
+        error: message
+      });
+    }
+    return JSON.stringify({
+      success: true,
+      id: entry.id,
+      category
+    });
+  }
+});
 // src/tools/knowledge-query.ts
 init_dist();
 import { existsSync as existsSync28 } from "fs";
 init_create_tool();
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
-var VALID_CATEGORIES2 = [
+var VALID_CATEGORIES3 = [
   "process",
   "architecture",
   "tooling",
@@ -56446,7 +56933,7 @@ function validateCategoryInput(category) {
   if (typeof category !== "string")
     return null;
   const normalized = category.toLowerCase().trim();
-  if (VALID_CATEGORIES2.includes(normalized)) {
+  if (VALID_CATEGORIES3.includes(normalized)) {
     return normalized;
   }
   return null;
@@ -56634,6 +57121,147 @@ var knowledge_query = createSwarmTool({
 `);
   }
 });
+// src/tools/knowledge-recall.ts
+init_dist();
+init_create_tool();
+var knowledgeRecall = createSwarmTool({
+  description: "Search the knowledge base for relevant past decisions, patterns, and lessons learned. Returns ranked results by semantic similarity.",
+  args: {
+    query: tool.schema.string().min(3).describe("Natural language search query"),
+    top_n: tool.schema.number().int().min(1).max(20).optional().describe("Maximum results to return (default: 5)"),
+    tier: tool.schema.enum(["all", "swarm", "hive"]).optional().describe("Knowledge tier to search (default: 'all')")
+  },
+  execute: async (args2, directory) => {
+    let queryInput;
+    let topNInput;
+    let tierInput;
+    try {
+      if (args2 && typeof args2 === "object") {
+        const obj = args2;
+        queryInput = obj.query;
+        topNInput = obj.top_n;
+        tierInput = obj.tier;
+      }
+    } catch {}
+    if (typeof queryInput !== "string" || queryInput.length < 3) {
+      return JSON.stringify({
+        results: [],
+        total: 0,
+        error: "query must be a string with at least 3 characters"
+      });
+    }
+    let topN = 5;
+    if (topNInput !== undefined) {
+      if (typeof topNInput === "number" && Number.isInteger(topNInput)) {
+        topN = Math.max(1, Math.min(20, topNInput));
+      }
+    }
+    let tier = "all";
+    if (tierInput !== undefined && typeof tierInput === "string") {
+      if (tierInput === "swarm" || tierInput === "hive") {
+        tier = tierInput;
+      }
+    }
+    const swarmPath = resolveSwarmKnowledgePath(directory);
+    const hivePath = resolveHiveKnowledgePath();
+    const [swarmEntries, hiveEntries] = await Promise.all([
+      readKnowledge(swarmPath),
+      readKnowledge(hivePath)
+    ]);
+    let entries = [];
+    if (tier === "all" || tier === "swarm") {
+      entries = entries.concat(swarmEntries);
+    }
+    if (tier === "all" || tier === "hive") {
+      entries = entries.concat(hiveEntries);
+    }
+    if (entries.length === 0) {
+      const result2 = { results: [], total: 0 };
+      return JSON.stringify(result2);
+    }
+    const normalizedQuery = normalize2(queryInput);
+    const queryBigrams = wordBigrams(normalizedQuery);
+    const scoredEntries = entries.map((entry) => {
+      const entryText = `${entry.lesson} ${entry.tags.join(" ")} ${entry.category}`;
+      const entryBigrams = wordBigrams(entryText);
+      const textScore = jaccardBigram(queryBigrams, entryBigrams);
+      const boost = entry.status === "established" ? 0.1 : entry.status === "promoted" ? 0.05 : 0;
+      const finalScore = textScore + boost;
+      return {
+        id: entry.id,
+        confidence: entry.confidence,
+        category: entry.category,
+        lesson: entry.lesson,
+        score: finalScore
+      };
+    });
+    scoredEntries.sort((a, b) => b.score - a.score);
+    const topResults = scoredEntries.slice(0, topN);
+    const result = {
+      results: topResults,
+      total: topResults.length
+    };
+    return JSON.stringify(result);
+  }
+});
+// src/tools/knowledge-remove.ts
+init_dist();
+init_create_tool();
+var knowledgeRemove = createSwarmTool({
+  description: "Delete an outdated knowledge entry by ID. Double-deletion is idempotent \u2014 removing a non-existent entry returns a clear message without error.",
+  args: {
+    id: tool.schema.string().min(1).describe("UUID of the knowledge entry to remove")
+  },
+  execute: async (args2, directory) => {
+    let idInput;
+    try {
+      if (args2 && typeof args2 === "object") {
+        const obj = args2;
+        idInput = obj.id;
+      }
+    } catch {}
+    if (typeof idInput !== "string" || idInput.length < 1) {
+      return JSON.stringify({
+        success: false,
+        error: "id must be a non-empty string"
+      });
+    }
+    const id = idInput;
+    const swarmPath = resolveSwarmKnowledgePath(directory);
+    let entries;
+    try {
+      entries = await readKnowledge(swarmPath);
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : "Unknown error";
+      return JSON.stringify({
+        success: false,
+        error: message
+      });
+    }
+    const originalCount = entries.length;
+    entries = entries.filter((entry) => entry.id !== id);
+    if (entries.length === originalCount) {
+      return JSON.stringify({
+        success: false,
+        message: "entry not found"
+      });
+    }
+    try {
+      await rewriteKnowledge(swarmPath, entries);
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : "Unknown error";
+      return JSON.stringify({
+        success: false,
+        error: message
+      });
+    }
+    return JSON.stringify({
+      success: true,
+      removed: 1,
+      remaining: entries.length
+    });
+  }
+});
 
 // src/tools/index.ts
 init_lint();
@@ -56644,7 +57272,7 @@ init_config();
 init_schema();
 init_manager();
 import * as fs31 from "fs";
-import * as path44 from "path";
+import * as path45 from "path";
 init_utils2();
 init_create_tool();
 function safeWarn(message, error93) {
@@ -56701,7 +57329,7 @@ function collectCrossSessionDispatchedAgents(phaseReferenceTimestamp, callerSess
 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, workingDirectory) {
+async function executePhaseComplete(args2, workingDirectory, directory) {
   const phase = Number(args2.phase);
   const summary = args2.summary;
   const sessionID = args2.sessionID;
@@ -56729,7 +57357,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   const phaseReferenceTimestamp = session.lastPhaseCompleteTimestamp ?? 0;
   const crossSessionResult = collectCrossSessionDispatchedAgents(phaseReferenceTimestamp, sessionID);
   const agentsDispatched = Array.from(crossSessionResult.agents).sort();
-  const dir = workingDirectory ?? process.cwd();
+  const dir = workingDirectory || directory || process.cwd();
   const { config: config3 } = loadPluginConfigWithMeta(dir);
   let phaseCompleteConfig;
   try {
@@ -56862,7 +57490,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   };
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path44.basename(dir);
+      const projectName = path45.basename(dir);
       await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
     } catch (error93) {
       safeWarn("[phase_complete] Failed to curate lessons from retrospective:", error93);
@@ -56874,7 +57502,17 @@ async function executePhaseComplete(args2, workingDirectory) {
     if (curatorConfig.enabled && curatorConfig.phase_enabled) {
       const curatorResult = await runCuratorPhase(dir, phase, agentsDispatched, curatorConfig, {});
       await applyCuratorKnowledgeUpdates(dir, curatorResult.knowledge_recommendations, knowledgeConfig);
-      await runCriticDriftCheck(dir, phase, curatorResult, curatorConfig);
+      const driftResult = await runCriticDriftCheck(dir, phase, curatorResult, curatorConfig);
+      const callerSessionState = swarmState.agentSessions.get(sessionID);
+      if (callerSessionState) {
+        callerSessionState.pendingAdvisoryMessages ??= [];
+        const digestSummary = curatorResult.digest?.summary ? curatorResult.digest.summary.slice(0, 200) : "Phase analysis complete";
+        const complianceNote = curatorResult.compliance.length > 0 ? ` (${curatorResult.compliance.length} compliance observation(s))` : "";
+        callerSessionState.pendingAdvisoryMessages.push(`[CURATOR] Phase ${phase} digest: ${digestSummary}${complianceNote}. Call curator_analyze with recommendations to apply knowledge updates from this phase.`);
+        if (driftResult.report.drift_score > 0) {
+          callerSessionState.pendingAdvisoryMessages.push(`[CURATOR DRIFT DETECTED (phase ${phase}, score ${driftResult.report.drift_score})]: ${driftResult.injection_text.slice(0, 300)}. Review ${driftResult.report_path} and address spec alignment before proceeding.`);
+        }
+      }
       if (curatorResult.compliance.length > 0 && !curatorConfig.suppress_warnings) {
         const complianceLines = curatorResult.compliance.map((obs) => `[${obs.severity.toUpperCase()}] ${obs.description}`).slice(0, 5);
         complianceWarnings = complianceLines;
@@ -57002,7 +57640,7 @@ var phase_complete = createSwarmTool({
         warnings: ["Failed to parse arguments"]
       }, null, 2);
     }
-    return executePhaseComplete(phaseCompleteArgs, directory);
+    return executePhaseComplete(phaseCompleteArgs, undefined, directory);
   }
 });
 // src/tools/pkg-audit.ts
@@ -57011,7 +57649,7 @@ init_discovery();
 init_utils();
 init_create_tool();
 import * as fs32 from "fs";
-import * as path45 from "path";
+import * as path46 from "path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -57029,16 +57667,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs32.existsSync(path45.join(cwd, "package.json"))) {
+  if (fs32.existsSync(path46.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs32.existsSync(path45.join(cwd, "pyproject.toml")) || fs32.existsSync(path45.join(cwd, "requirements.txt"))) {
+  if (fs32.existsSync(path46.join(cwd, "pyproject.toml")) || fs32.existsSync(path46.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs32.existsSync(path45.join(cwd, "Cargo.toml"))) {
+  if (fs32.existsSync(path46.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs32.existsSync(path45.join(cwd, "go.mod"))) {
+  if (fs32.existsSync(path46.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -57047,10 +57685,10 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs32.existsSync(path45.join(cwd, "Gemfile")) || fs32.existsSync(path45.join(cwd, "Gemfile.lock"))) {
+  if (fs32.existsSync(path46.join(cwd, "Gemfile")) || fs32.existsSync(path46.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs32.existsSync(path45.join(cwd, "pubspec.yaml"))) {
+  if (fs32.existsSync(path46.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
   return ecosystems;
@@ -57063,7 +57701,7 @@ async function runNpmAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve15) => setTimeout(() => resolve15("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve16) => setTimeout(() => resolve16("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -57186,7 +57824,7 @@ async function runPipAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve15) => setTimeout(() => resolve15("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve16) => setTimeout(() => resolve16("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -57317,7 +57955,7 @@ async function runCargoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve15) => setTimeout(() => resolve15("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve16) => setTimeout(() => resolve16("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -57444,7 +58082,7 @@ async function runGoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve15) => setTimeout(() => resolve15("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve16) => setTimeout(() => resolve16("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -57580,7 +58218,7 @@ async function runDotnetAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve15) => setTimeout(() => resolve15("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve16) => setTimeout(() => resolve16("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -57699,7 +58337,7 @@ async function runBundleAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve15) => setTimeout(() => resolve15("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve16) => setTimeout(() => resolve16("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -57846,7 +58484,7 @@ async function runDartAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve15) => setTimeout(() => resolve15("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve16) => setTimeout(() => resolve16("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -58113,7 +58751,7 @@ var SUPPORTED_PARSER_EXTENSIONS = new Set([
 // src/tools/pre-check-batch.ts
 init_dist();
 import * as fs35 from "fs";
-import * as path48 from "path";
+import * as path49 from "path";
 
 // node_modules/yocto-queue/index.js
 class Node2 {
@@ -58204,26 +58842,26 @@ function pLimit(concurrency) {
     activeCount--;
     resumeNext();
   };
-  const run2 = async (function_, resolve15, arguments_2) => {
+  const run2 = async (function_, resolve16, arguments_2) => {
     const result = (async () => function_(...arguments_2))();
-    resolve15(result);
+    resolve16(result);
     try {
       await result;
     } catch {}
     next();
   };
-  const enqueue = (function_, resolve15, reject, arguments_2) => {
+  const enqueue = (function_, resolve16, reject, arguments_2) => {
     const queueItem = { reject };
     new Promise((internalResolve) => {
       queueItem.run = internalResolve;
       queue.enqueue(queueItem);
-    }).then(run2.bind(undefined, function_, resolve15, arguments_2));
+    }).then(run2.bind(undefined, function_, resolve16, arguments_2));
     if (activeCount < concurrency) {
       resumeNext();
     }
   };
-  const generator = (function_, ...arguments_2) => new Promise((resolve15, reject) => {
-    enqueue(function_, resolve15, reject, arguments_2);
+  const generator = (function_, ...arguments_2) => new Promise((resolve16, reject) => {
+    enqueue(function_, resolve16, reject, arguments_2);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -58281,7 +58919,7 @@ init_manager();
 
 // src/quality/metrics.ts
 import * as fs33 from "fs";
-import * as path46 from "path";
+import * as path47 from "path";
 var MAX_FILE_SIZE_BYTES5 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -58333,7 +58971,7 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
+    const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
     if (!fs33.existsSync(fullPath)) {
       continue;
     }
@@ -58456,7 +59094,7 @@ function countGoExports(content) {
 function getExportCountForFile(filePath) {
   try {
     const content = fs33.readFileSync(filePath, "utf-8");
-    const ext = path46.extname(filePath).toLowerCase();
+    const ext = path47.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -58482,7 +59120,7 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
+    const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
     if (!fs33.existsSync(fullPath)) {
       continue;
     }
@@ -58516,7 +59154,7 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
+    const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
     if (!fs33.existsSync(fullPath)) {
       continue;
     }
@@ -58549,8 +59187,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename8 = path46.basename(filePath);
-  const _ext = path46.extname(filePath).toLowerCase();
+  const basename8 = path47.basename(filePath);
+  const _ext = path47.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -58631,8 +59269,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path47, glob) {
-  const normalizedPath = path47.replace(/\\/g, "/");
+function matchesGlobSegment(path48, glob) {
+  const normalizedPath = path48.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -58663,8 +59301,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path47, glob) {
-  const normalizedPath = path47.replace(/\\/g, "/");
+function globMatches(path48, glob) {
+  const normalizedPath = path48.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -58700,7 +59338,7 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path46.join(workingDir, "src");
+  const srcDir = path47.join(workingDir, "src");
   if (fs33.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
@@ -58708,14 +59346,14 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path46.join(workingDir, dir);
+    const dirPath = path47.join(workingDir, dir);
     if (fs33.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path46.join(workingDir, "tests");
+  const testsDir = path47.join(workingDir, "tests");
   if (fs33.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
@@ -58723,7 +59361,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path46.join(workingDir, dir);
+    const dirPath = path47.join(workingDir, dir);
     if (fs33.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
@@ -58738,15 +59376,15 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
   try {
     const entries = fs33.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path46.join(dirPath, entry.name);
+      const fullPath = path47.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
         }
         await scanDirectoryForLines(fullPath, includeGlobs, excludeGlobs, isTestScan, callback);
       } else if (entry.isFile()) {
-        const relativePath = fullPath.replace(`${process.cwd()}/`, "");
-        const ext = path46.extname(entry.name).toLowerCase();
+        const relativePath = fullPath.replace(`${dirPath}/`, "");
+        const ext = path47.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -58997,7 +59635,7 @@ init_dist();
 init_manager();
 init_detector();
 import * as fs34 from "fs";
-import * as path47 from "path";
+import * as path48 from "path";
 import { extname as extname9 } from "path";
 
 // src/sast/rules/c.ts
@@ -59745,7 +60383,7 @@ function mapSemgrepSeverity(severity) {
   }
 }
 async function executeWithTimeout(command, args2, options) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     const child = spawn2(command, args2, {
       shell: false,
       cwd: options.cwd
@@ -59754,7 +60392,7 @@ async function executeWithTimeout(command, args2, options) {
     let stderr = "";
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
-      resolve15({
+      resolve16({
         stdout,
         stderr: "Process timed out",
         exitCode: 124
@@ -59768,7 +60406,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("close", (code) => {
       clearTimeout(timeout);
-      resolve15({
+      resolve16({
         stdout,
         stderr,
         exitCode: code ?? 0
@@ -59776,7 +60414,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("error", (err2) => {
       clearTimeout(timeout);
-      resolve15({
+      resolve16({
         stdout,
         stderr: err2.message,
         exitCode: 1
@@ -59960,7 +60598,7 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path47.isAbsolute(filePath) ? filePath : path47.resolve(directory, filePath);
+    const resolvedPath = path48.isAbsolute(filePath) ? filePath : path48.resolve(directory, filePath);
     if (!fs34.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
@@ -60159,20 +60797,20 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path48.win32.resolve(inputPath);
-  } else if (path48.isAbsolute(inputPath)) {
-    resolved = path48.resolve(inputPath);
+    resolved = path49.win32.resolve(inputPath);
+  } else if (path49.isAbsolute(inputPath)) {
+    resolved = path49.resolve(inputPath);
   } else {
-    resolved = path48.resolve(baseDir, inputPath);
+    resolved = path49.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path48.resolve(workspaceDir);
-  let relative5;
+  const workspaceResolved = path49.resolve(workspaceDir);
+  let relative6;
   if (isWinAbs) {
-    relative5 = path48.win32.relative(workspaceResolved, resolved);
+    relative6 = path49.win32.relative(workspaceResolved, resolved);
   } else {
-    relative5 = path48.relative(workspaceResolved, resolved);
+    relative6 = path49.relative(workspaceResolved, resolved);
   }
-  if (relative5.startsWith("..")) {
+  if (relative6.startsWith("..")) {
     return "path traversal detected";
   }
   return null;
@@ -60231,13 +60869,13 @@ async function runLintWrapped(files, directory, _config) {
 }
 async function runLintOnFiles(linter, files, workspaceDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path48.join(workspaceDir, "node_modules", ".bin");
+  const binDir = path49.join(workspaceDir, "node_modules", ".bin");
   const validatedFiles = [];
   for (const file3 of files) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path48.resolve(file3);
+    const resolvedPath = path49.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -60255,10 +60893,10 @@ async function runLintOnFiles(linter, files, workspaceDir) {
   }
   let command;
   if (linter === "biome") {
-    const biomeBin = isWindows ? path48.join(binDir, "biome.EXE") : path48.join(binDir, "biome");
+    const biomeBin = isWindows ? path49.join(binDir, "biome.EXE") : path49.join(binDir, "biome");
     command = [biomeBin, "check", ...validatedFiles];
   } else {
-    const eslintBin = isWindows ? path48.join(binDir, "eslint.cmd") : path48.join(binDir, "eslint");
+    const eslintBin = isWindows ? path49.join(binDir, "eslint.cmd") : path49.join(binDir, "eslint");
     command = [eslintBin, ...validatedFiles];
   }
   try {
@@ -60395,7 +61033,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path48.resolve(file3);
+      const resolvedPath = path49.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -60413,7 +61051,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path48.extname(file3).toLowerCase();
+      const ext = path49.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -60531,8 +61169,8 @@ async function runQualityBudgetWrapped(changedFiles, directory, _config) {
     };
   }
 }
-async function runPreCheckBatch(input, workspaceDir) {
-  const effectiveWorkspaceDir = workspaceDir || input.directory || process.cwd();
+async function runPreCheckBatch(input, workspaceDir, contextDir) {
+  const effectiveWorkspaceDir = workspaceDir || input.directory || contextDir;
   const { files, directory, sast_threshold = "medium", config: config3 } = input;
   const dirError = validateDirectory3(directory, effectiveWorkspaceDir);
   if (dirError) {
@@ -60572,7 +61210,7 @@ async function runPreCheckBatch(input, workspaceDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path48.resolve(directory, file3));
+    changedFiles.push(path49.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -60723,7 +61361,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path48.resolve(typedArgs.directory);
+    const resolvedDirectory = path49.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory3(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -60743,7 +61381,7 @@ var pre_check_batch = createSwarmTool({
         directory: resolvedDirectory,
         sast_threshold: typedArgs.sast_threshold,
         config: typedArgs.config
-      }, workspaceAnchor);
+      }, workspaceAnchor, directory);
       return JSON.stringify(result, null, 2);
     } catch (error93) {
       const errorMessage = error93 instanceof Error ? error93.message : "Unknown error";
@@ -60761,21 +61399,22 @@ var pre_check_batch = createSwarmTool({
 });
 // src/tools/retrieve-summary.ts
 init_dist();
+init_create_tool();
 var RETRIEVE_MAX_BYTES = 10 * 1024 * 1024;
-var retrieve_summary = tool({
+var retrieve_summary = createSwarmTool({
   description: "Retrieve the full content of a stored tool output summary by its ID (e.g. S1, S2). Use this when a prior tool output was summarized and you need the full content.",
   args: {
     id: tool.schema.string().describe("The summary ID to retrieve (e.g. S1, S2, S99). Must match pattern S followed by digits."),
     offset: tool.schema.number().min(0).default(0).describe("Line offset to start from (default: 0)."),
     limit: tool.schema.number().min(1).max(500).default(100).describe("Number of lines to return (default: 100, max: 500).")
   },
-  async execute(args2, context) {
-    const directory = context.directory;
-    const offset = args2.offset ?? 0;
-    const limit = Math.min(args2.limit ?? 100, 500);
+  async execute(args2, directory, _ctx) {
+    const typedArgs = args2;
+    const offset = typedArgs.offset ?? 0;
+    const limit = Math.min(typedArgs.limit ?? 100, 500);
     let sanitizedId;
     try {
-      sanitizedId = sanitizeSummaryId(args2.id);
+      sanitizedId = sanitizeSummaryId(typedArgs.id);
     } catch {
       return "Error: invalid summary ID format. Expected format: S followed by digits (e.g. S1, S2, S99).";
     }
@@ -60831,7 +61470,7 @@ init_tool();
 init_manager2();
 init_create_tool();
 import * as fs36 from "fs";
-import * as path49 from "path";
+import * as path50 from "path";
 function detectPlaceholderContent(args2) {
   const issues = [];
   const placeholderPattern = /^\[\w[\w\s]*\]$/;
@@ -60935,7 +61574,7 @@ async function executeSavePlan(args2, fallbackDir) {
   try {
     await savePlan(dir, plan);
     try {
-      const markerPath = path49.join(dir, ".swarm", ".plan-write-marker");
+      const markerPath = path50.join(dir, ".swarm", ".plan-write-marker");
       const marker = JSON.stringify({
         source: "save_plan",
         timestamp: new Date().toISOString(),
@@ -60947,7 +61586,7 @@ async function executeSavePlan(args2, fallbackDir) {
     return {
       success: true,
       message: "Plan saved successfully",
-      plan_path: path49.join(dir, ".swarm", "plan.json"),
+      plan_path: path50.join(dir, ".swarm", "plan.json"),
       phases_count: plan.phases.length,
       tasks_count: tasksCount
     };
@@ -60986,7 +61625,7 @@ var save_plan = createSwarmTool({
 init_dist();
 init_manager();
 import * as fs37 from "fs";
-import * as path50 from "path";
+import * as path51 from "path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -61834,7 +62473,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs37.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path50.join(dir, entry.name);
+        const fullPath = path51.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -61843,7 +62482,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path50.relative(rootDir, fullPath));
+              manifestFiles.push(path51.relative(rootDir, fullPath));
               break;
             }
           }
@@ -61861,11 +62500,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs37.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path50.join(dir, entry.name);
+        const fullPath = path51.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path50.relative(workingDir, fullPath));
+              found.push(path51.relative(workingDir, fullPath));
               break;
             }
           }
@@ -61878,11 +62517,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path50.dirname(file3);
+    let currentDir = path51.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path50.sep) {
-        dirs.add(path50.join(workingDir, currentDir));
-        const parent = path50.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path51.sep) {
+        dirs.add(path51.join(workingDir, currentDir));
+        const parent = path51.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -61966,7 +62605,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path50.isAbsolute(relativeOutputDir) ? relativeOutputDir : path50.join(workingDir, relativeOutputDir);
+    const outputDir = path51.isAbsolute(relativeOutputDir) ? relativeOutputDir : path51.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -61989,7 +62628,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path50.isAbsolute(manifestFile) ? manifestFile : path50.join(workingDir, manifestFile);
+        const fullPath = path51.isAbsolute(manifestFile) ? manifestFile : path51.join(workingDir, manifestFile);
         if (!fs37.existsSync(fullPath)) {
           continue;
         }
@@ -62006,7 +62645,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path50.join(outputDir, filename);
+    const outputPath = path51.join(outputDir, filename);
     fs37.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -62050,7 +62689,7 @@ var sbom_generate = createSwarmTool({
 init_dist();
 init_create_tool();
 import * as fs38 from "fs";
-import * as path51 from "path";
+import * as path52 from "path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -62082,12 +62721,12 @@ function normalizePath2(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path51.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path51.sep) ? cwd : cwd + path51.sep;
+    const resolvedPath = path52.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path52.sep) ? cwd : cwd + path52.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path51.extname(resolvedPath).toLowerCase();
+    const ext = path52.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -62101,7 +62740,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path51.resolve(cwd, candidate);
+    const candidatePath = path52.resolve(cwd, candidate);
     if (fs38.existsSync(candidatePath)) {
       const stats = fs38.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
@@ -62113,7 +62752,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs38.readFileSync(specFile, "utf-8");
-  const ext = path51.extname(specFile).toLowerCase();
+  const ext = path52.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -62189,7 +62828,7 @@ function extractRoutes(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path51.join(dir, entry.name);
+      const fullPath = path52.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -62199,7 +62838,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path51.extname(entry.name).toLowerCase();
+        const ext = path52.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -62369,7 +63008,7 @@ init_secretscan();
 init_tool();
 init_create_tool();
 import * as fs39 from "fs";
-import * as path52 from "path";
+import * as path53 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) {
@@ -62398,11 +63037,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path52.resolve(workspace, filePath);
+    const resolvedPath = path53.resolve(workspace, filePath);
     const realWorkspace = fs39.realpathSync(workspace);
     const realResolvedPath = fs39.realpathSync(resolvedPath);
-    const relativePath = path52.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path52.isAbsolute(relativePath)) {
+    const relativePath = path53.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path53.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -62414,7 +63053,7 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path52.join(cwd, filePath);
+  const fullPath = path53.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -62566,7 +63205,7 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path52.join(cwd, filePath);
+  const fullPath = path53.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -62649,7 +63288,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path52.extname(file3);
+    const ext = path53.extname(file3);
     if (containsControlCharacters(file3)) {
       return JSON.stringify({
         file: file3,
@@ -62721,7 +63360,7 @@ init_dist();
 init_utils();
 init_create_tool();
 import * as fs40 from "fs";
-import * as path53 from "path";
+import * as path54 from "path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS2 = new Set([
@@ -62792,9 +63431,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path53.resolve(paths);
-    const normalizedCwd = path53.resolve(cwd);
-    const normalizedResolved = path53.resolve(resolvedPath);
+    const resolvedPath = path54.resolve(paths);
+    const normalizedCwd = path54.resolve(cwd);
+    const normalizedResolved = path54.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -62810,7 +63449,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path53.extname(filePath).toLowerCase();
+  const ext = path54.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS2.has(ext);
 }
 function findSourceFiles2(dir, files = []) {
@@ -62825,7 +63464,7 @@ function findSourceFiles2(dir, files = []) {
     if (SKIP_DIRECTORIES3.has(entry)) {
       continue;
     }
-    const fullPath = path53.join(dir, entry);
+    const fullPath = path54.join(dir, entry);
     let stat2;
     try {
       stat2 = fs40.statSync(fullPath);
@@ -62937,7 +63576,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path53.extname(scanPath)}`,
+          error: `unsupported file extension: ${path54.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -62983,14 +63622,14 @@ var todo_extract = createSwarmTool({
 init_tool();
 init_schema();
 import * as fs42 from "fs";
-import * as path55 from "path";
+import * as path56 from "path";
 
 // src/hooks/diff-scope.ts
 import * as fs41 from "fs";
-import * as path54 from "path";
+import * as path55 from "path";
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path54.join(directory, ".swarm", "plan.json");
+    const planPath = path55.join(directory, ".swarm", "plan.json");
     if (!fs41.existsSync(planPath))
       return null;
     const raw = fs41.readFileSync(planPath, "utf-8");
@@ -63105,7 +63744,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path55.basename(file3);
+    const fileName = path56.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -63127,7 +63766,7 @@ function checkReviewerGate(taskId, workingDirectory) {
     if (hasActiveTurboMode2()) {
       const resolvedDir2 = workingDirectory ?? process.cwd();
       try {
-        const planPath = path55.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path56.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs42.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -63147,7 +63786,7 @@ function checkReviewerGate(taskId, workingDirectory) {
     }
     const resolvedDir = workingDirectory ?? process.cwd();
     try {
-      const evidencePath = path55.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
+      const evidencePath = path56.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
       const raw = fs42.readFileSync(evidencePath, "utf-8");
       const evidence = JSON.parse(raw);
       if (evidence?.required_gates && Array.isArray(evidence.required_gates) && evidence?.gates) {
@@ -63188,7 +63827,7 @@ function checkReviewerGate(taskId, workingDirectory) {
     }
     try {
       const resolvedDir2 = workingDirectory ?? process.cwd();
-      const planPath = path55.join(resolvedDir2, ".swarm", "plan.json");
+      const planPath = path56.join(resolvedDir2, ".swarm", "plan.json");
       const planRaw = fs42.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
@@ -63370,8 +64009,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path55.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path55.sep);
+    normalizedDir = path56.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path56.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -63381,10 +64020,10 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path55.resolve(normalizedDir);
+    const resolvedDir = path56.resolve(normalizedDir);
     try {
       const realPath = fs42.realpathSync(resolvedDir);
-      const planPath = path55.join(realPath, ".swarm", "plan.json");
+      const planPath = path56.join(realPath, ".swarm", "plan.json");
       if (!fs42.existsSync(planPath)) {
         return {
           success: false,
@@ -63405,7 +64044,10 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
       };
     }
   } else {
-    directory = fallbackDir ?? process.cwd();
+    if (!fallbackDir) {
+      console.warn("[update-task-status] fallbackDir is undefined, falling back to process.cwd()");
+    }
+    directory = fallbackDir || process.cwd();
   }
   if (args2.status === "completed") {
     recoverTaskStateFromDelegations(args2.task_id);
@@ -63523,6 +64165,24 @@ var OpenCodeSwarm = async (ctx) => {
   }
   const delegationHandler = createDelegationTrackerHook(config3, guardrailsConfig.enabled);
   const guardrailsHooks = createGuardrailsHooks(ctx.directory, guardrailsConfig);
+  const watchdogConfig = WatchdogConfigSchema.parse(config3.watchdog ?? {});
+  const advisoryInjector = (sessionId, message) => {
+    const s = swarmState.agentSessions.get(sessionId);
+    if (s) {
+      s.pendingAdvisoryMessages ??= [];
+      s.pendingAdvisoryMessages.push(message);
+    }
+  };
+  const scopeGuardHook = createScopeGuardHook({
+    enabled: watchdogConfig.scope_guard,
+    skip_in_turbo: watchdogConfig.skip_in_turbo
+  }, ctx.directory, advisoryInjector);
+  const delegationLedgerHook = createDelegationLedgerHook({ enabled: watchdogConfig.delegation_ledger }, ctx.directory, advisoryInjector);
+  const selfReviewConfig = SelfReviewConfigSchema.parse(config3.self_review ?? {});
+  const selfReviewHook = createSelfReviewHook({
+    enabled: selfReviewConfig.enabled,
+    skip_in_turbo: selfReviewConfig.skip_in_turbo
+  }, advisoryInjector);
   const summaryConfig = SummaryConfigSchema.parse(config3.summaries ?? {});
   const toolSummarizerHook = createToolSummarizerHook(summaryConfig, ctx.directory);
   const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
@@ -63536,7 +64196,8 @@ var OpenCodeSwarm = async (ctx) => {
     enabled: true,
     classThreshold: 3,
     commentStripThreshold: 5,
-    diffLineThreshold: 200
+    diffLineThreshold: 200,
+    importHygieneThreshold: 2
   }, ctx.directory, (sessionId, message) => {
     const s = swarmState.agentSessions.get(sessionId);
     if (s) {
@@ -63579,7 +64240,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 = path56.resolve(ctx.directory, ".swarm");
+    const swarmDir = path57.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -63676,6 +64337,10 @@ var OpenCodeSwarm = async (ctx) => {
       check_gate_status,
       checkpoint,
       complexity_hotspots,
+      curator_analyze,
+      knowledgeAdd,
+      knowledgeRecall,
+      knowledgeRemove,
       detect_domains,
       evidence_check,
       extract_code_blocks,
@@ -63805,6 +64470,20 @@ var OpenCodeSwarm = async (ctx) => {
       });
     },
     "experimental.chat.messages.transform": composeHandlers(...[
+      (input, _output) => {
+        const p = input;
+        if (p.sessionID) {
+          const archAgent = swarmState.activeAgent.get(p.sessionID);
+          const archSession = swarmState.agentSessions.get(p.sessionID);
+          const agentName = archAgent ?? archSession?.agentName ?? "";
+          if (stripKnownSwarmPrefix(agentName) === ORCHESTRATOR_NAME) {
+            try {
+              delegationLedgerHook.onArchitectResume(p.sessionID);
+            } catch {}
+          }
+        }
+        return Promise.resolve();
+      },
       pipelineHook["experimental.chat.messages.transform"],
       contextBudgetHandler,
       guardrailsHooks.messagesTransform,
@@ -63841,6 +64520,7 @@ var OpenCodeSwarm = async (ctx) => {
         }
       }
       await guardrailsHooks.toolBefore(input, output);
+      await scopeGuardHook.toolBefore(input, output);
       if (swarmState.lastBudgetPct >= 50) {
         const pressureSession = ensureAgentSession(input.sessionID, swarmState.activeAgent.get(input.sessionID) ?? ORCHESTRATOR_NAME);
         if (!pressureSession.contextPressureWarningSent) {
@@ -63854,6 +64534,8 @@ var OpenCodeSwarm = async (ctx) => {
     "tool.execute.after": async (input, output) => {
       await activityHooks.toolAfter(input, output);
       await guardrailsHooks.toolAfter(input, output);
+      await safeHook(delegationLedgerHook.toolAfter)(input, output);
+      await safeHook(selfReviewHook.toolAfter)(input, output);
       await safeHook(delegationGateHooks.toolAfter)(input, output);
       if (knowledgeCuratorHook)
         await safeHook(knowledgeCuratorHook)(input, output);