opencode-swarm 7.122.0 → 7.123.0

package/dist/cli/{index-emkb0bbe.js → index-7cspygmb.js}

@@ -5,11 +5,8 @@ import {
 import {
   EVIDENCE_MAX_JSON_BYTES,
   EvidenceBundleSchema,
-  EvidenceSchema,
-  ExecutionProfileSchema,
-  PlanSchema,
-  TaskStatusSchema
-} from "./index-qt2yaghg.js";
+  EvidenceSchema
+} from "./index-vcgfqd8f.js";
 import {
   _internals,
   buildDefaultPolicy,
@@ -17,6 +14,25 @@ import {
   init_runner_client,
   probe
 } from "./index-q1exe2b3.js";
+import {
+  LedgerStaleWriterError,
+  appendLedgerEvent,
+  computeCurrentPlanHash,
+  computePlanHash,
+  derivePlanId,
+  getLatestLedgerSeq,
+  initLedger,
+  ledgerExists,
+  loadLastApprovedPlan,
+  readLedgerEvents,
+  replayFromLedger,
+  replayFromLedgerWithStatus,
+  takeSnapshotEvent,
+  takeSnapshotWithRetry
+} from "./index-ctpgsj84.js";
+import {
+  PlanSchema
+} from "./index-m1abzg93.js";
 import {
   readSwarmFileAsync,
   validateSwarmPath
@@ -25,7 +41,6 @@ import {
   criticalWarn,
   error,
   init_logger,
-  log,
   warn
 } from "./index-zgwm4ryv.js";
 import {
@@ -33,16 +48,16 @@ import {
   readTaskEvidence,
   readTaskEvidenceRaw,
   sanitizeTaskId
-} from "./index-qg11yf8q.js";
+} from "./index-6xnxz6z0.js";
 import {
   atomicWriteFile
-} from "./index-h07wn84h.js";
-import {
-  withEvidenceLock
-} from "./index-76kvm9z5.js";
+} from "./index-7mkpsw6g.js";
 import {
   readCachedParsedFile
 } from "./index-fsrp8wp3.js";
+import {
+  withEvidenceLock
+} from "./index-76kvm9z5.js";
 import {
   emit
 } from "./index-q2rrv0cy.js";
@@ -442,12 +457,33 @@ function detectPowerShellEscape(command) {
 var init_edge_cases = () => {};
 
 // src/sandbox/win32/restricted-environment-executor.ts
+import { Buffer } from "buffer";
 import { spawnSync as spawnSync3 } from "child_process";
 import * as os2 from "os";
 import * as path2 from "path";
+function containsUnsafePathSyntax(value) {
+  return [...value].some((character) => character.charCodeAt(0) < 32 || UNSAFE_PATH_CHARACTERS.has(character));
+}
+function getSafeSystemRoot() {
+  const raw = process.env.SystemRoot;
+  if (typeof raw !== "string" || !/^[A-Za-z]:[\\/]/.test(raw) || containsUnsafePathSyntax(raw.slice(2)) || raw.slice(3).split(/[\\/]+/).some((segment) => segment === "." || segment === "..")) {
+    return DEFAULT_SYSTEM_ROOT;
+  }
+  const normalized = path2.win32.normalize(raw);
+  return normalized.length > 3 ? normalized.replace(/\\+$/, "") : normalized;
+}
+function getWindowsExecutablePaths() {
+  const systemRoot = getSafeSystemRoot();
+  return {
+    systemRoot,
+    cmdExe: path2.win32.join(systemRoot, "System32", "cmd.exe"),
+    powerShellExe: path2.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+  };
+}
 function probeWindowsSandbox() {
   try {
-    const result = spawnSync3("cmd", ["/c", "echo", "ok"], {
+    const result = spawnSync3(getWindowsExecutablePaths().cmdExe, ["/d", "/s", "/c", "echo ok"], {
+      cwd: os2.tmpdir(),
       windowsHide: true,
       encoding: "utf-8",
       timeout: 5000,
@@ -469,14 +505,37 @@ function probeWindowsSandbox() {
     return false;
   }
 }
-function psStringEscape(s) {
-  return s.replace(/[`"$]/g, "`$&");
+function psSingleQuoteEscape(s) {
+  return s.replace(/'/g, "''");
+}
+function normalizeInheritedPathEntry(rawEntry) {
+  const entry = rawEntry.trim();
+  if (!/^[A-Za-z]:[\\/]/.test(entry) || containsUnsafePathSyntax(entry.slice(2)) || entry.slice(3).split(/[\\/]+/).some((segment) => segment === "." || segment === "..")) {
+    return null;
+  }
+  const normalized = path2.win32.normalize(entry);
+  return normalized.length > 3 ? normalized.replace(/\\+$/, "") : normalized;
 }
 function getSafeWindowsPath() {
-  const raw = process.env.SystemRoot;
-  const isValid = typeof raw === "string" && raw.length > 0 && /^[A-Za-z]:[\\/](?:[^\\/;"'<>|*?\r\n]+[\\/]?)*$/.test(raw);
-  const sysRoot = isValid ? raw : "C:\\Windows";
-  return `${sysRoot}\\System32;${sysRoot}`;
+  const { systemRoot } = getWindowsExecutablePaths();
+  const candidates = [
+    path2.win32.join(systemRoot, "System32"),
+    systemRoot,
+    ...(process.env.PATH ?? "").split(";")
+  ];
+  const seen = new Set;
+  const safeEntries = [];
+  for (const candidate of candidates) {
+    const normalized = normalizeInheritedPathEntry(candidate);
+    if (!normalized)
+      continue;
+    const identity = normalized.toLowerCase();
+    if (seen.has(identity))
+      continue;
+    seen.add(identity);
+    safeEntries.push(normalized);
+  }
+  return safeEntries.join(";");
 }
 function isPowerShellNativeCommand(command) {
   return /^(?:Remove-Item|rm|del|erase|Copy-Item|cp|copy|Move-Item|mv|move|Rename-Item|ren|New-Item|ni|Get-Item|gi|Get-ChildItem|ls|dir|gci|Get-Content|cat|type|gc|Set-Content|sc|Add-Content|ac|Clear-Content|clc|Test-Path|Resolve-Path|Split-Path|Join-Path|Out-File|Get-Date)\b/i.test(command.trimStart());
@@ -557,8 +616,11 @@ class WindowsSandboxExecutor {
       throw new SandboxError("PowerShell-native command body contains unsafe characters", "UNSAFE_PS_COMMAND");
     }
     const safePath = getSafeWindowsPath();
-    const escapedTemp = psStringEscape(temp);
-    const escapedCommand = psStringEscape(command);
+    const { cmdExe, powerShellExe } = getWindowsExecutablePaths();
+    const commandBase64 = Buffer.from(command, "utf8").toString("base64");
+    const escapedTemp = psSingleQuoteEscape(temp);
+    const escapedPath = psSingleQuoteEscape(safePath);
+    const escapedCmdExe = psSingleQuoteEscape(cmdExe);
     const envOverrideLines = [];
     if (envOverrides) {
       for (const [key, value] of Object.entries(envOverrides)) {
@@ -568,27 +630,50 @@ class WindowsSandboxExecutor {
         if (value === null) {
           envOverrideLines.push(`Remove-Item Env:${key} -Force -ErrorAction SilentlyContinue;`);
         } else {
-          const psEscaped = value.replace(/'/g, "''");
+          const psEscaped = psSingleQuoteEscape(value);
           envOverrideLines.push(`$env:${key} = '${psEscaped}';`);
         }
       }
     }
-    const commandExec = isPowerShellNativeCommand(command) ? `Invoke-Expression "${escapedCommand}"` : `cmd /c "${escapedCommand}"`;
+    const commandExec = isPowerShellNativeCommand(command) ? `Invoke-Expression $command;
+  exit 0;` : `$batchPath = $null;
+  $batchLocationPushed = $false;
+  try {
+    if ($command.Contains([char]13) -or $command.Contains([char]10)) {
+      $batchName = 'opencode-swarm-' + [Guid]::NewGuid().ToString('N') + '.cmd';
+      $batchPath = Join-Path $env:TEMP $batchName;
+      [IO.File]::WriteAllText($batchPath, $command, [Text.UTF8Encoding]::new($false));
+      Push-Location -LiteralPath $env:TEMP;
+      $batchLocationPushed = $true;
+      & '${escapedCmdExe}' /d /v:off /s /c ('call "' + $batchName + '"');
+    } else {
+      & '${escapedCmdExe}' /d /v:off /s /c $command;
+    }
+    $childExitCode = $LASTEXITCODE;
+  } finally {
+    if ($batchLocationPushed) {
+      Pop-Location;
+    }
+    if ($null -ne $batchPath) {
+      Remove-Item -LiteralPath $batchPath -Force -ErrorAction SilentlyContinue;
+    }
+  }
+  if ($null -eq $childExitCode) {
+    throw 'cmd.exe did not report an exit code';
+  }
+  exit [int]$childExitCode;`;
     const envOverrideBlock = envOverrideLines.length > 0 ? `
   ${envOverrideLines.join(`
   `)}` : "";
     const psScript = `
 $ErrorActionPreference = 'Stop';
+$ProgressPreference = 'SilentlyContinue';
 try {
-  # Set scoped temp directory
   $env:TEMP = '${escapedTemp}';
   $env:TMP = '${escapedTemp}';
 
-  # Restrict PATH to safe system paths only
-  $env:PATH = '${safePath}';
+  $env:PATH = '${escapedPath}';
 
-  # Remove dangerous environment variables that could be used to bypass restrictions
-  # Note: LD_PRELOAD, DYLD_* don't apply on Windows but we clear them for completeness
   $dangerousVars = @(
     'LD_PRELOAD',
     'DYLD_INSERT_LIBRARIES',
@@ -605,12 +690,16 @@ try {
   ${envOverrideBlock}
 
   # Execute the command \u2014 PS-native cmdlets via Invoke-Expression, others via the standard command interpreter
+  $commandBytes = [Convert]::FromBase64String('${commandBase64}');
+  $command = [Text.Encoding]::UTF8.GetString($commandBytes);
   ${commandExec};
 } catch {
-  Write-Error $_.Exception.Message;
+  [Console]::Error.WriteLine($_.Exception.Message);
   exit 1;
 }`;
-    return `powershell -ExecutionPolicy Bypass -NoProfile -WindowStyle Hidden -Command "${psScript.replace(/\n/g, " ").trim()}"`;
+    const encodedScript = Buffer.from(psScript, "utf16le").toString("base64");
+    const escapedPowerShellExe = psSingleQuoteEscape(powerShellExe);
+    return `& '${escapedPowerShellExe}' -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand ${encodedScript}; exit $LASTEXITCODE`;
   }
   getEnvOverrides() {
     return {
@@ -626,7 +715,7 @@ try {
     };
   }
 }
-var SANDBOX_UNAVAILABLE_CODES2, _internals4;
+var SANDBOX_UNAVAILABLE_CODES2, DEFAULT_SYSTEM_ROOT = "C:\\Windows", UNSAFE_PATH_CHARACTERS, _internals4;
 var init_restricted_environment_executor = __esm(() => {
   init_logger();
   init_executor();
@@ -637,6 +726,23 @@ var init_restricted_environment_executor = __esm(() => {
     "EPERM",
     "ENOSPC"
   ]);
+  UNSAFE_PATH_CHARACTERS = new Set([
+    ":",
+    '"',
+    "'",
+    ";",
+    "&",
+    "|",
+    "<",
+    ">",
+    "^",
+    "%",
+    "!",
+    "?",
+    "*",
+    "`",
+    "$"
+  ]);
   _internals4 = {
     probeWindowsSandbox
   };
@@ -857,19 +963,19 @@ var init_executor = __esm(() => {
 
 // src/plan/manager.ts
 import {
-  closeSync as closeSync2,
+  closeSync,
   copyFileSync,
-  existsSync as existsSync5,
-  fsyncSync as fsyncSync2,
-  mkdirSync as mkdirSync5,
-  openSync as openSync2,
-  readdirSync as readdirSync2,
-  renameSync as renameSync4,
+  existsSync as existsSync4,
+  fsyncSync,
+  mkdirSync as mkdirSync4,
+  openSync,
+  readdirSync,
+  renameSync as renameSync3,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync5
 } from "fs";
 import * as fsPromises from "fs/promises";
-import * as path9 from "path";
+import * as path8 from "path";
 
 // src/git/branch.ts
 init_executor();
@@ -2072,508 +2178,6 @@ function computeLcsDiff(oldLines, newLines) {
   });
 }
 
-// src/plan/ledger.ts
-import * as crypto2 from "crypto";
-import * as fs5 from "fs";
-import * as path8 from "path";
-init_logger();
-
-// src/plan/utils.ts
-function derivePlanId(plan) {
-  return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
-}
-
-// src/plan/ledger.ts
-var LEDGER_SCHEMA_VERSION = "1.1.0";
-var LEDGER_FILENAME = "plan-ledger.jsonl";
-var LEDGER_LOCK_PATH = path8.join(".swarm", LEDGER_FILENAME);
-var PLAN_JSON_FILENAME = "plan.json";
-
-class LedgerStaleWriterError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "LedgerStaleWriterError";
-  }
-}
-function getLedgerPath(directory) {
-  return path8.join(directory, ".swarm", LEDGER_FILENAME);
-}
-function getPlanJsonPath(directory) {
-  return path8.join(directory, ".swarm", PLAN_JSON_FILENAME);
-}
-function writeFileFsyncedThenRename(tempPath, targetPath, data) {
-  const fd = fs5.openSync(tempPath, "w");
-  try {
-    fs5.writeFileSync(fd, data, "utf8");
-    fs5.fsyncSync(fd);
-  } finally {
-    fs5.closeSync(fd);
-  }
-  fs5.renameSync(tempPath, targetPath);
-}
-function computePlanHash(plan) {
-  const normalized = {
-    schema_version: plan.schema_version,
-    title: plan.title,
-    swarm: plan.swarm,
-    current_phase: plan.current_phase,
-    migration_status: plan.migration_status,
-    execution_profile: plan.execution_profile,
-    phases: plan.phases.map((phase) => ({
-      id: phase.id,
-      name: phase.name,
-      status: phase.status,
-      required_agents: phase.required_agents ? [...phase.required_agents].sort() : undefined,
-      tasks: phase.tasks.map((task) => ({
-        id: task.id,
-        phase: task.phase,
-        status: task.status,
-        size: task.size,
-        description: task.description,
-        depends: [...task.depends].sort(),
-        acceptance: task.acceptance,
-        files_touched: [...task.files_touched].sort(),
-        evidence_path: task.evidence_path,
-        blocked_reason: task.blocked_reason
-      }))
-    }))
-  };
-  const jsonString = JSON.stringify(normalized);
-  return crypto2.createHash("sha256").update(jsonString, "utf8").digest("hex");
-}
-function computeCurrentPlanHash(directory) {
-  const planPath = getPlanJsonPath(directory);
-  try {
-    const content = fs5.readFileSync(planPath, "utf8");
-    const plan = JSON.parse(content);
-    return computePlanHash(plan);
-  } catch {
-    return "";
-  }
-}
-async function ledgerExists(directory) {
-  const ledgerPath = getLedgerPath(directory);
-  return fs5.existsSync(ledgerPath);
-}
-async function getLatestLedgerSeq(directory) {
-  const ledgerPath = getLedgerPath(directory);
-  if (!fs5.existsSync(ledgerPath)) {
-    return 0;
-  }
-  try {
-    const content = fs5.readFileSync(ledgerPath, "utf8");
-    const lines = content.trim().split(`
-`).filter((line) => line.trim() !== "");
-    if (lines.length === 0) {
-      return 0;
-    }
-    let maxSeq = 0;
-    for (const line of lines) {
-      try {
-        const event = JSON.parse(line);
-        if (event.seq > maxSeq) {
-          maxSeq = event.seq;
-        }
-      } catch {}
-    }
-    return maxSeq;
-  } catch {
-    return 0;
-  }
-}
-async function readLedgerEvents(directory) {
-  const ledgerPath = getLedgerPath(directory);
-  if (!fs5.existsSync(ledgerPath)) {
-    return [];
-  }
-  try {
-    const content = fs5.readFileSync(ledgerPath, "utf8");
-    const lines = content.trim().split(`
-`).filter((line) => line.trim() !== "");
-    const events = [];
-    let skippedCount = 0;
-    for (const line of lines) {
-      try {
-        const event = JSON.parse(line);
-        events.push(event);
-      } catch {
-        skippedCount++;
-      }
-    }
-    if (skippedCount > 0) {
-      log(`[ledger] Skipped ${skippedCount} malformed line(s) in plan-ledger.jsonl`);
-    }
-    events.sort((a, b) => a.seq - b.seq);
-    return events;
-  } catch {
-    return [];
-  }
-}
-async function initLedger(directory, planId, initialPlanHash, initialPlan) {
-  const ledgerPath = getLedgerPath(directory);
-  const planJsonPath = getPlanJsonPath(directory);
-  if (fs5.existsSync(ledgerPath)) {
-    throw new Error("Ledger already initialized. Use appendLedgerEvent to add events.");
-  }
-  let planHashAfter = initialPlanHash ?? "";
-  let embeddedPlan = initialPlan;
-  if (!initialPlanHash) {
-    try {
-      if (fs5.existsSync(planJsonPath)) {
-        const content = fs5.readFileSync(planJsonPath, "utf8");
-        const plan = JSON.parse(content);
-        planHashAfter = computePlanHash(plan);
-        if (!embeddedPlan)
-          embeddedPlan = plan;
-      }
-    } catch {}
-  }
-  const payload = embeddedPlan ? { plan: embeddedPlan, payload_hash: planHashAfter } : undefined;
-  const event = {
-    seq: 1,
-    timestamp: new Date().toISOString(),
-    plan_id: planId,
-    event_type: "plan_created",
-    source: "initLedger",
-    plan_hash_before: "",
-    plan_hash_after: planHashAfter,
-    schema_version: LEDGER_SCHEMA_VERSION,
-    ...payload ? { payload } : {}
-  };
-  fs5.mkdirSync(path8.join(directory, ".swarm"), { recursive: true });
-  const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  const line = `${JSON.stringify(event)}
-`;
-  writeFileFsyncedThenRename(tempPath, ledgerPath, line);
-}
-async function appendLedgerEvent(directory, eventInput, options) {
-  return withEvidenceLock(directory, LEDGER_LOCK_PATH, "plan-ledger", "append-ledger-event", async () => {
-    const ledgerPath = getLedgerPath(directory);
-    const latestSeq = await getLatestLedgerSeq(directory);
-    const nextSeq = latestSeq + 1;
-    const planHashBefore = computeCurrentPlanHash(directory);
-    if (options?.expectedSeq !== undefined && options.expectedSeq !== latestSeq) {
-      throw new LedgerStaleWriterError(`Stale writer: expected seq ${options.expectedSeq} but found ${latestSeq}`);
-    }
-    if (options?.expectedHash !== undefined && options.expectedHash !== planHashBefore) {
-      throw new LedgerStaleWriterError(`Stale writer: expected hash ${options.expectedHash} but found ${planHashBefore}`);
-    }
-    const planHashAfter = options?.planHashAfter ?? planHashBefore;
-    const event = {
-      ...eventInput,
-      seq: nextSeq,
-      timestamp: new Date().toISOString(),
-      plan_hash_before: planHashBefore,
-      plan_hash_after: planHashAfter,
-      schema_version: LEDGER_SCHEMA_VERSION
-    };
-    fs5.mkdirSync(path8.join(directory, ".swarm"), { recursive: true });
-    const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-    const line = `${JSON.stringify(event)}
-`;
-    if (!fs5.existsSync(ledgerPath)) {
-      throw new Error("Ledger not initialized. Call initLedger() first.");
-    }
-    const existingContent = fs5.readFileSync(ledgerPath, "utf8");
-    writeFileFsyncedThenRename(tempPath, ledgerPath, existingContent + line);
-    return event;
-  });
-}
-async function takeSnapshotWithRetry(directory, plan, options) {
-  const MAX_RETRIES = 3;
-  const TOTAL_ATTEMPTS = 1 + MAX_RETRIES;
-  const telemetrySource = options?.source ?? "save_plan_tool";
-  const snapshotOptions = { planHashAfter: options?.planHashAfter };
-  let lastError;
-  for (let attempt = 1;attempt <= TOTAL_ATTEMPTS; attempt++) {
-    try {
-      await takeSnapshotEvent(directory, plan, snapshotOptions);
-      return;
-    } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err));
-      if (attempt < TOTAL_ATTEMPTS) {
-        await new Promise((r) => setTimeout(r, 10 * 2 ** (attempt - 1)));
-      }
-    }
-  }
-  criticalWarn(`[takeSnapshotWithRetry] Snapshot failed after ${MAX_RETRIES} retries (${TOTAL_ATTEMPTS} attempts): ${lastError.message}`);
-  try {
-    emit("snapshot_failed", {
-      error: lastError.message,
-      retries: MAX_RETRIES,
-      source: telemetrySource
-    });
-  } catch {}
-}
-async function takeSnapshotEvent(directory, plan, options) {
-  const payloadHash = options?.payloadHashOverride ?? computePlanHash(plan);
-  const snapshotPayload = {
-    plan,
-    payload_hash: payloadHash
-  };
-  if (options?.approvalMetadata) {
-    snapshotPayload.approval = options.approvalMetadata;
-  }
-  const planId = derivePlanId(plan);
-  return appendLedgerEvent(directory, {
-    event_type: "snapshot",
-    source: options?.source ?? "takeSnapshotEvent",
-    plan_id: planId,
-    payload: snapshotPayload
-  }, { planHashAfter: options?.planHashAfter });
-}
-async function replayFromLedger(directory, options) {
-  const { plan } = await replayFromLedgerWithStatus(directory, options);
-  return plan;
-}
-async function replayFromLedgerWithStatus(directory, _options) {
-  const { events, truncated, badSuffix } = await readLedgerEventsWithIntegrity(directory);
-  if (events.length === 0) {
-    return { plan: null, truncated, badSuffix };
-  }
-  if (truncated && badSuffix !== null) {
-    await quarantineLedgerSuffix(directory, badSuffix);
-  }
-  const plan = reconstructPlanFromEvents(directory, events);
-  return { plan, truncated, badSuffix };
-}
-function reconstructPlanFromEvents(directory, events) {
-  const targetPlanId = events[0].plan_id;
-  const relevantEvents = events.filter((e) => e.plan_id === targetPlanId);
-  {
-    const snapshotEvents = relevantEvents.filter((e) => e.event_type === "snapshot");
-    if (snapshotEvents.length > 0) {
-      const latestSnapshotEvent = snapshotEvents[snapshotEvents.length - 1];
-      const snapshotPayload = latestSnapshotEvent.payload;
-      let plan2 = snapshotPayload.plan;
-      const eventsAfterSnapshot = relevantEvents.filter((e) => e.seq > latestSnapshotEvent.seq);
-      for (const event of eventsAfterSnapshot) {
-        plan2 = applyEventToPlan(plan2, event);
-        if (plan2 === null) {
-          return null;
-        }
-      }
-      return plan2;
-    }
-  }
-  const createdEvent = relevantEvents.find((e) => e.event_type === "plan_created");
-  if (createdEvent?.payload && typeof createdEvent.payload === "object" && "plan" in createdEvent.payload) {
-    const parseResult = PlanSchema.safeParse(createdEvent.payload.plan);
-    if (parseResult.success) {
-      let plan2 = parseResult.data;
-      const eventsAfterCreated = relevantEvents.filter((e) => e.seq > createdEvent.seq);
-      for (const event of eventsAfterCreated) {
-        if (plan2 === null)
-          return null;
-        plan2 = applyEventToPlan(plan2, event);
-      }
-      return plan2;
-    }
-  }
-  const planJsonPath = getPlanJsonPath(directory);
-  if (!fs5.existsSync(planJsonPath)) {
-    return null;
-  }
-  let plan;
-  try {
-    const content = fs5.readFileSync(planJsonPath, "utf8");
-    plan = JSON.parse(content);
-  } catch {
-    return null;
-  }
-  for (const event of relevantEvents) {
-    if (plan === null) {
-      return null;
-    }
-    plan = applyEventToPlan(plan, event);
-  }
-  return plan;
-}
-function applyEventToPlan(plan, event) {
-  switch (event.event_type) {
-    case "plan_created":
-      if (event.payload && typeof event.payload === "object" && "plan" in event.payload) {
-        const parsed = PlanSchema.safeParse(event.payload.plan);
-        if (parsed.success)
-          return parsed.data;
-      }
-      return plan;
-    case "task_status_changed":
-      if (event.task_id && event.to_status) {
-        const parseResult = TaskStatusSchema.safeParse(event.to_status);
-        if (!parseResult.success) {
-          return plan;
-        }
-        for (const phase of plan.phases) {
-          const task = phase.tasks.find((t) => t.id === event.task_id);
-          if (task) {
-            task.status = parseResult.data;
-            break;
-          }
-        }
-      }
-      return plan;
-    case "phase_completed":
-      if (event.phase_id) {
-        const phase = plan.phases.find((p) => p.id === event.phase_id);
-        if (phase) {
-          phase.status = "complete";
-        }
-      }
-      return plan;
-    case "plan_exported":
-      return plan;
-    case "task_added":
-      return plan;
-    case "task_removed":
-      if (event.task_id) {
-        for (const phase of plan.phases) {
-          const idx = phase.tasks.findIndex((t) => t.id === event.task_id);
-          if (idx !== -1) {
-            phase.tasks.splice(idx, 1);
-            break;
-          }
-        }
-      }
-      return plan;
-    case "task_updated":
-      return plan;
-    case "plan_rebuilt":
-      return plan;
-    case "task_reordered":
-      return plan;
-    case "snapshot":
-      return plan;
-    case "plan_reset":
-      return null;
-    case "execution_profile_set": {
-      const rawProfile = event.payload?.execution_profile;
-      if (rawProfile !== undefined) {
-        const parsed = ExecutionProfileSchema.safeParse(rawProfile);
-        if (parsed.success) {
-          return { ...plan, execution_profile: parsed.data };
-        }
-      }
-      return plan;
-    }
-    case "execution_profile_locked": {
-      if (plan.execution_profile) {
-        return {
-          ...plan,
-          execution_profile: { ...plan.execution_profile, locked: true }
-        };
-      }
-      return plan;
-    }
-    default:
-      throw new Error(`applyEventToPlan: unhandled event type "${event.event_type}" at seq ${event.seq}`);
-  }
-}
-async function readLedgerEventsWithIntegrity(directory) {
-  const ledgerPath = getLedgerPath(directory);
-  if (!fs5.existsSync(ledgerPath)) {
-    return { events: [], truncated: false, badSuffix: null };
-  }
-  try {
-    const content = fs5.readFileSync(ledgerPath, "utf8");
-    const lines = content.split(`
-`);
-    const events = [];
-    let truncated = false;
-    let badSuffix = null;
-    for (let i = 0;i < lines.length; i++) {
-      const line = lines[i];
-      if (line.trim() === "") {
-        continue;
-      }
-      try {
-        const event = JSON.parse(line);
-        events.push(event);
-      } catch {
-        truncated = true;
-        badSuffix = lines.slice(i).join(`
-`);
-        break;
-      }
-    }
-    events.sort((a, b) => a.seq - b.seq);
-    return { events, truncated, badSuffix };
-  } catch {
-    return { events: [], truncated: false, badSuffix: null };
-  }
-}
-async function quarantineLedgerSuffix(directory, badSuffix) {
-  let salvagedCount = 0;
-  for (const line of badSuffix.split(`
-`)) {
-    if (line.trim() === "")
-      continue;
-    try {
-      JSON.parse(line);
-      salvagedCount++;
-    } catch {}
-  }
-  try {
-    const hash = crypto2.createHash("sha256").update(badSuffix, "utf8").digest("hex").slice(0, 12);
-    const swarmDir = path8.join(directory, ".swarm");
-    try {
-      const existing = fs5.readdirSync(swarmDir).filter((name) => name.startsWith("plan-ledger.quarantine.") && name.endsWith(`.${hash}`));
-      for (const name of existing) {
-        const existingPath = path8.join(swarmDir, name);
-        if (fs5.readFileSync(existingPath, "utf8") === badSuffix) {
-          return { path: existingPath, salvagedCount };
-        }
-      }
-    } catch {}
-    const quarantinePath = path8.join(swarmDir, `plan-ledger.quarantine.${Date.now()}.${hash}`);
-    fs5.writeFileSync(quarantinePath, badSuffix, "utf8");
-    log(`[ledger] Corrupted suffix quarantined to ${path8.relative(directory, quarantinePath)} (salvageable events: ${salvagedCount})`);
-    return { path: quarantinePath, salvagedCount };
-  } catch {
-    return { path: null, salvagedCount };
-  }
-}
-async function loadLastApprovedPlan(directory, expectedPlanId) {
-  const events = await readLedgerEvents(directory);
-  return findLastApprovedSnapshot(events, expectedPlanId);
-}
-function findLastApprovedSnapshot(events, expectedPlanId, extraFilter) {
-  if (events.length === 0) {
-    return null;
-  }
-  for (let i = events.length - 1;i >= 0; i--) {
-    const event = events[i];
-    if (event.event_type !== "snapshot")
-      continue;
-    if (event.source !== "critic_approved")
-      continue;
-    if (expectedPlanId !== undefined && event.plan_id !== expectedPlanId) {
-      continue;
-    }
-    const payload = event.payload;
-    if (!payload || typeof payload !== "object" || !payload.plan) {
-      continue;
-    }
-    if (expectedPlanId !== undefined) {
-      const payloadPlanId = derivePlanId(payload.plan);
-      if (payloadPlanId !== expectedPlanId) {
-        continue;
-      }
-    }
-    if (extraFilter && !extraFilter(payload)) {
-      continue;
-    }
-    return {
-      plan: payload.plan,
-      seq: event.seq,
-      timestamp: event.timestamp,
-      approval: payload.approval,
-      payloadHash: payload.payload_hash
-    };
-  }
-  return null;
-}
-
 // src/plan/manager.ts
 class PlanConcurrentModificationError extends Error {
   constructor(message) {
@@ -2735,7 +2339,7 @@ async function getLatestLedgerHash(directory) {
   }
 }
 async function surfaceLedgerStaleIfPersisted(directory, plan) {
-  const resolvedWorkspace = path9.resolve(directory);
+  const resolvedWorkspace = path8.resolve(directory);
   if (!ledgerStaleWorkspaces.has(resolvedWorkspace)) {
     return plan;
   }
@@ -2754,7 +2358,7 @@ async function surfaceLedgerStaleIfPersisted(directory, plan) {
   return plan;
 }
 async function parsePlanJsonCached(directory) {
-  const planJsonPath = path9.resolve(directory, ".swarm", "plan.json");
+  const planJsonPath = path8.resolve(directory, ".swarm", "plan.json");
   return readCachedParsedFile(planJsonPath, PLAN_JSON_CACHE_NAMESPACE, () => readSwarmFileAsync(directory, "plan.json"), (planJsonContent) => {
     if (planJsonContent.includes("\x00") || planJsonContent.includes("\uFFFD")) {
       throw new Error("Plan rejected: .swarm/plan.json contains null bytes or invalid encoding");
@@ -2814,16 +2418,16 @@ async function isPlanMdInSync(directory, plan, cache) {
   return false;
 }
 async function regeneratePlanMarkdown(directory, plan) {
-  const swarmDir = path9.resolve(directory, ".swarm");
+  const swarmDir = path8.resolve(directory, ".swarm");
   const contentHash = computePlanContentHash(plan);
   const markdown = derivePlanMarkdown(plan);
   const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-  const mdPath = path9.join(swarmDir, "plan.md");
-  const mdTempPath = path9.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const mdPath = path8.join(swarmDir, "plan.md");
+  const mdTempPath = path8.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(mdTempPath, markdownWithHash);
-    renameSync4(mdTempPath, mdPath);
+    renameSync3(mdTempPath, mdPath);
   } finally {
     try {
       unlinkSync3(mdTempPath);
@@ -2852,7 +2456,7 @@ async function loadPlan(directory, cache) {
           if (await ledgerExists(directory)) {
             const planHash = computePlanHash(validated);
             const ledgerHash = await getLatestLedgerHash(directory);
-            const resolvedWorkspace = path9.resolve(directory);
+            const resolvedWorkspace = path8.resolve(directory);
             if (!startupLedgerCheckedWorkspaces.has(resolvedWorkspace)) {
               startupLedgerCheckedWorkspaces.add(resolvedWorkspace);
               if (ledgerHash !== "" && planHash !== ledgerHash) {
@@ -2926,7 +2530,7 @@ async function loadPlan(directory, cache) {
               if (!preserving) {
                 try {
                   const diffInfo = computeSpecDiff(directory);
-                  const specStalenessPath = path9.join(directory, ".swarm", "spec-staleness.json");
+                  const specStalenessPath = path8.join(directory, ".swarm", "spec-staleness.json");
                   await fsPromises.writeFile(specStalenessPath, JSON.stringify({
                     type: "spec_stale_detected",
                     timestamp: new Date().toISOString(),
@@ -2940,7 +2544,7 @@ async function loadPlan(directory, cache) {
                   }, null, 2), "utf-8");
                 } catch {}
                 try {
-                  const eventsPath = path9.join(directory, ".swarm", "events.jsonl");
+                  const eventsPath = path8.join(directory, ".swarm", "events.jsonl");
                   const event = {
                     type: "spec_stale_detected",
                     timestamp: new Date().toISOString(),
@@ -3006,7 +2610,7 @@ async function loadPlan(directory, cache) {
     return migrated;
   }
   if (await ledgerExists(directory)) {
-    const resolvedDir = path9.resolve(directory);
+    const resolvedDir = path8.resolve(directory);
     const existingMutex = recoveryMutexes.get(resolvedDir);
     if (existingMutex) {
       await existingMutex;
@@ -3135,13 +2739,13 @@ async function savePlan(directory, plan, options) {
   } else {
     const existingEvents = await readLedgerEvents(directory);
     if (existingEvents.length > 0 && existingEvents[0].plan_id !== planId) {
-      const swarmDir2 = path9.resolve(directory, ".swarm");
-      const oldLedgerPath = path9.join(swarmDir2, "plan-ledger.jsonl");
-      const oldLedgerBackupPath = path9.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+      const swarmDir2 = path8.resolve(directory, ".swarm");
+      const oldLedgerPath = path8.join(swarmDir2, "plan-ledger.jsonl");
+      const oldLedgerBackupPath = path8.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
       let backupExists = false;
-      if (existsSync5(oldLedgerPath)) {
+      if (existsSync4(oldLedgerPath)) {
         try {
-          renameSync4(oldLedgerPath, oldLedgerBackupPath);
+          renameSync3(oldLedgerPath, oldLedgerBackupPath);
           backupExists = true;
         } catch (renameErr) {
           throw new Error(`[savePlan] Cannot reinitialize ledger: could not move old ledger aside (rename failed: ${renameErr instanceof Error ? renameErr.message : String(renameErr)}). The existing ledger has plan_id="${existingEvents[0].plan_id}" which does not match the current plan="${planId}". To proceed, close any programs that may have the ledger file open, or run /swarm reset-session to clear the ledger.`);
@@ -3156,13 +2760,13 @@ async function savePlan(directory, plan, options) {
           const errorMessage2 = String(initErr);
           if (errorMessage2.includes("already initialized")) {
             try {
-              if (existsSync5(oldLedgerBackupPath))
+              if (existsSync4(oldLedgerBackupPath))
                 unlinkSync3(oldLedgerBackupPath);
             } catch {}
           } else {
-            if (existsSync5(oldLedgerBackupPath)) {
+            if (existsSync4(oldLedgerBackupPath)) {
               try {
-                renameSync4(oldLedgerBackupPath, oldLedgerPath);
+                renameSync3(oldLedgerBackupPath, oldLedgerPath);
               } catch {
                 copyFileSync(oldLedgerBackupPath, oldLedgerPath);
                 try {
@@ -3175,32 +2779,32 @@ async function savePlan(directory, plan, options) {
         }
       }
       if (initSucceeded && backupExists) {
-        const archivePath = path9.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+        const archivePath = path8.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
         try {
-          renameSync4(oldLedgerBackupPath, archivePath);
+          renameSync3(oldLedgerBackupPath, archivePath);
           warn(`[savePlan] Ledger identity mismatch (was "${existingEvents[0].plan_id}", now "${planId}") \u2014 archived old ledger to ${archivePath} and reinitializing.`);
         } catch (renameErr) {
           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 (existsSync5(oldLedgerBackupPath))
+            if (existsSync4(oldLedgerBackupPath))
               unlinkSync3(oldLedgerBackupPath);
           } catch {}
         }
       } else if (!initSucceeded && backupExists) {
         try {
-          if (existsSync5(oldLedgerBackupPath))
+          if (existsSync4(oldLedgerBackupPath))
             unlinkSync3(oldLedgerBackupPath);
         } catch {}
       }
       const MAX_ARCHIVED_SIBLINGS = 5;
       try {
-        const allFiles = readdirSync2(swarmDir2);
+        const allFiles = readdirSync(swarmDir2);
         const archivedSiblings = allFiles.filter((f) => f.startsWith("plan-ledger.archived-") && f.endsWith(".jsonl")).sort();
         if (archivedSiblings.length > MAX_ARCHIVED_SIBLINGS) {
           const toRemove = archivedSiblings.slice(0, archivedSiblings.length - MAX_ARCHIVED_SIBLINGS);
           for (const file of toRemove) {
             try {
-              unlinkSync3(path9.join(swarmDir2, file));
+              unlinkSync3(path8.join(swarmDir2, file));
             } catch {}
           }
         }
@@ -3343,19 +2947,19 @@ async function savePlan(directory, plan, options) {
       source: "savePlan_manager"
     });
   }
-  const swarmDir = path9.resolve(directory, ".swarm");
-  const planPath = path9.join(swarmDir, "plan.json");
-  const tempPath = path9.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path8.resolve(directory, ".swarm");
+  const planPath = path8.join(swarmDir, "plan.json");
+  const tempPath = path8.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(tempPath, JSON.stringify(projectedPlan, null, 2));
-    renameSync4(tempPath, planPath);
+    renameSync3(tempPath, planPath);
   } finally {
     try {
       unlinkSync3(tempPath);
     } catch {}
   }
   try {
-    const markerPath = path9.join(swarmDir, ".plan-write-marker");
+    const markerPath = path8.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
@@ -3370,11 +2974,11 @@ async function savePlan(directory, plan, options) {
     const markdown = derivePlanMarkdown(projectedPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdPath = path9.join(swarmDir, "plan.md");
-    const mdTempPath = path9.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdPath = path8.join(swarmDir, "plan.md");
+    const mdTempPath = path8.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await bunWrite(mdTempPath, markdownWithHash);
-      renameSync4(mdTempPath, mdPath);
+      renameSync3(mdTempPath, mdPath);
     } finally {
       try {
         unlinkSync3(mdTempPath);
@@ -3392,7 +2996,7 @@ ${markdown}`;
     } catch {}
   }
   try {
-    const markerPath = path9.join(swarmDir, ".plan-write-marker");
+    const markerPath = path8.join(swarmDir, ".plan-write-marker");
     const tasksCount = projectedPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
     const marker = JSON.stringify({
       source: "plan_manager",
@@ -3408,23 +3012,23 @@ async function rebuildPlan(directory, plan, options) {
   const targetPlan = plan ?? await replayFromLedger(directory);
   if (!targetPlan)
     return null;
-  const swarmDir = path9.join(directory, ".swarm");
-  const planPath = path9.join(swarmDir, "plan.json");
-  const mdPath = path9.join(swarmDir, "plan.md");
-  mkdirSync5(swarmDir, { recursive: true });
-  const tempPlanPath = path9.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path8.join(directory, ".swarm");
+  const planPath = path8.join(swarmDir, "plan.json");
+  const mdPath = path8.join(swarmDir, "plan.md");
+  mkdirSync4(swarmDir, { recursive: true });
+  const tempPlanPath = path8.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   {
-    const fd = openSync2(tempPlanPath, "w");
+    const fd = openSync(tempPlanPath, "w");
     try {
-      writeFileSync6(fd, JSON.stringify(targetPlan, null, 2), "utf8");
-      fsyncSync2(fd);
+      writeFileSync5(fd, JSON.stringify(targetPlan, null, 2), "utf8");
+      fsyncSync(fd);
     } finally {
-      closeSync2(fd);
+      closeSync(fd);
     }
   }
-  renameSync4(tempPlanPath, planPath);
+  renameSync3(tempPlanPath, planPath);
   try {
-    const markerPath = path9.join(swarmDir, ".plan-write-marker");
+    const markerPath = path8.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
@@ -3439,12 +3043,12 @@ async function rebuildPlan(directory, plan, options) {
     const markdown = derivePlanMarkdown(targetPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const tempMdPath = path9.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const tempMdPath = path8.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(tempMdPath, markdownWithHash);
-    renameSync4(tempMdPath, mdPath);
+    renameSync3(tempMdPath, mdPath);
   } finally {
     try {
-      const markerPath = path9.join(swarmDir, ".plan-write-marker");
+      const markerPath = path8.join(swarmDir, ".plan-write-marker");
       const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
       const marker = JSON.stringify({
         source: "plan_manager",
@@ -3507,13 +3111,13 @@ async function closePlanTerminalState(directory, plan, options) {
     planHashAfter: hashAfter,
     source: "close_terminal"
   });
-  const swarmDir = path9.join(directory, ".swarm");
-  const planPath = path9.join(swarmDir, "plan.json");
-  const tempPlanPath = path9.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path8.join(directory, ".swarm");
+  const planPath = path8.join(swarmDir, "plan.json");
+  const tempPlanPath = path8.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(validated, null, 2));
-  renameSync4(tempPlanPath, planPath);
+  renameSync3(tempPlanPath, planPath);
   try {
-    const markerPath = path9.join(swarmDir, ".plan-write-marker");
+    const markerPath = path8.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager_close",
       timestamp: new Date().toISOString(),
@@ -3524,17 +3128,17 @@ async function closePlanTerminalState(directory, plan, options) {
     await bunWrite(markerPath, inProgressMarker);
   } catch {}
   try {
-    const mdPath = path9.join(swarmDir, "plan.md");
+    const mdPath = path8.join(swarmDir, "plan.md");
     const contentHash = computePlanContentHash(validated);
     const markdown = derivePlanMarkdown(validated);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdTempPath = path9.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdTempPath = path8.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(mdTempPath, markdownWithHash);
-    renameSync4(mdTempPath, mdPath);
+    renameSync3(mdTempPath, mdPath);
   } finally {
     try {
-      const markerPath = path9.join(swarmDir, ".plan-write-marker");
+      const markerPath = path8.join(swarmDir, ".plan-write-marker");
       const tasksCount = validated.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
       const marker = JSON.stringify({
         source: "plan_manager_close",
@@ -3818,19 +3422,19 @@ function migrateLegacyPlan(planContent, swarmId) {
 
 // src/evidence/manager.ts
 import {
-  mkdirSync as mkdirSync6,
-  readdirSync as readdirSync3,
+  mkdirSync as mkdirSync5,
+  readdirSync as readdirSync2,
   realpathSync as realpathSync2,
   rmSync,
   statSync as statSync2
 } from "fs";
-import * as fs7 from "fs/promises";
+import * as fs6 from "fs/promises";
 import * as os4 from "os";
-import * as path13 from "path";
+import * as path12 from "path";
 
 // src/evaluation/retention.ts
-import * as fs6 from "fs/promises";
-import * as path12 from "path";
+import * as fs5 from "fs/promises";
+import * as path11 from "path";
 
 // src/evaluation/contracts.ts
 var IdentifierSchema = exports_external.string().min(1).max(160).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
@@ -4205,13 +3809,13 @@ var TaskSetSnapshotV1Schema = exports_external.object({
 
 // src/evaluation/store.ts
 import { mkdir, readdir, readFile as readFile2 } from "fs/promises";
-import * as path11 from "path";
+import * as path10 from "path";
 
 // src/evaluation/hashing.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { lstatSync, realpathSync } from "fs";
 import { lstat, opendir, readFile, realpath } from "fs/promises";
-import * as path10 from "path";
+import * as path9 from "path";
 function canonicalize(value, ancestors) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
@@ -4252,7 +3856,7 @@ function canonicalJson(value) {
   return JSON.stringify(canonicalize(value, new Set));
 }
 function sha256(value) {
-  return createHash3("sha256").update(value).digest("hex");
+  return createHash2("sha256").update(value).digest("hex");
 }
 function canonicalHash(value) {
   return sha256(canonicalJson(value));
@@ -4302,9 +3906,9 @@ async function hashTree(projectRoot, relativePath, budget) {
     }
     if (!entryAlreadyCharged)
       chargeHashEntry(budget);
-    const relative3 = path10.relative(canonicalRoot, absolutePath).replace(/\\/g, "/");
+    const relative2 = path9.relative(canonicalRoot, absolutePath).replace(/\\/g, "/");
     if (stat.isDirectory()) {
-      entries.push({ path: relative3, type: "directory" });
+      entries.push({ path: relative2, type: "directory" });
       const children = [];
       const directory = await _internals9.opendir(absolutePath);
       try {
@@ -4319,12 +3923,12 @@ async function hashTree(projectRoot, relativePath, budget) {
         await closeDirectory(directory);
       }
       for (const child of children.sort()) {
-        await visit(path10.join(absolutePath, child), true);
+        await visit(path9.join(absolutePath, child), true);
       }
       return;
     }
     if (!stat.isFile()) {
-      throw new Error(`evaluation input must contain only regular files: ${relative3}`);
+      throw new Error(`evaluation input must contain only regular files: ${relative2}`);
     }
     budget.bytes += stat.size;
     if (budget.bytes > budget.limits.maxBytes) {
@@ -4332,7 +3936,7 @@ async function hashTree(projectRoot, relativePath, budget) {
     }
     const content = await _internals9.readFile(absolutePath);
     entries.push({
-      path: relative3,
+      path: relative2,
       type: "file",
       bytes: content.byteLength,
       sha256: sha256(content)
@@ -4362,10 +3966,10 @@ async function computeTaskLineageInputHash(projectRoot, task, limits = {}) {
   const normalizedTree = async (relativePath) => {
     const canonicalRoot = await _internals9.realpath(projectRoot);
     const target = await resolveContainedExistingPathAsync(projectRoot, relativePath);
-    const targetRelative = path10.relative(canonicalRoot, target).replace(/\\/g, "/");
+    const targetRelative = path9.relative(canonicalRoot, target).replace(/\\/g, "/");
     return (await hashTree(projectRoot, relativePath, budget)).map((entry) => ({
       ...entry,
-      path: path10.posix.relative(targetRelative, entry.path) || "."
+      path: path9.posix.relative(targetRelative, entry.path) || "."
     }));
   };
   const scorerArgv = [...task.scorer.argv];
@@ -4394,11 +3998,11 @@ function computeManifestContentHash(manifest) {
   return contentHashWithout(manifest, ["contentHash"]);
 }
 function isWithin(root, candidate) {
-  const relative3 = path10.relative(root, candidate);
-  return relative3 === "" || !relative3.startsWith("..") && !path10.isAbsolute(relative3);
+  const relative2 = path9.relative(root, candidate);
+  return relative2 === "" || !relative2.startsWith("..") && !path9.isAbsolute(relative2);
 }
 function resolveContainedExistingPath(root, relativePath) {
-  if (path10.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
+  if (path9.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
     throw new Error("evaluation path must be a non-NUL relative path");
   }
   const segments = relativePath.replace(/\\/g, "/").split("/").filter(Boolean);
@@ -4410,7 +4014,7 @@ function resolveContainedExistingPath(root, relativePath) {
   for (const segment of segments) {
     if (segment === ".")
       continue;
-    cursor = path10.join(cursor, segment);
+    cursor = path9.join(cursor, segment);
     const stat = lstatSync(cursor);
     if (stat.isSymbolicLink()) {
       throw new Error(`evaluation path contains a symlink or reparse point: ${relativePath}`);
@@ -4423,7 +4027,7 @@ function resolveContainedExistingPath(root, relativePath) {
   return canonicalCandidate;
 }
 async function resolveContainedExistingPathAsync(root, relativePath) {
-  if (path10.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
+  if (path9.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
     throw new Error("evaluation path must be a non-NUL relative path");
   }
   const segments = relativePath.replace(/\\/g, "/").split("/").filter(Boolean);
@@ -4435,7 +4039,7 @@ async function resolveContainedExistingPathAsync(root, relativePath) {
   for (const segment of segments) {
     if (segment === ".")
       continue;
-    cursor = path10.join(cursor, segment);
+    cursor = path9.join(cursor, segment);
     const stat = await _internals9.lstat(cursor);
     if (stat.isSymbolicLink()) {
       throw new Error(`evaluation path contains a symlink or reparse point: ${relativePath}`);
@@ -4456,8 +4060,8 @@ var _internals9 = {
 
 // src/evaluation/store.ts
 var AGENT = "evaluation-store";
-var TEST_LEDGER_RELATIVE = path11.join("evolution", "test-consumption.jsonl");
-var TASK_SPLIT_REGISTRY_RELATIVE = path11.join("evolution", "tasks", "split-registry.json");
+var TEST_LEDGER_RELATIVE = path10.join("evolution", "test-consumption.jsonl");
+var TASK_SPLIT_REGISTRY_RELATIVE = path10.join("evolution", "tasks", "split-registry.json");
 
 class EvaluationConflictError extends Error {
   constructor(message) {
@@ -4466,7 +4070,7 @@ class EvaluationConflictError extends Error {
   }
 }
 function swarmPath(directory, ...segments) {
-  return path11.join(directory, ".swarm", ...segments);
+  return path10.join(directory, ".swarm", ...segments);
 }
 function serialized(value) {
   return `${canonicalJson(value)}
@@ -4515,7 +4119,7 @@ async function readOptional(filePath) {
   }
 }
 async function writeImmutable(options) {
-  await mkdir(path11.dirname(options.filePath), { recursive: true });
+  await mkdir(path10.dirname(options.filePath), { recursive: true });
   return withEvidenceLock(options.directory, options.relativeLockPath, AGENT, options.taskId, async () => {
     const desired = serialized(options.value);
     const existing = await readOptional(options.filePath);
@@ -4543,8 +4147,8 @@ function validateTaskInputs(directory, task) {
     if (!executable)
       throw new Error("project scorer requires an executable");
     const scorerPath = resolveContainedExistingPath(directory, executable);
-    const relative4 = path11.relative(environmentRoot, scorerPath);
-    if (!relative4 || relative4 === ".." || relative4.startsWith(`..${path11.sep}`) || path11.isAbsolute(relative4)) {
+    const relative3 = path10.relative(environmentRoot, scorerPath);
+    if (!relative3 || relative3 === ".." || relative3.startsWith(`..${path10.sep}`) || path10.isAbsolute(relative3)) {
       throw new Error("project scorer executable must be inside the admitted task environment");
     }
   }
@@ -4556,10 +4160,10 @@ async function admitEvaluationTask(directory, input, inputRoot = directory) {
   }
   validateTaskInputs(inputRoot, task);
   const lineageInputHash = await computeTaskLineageInputHash(inputRoot, task);
-  const relative4 = path11.join("evolution", "tasks", task.split, `${task.id}.json`);
+  const relative3 = path10.join("evolution", "tasks", task.split, `${task.id}.json`);
   const admissionLock = TASK_SPLIT_REGISTRY_RELATIVE;
-  const filePath = swarmPath(directory, relative4);
-  await mkdir(path11.dirname(filePath), { recursive: true });
+  const filePath = swarmPath(directory, relative3);
+  await mkdir(path10.dirname(filePath), { recursive: true });
   return withEvidenceLock(directory, admissionLock, AGENT, task.id, async () => {
     const registryPath = swarmPath(directory, TASK_SPLIT_REGISTRY_RELATIVE);
     const registry = parseTaskSplitRegistry(await readOptional(registryPath));
@@ -4647,11 +4251,11 @@ async function saveTaskSetSnapshot(directory, input, inputRoot = directory) {
   if (computeTaskSetContentHash(snapshot) !== snapshot.contentHash) {
     throw new Error("task-set content hash does not match its canonical inputs");
   }
-  const relative4 = path11.join("evolution", "task-sets", `${snapshot.contentHash}.json`);
+  const relative3 = path10.join("evolution", "task-sets", `${snapshot.contentHash}.json`);
   return writeImmutable({
     directory,
-    relativeLockPath: relative4,
-    filePath: swarmPath(directory, relative4),
+    relativeLockPath: relative3,
+    filePath: swarmPath(directory, relative3),
     taskId: snapshot.id,
     value: snapshot,
     parse: (value) => TaskSetSnapshotV1Schema.parse(value),
@@ -4660,11 +4264,11 @@ async function saveTaskSetSnapshot(directory, input, inputRoot = directory) {
 }
 async function saveGateAuditResult(directory, input) {
   const result = GateAuditResultV1Schema.parse(input);
-  const relative4 = path11.join("evidence", "gate-audit", result.runId, "results.json");
+  const relative3 = path10.join("evidence", "gate-audit", result.runId, "results.json");
   return writeImmutable({
     directory,
-    relativeLockPath: relative4,
-    filePath: swarmPath(directory, relative4),
+    relativeLockPath: relative3,
+    filePath: swarmPath(directory, relative3),
     taskId: result.runId,
     value: result,
     parse: (value) => GateAuditResultV1Schema.parse(value)
@@ -4672,11 +4276,11 @@ async function saveGateAuditResult(directory, input) {
 }
 async function saveGateAuditManifest(directory, input) {
   const manifest = GateAuditManifestV1Schema.parse(input);
-  const relative4 = path11.join("evolution", "gate-audit-manifests", `${manifest.id}.json`);
+  const relative3 = path10.join("evolution", "gate-audit-manifests", `${manifest.id}.json`);
   return writeImmutable({
     directory,
-    relativeLockPath: relative4,
-    filePath: swarmPath(directory, relative4),
+    relativeLockPath: relative3,
+    filePath: swarmPath(directory, relative3),
     taskId: manifest.id,
     value: manifest,
     parse: (value) => GateAuditManifestV1Schema.parse(value)
@@ -4708,7 +4312,7 @@ async function listGateAuditResults(directory) {
       continue;
     }
     try {
-      const parsed = GateAuditResultV1Schema.parse(JSON.parse(await readFile2(path11.join(root, entry.name, "results.json"), "utf8")));
+      const parsed = GateAuditResultV1Schema.parse(JSON.parse(await readFile2(path10.join(root, entry.name, "results.json"), "utf8")));
       if (parsed.runId !== entry.name)
         throw new Error("run id/path mismatch");
       results.push(parsed);
@@ -4741,7 +4345,7 @@ async function getProtectedEvaluationRunIds(directory) {
       throw error2;
   }
   for (const filename of files.filter((value) => value.endsWith(".json")).sort()) {
-    const decision = PromotionDecisionV1Schema.parse(JSON.parse(await readFile2(path11.join(decisionsDirectory, filename), "utf8")));
+    const decision = PromotionDecisionV1Schema.parse(JSON.parse(await readFile2(path10.join(decisionsDirectory, filename), "utf8")));
     protectedIds.add(decision.runId);
     protectedIds.add(decision.lineage.baselineRunId);
     if (decision.lineage.historicalBestRunId !== "unavailable") {
@@ -4759,10 +4363,10 @@ function validId(value) {
   return /^[A-Za-z0-9][A-Za-z0-9._-]{0,159}$/.test(value);
 }
 async function evaluationRunCandidates(directory) {
-  const root = path12.join(directory, ".swarm", "evolution", "runs");
+  const root = path11.join(directory, ".swarm", "evolution", "runs");
   let entries = [];
   try {
-    entries = await fs6.readdir(root, { withFileTypes: true });
+    entries = await fs5.readdir(root, { withFileTypes: true });
   } catch (error2) {
     if (error2.code === "ENOENT") {
       return { candidates: [], corrupt: [] };
@@ -4778,9 +4382,9 @@ async function evaluationRunCandidates(directory) {
     if (!validId(id))
       continue;
     const artifact = { namespace: "evaluation-run", id };
-    const target = path12.join(root, entry.name);
+    const target = path11.join(root, entry.name);
     try {
-      const run = EvaluationRunV1Schema.parse(JSON.parse(await fs6.readFile(target, "utf8")));
+      const run = EvaluationRunV1Schema.parse(JSON.parse(await fs5.readFile(target, "utf8")));
       if (run.runId !== id)
         throw new Error("run id/path mismatch");
       candidates.push({
@@ -4796,10 +4400,10 @@ async function evaluationRunCandidates(directory) {
   return { candidates, corrupt };
 }
 async function gateAuditCandidates(directory) {
-  const root = path12.join(directory, ".swarm", "evidence", "gate-audit");
+  const root = path11.join(directory, ".swarm", "evidence", "gate-audit");
   let entries = [];
   try {
-    entries = await fs6.readdir(root, { withFileTypes: true });
+    entries = await fs5.readdir(root, { withFileTypes: true });
   } catch (error2) {
     if (error2.code === "ENOENT") {
       return { candidates: [], corrupt: [] };
@@ -4812,9 +4416,9 @@ async function gateAuditCandidates(directory) {
     if (!entry.isDirectory() || !validId(entry.name))
       continue;
     const artifact = { namespace: "gate-audit", id: entry.name };
-    const target = path12.join(root, entry.name);
+    const target = path11.join(root, entry.name);
     try {
-      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs6.readFile(path12.join(target, "results.json"), "utf8")));
+      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs5.readFile(path11.join(target, "results.json"), "utf8")));
       if (result.runId !== entry.name)
         throw new Error("run id/path mismatch");
       candidates.push({
@@ -4845,17 +4449,17 @@ async function protectedArtifacts(directory) {
 }
 async function removeCandidate(candidate) {
   if (candidate.kind === "directory") {
-    await fs6.rm(candidate.target, { recursive: true, force: true });
+    await fs5.rm(candidate.target, { recursive: true, force: true });
     return;
   }
-  await fs6.unlink(candidate.target);
+  await fs5.unlink(candidate.target);
 }
 var _retentionInternals = {
   protectedArtifacts,
   removeCandidate
 };
 async function archiveEvaluationArtifacts(args) {
-  return withEvidenceLock(args.directory, path12.join("evolution", "retention-index"), "evaluation-retention", "archive", async () => {
+  return withEvidenceLock(args.directory, path11.join("evolution", "retention-index"), "evaluation-retention", "archive", async () => {
     const inventory = await retentionCandidates(args.directory);
     let protectedKeys = await _retentionInternals.protectedArtifacts(args.directory);
     const protectedRefs = inventory.candidates.filter((candidate) => protectedKeys.has(artifactKey(candidate.artifact))).map((candidate) => candidate.artifact);
@@ -4942,8 +4546,8 @@ function isWeakConfigContainerRoot(directory) {
     const resolved = realpathSync2(directory);
     return resolved === realpathSync2(os4.tmpdir()) || resolved === realpathSync2(os4.homedir());
   } catch {
-    const resolved = path13.resolve(directory);
-    return resolved === path13.resolve(os4.tmpdir()) || resolved === path13.resolve(os4.homedir());
+    const resolved = path12.resolve(directory);
+    return resolved === path12.resolve(os4.tmpdir()) || resolved === path12.resolve(os4.homedir());
   }
 }
 function hasAccessibleProjectIndicator(directory, options = {}) {
@@ -4953,7 +4557,7 @@ function hasAccessibleProjectIndicator(directory, options = {}) {
       continue;
     }
     try {
-      const indicatorStat = statSync2(path13.join(directory, indicator));
+      const indicatorStat = statSync2(path12.join(directory, indicator));
       if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
         return true;
       }
@@ -4975,14 +4579,14 @@ function validateProjectRoot(directory) {
     if (depth >= MAX_DEPTH)
       break;
     depth++;
-    const parent = path13.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current)
       break;
-    if (path13.dirname(parent) === parent) {
+    if (path12.dirname(parent) === parent) {
       current = parent;
       continue;
     }
-    const parentSwarm = path13.join(parent, ".swarm");
+    const parentSwarm = path12.join(parent, ".swarm");
     try {
       if (statSync2(parentSwarm).isDirectory()) {
         if (hasAccessibleProjectIndicator(parent, {
@@ -5003,12 +4607,12 @@ function validateProjectRoot(directory) {
 async function saveEvidence(directory, taskId, evidence) {
   _internals10.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path13.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path12.join("evidence", sanitizedTaskId, "evidence.json");
   validateSwarmPath(directory, relativePath);
   _internals10.validateEvidence(evidence);
   return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
     const evidencePath = validateSwarmPath(directory, relativePath);
-    const evidenceDir = path13.dirname(evidencePath);
+    const evidenceDir = path12.dirname(evidencePath);
     let bundle;
     const existingContent = await readSwarmFileAsync(directory, relativePath);
     if (existingContent !== null) {
@@ -5050,11 +4654,11 @@ async function saveEvidence(directory, taskId, evidence) {
     if (bundleJson.length > EVIDENCE_MAX_JSON_BYTES) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
-    mkdirSync6(evidenceDir, { recursive: true });
-    const tempPath = path13.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+    mkdirSync5(evidenceDir, { recursive: true });
+    const tempPath = path12.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
-      await fs7.rename(tempPath, evidencePath);
+      await fs6.rename(tempPath, evidencePath);
     } catch (error2) {
       try {
         rmSync(tempPath, { force: true });
@@ -5095,7 +4699,7 @@ function wrapFlatRetrospective(flatEntry, taskId) {
 }
 async function loadEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path13.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path12.join("evidence", sanitizedTaskId, "evidence.json");
   if (relativePath.length > 4096) {
     return { status: "not_found" };
   }
@@ -5116,12 +4720,12 @@ async function loadEvidence(directory, taskId) {
       const validated = EvidenceBundleSchema.parse(wrappedBundle);
       try {
         await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
-          const evidenceDir = path13.dirname(evidencePath);
+          const evidenceDir = path12.dirname(evidencePath);
           const bundleJson = JSON.stringify(validated);
-          const tempPath = path13.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+          const tempPath = path12.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
           try {
             await bunWrite(tempPath, bundleJson);
-            await fs7.rename(tempPath, evidencePath);
+            await fs6.rename(tempPath, evidencePath);
           } catch (writeError) {
             try {
               rmSync(tempPath, { force: true });
@@ -5157,13 +4761,13 @@ async function listEvidenceTaskIds(directory) {
   }
   let entries;
   try {
-    entries = readdirSync3(evidenceBasePath);
+    entries = readdirSync2(evidenceBasePath);
   } catch {
     return [];
   }
   const taskIds = [];
   for (const entry of entries) {
-    const entryPath = path13.join(evidenceBasePath, entry);
+    const entryPath = path12.join(evidenceBasePath, entry);
     try {
       const stats = statSync2(entryPath);
       if (!stats.isDirectory()) {
@@ -5181,7 +4785,7 @@ async function listEvidenceTaskIds(directory) {
 }
 async function deleteEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path13.join("evidence", sanitizedTaskId);
+  const relativePath = path12.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
     statSync2(evidenceDir);
@@ -5197,10 +4801,10 @@ async function deleteEvidence(directory, taskId) {
   }
 }
 async function checkRequirementCoverage(phase, directory) {
-  const relativePath = path13.join("evidence", `req-coverage-phase-${phase}.json`);
-  const absolutePath = path13.resolve(directory, ".swarm", relativePath);
+  const relativePath = path12.join("evidence", `req-coverage-phase-${phase}.json`);
+  const absolutePath = path12.resolve(directory, ".swarm", relativePath);
   try {
-    await fs7.access(absolutePath);
+    await fs6.access(absolutePath);
     return { exists: true, path: absolutePath };
   } catch {
     return { exists: false, path: absolutePath };
@@ -5399,4 +5003,4 @@ function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
   return merged;
 }
 
-export { getExecutor, init_executor, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, resetToRemoteBranch, resetToMainAfterMerge, initDurableStatusPath, getAllWorktreeMergeFailures, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, computeSpecHash, derivePlanId, computePlanHash, initLedger, appendLedgerEvent, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, IdentifierSchema, EvaluationTaskV1Schema, GateNameSchema, GateAuditManifestV1Schema, GateAuditResultV1Schema, canonicalJson, canonicalHash, computeTaskInputContentHash, computeTaskSetContentHash, computeManifestContentHash, resolveContainedExistingPath, admitEvaluationTask, saveTaskSetSnapshot, saveGateAuditResult, saveGateAuditManifest, readGateAuditManifest, readGateAuditResult, listGateAuditResults, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };
+export { getExecutor, init_executor, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, resetToRemoteBranch, resetToMainAfterMerge, initDurableStatusPath, getAllWorktreeMergeFailures, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, computeSpecHash, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, IdentifierSchema, EvaluationTaskV1Schema, GateNameSchema, GateAuditManifestV1Schema, GateAuditResultV1Schema, canonicalJson, canonicalHash, computeTaskInputContentHash, computeTaskSetContentHash, computeManifestContentHash, resolveContainedExistingPath, admitEvaluationTask, saveTaskSetSnapshot, saveGateAuditResult, saveGateAuditManifest, readGateAuditManifest, readGateAuditResult, listGateAuditResults, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };