opencode-swarm 7.136.0 → 7.136.2

package/dist/cli/{index-cggqh2dz.js → index-kwwxevne.js}

@@ -1,4 +1,9 @@
 // @bun
+import {
+  EvaluationRunV1Schema,
+  GateAuditResultV1Schema,
+  getProtectedEvaluationRunIds
+} from "./index-z1tm47nj.js";
 import {
   readEffectiveSpecSync
 } from "./index-9ss2m4rs.js";
@@ -8,9 +13,6 @@ import {
   readTaskEvidenceRaw,
   sanitizeTaskId
 } from "./index-mrtms113.js";
-import {
-  atomicWriteFile
-} from "./index-ey29aap6.js";
 import {
   EVIDENCE_MAX_JSON_BYTES,
   EvidenceBundleSchema,
@@ -57,7 +59,6 @@ import {
 } from "./index-09b9zncg.js";
 import {
   ZodError,
-  exports_external,
   init_zod
 } from "./index-bpmtbmy9.js";
 import {
@@ -3382,961 +3383,17 @@ init_zod();
 import {
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync2,
-  realpathSync as realpathSync2,
+  realpathSync,
   rmSync,
   statSync as statSync2
 } from "fs";
 import * as fs6 from "fs/promises";
 import * as os4 from "os";
-import * as path12 from "path";
+import * as path9 from "path";
 
 // src/evaluation/retention.ts
 import * as fs4 from "fs/promises";
-import * as path11 from "path";
-
-// src/evaluation/contracts.ts
-init_zod();
-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 as mkdir2, readdir, readFile as readFile3 } from "fs/promises";
-import * as path10 from "path";
-
-// src/evidence/immutable-store.ts
-import { mkdir, readFile } from "fs/promises";
 import * as path8 from "path";
-async function readOptionalFile(filePath) {
-  try {
-    return await readFile(filePath, "utf8");
-  } catch (error2) {
-    if (error2.code === "ENOENT")
-      return;
-    throw error2;
-  }
-}
-async function writeImmutableArtifact(options) {
-  await mkdir(path8.dirname(options.filePath), { recursive: true });
-  return withEvidenceLock(options.directory, options.relativeLockPath, options.agent, options.taskId, async () => {
-    const desired = options.serialize(options.value);
-    const existing = await readOptionalFile(options.filePath);
-    if (existing !== undefined) {
-      let parsed;
-      try {
-        parsed = options.parse(JSON.parse(existing));
-      } catch (error2) {
-        throw options.conflictError({
-          kind: "corrupt",
-          filePath: options.filePath,
-          cause: error2
-        });
-      }
-      if (options.serialize(parsed) === desired || options.isEquivalent?.(parsed, options.value)) {
-        return parsed;
-      }
-      throw options.conflictError({
-        kind: "divergent",
-        filePath: options.filePath
-      });
-    }
-    await atomicWriteFile(options.filePath, desired);
-    return options.value;
-  });
-}
-
-// src/evaluation/hashing.ts
-import { createHash as createHash2 } from "crypto";
-import { lstatSync, realpathSync } from "fs";
-import { lstat, opendir, readFile as readFile2, realpath } from "fs/promises";
-import * as path9 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 createHash2("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 relative2 = path9.relative(canonicalRoot, absolutePath).replace(/\\/g, "/");
-    if (stat.isDirectory()) {
-      entries.push({ path: relative2, 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(path9.join(absolutePath, child), true);
-      }
-      return;
-    }
-    if (!stat.isFile()) {
-      throw new Error(`evaluation input must contain only regular files: ${relative2}`);
-    }
-    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: relative2,
-      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 = path9.relative(canonicalRoot, target).replace(/\\/g, "/");
-    return (await hashTree(projectRoot, relativePath, budget)).map((entry) => ({
-      ...entry,
-      path: path9.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 relative2 = path9.relative(root, candidate);
-  return relative2 === "" || !relative2.startsWith("..") && !path9.isAbsolute(relative2);
-}
-function resolveContainedExistingPath(root, relativePath) {
-  if (path9.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
-    throw new Error("evaluation path must be a non-NUL relative path");
-  }
-  const segments = relativePath.replace(/\\/g, "/").split("/").filter(Boolean);
-  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 = path9.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 (path9.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
-    throw new Error("evaluation path must be a non-NUL relative path");
-  }
-  const segments = relativePath.replace(/\\/g, "/").split("/").filter(Boolean);
-  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 = path9.join(cursor, segment);
-    const stat = await _internals9.lstat(cursor);
-    if (stat.isSymbolicLink()) {
-      throw new Error(`evaluation path contains a symlink or reparse point: ${relativePath}`);
-    }
-  }
-  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: readFile2,
-  realpath
-};
-
-// src/evaluation/store.ts
-var AGENT = "evaluation-store";
-var TEST_LEDGER_RELATIVE = path10.join("evolution", "test-consumption.jsonl");
-var TASK_SPLIT_REGISTRY_RELATIVE = path10.join("evolution", "tasks", "split-registry.json");
-
-class EvaluationConflictError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "EvaluationConflictError";
-  }
-}
-function swarmPath(directory, ...segments) {
-  return path10.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 };
-}
-function evaluationConflictError(conflict) {
-  return conflict.kind === "corrupt" ? new EvaluationConflictError(`existing evaluation artifact is corrupt: ${conflict.filePath}: ${String(conflict.cause)}`) : new EvaluationConflictError(`immutable evaluation artifact conflicts with existing content: ${conflict.filePath}`);
-}
-function writeImmutable(options) {
-  return writeImmutableArtifact({
-    ...options,
-    agent: AGENT,
-    serialize: serialized,
-    conflictError: evaluationConflictError
-  });
-}
-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 relative3 = path10.relative(environmentRoot, scorerPath);
-    if (!relative3 || relative3 === ".." || relative3.startsWith(`..${path10.sep}`) || path10.isAbsolute(relative3)) {
-      throw new Error("project scorer executable must be inside the admitted task environment");
-    }
-  }
-}
-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 relative3 = path10.join("evolution", "tasks", task.split, `${task.id}.json`);
-  const admissionLock = TASK_SPLIT_REGISTRY_RELATIVE;
-  const filePath = swarmPath(directory, relative3);
-  await mkdir2(path10.dirname(filePath), { recursive: true });
-  return withEvidenceLock(directory, admissionLock, AGENT, task.id, async () => {
-    const registryPath = swarmPath(directory, TASK_SPLIT_REGISTRY_RELATIVE);
-    const registry = parseTaskSplitRegistry(await readOptionalFile(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 readOptionalFile(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 readOptionalFile(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 relative3 = path10.join("evolution", "task-sets", `${snapshot.contentHash}.json`);
-  return writeImmutable({
-    directory,
-    relativeLockPath: relative3,
-    filePath: swarmPath(directory, relative3),
-    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 relative3 = path10.join("evidence", "gate-audit", result.runId, "results.json");
-  return writeImmutable({
-    directory,
-    relativeLockPath: relative3,
-    filePath: swarmPath(directory, relative3),
-    taskId: result.runId,
-    value: result,
-    parse: (value) => GateAuditResultV1Schema.parse(value)
-  });
-}
-async function saveGateAuditManifest(directory, input) {
-  const manifest = GateAuditManifestV1Schema.parse(input);
-  const relative3 = path10.join("evolution", "gate-audit-manifests", `${manifest.id}.json`);
-  return writeImmutable({
-    directory,
-    relativeLockPath: relative3,
-    filePath: swarmPath(directory, relative3),
-    taskId: manifest.id,
-    value: manifest,
-    parse: (value) => GateAuditManifestV1Schema.parse(value)
-  });
-}
-async function readGateAuditManifest(directory, runId) {
-  const content = await readOptionalFile(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 readOptionalFile(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 readFile3(path10.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 readOptionalFile(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 readFile3(path10.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}`;
 }
@@ -4344,7 +3401,7 @@ function validId(value) {
   return /^[A-Za-z0-9][A-Za-z0-9._-]{0,159}$/.test(value);
 }
 async function evaluationRunCandidates(directory) {
-  const root = path11.join(directory, ".swarm", "evolution", "runs");
+  const root = path8.join(directory, ".swarm", "evolution", "runs");
   let entries = [];
   try {
     entries = await fs4.readdir(root, { withFileTypes: true });
@@ -4363,7 +3420,7 @@ async function evaluationRunCandidates(directory) {
     if (!validId(id))
       continue;
     const artifact = { namespace: "evaluation-run", id };
-    const target = path11.join(root, entry.name);
+    const target = path8.join(root, entry.name);
     try {
       const run = EvaluationRunV1Schema.parse(JSON.parse(await fs4.readFile(target, "utf8")));
       if (run.runId !== id)
@@ -4381,7 +3438,7 @@ async function evaluationRunCandidates(directory) {
   return { candidates, corrupt };
 }
 async function gateAuditCandidates(directory) {
-  const root = path11.join(directory, ".swarm", "evidence", "gate-audit");
+  const root = path8.join(directory, ".swarm", "evidence", "gate-audit");
   let entries = [];
   try {
     entries = await fs4.readdir(root, { withFileTypes: true });
@@ -4397,9 +3454,9 @@ async function gateAuditCandidates(directory) {
     if (!entry.isDirectory() || !validId(entry.name))
       continue;
     const artifact = { namespace: "gate-audit", id: entry.name };
-    const target = path11.join(root, entry.name);
+    const target = path8.join(root, entry.name);
     try {
-      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs4.readFile(path11.join(target, "results.json"), "utf8")));
+      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs4.readFile(path8.join(target, "results.json"), "utf8")));
       if (result.runId !== entry.name)
         throw new Error("run id/path mismatch");
       candidates.push({
@@ -4440,7 +3497,7 @@ var _retentionInternals = {
   removeCandidate
 };
 async function archiveEvaluationArtifacts(args) {
-  return withEvidenceLock(args.directory, path11.join("evolution", "retention-index"), "evaluation-retention", "archive", async () => {
+  return withEvidenceLock(args.directory, path8.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);
@@ -4497,7 +3554,7 @@ 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 _internals10 = {
+var _internals9 = {
   stat: (p) => fsp.stat(p),
   createReadStream: (p, options) => fs5.createReadStream(p, options),
   openSync: (p, flags) => fs5.openSync(p, flags),
@@ -4539,9 +3596,9 @@ function emptyResult(dryRun) {
   };
 }
 async function readCacheRows(filePath) {
-  const stat2 = await _internals10.stat(filePath);
+  const stat2 = await _internals9.stat(filePath);
   const bytesBefore = stat2.size;
-  const stream = _internals10.createReadStream(filePath, {
+  const stream = _internals9.createReadStream(filePath, {
     encoding: "utf8",
     highWaterMark: 64 * 1024
   });
@@ -4617,23 +3674,23 @@ async function rewriteAtomic(filePath, survivors) {
 `)}
 ` : "";
   let succeeded = false;
-  const fd = _internals10.openSync(tmpPath, "w");
+  const fd = _internals9.openSync(tmpPath, "w");
   try {
-    _internals10.writeSync(fd, payload, 0);
-    _internals10.fsyncSync(fd);
-    _internals10.closeSync(fd);
-    await _internals10.renameWithRetry(tmpPath, filePath);
+    _internals9.writeSync(fd, payload, 0);
+    _internals9.fsyncSync(fd);
+    _internals9.closeSync(fd);
+    await _internals9.renameWithRetry(tmpPath, filePath);
     succeeded = true;
   } catch (err) {
     try {
-      _internals10.closeSync(fd);
+      _internals9.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 _internals10.unlink(tmpPath);
+        await _internals9.unlink(tmpPath);
       } catch {}
     }
   }
@@ -4645,7 +3702,7 @@ async function pruneEvidenceDocuments(args) {
   const filePath = validateSwarmPath(args.directory, EVIDENCE_CACHE_FILE);
   let stat2;
   try {
-    stat2 = await _internals10.stat(filePath);
+    stat2 = await _internals9.stat(filePath);
   } catch (err) {
     const code = err?.code;
     if (code === "ENOENT")
@@ -4760,11 +3817,11 @@ var PROJECT_INDICATORS = [
 ];
 function isWeakConfigContainerRoot(directory) {
   try {
-    const resolved = realpathSync2(directory);
-    return resolved === realpathSync2(os4.tmpdir()) || resolved === realpathSync2(os4.homedir());
+    const resolved = realpathSync(directory);
+    return resolved === realpathSync(os4.tmpdir()) || resolved === realpathSync(os4.homedir());
   } catch {
-    const resolved = path12.resolve(directory);
-    return resolved === path12.resolve(os4.tmpdir()) || resolved === path12.resolve(os4.homedir());
+    const resolved = path9.resolve(directory);
+    return resolved === path9.resolve(os4.tmpdir()) || resolved === path9.resolve(os4.homedir());
   }
 }
 function hasAccessibleProjectIndicator(directory, options = {}) {
@@ -4774,7 +3831,7 @@ function hasAccessibleProjectIndicator(directory, options = {}) {
       continue;
     }
     try {
-      const indicatorStat = statSync2(path12.join(directory, indicator));
+      const indicatorStat = statSync2(path9.join(directory, indicator));
       if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
         return true;
       }
@@ -4785,7 +3842,7 @@ function hasAccessibleProjectIndicator(directory, options = {}) {
 function validateProjectRoot(directory) {
   let resolved;
   try {
-    resolved = realpathSync2(directory);
+    resolved = realpathSync(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`);
@@ -4796,14 +3853,14 @@ function validateProjectRoot(directory) {
     if (depth >= MAX_DEPTH)
       break;
     depth++;
-    const parent = path12.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current)
       break;
-    if (path12.dirname(parent) === parent) {
+    if (path9.dirname(parent) === parent) {
       current = parent;
       continue;
     }
-    const parentSwarm = path12.join(parent, ".swarm");
+    const parentSwarm = path9.join(parent, ".swarm");
     try {
       if (statSync2(parentSwarm).isDirectory()) {
         if (hasAccessibleProjectIndicator(parent, {
@@ -4822,14 +3879,14 @@ function validateProjectRoot(directory) {
   }
 }
 async function saveEvidence(directory, taskId, evidence) {
-  _internals11.validateProjectRoot(directory);
+  _internals10.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path12.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path9.join("evidence", sanitizedTaskId, "evidence.json");
   validateSwarmPath(directory, relativePath);
-  _internals11.validateEvidence(evidence);
+  _internals10.validateEvidence(evidence);
   return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
     const evidencePath = validateSwarmPath(directory, relativePath);
-    const evidenceDir = path12.dirname(evidencePath);
+    const evidenceDir = path9.dirname(evidencePath);
     let bundle;
     const existingContent = await readSwarmFileAsync(directory, relativePath);
     if (existingContent !== null) {
@@ -4872,7 +3929,7 @@ async function saveEvidence(directory, taskId, evidence) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
     mkdirSync4(evidenceDir, { recursive: true });
-    const tempPath = path12.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+    const tempPath = path9.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
       await fs6.rename(tempPath, evidencePath);
@@ -4916,7 +3973,7 @@ function wrapFlatRetrospective(flatEntry, taskId) {
 }
 async function loadEvidence(directory, taskId, options) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path12.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path9.join("evidence", sanitizedTaskId, "evidence.json");
   if (relativePath.length > 4096) {
     return { status: "not_found" };
   }
@@ -4932,7 +3989,7 @@ async function loadEvidence(directory, taskId, options) {
     return { status: "invalid_schema", errors: ["Invalid JSON"] };
   }
   if (isFlatRetrospective(parsed)) {
-    const wrappedBundle = _internals11.wrapFlatRetrospective(parsed, sanitizedTaskId);
+    const wrappedBundle = _internals10.wrapFlatRetrospective(parsed, sanitizedTaskId);
     try {
       const validated = EvidenceBundleSchema.parse(wrappedBundle);
       if (options?.migrate === false) {
@@ -4940,9 +3997,9 @@ async function loadEvidence(directory, taskId, options) {
       }
       try {
         await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
-          const evidenceDir = path12.dirname(evidencePath);
+          const evidenceDir = path9.dirname(evidencePath);
           const bundleJson = JSON.stringify(validated);
-          const tempPath = path12.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+          const tempPath = path9.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
           try {
             await bunWrite(tempPath, bundleJson);
             await fs6.rename(tempPath, evidencePath);
@@ -4987,7 +4044,7 @@ async function listEvidenceTaskIds(directory) {
   }
   const taskIds = [];
   for (const entry of entries) {
-    const entryPath = path12.join(evidenceBasePath, entry);
+    const entryPath = path9.join(evidenceBasePath, entry);
     try {
       const stats = statSync2(entryPath);
       if (!stats.isDirectory()) {
@@ -5005,7 +4062,7 @@ async function listEvidenceTaskIds(directory) {
 }
 async function deleteEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path12.join("evidence", sanitizedTaskId);
+  const relativePath = path9.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
     statSync2(evidenceDir);
@@ -5021,8 +4078,8 @@ async function deleteEvidence(directory, taskId) {
   }
 }
 async function checkRequirementCoverage(phase, directory) {
-  const relativePath = path12.join("evidence", `req-coverage-phase-${phase}.json`);
-  const absolutePath = path12.resolve(directory, ".swarm", relativePath);
+  const relativePath = path9.join("evidence", `req-coverage-phase-${phase}.json`);
+  const absolutePath = path9.resolve(directory, ".swarm", relativePath);
   try {
     await fs6.access(absolutePath);
     return { exists: true, path: absolutePath };
@@ -5031,8 +4088,8 @@ async function checkRequirementCoverage(phase, directory) {
   }
 }
 async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
-  const taskIds = await _internals11.listEvidenceTaskIds(directory);
-  const cutoffDate = options?.now ? new Date(options.now) : _internals11.now();
+  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;
@@ -5044,7 +4101,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
   for (const taskId of taskIds) {
     let result;
     try {
-      result = await _internals11.loadEvidence(directory, taskId);
+      result = await _internals10.loadEvidence(directory, taskId);
     } catch {
       warn("archive: skipping corrupt or unreadable evidence for task", taskId);
       continue;
@@ -5072,7 +4129,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
   }
   if (!options?.dryRun) {
     for (const taskId of [...selected].sort()) {
-      const deleted = await _internals11.deleteEvidence(directory, taskId);
+      const deleted = await _internals10.deleteEvidence(directory, taskId);
       if (deleted)
         archived.push(taskId);
       else
@@ -5098,7 +4155,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
   };
   if (typeof options?.cacheMaxBytes === "number" && options.cacheMaxBytes > 0 || typeof options?.cacheMaxRecords === "number" && options.cacheMaxRecords > 0) {
     try {
-      documentsCache = await _internals11.pruneEvidenceDocuments({
+      documentsCache = await _internals10.pruneEvidenceDocuments({
         directory,
         maxBytes: options?.cacheMaxBytes,
         maxRecords: options?.cacheMaxRecords,
@@ -5126,7 +4183,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
 function validateEvidence(evidence) {
   return EvidenceSchema.parse(evidence);
 }
-var _internals11 = {
+var _internals10 = {
   wrapFlatRetrospective,
   loadEvidence,
   listEvidenceTaskIds,
@@ -5248,4 +4305,4 @@ function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
   return merged;
 }
 
-export { getExecutor, init_executor, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, resetToRemoteBranch, resetToMainAfterMerge, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, computeSpecHash, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, IdentifierSchema, EvaluationTaskV1Schema, GateNameSchema, GateAuditManifestV1Schema, GateAuditResultV1Schema, canonicalJson, canonicalHash, computeTaskInputContentHash, computeTaskSetContentHash, computeManifestContentHash, resolveContainedExistingPath, admitEvaluationTask, saveTaskSetSnapshot, saveGateAuditResult, saveGateAuditManifest, readGateAuditManifest, readGateAuditResult, listGateAuditResults, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };
+export { getExecutor, init_executor, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, resetToRemoteBranch, resetToMainAfterMerge, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, computeSpecHash, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };