opencode-swarm 7.32.2 → 7.33.0

package/dist/index.js

@@ -48,7 +48,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.32.2",
+    version: "7.33.0",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -15539,13 +15539,41 @@ var init_schema = __esm(() => {
   });
   MemoryConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
-    provider: exports_external.literal("local-jsonl").default("local-jsonl"),
+    provider: exports_external.enum(["local-jsonl", "sqlite"]).default("local-jsonl"),
     storageDir: exports_external.string().default(".swarm/memory"),
+    sqlite: exports_external.object({
+      path: exports_external.string().default(".swarm/memory/memory.db"),
+      busyTimeoutMs: exports_external.number().int().min(0).max(60000).default(5000)
+    }).default({ path: ".swarm/memory/memory.db", busyTimeoutMs: 5000 }),
     recall: exports_external.object({
       defaultMaxItems: exports_external.number().int().min(1).max(20).default(8),
       defaultTokenBudget: exports_external.number().int().min(100).max(5000).default(1200),
-      minScore: exports_external.number().min(0).max(1).default(0.05)
-    }).default({ defaultMaxItems: 8, defaultTokenBudget: 1200, minScore: 0.05 }),
+      minScore: exports_external.number().min(0).max(1).default(0.05),
+      injection: exports_external.object({
+        enabled: exports_external.boolean().default(true),
+        minScore: exports_external.number().min(0).max(1).default(0.25),
+        requireQuerySignal: exports_external.boolean().default(true),
+        maxItems: exports_external.number().int().min(1).max(20).default(6),
+        tokenBudget: exports_external.number().int().min(100).max(5000).default(1000)
+      }).default({
+        enabled: true,
+        minScore: 0.25,
+        requireQuerySignal: true,
+        maxItems: 6,
+        tokenBudget: 1000
+      })
+    }).default({
+      defaultMaxItems: 8,
+      defaultTokenBudget: 1200,
+      minScore: 0.05,
+      injection: {
+        enabled: true,
+        minScore: 0.25,
+        requireQuerySignal: true,
+        maxItems: 6,
+        tokenBudget: 1000
+      }
+    }),
     writes: exports_external.object({
       mode: exports_external.literal("propose").default("propose")
     }).default({ mode: "propose" }),
@@ -84575,7 +84603,7 @@ __export(exports_project_context, {
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs113 from "node:fs";
-import * as path147 from "node:path";
+import * as path148 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -84587,7 +84615,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs113.accessSync(path147.join(directory, pattern));
+    fs113.accessSync(path148.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -84596,7 +84624,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs113.readFileSync(path147.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs113.readFileSync(path148.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -84705,7 +84733,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path148 from "node:path";
+import * as path149 from "node:path";
 
 // src/background/index.ts
 init_event_bus();
@@ -97571,10 +97599,21 @@ var DEFAULT_MEMORY_CONFIG = {
   enabled: false,
   provider: "local-jsonl",
   storageDir: ".swarm/memory",
+  sqlite: {
+    path: ".swarm/memory/memory.db",
+    busyTimeoutMs: 5000
+  },
   recall: {
     defaultMaxItems: 8,
     defaultTokenBudget: 1200,
-    minScore: 0.05
+    minScore: 0.05,
+    injection: {
+      enabled: true,
+      minScore: 0.25,
+      requireQuerySignal: true,
+      maxItems: 6,
+      tokenBudget: 1000
+    }
   },
   writes: {
     mode: "propose"
@@ -97603,9 +97642,17 @@ function resolveMemoryConfig(input) {
   return {
     ...DEFAULT_MEMORY_CONFIG,
     ...input ?? {},
+    sqlite: {
+      ...DEFAULT_MEMORY_CONFIG.sqlite,
+      ...input?.sqlite ?? {}
+    },
     recall: {
       ...DEFAULT_MEMORY_CONFIG.recall,
-      ...input?.recall ?? {}
+      ...input?.recall ?? {},
+      injection: {
+        ...DEFAULT_MEMORY_CONFIG.recall.injection,
+        ...input?.recall?.injection ?? {}
+      }
     },
     writes: {
       ...DEFAULT_MEMORY_CONFIG.writes,
@@ -97636,7 +97683,7 @@ class MemoryDisabledError extends Error {
 // src/memory/gateway.ts
 import { createHash as createHash9 } from "node:crypto";
 import { existsSync as existsSync50, readFileSync as readFileSync39 } from "node:fs";
-import * as path96 from "node:path";
+import * as path97 from "node:path";
 
 // src/memory/local-jsonl-provider.ts
 init_utils2();
@@ -97887,6 +97934,24 @@ function validateMemoryProposal(proposal) {
 function tokenize(text) {
   return new Set(text.toLowerCase().replace(/[^\w\s-]/g, " ").split(/\s+/).map((token) => token.trim()).filter(Boolean));
 }
+function normalizeKindText(kind) {
+  return kind.replace(/_/g, " ");
+}
+function collectMetadataStrings(metadata2, keys) {
+  const values = [];
+  for (const key of keys) {
+    const value = metadata2[key];
+    if (typeof value === "string")
+      values.push(value);
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === "string")
+          values.push(item);
+      }
+    }
+  }
+  return values;
+}
 function overlap(a, b) {
   if (a.size === 0 || b.size === 0)
     return 0;
@@ -97924,37 +97989,101 @@ function sameScope(a, b) {
 function scopeAllowed(recordScope, allowedScopes) {
   return allowedScopes.some((scope) => sameScope(recordScope, scope));
 }
-function scoreMemoryRecord(record3, request) {
-  if (!request.includeExpired && isExpired2(record3))
-    return null;
+function scoreMemoryRecordDetailed(record3, request) {
+  if (!request.includeExpired && isExpired2(record3)) {
+    return { item: null, skipReason: "filtered" };
+  }
   if (record3.supersededBy)
-    return null;
-  if (record3.metadata.deleted === true)
-    return null;
-  if (!scopeAllowed(record3.scope, request.scopes))
-    return null;
-  if (request.kinds && !request.kinds.includes(record3.kind))
-    return null;
-  const queryTokens = tokenize(request.query);
+    return { item: null, skipReason: "filtered" };
+  if (record3.metadata.deleted === true) {
+    return { item: null, skipReason: "filtered" };
+  }
+  if (!scopeAllowed(record3.scope, request.scopes)) {
+    return { item: null, skipReason: "filtered" };
+  }
+  if (request.kinds && !request.kinds.includes(record3.kind)) {
+    return { item: null, skipReason: "filtered" };
+  }
+  const queryTokens = request.mode === "injection" && request.task ? tokenize(request.task) : tokenize(request.query);
   const textTokens = tokenize(record3.text);
   const tagTokens = tokenize(record3.tags.join(" "));
+  const fileTokens = tokenize([
+    record3.source.filePath,
+    ...collectMetadataStrings(record3.metadata, [
+      "file",
+      "filePath",
+      "files",
+      "touchedFiles"
+    ])
+  ].filter((value) => typeof value === "string").join(" "));
+  const symbolTokens = tokenize(collectMetadataStrings(record3.metadata, ["symbol", "symbols"]).join(" "));
+  const kindQueryOverlap = overlap(queryTokens, tokenize(normalizeKindText(record3.kind)));
   const textOverlap = overlap(queryTokens, textTokens);
   const tagOverlap = overlap(queryTokens, tagTokens);
-  const score = textOverlap * 0.45 + tagOverlap * 0.2 + scopeSpecificityBoost(record3.scope) * 0.15 + kindProfileBoost(record3.kind, request) * 0.1 + record3.confidence * 0.1;
+  const fileOverlap = overlap(queryTokens, fileTokens);
+  const symbolOverlap = overlap(queryTokens, symbolTokens);
+  const kindMatch = request.kinds?.includes(record3.kind) ?? false;
+  const scopeMatch = scopeAllowed(record3.scope, request.scopes);
+  const hasQuerySignal = textOverlap > 0 || tagOverlap > 0 || fileOverlap > 0 || symbolOverlap > 0 || kindQueryOverlap > 0;
+  if (request.mode === "injection" && request.requireQuerySignal !== false && !hasQuerySignal) {
+    return { item: null, skipReason: "no_signal" };
+  }
+  const score = textOverlap * 0.45 + tagOverlap * 0.2 + fileOverlap * 0.05 + symbolOverlap * 0.05 + scopeSpecificityBoost(record3.scope) * 0.15 + kindProfileBoost(record3.kind, request) * 0.1 + record3.confidence * 0.1;
   const reasonParts = [
     textOverlap > 0 ? `text_overlap=${textOverlap.toFixed(2)}` : null,
     tagOverlap > 0 ? `tag_overlap=${tagOverlap.toFixed(2)}` : null,
+    fileOverlap > 0 ? `file_overlap=${fileOverlap.toFixed(2)}` : null,
+    symbolOverlap > 0 ? `symbol_overlap=${symbolOverlap.toFixed(2)}` : null,
+    kindQueryOverlap > 0 ? `kind_query=${kindQueryOverlap.toFixed(2)}` : null,
     `scope=${record3.scope.type}`,
     `confidence=${record3.confidence.toFixed(2)}`
   ].filter(Boolean);
   return {
-    record: record3,
-    score,
-    reason: reasonParts.join(", ")
+    item: {
+      record: record3,
+      score,
+      reason: reasonParts.join(", "),
+      signals: {
+        textOverlap,
+        tagOverlap,
+        fileOverlap,
+        symbolOverlap,
+        kindMatch,
+        scopeMatch
+      }
+    }
   };
 }
-function scoreMemoryRecords(records, request) {
-  return records.map((record3) => scoreMemoryRecord(record3, request)).filter((item) => item !== null).filter((item) => item.score >= (request.minScore ?? 0)).sort((a, b) => b.score - a.score || a.record.id.localeCompare(b.record.id));
+function scoreMemoryRecordsWithDiagnostics(records, request) {
+  const minScore = request.minScore ?? 0;
+  const diagnostics = {
+    candidateCount: records.length,
+    preScoredFilteredCount: 0,
+    scoredCount: 0,
+    returnedCount: 0,
+    noSignalCount: 0,
+    belowThresholdCount: 0
+  };
+  const items = [];
+  for (const record3 of records) {
+    const result = scoreMemoryRecordDetailed(record3, request);
+    if (!result.item) {
+      if (result.skipReason === "filtered")
+        diagnostics.preScoredFilteredCount++;
+      if (result.skipReason === "no_signal")
+        diagnostics.noSignalCount++;
+      continue;
+    }
+    diagnostics.scoredCount++;
+    if (result.item.score < minScore) {
+      diagnostics.belowThresholdCount++;
+      continue;
+    }
+    items.push(result.item);
+  }
+  items.sort((a, b) => b.score - a.score || a.record.id.localeCompare(b.record.id));
+  diagnostics.returnedCount = items.length;
+  return { items, diagnostics };
 }
 
 // src/memory/local-jsonl-provider.ts
@@ -98030,13 +98159,23 @@ class LocalJsonlMemoryProvider {
     await this.audit("delete", id, reason);
   }
   async recall(request) {
+    return (await this.recallWithDiagnostics(request)).items;
+  }
+  async recallWithDiagnostics(request) {
     await this.initialize();
     const records = await this.list({
       scopes: request.scopes,
       kinds: request.kinds,
       includeExpired: request.includeExpired
     });
-    return scoreMemoryRecords(records, request).slice(0, request.maxItems);
+    const result = scoreMemoryRecordsWithDiagnostics(records, request);
+    return {
+      items: result.items.slice(0, request.maxItems),
+      diagnostics: {
+        ...result.diagnostics,
+        returnedCount: Math.min(result.diagnostics.returnedCount, request.maxItems)
+      }
+    };
   }
   async recordRecallUsage(event) {
     await this.initialize();
@@ -98241,10 +98380,372 @@ function toRecallBundle(input) {
     generatedAt: input.generatedAt,
     items: block.items,
     tokenEstimate: block.tokenEstimate,
-    promptBlock: block.promptBlock
+    promptBlock: block.promptBlock,
+    diagnostics: input.diagnostics
   };
 }
 
+// src/memory/sqlite-provider.ts
+init_utils2();
+import { randomUUID as randomUUID9 } from "node:crypto";
+import { mkdirSync as mkdirSync24 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import * as path96 from "node:path";
+var _DatabaseCtor2 = null;
+function loadDatabaseCtor2() {
+  if (_DatabaseCtor2)
+    return _DatabaseCtor2;
+  const req = createRequire3(import.meta.url);
+  _DatabaseCtor2 = req("bun:sqlite").Database;
+  return _DatabaseCtor2;
+}
+var MIGRATIONS2 = [
+  {
+    version: 1,
+    name: "create_memory_provider_tables",
+    sql: `
+			CREATE TABLE IF NOT EXISTS memory_items (
+				id TEXT PRIMARY KEY,
+				scope_key TEXT NOT NULL,
+				kind TEXT NOT NULL,
+				updated_at TEXT NOT NULL,
+				expires_at TEXT,
+				superseded_by TEXT,
+				deleted INTEGER NOT NULL DEFAULT 0,
+				record_json TEXT NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_memory_items_scope_kind
+				ON memory_items(scope_key, kind);
+			CREATE INDEX IF NOT EXISTS idx_memory_items_updated_at
+				ON memory_items(updated_at);
+
+			CREATE TABLE IF NOT EXISTS memory_proposals (
+				id TEXT PRIMARY KEY,
+				status TEXT NOT NULL,
+				created_at TEXT NOT NULL,
+				proposal_json TEXT NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_memory_proposals_status_created
+				ON memory_proposals(status, created_at);
+
+			CREATE TABLE IF NOT EXISTS memory_events (
+				id TEXT PRIMARY KEY,
+				operation TEXT NOT NULL,
+				target_id TEXT NOT NULL,
+				reason TEXT,
+				timestamp TEXT NOT NULL,
+				event_json TEXT
+			);
+
+			CREATE TABLE IF NOT EXISTS memory_recall_usage (
+				id TEXT PRIMARY KEY,
+				bundle_id TEXT NOT NULL,
+				timestamp TEXT NOT NULL,
+				usage_json TEXT NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_memory_recall_usage_bundle
+				ON memory_recall_usage(bundle_id);
+		`
+  }
+];
+
+class SQLiteMemoryProvider {
+  name = "sqlite";
+  rootDirectory;
+  config;
+  initialized = false;
+  db = null;
+  memories = new Map;
+  proposals = new Map;
+  constructor(rootDirectory, config3 = {}) {
+    this.rootDirectory = rootDirectory;
+    this.config = {
+      ...DEFAULT_MEMORY_CONFIG,
+      ...config3,
+      sqlite: {
+        ...DEFAULT_MEMORY_CONFIG.sqlite,
+        ...config3.sqlite ?? {}
+      },
+      recall: {
+        ...DEFAULT_MEMORY_CONFIG.recall,
+        ...config3.recall ?? {},
+        injection: {
+          ...DEFAULT_MEMORY_CONFIG.recall.injection,
+          ...config3.recall?.injection ?? {}
+        }
+      },
+      writes: {
+        ...DEFAULT_MEMORY_CONFIG.writes,
+        ...config3.writes ?? {}
+      },
+      redaction: {
+        ...DEFAULT_MEMORY_CONFIG.redaction,
+        ...config3.redaction ?? {}
+      }
+    };
+  }
+  databasePath() {
+    const relativePath = this.config.sqlite.path.replace(/^\.swarm[/\\]?/, "");
+    return validateSwarmPath(this.rootDirectory, relativePath);
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    const dbPath = this.databasePath();
+    mkdirSync24(path96.dirname(dbPath), { recursive: true });
+    const Db = loadDatabaseCtor2();
+    this.db = new Db(dbPath);
+    this.db.run("PRAGMA journal_mode = WAL;");
+    this.db.run("PRAGMA synchronous = NORMAL;");
+    const busyTimeoutMs = Math.min(60000, Math.max(0, Math.trunc(this.config.sqlite.busyTimeoutMs)));
+    this.db.run(`PRAGMA busy_timeout = ${busyTimeoutMs};`);
+    this.db.run("PRAGMA foreign_keys = ON;");
+    this.runMigrations();
+    const memoryLoad = this.loadMemories();
+    const proposalLoad = this.loadProposals();
+    this.memories = new Map(memoryLoad.records.map((record3) => [record3.id, record3]));
+    this.proposals = new Map(proposalLoad.records.map((proposal) => [proposal.id, proposal]));
+    this.initialized = true;
+    if (memoryLoad.invalidCount > 0) {
+      await this.event("invalid_load", "memory_items", `${memoryLoad.invalidCount} invalid SQLite memory row(s) skipped`);
+    }
+    if (proposalLoad.invalidCount > 0) {
+      await this.event("invalid_load", "memory_proposals", `${proposalLoad.invalidCount} invalid SQLite proposal row(s) skipped`);
+    }
+  }
+  async upsert(record3) {
+    await this.initialize();
+    const existing = this.memories.get(record3.id);
+    if (existing?.metadata.deleted === true) {
+      throw new MemoryValidationError("memory is tombstoned and cannot be upserted");
+    }
+    const next = validateMemoryRecordRules({
+      ...record3,
+      createdAt: existing?.createdAt ?? record3.createdAt
+    }, { rejectDurableSecrets: this.config.redaction.rejectDurableSecrets });
+    this.memories.set(next.id, next);
+    this.writeMemory(next);
+    await this.event("upsert", next.id);
+    return next;
+  }
+  async get(id) {
+    await this.initialize();
+    return this.memories.get(id) ?? null;
+  }
+  async delete(id, reason) {
+    await this.initialize();
+    const existing = this.memories.get(id);
+    if (!existing)
+      return;
+    if (this.config.hardDelete) {
+      this.memories.delete(id);
+      this.requireDb().run("DELETE FROM memory_items WHERE id = ?", [id]);
+    } else {
+      const tombstone = {
+        ...existing,
+        updatedAt: new Date().toISOString(),
+        metadata: { ...existing.metadata, deleted: true, deleteReason: reason }
+      };
+      this.memories.set(id, tombstone);
+      this.writeMemory(tombstone);
+    }
+    await this.event("delete", id, reason);
+  }
+  async recall(request) {
+    return (await this.recallWithDiagnostics(request)).items;
+  }
+  async recallWithDiagnostics(request) {
+    await this.initialize();
+    const records = await this.list({
+      scopes: request.scopes,
+      kinds: request.kinds,
+      includeExpired: request.includeExpired
+    });
+    const result = scoreMemoryRecordsWithDiagnostics(records, request);
+    return {
+      items: result.items.slice(0, request.maxItems),
+      diagnostics: {
+        ...result.diagnostics,
+        returnedCount: Math.min(result.diagnostics.returnedCount, request.maxItems)
+      }
+    };
+  }
+  async recordRecallUsage(event) {
+    await this.initialize();
+    this.requireDb().run(`INSERT INTO memory_recall_usage (
+				id,
+				bundle_id,
+				timestamp,
+				usage_json
+			) VALUES (?, ?, ?, ?)`, [randomUUID9(), event.bundleId, event.timestamp, JSON.stringify(event)]);
+    await this.event("recall", event.bundleId, JSON.stringify(event));
+  }
+  async list(filter = {}) {
+    await this.initialize();
+    let records = Array.from(this.memories.values());
+    if (filter.scopes && filter.scopes.length > 0) {
+      records = records.filter((record3) => scopeAllowed(record3.scope, filter.scopes ?? []));
+    }
+    if (filter.kinds && filter.kinds.length > 0) {
+      records = records.filter((record3) => filter.kinds?.includes(record3.kind));
+    }
+    if (!filter.includeExpired) {
+      const now = Date.now();
+      records = records.filter((record3) => {
+        if (!record3.expiresAt)
+          return true;
+        const expires = Date.parse(record3.expiresAt);
+        return !Number.isFinite(expires) || expires > now;
+      });
+    }
+    records = records.filter((record3) => !record3.supersededBy && record3.metadata.deleted !== true);
+    records.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    return records.slice(0, filter.limit ?? records.length);
+  }
+  async createProposal(proposal) {
+    await this.initialize();
+    const next = validateMemoryProposal(proposal);
+    if (next.proposedRecord) {
+      validateMemoryRecordRules(next.proposedRecord, {
+        rejectDurableSecrets: this.config.redaction.rejectDurableSecrets
+      });
+    }
+    this.proposals.set(next.id, next);
+    this.requireDb().run(`INSERT OR REPLACE INTO memory_proposals (
+				id,
+				status,
+				created_at,
+				proposal_json
+			) VALUES (?, ?, ?, ?)`, [next.id, next.status, next.createdAt, JSON.stringify(next)]);
+    await this.event("proposal", next.id);
+    return next;
+  }
+  async listProposals(filter = {}) {
+    await this.initialize();
+    let proposals = Array.from(this.proposals.values());
+    if (filter.status) {
+      proposals = proposals.filter((proposal) => proposal.status === filter.status);
+    }
+    proposals.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return proposals.slice(0, filter.limit ?? proposals.length);
+  }
+  close() {
+    if (!this.db)
+      return;
+    this.db.close();
+    this.db = null;
+    this.initialized = false;
+  }
+  runMigrations() {
+    const db = this.requireDb();
+    db.run(`CREATE TABLE IF NOT EXISTS schema_migrations (
+			version INTEGER PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+		)`);
+    const row = db.query("SELECT MAX(version) as version FROM schema_migrations").get();
+    const currentVersion = row?.version ?? 0;
+    for (const migration of MIGRATIONS2) {
+      if (migration.version <= currentVersion)
+        continue;
+      const apply = db.transaction(() => {
+        for (const statement of splitSql(migration.sql)) {
+          db.run(statement);
+        }
+        db.run("INSERT INTO schema_migrations (version, name) VALUES (?, ?)", [
+          migration.version,
+          migration.name
+        ]);
+        this.insertEvent("migration", String(migration.version), migration.name);
+      });
+      apply();
+    }
+  }
+  loadMemories() {
+    const rows = this.requireDb().query("SELECT id, record_json FROM memory_items ORDER BY updated_at ASC").all();
+    const records = [];
+    let invalidCount = 0;
+    for (const row of rows) {
+      try {
+        records.push(validateMemoryRecordRules(JSON.parse(row.record_json), {
+          rejectDurableSecrets: this.config.redaction.rejectDurableSecrets
+        }));
+      } catch {
+        invalidCount++;
+      }
+    }
+    return { records, invalidCount };
+  }
+  loadProposals() {
+    const rows = this.requireDb().query("SELECT id, proposal_json FROM memory_proposals ORDER BY created_at ASC").all();
+    const records = [];
+    let invalidCount = 0;
+    for (const row of rows) {
+      try {
+        const proposal = validateMemoryProposal(JSON.parse(row.proposal_json));
+        if (proposal.proposedRecord) {
+          validateMemoryRecordRules(proposal.proposedRecord, {
+            rejectDurableSecrets: this.config.redaction.rejectDurableSecrets
+          });
+        }
+        records.push(proposal);
+      } catch {
+        invalidCount++;
+      }
+    }
+    return { records, invalidCount };
+  }
+  writeMemory(record3) {
+    this.requireDb().run(`INSERT OR REPLACE INTO memory_items (
+				id,
+				scope_key,
+				kind,
+				updated_at,
+				expires_at,
+				superseded_by,
+				deleted,
+				record_json
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+      record3.id,
+      JSON.stringify(record3.scope),
+      record3.kind,
+      record3.updatedAt,
+      record3.expiresAt ?? null,
+      record3.supersededBy ?? null,
+      record3.metadata.deleted === true ? 1 : 0,
+      JSON.stringify(record3)
+    ]);
+  }
+  async event(operation, targetId, reason) {
+    this.insertEvent(operation, targetId, reason);
+  }
+  insertEvent(operation, targetId, reason) {
+    this.requireDb().run(`INSERT INTO memory_events (
+				id,
+				operation,
+				target_id,
+				reason,
+				timestamp,
+				event_json
+			) VALUES (?, ?, ?, ?, ?, ?)`, [
+      randomUUID9(),
+      operation,
+      targetId,
+      reason ?? null,
+      new Date().toISOString(),
+      reason ? JSON.stringify({ reason }) : null
+    ]);
+  }
+  requireDb() {
+    if (!this.db)
+      throw new Error("SQLite memory provider is not initialized");
+    return this.db;
+  }
+}
+function splitSql(sql) {
+  return sql.split(";").map((statement) => statement.trim()).filter(Boolean);
+}
+
 // src/memory/gateway.ts
 class MemoryGateway {
   context;
@@ -98254,16 +98755,19 @@ class MemoryGateway {
   constructor(context, options = {}) {
     this.context = context;
     this.config = resolveMemoryConfig(options.config ?? DEFAULT_MEMORY_CONFIG);
-    this.provider = options.provider ?? new LocalJsonlMemoryProvider(context.directory, this.config);
+    this.provider = options.provider ?? createConfiguredMemoryProvider(context.directory, this.config);
     this.now = options.now ?? (() => new Date);
   }
   isEnabled() {
     return this.config.enabled;
   }
+  async dispose() {
+    await this.provider.close?.();
+  }
   deriveAllowedScopes() {
-    const resolvedRoot = path96.resolve(this.context.directory);
-    const repoId = createStableId(readGitRemoteUrl(resolvedRoot) ?? path96.basename(resolvedRoot));
-    const workspaceId = createStableId(path96.dirname(resolvedRoot));
+    const resolvedRoot = path97.resolve(this.context.directory);
+    const repoId = createStableId(readGitRemoteUrl(resolvedRoot) ?? path97.basename(resolvedRoot));
+    const workspaceId = createStableId(path97.dirname(resolvedRoot));
     const scopes = [
       { type: "workspace", workspaceId },
       {
@@ -98302,20 +98806,29 @@ class MemoryGateway {
       query,
       task: input.task,
       agentRole: this.context.agentRole,
+      mode: input.mode ?? "manual",
       scopes,
       kinds: input.kinds,
       maxItems,
       tokenBudget,
       minScore: input.minScore ?? this.config.recall.minScore,
+      requireQuerySignal: input.requireQuerySignal,
       includeExpired: input.includeExpired
     };
-    const results = await this.provider.recall(request);
+    const recallResult = this.provider.recallWithDiagnostics ? await this.provider.recallWithDiagnostics(request) : { items: await this.provider.recall(request) };
     const bundle = toRecallBundle({
       id: createBundleId(query, generatedAt),
       query,
       generatedAt,
-      items: results,
-      tokenBudget
+      items: recallResult.items,
+      tokenBudget,
+      diagnostics: recallResult.diagnostics ? {
+        injectionSkipReason: input.mode === "injection" ? resolveInjectionSkipReason(recallResult.diagnostics) : undefined,
+        candidateCount: recallResult.diagnostics.candidateCount,
+        preScoredFilteredCount: recallResult.diagnostics.preScoredFilteredCount,
+        noSignalCount: recallResult.diagnostics.noSignalCount,
+        belowThresholdCount: recallResult.diagnostics.belowThresholdCount
+      } : undefined
     });
     await this.provider.recordRecallUsage?.({
       bundleId: bundle.id,
@@ -98454,6 +98967,12 @@ class MemoryGateway {
 function createMemoryGateway(context, options = {}) {
   return new MemoryGateway(context, options);
 }
+function createConfiguredMemoryProvider(directory, config3) {
+  if (config3.provider === "sqlite") {
+    return new SQLiteMemoryProvider(directory, config3);
+  }
+  return new LocalJsonlMemoryProvider(directory, config3);
+}
 function sourceFromEvidence(evidenceRefs, context) {
   const first = evidenceRefs[0];
   if (!first) {
@@ -98475,7 +98994,7 @@ var gitRemoteUrlCache = new Map;
 function readGitRemoteUrl(directory) {
   if (gitRemoteUrlCache.has(directory))
     return gitRemoteUrlCache.get(directory);
-  const gitConfigPath = path96.join(directory, ".git", "config");
+  const gitConfigPath = path97.join(directory, ".git", "config");
   if (!existsSync50(gitConfigPath)) {
     gitRemoteUrlCache.set(directory, undefined);
     return;
@@ -98503,6 +99022,19 @@ function validateRequestedScopes(requested, allowed) {
   }
   return requested;
 }
+function resolveInjectionSkipReason(diagnostics) {
+  if (diagnostics.returnedCount > 0)
+    return;
+  if (diagnostics.candidateCount === 0)
+    return "no_results";
+  const signalEligibleCount = diagnostics.candidateCount - diagnostics.preScoredFilteredCount;
+  if (signalEligibleCount > 0 && diagnostics.noSignalCount > 0 && diagnostics.noSignalCount >= signalEligibleCount) {
+    return "no_signal";
+  }
+  if (diagnostics.belowThresholdCount > 0)
+    return "below_threshold";
+  return "no_results";
+}
 function scopeKey(scope) {
   return JSON.stringify({
     type: scope.type,
@@ -98510,7 +99042,7 @@ function scopeKey(scope) {
     workspaceId: scope.workspaceId,
     projectId: scope.projectId,
     repoId: scope.repoId,
-    repoRoot: scope.repoRoot ? path96.resolve(scope.repoRoot) : undefined,
+    repoRoot: scope.repoRoot ? path97.resolve(scope.repoRoot) : undefined,
     runId: scope.runId,
     agentId: scope.agentId
   });
@@ -98757,12 +99289,12 @@ function buildScopesFromInput(input) {
 // src/memory/run-log.ts
 init_utils2();
 import { appendFile as appendFile12, mkdir as mkdir19 } from "node:fs/promises";
-import * as path97 from "node:path";
+import * as path98 from "node:path";
 async function appendMemoryRunLog(directory, runId, event) {
   const safeRunId = sanitizeRunId(runId);
-  const relativePath = path97.join("runs", safeRunId, "memory.jsonl");
+  const relativePath = path98.join("runs", safeRunId, "memory.jsonl");
   const filePath = validateSwarmPath(directory, relativePath);
-  await mkdir19(path97.dirname(filePath), { recursive: true });
+  await mkdir19(path98.dirname(filePath), { recursive: true });
   await appendFile12(filePath, `${JSON.stringify({
     ...event,
     runId: safeRunId,
@@ -98897,8 +99429,15 @@ async function recallForAgent(input) {
     agentId: input.agentId,
     runId: input.sessionID
   }, { config: input.config });
-  if (!gateway.isEnabled())
+  const resolvedConfig = resolveMemoryConfig(input.config);
+  if (!gateway.isEnabled()) {
+    await logInjectionSkipped(input, "disabled");
+    return null;
+  }
+  if (!resolvedConfig.recall.injection.enabled) {
+    await logInjectionSkipped(input, "disabled");
     return null;
+  }
   const scopes = gateway.deriveAllowedScopes();
   const planInput = {
     userGoal: compactText(input.userGoal),
@@ -98909,6 +99448,8 @@ async function recallForAgent(input) {
     touchedFiles: extractTouchedFiles(input.agentTask)
   };
   const plan = buildMemoryRecallPlan(planInput, { scopes });
+  plan.maxItems = resolvedConfig.recall.injection.maxItems;
+  plan.tokenBudget = resolvedConfig.recall.injection.tokenBudget;
   await input.appendRunLog(input.directory, input.sessionID, {
     event: "recall_requested",
     runId: input.sessionID ?? "unknown",
@@ -98924,10 +99465,13 @@ async function recallForAgent(input) {
   const recallInput = {
     query: plan.query,
     task: planInput.agentTask,
+    mode: "injection",
     scopes: plan.scopes,
     kinds: plan.kinds,
     maxItems: plan.maxItems,
-    tokenBudget: plan.tokenBudget
+    tokenBudget: plan.tokenBudget,
+    minScore: resolvedConfig.recall.injection.minScore,
+    requireQuerySignal: resolvedConfig.recall.injection.requireQuerySignal
   };
   const bundle = await gateway.recall(recallInput);
   await input.appendRunLog(input.directory, input.sessionID, {
@@ -98940,8 +99484,31 @@ async function recallForAgent(input) {
     scores: bundle.items.map((item) => item.score),
     tokenEstimate: bundle.tokenEstimate
   });
+  if (bundle.items.length === 0) {
+    await logInjectionSkipped(input, bundle.diagnostics?.injectionSkipReason ?? "no_results", bundle);
+  }
   return { bundle, scopes };
 }
+async function logInjectionSkipped(input, reason, bundle) {
+  await input.appendRunLog(input.directory, input.sessionID, {
+    event: "prompt_injection_skipped",
+    runId: input.sessionID ?? "unknown",
+    agentRole: input.agentRole,
+    agentId: input.agentId,
+    bundleId: bundle?.id,
+    memoryIds: bundle?.items.map((item) => item.record.id),
+    scores: bundle?.items.map((item) => item.score),
+    tokenEstimate: bundle?.tokenEstimate,
+    rejectionReason: reason,
+    metadata: {
+      reason,
+      candidateCount: bundle?.diagnostics?.candidateCount,
+      preScoredFilteredCount: bundle?.diagnostics?.preScoredFilteredCount,
+      noSignalCount: bundle?.diagnostics?.noSignalCount,
+      belowThresholdCount: bundle?.diagnostics?.belowThresholdCount
+    }
+  });
+}
 function parseTaskToolInput(input) {
   const record3 = input;
   const rawTool = typeof record3.tool === "string" ? record3.tool : undefined;
@@ -99505,16 +100072,16 @@ init_telemetry();
 
 // src/prm/replay.ts
 import { promises as fs68 } from "node:fs";
-import path98 from "node:path";
+import path99 from "node:path";
 function isPathSafe2(targetPath, basePath) {
-  const resolvedTarget = path98.resolve(targetPath);
-  const resolvedBase = path98.resolve(basePath);
-  const rel = path98.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path98.isAbsolute(rel);
+  const resolvedTarget = path99.resolve(targetPath);
+  const resolvedBase = path99.resolve(basePath);
+  const rel = path99.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path99.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path98.resolve(targetPath);
-  const parts2 = resolved.split(path98.sep);
+  const resolved = path99.resolve(targetPath);
+  const parts2 = resolved.split(path99.sep);
   for (let i2 = 0;i2 < parts2.length - 1; i2++) {
     if (parts2[i2] === ".swarm" && parts2[i2 + 1] === "replays") {
       return true;
@@ -99527,10 +100094,10 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path98.join(directory, ".swarm", "replays");
+    const replayDir = path99.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path98.join(replayDir, filename);
+    const filepath = path99.join(replayDir, filename);
     if (!isPathSafe2(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
@@ -99911,7 +100478,7 @@ init_telemetry();
 init_dist();
 init_create_tool();
 import * as fs69 from "node:fs";
-import * as path99 from "node:path";
+import * as path100 from "node:path";
 init_path_security();
 var WINDOWS_RESERVED_NAMES2 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks2(str) {
@@ -99928,14 +100495,14 @@ function containsWindowsAttacks2(str) {
 }
 function isPathInWorkspace2(filePath, workspace) {
   try {
-    const resolvedPath = path99.resolve(workspace, filePath);
+    const resolvedPath = path100.resolve(workspace, filePath);
     if (!fs69.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs69.realpathSync(workspace);
     const realResolvedPath = fs69.realpathSync(resolvedPath);
-    const relativePath = path99.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path99.isAbsolute(relativePath)) {
+    const relativePath = path100.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path100.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -99944,7 +100511,7 @@ function isPathInWorkspace2(filePath, workspace) {
   }
 }
 function processFile2(file3, cwd, exportedOnly) {
-  const ext = path99.extname(file3);
+  const ext = path100.extname(file3);
   if (containsControlChars(file3)) {
     return {
       file: file3,
@@ -99977,7 +100544,7 @@ function processFile2(file3, cwd, exportedOnly) {
       errorType: "path-outside-workspace"
     };
   }
-  const fullPath = path99.join(cwd, file3);
+  const fullPath = path100.join(cwd, file3);
   if (!fs69.existsSync(fullPath)) {
     return {
       file: file3,
@@ -100269,15 +100836,15 @@ init_task_id();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs70 from "node:fs";
-import * as path100 from "node:path";
+import * as path101 from "node:path";
 var EVIDENCE_DIR = ".swarm/evidence";
 function isValidTaskId3(taskId) {
   return isStrictTaskId(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path100.resolve(workspaceRoot);
-  const swarmPath = path100.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path100.resolve(filePath);
+  const normalizedWorkspace = path101.resolve(workspaceRoot);
+  const swarmPath = path101.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path101.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
@@ -100358,7 +100925,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path100.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path101.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -100455,7 +101022,7 @@ init_state();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs71 from "node:fs";
-import * as path101 from "node:path";
+import * as path102 from "node:path";
 function extractMatches(regex, text) {
   return Array.from(text.matchAll(regex));
 }
@@ -100607,10 +101174,10 @@ async function executeCompletionVerify(args2, directory) {
     let hasFileReadFailure = false;
     for (const filePath of fileTargets) {
       const normalizedPath = filePath.replace(/\\/g, "/");
-      const resolvedPath = path101.resolve(directory, normalizedPath);
-      const projectRoot = path101.resolve(directory);
-      const relative21 = path101.relative(projectRoot, resolvedPath);
-      const withinProject = relative21 === "" || !relative21.startsWith("..") && !path101.isAbsolute(relative21);
+      const resolvedPath = path102.resolve(directory, normalizedPath);
+      const projectRoot = path102.resolve(directory);
+      const relative21 = path102.relative(projectRoot, resolvedPath);
+      const withinProject = relative21 === "" || !relative21.startsWith("..") && !path102.isAbsolute(relative21);
       if (!withinProject) {
         blockedTasks.push({
           task_id: task.id,
@@ -100665,8 +101232,8 @@ async function executeCompletionVerify(args2, directory) {
     blockedTasks
   };
   try {
-    const evidenceDir = path101.join(directory, ".swarm", "evidence", `${phase}`);
-    const evidencePath = path101.join(evidenceDir, "completion-verify.json");
+    const evidenceDir = path102.join(directory, ".swarm", "evidence", `${phase}`);
+    const evidencePath = path102.join(evidenceDir, "completion-verify.json");
     fs71.mkdirSync(evidenceDir, { recursive: true });
     const evidenceBundle = {
       schema_version: "1.0.0",
@@ -100743,11 +101310,11 @@ var completion_verify = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_zod();
 import * as fs73 from "node:fs";
-import * as path103 from "node:path";
+import * as path104 from "node:path";
 
 // src/quality/metrics.ts
 import * as fs72 from "node:fs";
-import * as path102 from "node:path";
+import * as path103 from "node:path";
 var MAX_FILE_SIZE_BYTES4 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -100799,7 +101366,7 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path102.isAbsolute(file3) ? file3 : path102.join(workingDir, file3);
+    const fullPath = path103.isAbsolute(file3) ? file3 : path103.join(workingDir, file3);
     if (!fs72.existsSync(fullPath)) {
       continue;
     }
@@ -100922,7 +101489,7 @@ function countGoExports(content) {
 function getExportCountForFile(filePath) {
   try {
     const content = fs72.readFileSync(filePath, "utf-8");
-    const ext = path102.extname(filePath).toLowerCase();
+    const ext = path103.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -100948,7 +101515,7 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path102.isAbsolute(file3) ? file3 : path102.join(workingDir, file3);
+    const fullPath = path103.isAbsolute(file3) ? file3 : path103.join(workingDir, file3);
     if (!fs72.existsSync(fullPath)) {
       continue;
     }
@@ -100982,7 +101549,7 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path102.isAbsolute(file3) ? file3 : path102.join(workingDir, file3);
+    const fullPath = path103.isAbsolute(file3) ? file3 : path103.join(workingDir, file3);
     if (!fs72.existsSync(fullPath)) {
       continue;
     }
@@ -101015,8 +101582,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename15 = path102.basename(filePath);
-  const _ext = path102.extname(filePath).toLowerCase();
+  const basename15 = path103.basename(filePath);
+  const _ext = path103.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -101097,8 +101664,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path103, glob) {
-  const normalizedPath = path103.replace(/\\/g, "/");
+function matchesGlobSegment(path104, glob) {
+  const normalizedPath = path104.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -101129,8 +101696,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path103, glob) {
-  const normalizedPath = path103.replace(/\\/g, "/");
+function globMatches(path104, glob) {
+  const normalizedPath = path104.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -101166,7 +101733,7 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path102.join(workingDir, "src");
+  const srcDir = path103.join(workingDir, "src");
   if (fs72.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
@@ -101174,14 +101741,14 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path102.join(workingDir, dir);
+    const dirPath = path103.join(workingDir, dir);
     if (fs72.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path102.join(workingDir, "tests");
+  const testsDir = path103.join(workingDir, "tests");
   if (fs72.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
@@ -101189,7 +101756,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path102.join(workingDir, dir);
+    const dirPath = path103.join(workingDir, dir);
     if (fs72.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
@@ -101204,7 +101771,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
   try {
     const entries = fs72.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path102.join(dirPath, entry.name);
+      const fullPath = path103.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -101212,7 +101779,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
         await scanDirectoryForLines(fullPath, includeGlobs, excludeGlobs, isTestScan, callback);
       } else if (entry.isFile()) {
         const relativePath = fullPath.replace(`${dirPath}/`, "");
-        const ext = path102.extname(entry.name).toLowerCase();
+        const ext = path103.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -101463,7 +102030,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   const extSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
   const filteredChurn = new Map;
   for (const [file3, count] of churnMap) {
-    const ext = path103.extname(file3).toLowerCase();
+    const ext = path104.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -101474,7 +102041,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
     if (!fs73.existsSync(fullPath)) {
-      fullPath = path103.join(cwd, file3);
+      fullPath = path104.join(cwd, file3);
     }
     const complexity = getComplexityForFile2(fullPath);
     if (complexity !== null) {
@@ -101642,7 +102209,7 @@ ${body2}`);
 
 // src/council/council-evidence-writer.ts
 init_task_file();
-import { appendFileSync as appendFileSync12, existsSync as existsSync55, mkdirSync as mkdirSync25, readFileSync as readFileSync45 } from "node:fs";
+import { appendFileSync as appendFileSync12, existsSync as existsSync55, mkdirSync as mkdirSync26, readFileSync as readFileSync45 } from "node:fs";
 import { join as join88 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
@@ -101681,7 +102248,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
     throw new Error(`writeCouncilEvidence: invalid taskId "${synthesis.taskId}" — must match N.M or N.M.P format`);
   }
   const dir = join88(workingDir, EVIDENCE_DIR2);
-  mkdirSync25(dir, { recursive: true });
+  mkdirSync26(dir, { recursive: true });
   const filePath = taskEvidencePath(workingDir, synthesis.taskId);
   await _internals45.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
     const existingRoot = Object.create(null);
@@ -101719,7 +102286,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
   });
   try {
     const councilDir = join88(workingDir, ".swarm", "council");
-    mkdirSync25(councilDir, { recursive: true });
+    mkdirSync26(councilDir, { recursive: true });
     const auditLine = JSON.stringify({
       round: synthesis.roundNumber,
       verdict: synthesis.overallVerdict,
@@ -102048,12 +102615,12 @@ function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFi
 }
 
 // src/council/criteria-store.ts
-import { existsSync as existsSync56, mkdirSync as mkdirSync26, readFileSync as readFileSync46, writeFileSync as writeFileSync17 } from "node:fs";
+import { existsSync as existsSync56, mkdirSync as mkdirSync27, readFileSync as readFileSync46, writeFileSync as writeFileSync17 } from "node:fs";
 import { join as join89 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 function writeCriteria(workingDir, taskId, criteria) {
   const dir = join89(workingDir, COUNCIL_DIR);
-  mkdirSync26(dir, { recursive: true });
+  mkdirSync27(dir, { recursive: true });
   const payload = {
     taskId,
     criteria,
@@ -102215,7 +102782,7 @@ var submit_council_verdicts = createSwarmTool({
 init_zod();
 init_loader();
 import * as fs74 from "node:fs";
-import * as path104 from "node:path";
+import * as path105 from "node:path";
 
 // src/council/general-council-advisory.ts
 var ADVISORY_HEADER = "[general_council] (advisory; not blocking)";
@@ -102643,10 +103210,10 @@ var convene_general_council = createSwarmTool({
     const round1 = input.round1Responses;
     const round2 = input.round2Responses ?? [];
     const result = synthesizeGeneralCouncil(input.question, input.mode, round1, round2);
-    const evidenceDir = path104.join(workingDir, ".swarm", "council", "general");
+    const evidenceDir = path105.join(workingDir, ".swarm", "council", "general");
     const safeTimestamp = result.timestamp.replace(/[:.]/g, "-");
     const evidenceFile = `${safeTimestamp}-${input.mode}.json`;
-    const evidencePath = path104.join(evidenceDir, evidenceFile);
+    const evidencePath = path105.join(evidenceDir, evidenceFile);
     try {
       await fs74.promises.mkdir(evidenceDir, { recursive: true });
       await fs74.promises.writeFile(evidencePath, JSON.stringify(result, null, 2));
@@ -102891,7 +103458,7 @@ init_state();
 init_task_id();
 init_create_tool();
 import * as fs75 from "node:fs";
-import * as path105 from "node:path";
+import * as path106 from "node:path";
 function validateTaskIdFormat2(taskId) {
   return validateTaskIdFormat(taskId);
 }
@@ -102965,8 +103532,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path105.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path105.sep);
+    normalizedDir = path106.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path106.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -102976,10 +103543,10 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path105.resolve(normalizedDir);
+    const resolvedDir = path106.resolve(normalizedDir);
     try {
       const realPath = fs75.realpathSync(resolvedDir);
-      const planPath2 = path105.join(realPath, ".swarm", "plan.json");
+      const planPath2 = path106.join(realPath, ".swarm", "plan.json");
       if (!fs75.existsSync(planPath2)) {
         return {
           success: false,
@@ -103000,9 +103567,9 @@ async function executeDeclareScope(args2, fallbackDir) {
     }
     if (normalizedDir && fallbackDir) {
       try {
-        const canonicalWorkingDir = fs75.realpathSync(path105.resolve(normalizedDir));
-        const canonicalProjectRoot = fs75.realpathSync(path105.resolve(fallbackDir));
-        if (canonicalWorkingDir.startsWith(canonicalProjectRoot + path105.sep)) {
+        const canonicalWorkingDir = fs75.realpathSync(path106.resolve(normalizedDir));
+        const canonicalProjectRoot = fs75.realpathSync(path106.resolve(fallbackDir));
+        if (canonicalWorkingDir.startsWith(canonicalProjectRoot + path106.sep)) {
           return {
             success: false,
             message: `working_directory "${normalizedDir}" is a subdirectory of the project root. Use the project root "${fallbackDir}" instead.`,
@@ -103024,7 +103591,7 @@ async function executeDeclareScope(args2, fallbackDir) {
     };
   }
   const directory = normalizedDir || fallbackDir;
-  const planPath = path105.resolve(directory, ".swarm", "plan.json");
+  const planPath = path106.resolve(directory, ".swarm", "plan.json");
   if (!fs75.existsSync(planPath)) {
     return {
       success: false,
@@ -103064,8 +103631,8 @@ async function executeDeclareScope(args2, fallbackDir) {
   const normalizeErrors = [];
   const dir = directory;
   const mergedFiles = rawMergedFiles.map((file3) => {
-    if (path105.isAbsolute(file3)) {
-      const relativePath = path105.relative(dir, file3).replace(/\\/g, "/");
+    if (path106.isAbsolute(file3)) {
+      const relativePath = path106.relative(dir, file3).replace(/\\/g, "/");
       if (relativePath.startsWith("..")) {
         normalizeErrors.push(`Path '${file3}' resolves outside the project directory`);
         return file3;
@@ -103126,7 +103693,7 @@ var declare_scope = createSwarmTool({
 init_zod();
 import * as child_process7 from "node:child_process";
 import * as fs76 from "node:fs";
-import * as path106 from "node:path";
+import * as path107 from "node:path";
 init_create_tool();
 var MAX_DIFF_LINES = 500;
 var DIFF_TIMEOUT_MS = 30000;
@@ -103155,20 +103722,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path107 of paths) {
-    if (!path107 || path107.length === 0) {
+  for (const path108 of paths) {
+    if (!path108 || path108.length === 0) {
       return "empty path not allowed";
     }
-    if (path107.length > MAX_PATH_LENGTH) {
+    if (path108.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path107)) {
+    if (SHELL_METACHARACTERS2.test(path108)) {
       return "path contains shell metacharacters";
     }
-    if (path107.startsWith("-")) {
+    if (path108.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path107)) {
+    if (CONTROL_CHAR_PATTERN2.test(path108)) {
       return "path contains control characters";
     }
   }
@@ -103276,8 +103843,8 @@ var diff = createSwarmTool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path107 = parts2[2];
-          files.push({ path: path107, additions, deletions });
+          const path108 = parts2[2];
+          files.push({ path: path108, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -103317,7 +103884,7 @@ var diff = createSwarmTool({
           } else if (base === "unstaged") {
             const oldRef = `:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
-            newContent = fs76.readFileSync(path106.join(directory, file3.path), "utf-8");
+            newContent = fs76.readFileSync(path107.join(directory, file3.path), "utf-8");
           } else {
             const oldRef = `${base}:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
@@ -103392,7 +103959,7 @@ var diff = createSwarmTool({
 init_zod();
 import * as child_process8 from "node:child_process";
 import * as fs77 from "node:fs";
-import * as path107 from "node:path";
+import * as path108 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var diff_summary = createSwarmTool({
@@ -103445,7 +104012,7 @@ var diff_summary = createSwarmTool({
         }
         try {
           let oldContent;
-          const newContent = fs77.readFileSync(path107.join(workingDir, filePath), "utf-8");
+          const newContent = fs77.readFileSync(path108.join(workingDir, filePath), "utf-8");
           if (fileExistsInHead) {
             oldContent = child_process8.execFileSync("git", ["show", `HEAD:${filePath}`], {
               encoding: "utf-8",
@@ -103674,7 +104241,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs78 from "node:fs";
-import * as path108 from "node:path";
+import * as path109 from "node:path";
 var MAX_FILE_SIZE_BYTES6 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR3 = ".swarm/evidence";
@@ -103701,9 +104268,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path108.resolve(cwd);
-  const swarmPath = path108.join(normalizedCwd, ".swarm");
-  const normalizedPath = path108.resolve(filePath);
+  const normalizedCwd = path109.resolve(cwd);
+  const swarmPath = path109.join(normalizedCwd, ".swarm");
+  const normalizedPath = path109.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -103733,10 +104300,10 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path108.join(evidenceDir, filename);
+    const filePath = path109.join(evidenceDir, filename);
     try {
-      const resolvedPath = path108.resolve(filePath);
-      const evidenceDirResolved = path108.resolve(evidenceDir);
+      const resolvedPath = path109.resolve(filePath);
+      const evidenceDirResolved = path109.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
@@ -103854,7 +104421,7 @@ var evidence_check = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0).map(normalizeEvidenceType);
-    const planPath = path108.join(cwd, PLAN_FILE);
+    const planPath = path109.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -103886,7 +104453,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path108.join(cwd, EVIDENCE_DIR3);
+    const evidenceDir = path109.join(cwd, EVIDENCE_DIR3);
     const evidence = readEvidenceFiles(evidenceDir, cwd);
     const { tasksWithFullEvidence, gaps } = analyzeGaps(completedTasks, evidence, requiredTypes);
     const completeness = completedTasks.length > 0 ? Math.round(tasksWithFullEvidence.length / completedTasks.length * 100) / 100 : 1;
@@ -103904,7 +104471,7 @@ var evidence_check = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs79 from "node:fs";
-import * as path109 from "node:path";
+import * as path110 from "node:path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -103985,12 +104552,12 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path109.join(targetDir, filename);
-      const base = path109.basename(filepath, path109.extname(filepath));
-      const ext = path109.extname(filepath);
+      let filepath = path110.join(targetDir, filename);
+      const base = path110.basename(filepath, path110.extname(filepath));
+      const ext = path110.extname(filepath);
       let counter = 1;
       while (fs79.existsSync(filepath)) {
-        filepath = path109.join(targetDir, `${base}_${counter}${ext}`);
+        filepath = path110.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
@@ -104248,7 +104815,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs80 from "node:fs";
-import * as path110 from "node:path";
+import * as path111 from "node:path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
@@ -104296,7 +104863,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path110.extname(filePath).toLowerCase();
+  const ext = path111.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -104320,15 +104887,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path110.resolve(targetFile);
+    _resolvedTarget = path111.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path110.basename(targetFile, path110.extname(targetFile));
+  const targetBasename = path111.basename(targetFile, path111.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path110.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path110.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path111.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path111.normalize(targetWithoutExt).replace(/\\/g, "/");
   const importRegex = /import\s+(?:\{[\s\S]*?\}|(?:\*\s+as\s+\w+)|\w+)\s+from\s+['"`]([^'"`]+)['"`]|import\s+['"`]([^'"`]+)['"`]|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
   for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
     const modulePath = match[1] || match[2] || match[3];
@@ -104351,9 +104918,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path110.dirname(targetFile);
-    const targetExt = path110.extname(targetFile);
-    const targetBasenameNoExt = path110.basename(targetFile, targetExt);
+    const _targetDir = path111.dirname(targetFile);
+    const targetExt = path111.extname(targetFile);
+    const targetBasenameNoExt = path111.basename(targetFile, targetExt);
     const moduleNormalized = modulePath.replace(/\\/g, "/").replace(/^\.\//, "");
     const moduleName = modulePath.split(/[/\\]/).pop() || "";
     const moduleNameNoExt = moduleName.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
@@ -104421,10 +104988,10 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
     if (SKIP_DIRECTORIES4.has(entry)) {
-      stats.skippedDirs.push(path110.join(dir, entry));
+      stats.skippedDirs.push(path111.join(dir, entry));
       continue;
     }
-    const fullPath = path110.join(dir, entry);
+    const fullPath = path111.join(dir, entry);
     let stat8;
     try {
       stat8 = fs80.statSync(fullPath);
@@ -104438,7 +105005,7 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
     if (stat8.isDirectory()) {
       findSourceFiles2(fullPath, files, stats);
     } else if (stat8.isFile()) {
-      const ext = path110.extname(fullPath).toLowerCase();
+      const ext = path111.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS3.includes(ext)) {
         files.push(fullPath);
       }
@@ -104495,7 +105062,7 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path110.resolve(file3);
+      const targetFile = path111.resolve(file3);
       if (!fs80.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
@@ -104517,7 +105084,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path110.dirname(targetFile);
+      const baseDir = path111.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -104602,7 +105169,7 @@ var imports = createSwarmTool({
 });
 // src/tools/knowledge-ack.ts
 init_zod();
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 init_state();
 init_logger();
 init_create_tool();
@@ -104635,7 +105202,7 @@ var knowledge_ack = createSwarmTool({
     let sessionId = ctx?.sessionID;
     if (!sessionId) {
       warn("[knowledge-ack] No sessionID in tool context — dedup disabled for this acknowledgment");
-      sessionId = randomUUID9();
+      sessionId = randomUUID10();
     }
     const dedupKey = buildAckDedupKey(sessionId, a.id, a.result);
     if (swarmState.knowledgeAckDedup.has(dedupKey)) {
@@ -104665,7 +105232,7 @@ init_knowledge_store();
 init_knowledge_validator();
 init_manager();
 init_create_tool();
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 var VALID_CATEGORIES2 = [
   "process",
   "architecture",
@@ -104739,7 +105306,7 @@ var knowledge_add = createSwarmTool({
       project_name = plan?.title ?? "";
     } catch {}
     const entry = {
-      id: randomUUID10(),
+      id: randomUUID11(),
       tier: "swarm",
       lesson,
       category,
@@ -105142,22 +105709,22 @@ init_schema();
 init_qa_gate_profile();
 init_manager2();
 import * as fs85 from "node:fs";
-import * as path115 from "node:path";
+import * as path116 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
 init_logger();
 init_state2();
 import * as fs81 from "node:fs";
-import * as path111 from "node:path";
+import * as path112 from "node:path";
 var APPROVAL_TTL_MS = 24 * 60 * 60 * 1000;
 function readEvidenceDir(directory, phase) {
   try {
-    const dirPath = validateSwarmPath(directory, path111.posix.join("evidence", String(phase)));
+    const dirPath = validateSwarmPath(directory, path112.posix.join("evidence", String(phase)));
     if (!fs81.existsSync(dirPath))
       return [];
     const entries = fs81.readdirSync(dirPath);
-    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path111.join(dirPath, e));
+    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path112.join(dirPath, e));
   } catch {
     return [];
   }
@@ -105296,16 +105863,16 @@ init_plan_schema();
 init_ledger();
 init_manager();
 import * as fs82 from "node:fs";
-import * as path112 from "node:path";
+import * as path113 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const swarmDir = path112.join(directory, ".swarm");
+    const swarmDir = path113.join(directory, ".swarm");
     fs82.mkdirSync(swarmDir, { recursive: true });
-    const jsonPath = path112.join(swarmDir, "SWARM_PLAN.json");
-    const mdPath = path112.join(swarmDir, "SWARM_PLAN.md");
+    const jsonPath = path113.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path113.join(swarmDir, "SWARM_PLAN.md");
     fs82.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
     fs82.writeFileSync(mdPath, md, "utf8");
@@ -105324,15 +105891,15 @@ init_telemetry();
 // src/turbo/lean/phase-ready.ts
 init_file_locks();
 import * as fs84 from "node:fs";
-import * as path114 from "node:path";
+import * as path115 from "node:path";
 
 // src/turbo/lean/evidence.ts
 init_bun_compat();
 import { rmSync as rmSync6 } from "node:fs";
 import * as fs83 from "node:fs/promises";
-import * as path113 from "node:path";
+import * as path114 from "node:path";
 function leanTurboEvidenceDir(directory, phase) {
-  return path113.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  return path114.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
 }
 function validateLaneId(laneId) {
   if (laneId.length === 0) {
@@ -105354,16 +105921,16 @@ function validateLaneId(laneId) {
 function laneEvidencePath(directory, phase, laneId) {
   validateLaneId(laneId);
   const expectedDir = leanTurboEvidenceDir(directory, phase);
-  const resolvedPath = path113.resolve(path113.join(expectedDir, `${laneId}.json`));
-  const resolvedDir = path113.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path113.sep) && resolvedPath !== resolvedDir) {
+  const resolvedPath = path114.resolve(path114.join(expectedDir, `${laneId}.json`));
+  const resolvedDir = path114.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path114.sep) && resolvedPath !== resolvedDir) {
     throw new Error(`Invalid laneId: path traversal detected (got "${laneId}")`);
   }
   return resolvedPath;
 }
 async function atomicWriteJson(filePath, data) {
   const content = JSON.stringify(data, null, 2);
-  const dir = path113.dirname(filePath);
+  const dir = path114.dirname(filePath);
   await fs83.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
   try {
@@ -105377,7 +105944,7 @@ async function atomicWriteJson(filePath, data) {
   }
 }
 function phaseEvidencePath(directory, phase) {
-  return path113.join(leanTurboEvidenceDir(directory, phase), "lean-turbo-phase.json");
+  return path114.join(leanTurboEvidenceDir(directory, phase), "lean-turbo-phase.json");
 }
 async function writeLaneEvidence(directory, phase, evidence) {
   const targetPath = laneEvidencePath(directory, phase, evidence.laneId);
@@ -105421,7 +105988,7 @@ async function listLaneEvidence(directory, phase) {
     if (entry === "lean-turbo-phase.json") {
       continue;
     }
-    const filePath = path113.join(evidenceDir, entry);
+    const filePath = path114.join(evidenceDir, entry);
     let content;
     try {
       content = await fs83.readFile(filePath, "utf-8");
@@ -105445,7 +106012,7 @@ var DEFAULT_CONFIG2 = {
 };
 function defaultReadPlanJson(dir) {
   try {
-    const planPath = path114.join(dir, ".swarm", "plan.json");
+    const planPath = path115.join(dir, ".swarm", "plan.json");
     if (!fs84.existsSync(planPath))
       return null;
     const raw = fs84.readFileSync(planPath, "utf-8");
@@ -105460,7 +106027,7 @@ function defaultReadPlanJson(dir) {
 }
 function readReviewerEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path114.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
+    const evidencePath = path115.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
     if (!fs84.existsSync(evidencePath)) {
       return null;
     }
@@ -105480,7 +106047,7 @@ function readReviewerEvidenceFromFile(directory, phase) {
 }
 function readCriticEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path114.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
+    const evidencePath = path115.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
     if (!fs84.existsSync(evidencePath)) {
       return null;
     }
@@ -105499,7 +106066,7 @@ function readCriticEvidenceFromFile(directory, phase) {
   }
 }
 function listLaneEvidenceSync(directory, phase) {
-  const evidenceDir = path114.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const evidenceDir = path115.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
   let entries;
   try {
     entries = fs84.readdirSync(evidenceDir);
@@ -105569,7 +106136,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     ...DEFAULT_CONFIG2,
     ...actualConfig
   };
-  const statePath = path114.join(directory, ".swarm", "turbo-state.json");
+  const statePath = path115.join(directory, ".swarm", "turbo-state.json");
   if (!fs84.existsSync(statePath)) {
     return {
       ok: false,
@@ -105757,7 +106324,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (mergedConfig.integrated_diff_required) {
-    const evidencePath = path114.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
+    const evidencePath = path115.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
     let hasDiff = false;
     try {
       const content = fs84.readFileSync(evidencePath, "utf-8");
@@ -106052,7 +106619,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     let driftCheckEnabled = true;
     let driftHasSpecMd = false;
     try {
-      const specMdPath = path115.join(dir, ".swarm", "spec.md");
+      const specMdPath = path116.join(dir, ".swarm", "spec.md");
       driftHasSpecMd = fs85.existsSync(specMdPath);
       const gatePlan = await loadPlan(dir);
       if (gatePlan) {
@@ -106073,7 +106640,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     } else {
       let phaseType;
       try {
-        const planPath = path115.join(dir, ".swarm", "plan.json");
+        const planPath = path116.join(dir, ".swarm", "plan.json");
         if (fs85.existsSync(planPath)) {
           const planRaw = fs85.readFileSync(planPath, "utf-8");
           const plan = JSON.parse(planRaw);
@@ -106085,7 +106652,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
         warnings.push(`Phase ${phase} is annotated as 'non-code'. Drift verification was skipped per phase type annotation.`);
       } else {
         try {
-          const driftEvidencePath = path115.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+          const driftEvidencePath = path116.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
           let driftVerdictFound = false;
           let driftVerdictApproved = false;
           try {
@@ -106123,7 +106690,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
               let incompleteTaskCount = 0;
               let planParseable = false;
               try {
-                const planPath = path115.join(dir, ".swarm", "plan.json");
+                const planPath = path116.join(dir, ".swarm", "plan.json");
                 if (fs85.existsSync(planPath)) {
                   const planRaw = fs85.readFileSync(planPath, "utf-8");
                   const plan = JSON.parse(planRaw);
@@ -106190,7 +106757,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.hallucination_guard === true) {
-            const hgPath = path115.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+            const hgPath = path116.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
             let hgVerdictFound = false;
             let hgVerdictApproved = false;
             try {
@@ -106262,7 +106829,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.mutation_test === true) {
-            const mgPath = path115.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+            const mgPath = path116.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
             let mgVerdictFound = false;
             let mgVerdict;
             try {
@@ -106336,7 +106903,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const effective = getEffectiveGates(profile, overrides);
           if (effective.council_mode === true) {
             councilModeEnabled = true;
-            const pcPath = path115.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+            const pcPath = path116.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
             let pcVerdictFound = false;
             let _pcVerdict;
             let pcQuorumSize;
@@ -106544,7 +107111,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
             const effective = getEffectiveGates(profile, overrides);
             if (effective.final_council === true) {
               finalCouncilEnabled = true;
-              const fcPath = path115.join(dir, ".swarm", "evidence", "final-council.json");
+              const fcPath = path116.join(dir, ".swarm", "evidence", "final-council.json");
               let fcVerdictFound = false;
               let _fcVerdict;
               try {
@@ -106732,7 +107299,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path115.basename(dir);
+      const projectName = path116.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -107102,7 +107669,7 @@ init_utils();
 init_bun_compat();
 init_create_tool();
 import * as fs86 from "node:fs";
-import * as path116 from "node:path";
+import * as path117 from "node:path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -107130,16 +107697,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs86.existsSync(path116.join(cwd, "package.json"))) {
+  if (fs86.existsSync(path117.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs86.existsSync(path116.join(cwd, "pyproject.toml")) || fs86.existsSync(path116.join(cwd, "requirements.txt"))) {
+  if (fs86.existsSync(path117.join(cwd, "pyproject.toml")) || fs86.existsSync(path117.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs86.existsSync(path116.join(cwd, "Cargo.toml"))) {
+  if (fs86.existsSync(path117.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs86.existsSync(path116.join(cwd, "go.mod"))) {
+  if (fs86.existsSync(path117.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -107148,13 +107715,13 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs86.existsSync(path116.join(cwd, "Gemfile")) || fs86.existsSync(path116.join(cwd, "Gemfile.lock"))) {
+  if (fs86.existsSync(path117.join(cwd, "Gemfile")) || fs86.existsSync(path117.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs86.existsSync(path116.join(cwd, "pubspec.yaml"))) {
+  if (fs86.existsSync(path117.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs86.existsSync(path116.join(cwd, "composer.lock"))) {
+  if (fs86.existsSync(path117.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -108290,7 +108857,7 @@ var pkg_audit = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs87 from "node:fs";
-import * as path117 from "node:path";
+import * as path118 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -108413,7 +108980,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path117.basename(filePath);
+  const filename = path118.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -108430,7 +108997,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path117.basename(filePath);
+    const filename = path118.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -108439,7 +109006,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path117.extname(filePath).toLowerCase();
+  const ext = path118.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -108686,9 +109253,9 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path117.isAbsolute(filePath) ? filePath : path117.resolve(directory, filePath);
-    const resolvedDirectory = path117.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path117.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path118.isAbsolute(filePath) ? filePath : path118.resolve(directory, filePath);
+    const resolvedDirectory = path118.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path118.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
     if (!fs87.existsSync(fullPath)) {
@@ -108697,7 +109264,7 @@ async function placeholderScan(input, directory) {
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path117.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path118.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
@@ -108769,7 +109336,7 @@ var placeholder_scan = createSwarmTool({
 });
 // src/tools/pre-check-batch.ts
 import * as fs91 from "node:fs";
-import * as path121 from "node:path";
+import * as path122 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -108910,7 +109477,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs90 from "node:fs";
-import * as path120 from "node:path";
+import * as path121 from "node:path";
 import { extname as extname20 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -109626,7 +110193,7 @@ function executeRulesSync(filePath, content, language) {
 // src/sast/semgrep.ts
 import * as child_process9 from "node:child_process";
 import * as fs88 from "node:fs";
-import * as path118 from "node:path";
+import * as path119 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS3 = 30000;
@@ -109813,7 +110380,7 @@ async function runSemgrep(options) {
 }
 function getRulesDirectory(projectRoot) {
   if (projectRoot) {
-    return path118.resolve(projectRoot, DEFAULT_RULES_DIR);
+    return path119.resolve(projectRoot, DEFAULT_RULES_DIR);
   }
   return DEFAULT_RULES_DIR;
 }
@@ -109834,24 +110401,24 @@ init_create_tool();
 init_utils2();
 import * as crypto10 from "node:crypto";
 import * as fs89 from "node:fs";
-import * as path119 from "node:path";
+import * as path120 from "node:path";
 var BASELINE_SCHEMA_VERSION = "1.0.0";
 var MAX_BASELINE_FINDINGS = 2000;
 var MAX_BASELINE_BYTES = 2 * 1048576;
 var LOCK_RETRY_DELAYS_MS = [50, 100, 200, 400, 800];
 function normalizeFindingPath(directory, file3) {
-  const resolved = path119.isAbsolute(file3) ? file3 : path119.resolve(directory, file3);
-  const rel = path119.relative(path119.resolve(directory), resolved);
+  const resolved = path120.isAbsolute(file3) ? file3 : path120.resolve(directory, file3);
+  const rel = path120.relative(path120.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path119.join("evidence", String(phase), "sast-baseline.json");
+  return path120.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path119.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path120.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path119.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path120.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -109972,8 +110539,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs89.mkdirSync(path119.dirname(baselinePath), { recursive: true });
-  fs89.mkdirSync(path119.dirname(tempPath), { recursive: true });
+  fs89.mkdirSync(path120.dirname(baselinePath), { recursive: true });
+  fs89.mkdirSync(path120.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
@@ -110246,9 +110813,9 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path120.isAbsolute(filePath) ? filePath : path120.resolve(directory, filePath);
-    const resolvedDirectory = path120.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path120.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path121.isAbsolute(filePath) ? filePath : path121.resolve(directory, filePath);
+    const resolvedDirectory = path121.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path121.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
@@ -110563,18 +111130,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path121.win32.resolve(inputPath);
-  } else if (path121.isAbsolute(inputPath)) {
-    resolved = path121.resolve(inputPath);
+    resolved = path122.win32.resolve(inputPath);
+  } else if (path122.isAbsolute(inputPath)) {
+    resolved = path122.resolve(inputPath);
   } else {
-    resolved = path121.resolve(baseDir, inputPath);
+    resolved = path122.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path121.resolve(workspaceDir);
+  const workspaceResolved = path122.resolve(workspaceDir);
   let relative25;
   if (isWinAbs) {
-    relative25 = path121.win32.relative(workspaceResolved, resolved);
+    relative25 = path122.win32.relative(workspaceResolved, resolved);
   } else {
-    relative25 = path121.relative(workspaceResolved, resolved);
+    relative25 = path122.relative(workspaceResolved, resolved);
   }
   if (relative25.startsWith("..")) {
     return "path traversal detected";
@@ -110639,7 +111206,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path121.resolve(file3);
+    const resolvedPath = path122.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -110796,7 +111363,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path121.resolve(file3);
+      const resolvedPath = path122.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -110814,7 +111381,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path121.extname(file3).toLowerCase();
+      const ext = path122.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -111033,7 +111600,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path121.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path122.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -111084,7 +111651,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path121.resolve(directory, file3));
+    changedFiles.push(path122.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -111285,9 +111852,9 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path121.resolve(typedArgs.directory);
-    const workspaceAnchor = path121.resolve(directory);
-    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path121.sep)) {
+    const resolvedDirectory = path122.resolve(typedArgs.directory);
+    const workspaceAnchor = path122.resolve(directory);
+    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path122.sep)) {
       const subDirError = `directory "${typedArgs.directory}" is a subdirectory of the project root — pre_check_batch requires the project root directory "${workspaceAnchor}"`;
       const subDirResult = {
         gates_passed: false,
@@ -111338,7 +111905,7 @@ var pre_check_batch = createSwarmTool({
 });
 // src/tools/repo-map.ts
 init_zod();
-import * as path122 from "node:path";
+import * as path123 from "node:path";
 init_path_security();
 init_create_tool();
 var VALID_ACTIONS = [
@@ -111363,7 +111930,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path122.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path123.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -111386,8 +111953,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path122.isAbsolute(normalized)) {
-    const rel = path122.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path123.isAbsolute(normalized)) {
+    const rel = path123.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath2(rel);
   }
   return normalizeGraphPath2(normalized);
@@ -111532,7 +112099,7 @@ var repo_map = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs92 from "node:fs";
-import * as path123 from "node:path";
+import * as path124 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS = ["MUST", "SHOULD", "SHALL"];
@@ -111601,7 +112168,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path123.join(evidenceDir, entry);
+    const entryPath = path124.join(evidenceDir, entry);
     try {
       const stat8 = fs92.statSync(entryPath);
       if (!stat8.isDirectory()) {
@@ -111617,11 +112184,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path123.join(entryPath, "evidence.json");
+    const evidenceFilePath = path124.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path123.resolve(evidenceFilePath);
-      const evidenceDirResolved = path123.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path123.sep)) {
+      const resolvedPath = path124.resolve(evidenceFilePath);
+      const evidenceDirResolved = path124.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path124.sep)) {
         continue;
       }
       const stat8 = fs92.lstatSync(evidenceFilePath);
@@ -111655,7 +112222,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
             if (Array.isArray(diffEntry.files_changed)) {
               for (const file3 of diffEntry.files_changed) {
                 if (typeof file3 === "string") {
-                  touchedFiles.add(path123.resolve(cwd, file3));
+                  touchedFiles.add(path124.resolve(cwd, file3));
                 }
               }
             }
@@ -111668,8 +112235,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path123.resolve(filePath);
-    const cwdResolved = path123.resolve(cwd);
+    const resolvedPath = path124.resolve(filePath);
+    const cwdResolved = path124.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
@@ -111803,7 +112370,7 @@ var req_coverage = createSwarmTool({
       }, null, 2);
     }
     const cwd = inputDirectory || directory;
-    const specPath = path123.join(cwd, SPEC_FILE);
+    const specPath = path124.join(cwd, SPEC_FILE);
     let specContent;
     try {
       specContent = fs92.readFileSync(specPath, "utf-8");
@@ -111830,7 +112397,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path123.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path124.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -111856,7 +112423,7 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path123.join(evidenceDir, reportFilename);
+    const reportPath = path124.join(evidenceDir, reportFilename);
     try {
       if (!fs92.existsSync(evidenceDir)) {
         fs92.mkdirSync(evidenceDir, { recursive: true });
@@ -111944,7 +112511,7 @@ init_qa_gate_profile();
 init_file_locks();
 import * as crypto11 from "node:crypto";
 import * as fs93 from "node:fs";
-import * as path124 from "node:path";
+import * as path125 from "node:path";
 init_ledger();
 init_manager();
 init_state();
@@ -112022,8 +112589,8 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path124.resolve(args2.working_directory);
-    const resolvedRoot = path124.resolve(fallbackDir);
+    const resolvedTarget = path125.resolve(args2.working_directory);
+    const resolvedRoot = path125.resolve(fallbackDir);
     let fallbackExists = false;
     try {
       fs93.accessSync(resolvedRoot, fs93.constants.F_OK);
@@ -112032,7 +112599,7 @@ async function executeSavePlan(args2, fallbackDir) {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path124.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path125.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -112048,7 +112615,7 @@ async function executeSavePlan(args2, fallbackDir) {
   let specMtime;
   let specHash;
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
-    const specPath = path124.join(targetWorkspace, ".swarm", "spec.md");
+    const specPath = path125.join(targetWorkspace, ".swarm", "spec.md");
     try {
       const stat8 = await fs93.promises.stat(specPath);
       specMtime = stat8.mtime.toISOString();
@@ -112064,7 +112631,7 @@ async function executeSavePlan(args2, fallbackDir) {
     }
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path124.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path125.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
       contextContent = await fs93.promises.readFile(contextPath, "utf8");
@@ -112321,7 +112888,7 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path124.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path125.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
@@ -112344,7 +112911,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path124.join(dir, ".swarm", "plan.json"),
+        plan_path: path125.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -112409,7 +112976,7 @@ var save_plan = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs94 from "node:fs";
-import * as path125 from "node:path";
+import * as path126 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -113259,7 +113826,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs94.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path125.join(dir, entry.name);
+        const fullPath = path126.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -113268,7 +113835,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path125.relative(rootDir, fullPath));
+              manifestFiles.push(path126.relative(rootDir, fullPath));
               break;
             }
           }
@@ -113286,11 +113853,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs94.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path125.join(dir, entry.name);
+        const fullPath = path126.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path125.relative(workingDir, fullPath));
+              found.push(path126.relative(workingDir, fullPath));
               break;
             }
           }
@@ -113303,11 +113870,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path125.dirname(file3);
+    let currentDir = path126.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path125.sep) {
-        dirs.add(path125.join(workingDir, currentDir));
-        const parent = path125.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path126.sep) {
+        dirs.add(path126.join(workingDir, currentDir));
+        const parent = path126.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -113391,7 +113958,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path125.isAbsolute(relativeOutputDir) ? relativeOutputDir : path125.join(workingDir, relativeOutputDir);
+    const outputDir = path126.isAbsolute(relativeOutputDir) ? relativeOutputDir : path126.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -113414,7 +113981,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path125.isAbsolute(manifestFile) ? manifestFile : path125.join(workingDir, manifestFile);
+        const fullPath = path126.isAbsolute(manifestFile) ? manifestFile : path126.join(workingDir, manifestFile);
         if (!fs94.existsSync(fullPath)) {
           continue;
         }
@@ -113431,7 +113998,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path125.join(outputDir, filename);
+    const outputPath = path126.join(outputDir, filename);
     fs94.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -113475,7 +114042,7 @@ var sbom_generate = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs95 from "node:fs";
-import * as path126 from "node:path";
+import * as path127 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -113507,12 +114074,12 @@ function normalizePath4(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path126.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path126.sep) ? cwd : cwd + path126.sep;
+    const resolvedPath = path127.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path127.sep) ? cwd : cwd + path127.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path126.extname(resolvedPath).toLowerCase();
+    const ext = path127.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -113526,7 +114093,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path126.resolve(cwd, candidate);
+    const candidatePath = path127.resolve(cwd, candidate);
     if (fs95.existsSync(candidatePath)) {
       const stats = fs95.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
@@ -113538,7 +114105,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs95.readFileSync(specFile, "utf-8");
-  const ext = path126.extname(specFile).toLowerCase();
+  const ext = path127.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -113614,7 +114181,7 @@ function extractRoutes(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path126.join(dir, entry.name);
+      const fullPath = path127.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -113624,7 +114191,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path126.extname(entry.name).toLowerCase();
+        const ext = path127.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -113792,7 +114359,7 @@ init_bun_compat();
 init_path_security();
 init_create_tool();
 import * as fs96 from "node:fs";
-import * as path127 from "node:path";
+import * as path128 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -113828,11 +114395,11 @@ function containsWindowsAttacks3(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path127.resolve(workspace, filePath);
+    const resolvedPath = path128.resolve(workspace, filePath);
     const realWorkspace = fs96.realpathSync(workspace);
     const realResolvedPath = fs96.realpathSync(resolvedPath);
-    const relativePath = path127.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path127.isAbsolute(relativePath)) {
+    const relativePath = path128.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path128.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -113845,11 +114412,11 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path127.delimiter)) {
+  for (const dir of searchPath.split(path128.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path127.join(dir, isWindows ? "rg.exe" : "rg");
+    const candidate = path128.join(dir, isWindows ? "rg.exe" : "rg");
     if (fs96.existsSync(candidate))
       return candidate;
   }
@@ -113979,8 +114546,8 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
   try {
     const entries = fs96.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path127.join(dir, entry.name);
-      const relativePath = path127.relative(workspace, fullPath);
+      const fullPath = path128.join(dir, entry.name);
+      const relativePath = path128.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -114021,7 +114588,7 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path127.join(opts.workspace, file3);
+    const fullPath = path128.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
@@ -114389,7 +114956,7 @@ init_config();
 init_schema();
 init_create_tool();
 import { mkdir as mkdir21, rename as rename9, writeFile as writeFile16 } from "node:fs/promises";
-import * as path128 from "node:path";
+import * as path129 from "node:path";
 var MAX_SPEC_BYTES = 256 * 1024;
 var spec_write = createSwarmTool({
   description: "Write the canonical project spec to .swarm/spec.md. Atomic write, size-bounded (256 KiB), heading-required. Honors spec_writer.allow_spec_write.",
@@ -114430,8 +114997,8 @@ var spec_write = createSwarmTool({
         reason: 'spec must contain at least one top-level "# Heading"'
       }, null, 2);
     }
-    const target = path128.join(directory, ".swarm", "spec.md");
-    await mkdir21(path128.dirname(target), { recursive: true });
+    const target = path129.join(directory, ".swarm", "spec.md");
+    await mkdir21(path129.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
@@ -114460,13 +115027,13 @@ init_zod();
 init_loader();
 import {
   existsSync as existsSync74,
-  mkdirSync as mkdirSync32,
+  mkdirSync as mkdirSync33,
   readFileSync as readFileSync64,
   renameSync as renameSync20,
   unlinkSync as unlinkSync16,
   writeFileSync as writeFileSync24
 } from "node:fs";
-import path129 from "node:path";
+import path130 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var VerdictSchema2 = exports_external.object({
@@ -114596,7 +115163,7 @@ var submit_phase_council_verdicts = createSwarmTool({
   }
 });
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
-  const mutationGatePath = path129.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
+  const mutationGatePath = path130.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
     const raw = readFileSync64(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -114658,9 +115225,9 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   }
 }
 function writePhaseCouncilEvidence(workingDir, synthesis) {
-  const evidenceDir = path129.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
-  mkdirSync32(evidenceDir, { recursive: true });
-  const evidenceFile = path129.join(evidenceDir, "phase-council.json");
+  const evidenceDir = path130.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
+  mkdirSync33(evidenceDir, { recursive: true });
+  const evidenceFile = path130.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
       {
@@ -114813,16 +115380,20 @@ var swarm_memory_propose = createSwarmTool({
     }, {
       config: config3.memory
     });
-    const proposal = await gateway.propose(parsed.data);
-    return JSON.stringify({
-      success: proposal.status !== "rejected",
-      proposal_id: proposal.id,
-      status: proposal.status,
-      operation: proposal.operation,
-      memory_id: proposal.proposedRecord?.id,
-      rejection_reason: proposal.rejectionReason,
-      message: proposal.status === "pending" ? "Memory proposal created. Durable memory was not written." : "Memory proposal was captured with policy rejection metadata."
-    }, null, 2);
+    try {
+      const proposal = await gateway.propose(parsed.data);
+      return JSON.stringify({
+        success: proposal.status !== "rejected",
+        proposal_id: proposal.id,
+        status: proposal.status,
+        operation: proposal.operation,
+        memory_id: proposal.proposedRecord?.id,
+        rejection_reason: proposal.rejectionReason,
+        message: proposal.status === "pending" ? "Memory proposal created. Durable memory was not written." : "Memory proposal was captured with policy rejection metadata."
+      }, null, 2);
+    } finally {
+      await gateway.dispose();
+    }
   }
 });
 var _internals51 = {
@@ -114886,15 +115457,23 @@ var swarm_memory_recall = createSwarmTool({
     }, {
       config: config3.memory
     });
-    const bundle = await gateway.recall(parsed.data);
-    return JSON.stringify({
-      success: true,
-      bundle_id: bundle.id,
-      memory_ids: bundle.items.map((item) => item.record.id),
-      total: bundle.items.length,
-      token_estimate: bundle.tokenEstimate,
-      prompt_block: bundle.promptBlock
-    }, null, 2);
+    try {
+      const bundle = await gateway.recall(parsed.data);
+      return JSON.stringify({
+        success: true,
+        bundle_id: bundle.id,
+        memory_ids: bundle.items.map((item) => item.record.id),
+        total: bundle.items.length,
+        token_estimate: bundle.tokenEstimate,
+        signals: bundle.items.map((item) => ({
+          memory_id: item.record.id,
+          ...item.signals
+        })),
+        prompt_block: bundle.promptBlock
+      }, null, 2);
+    } finally {
+      await gateway.dispose();
+    }
   }
 });
 var RecallArgsSchema = exports_external.object({
@@ -114917,7 +115496,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs97 from "node:fs";
-import * as path130 from "node:path";
+import * as path131 from "node:path";
 var WINDOWS_RESERVED_NAMES4 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks4(str) {
   if (/:[^\\/]/.test(str))
@@ -114931,14 +115510,14 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path130.resolve(workspace, filePath);
+    const resolvedPath = path131.resolve(workspace, filePath);
     if (!fs97.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs97.realpathSync(workspace);
     const realResolvedPath = fs97.realpathSync(resolvedPath);
-    const relativePath = path130.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path130.isAbsolute(relativePath)) {
+    const relativePath = path131.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path131.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -115146,7 +115725,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path130.resolve(directory, change.file);
+      const fullPath = path131.resolve(directory, change.file);
       if (!fs97.existsSync(fullPath)) {
         errors5.push({
           success: false,
@@ -115450,11 +116029,11 @@ var lean_turbo_acquire_locks = createSwarmTool({
 init_zod();
 init_constants();
 import * as fs99 from "node:fs";
-import * as path132 from "node:path";
+import * as path133 from "node:path";
 
 // src/turbo/lean/conflicts.ts
 import * as fs98 from "node:fs";
-import * as path131 from "node:path";
+import * as path132 from "node:path";
 var DEFAULT_GLOBAL_FILES = [
   "package.json",
   "package-lock.json",
@@ -115581,7 +116160,7 @@ function isProtectedPath2(normalizedPath) {
   return false;
 }
 function readTaskScopes(directory, taskId) {
-  const scopePath = path131.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
+  const scopePath = path132.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
   try {
     if (!fs98.existsSync(scopePath)) {
       return null;
@@ -115969,7 +116548,7 @@ function createEmptyPlan(phaseNumber, planId) {
 // src/tools/lean-turbo-plan-lanes.ts
 init_create_tool();
 function readPlanJson(directory) {
-  const planPath = path132.join(directory, ".swarm", "plan.json");
+  const planPath = path133.join(directory, ".swarm", "plan.json");
   if (!fs99.existsSync(planPath)) {
     return null;
   }
@@ -116024,7 +116603,7 @@ init_config();
 // src/turbo/lean/reviewer.ts
 init_state();
 import * as fs100 from "node:fs/promises";
-import * as path133 from "node:path";
+import * as path134 from "node:path";
 init_state3();
 var DEFAULT_CONFIG3 = {
   reviewerAgent: "",
@@ -116140,9 +116719,9 @@ function parseReviewerVerdict(responseText) {
   return { verdict, reason };
 }
 async function writeReviewerEvidence(directory, phase, verdict, reason) {
-  const evidenceDir = path133.join(directory, ".swarm", "evidence", String(phase));
+  const evidenceDir = path134.join(directory, ".swarm", "evidence", String(phase));
   await fs100.mkdir(evidenceDir, { recursive: true });
-  const evidencePath = path133.join(evidenceDir, "lean-turbo-reviewer.json");
+  const evidencePath = path134.join(evidenceDir, "lean-turbo-reviewer.json");
   const content = JSON.stringify({
     phase,
     verdict,
@@ -116947,7 +117526,7 @@ var lean_turbo_status = createSwarmTool({
 init_spec_schema();
 init_create_tool();
 import * as fs101 from "node:fs";
-import * as path134 from "node:path";
+import * as path135 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHALL", "SHOULD", "MAY"];
@@ -117000,7 +117579,7 @@ var lint_spec = createSwarmTool({
   async execute(_args, directory) {
     const errors5 = [];
     const warnings = [];
-    const specPath = path134.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
+    const specPath = path135.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
     if (!fs101.existsSync(specPath)) {
       const result2 = {
         valid: false,
@@ -117071,12 +117650,12 @@ var lint_spec = createSwarmTool({
 // src/tools/mutation-test.ts
 init_zod();
 import * as fs102 from "node:fs";
-import * as path136 from "node:path";
+import * as path137 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { unlinkSync as unlinkSync17, writeFileSync as writeFileSync25 } from "node:fs";
-import * as path135 from "node:path";
+import * as path136 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -117222,7 +117801,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path135.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path136.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
       writeFileSync25(patchFile, patch.patch);
     } catch (writeErr) {
@@ -117626,7 +118205,7 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path136.resolve(cwd, filePath);
+          const resolvedPath = path137.resolve(cwd, filePath);
           sourceFiles.set(filePath, fs102.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
@@ -117646,7 +118225,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs103 from "node:fs";
-import * as path137 from "node:path";
+import * as path138 from "node:path";
 init_create_tool();
 var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
 var BINARY_CHECK_BYTES = 8192;
@@ -117712,7 +118291,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path137.extname(file3.path).toLowerCase();
+      const ext = path138.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -117725,7 +118304,7 @@ async function syntaxCheck(input, directory, config3) {
   let skippedCount = 0;
   for (const fileInfo of filesToCheck) {
     const { path: filePath } = fileInfo;
-    const fullPath = path137.isAbsolute(filePath) ? filePath : path137.join(directory, filePath);
+    const fullPath = path138.isAbsolute(filePath) ? filePath : path138.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -117774,7 +118353,7 @@ async function syntaxCheck(input, directory, config3) {
         results.push(result);
         continue;
       }
-      const ext = path137.extname(filePath).toLowerCase();
+      const ext = path138.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -117872,7 +118451,7 @@ init_utils();
 init_create_tool();
 init_path_security();
 import * as fs104 from "node:fs";
-import * as path138 from "node:path";
+import * as path139 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -117938,9 +118517,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path138.resolve(paths);
-    const normalizedCwd = path138.resolve(cwd);
-    const normalizedResolved = path138.resolve(resolvedPath);
+    const resolvedPath = path139.resolve(paths);
+    const normalizedCwd = path139.resolve(cwd);
+    const normalizedResolved = path139.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -117956,7 +118535,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path138.extname(filePath).toLowerCase();
+  const ext = path139.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
@@ -117971,7 +118550,7 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES5.has(entry)) {
       continue;
     }
-    const fullPath = path138.join(dir, entry);
+    const fullPath = path139.join(dir, entry);
     let stat8;
     try {
       stat8 = fs104.statSync(fullPath);
@@ -118083,7 +118662,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path138.extname(scanPath)}`,
+          error: `unsupported file extension: ${path139.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -118132,17 +118711,17 @@ init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
 import * as fs108 from "node:fs";
-import * as path142 from "node:path";
+import * as path143 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
 import * as fs106 from "node:fs";
-import * as path140 from "node:path";
+import * as path141 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
 import * as fs105 from "node:fs";
-import * as path139 from "node:path";
+import * as path140 from "node:path";
 var _internals58 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
@@ -118216,10 +118795,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludeRelPath = excludePathRaw.trim();
     if (!excludeRelPath)
       return;
-    const excludePath = path139.isAbsolute(excludeRelPath) ? excludeRelPath : path139.join(directory, excludeRelPath);
+    const excludePath = path140.isAbsolute(excludeRelPath) ? excludeRelPath : path140.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs105.mkdirSync(path139.dirname(excludePath), { recursive: true });
+        fs105.mkdirSync(path140.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
           existing = fs105.readFileSync(excludePath, "utf8");
@@ -118263,7 +118842,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 var _internals59 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path140.join(directory, ".swarm", "plan.json");
+    const planPath = path141.join(directory, ".swarm", "plan.json");
     if (!fs106.existsSync(planPath))
       return null;
     const raw = fs106.readFileSync(planPath, "utf-8");
@@ -118369,7 +118948,7 @@ init_telemetry();
 // src/turbo/lean/task-completion.ts
 init_file_locks();
 import * as fs107 from "node:fs";
-import * as path141 from "node:path";
+import * as path142 from "node:path";
 var _internals60 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
@@ -118388,7 +118967,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path141.basename(file3);
+    const fileName = path142.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -118400,7 +118979,7 @@ function matchesTier3Pattern(files) {
 function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
-    const statePath = path141.join(directory, ".swarm", "turbo-state.json");
+    const statePath = path142.join(directory, ".swarm", "turbo-state.json");
     if (!fs107.existsSync(statePath)) {
       return {
         ok: false,
@@ -118484,11 +119063,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
     };
   }
   const phase = runState.phase ?? 0;
-  const evidencePath = path141.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
-  const expectedDir = path141.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
-  const resolvedPath = path141.resolve(evidencePath);
-  const resolvedDir = path141.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path141.sep) && resolvedPath !== resolvedDir) {
+  const evidencePath = path142.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path142.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path142.resolve(evidencePath);
+  const resolvedDir = path142.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path142.sep) && resolvedPath !== resolvedDir) {
     return {
       ok: false,
       reason: `Lane ID causes path traversal: ${lane.laneId}`,
@@ -118528,7 +119107,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   }
   let filesTouched = [];
   try {
-    const planPath = path141.join(directory, ".swarm", "plan.json");
+    const planPath = path142.join(directory, ".swarm", "plan.json");
     const planRaw = fs107.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
@@ -118612,7 +119191,7 @@ var TIER_3_PATTERNS2 = [
 ];
 function matchesTier3Pattern2(files) {
   for (const file3 of files) {
-    const fileName = path142.basename(file3);
+    const fileName = path143.basename(file3);
     for (const pattern of TIER_3_PATTERNS2) {
       if (pattern.test(fileName)) {
         return true;
@@ -118651,7 +119230,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (!skipStandardTurboBypass && hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path142.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path143.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs108.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -118729,7 +119308,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     if (resolvedDir) {
       try {
-        const planPath = path142.join(resolvedDir, ".swarm", "plan.json");
+        const planPath = path143.join(resolvedDir, ".swarm", "plan.json");
         const planRaw = fs108.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -118966,8 +119545,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
         };
       }
     }
-    normalizedDir = path142.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path142.sep);
+    normalizedDir = path143.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path143.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -118977,10 +119556,10 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
         ]
       };
     }
-    const resolvedDir = path142.resolve(normalizedDir);
+    const resolvedDir = path143.resolve(normalizedDir);
     try {
       const realPath = fs108.realpathSync(resolvedDir);
-      const planPath = path142.join(realPath, ".swarm", "plan.json");
+      const planPath = path143.join(realPath, ".swarm", "plan.json");
       if (!fs108.existsSync(planPath)) {
         return {
           success: false,
@@ -119011,9 +119590,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     directory = fallbackDir;
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs108.realpathSync(path142.resolve(directory));
-    const canonicalRoot = fs108.realpathSync(path142.resolve(fallbackDir));
-    if (canonicalDir.startsWith(canonicalRoot + path142.sep)) {
+    const canonicalDir = fs108.realpathSync(path143.resolve(directory));
+    const canonicalRoot = fs108.realpathSync(path143.resolve(fallbackDir));
+    if (canonicalDir.startsWith(canonicalRoot + path143.sep)) {
       return {
         success: false,
         message: `Invalid working_directory: "${directory}" is a subdirectory of ` + `the project root "${fallbackDir}". Pass the project root path or ` + `omit working_directory entirely.`,
@@ -119025,8 +119604,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path142.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs108.mkdirSync(path142.dirname(evidencePath), { recursive: true });
+      const evidencePath = path143.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs108.mkdirSync(path143.dirname(evidencePath), { recursive: true });
       const fd = fs108.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
@@ -119050,7 +119629,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
-      const planPath = path142.join(directory, ".swarm", "plan.json");
+      const planPath = path143.join(directory, ".swarm", "plan.json");
       const planRaw = fs108.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
@@ -119362,7 +119941,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs109 from "node:fs";
-import path143 from "node:path";
+import path144 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -119410,7 +119989,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path143.join("evidence", String(phase), filename);
+  const relativePath = path144.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -119421,10 +120000,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path143.dirname(validatedPath);
+  const evidenceDir = path144.dirname(validatedPath);
   try {
     await fs109.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path143.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path144.join(evidenceDir, `.${filename}.tmp`);
     await fs109.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs109.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -119520,7 +120099,7 @@ var write_drift_evidence = createSwarmTool({
 init_zod();
 init_loader();
 import fs110 from "node:fs";
-import path144 from "node:path";
+import path145 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -119608,7 +120187,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path144.join("evidence", filename);
+  const relativePath = path145.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -119622,10 +120201,10 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path144.dirname(validatedPath);
+  const evidenceDir = path145.dirname(validatedPath);
   try {
     await fs110.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path144.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path145.join(evidenceDir, `.${filename}.tmp`);
     await fs110.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs110.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -119684,7 +120263,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs111 from "node:fs";
-import path145 from "node:path";
+import path146 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -119732,7 +120311,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path145.join("evidence", String(phase), filename);
+  const relativePath = path146.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -119743,10 +120322,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path145.dirname(validatedPath);
+  const evidenceDir = path146.dirname(validatedPath);
   try {
     await fs111.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path145.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path146.join(evidenceDir, `.${filename}.tmp`);
     await fs111.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs111.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -119795,7 +120374,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs112 from "node:fs";
-import path146 from "node:path";
+import path147 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -119869,7 +120448,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path146.join("evidence", String(phase), filename);
+  const relativePath = path147.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -119880,10 +120459,10 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path146.dirname(validatedPath);
+  const evidenceDir = path147.dirname(validatedPath);
   try {
     await fs112.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path146.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path147.join(evidenceDir, `.${filename}.tmp`);
     await fs112.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs112.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -120233,7 +120812,7 @@ async function initializeOpenCodeSwarm(ctx) {
     const { PreflightTriggerManager: PTM } = await Promise.resolve().then(() => (init_trigger(), exports_trigger));
     preflightTriggerManager = new PTM(automationConfig);
     const { AutomationStatusArtifact: ASA } = await Promise.resolve().then(() => (init_status_artifact(), exports_status_artifact));
-    const swarmDir = path148.resolve(ctx.directory, ".swarm");
+    const swarmDir = path149.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -120412,30 +120991,29 @@ async function initializeOpenCodeSwarm(ctx) {
       swarm_command: createSwarmCommandTool(agentDefinitionMap)
     },
     config: async (opencodeConfig) => {
-      if (!opencodeConfig.agent || typeof opencodeConfig.agent !== "object") {
-        opencodeConfig.agent = {};
-      }
-      if (!opencodeConfig.agent) {
-        opencodeConfig.agent = { ...agents };
-      } else {
-        Object.assign(opencodeConfig.agent, agents);
+      const isObjectRecord = (value) => typeof value === "object" && value !== null;
+      const pluginConfig = opencodeConfig;
+      if (!isObjectRecord(pluginConfig.agent)) {
+        pluginConfig.agent = {};
       }
+      const agentConfig = pluginConfig.agent;
+      Object.assign(agentConfig, agents);
       const autoSelect = config3?.auto_select_architect;
       if (autoSelect) {
         const hasArchitect = Object.keys(agents).some((name2) => stripKnownSwarmPrefix(name2) === "architect");
         if (hasArchitect) {
           for (const builtin of ["build", "plan"]) {
-            const existing = opencodeConfig.agent?.[builtin];
-            if (existing && typeof existing === "object" && existing.disable === true) {
+            const existing = agentConfig[builtin];
+            if (isObjectRecord(existing) && existing.disable === true) {
               continue;
             }
-            opencodeConfig.agent[builtin] = {
-              ...existing && typeof existing === "object" ? existing : {},
+            agentConfig[builtin] = {
+              ...isObjectRecord(existing) ? existing : {},
               disable: true
             };
           }
           if (autoSelect === true) {
-            const primaryArchitects = Object.entries(agents).filter(([name2, cfg]) => stripKnownSwarmPrefix(name2) === "architect" && cfg.mode === "primary");
+            const primaryArchitects = Object.entries(agents).filter(([name2, cfg]) => stripKnownSwarmPrefix(name2) === "architect" && isObjectRecord(cfg) && cfg.mode === "primary");
             if (primaryArchitects.length > 1) {
               const names = primaryArchitects.map(([n]) => n).join(", ");
               addDeferredWarning(`[swarm] auto_select_architect is true but ${primaryArchitects.length} architect agents are primary (${names}). Consider setting auto_select_architect to a specific agent name.`);
@@ -120447,22 +121025,19 @@ async function initializeOpenCodeSwarm(ctx) {
             if (targetIsArchitect) {
               for (const [name2, cfg] of Object.entries(agents)) {
                 if (stripKnownSwarmPrefix(name2) === "architect" && name2 !== targetName) {
-                  if (opencodeConfig.agent && typeof opencodeConfig.agent === "object") {
-                    opencodeConfig.agent[name2] = {
-                      ...cfg && typeof cfg === "object" ? cfg : {},
-                      mode: "subagent"
-                    };
-                  }
+                  agentConfig[name2] = {
+                    ...isObjectRecord(cfg) ? cfg : {},
+                    mode: "subagent"
+                  };
                 }
               }
-              if (opencodeConfig.agent && typeof opencodeConfig.agent === "object") {
-                const targetExisting = opencodeConfig.agent[targetName];
-                opencodeConfig.agent[targetName] = {
-                  ...targetExisting && typeof targetExisting === "object" ? targetExisting : {},
-                  ...agents[targetName] && typeof agents[targetName] === "object" ? agents[targetName] : {},
-                  mode: "primary"
-                };
-              }
+              const targetExisting = agentConfig[targetName];
+              const targetAgent = agents[targetName];
+              agentConfig[targetName] = {
+                ...isObjectRecord(targetExisting) ? targetExisting : {},
+                ...isObjectRecord(targetAgent) ? targetAgent : {},
+                mode: "primary"
+              };
             } else {
               addDeferredWarning(`[swarm] auto_select_architect is set to "${targetName}" but that is not a known architect agent. No architect demotion applied.`);
             }
@@ -120817,7 +121392,7 @@ ${promptRaw}`;
                   "ci-failure-resolver": "CI/CD failure resolution"
                 };
                 const skillPaths = topSkills.map((s) => {
-                  const dirName = path148.basename(path148.dirname(s.skillPath));
+                  const dirName = path149.basename(path149.dirname(s.skillPath));
                   const desc = SKILL_DESCRIPTIONS[dirName] ?? dirName;
                   return `file:${s.skillPath} (-- ${desc})`;
                 }).join(", ");
@@ -120826,7 +121401,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path148.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path149.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {