opencode-swarm 7.115.0 → 7.116.0

package/dist/cli/{index-yrrqs4b0.js → index-cnrhj56z.js}

@@ -27,17 +27,20 @@ import {
   readTaskEvidence,
   readTaskEvidenceRaw,
   sanitizeTaskId
-} from "./index-4h2ea8h5.js";
+} from "./index-81vzywh3.js";
+import {
+  atomicWriteFile
+} from "./index-bbsaxnj5.js";
 import {
   ZodError,
   exports_external
 } from "./index-293f68mj.js";
 import {
   withEvidenceLock
-} from "./index-4sckv7y6.js";
+} from "./index-42cx6g2h.js";
 import {
   emit
-} from "./index-pa6t33pt.js";
+} from "./index-q2rrv0cy.js";
 import {
   bunHash,
   bunWrite,
@@ -3868,13 +3871,13 @@ function migrateLegacyPlan(planContent, swarmId) {
 import {
   mkdirSync as mkdirSync6,
   readdirSync as readdirSync3,
-  realpathSync,
+  realpathSync as realpathSync2,
   rmSync,
   statSync as statSync2
 } from "fs";
-import * as fs6 from "fs/promises";
+import * as fs7 from "fs/promises";
 import * as os4 from "os";
-import * as path10 from "path";
+import * as path13 from "path";
 
 // src/config/evidence-schema.ts
 var EVIDENCE_MAX_JSON_BYTES = 500 * 1024;
@@ -4158,6 +4161,1081 @@ var EvidenceBundleSchema = exports_external.object({
   updated_at: exports_external.string().datetime()
 });
 
+// src/evaluation/retention.ts
+import * as fs6 from "fs/promises";
+import * as path12 from "path";
+
+// src/evaluation/contracts.ts
+var IdentifierSchema = exports_external.string().min(1).max(160).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var Sha256Schema = exports_external.string().regex(/^[a-f0-9]{64}$/);
+var IsoDateSchema = exports_external.iso.datetime({ offset: true });
+var RelativePathSchema = exports_external.string().min(1).max(1024).refine((value) => !value.includes("\x00"), "path contains a NUL byte").refine((value) => !/^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(value), {
+  message: "path must be project-relative"
+}).refine((value) => !value.replace(/\\/g, "/").split("/").some((segment) => segment === ".."), "path must not traverse outside its root");
+var EvaluationSplitSchema = exports_external.enum(["train", "validation", "test"]);
+var CostRecordSchema = exports_external.object({
+  source: exports_external.enum(["reported", "estimated", "unavailable"]),
+  usd: exports_external.number().finite().nonnegative().optional()
+}).strict().superRefine((value, ctx) => {
+  if (value.source === "unavailable" && value.usd !== undefined) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["usd"],
+      message: "unavailable costs cannot declare a USD value"
+    });
+  }
+  if (value.source !== "unavailable" && value.usd === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["usd"],
+      message: "reported and estimated costs require a USD value"
+    });
+  }
+});
+var HumanReviewReceiptSchema = exports_external.object({
+  reviewer: exports_external.string().min(1).max(200),
+  reviewedAt: IsoDateSchema,
+  instruction: exports_external.literal(true),
+  fixture: exports_external.literal(true),
+  scorer: exports_external.literal(true),
+  secretsPrivacy: exports_external.literal(true),
+  license: exports_external.literal(true),
+  split: exports_external.literal(true)
+}).strict();
+var EvaluationTaskV1Schema = exports_external.object({
+  v: exports_external.literal(1),
+  id: IdentifierSchema,
+  derivedFromTaskId: IdentifierSchema.optional(),
+  source: exports_external.enum(["curated", "trace-proposal"]),
+  split: EvaluationSplitSchema,
+  category: IdentifierSchema,
+  protected: exports_external.boolean().default(false),
+  instructionPath: RelativePathSchema,
+  environment: exports_external.discriminatedUnion("kind", [
+    exports_external.object({ kind: exports_external.literal("fixture"), path: RelativePathSchema }).strict(),
+    exports_external.object({ kind: exports_external.literal("container"), path: RelativePathSchema }).strict()
+  ]),
+  scorer: exports_external.object({
+    kind: exports_external.enum(["builtin", "project"]),
+    argv: exports_external.array(exports_external.string().min(1).max(4096)).min(1).max(64),
+    timeoutMs: exports_external.number().int().min(100).max(600000),
+    scoreRange: exports_external.tuple([exports_external.number().finite(), exports_external.number().finite()]).refine(([minimum, maximum]) => maximum > minimum, {
+      message: "score range maximum must be greater than minimum"
+    })
+  }).strict(),
+  provenance: exports_external.object({
+    origin: exports_external.string().min(1).max(2048),
+    license: exports_external.string().min(1).max(200),
+    collectedAt: IsoDateSchema.optional(),
+    review: HumanReviewReceiptSchema.optional()
+  }).strict(),
+  contentHash: Sha256Schema
+}).strict().superRefine((task, ctx) => {
+  if (task.derivedFromTaskId === task.id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["derivedFromTaskId"],
+      message: "a derived task must reference a different parent task"
+    });
+  }
+  if (task.source === "trace-proposal" && !task.provenance.review) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["provenance", "review"],
+      message: "trace-derived tasks require an explicit human review receipt"
+    });
+  }
+  if (task.scorer.kind === "project" && !RelativePathSchema.safeParse(task.scorer.argv[0]).success) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["scorer", "argv", 0],
+      message: "project scorer executable must be project-relative"
+    });
+  }
+});
+var EvaluationCandidateV1Schema = exports_external.object({
+  v: exports_external.literal(1),
+  id: IdentifierSchema,
+  kind: exports_external.enum(["baseline", "skill", "harness"]),
+  payloadPath: RelativePathSchema,
+  model: exports_external.string().min(1).max(300),
+  agent: exports_external.string().min(1).max(160).optional(),
+  contentHash: Sha256Schema
+}).strict();
+var EvaluationOutcomeSchema = exports_external.enum([
+  "scored",
+  "infrastructure_failure",
+  "timeout",
+  "cancelled",
+  "malformed",
+  "unsupported",
+  "integrity_failure"
+]);
+var EvaluationResultV1Schema = exports_external.object({
+  v: exports_external.literal(1),
+  taskId: IdentifierSchema,
+  category: IdentifierSchema,
+  protected: exports_external.boolean().default(false),
+  repetition: exports_external.number().int().nonnegative(),
+  candidateId: IdentifierSchema,
+  seed: exports_external.string().min(1).max(500),
+  outcome: EvaluationOutcomeSchema,
+  score: exports_external.number().finite().optional(),
+  scoreRange: exports_external.tuple([exports_external.number().finite(), exports_external.number().finite()]),
+  cost: CostRecordSchema,
+  durationMs: exports_external.number().int().nonnegative(),
+  retries: exports_external.number().int().nonnegative().default(0),
+  failureCode: exports_external.string().min(1).max(160).optional(),
+  metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+}).strict().superRefine((result, ctx) => {
+  const [minimum, maximum] = result.scoreRange;
+  if (maximum <= minimum) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["scoreRange"],
+      message: "score range maximum must be greater than minimum"
+    });
+  }
+  if (result.outcome === "scored") {
+    if (result.score === undefined || result.score < minimum || result.score > maximum) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["score"],
+        message: "scored outcomes require an in-range score"
+      });
+    }
+  } else if (result.score !== undefined) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["score"],
+      message: "non-score outcomes must not be imputed with a score"
+    });
+  }
+});
+var EvaluationBudgetsV1Schema = exports_external.object({
+  maxTasks: exports_external.number().int().positive(),
+  maxRepetitions: exports_external.number().int().positive(),
+  maxConcurrency: exports_external.number().int().positive(),
+  maxTaskTimeMs: exports_external.number().int().positive(),
+  maxRetries: exports_external.number().int().nonnegative(),
+  maxOutputBytes: exports_external.number().int().positive(),
+  maxSpendUsd: exports_external.number().finite().nonnegative().optional()
+}).strict();
+var EnvironmentFingerprintV1Schema = exports_external.object({
+  platform: exports_external.string().min(1),
+  arch: exports_external.string().min(1),
+  runtime: exports_external.string().min(1),
+  baseSha: exports_external.string().regex(/^[a-f0-9]{40,64}$/),
+  activeTreeHash: Sha256Schema,
+  taskSetHash: Sha256Schema
+}).strict();
+var EvaluationRunV1Schema = exports_external.object({
+  v: exports_external.literal(1),
+  runId: IdentifierSchema,
+  createdAt: IsoDateSchema,
+  status: exports_external.enum(["complete", "inconclusive", "cancelled"]),
+  baseline: EvaluationCandidateV1Schema,
+  candidate: EvaluationCandidateV1Schema,
+  taskSet: exports_external.object({
+    id: IdentifierSchema,
+    contentHash: Sha256Schema,
+    taskIds: exports_external.array(IdentifierSchema).min(1)
+  }).strict(),
+  split: EvaluationSplitSchema,
+  seed: exports_external.string().min(1).max(500),
+  models: exports_external.array(exports_external.string().min(1).max(300)).min(1),
+  environment: EnvironmentFingerprintV1Schema,
+  budgets: EvaluationBudgetsV1Schema,
+  results: exports_external.array(EvaluationResultV1Schema),
+  cost: CostRecordSchema,
+  integrityHash: Sha256Schema
+}).strict().superRefine((run, ctx) => {
+  if (run.environment.taskSetHash !== run.taskSet.contentHash) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["environment", "taskSetHash"],
+      message: "environment and task-set hashes must agree"
+    });
+  }
+  const allowed = new Set([run.baseline.id, run.candidate.id]);
+  if (allowed.size !== 2) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["candidate", "id"],
+      message: "baseline and candidate ids must differ"
+    });
+  }
+  if (run.results.some((result) => !allowed.has(result.candidateId))) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["results"],
+      message: "results may only reference the declared baseline and candidate"
+    });
+  }
+  const taskIds = new Set(run.taskSet.taskIds);
+  if (run.results.some((result) => !taskIds.has(result.taskId))) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["results"],
+      message: "results may only reference tasks in the frozen task set"
+    });
+  }
+  const resultKeys = run.results.map((result) => `${result.candidateId}\x00${result.taskId}\x00${result.repetition}`);
+  if (new Set(resultKeys).size !== resultKeys.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["results"],
+      message: "run contains duplicate candidate/task/repetition results"
+    });
+  }
+  if (run.results.some((result) => result.repetition >= run.budgets.maxRepetitions)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["results"],
+      message: "result repetition exceeds the declared run budget"
+    });
+  }
+});
+var PromotionPolicyV1Schema = exports_external.object({
+  v: exports_external.literal(1),
+  minValidPairs: exports_external.number().int().positive().default(6),
+  minCoverage: exports_external.number().min(0).max(1).default(0.8),
+  deadband: exports_external.number().min(0).max(1).default(0),
+  confidence: exports_external.literal(0.95).default(0.95),
+  bootstrapResamples: exports_external.literal(1e4).default(1e4),
+  requireAvailableCosts: exports_external.boolean().default(true),
+  protectedCategoryTolerances: exports_external.record(exports_external.string(), exports_external.number().min(0).max(1)).default({})
+}).strict();
+var PromotionComparisonSchema = exports_external.object({
+  baselineRunId: IdentifierSchema,
+  baselineCandidateId: IdentifierSchema,
+  baselineMean: exports_external.number().min(0).max(1),
+  candidateMean: exports_external.number().min(0).max(1),
+  pairedDelta: exports_external.number().min(-1).max(1),
+  confidenceInterval: exports_external.tuple([
+    exports_external.number().min(-1).max(1),
+    exports_external.number().min(-1).max(1)
+  ]),
+  validPairs: exports_external.number().int().nonnegative(),
+  missingPairs: exports_external.number().int().nonnegative(),
+  coverage: exports_external.number().min(0).max(1)
+}).strict();
+var PromotionDecisionV1Schema = exports_external.object({
+  v: exports_external.literal(1),
+  decisionId: IdentifierSchema,
+  runId: IdentifierSchema,
+  decidedAt: IsoDateSchema,
+  status: exports_external.enum(["accept", "reject", "inconclusive"]),
+  reasons: exports_external.array(exports_external.string().min(1).max(300)),
+  baseline: PromotionComparisonSchema,
+  historicalBest: PromotionComparisonSchema,
+  deadband: exports_external.number().min(0).max(1),
+  bootstrap: exports_external.object({
+    resamples: exports_external.literal(1e4),
+    confidence: exports_external.literal(0.95),
+    seedHash: Sha256Schema
+  }).strict(),
+  categories: exports_external.array(exports_external.object({
+    category: IdentifierSchema,
+    protected: exports_external.boolean(),
+    tolerance: exports_external.number().min(0).max(1),
+    baselineMean: exports_external.number().min(0).max(1),
+    candidateMean: exports_external.number().min(0).max(1),
+    pairedDelta: exports_external.number().min(-1).max(1),
+    regression: exports_external.boolean()
+  }).strict()),
+  lineage: exports_external.object({
+    baselineRunId: IdentifierSchema,
+    historicalBestRunId: IdentifierSchema,
+    taskSetHash: Sha256Schema,
+    baselineHash: Sha256Schema,
+    candidateHash: Sha256Schema,
+    historicalBestHash: Sha256Schema
+  }).strict(),
+  policyHash: Sha256Schema,
+  unavailableQualityMetrics: exports_external.array(exports_external.enum(["complexity_delta", "public_api_delta"])).default(["complexity_delta", "public_api_delta"])
+}).strict();
+var GateNameSchema = exports_external.enum([
+  "reviewer",
+  "test-engineer",
+  "sast",
+  "mutation",
+  "quality"
+]);
+var GateAuditManifestV1Schema = exports_external.object({
+  v: exports_external.literal(1),
+  id: IdentifierSchema,
+  createdAt: IsoDateSchema,
+  taskIds: exports_external.array(IdentifierSchema).min(1),
+  gates: exports_external.array(GateNameSchema).min(1),
+  models: exports_external.array(exports_external.string().min(1).max(300)).min(1),
+  preferredSwarm: IdentifierSchema.optional(),
+  repetitions: exports_external.number().int().positive().max(100),
+  seed: exports_external.string().min(1).max(500),
+  maxConcurrency: exports_external.number().int().positive().max(64),
+  maxRetries: exports_external.number().int().nonnegative().max(20),
+  maxTimeMs: exports_external.number().int().positive(),
+  maxCostUsd: exports_external.number().finite().nonnegative().optional(),
+  contentHash: Sha256Schema
+}).strict();
+var GateAuditCellV1Schema = exports_external.object({
+  v: exports_external.literal(1),
+  taskId: IdentifierSchema,
+  candidateId: IdentifierSchema.optional(),
+  defectType: IdentifierSchema,
+  gate: GateNameSchema,
+  model: exports_external.string().min(1).max(300),
+  repetition: exports_external.number().int().nonnegative(),
+  outcome: exports_external.enum([
+    "caught",
+    "missed",
+    "false_rejection",
+    "unsupported",
+    "infrastructure_failure"
+  ]),
+  retries: exports_external.number().int().nonnegative(),
+  cost: CostRecordSchema,
+  durationMs: exports_external.number().int().nonnegative(),
+  failureClassification: exports_external.enum([
+    "clean",
+    "pre_existing_failure",
+    "new_regression",
+    "flaky_failure",
+    "infrastructure_failure",
+    "unknown_failure"
+  ]).optional(),
+  failureCode: exports_external.string().min(1).max(160).optional()
+}).strict();
+var GateAuditResultV1Schema = exports_external.object({
+  v: exports_external.literal(1),
+  runId: IdentifierSchema,
+  manifestHash: Sha256Schema,
+  createdAt: IsoDateSchema,
+  status: exports_external.enum(["complete", "inconclusive", "cancelled"]),
+  cells: exports_external.array(GateAuditCellV1Schema),
+  cost: CostRecordSchema,
+  qualityMetricAvailability: exports_external.object({
+    complexity_delta: exports_external.literal("unavailable"),
+    public_api_delta: exports_external.literal("unavailable")
+  }).strict()
+}).strict();
+var TestConsumptionClaimV1Schema = exports_external.object({
+  v: exports_external.literal(1),
+  runId: IdentifierSchema,
+  taskSetHash: Sha256Schema,
+  baselineHash: Sha256Schema,
+  candidateHash: Sha256Schema,
+  claimedAt: IsoDateSchema
+}).strict();
+var TaskSetSnapshotV1Schema = exports_external.object({
+  v: exports_external.literal(1),
+  id: IdentifierSchema,
+  split: EvaluationSplitSchema,
+  tasks: exports_external.array(EvaluationTaskV1Schema).min(1),
+  contentHash: Sha256Schema,
+  createdAt: IsoDateSchema
+}).strict();
+
+// src/evaluation/store.ts
+import { mkdir, readdir, readFile as readFile2 } from "fs/promises";
+import * as path11 from "path";
+
+// src/evaluation/hashing.ts
+import { createHash as createHash3 } from "crypto";
+import { lstatSync, realpathSync } from "fs";
+import { lstat, opendir, readFile, realpath } from "fs/promises";
+import * as path10 from "path";
+function canonicalize(value, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new TypeError("canonical JSON rejects non-finite numbers");
+    return Object.is(value, -0) ? 0 : value;
+  }
+  if (value === undefined)
+    return;
+  if (typeof value !== "object") {
+    throw new TypeError(`canonical JSON cannot encode ${typeof value}`);
+  }
+  if (ancestors.has(value))
+    throw new TypeError("canonical JSON rejects cyclic values");
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((entry) => {
+        const encoded = canonicalize(entry, ancestors);
+        return encoded === undefined ? null : encoded;
+      });
+    }
+    const record = value;
+    const result = {};
+    for (const key of Object.keys(record).sort()) {
+      const encoded = canonicalize(record[key], ancestors);
+      if (encoded !== undefined)
+        result[key] = encoded;
+    }
+    return result;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value, new Set));
+}
+function sha256(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+function canonicalHash(value) {
+  return sha256(canonicalJson(value));
+}
+function contentHashWithout(value, keys) {
+  const copy = { ...value };
+  for (const key of keys)
+    delete copy[key];
+  return canonicalHash(copy);
+}
+function createHashBudget(limits) {
+  return { entries: 0, bytes: 0, limits };
+}
+function chargeHashEntry(budget) {
+  budget.entries++;
+  if (budget.entries > budget.limits.maxFiles) {
+    throw new Error("evaluation input exceeds the canonical hashing budget");
+  }
+}
+async function closeDirectory(directory) {
+  try {
+    await directory.close();
+  } catch (error2) {
+    if (typeof error2 !== "object" || error2 === null || !("code" in error2) || error2.code !== "ERR_DIR_CLOSED") {
+      throw error2;
+    }
+  }
+}
+function resolveTaskInputHashLimits(limits) {
+  const bounded = {
+    maxFiles: limits.maxFiles ?? 5000,
+    maxBytes: limits.maxBytes ?? 50 * 1024 * 1024
+  };
+  if (!Number.isSafeInteger(bounded.maxFiles) || bounded.maxFiles <= 0 || !Number.isSafeInteger(bounded.maxBytes) || bounded.maxBytes <= 0) {
+    throw new Error("task input hash limits must be positive safe integers");
+  }
+  return bounded;
+}
+async function hashTree(projectRoot, relativePath, budget) {
+  const target = await resolveContainedExistingPathAsync(projectRoot, relativePath);
+  const canonicalRoot = await _internals9.realpath(projectRoot);
+  const entries = [];
+  const visit = async (absolutePath, entryAlreadyCharged = false) => {
+    const stat = await _internals9.lstat(absolutePath);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`evaluation input contains a symlink or reparse point: ${relativePath}`);
+    }
+    if (!entryAlreadyCharged)
+      chargeHashEntry(budget);
+    const relative3 = path10.relative(canonicalRoot, absolutePath).replace(/\\/g, "/");
+    if (stat.isDirectory()) {
+      entries.push({ path: relative3, type: "directory" });
+      const children = [];
+      const directory = await _internals9.opendir(absolutePath);
+      try {
+        while (true) {
+          const child = await directory.read();
+          if (!child)
+            break;
+          chargeHashEntry(budget);
+          children.push(child.name);
+        }
+      } finally {
+        await closeDirectory(directory);
+      }
+      for (const child of children.sort()) {
+        await visit(path10.join(absolutePath, child), true);
+      }
+      return;
+    }
+    if (!stat.isFile()) {
+      throw new Error(`evaluation input must contain only regular files: ${relative3}`);
+    }
+    budget.bytes += stat.size;
+    if (budget.bytes > budget.limits.maxBytes) {
+      throw new Error("evaluation input exceeds the canonical hashing budget");
+    }
+    const content = await _internals9.readFile(absolutePath);
+    entries.push({
+      path: relative3,
+      type: "file",
+      bytes: content.byteLength,
+      sha256: sha256(content)
+    });
+  };
+  await visit(target);
+  return entries;
+}
+async function computeTaskInputContentHash(projectRoot, task, limits = {}) {
+  const bounded = resolveTaskInputHashLimits(limits);
+  const budget = createHashBudget(bounded);
+  const inputTrees = [
+    ...await hashTree(projectRoot, task.instructionPath, budget),
+    ...await hashTree(projectRoot, task.environment.path, budget)
+  ];
+  if (task.scorer.kind === "project" && task.scorer.argv[0]) {
+    inputTrees.push(...await hashTree(projectRoot, task.scorer.argv[0], budget));
+  }
+  return canonicalHash({
+    task: JSON.parse(canonicalJson({ ...task, contentHash: undefined })),
+    inputs: inputTrees.sort((left, right) => `${left.path}\x00${left.type}`.localeCompare(`${right.path}\x00${right.type}`))
+  });
+}
+async function computeTaskLineageInputHash(projectRoot, task, limits = {}) {
+  const bounded = resolveTaskInputHashLimits(limits);
+  const budget = createHashBudget(bounded);
+  const normalizedTree = async (relativePath) => {
+    const canonicalRoot = await _internals9.realpath(projectRoot);
+    const target = await resolveContainedExistingPathAsync(projectRoot, relativePath);
+    const targetRelative = path10.relative(canonicalRoot, target).replace(/\\/g, "/");
+    return (await hashTree(projectRoot, relativePath, budget)).map((entry) => ({
+      ...entry,
+      path: path10.posix.relative(targetRelative, entry.path) || "."
+    }));
+  };
+  const scorerArgv = [...task.scorer.argv];
+  const projectScorer = task.scorer.kind === "project" && scorerArgv[0] ? await normalizedTree(scorerArgv[0]) : undefined;
+  if (projectScorer)
+    scorerArgv[0] = "<project-scorer>";
+  return canonicalHash({
+    instruction: await normalizedTree(task.instructionPath),
+    environment: {
+      kind: task.environment.kind,
+      tree: await normalizedTree(task.environment.path)
+    },
+    scorer: {
+      kind: task.scorer.kind,
+      argv: scorerArgv,
+      timeoutMs: task.scorer.timeoutMs,
+      scoreRange: task.scorer.scoreRange,
+      projectScorer
+    }
+  });
+}
+function computeTaskSetContentHash(snapshot) {
+  return contentHashWithout(snapshot, ["contentHash", "createdAt"]);
+}
+function computeManifestContentHash(manifest) {
+  return contentHashWithout(manifest, ["contentHash"]);
+}
+function isWithin(root, candidate) {
+  const relative3 = path10.relative(root, candidate);
+  return relative3 === "" || !relative3.startsWith("..") && !path10.isAbsolute(relative3);
+}
+function resolveContainedExistingPath(root, relativePath) {
+  if (path10.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);
+  if (segments.length === 0 || segments.some((segment) => segment === "..")) {
+    throw new Error("evaluation path traversal is not allowed");
+  }
+  const canonicalRoot = realpathSync(root);
+  let cursor = canonicalRoot;
+  for (const segment of segments) {
+    if (segment === ".")
+      continue;
+    cursor = path10.join(cursor, segment);
+    const stat = lstatSync(cursor);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`evaluation path contains a symlink or reparse point: ${relativePath}`);
+    }
+  }
+  const canonicalCandidate = realpathSync(cursor);
+  if (!isWithin(canonicalRoot, canonicalCandidate)) {
+    throw new Error("evaluation path escapes its admitted root");
+  }
+  return canonicalCandidate;
+}
+async function resolveContainedExistingPathAsync(root, relativePath) {
+  if (path10.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);
+  if (segments.length === 0 || segments.some((segment) => segment === "..")) {
+    throw new Error("evaluation path traversal is not allowed");
+  }
+  const canonicalRoot = await _internals9.realpath(root);
+  let cursor = canonicalRoot;
+  for (const segment of segments) {
+    if (segment === ".")
+      continue;
+    cursor = path10.join(cursor, segment);
+    const stat = await _internals9.lstat(cursor);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`evaluation path contains a symlink or reparse point: ${relativePath}`);
+    }
+  }
+  const canonicalCandidate = await _internals9.realpath(cursor);
+  if (!isWithin(canonicalRoot, canonicalCandidate)) {
+    throw new Error("evaluation path escapes its admitted root");
+  }
+  return canonicalCandidate;
+}
+var _internals9 = {
+  lstat,
+  opendir,
+  readFile,
+  realpath
+};
+
+// 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");
+
+class EvaluationConflictError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EvaluationConflictError";
+  }
+}
+function swarmPath(directory, ...segments) {
+  return path11.join(directory, ".swarm", ...segments);
+}
+function serialized(value) {
+  return `${canonicalJson(value)}
+`;
+}
+function parseTaskSplitRegistry(content) {
+  if (content === undefined)
+    return { v: 1, entries: [] };
+  let value;
+  try {
+    value = JSON.parse(content);
+  } catch (error2) {
+    throw new EvaluationConflictError(`task split registry is corrupt: ${String(error2)}`);
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new EvaluationConflictError("task split registry is corrupt");
+  }
+  const record = value;
+  if (record.v !== 1 || !Array.isArray(record.entries)) {
+    throw new EvaluationConflictError("task split registry is corrupt");
+  }
+  const entries = record.entries.map((candidate) => {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+      throw new EvaluationConflictError("task split registry is corrupt");
+    }
+    const entry = candidate;
+    if (typeof entry.lineageHash !== "string" || !["train", "validation", "test"].includes(String(entry.split)) || !Array.isArray(entry.taskIds) || !entry.taskIds.every((id) => typeof id === "string") || !Array.isArray(entry.inputHashes) || !entry.inputHashes.every((hash) => typeof hash === "string")) {
+      throw new EvaluationConflictError("task split registry is corrupt");
+    }
+    return {
+      lineageHash: entry.lineageHash,
+      split: entry.split,
+      taskIds: [...new Set(entry.taskIds)].sort(),
+      inputHashes: [...new Set(entry.inputHashes)].sort()
+    };
+  });
+  return { v: 1, entries };
+}
+async function readOptional(filePath) {
+  try {
+    return await readFile2(filePath, "utf8");
+  } catch (error2) {
+    if (error2.code === "ENOENT")
+      return;
+    throw error2;
+  }
+}
+async function writeImmutable(options) {
+  await mkdir(path11.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);
+    if (existing !== undefined) {
+      let parsed;
+      try {
+        parsed = options.parse(JSON.parse(existing));
+      } catch (error2) {
+        throw new EvaluationConflictError(`existing evaluation artifact is corrupt: ${options.filePath}: ${String(error2)}`);
+      }
+      if (serialized(parsed) === desired || options.isEquivalent?.(parsed, options.value)) {
+        return parsed;
+      }
+      throw new EvaluationConflictError(`immutable evaluation artifact conflicts with existing content: ${options.filePath}`);
+    }
+    await atomicWriteFile(options.filePath, desired);
+    return options.value;
+  });
+}
+function validateTaskInputs(directory, task) {
+  resolveContainedExistingPath(directory, task.instructionPath);
+  const environmentRoot = resolveContainedExistingPath(directory, task.environment.path);
+  if (task.scorer.kind === "project") {
+    const executable = task.scorer.argv[0];
+    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)) {
+      throw new Error("project scorer executable must be inside the admitted task environment");
+    }
+  }
+}
+async function admitEvaluationTask(directory, input, inputRoot = directory) {
+  const task = EvaluationTaskV1Schema.parse(input);
+  if (await computeTaskInputContentHash(inputRoot, task) !== task.contentHash) {
+    throw new Error(`task ${task.id} content hash does not match its canonical inputs`);
+  }
+  validateTaskInputs(inputRoot, task);
+  const lineageInputHash = await computeTaskLineageInputHash(inputRoot, task);
+  const relative4 = path11.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 });
+  return withEvidenceLock(directory, admissionLock, AGENT, task.id, async () => {
+    const registryPath = swarmPath(directory, TASK_SPLIT_REGISTRY_RELATIVE);
+    const registry = parseTaskSplitRegistry(await readOptional(registryPath));
+    const existingTaskEntry = registry.entries.find((entry) => entry.taskIds.includes(task.id));
+    if (existingTaskEntry && existingTaskEntry.split !== task.split) {
+      throw new EvaluationConflictError(`task ${task.id} is already admitted to a different split`);
+    }
+    const parentEntry = task.derivedFromTaskId ? registry.entries.find((entry) => entry.taskIds.includes(task.derivedFromTaskId)) : undefined;
+    if (task.derivedFromTaskId && !parentEntry) {
+      throw new EvaluationConflictError(`derived task ${task.id} references an unadmitted parent ${task.derivedFromTaskId}`);
+    }
+    const lineageEntry = parentEntry ?? registry.entries.find((entry) => entry.lineageHash === lineageInputHash || entry.inputHashes.includes(lineageInputHash));
+    if (lineageEntry && lineageEntry.split !== task.split) {
+      throw new EvaluationConflictError(`task ${task.id} lineage is already admitted to ${lineageEntry.split}; derived and aliased tasks must inherit that split`);
+    }
+    for (const split of ["train", "validation", "test"]) {
+      if (split === task.split)
+        continue;
+      if (await readOptional(swarmPath(directory, "evolution", "tasks", split, `${task.id}.json`))) {
+        throw new EvaluationConflictError(`task ${task.id} is already admitted to a different split`);
+      }
+    }
+    const desired = serialized(task);
+    const existing = await readOptional(filePath);
+    if (existing !== undefined) {
+      const parsed = EvaluationTaskV1Schema.parse(JSON.parse(existing));
+      if (serialized(parsed) === desired) {
+        if (lineageEntry) {
+          lineageEntry.taskIds = [
+            ...new Set([...lineageEntry.taskIds, task.id])
+          ].sort();
+          lineageEntry.inputHashes = [
+            ...new Set([...lineageEntry.inputHashes, lineageInputHash])
+          ].sort();
+        } else {
+          registry.entries.push({
+            lineageHash: lineageInputHash,
+            split: task.split,
+            taskIds: [task.id],
+            inputHashes: [lineageInputHash]
+          });
+        }
+        registry.entries.sort((left, right) => left.lineageHash.localeCompare(right.lineageHash));
+        await atomicWriteFile(registryPath, serialized(registry));
+        return parsed;
+      }
+      if (task.split !== "train") {
+        throw new EvaluationConflictError(`${task.split} task ${task.id} is immutable after admission`);
+      }
+    }
+    await atomicWriteFile(filePath, desired);
+    if (lineageEntry) {
+      lineageEntry.taskIds = [
+        ...new Set([...lineageEntry.taskIds, task.id])
+      ].sort();
+      lineageEntry.inputHashes = [
+        ...new Set([...lineageEntry.inputHashes, lineageInputHash])
+      ].sort();
+    } else {
+      registry.entries.push({
+        lineageHash: lineageInputHash,
+        split: task.split,
+        taskIds: [task.id],
+        inputHashes: [lineageInputHash]
+      });
+    }
+    registry.entries.sort((left, right) => left.lineageHash.localeCompare(right.lineageHash));
+    await atomicWriteFile(registryPath, serialized(registry));
+    return task;
+  });
+}
+async function saveTaskSetSnapshot(directory, input, inputRoot = directory) {
+  const snapshot = TaskSetSnapshotV1Schema.parse(input);
+  const ids = snapshot.tasks.map((task) => task.id);
+  if (new Set(ids).size !== ids.length)
+    throw new Error("task-set contains duplicate task ids");
+  if (snapshot.tasks.some((task) => task.split !== snapshot.split)) {
+    throw new Error("task-set tasks must all belong to the declared split");
+  }
+  for (const task of snapshot.tasks) {
+    if (await computeTaskInputContentHash(inputRoot, task) !== task.contentHash) {
+      throw new Error(`task ${task.id} content hash is invalid`);
+    }
+  }
+  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`);
+  return writeImmutable({
+    directory,
+    relativeLockPath: relative4,
+    filePath: swarmPath(directory, relative4),
+    taskId: snapshot.id,
+    value: snapshot,
+    parse: (value) => TaskSetSnapshotV1Schema.parse(value),
+    isEquivalent: (existing, desired) => existing.contentHash === desired.contentHash
+  });
+}
+async function saveGateAuditResult(directory, input) {
+  const result = GateAuditResultV1Schema.parse(input);
+  const relative4 = path11.join("evidence", "gate-audit", result.runId, "results.json");
+  return writeImmutable({
+    directory,
+    relativeLockPath: relative4,
+    filePath: swarmPath(directory, relative4),
+    taskId: result.runId,
+    value: result,
+    parse: (value) => GateAuditResultV1Schema.parse(value)
+  });
+}
+async function saveGateAuditManifest(directory, input) {
+  const manifest = GateAuditManifestV1Schema.parse(input);
+  const relative4 = path11.join("evolution", "gate-audit-manifests", `${manifest.id}.json`);
+  return writeImmutable({
+    directory,
+    relativeLockPath: relative4,
+    filePath: swarmPath(directory, relative4),
+    taskId: manifest.id,
+    value: manifest,
+    parse: (value) => GateAuditManifestV1Schema.parse(value)
+  });
+}
+async function readGateAuditManifest(directory, runId) {
+  const content = await readOptional(swarmPath(directory, "evolution", "gate-audit-manifests", `${runId}.json`));
+  return content === undefined ? undefined : GateAuditManifestV1Schema.parse(JSON.parse(content));
+}
+async function readGateAuditResult(directory, runId) {
+  const content = await readOptional(swarmPath(directory, "evidence", "gate-audit", runId, "results.json"));
+  return content === undefined ? undefined : GateAuditResultV1Schema.parse(JSON.parse(content));
+}
+async function listGateAuditResults(directory) {
+  const root = swarmPath(directory, "evidence", "gate-audit");
+  let entries = [];
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch (error2) {
+    if (error2.code === "ENOENT") {
+      return { results: [], corruptRunIds: [] };
+    }
+    throw error2;
+  }
+  const results = [];
+  const corruptRunIds = [];
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    if (!entry.isDirectory() || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,159}$/.test(entry.name)) {
+      continue;
+    }
+    try {
+      const parsed = GateAuditResultV1Schema.parse(JSON.parse(await readFile2(path11.join(root, entry.name, "results.json"), "utf8")));
+      if (parsed.runId !== entry.name)
+        throw new Error("run id/path mismatch");
+      results.push(parsed);
+    } catch {
+      corruptRunIds.push(entry.name);
+    }
+  }
+  return { results, corruptRunIds };
+}
+function parseTestLedger(content) {
+  return content.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line, index) => {
+    try {
+      return TestConsumptionClaimV1Schema.parse(JSON.parse(line));
+    } catch (error2) {
+      throw new EvaluationConflictError(`test-consumption ledger is corrupt at line ${index + 1}: ${String(error2)}`);
+    }
+  });
+}
+async function getProtectedEvaluationRunIds(directory) {
+  const protectedIds = new Set;
+  const ledger = await readOptional(swarmPath(directory, TEST_LEDGER_RELATIVE));
+  for (const claim of parseTestLedger(ledger ?? ""))
+    protectedIds.add(claim.runId);
+  const decisionsDirectory = swarmPath(directory, "evolution", "decisions");
+  let files = [];
+  try {
+    files = await readdir(decisionsDirectory);
+  } catch (error2) {
+    if (error2.code !== "ENOENT")
+      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")));
+    protectedIds.add(decision.runId);
+    protectedIds.add(decision.lineage.baselineRunId);
+    if (decision.lineage.historicalBestRunId !== "unavailable") {
+      protectedIds.add(decision.lineage.historicalBestRunId);
+    }
+  }
+  return protectedIds;
+}
+
+// src/evaluation/retention.ts
+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 = path12.join(directory, ".swarm", "evolution", "runs");
+  let entries = [];
+  try {
+    entries = await fs6.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 = path12.join(root, entry.name);
+    try {
+      const run = EvaluationRunV1Schema.parse(JSON.parse(await fs6.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 = path12.join(directory, ".swarm", "evidence", "gate-audit");
+  let entries = [];
+  try {
+    entries = await fs6.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 = path12.join(root, entry.name);
+    try {
+      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs6.readFile(path12.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 fs6.rm(candidate.target, { recursive: true, force: true });
+    return;
+  }
+  await fs6.unlink(candidate.target);
+}
+var _retentionInternals = {
+  protectedArtifacts,
+  removeCandidate
+};
+async function archiveEvaluationArtifacts(args) {
+  return withEvidenceLock(args.directory, path12.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/manager.ts
 var VALID_EVIDENCE_TYPES = [
   "review",
@@ -4194,11 +5272,11 @@ var PROJECT_INDICATORS = [
 ];
 function isWeakConfigContainerRoot(directory) {
   try {
-    const resolved = realpathSync(directory);
-    return resolved === realpathSync(os4.tmpdir()) || resolved === realpathSync(os4.homedir());
+    const resolved = realpathSync2(directory);
+    return resolved === realpathSync2(os4.tmpdir()) || resolved === realpathSync2(os4.homedir());
   } catch {
-    const resolved = path10.resolve(directory);
-    return resolved === path10.resolve(os4.tmpdir()) || resolved === path10.resolve(os4.homedir());
+    const resolved = path13.resolve(directory);
+    return resolved === path13.resolve(os4.tmpdir()) || resolved === path13.resolve(os4.homedir());
   }
 }
 function hasAccessibleProjectIndicator(directory, options = {}) {
@@ -4208,7 +5286,7 @@ function hasAccessibleProjectIndicator(directory, options = {}) {
       continue;
     }
     try {
-      const indicatorStat = statSync2(path10.join(directory, indicator));
+      const indicatorStat = statSync2(path13.join(directory, indicator));
       if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
         return true;
       }
@@ -4219,7 +5297,7 @@ function hasAccessibleProjectIndicator(directory, options = {}) {
 function validateProjectRoot(directory) {
   let resolved;
   try {
-    resolved = realpathSync(directory);
+    resolved = realpathSync2(directory);
   } catch {
     warn(`[evidence] Cannot canonicalize directory "${directory}" \u2014 failing closed`);
     throw new Error(`Cannot verify project root for "${directory}" \u2014 directory may not exist or is inaccessible`);
@@ -4230,14 +5308,14 @@ function validateProjectRoot(directory) {
     if (depth >= MAX_DEPTH)
       break;
     depth++;
-    const parent = path10.dirname(current);
+    const parent = path13.dirname(current);
     if (parent === current)
       break;
-    if (path10.dirname(parent) === parent) {
+    if (path13.dirname(parent) === parent) {
       current = parent;
       continue;
     }
-    const parentSwarm = path10.join(parent, ".swarm");
+    const parentSwarm = path13.join(parent, ".swarm");
     try {
       if (statSync2(parentSwarm).isDirectory()) {
         if (hasAccessibleProjectIndicator(parent, {
@@ -4256,14 +5334,14 @@ function validateProjectRoot(directory) {
   }
 }
 async function saveEvidence(directory, taskId, evidence) {
-  _internals9.validateProjectRoot(directory);
+  _internals10.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path10.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path13.join("evidence", sanitizedTaskId, "evidence.json");
   validateSwarmPath(directory, relativePath);
-  _internals9.validateEvidence(evidence);
+  _internals10.validateEvidence(evidence);
   return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
     const evidencePath = validateSwarmPath(directory, relativePath);
-    const evidenceDir = path10.dirname(evidencePath);
+    const evidenceDir = path13.dirname(evidencePath);
     let bundle;
     const existingContent = await readSwarmFileAsync(directory, relativePath);
     if (existingContent !== null) {
@@ -4306,10 +5384,10 @@ async function saveEvidence(directory, taskId, evidence) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
     mkdirSync6(evidenceDir, { recursive: true });
-    const tempPath = path10.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+    const tempPath = path13.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
-      await fs6.rename(tempPath, evidencePath);
+      await fs7.rename(tempPath, evidencePath);
     } catch (error2) {
       try {
         rmSync(tempPath, { force: true });
@@ -4350,7 +5428,7 @@ function wrapFlatRetrospective(flatEntry, taskId) {
 }
 async function loadEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path10.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path13.join("evidence", sanitizedTaskId, "evidence.json");
   if (relativePath.length > 4096) {
     return { status: "not_found" };
   }
@@ -4366,17 +5444,17 @@ async function loadEvidence(directory, taskId) {
     return { status: "invalid_schema", errors: ["Invalid JSON"] };
   }
   if (isFlatRetrospective(parsed)) {
-    const wrappedBundle = _internals9.wrapFlatRetrospective(parsed, sanitizedTaskId);
+    const wrappedBundle = _internals10.wrapFlatRetrospective(parsed, sanitizedTaskId);
     try {
       const validated = EvidenceBundleSchema.parse(wrappedBundle);
       try {
         await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
-          const evidenceDir = path10.dirname(evidencePath);
+          const evidenceDir = path13.dirname(evidencePath);
           const bundleJson = JSON.stringify(validated);
-          const tempPath = path10.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+          const tempPath = path13.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
           try {
             await bunWrite(tempPath, bundleJson);
-            await fs6.rename(tempPath, evidencePath);
+            await fs7.rename(tempPath, evidencePath);
           } catch (writeError) {
             try {
               rmSync(tempPath, { force: true });
@@ -4418,7 +5496,7 @@ async function listEvidenceTaskIds(directory) {
   }
   const taskIds = [];
   for (const entry of entries) {
-    const entryPath = path10.join(evidenceBasePath, entry);
+    const entryPath = path13.join(evidenceBasePath, entry);
     try {
       const stats = statSync2(entryPath);
       if (!stats.isDirectory()) {
@@ -4436,7 +5514,7 @@ async function listEvidenceTaskIds(directory) {
 }
 async function deleteEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path10.join("evidence", sanitizedTaskId);
+  const relativePath = path13.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
     statSync2(evidenceDir);
@@ -4452,32 +5530,40 @@ async function deleteEvidence(directory, taskId) {
   }
 }
 async function checkRequirementCoverage(phase, directory) {
-  const relativePath = path10.join("evidence", `req-coverage-phase-${phase}.json`);
-  const absolutePath = path10.resolve(directory, ".swarm", relativePath);
+  const relativePath = path13.join("evidence", `req-coverage-phase-${phase}.json`);
+  const absolutePath = path13.resolve(directory, ".swarm", relativePath);
   try {
-    await fs6.access(absolutePath);
+    await fs7.access(absolutePath);
     return { exists: true, path: absolutePath };
   } catch {
     return { exists: false, path: absolutePath };
   }
 }
-async function archiveEvidence(directory, maxAgeDays, maxBundles) {
-  const taskIds = await _internals9.listEvidenceTaskIds(directory);
-  const cutoffDate = new Date;
+async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
+  const taskIds = await _internals10.listEvidenceTaskIds(directory);
+  const cutoffDate = options?.now ? new Date(options.now) : _internals10.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) {
-    const result = await _internals9.loadEvidence(directory, taskId);
+    let result;
+    try {
+      result = await _internals10.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) {
-      const deleted = await deleteEvidence(directory, taskId);
-      if (deleted) {
-        archived.push(taskId);
-      }
+      selected.add(taskId);
+      selectedByAge.add(taskId);
     } else {
       remainingBundles.push({
         taskId,
@@ -4489,24 +5575,51 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles) {
     remainingBundles.sort((a, b) => a.updatedAt.localeCompare(b.updatedAt));
     const toDelete = remainingBundles.length - maxBundles;
     for (let i = 0;i < toDelete; i++) {
-      const deleted = await deleteEvidence(directory, remainingBundles[i].taskId);
-      if (deleted) {
-        archived.push(remainingBundles[i].taskId);
-      }
+      selected.add(remainingBundles[i].taskId);
+      selectedByCount.add(remainingBundles[i].taskId);
     }
   }
-  return archived;
+  if (!options?.dryRun) {
+    for (const taskId of [...selected].sort()) {
+      const deleted = await _internals10.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
+  });
+  if (options?.report) {
+    return {
+      inventoryEvidence: [...taskIds].sort(),
+      selectedEvidence: [...selected].sort(),
+      selectedEvidenceByAge: [...selectedByAge].sort(),
+      selectedEvidenceByCount: [...selectedByCount].sort(),
+      archivedEvidence: archived.sort(),
+      failedEvidence: failed.sort(),
+      evaluation
+    };
+  }
+  return archived.sort();
 }
 function validateEvidence(evidence) {
   return EvidenceSchema.parse(evidence);
 }
-var _internals9 = {
+var _internals10 = {
   wrapFlatRetrospective,
   loadEvidence,
   listEvidenceTaskIds,
   validateProjectRoot,
   validateEvidence,
-  saveEvidence
+  saveEvidence,
+  deleteEvidence,
+  now: () => new Date
 };
 
 // src/evidence/gate-bridge.ts
@@ -4619,4 +5732,4 @@ function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
   return merged;
 }
 
-export { PlanSchema, 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, RetrospectiveEvidenceSchema, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };
+export { PlanSchema, 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, RetrospectiveEvidenceSchema, 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 };