opencode-swarm 7.184.11 → 7.184.12

package/dist/cli/index-34ysgky0.js

@@ -0,0 +1,954 @@
+// @bun
+import {
+  EvaluationRunV1Schema,
+  GateAuditResultV1Schema,
+  getProtectedEvaluationRunIds
+} from "./index-jtg0zsnx.js";
+import {
+  TASK_WORKFLOW_SCHEMA_MARKER,
+  deriveApplicableGateSet,
+  isValidTaskId,
+  readCurrentTaskDeclaredFiles,
+  readTaskEvidence,
+  readTaskEvidenceRaw,
+  sanitizeTaskId
+} from "./index-fbp7dqfe.js";
+import {
+  readSwarmFileAsync,
+  validateSwarmPath
+} from "./index-dftztz4y.js";
+import {
+  bunWrite
+} from "./index-2s7dvzff.js";
+import {
+  EVIDENCE_MAX_JSON_BYTES,
+  EvidenceBundleSchema,
+  EvidenceSchema
+} from "./index-frcemc0b.js";
+import {
+  withEvidenceLock
+} from "./index-6cjpmvpa.js";
+import {
+  assertProjectRoot
+} from "./index-t7hmqgjy.js";
+import {
+  invalidateCachedArtifact
+} from "./index-bntwj2tp.js";
+import {
+  ZodError,
+  init_zod
+} from "./index-gknz3bv1.js";
+import {
+  warn
+} from "./index-zgwm4ryv.js";
+
+// src/evidence/manager.ts
+init_zod();
+import {
+  mkdirSync,
+  readdirSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync
+} from "fs";
+import * as fs3 from "fs/promises";
+import * as path2 from "path";
+
+// src/evaluation/retention.ts
+import * as fs from "fs/promises";
+import * as path 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 = path.join(directory, ".swarm", "evolution", "runs");
+  let entries = [];
+  try {
+    entries = await fs.readdir(root, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { candidates: [], corrupt: [] };
+    }
+    throw error;
+  }
+  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 = path.join(root, entry.name);
+    try {
+      const run = EvaluationRunV1Schema.parse(JSON.parse(await fs.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 = path.join(directory, ".swarm", "evidence", "gate-audit");
+  let entries = [];
+  try {
+    entries = await fs.readdir(root, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { candidates: [], corrupt: [] };
+    }
+    throw error;
+  }
+  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 = path.join(root, entry.name);
+    try {
+      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs.readFile(path.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 fs.rm(candidate.target, { recursive: true, force: true });
+    return;
+  }
+  await fs.unlink(candidate.target);
+}
+var _retentionInternals = {
+  protectedArtifacts,
+  removeCandidate
+};
+async function archiveEvaluationArtifacts(args) {
+  assertProjectRoot(args.directory);
+  return withEvidenceLock(args.directory, path.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 (error) {
+          failed.push({
+            artifact: candidate.artifact,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+    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 fs2 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 _internals = {
+  stat: (p) => fsp.stat(p),
+  createReadStream: (p, options) => fs2.createReadStream(p, options),
+  openSync: (p, flags) => fs2.openSync(p, flags),
+  writeSync: (fd, data, position) => fs2.writeSync(fd, data, position),
+  fsyncSync: (fd) => fs2.fsyncSync(fd),
+  closeSync: (fd) => fs2.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((resolve) => setTimeout(resolve, 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 _internals.stat(filePath);
+  const bytesBefore = stat2.size;
+  const stream = _internals.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 = _internals.openSync(tmpPath, "w");
+  try {
+    _internals.writeSync(fd, payload, 0);
+    _internals.fsyncSync(fd);
+    _internals.closeSync(fd);
+    await _internals.renameWithRetry(tmpPath, filePath);
+    succeeded = true;
+  } catch (err) {
+    try {
+      _internals.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 _internals.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 _internals.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: _internals2.realpathSync,
+    statSync: _internals2.statSync
+  }, "evidence");
+}
+async function saveEvidence(directory, taskId, evidence, abortSignal) {
+  abortSignal?.throwIfAborted();
+  _internals2.validateProjectRoot(directory);
+  const sanitizedTaskId = sanitizeTaskId2(taskId);
+  const relativePath = path2.join("evidence", sanitizedTaskId, "evidence.json");
+  validateSwarmPath(directory, relativePath);
+  _internals2.validateEvidence(evidence);
+  return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
+    abortSignal?.throwIfAborted();
+    const evidencePath = validateSwarmPath(directory, relativePath);
+    const evidenceDir = path2.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 (error) {
+        warn(`Existing evidence bundle invalid for task ${sanitizedTaskId}, creating new: ${error instanceof Error ? error.message : String(error)}`);
+        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)`);
+    }
+    mkdirSync(evidenceDir, { recursive: true });
+    const tempPath = path2.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+    try {
+      await bunWrite(tempPath, bundleJson);
+      abortSignal?.throwIfAborted();
+      renameSync(tempPath, evidencePath);
+    } catch (error) {
+      try {
+        rmSync(tempPath, { force: true });
+      } catch {}
+      throw error;
+    }
+    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 = path2.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 = _internals2.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 = path2.dirname(evidencePath);
+          const bundleJson = JSON.stringify(validated);
+          const tempPath = path2.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+          try {
+            await bunWrite(tempPath, bundleJson);
+            await fs3.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 (error) {
+      warn(`Wrapped flat retrospective failed validation for task ${sanitizedTaskId}: ${error instanceof Error ? error.message : String(error)}`);
+      const errors = error instanceof ZodError ? error.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [error instanceof Error ? error.message : String(error)];
+      return { status: "invalid_schema", errors };
+    }
+  }
+  try {
+    const validated = EvidenceBundleSchema.parse(parsed);
+    return { status: "found", bundle: validated };
+  } catch (error) {
+    warn(`Evidence bundle validation failed for task ${sanitizedTaskId}: ${error instanceof Error ? error.message : String(error)}`);
+    const errors = error instanceof ZodError ? error.issues.map((e) => `${e.path.join(".")}: ${e.message}`) : [error instanceof Error ? error.message : String(error)];
+    return { status: "invalid_schema", errors };
+  }
+}
+async function listEvidenceTaskIds(directory) {
+  const evidenceBasePath = validateSwarmPath(directory, "evidence");
+  try {
+    statSync(evidenceBasePath);
+  } catch {
+    return [];
+  }
+  let entries;
+  try {
+    entries = readdirSync(evidenceBasePath);
+  } catch {
+    return [];
+  }
+  const taskIds = [];
+  for (const entry of entries) {
+    const entryPath = path2.join(evidenceBasePath, entry);
+    try {
+      const stats = statSync(entryPath);
+      if (!stats.isDirectory()) {
+        continue;
+      }
+      sanitizeTaskId2(entry);
+      taskIds.push(entry);
+    } catch (error) {
+      if (error instanceof Error && !error.message.startsWith("Invalid task ID")) {
+        warn(`Error reading evidence entry '${entry}': ${error.message}`);
+      }
+    }
+  }
+  return taskIds.sort();
+}
+async function deleteEvidence(directory, taskId) {
+  const sanitizedTaskId = sanitizeTaskId2(taskId);
+  try {
+    validateProjectRoot(directory);
+  } catch {
+    return false;
+  }
+  const relativePath = path2.join("evidence", sanitizedTaskId);
+  const evidenceDir = validateSwarmPath(directory, relativePath);
+  try {
+    statSync(evidenceDir);
+  } catch {
+    return false;
+  }
+  try {
+    rmSync(evidenceDir, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    warn(`Failed to delete evidence for task ${sanitizedTaskId}: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
+}
+async function checkRequirementCoverage(phase, directory) {
+  const relativePath = path2.join("evidence", `req-coverage-phase-${phase}.json`);
+  const absolutePath = path2.resolve(directory, ".swarm", relativePath);
+  try {
+    await fs3.access(absolutePath);
+    return { exists: true, path: absolutePath };
+  } catch {
+    return { exists: false, path: absolutePath };
+  }
+}
+async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
+  const taskIds = await _internals2.listEvidenceTaskIds(directory);
+  const cutoffDate = options?.now ? new Date(options.now) : _internals2.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 _internals2.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 _internals2.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 _internals2.pruneEvidenceDocuments({
+        directory,
+        maxBytes: options?.cacheMaxBytes,
+        maxRecords: options?.cacheMaxRecords,
+        dryRun: options?.dryRun
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      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 _internals2 = {
+  wrapFlatRetrospective,
+  loadEvidence,
+  listEvidenceTaskIds,
+  validateProjectRoot,
+  validateEvidence,
+  saveEvidence,
+  deleteEvidence,
+  pruneEvidenceDocuments,
+  realpathSync,
+  statSync,
+  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 { isValidEvidenceType, isSecretscanEvidence, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, _internals2 as _internals, readDurableGateEvidence, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };