opencode-swarm 7.164.11 → 7.164.12

package/dist/cli/{index-77z98j76.js → index-k0s8n6m5.js}

@@ -3,17 +3,13 @@ import {
   EvaluationRunV1Schema,
   GateAuditResultV1Schema,
   getProtectedEvaluationRunIds
-} from "./index-pp2nya9v.js";
+} from "./index-x39hjdf1.js";
 import {
   validateWorkspaceRoot
 } from "./index-cw912re7.js";
 import {
-  DURABILITY_CLASSES,
-  getProjectDb,
-  projectDbExists,
-  readEffectiveSpecSync,
-  withDurabilityClass
-} from "./index-b2nj04q6.js";
+  readEffectiveSpecSync
+} from "./index-9ss2m4rs.js";
 import {
   getWorktreeMergeFailure
 } from "./index-zsrtt42s.js";
@@ -27,14 +23,28 @@ import {
   readTaskEvidence,
   readTaskEvidenceRaw,
   sanitizeTaskId
-} from "./index-x43debgx.js";
+} from "./index-ad9064j9.js";
+import {
+  estimateCharsForTokens,
+  estimateTokens,
+  readSwarmFileAsync,
+  validateSwarmPath
+} from "./index-qqq04n70.js";
+import {
+  bunHash,
+  bunWrite,
+  mergeEnvForChild
+} from "./index-p612v1mv.js";
+import {
+  EVIDENCE_MAX_JSON_BYTES,
+  EvidenceBundleSchema,
+  EvidenceSchema
+} from "./index-3qf1vxtb.js";
 import {
   LedgerStaleWriterError,
   appendLedgerEvent,
   computeCurrentPlanHash,
   computePlanLedgerHash,
-  derivePlanId,
-  derivePlanIdentityHash,
   getLatestLedgerSeq,
   initLedger,
   ledgerExists,
@@ -47,40 +57,24 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-e90em0x4.js";
+} from "./index-4vb56w2k.js";
 import {
   appendCoreEventSync
-} from "./index-4gqxppcx.js";
+} from "./index-mee9maf5.js";
 import {
-  init_executor,
-  isUntrustedEnvKey,
-  isValidEnvKey
-} from "./index-4fwbbad3.js";
-import {
-  EVIDENCE_MAX_JSON_BYTES,
-  EvidenceBundleSchema,
-  EvidenceSchema
-} from "./index-3qf1vxtb.js";
-import {
-  estimateCharsForTokens,
-  estimateTokens,
-  readSwarmFileAsync,
-  validateSwarmPath
-} from "./index-zjg4chy2.js";
-import {
-  bunHash,
-  bunWrite,
-  mergeEnvForChild
-} from "./index-r3mvsbtq.js";
-import {
-  PlanSchema
-} from "./index-rhqdsc1x.js";
+  derivePlanId,
+  derivePlanIdentityHash,
+  getCoordinationState,
+  importCoordinationOnce,
+  listCoordinationStates,
+  transitionCoordinationState
+} from "./index-c45662wc.js";
 import {
-  GIT_BINARY_ENV_VAR,
-  describeGitResolution,
-  init_git_executable,
-  resolveGitExecutable
-} from "./index-9e6fdz2h.js";
+  DURABILITY_CLASSES,
+  getProjectDb,
+  projectDbExists,
+  withDurabilityClass
+} from "./index-es64amqt.js";
 import {
   canonicalRootKeyFresh
 } from "./index-7qefgq4j.js";
@@ -88,18 +82,33 @@ import {
   assertProjectRoot,
   tryAcquireLock,
   withEvidenceLock
-} from "./index-2bgr671r.js";
+} from "./index-2bhz5k91.js";
 import {
+  atomicWriteSwarmFileSync,
   invalidateCachedArtifact,
   readCachedParsedFile
-} from "./index-9gxbjkts.js";
+} from "./index-ewv8qa8q.js";
 import {
   emit
-} from "./index-ww6zm5hr.js";
+} from "./index-r2p0pgst.js";
+import {
+  PlanSchema
+} from "./index-vw66q1rw.js";
+import {
+  GIT_BINARY_ENV_VAR,
+  describeGitResolution,
+  init_git_executable,
+  resolveGitExecutable
+} from "./index-9e6fdz2h.js";
 import {
   ZodError,
   init_zod
 } from "./index-bpmtbmy9.js";
+import {
+  init_executor,
+  isUntrustedEnvKey,
+  isValidEnvKey
+} from "./index-4fwbbad3.js";
 import {
   criticalWarn,
   error,
@@ -117,8 +126,8 @@ import {
   openSync,
   readdirSync,
   renameSync as renameSync2,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
+  unlinkSync,
+  writeFileSync
 } from "fs";
 import * as fsPromises from "fs/promises";
 import * as path4 from "path";
@@ -1069,10 +1078,13 @@ var _internals2 = {
 };
 
 // src/turbo/epic/state.ts
+import { createHash as createHash3 } from "crypto";
 import * as fs2 from "fs";
 import * as path2 from "path";
 init_logger();
 var STATE_FILE = "epic-state.json";
+var COORDINATION_NAMESPACE = "turbo.epic.session";
+var MAX_SESSION_WRITE_ATTEMPTS = 5;
 function nowISO() {
   return new Date().toISOString();
 }
@@ -1083,6 +1095,200 @@ function ensureSwarmDir(directory) {
   }
   return swarmDir;
 }
+function stateFilePath(directory) {
+  return path2.join(directory, ".swarm", STATE_FILE);
+}
+function importedStateFilePath(directory) {
+  return `${stateFilePath(directory)}.imported`;
+}
+function archiveStateFileWithoutOverwrite(directory) {
+  const filePath = stateFilePath(directory);
+  if (!fs2.existsSync(filePath))
+    return;
+  const canonical = importedStateFilePath(directory);
+  if (!fs2.existsSync(canonical)) {
+    fs2.renameSync(filePath, canonical);
+    return;
+  }
+  for (let suffix = 1;suffix <= 1000; suffix += 1) {
+    const candidate = `${canonical}.${suffix}`;
+    if (fs2.existsSync(candidate))
+      continue;
+    fs2.renameSync(filePath, candidate);
+    return;
+  }
+  throw new Error("Epic state legacy archive collision limit exceeded");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validatePersistedShape(parsed) {
+  return isRecord(parsed) && parsed.version === 1 && isRecord(parsed.sessions);
+}
+function parsePersistedJson(raw) {
+  const parsed = JSON.parse(raw);
+  if (!validatePersistedShape(parsed)) {
+    const maybe = parsed;
+    throw new Error(`malformed shape (version=${maybe?.version}, sessions type=${Array.isArray(maybe?.sessions) ? "array" : typeof maybe?.sessions})`);
+  }
+  return {
+    version: 1,
+    updatedAt: typeof parsed.updatedAt === "string" && parsed.updatedAt.length > 0 ? parsed.updatedAt : nowISO(),
+    sessions: parsed.sessions
+  };
+}
+function parseSessionPayload(payload, entityKey) {
+  const parsed = JSON.parse(payload);
+  if (!isRecord(parsed) || parsed.sessionID !== entityKey) {
+    throw new Error(`session payload malformed for ${entityKey}: sessionID mismatch`);
+  }
+  return parsed;
+}
+function buildPersistedFromCoordination(directory) {
+  const rows = listCoordinationStates(directory, COORDINATION_NAMESPACE);
+  if (rows.length === 0)
+    return null;
+  const sessions = {};
+  let updatedAt = "";
+  for (const row of rows) {
+    sessions[row.entityKey] = parseSessionPayload(row.payload, row.entityKey);
+    if (!updatedAt || row.updatedAt > updatedAt)
+      updatedAt = row.updatedAt;
+  }
+  return {
+    version: 1,
+    updatedAt: updatedAt || nowISO(),
+    sessions
+  };
+}
+function readLegacyPersisted(directory) {
+  const filePath = stateFilePath(directory);
+  if (!fs2.existsSync(filePath))
+    return null;
+  const raw = fs2.readFileSync(filePath, "utf-8");
+  return {
+    persisted: parsePersistedJson(raw),
+    sourceDigest: createHash3("sha256").update(raw).digest("hex")
+  };
+}
+function writeProjection(directory, persisted) {
+  ensureSwarmDir(directory);
+  const filePath = stateFilePath(directory);
+  if (fs2.existsSync(filePath) && fs2.lstatSync(filePath).isDirectory()) {
+    throw new Error(`${STATE_FILE} is a directory`);
+  }
+  const payload = `${JSON.stringify(persisted, null, 2)}
+`;
+  atomicWriteSwarmFileSync(filePath, payload);
+}
+function seedProjectionBestEffort(directory, persisted) {
+  try {
+    writeProjection(directory, persisted);
+  } catch {}
+}
+function preflightProjectionTarget(directory) {
+  ensureSwarmDir(directory);
+  const filePath = stateFilePath(directory);
+  if (fs2.existsSync(filePath) && fs2.lstatSync(filePath).isDirectory()) {
+    throw new Error(`Epic state persistence prepare failed: ${STATE_FILE} is a directory`);
+  }
+}
+function importLegacyStateIfNeeded(directory) {
+  const legacy = readLegacyPersisted(directory);
+  if (!legacy)
+    return null;
+  const outcome = importCoordinationOnce(directory, {
+    source: STATE_FILE,
+    sourceDigest: legacy.sourceDigest,
+    rowCount: Object.keys(legacy.persisted.sessions).length,
+    emptyNamespace: COORDINATION_NAMESPACE
+  }, () => {
+    for (const [sessionID, state] of Object.entries(legacy.persisted.sessions)) {
+      const result = transitionCoordinationState(directory, {
+        namespace: COORDINATION_NAMESPACE,
+        entityKey: sessionID,
+        expectedRevision: null,
+        generation: 1,
+        status: state.active ? "active" : "inactive",
+        payload: JSON.stringify(state)
+      });
+      if (result.outcome !== "applied") {
+        throw new Error("Epic legacy import conflict");
+      }
+    }
+  });
+  if (outcome === "imported") {
+    archiveStateFileWithoutOverwrite(directory);
+  }
+  const authoritative = buildPersistedFromCoordination(directory) ?? emptyPersisted();
+  seedProjectionBestEffort(directory, authoritative);
+  return authoritative;
+}
+function unreadableStateError(directory) {
+  return new Error(`Epic state is unreadable for ${directory}. Repair .swarm/${STATE_FILE} before continuing.`);
+}
+function ensureReadableState(directory) {
+  if (stateUnreadableMap.get(stateKey(directory)))
+    throw unreadableStateError(directory);
+  if (!readPersisted(directory))
+    throw unreadableStateError(directory);
+}
+function refreshProjectionFromCoordination(directory) {
+  const persisted = buildPersistedFromCoordination(directory) ?? emptyPersisted();
+  writeProjection(directory, persisted);
+}
+function saveSessionRowAtomic(directory, state) {
+  preflightProjectionTarget(directory);
+  ensureReadableState(directory);
+  for (let attempt = 0;attempt < MAX_SESSION_WRITE_ATTEMPTS; attempt++) {
+    const current = getCoordinationState(directory, COORDINATION_NAMESPACE, state.sessionID);
+    const result = transitionCoordinationState(directory, {
+      namespace: COORDINATION_NAMESPACE,
+      entityKey: state.sessionID,
+      expectedRevision: current?.revision ?? null,
+      generation: (current?.generation ?? 0) + 1,
+      status: state.active ? "active" : "inactive",
+      payload: JSON.stringify(state)
+    });
+    if (result.outcome === "applied") {
+      refreshProjectionFromCoordination(directory);
+      return;
+    }
+    if (result.outcome === "revision_conflict" || result.outcome === "stale_generation") {
+      continue;
+    }
+    throw new Error(`Epic state persistence failed: ${result.outcome} for ${state.sessionID}`);
+  }
+  throw new Error(`Epic state persistence failed: contention for ${state.sessionID}`);
+}
+function mutateSessionRowAtomic(directory, sessionID, mutate) {
+  preflightProjectionTarget(directory);
+  ensureReadableState(directory);
+  for (let attempt = 0;attempt < MAX_SESSION_WRITE_ATTEMPTS; attempt++) {
+    const current = getCoordinationState(directory, COORDINATION_NAMESPACE, sessionID);
+    if (!current)
+      return null;
+    const nextState = parseSessionPayload(current.payload, sessionID);
+    mutate(nextState);
+    const result = transitionCoordinationState(directory, {
+      namespace: COORDINATION_NAMESPACE,
+      entityKey: sessionID,
+      expectedRevision: current.revision,
+      generation: current.generation + 1,
+      status: nextState.active ? "active" : "inactive",
+      payload: JSON.stringify(nextState)
+    });
+    if (result.outcome === "applied") {
+      refreshProjectionFromCoordination(directory);
+      return nextState;
+    }
+    if (result.outcome === "revision_conflict" || result.outcome === "stale_generation") {
+      continue;
+    }
+    throw new Error(`Epic state persistence failed: ${result.outcome} for ${sessionID}`);
+  }
+  throw new Error(`Epic state persistence failed: contention for ${sessionID}`);
+}
 function emptyPersisted() {
   return { version: 1, updatedAt: nowISO(), sessions: {} };
 }
@@ -1098,69 +1304,38 @@ function isStateUnreadable(directory) {
 }
 function markStateUnreadable(directory, reason) {
   stateUnreadableMap.set(stateKey(directory), true);
-  error(`[turbo/epic/state] state file unreadable for ${directory}: ${reason} \u2014 failing closed`);
+  error(`[turbo/epic/state] state unreadable for ${directory}: ${reason} \u2014 failing closed`);
 }
 function readPersisted(directory) {
   try {
-    const filePath = path2.join(directory, ".swarm", STATE_FILE);
-    if (!fs2.existsSync(filePath)) {
-      const seed = emptyPersisted();
-      try {
-        ensureSwarmDir(directory);
-        fs2.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
-`, "utf-8");
-      } catch {}
-      return seed;
-    }
-    const raw = fs2.readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
-      markStateUnreadable(directory, `malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
-      return null;
+    const coordinated = buildPersistedFromCoordination(directory);
+    if (coordinated) {
+      const filePath = stateFilePath(directory);
+      if (fs2.existsSync(filePath)) {
+        let matches = false;
+        try {
+          matches = JSON.stringify(parsePersistedJson(fs2.readFileSync(filePath, "utf-8"))) === JSON.stringify(coordinated);
+        } catch {
+          matches = false;
+        }
+        if (!matches)
+          archiveStateFileWithoutOverwrite(directory);
+      }
+      seedProjectionBestEffort(directory, coordinated);
+      return coordinated;
     }
-    return {
-      version: 1,
-      updatedAt: parsed.updatedAt ?? nowISO(),
-      sessions: parsed.sessions
-    };
+    const imported = importLegacyStateIfNeeded(directory);
+    if (imported)
+      return imported;
+    const seed = emptyPersisted();
+    seedProjectionBestEffort(directory, seed);
+    return seed;
   } catch (error2) {
     const reason = error2 instanceof Error ? error2.message : String(error2);
     markStateUnreadable(directory, reason);
     return null;
   }
 }
-function writePersisted(directory, persisted) {
-  if (stateUnreadableMap.get(stateKey(directory))) {
-    throw new Error(`Epic state is unreadable. Please repair .swarm/${STATE_FILE} before continuing.`);
-  }
-  let filePath;
-  let tmpPath;
-  let payload;
-  try {
-    ensureSwarmDir(directory);
-    filePath = path2.join(directory, ".swarm", STATE_FILE);
-    tmpPath = `${filePath}.tmp.${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    persisted.updatedAt = nowISO();
-    payload = `${JSON.stringify(persisted, null, 2)}
-`;
-  } catch (error2) {
-    const msg = error2 instanceof Error ? error2.message : String(error2);
-    error(`[turbo/epic/state] Failed to prepare ${STATE_FILE} write: ${msg}`);
-    throw new Error(`Epic state persistence prepare failed: ${msg}`);
-  }
-  try {
-    fs2.writeFileSync(tmpPath, payload, "utf-8");
-    fs2.renameSync(tmpPath, filePath);
-  } catch (error2) {
-    const msg = error2 instanceof Error ? error2.message : String(error2);
-    error(`[turbo/epic/state] Failed to persist ${STATE_FILE} atomically: ${msg}`);
-    try {
-      if (fs2.existsSync(tmpPath))
-        fs2.unlinkSync(tmpPath);
-    } catch {}
-    throw new Error(`Epic state persistence failed: ${msg}`);
-  }
-}
 function loadEpicSessionState(directory, sessionID) {
   if (stateUnreadableMap.get(stateKey(directory)))
     return null;
@@ -1169,25 +1344,23 @@ function loadEpicSessionState(directory, sessionID) {
     return null;
   return persisted.sessions[sessionID] ?? null;
 }
-function saveEpicSessionState(directory, state) {
-  if (stateUnreadableMap.get(stateKey(directory))) {
-    throw new Error(`Epic state is unreadable for ${directory}. Repair .swarm/${STATE_FILE} before continuing.`);
-  }
-  const persisted = readPersisted(directory);
-  if (!persisted) {
-    throw new Error(`Epic state is unreadable for ${directory}. Repair .swarm/${STATE_FILE} before continuing.`);
-  }
-  persisted.sessions[state.sessionID] = state;
-  writePersisted(directory, persisted);
-}
 function isEpicModeActive(directory, sessionID) {
   const state = loadEpicSessionState(directory, sessionID);
   return state?.active === true;
 }
 function isEpicModeActiveForProject(directory) {
+  if (directory.split(/[\\/]/).includes(".."))
+    return false;
   if (stateUnreadableMap.get(stateKey(directory)))
     return false;
-  if (!fs2.existsSync(path2.join(directory, ".swarm", STATE_FILE))) {
+  const hasLegacyFile = fs2.existsSync(stateFilePath(directory));
+  let hasCoordinationRows = false;
+  try {
+    hasCoordinationRows = projectDbExists(directory) && listCoordinationStates(directory, COORDINATION_NAMESPACE, 1).length > 0;
+  } catch {
+    return false;
+  }
+  if (!hasLegacyFile && !hasCoordinationRows) {
     return false;
   }
   const persisted = readPersisted(directory);
@@ -1200,24 +1373,35 @@ function isEpicModeActiveForProject(directory) {
   return false;
 }
 function enableEpicMode(directory, sessionID) {
-  const current = loadEpicSessionState(directory, sessionID) ?? emptySessionState(sessionID);
-  current.active = true;
-  current.enabledAt = nowISO();
-  current.disabledAt = undefined;
-  saveEpicSessionState(directory, current);
+  const current = loadEpicSessionState(directory, sessionID);
+  if (!current) {
+    saveSessionRowAtomic(directory, {
+      ...emptySessionState(sessionID),
+      active: true,
+      enabledAt: nowISO(),
+      disabledAt: undefined
+    });
+    return;
+  }
+  mutateSessionRowAtomic(directory, sessionID, (state) => {
+    state.active = true;
+    state.enabledAt = nowISO();
+    state.disabledAt = undefined;
+  });
 }
 function disableEpicMode(directory, sessionID) {
   const current = loadEpicSessionState(directory, sessionID);
   if (!current) {
-    saveEpicSessionState(directory, {
+    saveSessionRowAtomic(directory, {
       ...emptySessionState(sessionID),
       disabledAt: nowISO()
     });
     return;
   }
-  current.active = false;
-  current.disabledAt = nowISO();
-  saveEpicSessionState(directory, current);
+  mutateSessionRowAtomic(directory, sessionID, (state) => {
+    state.active = false;
+    state.disabledAt = nowISO();
+  });
 }
 
 // src/turbo/epic/task-commit.ts
@@ -1459,14 +1643,14 @@ function readTaskScopes(directory, taskId) {
 }
 
 // src/utils/spec-hash.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import * as fsSync2 from "fs";
 import { join as join3 } from "path";
 async function computeSpecHash(directory) {
   const spec = _internals4.readEffectiveSpecSync(directory);
   if (!spec)
     return null;
-  return createHash3("sha256").update(spec.content, "utf-8").digest("hex");
+  return createHash4("sha256").update(spec.content, "utf-8").digest("hex");
 }
 async function isSpecStale(directory, plan) {
   const currentHash = await _internals4.computeSpecHash(directory);
@@ -1876,7 +2060,7 @@ ${markdown}`;
     renameSync2(mdTempPath, mdPath);
   } finally {
     try {
-      unlinkSync2(mdTempPath);
+      unlinkSync(mdTempPath);
     } catch {}
   }
   invalidateCachedArtifact(mdPath);
@@ -2234,7 +2418,7 @@ async function savePlan(directory, plan, options) {
           if (errorMessage2.includes("already initialized")) {
             try {
               if (existsSync3(oldLedgerBackupPath))
-                unlinkSync2(oldLedgerBackupPath);
+                unlinkSync(oldLedgerBackupPath);
             } catch {}
           } else {
             if (existsSync3(oldLedgerBackupPath)) {
@@ -2243,7 +2427,7 @@ async function savePlan(directory, plan, options) {
               } catch {
                 copyFileSync(oldLedgerBackupPath, oldLedgerPath);
                 try {
-                  unlinkSync2(oldLedgerBackupPath);
+                  unlinkSync(oldLedgerBackupPath);
                 } catch {}
               }
             }
@@ -2260,13 +2444,13 @@ async function savePlan(directory, plan, options) {
           warn(`[savePlan] Could not archive old ledger (rename failed: ${renameErr instanceof Error ? renameErr.message : String(renameErr)}). Old ledger may still exist at ${oldLedgerBackupPath}.`);
           try {
             if (existsSync3(oldLedgerBackupPath))
-              unlinkSync2(oldLedgerBackupPath);
+              unlinkSync(oldLedgerBackupPath);
           } catch {}
         }
       } else if (!initSucceeded && backupExists) {
         try {
           if (existsSync3(oldLedgerBackupPath))
-            unlinkSync2(oldLedgerBackupPath);
+            unlinkSync(oldLedgerBackupPath);
         } catch {}
       }
       const MAX_ARCHIVED_SIBLINGS = 5;
@@ -2277,7 +2461,7 @@ async function savePlan(directory, plan, options) {
           const toRemove = archivedSiblings.slice(0, archivedSiblings.length - MAX_ARCHIVED_SIBLINGS);
           for (const file of toRemove) {
             try {
-              unlinkSync2(path4.join(swarmDir2, file));
+              unlinkSync(path4.join(swarmDir2, file));
             } catch {}
           }
         }
@@ -2469,7 +2653,7 @@ async function savePlan(directory, plan, options) {
     renameSync2(tempPath, planPath);
   } finally {
     try {
-      unlinkSync2(tempPath);
+      unlinkSync(tempPath);
     } catch {}
   }
   invalidateCachedArtifact(planPath);
@@ -2496,7 +2680,7 @@ ${markdown}`;
       renameSync2(mdTempPath, mdPath);
     } finally {
       try {
-        unlinkSync2(mdTempPath);
+        unlinkSync(mdTempPath);
       } catch {}
     }
     invalidateCachedArtifact(mdPath);
@@ -2568,7 +2752,7 @@ async function rebuildPlan(directory, plan, options) {
   {
     const fd = openSync(tempPlanPath, "w");
     try {
-      writeFileSync2(fd, JSON.stringify(targetPlan, null, 2), "utf8");
+      writeFileSync(fd, JSON.stringify(targetPlan, null, 2), "utf8");
       fsyncSync(fd);
     } finally {
       closeSync(fd);

package/dist/cli/{index-7m32fjb4.js → index-kxv193aq.js}

@@ -1,4 +1,9 @@
 // @bun
+import {
+  queryHistoricalOutcomes,
+  readKnowledgeEvents,
+  recordKnowledgeEvent
+} from "./index-0byep4pe.js";
 import {
   jaccardBigram,
   readKnowledge,
@@ -6,12 +11,7 @@ import {
   resolveSwarmKnowledgePath,
   transactKnowledge,
   wordBigrams
-} from "./index-qbw3yw2d.js";
-import {
-  queryHistoricalOutcomes,
-  readKnowledgeEvents,
-  recordKnowledgeEvent
-} from "./index-ggrp3v00.js";
+} from "./index-888pq4xx.js";
 import {
   init_knowledge_types,
   isActiveStatus
@@ -224,11 +224,11 @@ async function maybeQuarantineOnContradiction(directory, entryId, threshold, win
         alreadyInactive: true
       };
     }
-    const { quarantineEntry } = await import("./knowledge-validator-h8m7065g.js");
+    const { quarantineEntry } = await import("./knowledge-validator-yhd31ryf.js");
     let policyConfig;
     try {
-      const { KnowledgeConfigSchema } = await import("./schema-jbbam3ev.js");
-      const { loadPluginConfigWithMeta } = await import("./index-mmjamc9b.js");
+      const { KnowledgeConfigSchema } = await import("./schema-0xp3bde3.js");
+      const { loadPluginConfigWithMeta } = await import("./index-3fnym6ac.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       policyConfig = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {

package/dist/cli/{index-hp22pzn5.js → index-m8xrbdmn.js}

@@ -14,14 +14,14 @@ import {
   detectWindowsWrites,
   getSharedClassifierGuardrailBlock,
   resolveWriteTargets
-} from "./index-r656jh9j.js";
+} from "./index-5wc5pbzc.js";
 import {
   checkFileAuthority,
   classifyFile,
   isInDeclaredScope,
   redactPath,
   redactShellCommand
-} from "./index-kch6yenm.js";
+} from "./index-wasdrhev.js";
 
 // src/services/guardrail-explain-service.ts
 import path from "path";