opencode-swarm 7.164.11 → 7.164.13

package/dist/cli/{index-r5q5gd2a.js → index-d224mhr9.js}

@@ -2,14 +2,14 @@
 import {
   init_loader,
   loadPluginConfigWithMeta
-} from "./index-rhqdsc1x.js";
+} from "./index-0mwjamha.js";
 import {
   init_schema
-} from "./index-aqppaaqx.js";
+} from "./index-asey3tb3.js";
 import {
   DEFAULT_WORKTREE_ISOLATION_CONFIG,
   init_constants
-} from "./index-50j914b5.js";
+} from "./index-a0d4fp6r.js";
 
 // src/config/index.ts
 init_constants();

package/dist/cli/{index-nqsj0g5y.js → index-dh5th4jn.js}

@@ -5,7 +5,7 @@ import {
   batchDurabilityClass,
   classifyDbWriteError,
   getProjectDb
-} from "./index-b2nj04q6.js";
+} from "./index-w6988bbc.js";
 import {
   _internals,
   canonicalRootKeyFresh
@@ -16,6 +16,13 @@ import {
   warn
 } from "./index-zgwm4ryv.js";
 
+// src/db/canonical-project.ts
+var defaultCanonicalRootRealpath = _internals.realpathSync;
+var defaultCanonicalRootNativeRealpath = _internals.realpathSyncNative;
+function canonicalProjectKey(directory) {
+  return canonicalRootKeyFresh(directory);
+}
+
 // src/background/event-bus.ts
 class AutomationEventBus {
   listeners = new Map;
@@ -83,13 +90,6 @@ function getGlobalEventBus() {
   return globalEventBus;
 }
 
-// src/db/canonical-project.ts
-var defaultCanonicalRootRealpath = _internals.realpathSync;
-var defaultCanonicalRootNativeRealpath = _internals.realpathSyncNative;
-function canonicalProjectKey(directory) {
-  return canonicalRootKeyFresh(directory);
-}
-
 // src/db/group-commit-writer.ts
 init_logger();
 function isClosedHandleError(err) {

package/dist/cli/index-e45htt92.js

@@ -0,0 +1,361 @@
+// @bun
+import {
+  DURABILITY_CLASSES,
+  getProjectDb,
+  projectDbExists,
+  withImmediateTransaction
+} from "./index-w6988bbc.js";
+
+// src/db/coordination-store.ts
+import { createHash } from "crypto";
+var MAX_KEY_CHARS = 512;
+var MAX_STATUS_CHARS = 128;
+var MAX_PAYLOAD_CHARS = 1048576;
+var MAX_EVENTS_PER_STREAM = 2048;
+var MAX_TOTAL_EVENTS = 1e5;
+var MAX_EVENT_FENCES_PER_STREAM = 8192;
+var MAX_TOTAL_EVENT_FENCES = 400000;
+var MAX_COORDINATION_STATE_LIST_ROWS = 25000;
+var COORDINATION_STATE_PAGE_SIZE = 5000;
+var _internals = {
+  maxEventsPerStream: MAX_EVENTS_PER_STREAM,
+  maxTotalEvents: MAX_TOTAL_EVENTS,
+  maxEventFencesPerStream: MAX_EVENT_FENCES_PER_STREAM,
+  maxTotalEventFences: MAX_TOTAL_EVENT_FENCES
+};
+function boundedText(value, label, max) {
+  if (value.length === 0 || value.length > max) {
+    throw new Error(`${label} must contain 1..${max} characters`);
+  }
+  return value;
+}
+function validatePayload(payload) {
+  boundedText(payload, "payload", MAX_PAYLOAD_CHARS);
+  JSON.parse(payload);
+  return payload;
+}
+function digestPayload(payload) {
+  return createHash("sha256").update(payload, "utf8").digest("hex");
+}
+function rowToState(row) {
+  if (!row)
+    return null;
+  validatePayload(row.payload);
+  return {
+    namespace: row.namespace,
+    entityKey: row.entity_key,
+    revision: row.revision,
+    generation: row.generation,
+    status: row.status,
+    payload: row.payload,
+    updatedAt: row.updated_at
+  };
+}
+function readState(db, namespace, entityKey) {
+  const row = db.query(`SELECT namespace, entity_key, revision, generation, status, payload, updated_at
+		 FROM coordination_state WHERE namespace = ? AND entity_key = ?`).get(namespace, entityKey) ?? null;
+  return rowToState(row);
+}
+function transactionHooks() {
+  return {
+    beforeBegin: (db) => _internals.coordinationFaultInjector?.("before_begin", db),
+    beforeOuterCommit: (db) => _internals.coordinationFaultInjector?.("before_outer_commit", db)
+  };
+}
+function withCoordinationTransaction(directory, fn) {
+  return withImmediateTransaction(getProjectDb(directory), DURABILITY_CLASSES.coordination_state, fn, transactionHooks());
+}
+function getCoordinationState(directory, namespace, entityKey) {
+  if (!projectDbExists(directory))
+    return null;
+  return readState(getProjectDb(directory), namespace, entityKey);
+}
+function listCoordinationStates(directory, namespace, limit = 5000) {
+  if (!projectDbExists(directory))
+    return [];
+  const boundedLimit = Number.isFinite(limit) ? Math.max(0, Math.min(MAX_COORDINATION_STATE_LIST_ROWS, Math.trunc(limit))) : 0;
+  if (boundedLimit === 0)
+    return [];
+  const db = getProjectDb(directory);
+  const states = [];
+  let lastEntityKey;
+  while (states.length < boundedLimit) {
+    const pageLimit = Math.min(COORDINATION_STATE_PAGE_SIZE, boundedLimit - states.length);
+    const rows = lastEntityKey === undefined ? db.query(`SELECT namespace, entity_key, revision, generation, status, payload, updated_at
+						 FROM coordination_state WHERE namespace = ? ORDER BY entity_key LIMIT ?`).all(namespace, pageLimit) : db.query(`SELECT namespace, entity_key, revision, generation, status, payload, updated_at
+						 FROM coordination_state
+						 WHERE namespace = ? AND entity_key > ?
+						 ORDER BY entity_key LIMIT ?`).all(namespace, lastEntityKey, pageLimit);
+    if (rows.length === 0)
+      break;
+    states.push(...rows.map((row) => rowToState(row)));
+    lastEntityKey = rows[rows.length - 1]?.entity_key;
+    if (rows.length < pageLimit)
+      break;
+  }
+  return states;
+}
+function countCoordinationStates(directory, namespace) {
+  if (!projectDbExists(directory))
+    return 0;
+  const row = getProjectDb(directory).query("SELECT COUNT(*) AS count FROM coordination_state WHERE namespace = ?").get(namespace);
+  return row?.count ?? 0;
+}
+function deleteCoordinationState(directory, namespace, entityKey, expectedRevision) {
+  return withCoordinationTransaction(directory, () => {
+    const db = getProjectDb(directory);
+    const result = expectedRevision === undefined ? db.run("DELETE FROM coordination_state WHERE namespace = ? AND entity_key = ?", [namespace, entityKey]) : db.run(`DELETE FROM coordination_state
+					 WHERE namespace = ? AND entity_key = ? AND revision = ?`, [namespace, entityKey, expectedRevision]);
+    return result.changes === 1;
+  });
+}
+function deleteCoordinationStateWithinTransaction(directory, namespace, entityKey, expectedRevision) {
+  const db = getProjectDb(directory);
+  const result = expectedRevision === undefined ? db.run("DELETE FROM coordination_state WHERE namespace = ? AND entity_key = ?", [namespace, entityKey]) : db.run(`DELETE FROM coordination_state
+					 WHERE namespace = ? AND entity_key = ? AND revision = ?`, [namespace, entityKey, expectedRevision]);
+  return result.changes === 1;
+}
+function validateTransitionInput(input) {
+  boundedText(input.namespace, "namespace", MAX_KEY_CHARS);
+  boundedText(input.entityKey, "entityKey", MAX_KEY_CHARS);
+  boundedText(input.status, "status", MAX_STATUS_CHARS);
+  validatePayload(input.payload);
+  if (!Number.isSafeInteger(input.generation) || input.generation < 0) {
+    throw new Error("generation must be a nonnegative safe integer");
+  }
+  if (input.event) {
+    if (input.expectedRevision === undefined) {
+      throw new Error("event-bearing coordination transitions require expectedRevision");
+    }
+    boundedText(input.event.streamId, "streamId", MAX_KEY_CHARS);
+    boundedText(input.event.idempotencyKey, "idempotencyKey", MAX_KEY_CHARS);
+    boundedText(input.event.eventType, "eventType", MAX_STATUS_CHARS);
+    validatePayload(input.event.payload);
+    if (input.event.expectedStreamVersion !== undefined && (!Number.isSafeInteger(input.event.expectedStreamVersion) || input.event.expectedStreamVersion < 0)) {
+      throw new Error("expectedStreamVersion must be a nonnegative safe integer");
+    }
+  }
+}
+function transitionCoordinationStateWithinTransaction(directory, input) {
+  validateTransitionInput(input);
+  const db = getProjectDb(directory);
+  const current = readState(db, input.namespace, input.entityKey);
+  if (input.event) {
+    const duplicate = db.query(`SELECT event_type, generation, payload_digest FROM coordination_event_fence
+				 WHERE stream_id = ? AND idempotency_key = ?`).get(input.event.streamId, input.event.idempotencyKey);
+    if (duplicate) {
+      const exact = duplicate.event_type === input.event.eventType && duplicate.generation === input.generation && duplicate.payload_digest === digestPayload(input.event.payload);
+      return {
+        outcome: exact ? "duplicate" : "idempotency_conflict",
+        state: current
+      };
+    }
+  }
+  if (current && input.generation < current.generation) {
+    return { outcome: "stale_generation", state: current };
+  }
+  if (input.expectedRevision === null && current !== null || typeof input.expectedRevision === "number" && current?.revision !== input.expectedRevision) {
+    return { outcome: "revision_conflict", state: current };
+  }
+  const nextRevision = (current?.revision ?? 0) + 1;
+  const now = new Date().toISOString();
+  if (input.event) {
+    const currentStreamVersion = db.query("SELECT MAX(version) AS max FROM coordination_event WHERE stream_id = ?").get(input.event.streamId)?.max ?? 0;
+    if (input.event.expectedStreamVersion !== undefined && input.event.expectedStreamVersion !== currentStreamVersion) {
+      return { outcome: "stream_version_conflict", state: current };
+    }
+    const nextVersion = currentStreamVersion + 1;
+    const payloadDigest = digestPayload(input.event.payload);
+    db.run(`INSERT INTO coordination_event
+				 (stream_id, version, idempotency_key, event_type, generation, payload, created_at)
+				 VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+      input.event.streamId,
+      nextVersion,
+      input.event.idempotencyKey,
+      input.event.eventType,
+      input.generation,
+      input.event.payload,
+      now
+    ]);
+    db.run(`INSERT INTO coordination_event_fence
+				 (stream_id, idempotency_key, event_type, generation, payload_digest, created_at)
+				 VALUES (?, ?, ?, ?, ?, ?)
+				 ON CONFLICT(stream_id, idempotency_key) DO UPDATE SET
+				 event_type = excluded.event_type, generation = excluded.generation,
+				 payload_digest = excluded.payload_digest, created_at = excluded.created_at`, [
+      input.event.streamId,
+      input.event.idempotencyKey,
+      input.event.eventType,
+      input.generation,
+      payloadDigest,
+      now
+    ]);
+    const streamFenceOverflow = (db.query("SELECT COUNT(*) AS count FROM coordination_event_fence WHERE stream_id = ?").get(input.event.streamId)?.count ?? 0) - _internals.maxEventFencesPerStream;
+    if (streamFenceOverflow > 0) {
+      db.run(`DELETE FROM coordination_event_fence WHERE rowid IN (
+					SELECT rowid FROM coordination_event_fence
+					WHERE stream_id = ? ORDER BY created_at, rowid LIMIT ?
+				)`, [input.event.streamId, streamFenceOverflow]);
+    }
+    const totalFenceCount = db.query("SELECT COUNT(*) AS count FROM coordination_event_fence").get()?.count ?? 0;
+    const totalFenceOverflow = totalFenceCount - _internals.maxTotalEventFences;
+    if (totalFenceOverflow > 0) {
+      db.run(`DELETE FROM coordination_event_fence WHERE rowid IN (
+					SELECT rowid FROM coordination_event_fence
+					ORDER BY created_at, stream_id, rowid LIMIT ?
+				)`, [totalFenceOverflow]);
+    }
+    const streamFloor = nextVersion - _internals.maxEventsPerStream;
+    if (streamFloor > 0) {
+      db.run("DELETE FROM coordination_event WHERE stream_id = ? AND version <= ?", [input.event.streamId, streamFloor]);
+    }
+    const total = db.query("SELECT COUNT(*) AS count FROM coordination_event").get()?.count ?? 0;
+    const overflow = total - _internals.maxTotalEvents;
+    if (overflow > 0) {
+      db.run(`DELETE FROM coordination_event WHERE rowid IN (
+						SELECT candidate.rowid FROM coordination_event AS candidate
+						WHERE candidate.version < (
+							SELECT MAX(head.version) FROM coordination_event AS head
+							WHERE head.stream_id = candidate.stream_id
+						)
+						ORDER BY candidate.created_at, candidate.stream_id, candidate.version LIMIT ?
+					)`, [overflow]);
+    }
+    _internals.coordinationFaultInjector?.("after_event_before_state", db);
+  }
+  db.run(`INSERT INTO coordination_state
+			 (namespace, entity_key, revision, generation, status, payload, updated_at)
+			 VALUES (?, ?, ?, ?, ?, ?, ?)
+			 ON CONFLICT(namespace, entity_key) DO UPDATE SET
+			 revision = excluded.revision, generation = excluded.generation,
+			 status = excluded.status, payload = excluded.payload, updated_at = excluded.updated_at`, [
+    input.namespace,
+    input.entityKey,
+    nextRevision,
+    input.generation,
+    input.status,
+    input.payload,
+    now
+  ]);
+  return {
+    outcome: "applied",
+    state: readState(db, input.namespace, input.entityKey)
+  };
+}
+function transitionCoordinationState(directory, input) {
+  validateTransitionInput(input);
+  return withCoordinationTransaction(directory, () => transitionCoordinationStateWithinTransaction(directory, input));
+}
+function getCoordinationLease(directory, namespace, entityKey) {
+  boundedText(namespace, "namespace", MAX_KEY_CHARS);
+  boundedText(entityKey, "entityKey", MAX_KEY_CHARS);
+  const row = getProjectDb(directory).query(`SELECT generation, owner_token, lease_expires_at, payload, updated_at
+			 FROM coordination_lease WHERE namespace = ? AND entity_key = ?`).get(namespace, entityKey);
+  return row ? {
+    namespace,
+    entityKey,
+    generation: row.generation,
+    ownerToken: row.owner_token,
+    leaseExpiresAt: row.lease_expires_at,
+    payload: row.payload,
+    updatedAt: row.updated_at
+  } : null;
+}
+function acquireCoordinationLease(directory, input) {
+  boundedText(input.namespace, "namespace", MAX_KEY_CHARS);
+  boundedText(input.entityKey, "entityKey", MAX_KEY_CHARS);
+  boundedText(input.ownerToken, "ownerToken", MAX_KEY_CHARS);
+  validatePayload(input.payload);
+  if (!Number.isSafeInteger(input.generation) || input.generation < 0) {
+    throw new Error("generation must be a nonnegative safe integer");
+  }
+  const expiryMs = Date.parse(input.leaseExpiresAt);
+  if (!Number.isFinite(expiryMs) || new Date(expiryMs).toISOString() !== input.leaseExpiresAt) {
+    throw new Error("leaseExpiresAt must be a canonical ISO timestamp");
+  }
+  return withCoordinationTransaction(directory, () => {
+    const db = getProjectDb(directory);
+    const row = db.query(`SELECT generation, owner_token, lease_expires_at FROM coordination_lease
+			 WHERE namespace = ? AND entity_key = ?`).get(input.namespace, input.entityKey);
+    if (row && input.generation < row.generation)
+      return { outcome: "stale_generation" };
+    if (row && row.lease_expires_at > new Date().toISOString() && row.owner_token !== input.ownerToken) {
+      return { outcome: "held" };
+    }
+    const now = new Date().toISOString();
+    db.run(`INSERT INTO coordination_lease
+			 (namespace, entity_key, generation, owner_token, lease_expires_at, payload, updated_at)
+			 VALUES (?, ?, ?, ?, ?, ?, ?)
+			 ON CONFLICT(namespace, entity_key) DO UPDATE SET
+			 generation = excluded.generation, owner_token = excluded.owner_token,
+			 lease_expires_at = excluded.lease_expires_at, payload = excluded.payload,
+			 updated_at = excluded.updated_at`, [
+      input.namespace,
+      input.entityKey,
+      input.generation,
+      input.ownerToken,
+      input.leaseExpiresAt,
+      input.payload,
+      now
+    ]);
+    return { outcome: "acquired" };
+  });
+}
+function releaseCoordinationLease(directory, namespace, entityKey, generation, ownerToken) {
+  return withCoordinationTransaction(directory, () => {
+    const result = getProjectDb(directory).run(`DELETE FROM coordination_lease
+			 WHERE namespace = ? AND entity_key = ? AND generation = ? AND owner_token = ?`, [namespace, entityKey, generation, ownerToken]);
+    return result.changes === 1;
+  });
+}
+function importCoordinationOnce(directory, input, importer) {
+  boundedText(input.source, "source", MAX_KEY_CHARS);
+  boundedText(input.sourceDigest, "sourceDigest", MAX_KEY_CHARS);
+  boundedText(input.emptyNamespace, "emptyNamespace", MAX_KEY_CHARS);
+  if (!Number.isSafeInteger(input.rowCount) || input.rowCount < 0) {
+    throw new Error("rowCount must be a nonnegative safe integer");
+  }
+  const result = withCoordinationTransaction(directory, () => {
+    const db = getProjectDb(directory);
+    const prior = db.query("SELECT 1 AS present FROM coordination_import WHERE source = ?").get(input.source);
+    if (prior)
+      return "already_imported";
+    const count = db.query("SELECT COUNT(*) AS count FROM coordination_state WHERE namespace = ?").get(input.emptyNamespace)?.count ?? 0;
+    if (count !== 0)
+      return "state_exists";
+    importer();
+    db.run(`INSERT INTO coordination_import
+			 (source, imported_at, source_digest, row_count) VALUES (?, ?, ?, ?)`, [
+      input.source,
+      new Date().toISOString(),
+      input.sourceDigest,
+      input.rowCount
+    ]);
+    return "imported";
+  });
+  if (result === "imported") {
+    _internals.coordinationFaultInjector?.("after_commit_before_archive", getProjectDb(directory));
+  }
+  return result;
+}
+function deleteCoordinationImports(directory, sources) {
+  const boundedSources = sources.map((source) => boundedText(source, "source", MAX_KEY_CHARS));
+  if (boundedSources.length === 0 || !projectDbExists(directory))
+    return 0;
+  return withCoordinationTransaction(directory, () => {
+    const placeholders = boundedSources.map(() => "?").join(", ");
+    const result = getProjectDb(directory).run(`DELETE FROM coordination_import WHERE source IN (${placeholders})`, boundedSources);
+    return result.changes;
+  });
+}
+
+// src/plan/utils.ts
+import { createHash as createHash2 } from "crypto";
+function derivePlanId(plan) {
+  return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+}
+function derivePlanIdentityHash(plan) {
+  return createHash2("sha256").update(JSON.stringify([plan.swarm, plan.title]), "utf8").digest("hex");
+}
+
+export { MAX_COORDINATION_STATE_LIST_ROWS, withCoordinationTransaction, getCoordinationState, listCoordinationStates, countCoordinationStates, deleteCoordinationState, deleteCoordinationStateWithinTransaction, transitionCoordinationStateWithinTransaction, transitionCoordinationState, getCoordinationLease, acquireCoordinationLease, releaseCoordinationLease, importCoordinationOnce, deleteCoordinationImports, derivePlanId, derivePlanIdentityHash };

package/dist/cli/{index-w95vxjde.js → index-f36hy1x4.js}

@@ -9,7 +9,7 @@ import {
   readEvaluationRun,
   saveEvaluationRun,
   saveTaskSetSnapshot
-} from "./index-pp2nya9v.js";
+} from "./index-tqw8w2n5.js";
 import {
   canonicalHash,
   computeCandidateInputContentHash,
@@ -20,11 +20,15 @@ import {
 } from "./index-txdagbh7.js";
 import {
   bunSpawn
-} from "./index-r3mvsbtq.js";
+} from "./index-p612v1mv.js";
 import {
   exports_external,
   init_zod
 } from "./index-bpmtbmy9.js";
+import {
+  init_logger,
+  warn
+} from "./index-zgwm4ryv.js";
 
 // src/evaluation/runner.ts
 import * as fs3 from "fs";
@@ -192,6 +196,20 @@ init_zod();
 // src/utils/external-tool-runner.ts
 import * as fs from "fs";
 import * as path from "path";
+init_logger();
+function decodeCompleteUtf8Prefix(bytes) {
+  const fatalDecoder = new TextDecoder("utf-8", { fatal: true });
+  try {
+    return fatalDecoder.decode(bytes);
+  } catch {
+    for (let trim = 1;trim <= 3 && trim <= bytes.byteLength; trim += 1) {
+      try {
+        return fatalDecoder.decode(bytes.subarray(0, bytes.byteLength - trim));
+      } catch {}
+    }
+    return new TextDecoder().decode(bytes).replace(/\uFFFD+$/u, "");
+  }
+}
 var DEFAULT_WINDOWS_EXTENSIONS = [".exe", ".cmd", ".bat"];
 var TERMINATION_GRACE_MS = 20;
 var TERMINATION_FORCE_MS = 20;
@@ -325,7 +343,7 @@ function startBoundedStreamRead(stream, maxBytes, onLimitExceeded) {
       offset += chunk.byteLength;
     }
     return {
-      text: new TextDecoder().decode(out),
+      text: decodeCompleteUtf8Prefix(out),
       truncated
     };
   })();
@@ -334,20 +352,32 @@ function startBoundedStreamRead(stream, maxBytes, onLimitExceeded) {
 function timeoutKillSignal(platform) {
   return platform === "win32" ? "SIGTERM" : "SIGKILL";
 }
+function reportKillFailure(error, signal) {
+  if (error?.code === "ESRCH")
+    return;
+  _internals.warn(`external tool process kill failed for ${signal}`, error);
+}
 function killProcess(proc) {
+  const signal = timeoutKillSignal(_internals.platform());
   try {
-    proc?.kill(timeoutKillSignal(_internals.platform()));
-  } catch {}
+    proc?.kill(signal);
+  } catch (error) {
+    reportKillFailure(error, signal);
+  }
 }
 function requestTermination(proc, signal) {
   try {
     if (proc?.killTree) {
-      return proc.killTree(signal).then(() => true, () => false);
+      return proc.killTree(signal).then(() => true, (error) => {
+        reportKillFailure(error, signal);
+        return false;
+      });
     } else {
       proc?.kill(signal);
       return Promise.resolve(proc !== undefined);
     }
-  } catch {
+  } catch (error) {
+    reportKillFailure(error, signal);
     return Promise.resolve(false);
   }
 }
@@ -635,7 +665,8 @@ var _internals = {
   setTimeout,
   clearTimeout,
   clampTimeoutMs,
-  computeSpawnTimeoutMs
+  computeSpawnTimeoutMs,
+  warn
 };
 
 // src/evaluation/disposable-worktree.ts

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

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

package/dist/cli/{index-47kh2103.js → index-fnyw5rzg.js}

@@ -2,10 +2,10 @@
 import {
   captureWorkspaceSnapshot,
   changedFilesSinceSnapshot
-} from "./index-w3gtqey0.js";
+} from "./index-6chhqq2n.js";
 import {
   removeWorktreeProvisioningOwner
-} from "./index-n8688d12.js";
+} from "./index-8bdk7124.js";
 import {
   SOURCE_WORKTREE_GONE_STAGE,
   ensureTaskGateRequirementsReceiptForSettledTransition,
@@ -14,16 +14,22 @@ import {
   reconcileLandedMerge,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-x43debgx.js";
+} from "./index-74514zkh.js";
+import {
+  validateSwarmPath
+} from "./index-anxs69ad.js";
 import {
   appendCoreEventSync
-} from "./index-4gqxppcx.js";
+} from "./index-xwbn7c8m.js";
 import {
   isPathWithinDeclaredScope
 } from "./index-556ja8an.js";
 import {
-  validateSwarmPath
-} from "./index-zjg4chy2.js";
+  canonicalRootKeyFresh
+} from "./index-7qefgq4j.js";
+import {
+  tryAcquireLock
+} from "./index-jre6tm3v.js";
 import {
   init_git_executable,
   resolveGitExecutable
@@ -32,12 +38,6 @@ import {
   advisoryWarn,
   init_warning_buffer
 } from "./index-4rhhvd1a.js";
-import {
-  canonicalRootKeyFresh
-} from "./index-7qefgq4j.js";
-import {
-  tryAcquireLock
-} from "./index-2bgr671r.js";
 import {
   criticalWarn,
   init_logger
@@ -487,7 +487,7 @@ async function cleanupRecoveredWorktree(directory, descriptor) {
     awaitingMergeByCallID,
     cleanupStandardWorktreeForCallId,
     standardWorktreeByCallID
-  } = await import("./worktree-isolation-k2dgfmeg.js");
+  } = await import("./worktree-isolation-vd1s86ya.js");
   standardWorktreeByCallID.delete(descriptor.callID);
   if (hasResidue)
     awaitingMergeByCallID.set(descriptor.callID, {
@@ -611,7 +611,7 @@ async function recoverCoderSettlement(directory, taskId) {
           awaitingMergeByCallID,
           finishStandardWorktreeDispatch,
           standardWorktreeByCallID
-        } = await import("./worktree-isolation-k2dgfmeg.js");
+        } = await import("./worktree-isolation-vd1s86ya.js");
         const descriptor = wal.worktree;
         const reconstructedDispatch = {
           callID: descriptor.callID,

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

@@ -1,4 +1,9 @@
 // @bun
+import {
+  queryHistoricalOutcomes,
+  readKnowledgeEvents,
+  recordKnowledgeEvent
+} from "./index-qtxevgdx.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-grn6tkbt.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-fd761gpx.js");
     let policyConfig;
     try {
-      const { KnowledgeConfigSchema } = await import("./schema-jbbam3ev.js");
-      const { loadPluginConfigWithMeta } = await import("./index-mmjamc9b.js");
+      const { KnowledgeConfigSchema } = await import("./schema-sec49ppy.js");
+      const { loadPluginConfigWithMeta } = await import("./index-y5hfk7ya.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       policyConfig = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {

package/dist/cli/{index-d9entpn3.js → index-g9weyhq6.js}

@@ -2,14 +2,14 @@
 import {
   readKnowledge,
   transactKnowledge
-} from "./index-qbw3yw2d.js";
+} from "./index-grn6tkbt.js";
+import {
+  resolveKnowledgeStoreDir
+} from "./index-6rx1rdaq.js";
 import {
   init_git_executable,
   resolveGitExecutableAsync
 } from "./index-9e6fdz2h.js";
-import {
-  resolveKnowledgeStoreDir
-} from "./index-vdn32nws.js";
 import {
   init_knowledge_types,
   isActiveStatus