opencode-swarm 7.122.0 → 7.123.0

package/dist/cli/index-d6h5hq91.js

@@ -0,0 +1,564 @@
+// @bun
+import {
+  computePlanStructureHash,
+  derivePlanId
+} from "./index-ctpgsj84.js";
+import {
+  PlanSchema
+} from "./index-m1abzg93.js";
+import {
+  require_proper_lockfile
+} from "./index-7g4c7s5r.js";
+import {
+  bunWrite
+} from "./index-qe3v54nb.js";
+import {
+  __toESM
+} from "./index-a76rekgs.js";
+
+// src/scope/scope-persistence.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { createHash } from "crypto";
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/scope/scope-binding.ts
+import * as fs from "fs";
+import * as path from "path";
+var MAX_PENDING_SCOPE_BINDINGS = 256;
+var DEFAULT_SCOPE_BINDING_TTL_MS = 60 * 60 * 1000;
+var pendingScopeBindings = new Map;
+function canonicalWorkspaceIdentity(directory) {
+  try {
+    const real = fs.realpathSync(directory).replace(/\\/g, "/");
+    return process.platform === "win32" ? real.toLowerCase() : real;
+  } catch {
+    return null;
+  }
+}
+function isStrictTaskId(value) {
+  return /^\d+\.\d+(?:\.\d+)*$/.test(value);
+}
+function normalizeScopePath(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim().replace(/\\/g, "/");
+  if (trimmed.length === 0 || trimmed.includes("\x00") || path.posix.isAbsolute(trimmed) || /^[A-Za-z]:\//.test(trimmed))
+    return null;
+  const normalized = path.posix.normalize(trimmed).replace(/^\.\//, "");
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../"))
+    return null;
+  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function normalizeScopeFiles(files) {
+  if (!Array.isArray(files) || files.length === 0 || files.length > 1e4)
+    return null;
+  const normalized = new Set;
+  for (const file of files) {
+    const candidate = normalizeScopePath(file);
+    if (!candidate)
+      return null;
+    normalized.add(candidate);
+  }
+  return normalized.size > 0 ? [...normalized].sort() : null;
+}
+function bindingKey(binding) {
+  return [
+    binding.workspaceIdentity,
+    binding.planStructureHash,
+    binding.taskId,
+    binding.ownerSessionId,
+    binding.ownerMessageId ?? ""
+  ].join("\x00");
+}
+function sweepExpired(now = Date.now()) {
+  for (const [key, binding] of pendingScopeBindings) {
+    if (binding.expiresAt <= now)
+      pendingScopeBindings.delete(key);
+  }
+}
+function registerScopeBinding(binding) {
+  sweepExpired();
+  if (binding.activation === "declaration" && binding.dispatchCallId === undefined) {
+    for (const [existingKey, existing] of pendingScopeBindings) {
+      if (existing.activation === "declaration" && existing.dispatchCallId === undefined && existing.workspaceIdentity === binding.workspaceIdentity && existing.taskId === binding.taskId && existing.ownerSessionId === binding.ownerSessionId)
+        pendingScopeBindings.delete(existingKey);
+    }
+  }
+  const key = bindingKey(binding);
+  pendingScopeBindings.delete(key);
+  pendingScopeBindings.set(key, binding);
+  while (pendingScopeBindings.size > MAX_PENDING_SCOPE_BINDINGS) {
+    const oldest = pendingScopeBindings.keys().next().value;
+    if (!oldest)
+      break;
+    pendingScopeBindings.delete(oldest);
+  }
+}
+function getAuthorizedScopeBinding(input) {
+  return getAuthorizedScopeBindingByPlanIdentity({
+    directory: input.directory,
+    planId: derivePlanId(input.plan),
+    planStructureHash: computePlanStructureHash(input.plan),
+    taskId: input.taskId,
+    activeSessionId: input.activeSessionId
+  });
+}
+function getAuthorizedScopeBindingByPlanIdentity(input) {
+  sweepExpired();
+  const workspaceIdentity = canonicalWorkspaceIdentity(input.directory);
+  if (!workspaceIdentity || !isStrictTaskId(input.taskId))
+    return null;
+  const matches = [...pendingScopeBindings.values()].filter((binding) => binding.workspaceIdentity === workspaceIdentity && binding.planId === input.planId && binding.planStructureHash === input.planStructureHash && binding.taskId === input.taskId && binding.ownerSessionId === input.activeSessionId && binding.activation === "active" && typeof binding.dispatchCallId === "string" && binding.dispatchCallId.length > 0 && binding.ownerMessageId === binding.dispatchCallId && typeof binding.parentOwnerSessionId === "string" && binding.parentOwnerSessionId.length > 0 && binding.ownerSessionId !== binding.parentOwnerSessionId && binding.parentCallId === binding.dispatchCallId);
+  return matches.length === 1 ? matches[0] : null;
+}
+function clearScopeBindings(predicate) {
+  const removed = [];
+  if (!predicate) {
+    removed.push(...pendingScopeBindings.values());
+    pendingScopeBindings.clear();
+    return removed;
+  }
+  for (const [key, binding] of pendingScopeBindings) {
+    if (predicate(binding)) {
+      removed.push(binding);
+      pendingScopeBindings.delete(key);
+    }
+  }
+  return removed;
+}
+
+// src/scope/scope-persistence.ts
+var SCOPE_SCHEMA_VERSION = 1;
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+var LOCK_STALE_MS = 30 * 1000;
+var SCOPES_DIR = ".swarm/scopes";
+var MAX_FILES_PER_SCOPE = 1e4;
+var MAX_PLAN_BYTES = 10 * 1024 * 1024;
+var MAX_SCOPE_BYTES = 2 * 1024 * 1024;
+var WINDOWS_RESERVED = new Set([
+  "CON",
+  "PRN",
+  "AUX",
+  "NUL",
+  "COM1",
+  "COM2",
+  "COM3",
+  "COM4",
+  "COM5",
+  "COM6",
+  "COM7",
+  "COM8",
+  "COM9",
+  "LPT1",
+  "LPT2",
+  "LPT3",
+  "LPT4",
+  "LPT5",
+  "LPT6",
+  "LPT7",
+  "LPT8",
+  "LPT9"
+]);
+function getScopesDir(directory) {
+  return path2.join(directory, SCOPES_DIR);
+}
+function normalizePathForComparison(value) {
+  const normalized = path2.resolve(value);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isSafeTaskId(taskId) {
+  if (typeof taskId !== "string")
+    return false;
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(taskId))
+    return false;
+  const head = taskId.replace(/\.+$/, "").split(".")[0].toUpperCase();
+  if (WINDOWS_RESERVED.has(head))
+    return false;
+  return true;
+}
+function isScopesDirSafe(directory, scopesDir) {
+  try {
+    const resolvedWorkspace = fs2.realpathSync(directory);
+    const expectedSwarmDir = path2.join(resolvedWorkspace, ".swarm");
+    const expectedScopesDir = path2.join(expectedSwarmDir, "scopes");
+    const swarmStat = fs2.lstatSync(expectedSwarmDir);
+    const scopesStat = fs2.lstatSync(expectedScopesDir);
+    if (!swarmStat.isDirectory() || swarmStat.isSymbolicLink() || !scopesStat.isDirectory() || scopesStat.isSymbolicLink())
+      return false;
+    const resolvedScopes = fs2.realpathSync(scopesDir);
+    if (normalizePathForComparison(resolvedScopes) !== normalizePathForComparison(expectedScopesDir))
+      return false;
+    const rel = path2.relative(resolvedWorkspace, resolvedScopes);
+    return rel.length > 0 && !rel.startsWith("..") && !path2.isAbsolute(rel);
+  } catch {
+    return false;
+  }
+}
+function resolveSafeScopeFileForUnlink(directory, targetPath) {
+  try {
+    const resolvedWorkspace = fs2.realpathSync(directory);
+    const scopesDir = path2.join(resolvedWorkspace, SCOPES_DIR);
+    if (!isScopesDirSafe(resolvedWorkspace, scopesDir))
+      return null;
+    const candidate = path2.resolve(targetPath);
+    const resolvedCandidate = fs2.realpathSync(candidate);
+    if (normalizePathForComparison(path2.dirname(candidate)) !== normalizePathForComparison(scopesDir) || normalizePathForComparison(resolvedCandidate) !== normalizePathForComparison(candidate))
+      return null;
+    const relative2 = path2.relative(resolvedWorkspace, resolvedCandidate);
+    if (relative2.length === 0 || relative2 === ".." || relative2.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative2))
+      return null;
+    const leafStat = fs2.lstatSync(candidate);
+    if (!leafStat.isFile() || leafStat.isSymbolicLink())
+      return null;
+    if (!isScopesDirSafe(resolvedWorkspace, scopesDir))
+      return null;
+    const finalResolvedCandidate = fs2.realpathSync(candidate);
+    const finalLeafStat = fs2.lstatSync(candidate);
+    if (normalizePathForComparison(finalResolvedCandidate) !== normalizePathForComparison(candidate) || !finalLeafStat.isFile() || finalLeafStat.isSymbolicLink() || finalLeafStat.dev !== leafStat.dev || finalLeafStat.ino !== leafStat.ino)
+      return null;
+    return candidate;
+  } catch {
+    return null;
+  }
+}
+function getScopeFilePath(directory, taskId) {
+  if (!isSafeTaskId(taskId)) {
+    throw new Error(`Invalid taskId for scope persistence: ${taskId}`);
+  }
+  return path2.join(getScopesDir(directory), `scope-${taskId}.json`);
+}
+function getBindingFilePath(directory, taskId, ownerSessionId) {
+  if (!isSafeTaskId(taskId) || !ownerSessionId.trim()) {
+    throw new Error("Invalid identity for scope binding persistence");
+  }
+  const ownerHash = createHash("sha256").update(ownerSessionId).digest("hex").slice(0, 24);
+  return path2.join(getScopesDir(directory), `binding-${taskId}-${ownerHash}.json`);
+}
+async function writeScopeToDisk(directory, taskId, files, ttlMs = DEFAULT_TTL_MS) {
+  if (!isSafeTaskId(taskId))
+    return;
+  if (!Array.isArray(files) || files.length === 0)
+    return;
+  if (files.length > MAX_FILES_PER_SCOPE)
+    return;
+  const scopesDir = getScopesDir(directory);
+  const scopePath = getScopeFilePath(directory, taskId);
+  try {
+    fs2.mkdirSync(scopesDir, { recursive: true });
+  } catch {
+    return;
+  }
+  if (!isScopesDirSafe(directory, scopesDir))
+    return;
+  const now = Date.now();
+  const payload = {
+    version: SCOPE_SCHEMA_VERSION,
+    taskId,
+    declaredAt: now,
+    expiresAt: now + ttlMs,
+    files: [...files]
+  };
+  const content = JSON.stringify(payload, null, 2);
+  try {
+    const flags = fs2.constants.O_WRONLY | fs2.constants.O_CREAT;
+    const nofollow = fs2.constants.O_NOFOLLOW ?? 0;
+    const fd = fs2.openSync(scopePath, flags | nofollow);
+    fs2.closeSync(fd);
+  } catch {
+    return;
+  }
+  let release;
+  try {
+    release = await import_proper_lockfile.default.lock(scopePath, {
+      stale: LOCK_STALE_MS,
+      retries: { retries: 3, minTimeout: 50, maxTimeout: 200 },
+      realpath: false
+    });
+    await atomicWrite(scopePath, content);
+  } catch {} finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+async function writeScopeBindingToDisk(directory, binding) {
+  if (!isSafeTaskId(binding.taskId) || binding.version !== 2)
+    return;
+  const workspaceIdentity = canonicalWorkspaceIdentity(directory);
+  const files = normalizeScopeFiles(binding.files);
+  if (!workspaceIdentity || workspaceIdentity !== binding.workspaceIdentity || !files || !binding.ownerSessionId || !binding.ownerMessageId || binding.expiresAt <= Date.now())
+    return;
+  const scopesDir = getScopesDir(directory);
+  const scopePath = getBindingFilePath(directory, binding.taskId, binding.ownerSessionId);
+  try {
+    fs2.mkdirSync(scopesDir, { recursive: true });
+  } catch {
+    return;
+  }
+  if (!isScopesDirSafe(directory, scopesDir))
+    return;
+  const content = JSON.stringify({ ...binding, files }, null, 2);
+  try {
+    const flags = fs2.constants.O_WRONLY | fs2.constants.O_CREAT;
+    const nofollow = fs2.constants.O_NOFOLLOW ?? 0;
+    const fd = fs2.openSync(scopePath, flags | nofollow);
+    fs2.closeSync(fd);
+  } catch {
+    return;
+  }
+  let release;
+  try {
+    release = await import_proper_lockfile.default.lock(scopePath, {
+      stale: LOCK_STALE_MS,
+      retries: { retries: 3, minTimeout: 50, maxTimeout: 200 },
+      realpath: false
+    });
+    await atomicWrite(scopePath, content);
+  } catch {} finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+function readScopeBindingFromDisk(input) {
+  if (!isSafeTaskId(input.taskId))
+    return null;
+  const scopesDir = getScopesDir(input.directory);
+  if (!isScopesDirSafe(input.directory, scopesDir))
+    return null;
+  let scopePath;
+  try {
+    scopePath = getBindingFilePath(input.directory, input.taskId, input.ownerSessionId);
+  } catch {
+    return null;
+  }
+  const nofollow = fs2.constants.O_NOFOLLOW ?? 0;
+  let fd;
+  try {
+    fd = fs2.openSync(scopePath, fs2.constants.O_RDONLY | nofollow);
+  } catch {
+    return null;
+  }
+  let raw = "";
+  try {
+    const stat = fs2.fstatSync(fd);
+    if (!stat.isFile() || stat.size > MAX_SCOPE_BYTES)
+      return null;
+    const buffer = Buffer.alloc(stat.size);
+    fs2.readSync(fd, buffer, 0, stat.size, 0);
+    raw = buffer.toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    try {
+      fs2.closeSync(fd);
+    } catch {}
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const now = Date.now();
+  const workspaceIdentity = canonicalWorkspaceIdentity(input.directory);
+  const files = Array.isArray(parsed.files) ? normalizeScopeFiles(parsed.files.filter((file) => typeof file === "string")) : null;
+  if (parsed.version !== 2 || parsed.taskId !== input.taskId || !workspaceIdentity || parsed.workspaceIdentity !== workspaceIdentity || parsed.planId !== derivePlanId(input.plan) || parsed.planStructureHash !== computePlanStructureHash(input.plan) || typeof parsed.declaredAt !== "number" || parsed.declaredAt > now || typeof parsed.expiresAt !== "number" || parsed.expiresAt <= now || !parsed.ownerSessionId || !parsed.ownerMessageId || !parsed.source || !files || parsed.ownerSessionId !== input.ownerSessionId || input.requireDispatchCorrelation === true && (typeof parsed.dispatchCallId !== "string" || parsed.dispatchCallId.length === 0 || parsed.activation !== "active" || parsed.ownerMessageId !== parsed.dispatchCallId || typeof parsed.parentOwnerSessionId !== "string" || parsed.parentOwnerSessionId.length === 0 || parsed.ownerSessionId === parsed.parentOwnerSessionId || parsed.parentCallId !== parsed.dispatchCallId) || input.requireDeclaration === true && (parsed.activation !== "declaration" || parsed.dispatchCallId !== undefined) || input.parentCallId !== undefined && parsed.parentCallId !== input.parentCallId)
+    return null;
+  return { ...parsed, files };
+}
+function clearScopeBindingFromDisk(input) {
+  try {
+    const resolvedWorkspace = fs2.realpathSync(input.directory);
+    const scopePath = getBindingFilePath(resolvedWorkspace, input.taskId, input.ownerSessionId);
+    const safePath = resolveSafeScopeFileForUnlink(resolvedWorkspace, scopePath);
+    if (!safePath)
+      return;
+    fs2.unlinkSync(safePath);
+  } catch {}
+}
+function readCurrentPlan(directory) {
+  try {
+    const planPath = path2.join(directory, ".swarm", "plan.json");
+    const stat = fs2.statSync(planPath);
+    if (!stat.isFile() || stat.size > MAX_PLAN_BYTES)
+      return null;
+    const parsed = PlanSchema.safeParse(JSON.parse(fs2.readFileSync(planPath, "utf8")));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+function resolveAuthorizedScopeBindingForPlan(input) {
+  const inMemory = getAuthorizedScopeBinding(input);
+  if (inMemory)
+    return inMemory;
+  const durable = readScopeBindingFromDisk({
+    directory: input.directory,
+    taskId: input.taskId,
+    plan: input.plan,
+    ownerSessionId: input.activeSessionId,
+    requireDispatchCorrelation: true
+  });
+  if (durable)
+    registerScopeBinding(durable);
+  return durable;
+}
+function resolveAuthorizedScopeBinding(input) {
+  const plan = readCurrentPlan(input.directory);
+  return plan ? resolveAuthorizedScopeBindingForPlan({ ...input, plan }) : null;
+}
+function resolveAuthorizedScopeBindingForSession(input) {
+  const plan = readCurrentPlan(input.directory);
+  if (!plan)
+    return null;
+  const matches = [];
+  for (const task of plan.phases.flatMap((phase) => phase.tasks)) {
+    const binding = resolveAuthorizedScopeBindingForPlan({
+      directory: input.directory,
+      plan,
+      taskId: task.id,
+      activeSessionId: input.activeSessionId
+    });
+    if (binding)
+      matches.push(binding);
+    if (matches.length > 1)
+      return null;
+  }
+  return matches[0] ?? null;
+}
+async function atomicWrite(targetPath, content) {
+  const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
+  try {
+    await bunWrite(tempPath, content);
+    fs2.renameSync(tempPath, targetPath);
+  } finally {
+    try {
+      fs2.unlinkSync(tempPath);
+    } catch {}
+  }
+}
+function readScopeFromDisk(directory, taskId) {
+  if (!isSafeTaskId(taskId))
+    return null;
+  const scopesDir = getScopesDir(directory);
+  if (!isScopesDirSafe(directory, scopesDir))
+    return null;
+  const scopePath = getScopeFilePath(directory, taskId);
+  const nofollow = fs2.constants.O_NOFOLLOW ?? 0;
+  let fd;
+  try {
+    fd = fs2.openSync(scopePath, fs2.constants.O_RDONLY | nofollow);
+  } catch {
+    return null;
+  }
+  let raw;
+  try {
+    const stat = fs2.fstatSync(fd);
+    if (!stat.isFile())
+      return null;
+    if (stat.size > MAX_SCOPE_BYTES)
+      return null;
+    const buf = Buffer.alloc(stat.size);
+    fs2.readSync(fd, buf, 0, stat.size, 0);
+    raw = buf.toString("utf-8");
+  } catch {
+    return null;
+  } finally {
+    try {
+      fs2.closeSync(fd);
+    } catch {}
+  }
+  if (!raw.trim())
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed.version !== SCOPE_SCHEMA_VERSION)
+    return null;
+  if (parsed.taskId !== taskId)
+    return null;
+  const now = Date.now();
+  if (typeof parsed.declaredAt !== "number" || parsed.declaredAt > now) {
+    return null;
+  }
+  if (typeof parsed.expiresAt !== "number" || now >= parsed.expiresAt) {
+    return null;
+  }
+  if (!Array.isArray(parsed.files))
+    return null;
+  if (parsed.files.length > MAX_FILES_PER_SCOPE)
+    return null;
+  const files = parsed.files.filter((f) => typeof f === "string");
+  return files.length > 0 ? files : null;
+}
+function readPlanScope(directory, taskId) {
+  if (!isSafeTaskId(taskId))
+    return null;
+  try {
+    const planPath = path2.join(directory, ".swarm", "plan.json");
+    const stat = fs2.statSync(planPath);
+    if (!stat.isFile())
+      return null;
+    if (stat.size > MAX_PLAN_BYTES)
+      return null;
+    const raw = fs2.readFileSync(planPath, "utf-8");
+    const plan = JSON.parse(raw);
+    for (const phase of plan.phases ?? []) {
+      for (const task of phase.tasks ?? []) {
+        if (task.id !== taskId)
+          continue;
+        const ft = task.files_touched;
+        if (Array.isArray(ft) && ft.length > 0) {
+          if (ft.length > MAX_FILES_PER_SCOPE)
+            return null;
+          return ft.filter((f) => typeof f === "string");
+        }
+        if (typeof ft === "string" && ft.length > 0)
+          return [ft];
+        return null;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function clearScopeForTask(directory, taskId) {
+  if (!isSafeTaskId(taskId))
+    return;
+  try {
+    fs2.unlinkSync(getScopeFilePath(directory, taskId));
+  } catch {}
+}
+function clearAllScopes(directory) {
+  try {
+    fs2.rmSync(getScopesDir(directory), { recursive: true, force: true });
+  } catch {}
+}
+function resolveScopeWithFallbacks(input) {
+  const { directory, taskId, inMemoryScope, pendingMapScope } = input;
+  if (inMemoryScope && inMemoryScope.length > 0)
+    return inMemoryScope;
+  if (taskId) {
+    const disk = readScopeFromDisk(directory, taskId);
+    if (disk && disk.length > 0)
+      return disk;
+    const plan = readPlanScope(directory, taskId);
+    if (plan && plan.length > 0)
+      return plan;
+  }
+  if (pendingMapScope && pendingMapScope.length > 0)
+    return pendingMapScope;
+  return null;
+}
+
+export { MAX_PENDING_SCOPE_BINDINGS, clearScopeBindings, writeScopeToDisk, writeScopeBindingToDisk, readScopeBindingFromDisk, clearScopeBindingFromDisk, resolveAuthorizedScopeBinding, resolveAuthorizedScopeBindingForSession, readScopeFromDisk, readPlanScope, clearScopeForTask, clearAllScopes, resolveScopeWithFallbacks };

package/dist/cli/{index-vqcgmy4y.js → index-det5jwfk.js}

@@ -5,7 +5,7 @@ import {
   GateConfigSchema,
   PluginConfigSchema,
   stripKnownSwarmPrefix
-} from "./index-tftv9xh9.js";
+} from "./index-wr8qgpz5.js";
 import {
   log
 } from "./index-zgwm4ryv.js";

package/dist/cli/{index-3sx27bxt.js → index-dywekeen.js}

@@ -4,14 +4,14 @@ import {
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-3jvqw5hy.js";
+} from "./index-q27bajqb.js";
 import {
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
 import {
   atomicWriteFile
-} from "./index-h07wn84h.js";
+} from "./index-7mkpsw6g.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
@@ -608,7 +608,7 @@ async function applyKnowledgeVerdictFeedback(directory, options) {
       deltas.push({ id, delta });
     }
     if (deltas.length > 0) {
-      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-qg66a93n.js");
+      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-e07b4s54.js");
       await bumpKnowledgeConfidenceBatch(directory, deltas, options?.floorOptions);
     }
     return {

package/dist/cli/{index-wtn8wf7h.js → index-gw3m5fw0.js}

@@ -37,7 +37,7 @@ var _internals = {
     symlinkSync: fs.symlinkSync
   },
   writeScopeToDisk: async (directory, taskId, files) => {
-    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-mfr36yc9.js");
+    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-d9erwnvb.js");
     return realWrite(directory, taskId, files);
   },
   writeLaneProfileToDisk: async (_worktreePath, _laneIndex, _envOverrides) => {

package/dist/cli/{index-rkd6qwjh.js → index-hns7xjm7.js}

@@ -2,10 +2,10 @@
 import {
   readKnowledge,
   transactKnowledge
-} from "./index-ny13nr0x.js";
+} from "./index-n2712byd.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-3jvqw5hy.js";
+} from "./index-q27bajqb.js";
 import {
   isActiveStatus
 } from "./index-4rhcth7a.js";

package/dist/cli/{index-xdsj4qtd.js → index-j9kxwshw.js}

@@ -6,13 +6,13 @@ import {
   resolveSwarmKnowledgePath,
   transactKnowledge,
   wordBigrams
-} from "./index-ny13nr0x.js";
+} from "./index-n2712byd.js";
 import {
   countEntryContradictionsInWindow,
   countEntryViolationsInWindow,
   readKnowledgeEvents,
   recordKnowledgeEvent
-} from "./index-3sx27bxt.js";
+} from "./index-dywekeen.js";
 import {
   isActiveStatus
 } from "./index-4rhcth7a.js";
@@ -188,11 +188,11 @@ async function maybeQuarantineOnContradiction(directory, entryId, threshold, win
         alreadyInactive: true
       };
     }
-    const { quarantineEntry } = await import("./knowledge-validator-gar6wv4f.js");
+    const { quarantineEntry } = await import("./knowledge-validator-sfyf7wn2.js");
     let policyConfig;
     try {
-      const { KnowledgeConfigSchema } = await import("./schema-vwxpsk6j.js");
-      const { loadPluginConfigWithMeta } = await import("./index-rbfq77sz.js");
+      const { KnowledgeConfigSchema } = await import("./schema-13bnng2n.js");
+      const { loadPluginConfigWithMeta } = await import("./index-2j25br0p.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       policyConfig = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {