opencode-swarm 7.184.11 → 7.184.13

package/dist/cli/{index-645ckyxy.js → index-v4ra6hz8.js}

@@ -1,48 +1,31 @@
 // @bun
-import {
-  EvaluationRunV1Schema,
-  GateAuditResultV1Schema,
-  getProtectedEvaluationRunIds
-} from "./index-nh5fxxc9.js";
-import {
-  readEffectiveSpecSync
-} from "./index-c0dahh34.js";
 import {
   validateWorkspaceRoot
 } from "./index-6b295cas.js";
+import {
+  readEffectiveSpecSync
+} from "./index-9y5b3nsk.js";
 import {
   getWorktreeMergeFailure
 } from "./index-zsrtt42s.js";
 import {
   GitBinaryMissingError,
   GitSpawnCwdError,
-  TASK_WORKFLOW_SCHEMA_MARKER,
-  deriveApplicableGateSet,
   isGitBinaryMissing,
   isSpawnCwdMissing,
-  isSpawnCwdUnreadable,
-  isValidTaskId,
-  readCurrentTaskDeclaredFiles,
-  readTaskEvidence,
-  readTaskEvidenceRaw,
-  sanitizeTaskId
-} from "./index-hwjr3xyg.js";
+  isSpawnCwdUnreadable
+} from "./index-g4fs6z4e.js";
 import {
   estimateCharsForTokens,
   estimateTokens,
   readSwarmFileAsync,
   validateSwarmPath
-} from "./index-gnryhmak.js";
+} from "./index-dftztz4y.js";
 import {
   bunHash,
   bunWrite,
   mergeEnvForChild
 } from "./index-2s7dvzff.js";
-import {
-  EVIDENCE_MAX_JSON_BYTES,
-  EvidenceBundleSchema,
-  EvidenceSchema
-} from "./index-frcemc0b.js";
 import {
   LedgerStaleWriterError,
   appendLedgerEvent,
@@ -61,33 +44,32 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-e0rrj9kk.js";
+} from "./index-d2xdwz22.js";
 import {
   appendCoreEventSync
-} from "./index-kg2mb1m5.js";
+} from "./index-7rzgdcvc.js";
 import {
-  derivePlanId,
-  derivePlanIdentityHash,
   getCoordinationState,
   importCoordinationOnce,
   listCoordinationStates,
   transitionCoordinationState
-} from "./index-aae38s4x.js";
+} from "./index-cftva3pa.js";
 import {
   DURABILITY_CLASSES,
   getProjectDb,
   projectDbExists,
   withDurabilityClass
-} from "./index-5m1b70z3.js";
+} from "./index-pwcbtbhd.js";
 import {
-  withEvidenceLock
-} from "./index-35cdceqf.js";
+  derivePlanId,
+  derivePlanIdentityHash
+} from "./index-7pmbnjvj.js";
 import {
   assertProjectRoot
 } from "./index-t7hmqgjy.js";
 import {
   emit
-} from "./index-x1gyqgze.js";
+} from "./index-w6w6ny06.js";
 import {
   canonicalRootKeyFresh
 } from "./index-mc72pk74.js";
@@ -98,7 +80,7 @@ import {
   atomicWriteSwarmFileSync,
   invalidateCachedArtifact,
   readCachedParsedFile
-} from "./index-0mj7hc2z.js";
+} from "./index-bntwj2tp.js";
 import {
   PlanSchema,
   normalizeCurrentPhaseInPlace,
@@ -110,10 +92,6 @@ import {
   init_git_executable,
   resolveGitExecutable
 } from "./index-zxdawwc7.js";
-import {
-  ZodError,
-  init_zod
-} from "./index-gknz3bv1.js";
 import {
   init_executor,
   isUntrustedEnvKey,
@@ -129,19 +107,6 @@ import {
   __require
 } from "./index-a76rekgs.js";
 
-// src/plan/manager.ts
-import {
-  closeSync,
-  fsyncSync,
-  mkdirSync as mkdirSync2,
-  openSync,
-  renameSync as renameSync2,
-  unlinkSync,
-  writeFileSync
-} from "fs";
-import * as fsPromises from "fs/promises";
-import * as path3 from "path";
-
 // src/db/task-checkpoint-receipt.ts
 import { createHash } from "crypto";
 var TASK_COMPLETION_HASH_LENGTH = 16;
@@ -299,14 +264,6 @@ function updateTaskCheckpointReceipt(directory, descriptor, state, sha) {
   return rowAfter;
 }
 
-// src/git/branch.ts
-init_executor();
-import * as child_process from "child_process";
-import * as fsSync from "fs";
-import path from "path";
-init_git_executable();
-init_logger();
-
 // src/utils/transient-retry.ts
 var MAX_TRANSIENT_RETRIES = 5;
 var RETRY_BASE_DELAY_MS = 200;
@@ -326,6 +283,27 @@ function transientBackoff(attempt) {
   }
 }
 
+// src/plan/manager.ts
+import {
+  closeSync,
+  fsyncSync,
+  mkdirSync as mkdirSync2,
+  openSync,
+  renameSync as renameSync2,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import * as fsPromises from "fs/promises";
+import * as path3 from "path";
+
+// src/git/branch.ts
+init_executor();
+import * as child_process from "child_process";
+import * as fsSync from "fs";
+import path from "path";
+init_git_executable();
+init_logger();
+
 // src/git/safe-ref.ts
 class UnsafeGitRefError extends Error {
   ref;
@@ -1764,7 +1742,8 @@ var _internals5 = {
   isEpicModeActiveForProject,
   commitTaskCompletion,
   getWorktreeMergeFailure,
-  recordTaskAttempt
+  recordTaskAttempt,
+  maybeSaveAutoCheckpoint: defaultMaybeSaveAutoCheckpoint
 };
 var CAS_BACKOFF_START_MS = 5;
 var CAS_BACKOFF_CAP_MS = 250;
@@ -3024,6 +3003,10 @@ ${markdown}`;
     } catch {}
   }
 }
+async function defaultMaybeSaveAutoCheckpoint(directory, plan) {
+  const { maybeSaveAutoCheckpoint } = await import("./auto-checkpoint-a2zbyh20.js");
+  return maybeSaveAutoCheckpoint(directory, plan);
+}
 async function updateTaskStatus(directory, taskId, status, options) {
   assertProjectRoot(directory);
   const derivePhaseStatusFromTasks = (tasks) => {
@@ -3097,7 +3080,7 @@ async function updateTaskStatus(directory, taskId, status, options) {
       if (status === "completed") {
         try {
           const completedTask = updatedPlan.phases.flatMap((phase) => phase.tasks).find((candidate) => candidate.id === taskId);
-          const { maybePropagateSpeckitCheckoff } = await import("./speckit-checkoff-hc479v4r.js");
+          const { maybePropagateSpeckitCheckoff } = await import("./speckit-checkoff-qxt03eh3.js");
           await maybePropagateSpeckitCheckoff(directory, {
             taskId,
             frRefs: completedTask?.fr_refs ?? [],
@@ -3122,7 +3105,7 @@ async function updateTaskStatus(directory, taskId, status, options) {
               break;
             }
           }
-          const { readDeclaredScopeFilesFromBindings } = await import("./scope-persistence-de472fxy.js");
+          const { readDeclaredScopeFilesFromBindings } = await import("./scope-persistence-vtz91b5n.js");
           const canonicalScope = readDeclaredScopeFilesFromBindings({
             directory,
             taskId,
@@ -3133,6 +3116,16 @@ async function updateTaskStatus(directory, taskId, status, options) {
           criticalWarn(`[plan/manager] Rule 2 auto-commit for ${taskId} threw (non-fatal): ${commitErr instanceof Error ? commitErr.message : String(commitErr)}`);
         }
       }
+      if (status === "completed") {
+        try {
+          const outcome = await _internals5.maybeSaveAutoCheckpoint(directory, updatedPlan);
+          if (outcome && outcome.saved === false && outcome.warning) {
+            criticalWarn(`[plan/manager] auto-checkpoint for ${taskId} was not saved (non-fatal): ${outcome.warning}`);
+          }
+        } catch (checkpointErr) {
+          criticalWarn(`[plan/manager] auto-checkpoint cadence trigger for ${taskId} failed (non-fatal): ${checkpointErr instanceof Error ? checkpointErr.message : String(checkpointErr)}`);
+        }
+      }
       return updatedPlan;
     } catch (error2) {
       if (error2 instanceof PlanConcurrentModificationError && attempt < MAX_OUTER_RETRIES) {
@@ -3453,913 +3446,4 @@ function migrateLegacyPlan(planContent, swarmId) {
   return plan;
 }
 
-// src/evidence/manager.ts
-init_zod();
-import {
-  mkdirSync as mkdirSync3,
-  readdirSync,
-  realpathSync,
-  renameSync as renameSync3,
-  rmSync,
-  statSync as statSync2
-} from "fs";
-import * as fs5 from "fs/promises";
-import * as path5 from "path";
-
-// src/evaluation/retention.ts
-import * as fs3 from "fs/promises";
-import * as path4 from "path";
-function artifactKey(artifact) {
-  return `${artifact.namespace}/${artifact.id}`;
-}
-function validId(value) {
-  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,159}$/.test(value);
-}
-async function evaluationRunCandidates(directory) {
-  const root = path4.join(directory, ".swarm", "evolution", "runs");
-  let entries = [];
-  try {
-    entries = await fs3.readdir(root, { withFileTypes: true });
-  } catch (error2) {
-    if (error2.code === "ENOENT") {
-      return { candidates: [], corrupt: [] };
-    }
-    throw error2;
-  }
-  const candidates = [];
-  const corrupt = [];
-  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    if (!entry.isFile() || !entry.name.endsWith(".json"))
-      continue;
-    const id = entry.name.slice(0, -".json".length);
-    if (!validId(id))
-      continue;
-    const artifact = { namespace: "evaluation-run", id };
-    const target = path4.join(root, entry.name);
-    try {
-      const run = EvaluationRunV1Schema.parse(JSON.parse(await fs3.readFile(target, "utf8")));
-      if (run.runId !== id)
-        throw new Error("run id/path mismatch");
-      candidates.push({
-        artifact,
-        createdAt: run.createdAt,
-        target,
-        kind: "file"
-      });
-    } catch {
-      corrupt.push(artifact);
-    }
-  }
-  return { candidates, corrupt };
-}
-async function gateAuditCandidates(directory) {
-  const root = path4.join(directory, ".swarm", "evidence", "gate-audit");
-  let entries = [];
-  try {
-    entries = await fs3.readdir(root, { withFileTypes: true });
-  } catch (error2) {
-    if (error2.code === "ENOENT") {
-      return { candidates: [], corrupt: [] };
-    }
-    throw error2;
-  }
-  const candidates = [];
-  const corrupt = [];
-  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    if (!entry.isDirectory() || !validId(entry.name))
-      continue;
-    const artifact = { namespace: "gate-audit", id: entry.name };
-    const target = path4.join(root, entry.name);
-    try {
-      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs3.readFile(path4.join(target, "results.json"), "utf8")));
-      if (result.runId !== entry.name)
-        throw new Error("run id/path mismatch");
-      candidates.push({
-        artifact,
-        createdAt: result.createdAt,
-        target,
-        kind: "directory"
-      });
-    } catch {
-      corrupt.push(artifact);
-    }
-  }
-  return { candidates, corrupt };
-}
-async function retentionCandidates(directory) {
-  const [runs, audits] = await Promise.all([
-    evaluationRunCandidates(directory),
-    gateAuditCandidates(directory)
-  ]);
-  return {
-    candidates: [...runs.candidates, ...audits.candidates].sort((a, b) => artifactKey(a.artifact).localeCompare(artifactKey(b.artifact))),
-    corrupt: [...runs.corrupt, ...audits.corrupt].sort((a, b) => artifactKey(a).localeCompare(artifactKey(b)))
-  };
-}
-async function protectedArtifacts(directory) {
-  const ids = await getProtectedEvaluationRunIds(directory);
-  return new Set([...ids].map((id) => `evaluation-run/${id}`));
-}
-async function removeCandidate(candidate) {
-  if (candidate.kind === "directory") {
-    await fs3.rm(candidate.target, { recursive: true, force: true });
-    return;
-  }
-  await fs3.unlink(candidate.target);
-}
-var _retentionInternals = {
-  protectedArtifacts,
-  removeCandidate
-};
-async function archiveEvaluationArtifacts(args) {
-  assertProjectRoot(args.directory);
-  return withEvidenceLock(args.directory, path4.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);
-    const eligible = inventory.candidates.filter((candidate) => !protectedKeys.has(artifactKey(candidate.artifact)));
-    const now = args.now ?? new Date;
-    const cutoff = new Date(now.getTime() - args.maxAgeDays * 86400000).toISOString();
-    const selectedKeys = new Set(eligible.filter((candidate) => candidate.createdAt < cutoff).map((candidate) => artifactKey(candidate.artifact)));
-    const remaining = eligible.filter((candidate) => !selectedKeys.has(artifactKey(candidate.artifact))).sort((a, b) => a.createdAt === b.createdAt ? artifactKey(a.artifact).localeCompare(artifactKey(b.artifact)) : a.createdAt.localeCompare(b.createdAt));
-    if (args.maxBundles !== undefined && remaining.length > args.maxBundles) {
-      for (const candidate of remaining.slice(0, remaining.length - args.maxBundles)) {
-        selectedKeys.add(artifactKey(candidate.artifact));
-      }
-    }
-    const selectedCandidates = eligible.filter((candidate) => selectedKeys.has(artifactKey(candidate.artifact))).sort((a, b) => artifactKey(a.artifact).localeCompare(artifactKey(b.artifact)));
-    const archived = [];
-    const failed = [];
-    if (!args.dryRun) {
-      for (const candidate of selectedCandidates) {
-        protectedKeys = await _retentionInternals.protectedArtifacts(args.directory);
-        if (protectedKeys.has(artifactKey(candidate.artifact))) {
-          protectedRefs.push(candidate.artifact);
-          continue;
-        }
-        try {
-          await _retentionInternals.removeCandidate(candidate);
-          archived.push(candidate.artifact);
-        } catch (error2) {
-          failed.push({
-            artifact: candidate.artifact,
-            error: error2 instanceof Error ? error2.message : String(error2)
-          });
-        }
-      }
-    }
-    return {
-      inventory: inventory.candidates.map((candidate) => candidate.artifact),
-      selected: selectedCandidates.map((candidate) => candidate.artifact),
-      archived,
-      corrupt: inventory.corrupt,
-      protected: [
-        ...new Map(protectedRefs.map((artifact) => [artifactKey(artifact), artifact])).values()
-      ].sort((a, b) => artifactKey(a).localeCompare(artifactKey(b))),
-      failed
-    };
-  });
-}
-
-// src/evidence/documents-retention.ts
-import * as fs4 from "fs";
-import * as fsp from "fs/promises";
-import * as readline from "readline";
-var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
-var MAX_READ_BYTES = 100 * 1024 * 1024;
-var RENAME_MAX_ATTEMPTS = 5;
-var RENAME_BACKOFF_MS = 10;
-var RENAME_RETRY_CODES = new Set(["EPERM", "EBUSY", "ENOTEMPTY", "EACCES"]);
-var _internals6 = {
-  stat: (p) => fsp.stat(p),
-  createReadStream: (p, options) => fs4.createReadStream(p, options),
-  openSync: (p, flags) => fs4.openSync(p, flags),
-  writeSync: (fd, data, position) => fs4.writeSync(fd, data, position),
-  fsyncSync: (fd) => fs4.fsyncSync(fd),
-  closeSync: (fd) => fs4.closeSync(fd),
-  renameWithRetry: atomicRenameWithRetry,
-  unlink: (p) => fsp.unlink(p)
-};
-async function atomicRenameWithRetry(src, dst, renameFn = fsp.rename) {
-  let lastErr;
-  for (let attempt = 0;attempt < RENAME_MAX_ATTEMPTS; attempt++) {
-    try {
-      await renameFn(src, dst);
-      return;
-    } catch (err) {
-      lastErr = err;
-      const code = err?.code;
-      if (!code || !RENAME_RETRY_CODES.has(code)) {
-        throw err;
-      }
-      if (attempt < RENAME_MAX_ATTEMPTS - 1) {
-        await new Promise((resolve3) => setTimeout(resolve3, RENAME_BACKOFF_MS));
-      }
-    }
-  }
-  throw lastErr;
-}
-function emptyResult(dryRun) {
-  return {
-    inventory: 0,
-    selected: 0,
-    archived: 0,
-    corrupt: 0,
-    bytesBefore: 0,
-    bytesAfter: 0,
-    dryRun,
-    aborted: false
-  };
-}
-async function readCacheRows(filePath) {
-  const stat2 = await _internals6.stat(filePath);
-  const bytesBefore = stat2.size;
-  const stream = _internals6.createReadStream(filePath, {
-    encoding: "utf8",
-    highWaterMark: 64 * 1024
-  });
-  const rl = readline.createInterface({
-    input: stream,
-    crlfDelay: Infinity
-  });
-  const rows = [];
-  let corrupt = 0;
-  let bytesRead = 0;
-  let aborted = false;
-  try {
-    for await (const line of rl) {
-      const lineBytes = Buffer.byteLength(line, "utf8") + 1;
-      bytesRead += lineBytes;
-      if (bytesRead > MAX_READ_BYTES) {
-        aborted = true;
-        break;
-      }
-      if (line.length === 0)
-        continue;
-      let record = null;
-      try {
-        const parsed = JSON.parse(line);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-          record = parsed;
-        } else {
-          corrupt++;
-          continue;
-        }
-      } catch {
-        corrupt++;
-        continue;
-      }
-      rows.push({ raw: line, bytes: lineBytes, record });
-    }
-  } finally {
-    rl.close();
-    stream.destroy();
-  }
-  return { rows, corrupt, aborted, bytesBefore };
-}
-function oldestFirst(a, b) {
-  const at = typeof a.record?.capturedAt === "string" ? a.record.capturedAt : "";
-  const bt = typeof b.record?.capturedAt === "string" ? b.record.capturedAt : "";
-  if (at === bt)
-    return a.raw.localeCompare(b.raw);
-  return at.localeCompare(bt);
-}
-function selectSurvivors(rows, maxRecords, maxBytes) {
-  const ordered = [...rows].sort(oldestFirst);
-  let keepFrom = 0;
-  if (typeof maxRecords === "number" && ordered.length > maxRecords) {
-    keepFrom = ordered.length - maxRecords;
-  }
-  if (typeof maxBytes === "number" && maxBytes > 0) {
-    let total = 0;
-    for (let i = keepFrom;i < ordered.length; i++) {
-      total += ordered[i].bytes;
-    }
-    while (keepFrom < ordered.length && total > maxBytes) {
-      total -= ordered[keepFrom].bytes;
-      keepFrom++;
-    }
-  }
-  const survivors = ordered.slice(keepFrom);
-  const selected = rows.length - survivors.length;
-  return { survivors, selected };
-}
-async function rewriteAtomic(filePath, survivors) {
-  const tmpPath = `${filePath}.tmp.${Date.now()}.${process.pid}`;
-  const payload = survivors.length > 0 ? `${survivors.map((row) => row.raw).join(`
-`)}
-` : "";
-  let succeeded = false;
-  const fd = _internals6.openSync(tmpPath, "w");
-  try {
-    _internals6.writeSync(fd, payload, 0);
-    _internals6.fsyncSync(fd);
-    _internals6.closeSync(fd);
-    await _internals6.renameWithRetry(tmpPath, filePath);
-    succeeded = true;
-  } catch (err) {
-    try {
-      _internals6.closeSync(fd);
-    } catch {}
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`documents-cache rewrite failed: ${msg}`);
-  } finally {
-    if (!succeeded) {
-      try {
-        await _internals6.unlink(tmpPath);
-      } catch {}
-    }
-  }
-  return Buffer.byteLength(payload, "utf8");
-}
-async function pruneEvidenceDocuments(args) {
-  assertProjectRoot(args.directory);
-  const dryRun = args.dryRun === true;
-  const capsUnset = (typeof args.maxBytes !== "number" || args.maxBytes <= 0) && (typeof args.maxRecords !== "number" || args.maxRecords <= 0);
-  const filePath = validateSwarmPath(args.directory, EVIDENCE_CACHE_FILE);
-  let stat2;
-  try {
-    stat2 = await _internals6.stat(filePath);
-  } catch (err) {
-    const code = err?.code;
-    if (code === "ENOENT")
-      return emptyResult(dryRun);
-    throw err;
-  }
-  if (capsUnset) {
-    return {
-      inventory: 0,
-      selected: 0,
-      archived: 0,
-      corrupt: 0,
-      bytesBefore: stat2.size,
-      bytesAfter: stat2.size,
-      dryRun,
-      aborted: false
-    };
-  }
-  let readResult;
-  try {
-    readResult = await readCacheRows(filePath);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    warn(`documents-cache prune: read failed: ${msg}`);
-    throw err;
-  }
-  if (readResult.aborted) {
-    warn(`documents-cache prune: aborted, file exceeds ${MAX_READ_BYTES} bytes; left untouched`);
-    return {
-      inventory: readResult.rows.length,
-      selected: 0,
-      archived: 0,
-      corrupt: readResult.corrupt,
-      bytesBefore: readResult.bytesBefore,
-      bytesAfter: readResult.bytesBefore,
-      dryRun,
-      aborted: true
-    };
-  }
-  const { survivors, selected } = selectSurvivors(readResult.rows, args.maxRecords, args.maxBytes);
-  if (dryRun) {
-    const bytesAfter2 = survivors.reduce((sum, row) => sum + row.bytes, 0);
-    return {
-      inventory: readResult.rows.length,
-      selected,
-      archived: 0,
-      corrupt: readResult.corrupt,
-      bytesBefore: readResult.bytesBefore,
-      bytesAfter: bytesAfter2,
-      dryRun: true,
-      aborted: false
-    };
-  }
-  if (selected === 0 && readResult.corrupt === 0) {
-    return {
-      inventory: readResult.rows.length,
-      selected: 0,
-      archived: 0,
-      corrupt: 0,
-      bytesBefore: readResult.bytesBefore,
-      bytesAfter: readResult.bytesBefore,
-      dryRun: false,
-      aborted: false
-    };
-  }
-  const bytesAfter = await rewriteAtomic(filePath, survivors);
-  return {
-    inventory: readResult.rows.length,
-    selected,
-    archived: selected,
-    corrupt: readResult.corrupt,
-    bytesBefore: readResult.bytesBefore,
-    bytesAfter,
-    dryRun: false,
-    aborted: false
-  };
-}
-
-// src/evidence/manager.ts
-var VALID_EVIDENCE_TYPES = [
-  "review",
-  "test",
-  "diff",
-  "approval",
-  "note",
-  "retrospective",
-  "syntax",
-  "placeholder",
-  "sast",
-  "sbom",
-  "build",
-  "quality_budget",
-  "secretscan"
-];
-function isValidEvidenceType(type) {
-  return VALID_EVIDENCE_TYPES.includes(type);
-}
-function isSecretscanEvidence(evidence) {
-  return evidence.type === "secretscan";
-}
-var sanitizeTaskId2 = sanitizeTaskId;
-function validateProjectRoot(directory) {
-  assertProjectRoot(directory, {
-    realpathSync: _internals7.realpathSync,
-    statSync: _internals7.statSync
-  }, "evidence");
-}
-async function saveEvidence(directory, taskId, evidence, abortSignal) {
-  abortSignal?.throwIfAborted();
-  _internals7.validateProjectRoot(directory);
-  const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path5.join("evidence", sanitizedTaskId, "evidence.json");
-  validateSwarmPath(directory, relativePath);
-  _internals7.validateEvidence(evidence);
-  return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
-    abortSignal?.throwIfAborted();
-    const evidencePath = validateSwarmPath(directory, relativePath);
-    const evidenceDir = path5.dirname(evidencePath);
-    let bundle;
-    const existingContent = await readSwarmFileAsync(directory, relativePath);
-    abortSignal?.throwIfAborted();
-    if (existingContent !== null) {
-      try {
-        const parsed = JSON.parse(existingContent);
-        bundle = EvidenceBundleSchema.parse(parsed);
-      } catch (error2) {
-        warn(`Existing evidence bundle invalid for task ${sanitizedTaskId}, creating new: ${error2 instanceof Error ? error2.message : String(error2)}`);
-        const now = new Date().toISOString();
-        bundle = {
-          schema_version: "1.0.0",
-          task_id: sanitizedTaskId,
-          entries: [],
-          created_at: now,
-          updated_at: now
-        };
-      }
-    } else {
-      const now = new Date().toISOString();
-      bundle = {
-        schema_version: "1.0.0",
-        task_id: sanitizedTaskId,
-        entries: [],
-        created_at: now,
-        updated_at: now
-      };
-    }
-    const MAX_BUNDLE_ENTRIES = 100;
-    let entries = [...bundle.entries, evidence];
-    if (entries.length > MAX_BUNDLE_ENTRIES) {
-      entries = entries.slice(entries.length - MAX_BUNDLE_ENTRIES);
-    }
-    const updatedBundle = {
-      ...bundle,
-      entries,
-      updated_at: new Date().toISOString()
-    };
-    const bundleJson = JSON.stringify(updatedBundle);
-    if (bundleJson.length > EVIDENCE_MAX_JSON_BYTES) {
-      throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
-    }
-    mkdirSync3(evidenceDir, { recursive: true });
-    const tempPath = path5.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
-    try {
-      await bunWrite(tempPath, bundleJson);
-      abortSignal?.throwIfAborted();
-      renameSync3(tempPath, evidencePath);
-    } catch (error2) {
-      try {
-        rmSync(tempPath, { force: true });
-      } catch {}
-      throw error2;
-    }
-    invalidateCachedArtifact(evidencePath);
-    return updatedBundle;
-  });
-}
-function isFlatRetrospective(parsed) {
-  return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && parsed.type === "retrospective" && !parsed.schema_version;
-}
-var LEGACY_TASK_COMPLEXITY_MAP = {
-  low: "simple",
-  medium: "moderate",
-  high: "complex"
-};
-function remapLegacyTaskComplexity(entry) {
-  const taskComplexity = entry.task_complexity;
-  if (typeof taskComplexity === "string" && taskComplexity in LEGACY_TASK_COMPLEXITY_MAP) {
-    return {
-      ...entry,
-      task_complexity: LEGACY_TASK_COMPLEXITY_MAP[taskComplexity]
-    };
-  }
-  return entry;
-}
-function wrapFlatRetrospective(flatEntry, taskId) {
-  const now = new Date().toISOString();
-  const remappedEntry = remapLegacyTaskComplexity(flatEntry);
-  return {
-    schema_version: "1.0.0",
-    task_id: remappedEntry.task_id ?? taskId,
-    created_at: remappedEntry.timestamp ?? now,
-    updated_at: remappedEntry.timestamp ?? now,
-    entries: [remappedEntry]
-  };
-}
-async function loadEvidence(directory, taskId, options) {
-  const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path5.join("evidence", sanitizedTaskId, "evidence.json");
-  if (relativePath.length > 4096) {
-    return { status: "not_found" };
-  }
-  const evidencePath = validateSwarmPath(directory, relativePath);
-  const content = await readSwarmFileAsync(directory, relativePath);
-  if (content === null) {
-    return { status: "not_found" };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    return { status: "invalid_schema", errors: ["Invalid JSON"] };
-  }
-  if (isFlatRetrospective(parsed)) {
-    const wrappedBundle = _internals7.wrapFlatRetrospective(parsed, sanitizedTaskId);
-    try {
-      const validated = EvidenceBundleSchema.parse(wrappedBundle);
-      if (options?.migrate === false) {
-        return { status: "found", bundle: validated };
-      }
-      try {
-        validateProjectRoot(directory);
-        await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
-          const evidenceDir = path5.dirname(evidencePath);
-          const bundleJson = JSON.stringify(validated);
-          const tempPath = path5.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
-          try {
-            await bunWrite(tempPath, bundleJson);
-            await fs5.rename(tempPath, evidencePath);
-            invalidateCachedArtifact(evidencePath);
-          } catch (writeError) {
-            try {
-              rmSync(tempPath, { force: true });
-            } catch {}
-            warn(`Failed to persist repaired flat retrospective for task ${sanitizedTaskId}: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
-          }
-        });
-      } catch (lockErr) {
-        warn(`Evidence lock failed during flat-retrospective write-back for task ${sanitizedTaskId}: ${lockErr instanceof Error ? lockErr.message : String(lockErr)}`);
-      }
-      return { status: "found", bundle: validated };
-    } catch (error2) {
-      warn(`Wrapped flat retrospective failed validation for task ${sanitizedTaskId}: ${error2 instanceof Error ? error2.message : String(error2)}`);
-      const errors = error2 instanceof ZodError ? error2.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [error2 instanceof Error ? error2.message : String(error2)];
-      return { status: "invalid_schema", errors };
-    }
-  }
-  try {
-    const validated = EvidenceBundleSchema.parse(parsed);
-    return { status: "found", bundle: validated };
-  } catch (error2) {
-    warn(`Evidence bundle validation failed for task ${sanitizedTaskId}: ${error2 instanceof Error ? error2.message : String(error2)}`);
-    const errors = error2 instanceof ZodError ? error2.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [error2 instanceof Error ? error2.message : String(error2)];
-    return { status: "invalid_schema", errors };
-  }
-}
-async function listEvidenceTaskIds(directory) {
-  const evidenceBasePath = validateSwarmPath(directory, "evidence");
-  try {
-    statSync2(evidenceBasePath);
-  } catch {
-    return [];
-  }
-  let entries;
-  try {
-    entries = readdirSync(evidenceBasePath);
-  } catch {
-    return [];
-  }
-  const taskIds = [];
-  for (const entry of entries) {
-    const entryPath = path5.join(evidenceBasePath, entry);
-    try {
-      const stats = statSync2(entryPath);
-      if (!stats.isDirectory()) {
-        continue;
-      }
-      sanitizeTaskId2(entry);
-      taskIds.push(entry);
-    } catch (error2) {
-      if (error2 instanceof Error && !error2.message.startsWith("Invalid task ID")) {
-        warn(`Error reading evidence entry '${entry}': ${error2.message}`);
-      }
-    }
-  }
-  return taskIds.sort();
-}
-async function deleteEvidence(directory, taskId) {
-  const sanitizedTaskId = sanitizeTaskId2(taskId);
-  try {
-    validateProjectRoot(directory);
-  } catch {
-    return false;
-  }
-  const relativePath = path5.join("evidence", sanitizedTaskId);
-  const evidenceDir = validateSwarmPath(directory, relativePath);
-  try {
-    statSync2(evidenceDir);
-  } catch {
-    return false;
-  }
-  try {
-    rmSync(evidenceDir, { recursive: true, force: true });
-    return true;
-  } catch (error2) {
-    warn(`Failed to delete evidence for task ${sanitizedTaskId}: ${error2 instanceof Error ? error2.message : String(error2)}`);
-    return false;
-  }
-}
-async function checkRequirementCoverage(phase, directory) {
-  const relativePath = path5.join("evidence", `req-coverage-phase-${phase}.json`);
-  const absolutePath = path5.resolve(directory, ".swarm", relativePath);
-  try {
-    await fs5.access(absolutePath);
-    return { exists: true, path: absolutePath };
-  } catch {
-    return { exists: false, path: absolutePath };
-  }
-}
-async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
-  const taskIds = await _internals7.listEvidenceTaskIds(directory);
-  const cutoffDate = options?.now ? new Date(options.now) : _internals7.now();
-  cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
-  const cutoffIso = cutoffDate.toISOString();
-  const selected = new Set;
-  const selectedByAge = new Set;
-  const selectedByCount = new Set;
-  const archived = [];
-  const failed = [];
-  const remainingBundles = [];
-  for (const taskId of taskIds) {
-    let result;
-    try {
-      result = await _internals7.loadEvidence(directory, taskId);
-    } catch {
-      warn("archive: skipping corrupt or unreadable evidence for task", taskId);
-      continue;
-    }
-    if (result.status !== "found") {
-      continue;
-    }
-    if (result.bundle.updated_at < cutoffIso) {
-      selected.add(taskId);
-      selectedByAge.add(taskId);
-    } else {
-      remainingBundles.push({
-        taskId,
-        updatedAt: result.bundle.updated_at
-      });
-    }
-  }
-  if (maxBundles !== undefined && remainingBundles.length > maxBundles) {
-    remainingBundles.sort((a, b) => a.updatedAt.localeCompare(b.updatedAt));
-    const toDelete = remainingBundles.length - maxBundles;
-    for (let i = 0;i < toDelete; i++) {
-      selected.add(remainingBundles[i].taskId);
-      selectedByCount.add(remainingBundles[i].taskId);
-    }
-  }
-  if (!options?.dryRun) {
-    for (const taskId of [...selected].sort()) {
-      const deleted = await _internals7.deleteEvidence(directory, taskId);
-      if (deleted)
-        archived.push(taskId);
-      else
-        failed.push(taskId);
-    }
-  }
-  const evaluation = await archiveEvaluationArtifacts({
-    directory,
-    maxAgeDays,
-    maxBundles,
-    dryRun: options?.dryRun,
-    now: options?.now
-  });
-  let documentsCache = {
-    inventory: 0,
-    selected: 0,
-    archived: 0,
-    corrupt: 0,
-    bytesBefore: 0,
-    bytesAfter: 0,
-    dryRun: options?.dryRun === true,
-    aborted: false
-  };
-  if (typeof options?.cacheMaxBytes === "number" && options.cacheMaxBytes > 0 || typeof options?.cacheMaxRecords === "number" && options.cacheMaxRecords > 0) {
-    try {
-      documentsCache = await _internals7.pruneEvidenceDocuments({
-        directory,
-        maxBytes: options?.cacheMaxBytes,
-        maxRecords: options?.cacheMaxRecords,
-        dryRun: options?.dryRun
-      });
-    } catch (error2) {
-      const msg = error2 instanceof Error ? error2.message : String(error2);
-      warn(`archiveEvidence: documents-cache prune failed (fail-open): ${msg}`);
-    }
-  }
-  if (options?.report) {
-    return {
-      inventoryEvidence: [...taskIds].sort(),
-      selectedEvidence: [...selected].sort(),
-      selectedEvidenceByAge: [...selectedByAge].sort(),
-      selectedEvidenceByCount: [...selectedByCount].sort(),
-      archivedEvidence: archived.sort(),
-      failedEvidence: failed.sort(),
-      evaluation,
-      documentsCache
-    };
-  }
-  return archived.sort();
-}
-function validateEvidence(evidence) {
-  return EvidenceSchema.parse(evidence);
-}
-var _internals7 = {
-  wrapFlatRetrospective,
-  loadEvidence,
-  listEvidenceTaskIds,
-  validateProjectRoot,
-  validateEvidence,
-  saveEvidence,
-  deleteEvidence,
-  pruneEvidenceDocuments,
-  realpathSync,
-  statSync: statSync2,
-  now: () => new Date
-};
-
-// src/evidence/gate-bridge.ts
-var GATE_EVIDENCE_TYPE_BY_GATE = {
-  reviewer: "review",
-  test_engineer: "test"
-};
-async function readDurableGateEvidence(directory, taskId) {
-  try {
-    return await readTaskEvidence(directory, taskId);
-  } catch {
-    return null;
-  }
-}
-function getDurableGateEvidenceStatus(evidence) {
-  if (!evidence?.gates || typeof evidence.gates !== "object") {
-    return {
-      isComplete: false,
-      missingGates: [],
-      evidenceExists: evidence != null,
-      invalid: false
-    };
-  }
-  if (!Array.isArray(evidence.required_gates)) {
-    return {
-      isComplete: false,
-      missingGates: ["required_gates"],
-      evidenceExists: true,
-      invalid: false
-    };
-  }
-  const derivedGates = deriveApplicableGateSet(evidence);
-  return {
-    isComplete: derivedGates.missingGates.length === 0,
-    missingGates: derivedGates.missingGates,
-    evidenceExists: true,
-    invalid: false
-  };
-}
-async function getDurableGateEvidenceStatusForTask(directory, taskId) {
-  if (!isValidTaskId(taskId)) {
-    return {
-      isComplete: false,
-      missingGates: [],
-      evidenceExists: false,
-      invalid: false
-    };
-  }
-  try {
-    return getDurableGateEvidenceStatusWithCurrentScope(readTaskEvidenceRaw(directory, taskId), directory, taskId);
-  } catch {
-    return {
-      isComplete: false,
-      missingGates: ["invalid_gate_evidence"],
-      evidenceExists: true,
-      invalid: true
-    };
-  }
-}
-function getDurableGateEvidenceStatusWithCurrentScope(evidence, directory, taskId) {
-  if (!evidence?.gates || typeof evidence.gates !== "object") {
-    return getDurableGateEvidenceStatus(evidence);
-  }
-  if (!Array.isArray(evidence.required_gates)) {
-    return getDurableGateEvidenceStatus(evidence);
-  }
-  if (!evidence.workflow || evidence.workflow.schema !== TASK_WORKFLOW_SCHEMA_MARKER) {
-    if (evidence.required_gates.length === 0) {
-      return {
-        isComplete: false,
-        missingGates: ["required_gates"],
-        evidenceExists: true,
-        invalid: false
-      };
-    }
-    const missingGates = evidence.required_gates.filter((gate) => evidence.gates[gate] == null);
-    return {
-      isComplete: missingGates.length === 0,
-      missingGates,
-      evidenceExists: true,
-      invalid: false
-    };
-  }
-  const derivedGates = deriveApplicableGateSet(evidence, {
-    currentDeclaredFiles: readCurrentTaskDeclaredFiles(directory, taskId)
-  });
-  return {
-    isComplete: derivedGates.missingGates.length === 0,
-    missingGates: derivedGates.missingGates,
-    evidenceExists: true,
-    invalid: false
-  };
-}
-function gateEvidenceToEntry(taskId, gate, type, evidence) {
-  const gateRecord = evidence.gates[gate];
-  if (!gateRecord) {
-    return null;
-  }
-  const base = {
-    task_id: taskId,
-    timestamp: gateRecord.timestamp,
-    agent: gateRecord.agent || gate,
-    verdict: "pass",
-    summary: `Gate evidence recorded by ${gate}`,
-    metadata: { source: "durable_gate_evidence", gate }
-  };
-  if (type === "review") {
-    return {
-      ...base,
-      type,
-      risk: "low",
-      issues: []
-    };
-  }
-  if (type === "approval") {
-    return {
-      ...base,
-      type
-    };
-  }
-  return {
-    ...base,
-    type,
-    tests_passed: 0,
-    tests_failed: 0,
-    failures: []
-  };
-}
-function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
-  if (!evidence?.gates) {
-    return entries;
-  }
-  const merged = [...entries];
-  for (const gate of Object.keys(evidence.gates).sort()) {
-    const type = GATE_EVIDENCE_TYPE_BY_GATE[gate] ?? "approval";
-    if ((type === "review" || type === "test") && merged.some((entry2) => entry2.type === type)) {
-      continue;
-    }
-    const entry = gateEvidenceToEntry(taskId, gate, type, evidence);
-    if (entry) {
-      merged.push(entry);
-    }
-  }
-  return merged;
-}
-
-export { buildTaskCompletionDescriptor, ensureTaskCheckpointReceipt, updateTaskCheckpointReceipt, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, readLaneEnvFileFromDiskSync, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, detectDefaultRemoteBranch, resetToRemoteBranch, resetToMainAfterMerge, sanitizeContextText, getRunMemorySummary, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, PlanRecoverySupersededError, loadPlanJsonOnly, loadPlan, withPlanLifecycleLock, savePlan, closePlanTerminalState, updateTaskStatus, derivePlanMarkdown, getCurrentTaskId, isValidEvidenceType, isSecretscanEvidence, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, _internals7 as _internals, readDurableGateEvidence, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };
+export { buildTaskCompletionDescriptor, ensureTaskCheckpointReceipt, updateTaskCheckpointReceipt, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, readLaneEnvFileFromDiskSync, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, detectDefaultRemoteBranch, resetToRemoteBranch, resetToMainAfterMerge, sanitizeContextText, getRunMemorySummary, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, PlanRecoverySupersededError, loadPlanJsonOnly, loadPlan, withPlanLifecycleLock, savePlan, closePlanTerminalState, updateTaskStatus, derivePlanMarkdown, getCurrentTaskId };