agent-qa 0.2.3 → 0.2.4

package/dist/index.js

@@ -9,29 +9,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/hard-cut.ts
-function INVALID_CONFIG_FIX(configPath) {
-  return `Fix or remove the key named above in ${configPath}, then run agent-qa validate. To start over, agent-qa init --force rewrites agent-qa.config.yaml.`;
-}
-function isRetiredKeyIssue(issue) {
-  return issue.code === "custom" && typeof issue.params === "object" && issue.params !== null && issue.params.retired === true;
-}
-var RE_INITIALIZE_URL, HARD_CUT_STEPS;
-var init_hard_cut = __esm({
-  "src/hard-cut.ts"() {
-    "use strict";
-    RE_INITIALIZE_URL = "https://vostride.com/docs/agent-qa/migrate/v0-1-to-v0-2";
-    HARD_CUT_STEPS = [
-      "This config was written for agent-qa before v2. v2 does not upgrade a workspace; re-create it:",
-      "  1. Stop agent-qa in this project: the dashboard, the daemon (agent-qa daemon stop) and any MCP server.",
-      "  2. Copy aside rules you wrote: agent-qa-knowledge/policies/*.md and the agent-rules.md file your config names.",
-      "  3. Delete .agent-qa/, agent-qa-knowledge/ and agent-qa-memory/.",
-      "  4. Run agent-qa init --force. Your own tests, .env and .env.secrets.local are kept.",
-      `What re-initializing loses, and every step: ${RE_INITIALIZE_URL}`
-    ].join("\n");
-  }
-});
-
 // src/provider-plugins.ts
 var provider_plugins_exports = {};
 __export(provider_plugins_exports, {
@@ -56,26 +33,11 @@ var init_provider_plugins = __esm({
   }
 });
 
+// src/index.ts
+import { getAgentQaVersion } from "@vostride/agent-qa-core";
+export * from "@vostride/agent-qa-core";
+
 // src/config.ts
-var config_exports = {};
-__export(config_exports, {
-  ConfigFileNotFoundError: () => ConfigFileNotFoundError,
-  ConfigFileNotYamlError: () => ConfigFileNotYamlError,
-  deepMerge: () => deepMerge,
-  formatConfigDebug: () => formatConfigDebug,
-  loadConfigFile: () => loadConfigFile,
-  loadConfigPlugins: () => loadConfigPlugins,
-  loadEnvOverrides: () => loadEnvOverrides,
-  loadRequiredConfigFile: () => loadRequiredConfigFile,
-  mergeConfigs: () => mergeConfigs,
-  mergeUseBlocks: () => mergeUseBlocks,
-  mergeWithTestConfig: () => mergeWithTestConfig,
-  normalizeConfigForValidation: () => normalizeConfigForValidation,
-  readAnalyticsPrivacyDeclaration: () => readAnalyticsPrivacyDeclaration,
-  resolveConfig: () => resolveConfig,
-  resolveConfiguredKnowledgeRoot: () => resolveConfiguredKnowledgeRoot,
-  resolveRawConfigKnowledgeRoot: () => resolveRawConfigKnowledgeRoot
-});
 import { readFile } from "fs/promises";
 import { dirname as dirname2, resolve as resolvePath2 } from "path";
 import { parse as parseYaml } from "yaml";
@@ -87,6 +49,32 @@ import {
   resolveKnowledgeRoot,
   yamlParseFailureMessage
 } from "@vostride/agent-qa-core";
+
+// src/hard-cut.ts
+var RE_INITIALIZE_URL = "https://vostride.com/docs/agent-qa/migrate/v0-1-to-v0-2";
+var HARD_CUT_STEPS = [
+  "This config was written for agent-qa before v2. v2 does not upgrade a workspace; re-create it:",
+  "  1. Stop agent-qa in this project: the dashboard, the daemon (agent-qa daemon stop) and any MCP server.",
+  "  2. Copy aside rules you wrote: agent-qa-knowledge/policies/*.md and the agent-rules.md file your config names.",
+  "  3. Delete .agent-qa/, agent-qa-knowledge/ and agent-qa-memory/.",
+  "  4. Run agent-qa init --force. Your own tests, .env and .env.secrets.local are kept.",
+  `What re-initializing loses, and every step: ${RE_INITIALIZE_URL}`
+].join("\n");
+function INVALID_CONFIG_FIX(configPath) {
+  return `Fix or remove the key named above in ${configPath}, then run agent-qa validate. To start over, agent-qa init --force rewrites agent-qa.config.yaml.`;
+}
+function isHardCutIssue(issue) {
+  return issue.code === "custom" && typeof issue.params === "object" && issue.params !== null && issue.params.hardCut === true;
+}
+
+// src/config.ts
+var ENV_MAPPING = {
+  AGENT_QA_DASHBOARD_PORT: "services.dashboard.port",
+  AGENT_QA_MCP_PORT: "services.mcp.port",
+  AGENT_QA_CACHE_DIR: "services.cache.dir",
+  AGENT_QA_LOG_LEVEL: "services.logging.level",
+  AGENT_QA_HEADLESS: "use.browser.headless"
+};
 function setNestedValue(obj, path, value) {
   const parts = path.split(".");
   let current = obj;
@@ -111,6 +99,15 @@ function parseEnvValue(key, value) {
   }
   return value;
 }
+var ConfigFileNotYamlError = class extends Error {
+  configPath;
+  constructor(configPath, cause) {
+    const positionOnly = `${configPath}: ${yamlParseFailureMessage(cause)}`;
+    super(positionOnly, { cause: new Error(positionOnly) });
+    this.name = "ConfigFileNotYamlError";
+    this.configPath = configPath;
+  }
+};
 async function loadConfigFile(configPath) {
   let content;
   try {
@@ -125,6 +122,14 @@ async function loadConfigFile(configPath) {
     throw new ConfigFileNotYamlError(configPath, err);
   }
 }
+var ConfigFileNotFoundError = class extends Error {
+  configPath;
+  constructor(configPath) {
+    super(`Config file not found: ${configPath}`);
+    this.name = "ConfigFileNotFoundError";
+    this.configPath = configPath;
+  }
+};
 async function loadRequiredConfigFile(configPath) {
   let content;
   try {
@@ -190,6 +195,7 @@ function mergeUseBlocks(globalUse, suiteUse, testUse, cliFlags) {
     cliFlags
   );
 }
+var CIRCULAR_MARKER = "<circular>";
 function flattenObject(obj, prefix = "", ancestors = []) {
   const result = {};
   if (typeof obj !== "object" || obj === null) {
@@ -287,7 +293,7 @@ Hint: services.dashboard.enabled was removed. Dashboard behavior is enabled by t
     const baseUrlHint = baseUrlRefused ? `
 
 Hint: services.dashboard.baseUrl must now carry a scheme \u2014 write an absolute URL such as http://127.0.0.1:3470 rather than a bare host like localhost:3470, or remove the key entirely. An empty string is not an absence: absence is a legal and deliberate posture here \u2014 a standalone \`agent-qa mcp\` with no dashboard has no base, and the carrier tool result then names that absence rather than fabricating a URL. The value is refused because it is assigned to an href inside the served App document and appended verbatim to every carrier tool result, so a schemeless or empty base composes a link that resolves against nothing.` : "";
-    const closing = result.error.issues.some(isRetiredKeyIssue) ? HARD_CUT_STEPS : INVALID_CONFIG_FIX(configPath);
+    const closing = result.error.issues.some(isHardCutIssue) ? HARD_CUT_STEPS : INVALID_CONFIG_FIX(configPath);
     throw new Error(
       `Config validation failed:
 ${messages.join("\n")}
@@ -319,39 +325,6 @@ function resolveRawConfigKnowledgeRoot(config, configPath) {
     return null;
   }
 }
-var ENV_MAPPING, ConfigFileNotYamlError, ConfigFileNotFoundError, CIRCULAR_MARKER;
-var init_config = __esm({
-  "src/config.ts"() {
-    "use strict";
-    init_hard_cut();
-    ENV_MAPPING = {
-      AGENT_QA_DASHBOARD_PORT: "services.dashboard.port",
-      AGENT_QA_MCP_PORT: "services.mcp.port",
-      AGENT_QA_CACHE_DIR: "services.cache.dir",
-      AGENT_QA_CACHE_TTL: "services.cache.ttl",
-      AGENT_QA_LOG_LEVEL: "services.logging.level",
-      AGENT_QA_HEADLESS: "use.browser.headless"
-    };
-    ConfigFileNotYamlError = class extends Error {
-      configPath;
-      constructor(configPath, cause) {
-        const positionOnly = `${configPath}: ${yamlParseFailureMessage(cause)}`;
-        super(positionOnly, { cause: new Error(positionOnly) });
-        this.name = "ConfigFileNotYamlError";
-        this.configPath = configPath;
-      }
-    };
-    ConfigFileNotFoundError = class extends Error {
-      configPath;
-      constructor(configPath) {
-        super(`Config file not found: ${configPath}`);
-        this.name = "ConfigFileNotFoundError";
-        this.configPath = configPath;
-      }
-    };
-    CIRCULAR_MARKER = "<circular>";
-  }
-});
 
 // src/targets.ts
 function resolveTarget(config, targetName) {
@@ -369,8 +342,7 @@ function resolveTarget(config, targetName) {
     appPackage: target.appPackage,
     appActivity: target.appActivity,
     device: target.device,
-    // Carried through UNCHANGED, undefined included: the resolver does not fill in a class for a
-    // target whose author did not declare one (D-06).
+    // Carried unchanged, `undefined` included: an undeclared target gets no filled-in class.
     environment: target.environment
   };
 }
@@ -381,3261 +353,19 @@ function listTargets(config) {
     const typedEntry = entry;
     return {
       name,
-      platform: typedEntry.platform
-    };
-  });
-}
-var init_targets = __esm({
-  "src/targets.ts"() {
-    "use strict";
-  }
-});
-
-// src/composition/declared-secrets.ts
-import { existsSync as existsSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { parse as parseYaml2 } from "yaml";
-import { resolveWorkspacePaths } from "@vostride/agent-qa-core";
-import { SecretRedactor, SecretStore } from "@vostride/agent-qa-runner";
-function readDeclaredSecrets(secretsPath) {
-  if (!existsSync2(secretsPath)) {
-    throw new DeclaredSecretsUnavailableError([
-      `Error: Secrets file not found: ${secretsPath}`,
-      "Create the file before running tests. It may be empty, but it must exist."
-    ]);
-  }
-  let content;
-  try {
-    content = readFileSync4(secretsPath, "utf-8");
-  } catch {
-    throw new DeclaredSecretsUnavailableError([
-      `Error: Secrets file could not be read: ${secretsPath}`,
-      "Check the path and file permissions before running tests."
-    ]);
-  }
-  try {
-    return SecretStore.fromEnvContent(content);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new DeclaredSecretsUnavailableError([`Error: Secrets file is invalid: ${message}`]);
-  }
-}
-function resolveSecretsPath(configPath) {
-  const file = parseYaml2(readFileSync4(configPath, "utf-8")) ?? {};
-  const config = mergeConfigs(file, loadEnvOverrides(), {});
-  const configured = config?.workspace?.secretsFile;
-  if (typeof configured !== "string" || configured.trim().length === 0) {
-    throw DeclaredSecretsUnavailableError.required();
-  }
-  const workspace = resolveWorkspacePaths({ config, configPath });
-  return workspace.secretsFile.absolutePath;
-}
-function statKey(path) {
-  const stat2 = statSync2(path);
-  return `${stat2.mtimeMs}:${stat2.size}:${stat2.ino}`;
-}
-function createDeclaredSecretMask(configPath) {
-  let resolved;
-  let cached;
-  const currentSecretsPath = () => {
-    const configKey = statKey(configPath);
-    if (resolved?.configKey !== configKey) {
-      resolved = void 0;
-      resolved = { configKey, secretsPath: resolveSecretsPath(configPath) };
-    }
-    return resolved.secretsPath;
-  };
-  const redactor = () => {
-    const secretsPath = currentSecretsPath();
-    let key;
-    try {
-      key = `${secretsPath}\0${statKey(secretsPath)}`;
-    } catch {
-      key = void 0;
-    }
-    if (key !== void 0 && cached?.key === key) return cached.redactor;
-    const current = new SecretRedactor(readDeclaredSecrets(secretsPath));
-    cached = key === void 0 ? void 0 : { key, redactor: current };
-    return current;
-  };
-  return { mask: (text) => redactor().redactString(text), redactor };
-}
-var DeclaredSecretsUnavailableError;
-var init_declared_secrets = __esm({
-  "src/composition/declared-secrets.ts"() {
-    "use strict";
-    init_config();
-    DeclaredSecretsUnavailableError = class _DeclaredSecretsUnavailableError extends Error {
-      lines;
-      constructor(lines) {
-        super(lines.join(" "));
-        this.name = "DeclaredSecretsUnavailableError";
-        this.lines = lines;
-      }
-      static required() {
-        return new _DeclaredSecretsUnavailableError([
-          "Error: workspace.secretsFile is required. Run `agent-qa init` or set it in agent-qa.config.yaml."
-        ]);
-      }
-    };
-  }
-});
-
-// src/curation/promotion-posture.ts
-import { existsSync as existsSync3, readdirSync as readdirSync3 } from "fs";
-import { dirname as dirname7, join as join8, resolve as resolve3 } from "path";
-function hasNoiseFloorArtefacts(committedRoot) {
-  if (existsSync3(join8(committedRoot, "reports", "noise-floor.json"))) return true;
-  try {
-    return readdirSync3(join8(committedRoot, "reports", "noise-floor")).some((name) => name.endsWith(".json"));
-  } catch (error) {
-    return error.code !== "ENOENT";
-  }
-}
-function renderPromotionLine(entry) {
-  return entry.promotionPath === void 0 ? `curation: ${entry.candidateId} held: ${entry.promotionHoldReason}` : `curation: ${entry.candidateId} promoted via ${entry.promotionPath}`;
-}
-var init_promotion_posture = __esm({
-  "src/curation/promotion-posture.ts"() {
-    "use strict";
-  }
-});
-
-// src/eval-report-render.ts
-function counterLines(title, counts) {
-  const lines = [`### ${title}`, ""];
-  const keys = Object.keys(counts).sort();
-  if (keys.length === 0) {
-    lines.push("- none");
-  } else {
-    for (const key of keys) lines.push(`- ${key}: ${counts[key]}`);
-  }
-  lines.push("");
-  return lines;
-}
-function rateLine(name, metric) {
-  const rate = metric.rate === void 0 ? "n/a (zero denominator)" : `${metric.rate}`;
-  return `- ${name}: ${metric.numerator}/${metric.denominator} (rate: ${rate})`;
-}
-function metricLine(name, metric) {
-  if (metric === void 0) return `${name}: ${notSupplied}`;
-  const rate = metric.denominator === 0 ? "unavailable (zero denominator)" : metric.rate ?? notSupplied;
-  return `${name}: ${metric.numerator}/${metric.denominator} (rate: ${rate})`;
-}
-function recoveryLines(name, recovery) {
-  const weightSum = recovery?.weightSum;
-  const weighted = weightSum === 0 ? "unavailable (zero weightSum)" : recovery?.weightedAccuracy ?? notSupplied;
-  return [
-    metricLine(`${name}.recoveryAccuracy`, recovery === void 0 ? void 0 : {
-      numerator: recovery.recoveredPositiveCount,
-      denominator: recovery.eligiblePositiveCount,
-      ...recovery.recoveryAccuracy === void 0 ? {} : { rate: recovery.recoveryAccuracy }
-    }),
-    `${name}.weightedAccuracy: ${weighted} (weightSum: ${weightSum ?? notSupplied})`,
-    `${name}.pairsWithoutWeight: ${recovery?.pairsWithoutWeight ?? notSupplied}`
-  ];
-}
-function splitLines(name, cell) {
-  const cost = cell?.perDecisionCost;
-  return [
-    metricLine(`${name}.firstAttemptDecisionAccuracy`, cell?.firstAttemptDecisionAccuracy),
-    metricLine(`${name}.verifierFalsePassRate`, cell?.verifierFalsePassRate),
-    ...recoveryLines(`${name}.recovery`, cell?.recovery),
-    `${name}.perDecisionCost: ` + (cost === void 0 ? notSupplied : `decisionCount=${cost.decisionCount} promptTokens=${cost.promptTokens} completionTokens=${cost.completionTokens} totalTokens=${cost.totalTokens} durationMs=${cost.durationMs}`)
-  ];
-}
-function renderReportLabelMetricLines(report) {
-  const calibration = report.calibration;
-  return [
-    metricLine("verifierFalsePassRate", report.headline.verifierFalsePassRate),
-    `calibration.status: ${calibration?.status ?? notSupplied}`,
-    `calibration.n_gold: ${calibration?.n_gold ?? notSupplied}`,
-    `calibration.precision: ${calibration?.precision ?? notSupplied}`,
-    metricLine("calibration.verifierFalsePassRate", calibration?.verifierFalsePassRate),
-    ...recoveryLines("recovery", report.recovery),
-    ...splitLines("perSplit.natural", report.perSplit?.natural),
-    ...splitLines("perSplit.held-out.shared", report.perSplit?.["held-out"]?.shared),
-    ...splitLines("perSplit.held-out.private", report.perSplit?.["held-out"]?.private),
-    ...splitLines("perSplit.adversarial", report.perSplit?.adversarial),
-    `perSplit.unassignedCount: ${report.perSplit?.unassignedCount ?? notSupplied}`
-  ];
-}
-function renderEvalReportMarkdown(report) {
-  const lines = ["# Eval Baseline Report", ""];
-  lines.push("## Provenance", "");
-  lines.push(`- batchKey: ${report.batchKey}`);
-  lines.push(`- matcherVersion: ${report.matcherVersion}`);
-  if (report.judgeIdentity === "mixed") {
-    lines.push(
-      `- judge: mixed identities across score records (${(report.mixedJudgeModelIds ?? []).join(", ")}) \u2014 no judge block, not a gate comparator`
-    );
-  } else if (report.judge === void 0) {
-    lines.push("- judge: no judge invoked");
-  } else {
-    lines.push(
-      `- judge: judgeModelId=${report.judge.judgeModelId} judgeFamily=${report.judge.judgeFamily} judgeVersion=${report.judge.judgeVersion} confidenceThreshold=${report.judge.confidenceThreshold}`
-    );
-    if (report.judge.familyOverride !== void 0) {
-      lines.push(
-        `- judge family override: ${report.judge.familyOverride} (self-preference bias condition disclosed; owner override of D-10, 2026-07-12)`
-      );
-    }
-  }
-  const calibration = report.judge?.calibration;
-  if (calibration !== void 0) {
-    lines.push("- judge calibration: " + (calibration.status === "capability-gap" ? `capability-gap reason=${calibration.reason}` : calibration.status === "uncalibrated" ? `uncalibrated n=${calibration.n}` + (calibration.provenance === "unavailable" ? " (unavailable)" : " (copied)") : `calibrated n=${calibration.n} pooledAgreement=${calibration.pooledAgreement} wilson95=[${calibration.wilson95.lower},${calibration.wilson95.upper}] halfWidth=${calibration.wilson95.halfWidth} (copied)`));
-  }
-  lines.push("");
-  const headline = report.headline;
-  lines.push("## Headline", "");
-  lines.push(rateLine("firstAttemptDecisionAccuracy", headline.firstAttemptDecisionAccuracy));
-  lines.push("- perDecisionCost:");
-  lines.push(`  - decisionCount: ${headline.perDecisionCost.decisionCount}`);
-  lines.push(`  - promptTokens: ${headline.perDecisionCost.promptTokens}`);
-  lines.push(`  - completionTokens: ${headline.perDecisionCost.completionTokens}`);
-  lines.push(`  - totalTokens: ${headline.perDecisionCost.totalTokens}`);
-  lines.push(`  - durationMs: ${headline.perDecisionCost.durationMs}`);
-  lines.push("");
-  lines.push("### Label metrics", "", ...renderReportLabelMetricLines(report).map((line) => `- ${line}`), "");
-  const honesty = report.honesty;
-  lines.push("## Honesty Counters", "");
-  lines.push(...counterLines("tieCounts", honesty.tieCounts));
-  lines.push(...counterLines("unscorableIdentityCounts", honesty.unscorableIdentityCounts));
-  lines.push(...counterLines("refusalCounts", honesty.refusalCounts));
-  lines.push(...counterLines("missByFailureCounts", honesty.missByFailureCounts));
-  lines.push(`- harnessErrorCount: ${honesty.harnessErrorCount}`, "");
-  lines.push(...counterLines("neverScoredCounts", honesty.neverScoredCounts));
-  lines.push(...counterLines("skippedCounts", honesty.skippedCounts));
-  lines.push(...counterLines("judge invoked", honesty.judge.invoked));
-  lines.push(...counterLines("judge settled", honesty.judge.settled));
-  lines.push(...counterLines("judge abstained", honesty.judge.abstained));
-  lines.push(...counterLines("judge errors", honesty.judge.errors));
-  lines.push(...counterLines("judge notInvoked", honesty.judge.notInvoked));
-  lines.push("### judge cost", "");
-  lines.push(`- calls: ${honesty.judge.cost.calls}`);
-  lines.push(`- inputTokens: ${honesty.judge.cost.inputTokens}`);
-  lines.push(`- outputTokens: ${honesty.judge.cost.outputTokens}`);
-  lines.push(`- outcomesMissingUsage: ${honesty.judge.cost.outcomesMissingUsage}`);
-  lines.push("");
-  lines.push("## Axis Distributions", "");
-  lines.push(...counterLines("elementIdentity", report.axisDistributions.elementIdentity));
-  lines.push(...counterLines("value", report.axisDistributions.value));
-  lines.push(...counterLines("opClass", report.axisDistributions.opClass));
-  lines.push(...counterLines("sideEffect", report.axisDistributions.sideEffect));
-  lines.push(...counterLines("loop", report.axisDistributions.loop));
-  const recovery = report.recovery;
-  lines.push("## Recovery", "");
-  lines.push(`- selfHealPairCount: ${recovery.selfHealPairCount}`);
-  lines.push(`- recoveredPositiveCount: ${recovery.recoveredPositiveCount}`);
-  lines.push(`- eligiblePositiveCount: ${recovery.eligiblePositiveCount}`);
-  lines.push(
-    `- recoveryAccuracy: ${recovery.recoveryAccuracy === void 0 ? "n/a (no eligible positives)" : recovery.recoveryAccuracy}`
-  );
-  lines.push(`- negativeDecisionCount: ${recovery.negativeDecisionCount}`);
-  lines.push(`- negativeFullMatchCount: ${recovery.negativeFullMatchCount}`);
-  lines.push("");
-  return lines.join("\n");
-}
-var notSupplied;
-var init_eval_report_render = __esm({
-  "src/eval-report-render.ts"() {
-    "use strict";
-    notSupplied = "unavailable (not supplied)";
-  }
-});
-
-// src/model-defaults.ts
-var DEFAULT_ANTHROPIC_MODEL;
-var init_model_defaults = __esm({
-  "src/model-defaults.ts"() {
-    "use strict";
-    DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-5-5";
-  }
-});
-
-// src/llm-utils.ts
-var llm_utils_exports = {};
-__export(llm_utils_exports, {
-  applyResolvedAuthToModelConfig: () => applyResolvedAuthToModelConfig,
-  buildAnalysisTokenBudget: () => buildAnalysisTokenBudget,
-  buildJobModelCapability: () => buildJobModelCapability,
-  loadAuthPluginsForRawConfig: () => loadAuthPluginsForRawConfig,
-  loadProviderPluginsForRawConfig: () => loadProviderPluginsForRawConfig,
-  resolveCliAnalysisTokenBudget: () => resolveCliAnalysisTokenBudget,
-  resolveCliChatCapabilities: () => resolveCliChatCapabilities,
-  resolveCliJobModel: () => resolveCliJobModel,
-  resolveCredentials: () => resolveCredentials,
-  resolveLLMModels: () => resolveLLMModels,
-  resolveModelAuth: () => resolveModelAuth,
-  resolveNamedConfig: () => resolveNamedConfig,
-  toModelProfileAndAuth: () => toModelProfileAndAuth
-});
-import { dirname as dirname8, resolve as resolvePath3 } from "path";
-import { createModel as createModel2, createTokenAccounting as createTokenAccounting2, getProviderOptions, resolveCapabilities as resolveCapabilities2, resolveVisionGate } from "@vostride/agent-qa-model";
-import { generateText as generateText2 } from "ai";
-function normalizeLLMConfig(raw) {
-  return {
-    name: raw.name,
-    provider: raw.provider,
-    model: raw.model,
-    ...raw.baseURL !== void 0 ? { baseURL: raw.baseURL } : {},
-    ...raw.providerHeaders !== void 0 ? { providerHeaders: raw.providerHeaders } : {},
-    ...raw.vision !== void 0 ? { vision: raw.vision } : {},
-    ...raw.contextWindow !== void 0 ? { contextWindow: raw.contextWindow } : {}
-  };
-}
-async function loadAuthPluginsForRawConfig(raw, configPath = "agent-qa.config.yaml") {
-  const declarations = raw?.plugins?.auth;
-  if (!Array.isArray(declarations) || declarations.length === 0) return;
-  const { loadLLMAuthPlugins: loadLLMAuthPlugins2 } = await import("@vostride/agent-qa-core");
-  await loadLLMAuthPlugins2(declarations, {
-    baseDir: dirname8(resolvePath3(configPath))
-  });
-}
-async function resolveNamedConfig(configName, configPath = "agent-qa.config.yaml", options = {}) {
-  const { loadConfigFile: loadConfigFile2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const raw = await loadConfigFile2(configPath);
-  if (options.keyOnly !== true) {
-    await loadAuthPluginsForRawConfig(raw, configPath);
-    await loadProviderPluginsForRawConfig(raw, configPath);
-  }
-  const llms = raw?.registry?.llms?.map(normalizeLLMConfig);
-  const defaultLLM = raw?.use?.llm;
-  if (!llms?.length) {
-    throw new Error("No LLM configs found. Run `agent-qa init` to set up your config.");
-  }
-  const targetName = configName ?? defaultLLM;
-  if (!targetName) {
-    throw new Error("No config name specified and no use.llm set in config.");
-  }
-  const found = llms.find((c) => c.name === targetName);
-  if (!found) {
-    throw new Error(`Config "${targetName}" not found. Available: ${llms.map((c) => c.name).join(", ")}`);
-  }
-  return { config: found, allConfigs: llms, defaultName: defaultLLM ?? "" };
-}
-function resolveLLMModels(config) {
-  const defaults = { provider: "anthropic-subscription", model: DEFAULT_ANTHROPIC_MODEL };
-  if (!config.registry?.llms || !config.use?.llm) {
-    return { planner: defaults, verifier: defaults, configName: "" };
-  }
-  const found = config.registry.llms.find((c) => c.name === config.use.llm);
-  if (!found) {
-    return { planner: defaults, verifier: defaults, configName: "" };
-  }
-  const { name, ...modelFields } = normalizeLLMConfig(found);
-  return { planner: modelFields, verifier: modelFields, configName: name };
-}
-async function resolveModelAuth(configName, llmConfig) {
-  const { resolveLLMAuth } = await import("@vostride/agent-qa-core");
-  return resolveLLMAuth(configName, llmConfig);
-}
-function applyResolvedAuthToModelConfig(llmConfig, auth) {
-  switch (auth.kind) {
-    case "api-key":
-      return { ...llmConfig, apiKey: auth.apiKey };
-    case "bearer-token":
-      return { ...llmConfig, authToken: auth.token };
-    case "auth-fetch":
-      return { ...llmConfig, fetch: auth.fetch, modelAdapter: auth.modelAdapter };
-    case "unauthenticated":
-      return { ...llmConfig };
-    case "missing":
-      throw new Error(auth.message);
-  }
-}
-function toModelProfileAndAuth(llmConfig, resolved) {
-  const providerOptions = getProviderOptions({
-    provider: llmConfig.provider,
-    modelAdapter: resolved.kind === "auth-fetch" ? resolved.modelAdapter : void 0,
-    fetch: resolved.kind === "auth-fetch" ? resolved.fetch : void 0
-  });
-  const profile = {
-    provider: llmConfig.provider,
-    model: llmConfig.model,
-    ...llmConfig.baseURL !== void 0 ? { baseURL: llmConfig.baseURL } : {},
-    ...llmConfig.providerHeaders !== void 0 ? { headers: llmConfig.providerHeaders } : {},
-    ...providerOptions ? { providerOptions } : {},
-    auth: toAuthDeclaration(resolved)
-  };
-  switch (resolved.kind) {
-    case "api-key":
-      return { profile, auth: { kind: "api-key", apiKey: resolved.apiKey } };
-    case "bearer-token":
-      return { profile, auth: { kind: "bearer-token", token: resolved.token } };
-    case "auth-fetch":
-      return { profile, auth: { kind: "auth-fetch", modelAdapter: resolved.modelAdapter, fetch: resolved.fetch } };
-    case "unauthenticated":
-      return { profile, auth: { kind: "none" } };
-    case "missing":
-      throw new Error(resolved.message);
-  }
-}
-function toAuthDeclaration(resolved) {
-  switch (resolved.kind) {
-    case "api-key":
-      return { mode: "api-key" };
-    case "bearer-token":
-      return { mode: "bearer-token" };
-    case "auth-fetch":
-      return { mode: "subscription", plugin: resolved.provider };
-    case "unauthenticated":
-    case "missing":
-      return { mode: "none" };
-  }
-}
-function buildJobModelCapability(profile, auth, mask, deps = {}) {
-  const model = (deps.createModelImpl ?? createModel2)(profile, auth, mask);
-  const accounting = (deps.createTokenAccountingImpl ?? createTokenAccounting2)({
-    getCapabilities: () => (deps.resolveCapabilitiesImpl ?? resolveCapabilities2)(profile)
-  });
-  const generate = deps.generateTextImpl ?? generateText2;
-  const vision = (deps.resolveCapabilitiesImpl ?? resolveCapabilities2)(profile).vision;
-  return {
-    modelId: `${profile.provider}:${profile.model}`,
-    vision,
-    async generate(request2) {
-      const base = {
-        model,
-        maxRetries: 0,
-        temperature: 0,
-        maxOutputTokens: accounting.getCeilings().maxOutput,
-        ...request2.system === void 0 ? {} : { system: request2.system },
-        ...request2.signal === void 0 ? {} : { abortSignal: request2.signal }
-      };
-      if (request2.images !== void 0 && request2.images.length > 0 && resolveVisionGate({ vision }).attachImage) {
-        const result2 = await generate({
-          ...base,
-          messages: [
-            {
-              role: "user",
-              content: [
-                { type: "text", text: request2.prompt },
-                ...request2.images.map((image) => ({ type: "image", image }))
-              ]
-            }
-          ]
-        });
-        return { text: result2.text };
-      }
-      const result = await generate({
-        ...base,
-        prompt: request2.prompt
-      });
-      return { text: result.text };
-    }
-  };
-}
-function buildAnalysisTokenBudget(profile, deps = {}) {
-  const accounting = (deps.createTokenAccountingImpl ?? createTokenAccounting2)({
-    getCapabilities: () => (deps.resolveCapabilitiesImpl ?? resolveCapabilities2)(profile)
-  });
-  const ceilings = accounting.getCeilings();
-  return {
-    estimate: (text) => accounting.estimate([{ role: "user", content: text }]),
-    inputBudget: Math.max(0, ceilings.contextWindow - ceilings.maxOutput)
-  };
-}
-async function resolveCliAnalysisTokenBudget(configPath, deps = {}) {
-  try {
-    const { config } = await resolveNamedConfig(void 0, configPath);
-    const resolved = await resolveModelAuth(config.name, config);
-    const { profile } = toModelProfileAndAuth(config, resolved);
-    return buildAnalysisTokenBudget(profile, deps);
-  } catch {
-    return void 0;
-  }
-}
-async function resolveCliJobModel(configPath, deps = {}) {
-  const { config } = await resolveNamedConfig(void 0, configPath);
-  const resolved = await resolveModelAuth(config.name, config);
-  const { profile, auth } = toModelProfileAndAuth(config, resolved);
-  return buildJobModelCapability(profile, auth, createDeclaredSecretMask(configPath).mask, deps);
-}
-async function resolveCliChatCapabilities(configPath, deps = {}) {
-  const { mask } = createDeclaredSecretMask(configPath);
-  const build = async (configName) => {
-    const { config } = await resolveNamedConfig(configName, configPath);
-    const resolved = await resolveModelAuth(config.name, config);
-    const { profile, auth } = toModelProfileAndAuth(config, resolved);
-    return {
-      model: (deps.createModelImpl ?? createModel2)(profile, auth, mask),
-      accounting: (deps.createTokenAccountingImpl ?? createTokenAccounting2)({
-        getCapabilities: () => (deps.resolveCapabilitiesImpl ?? resolveCapabilities2)(profile)
-      })
-    };
-  };
-  try {
-    const opened = await build();
-    return {
-      model: opened.model,
-      accounting: opened.accounting,
-      // A THROW rather than a degrade on this arm: `/model nonsense` is a person naming something,
-      // and the honest answer is the refusal that says which name failed. The turn engine's one
-      // refusal path carries it, leaving the same countable row any other refusal leaves.
-      modelFor: async (name) => (await build(name)).model
-    };
-  } catch {
-    return void 0;
-  }
-}
-async function resolveCredentials(configName, llmConfig) {
-  try {
-    const auth = await resolveModelAuth(configName, llmConfig);
-    if (auth.kind === "api-key") return { apiKey: auth.apiKey };
-    if (auth.kind === "bearer-token") return { authToken: auth.token };
-    if (auth.kind === "auth-fetch") return { authFetch: auth.fetch };
-    return {};
-  } catch {
-    return {};
-  }
-}
-var init_llm_utils = __esm({
-  "src/llm-utils.ts"() {
-    "use strict";
-    init_declared_secrets();
-    init_model_defaults();
-    init_provider_plugins();
-  }
-});
-
-// src/judge-panel-preflight.ts
-async function preflightJudgePanel(session, options = {}, deps = {}) {
-  const minN = resolveJudgeCalibrationMinimum(options.minN);
-  const names = selectedEvalJudgeNames(session.evalConfig);
-  if (names.length < 2) return {
-    kind: "capability-gap",
-    status: "capability-gap",
-    reason: "panel-not-configured",
-    minN,
-    entries: []
-  };
-  const named = deps.resolveNamedConfig ?? resolveNamedConfig;
-  const resolveAuth = deps.resolveModelAuth ?? resolveModelAuth;
-  const rows = [];
-  for (const [index, name] of names.entries()) {
-    const diagnostic = {
-      index,
-      name,
-      families: [],
-      credential: "resolution-failed",
-      failures: []
-    };
-    const row = { diagnostic };
-    try {
-      const { config } = await named(name, session.configPath, { keyOnly: true });
-      row.config = config;
-      diagnostic.modelId = config.model;
-      diagnostic.families = [...resolveJudgeFamilies(config.model)].sort();
-    } catch {
-      diagnostic.failures = ["config-unresolved"];
-    }
-    if (row.config) {
-      try {
-        const auth = await resolveAuth(row.config.name, row.config);
-        row.auth = auth;
-        diagnostic.credential = auth.kind === "missing" || auth.kind === "unauthenticated" ? auth.kind : "present";
-      } catch {
-      }
-    }
-    if (diagnostic.credential !== "present") diagnostic.failures = [...diagnostic.failures, "no-credential"];
-    rows.push(row);
-  }
-  let replayProfile;
-  try {
-    replayProfile = await resolveReplayProfileDeclaration(session, named);
-  } catch {
-    throw new Error("Cannot resolve the replay profile for judge panel preflight. Check use.llm and its registry.llms entry.");
-  }
-  const replayFamilies = resolveJudgeFamilies(replayProfile.model);
-  const sets = rows.map((row) => resolveJudgeFamilies(row.config?.model ?? ""));
-  for (const [index, row] of rows.entries()) {
-    const failures = [...row.diagnostic.failures];
-    if (row.config && (sets[index].size === 0 || replayFamilies.size === 0)) failures.push("unknown-family");
-    if (judgeFamiliesIntersect(sets[index], replayFamilies)) failures.push("replay-family-collision");
-    if (sets.some((set, other) => other !== index && judgeFamiliesIntersect(sets[index], set))) failures.push("member-family-collision");
-    row.diagnostic.failures = failures;
-  }
-  const entries = rows.map(({ diagnostic }) => ({
-    ...diagnostic,
-    name: session.mask(diagnostic.name),
-    ...diagnostic.modelId === void 0 ? {} : { modelId: session.mask(diagnostic.modelId) }
-  }));
-  const modelIds = rows.flatMap((row) => row.config ? [row.config.model] : []);
-  const complete = modelIds.length === names.length;
-  const identity = complete ? createPanelIdentity(modelIds) : void 0;
-  const safeIdentity = [replayProfile.model, ...modelIds].every((id) => session.mask(id) === id) ? identity : void 0;
-  const gap = (reason) => ({
-    kind: "capability-gap",
-    status: "capability-gap",
-    reason,
-    minN,
-    entries,
-    ...safeIdentity === void 0 ? {} : { identity: safeIdentity }
-  });
-  if (rows.some((row) => row.diagnostic.credential !== "present")) return gap("no-credential");
-  const eligibility = assessPanelEligibility({ memberModelIds: modelIds, replayedModelId: replayProfile.model });
-  if (!eligibility.eligible) return gap("single-family-host");
-  return {
-    kind: "eligible",
-    status: "uncalibrated",
-    n: 0,
-    minN,
-    entries,
-    identity,
-    replayProfile,
-    members: rows.map((row) => toModelProfileAndAuth(row.config, row.auth))
-  };
-}
-var init_judge_panel_preflight = __esm({
-  "src/judge-panel-preflight.ts"() {
-    "use strict";
-    init_eval_session_composition();
-    init_llm_utils();
-  }
-});
-
-// src/adversarial-probe-preflight.ts
-var adversarial_probe_preflight_exports = {};
-__export(adversarial_probe_preflight_exports, {
-  resolveAdversarialProbeCapability: () => resolveAdversarialProbeCapability
-});
-function authoringFamily(modelId) {
-  return [...resolveJudgeFamilies(modelId)].sort().join(",");
-}
-async function resolveAdversarialProbeCapability(session, deps = {}) {
-  const names = selectedEvalJudgeNames(session.evalConfig);
-  if (names.length === 0) {
-    return { kind: "no-probe-model", reason: "panel-not-configured", entries: [] };
-  }
-  const named = deps.resolveNamedConfig ?? resolveNamedConfig;
-  const resolveAuth = deps.resolveModelAuth ?? resolveModelAuth;
-  const rows = [];
-  for (const [index, name] of names.entries()) {
-    const diagnostic = {
-      index,
-      name,
-      families: [],
-      credential: "resolution-failed",
-      failures: []
-    };
-    const row = { diagnostic };
-    try {
-      const { config } = await named(name, session.configPath, { keyOnly: true });
-      row.config = config;
-      diagnostic.modelId = config.model;
-      diagnostic.families = [...resolveJudgeFamilies(config.model)].sort();
-    } catch {
-      diagnostic.failures = ["config-unresolved"];
-    }
-    if (row.config) {
-      try {
-        const auth2 = await resolveAuth(row.config.name, row.config);
-        row.auth = auth2;
-        diagnostic.credential = auth2.kind === "missing" || auth2.kind === "unauthenticated" ? auth2.kind : "present";
-      } catch {
-      }
-    }
-    if (diagnostic.credential !== "present") {
-      diagnostic.failures = [...diagnostic.failures, "no-credential"];
-    }
-    rows.push(row);
-  }
-  let replayProfile;
-  try {
-    replayProfile = await resolveReplayProfileDeclaration(session, named);
-  } catch {
-    throw new Error("Cannot resolve the replay profile for adversarial probe preflight. Check use.llm and its registry.llms entry.");
-  }
-  const replayFamilies = resolveJudgeFamilies(replayProfile.model);
-  for (const row of rows) {
-    if (!row.config) continue;
-    const families = resolveJudgeFamilies(row.config.model);
-    row.eligible = assessPanelEligibility({
-      memberModelIds: [row.config.model],
-      replayedModelId: replayProfile.model
-    }).eligible;
-    const failures = [...row.diagnostic.failures];
-    if (families.size === 0 || replayFamilies.size === 0) failures.push("unknown-family");
-    else if (!row.eligible) failures.push("replay-family-collision");
-    row.diagnostic.failures = failures;
-  }
-  const entries = rows.map(({ diagnostic }) => ({
-    ...diagnostic,
-    name: session.mask(diagnostic.name),
-    ...diagnostic.modelId === void 0 ? {} : { modelId: session.mask(diagnostic.modelId) }
-  }));
-  const gap = (reason) => ({ kind: "no-probe-model", reason, entries });
-  if (rows.every((row) => row.diagnostic.credential !== "present")) return gap("no-credential");
-  const selected = rows.find((row) => row.diagnostic.credential === "present" && row.config !== void 0 && row.eligible === true);
-  if (!selected) return gap("single-family-host");
-  const { profile, auth } = toModelProfileAndAuth(selected.config, selected.auth);
-  return {
-    kind: "probe-author",
-    entries,
-    author: {
-      index: selected.diagnostic.index,
-      name: selected.config.name,
-      authoringModel: { id: profile.model, family: authoringFamily(profile.model) },
-      profile,
-      auth
-    }
-  };
-}
-var init_adversarial_probe_preflight = __esm({
-  "src/adversarial-probe-preflight.ts"() {
-    "use strict";
-    init_eval_session_composition();
-    init_llm_utils();
-  }
-});
-
-// src/adversarial-probe-author.ts
-var adversarial_probe_author_exports = {};
-__export(adversarial_probe_author_exports, {
-  PROBE_AUTHOR_MAX_OUTPUT_TOKENS: () => PROBE_AUTHOR_MAX_OUTPUT_TOKENS,
-  PROBE_AUTHOR_TIMEOUT_MS: () => PROBE_AUTHOR_TIMEOUT_MS,
-  createAdversarialProbeAuthor: () => createAdversarialProbeAuthor
-});
-import { generateText as generateText3 } from "ai";
-import { z as z7 } from "zod";
-function createAdversarialProbeAuthor(input) {
-  const { author } = input;
-  const create = input.createModelImpl ?? createModel3;
-  const generate = input.generateTextImpl ?? generateText3;
-  return {
-    async author(request2) {
-      if (request2.authoringModel.id !== author.authoringModel.id) {
-        throw new Error("This probe author is bound to a different authoring model than the request names.");
-      }
-      await input.onCallAttempted?.({
-        seedCassetteId: request2.seedCassetteId,
-        kind: request2.kind,
-        promptVersion: request2.promptVersion,
-        authoringModelId: author.authoringModel.id
-      });
-      const profile = {
-        ...author.profile,
-        ...author.profile.capabilities === void 0 ? {} : { capabilities: { ...author.profile.capabilities } }
-      };
-      return await runSafetyScope({ executionContext: input.executionContext }, async () => {
-        const model = create(profile, author.auth, input.mask);
-        const prompt = renderAdversarialProbePrompt(request2);
-        const result = await generate({
-          model,
-          maxRetries: 0,
-          temperature: 0,
-          maxOutputTokens: PROBE_AUTHOR_MAX_OUTPUT_TOKENS,
-          abortSignal: AbortSignal.timeout(PROBE_AUTHOR_TIMEOUT_MS),
-          system: prompt.system,
-          prompt: prompt.user
-        });
-        const parsed = AUTHORED_NAME.safeParse(parseJson2(result.text));
-        if (!parsed.success) {
-          throw new Error("The probe author returned a response that is not the single-field name object the frozen prompt requires.");
-        }
-        return {
-          text: parsed.data.name,
-          // Reported spend, carried as reported -- and ABSENT when the provider reported
-          // nothing, never zero. A zero here would be a measured claim about a call whose
-          // cost we do not know, and the disclosure that reads this cannot tell the two
-          // apart once they are the same number. The probe budget is denominated in CALLS
-          // for exactly this reason, so an unreported token still never buys an extra call.
-          usage: {
-            ...reportedCount(result.usage?.inputTokens) === void 0 ? {} : { promptTokens: reportedCount(result.usage?.inputTokens) },
-            ...reportedCount(result.usage?.outputTokens) === void 0 ? {} : { completionTokens: reportedCount(result.usage?.outputTokens) }
-          }
-        };
-      });
-    }
-  };
-}
-function parseJson2(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
-}
-function reportedCount(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : void 0;
-}
-var PROBE_AUTHOR_MAX_OUTPUT_TOKENS, PROBE_AUTHOR_TIMEOUT_MS, AUTHORED_NAME;
-var init_adversarial_probe_author = __esm({
-  "src/adversarial-probe-author.ts"() {
-    "use strict";
-    init_eval_session_composition();
-    PROBE_AUTHOR_MAX_OUTPUT_TOKENS = 200;
-    PROBE_AUTHOR_TIMEOUT_MS = 2e4;
-    AUTHORED_NAME = z7.object({ name: z7.string() }).strict();
-  }
-});
-
-// src/curation/trust-priors.ts
-import { dirname as dirname9, resolve as resolve4 } from "path";
-function buildTrustPriorsResolver(input) {
-  const configDir = dirname9(resolve4(input.configPath));
-  const committedRoot = resolve4(configDir, "agent-qa-eval");
-  const read = readLabelCalibration(committedRoot);
-  if (read.kind === "refused") return Object.freeze({ kind: "refused", reason: REFUSAL });
-  const table = {};
-  const nByOrigin = { "agent-verified": 0, "agent-observed": 0 };
-  if (read.kind === "loaded") {
-    for (const [origin, channel] of [["agent-verified", "recorded-verdict"], ["agent-observed", "self-heal-pair"]]) {
-      nByOrigin[origin] = read.artifact.channels[channel].n;
-      const prior = read.artifact.priors[origin];
-      if (prior !== void 0) table[origin] = Object.freeze({ alpha: prior.alpha, beta: prior.beta });
-    }
-  }
-  const priors = Object.keys(table).length === 0 ? void 0 : Object.freeze(table);
-  const disclosure = Object.freeze({
-    status: priors === void 0 ? "provisional" : "calibrated",
-    ...read.kind === "loaded" ? { digest: read.artifact.generationId } : {},
-    nByOrigin: Object.freeze(nByOrigin)
-  });
-  let calibration;
-  if (input.inspectCalibration) {
-    if (read.kind === "absent") calibration = "label calibration: absent";
-    else {
-      const identity = readCalibrationGoldIdentity({ committedRoot, agentQaRoot: resolve4(configDir, ".agent-qa"), calibrationRead: read });
-      const freshness = identity.kind === "unavailable" ? "unavailable" : identity.goldSetDigest === read.artifact.goldSetDigest ? "current" : "stale";
-      const channels = ["recorded-verdict", "self-heal-pair"].map((channel) => {
-        const row = read.artifact.channels[channel];
-        return `${channel} ${row.status} n=${row.n}`;
-      }).join(", ");
-      calibration = `label calibration: ${channels}; goldDigest ${freshness}`;
-    }
-  }
-  return Object.freeze({
-    kind: "ready",
-    resolve: () => priors,
-    disclosure,
-    ...calibration === void 0 ? {} : { calibration }
-  });
-}
-function trustPriorsForHost(input) {
-  const result = buildTrustPriorsResolver(input);
-  if (result.kind === "refused") throw new TrustPriorsRefusedError();
-  return result;
-}
-var REFUSAL, TrustPriorsRefusedError;
-var init_trust_priors = __esm({
-  "src/curation/trust-priors.ts"() {
-    "use strict";
-    init_eval_session_composition();
-    REFUSAL = "Trust prior calibration is invalid or unavailable; inspect the selected config's committed calibration marker and referenced revisions, following https://vostride.com/docs/agent-qa/self-improvement/evals#if-calibration-is-refused before composing this host.";
-    TrustPriorsRefusedError = class extends Error {
-      kind = "trust-priors-refused";
-      constructor() {
-        super(REFUSAL);
-        this.name = "TrustPriorsRefusedError";
-      }
-    };
-  }
-});
-
-// src/gates/replay-gate-host.ts
-var replay_gate_host_exports = {};
-__export(replay_gate_host_exports, {
-  createReplayGateHost: () => createReplayGateHost,
-  createReplayGatePortForHost: () => createReplayGatePortForHost
-});
-import { dirname as dirname10, resolve as resolve5 } from "path";
-import { Gate1ReceiptNotPersistedError } from "@vostride/agent-qa-agent";
-import {
-  createKnowledgeReader,
-  LOCAL_CURATION_CAPABILITIES as LOCAL_CURATION_CAPABILITIES2
-} from "@vostride/agent-qa-agent-local";
-import {
-  GateReceiptSchema,
-  receiptDigestOf
-} from "@vostride/agent-qa-schema";
-function createReplayGatePortForHost(input) {
-  const resolveTrustPriors = input.resolveTrustPriors ?? trustPriorsForHost(input).resolve;
-  return {
-    async runReplayGate(candidateId) {
-      const { resolveEvalSession: resolveEvalSession2, runReplayGateVerb: runReplayGateVerb2 } = await Promise.resolve().then(() => (init_eval_session_composition(), eval_session_composition_exports));
-      const session = await resolveEvalSession2({ configPath: input.configPath, keyOnly: true });
-      const borrowed = input.resolveClaimAuthority?.();
-      const result = await runReplayGateVerb2(session, candidateId, {
-        resolveTrustPriors,
-        agentQaRoot: input.agentQaRoot,
-        onProgress: () => void 0,
-        ...borrowed === void 0 ? {} : { claimAuthority: borrowed }
-      });
-      if (result.kind === "refused") throw new Error(result.refusal.reason);
-      return checkedReceipt(acknowledged(result, candidateId), candidateId);
-    }
-  };
-}
-function acknowledged(result, candidateId) {
-  if (!ACKNOWLEDGED_RECORDINGS.includes(result.recorded)) {
-    throw new Gate1ReceiptNotPersistedError(candidateId, result.recorded);
-  }
-  return result.receipt;
-}
-function checkedReceipt(value, candidateId) {
-  const receipt = GateReceiptSchema.parse(value);
-  if (receipt.gate !== 1 || receipt.candidateId !== candidateId || receipt.receiptDigest !== receiptDigestOf(receipt))
-    throw new Error("Gate 1 returned a foreign candidate, wrong gate or invalid receipt digest");
-  return receipt;
-}
-function createReplayGateHost(deps) {
-  const resolveTrustPriors = deps.resolveTrustPriors ?? trustPriorsForHost(deps).resolve;
-  const configDir = dirname10(resolve5(deps.configPath));
-  const knowledgeRoot = resolveConfiguredKnowledgeRoot(deps.session.config, configDir);
-  const reader = deps.reader ?? createKnowledgeReader(() => knowledgeRoot, void 0, void 0, resolveTrustPriors);
-  const curation = deps.curation ?? LOCAL_CURATION_CAPABILITIES2;
-  async function run(candidateId) {
-    const read = reader.candidateInjection;
-    if (read === void 0) throw new Error("knowledge reader binds no candidateInjection");
-    const found = await read.call(reader, { candidateId });
-    if (found.kind === "not-found")
-      return {
-        kind: "refused",
-        refusal: {
-          path: knowledgeRoot,
-          reason: `candidate ${candidateId} not found`
-        },
-        notices: [],
-        exit: 2
-      };
-    if (found.injection.candidateId !== candidateId)
-      throw new Error("Gate 1 reader returned a foreign candidate");
-    const runGate = deps.runReplayGate ?? (await Promise.resolve().then(() => (init_eval_session_composition(), eval_session_composition_exports))).runReplayGate;
-    const result = await runGate({
-      ...deps.composition,
-      injection: found.injection,
-      committedRoot: resolve5(configDir, "agent-qa-eval"),
-      agentQaRoot: deps.agentQaRoot,
-      mask: deps.session.mask,
-      producedBy: { opId: "eval.replay-gate" }
-    });
-    if (result.kind === "refused") return { ...result, exit: 2 };
-    const receipt = checkedReceipt(result.receipt, candidateId);
-    const answer = {
-      kind: "receipt",
-      receipt,
-      lines: result.lines,
-      notices: [...result.notices],
-      recorded: "dry-run",
-      exit: receipt.verdict === "pass" ? 0 : receipt.verdict === "fail" ? 1 : 2
-    };
-    if (!deps.record) return answer;
-    const borrowed = deps.resolveClaimAuthority?.();
-    if (borrowed !== void 0) {
-      const outcome = await curation.recordGateReceipt({
-        resolveTrustPriors,
-        receipt,
-        lease: { leaseId: borrowed.leaseId, epoch: borrowed.epoch },
-        knowledgeRoot,
-        executionContext: deps.session.executionContext,
-        sourceBuildOrdinal: receipt.producedAtOrdinal,
-        ...deps.resolvePromotionPosture === void 0 ? {} : { resolvePromotionPosture: deps.resolvePromotionPosture }
-      });
-      answer.recorded = outcome.kind;
-      return answer;
-    }
-    const lease = curation.maintenance.acquireWriterLease(knowledgeRoot);
-    if (lease.kind !== "acquired") {
-      answer.recorded = lease.kind === "held" ? "lease-held" : "lease-refused";
-      answer.exit = 2;
-      answer.notices.push(
-        lease.kind === "held" ? "writer lease held by another process; receipt printed, not recorded \u2014 re-run when the daemon releases it" : `writer lease refused: ${lease.reason}; receipt printed, not recorded`
-      );
-      return answer;
-    }
-    try {
-      const outcome = await curation.recordGateReceipt({
-        resolveTrustPriors,
-        receipt,
-        lease: { leaseId: lease.leaseId, epoch: lease.epoch },
-        knowledgeRoot,
-        executionContext: deps.session.executionContext,
-        sourceBuildOrdinal: receipt.producedAtOrdinal,
-        ...deps.resolvePromotionPosture === void 0 ? {} : { resolvePromotionPosture: deps.resolvePromotionPosture }
-      });
-      answer.recorded = outcome.kind;
-      return answer;
-    } finally {
-      curation.maintenance.releaseLease({ knowledgeRoot, leaseId: lease.leaseId });
-    }
-  }
-  return {
-    run,
-    port: {
-      async runReplayGate(id) {
-        const result = await run(id);
-        if (result.kind === "refused") throw new Error(result.refusal.reason);
-        return acknowledged(result, id);
-      }
-    }
-  };
-}
-var ACKNOWLEDGED_RECORDINGS;
-var init_replay_gate_host = __esm({
-  "src/gates/replay-gate-host.ts"() {
-    "use strict";
-    init_trust_priors();
-    init_config();
-    ACKNOWLEDGED_RECORDINGS = ["appended", "duplicate"];
-  }
-});
-
-// src/eval-session-composition.ts
-var eval_session_composition_exports = {};
-__export(eval_session_composition_exports, {
-  ADVERSARIAL_STAGING_SUBDIR: () => ADVERSARIAL_STAGING_SUBDIR,
-  ATTR_DEFAULT_MAX_MISDIRECTION_CHECKS: () => ATTR_DEFAULT_MAX_MISDIRECTION_CHECKS,
-  EvalJudgeDeclarationError: () => EvalJudgeDeclarationError,
-  EvalNamedInputError: () => EvalNamedInputError,
-  EvalPartitionFlagsRequiredError: () => EvalPartitionFlagsRequiredError,
-  EvalPartitionManifestConflictError: () => EvalPartitionManifestConflictError,
-  FLOOR_DEFAULT_BOOTSTRAP_SEED: () => FLOOR_DEFAULT_BOOTSTRAP_SEED,
-  FLOOR_DEFAULT_REPEATS: () => FLOOR_DEFAULT_REPEATS,
-  FLOOR_DEFAULT_SEEDS: () => FLOOR_DEFAULT_SEEDS,
-  FsHandoffSource: () => FsHandoffSource,
-  FsMarkLedger: () => FsMarkLedger,
-  GATE1_DEFAULT_K: () => GATE1_DEFAULT_K,
-  GATE1_DEFAULT_MAX_SCREENS: () => GATE1_DEFAULT_MAX_SCREENS,
-  GATE2_DEFAULT_CANARY_HORIZON_BUILDS: () => GATE2_DEFAULT_CANARY_HORIZON_BUILDS,
-  GATE2_DEFAULT_MAX_ABLATIONS: () => GATE2_DEFAULT_MAX_ABLATIONS,
-  HANDOFF_FILE: () => HANDOFF_FILE2,
-  LABEL_CALIBRATION_MIN_GOLD: () => LABEL_CALIBRATION_MIN_GOLD,
-  MARK_INTENT_FILE: () => MARK_INTENT_FILE,
-  MarkLedgerCorruptError: () => MarkLedgerCorruptError,
-  NO_PROBE_MODEL_REASONS: () => NO_PROBE_MODEL_REASONS,
-  RUNS_SUBDIR: () => RUNS_SUBDIR2,
-  SEED_POLICIES: () => SEED_POLICIES2,
-  adversarialHostOptions: () => adversarialHostOptions,
-  assessPanelEligibility: () => assessPanelEligibility,
-  canonicalJson: () => canonicalJson6,
-  computeCorpusDigest: () => computeCorpusDigest2,
-  computeReplayProfileFingerprintFor: () => computeReplayProfileFingerprintFor,
-  createAdversarialProbeAuthor: () => createAdversarialProbeAuthor,
-  createModel: () => createModel3,
-  createPanelIdentity: () => createPanelIdentity,
-  feedbackSeedHostOptions: () => feedbackSeedHostOptions,
-  freezeGoldenTrajectory: () => freezeGoldenTrajectory,
-  isFeedbackStateNovel: () => isFeedbackStateNovel,
-  judgeCapabilityOf: () => judgeCapabilityOf,
-  judgeFamiliesIntersect: () => judgeFamiliesIntersect,
-  latestMarkReceiptFor: () => latestMarkReceiptFor,
-  listAdversarialBatches: () => listAdversarialBatches,
-  listStagedAdversarial: () => listStagedAdversarial2,
-  locateMisdirectionDecision: () => locateMisdirectionDecision,
-  markedDecisionCount: () => markedDecisionCount,
-  preflightJudgePanel: () => preflightJudgePanel,
-  previewMarkLabels: () => previewMarkLabels,
-  projectMatcherConfigContract: () => projectMatcherConfigContract,
-  readActiveCommittedCorpus: () => readActiveCommittedCorpus2,
-  readAdversarialRefreshRecords: () => readAdversarialRefreshRecords,
-  readCalibrationGoldIdentity: () => readCalibrationGoldIdentity,
-  readCanaryCorpusDigest: () => readCanaryCorpusDigest,
-  readCommittedCorpus: () => readCommittedCorpus2,
-  readGatePostureFor: () => readGatePostureFor,
-  readJudgeCalibration: () => readJudgeCalibration,
-  readLabelCalibration: () => readLabelCalibration,
-  readMisdirectionRootPosture: () => readMisdirectionRootPosture,
-  renderAdversarialProbePrompt: () => renderAdversarialProbePrompt,
-  renderBaselineComparatorRefusal: () => renderBaselineComparatorRefusal2,
-  renderCensusMarkdown: () => renderCensusMarkdown,
-  renderJudgeTargetedCalibration: () => renderJudgeTargetedCalibration,
-  resolveAdversarialProbeCapability: () => resolveAdversarialProbeCapability,
-  resolveEvalJudge: () => resolveEvalJudge,
-  resolveEvalSession: () => resolveEvalSession,
-  resolveGate2Caps: () => resolveGate2Caps,
-  resolveGateProfileIdentity: () => resolveGateProfileIdentity,
-  resolveJudgeCalibrationMinimum: () => resolveJudgeCalibrationMinimum,
-  resolveJudgeFamilies: () => resolveJudgeFamilies,
-  resolveMarkLabelTargets: () => resolveMarkLabelTargets,
-  resolveMarkedDecisions: () => resolveMarkedDecisions,
-  resolveMinimumGateSet: () => resolveMinimumGateSet,
-  resolveMisdirectionCaps: () => resolveMisdirectionCaps,
-  resolveProductPartition: () => resolveProductPartition2,
-  resolveReplayPlanner: () => resolveReplayPlanner,
-  resolveReplayProfileDeclaration: () => resolveReplayProfileDeclaration,
-  resolveReplayProfileFingerprint: () => resolveReplayProfileFingerprint,
-  resolveTargetEnvironmentForProduct: () => resolveTargetEnvironmentForProduct,
-  runAdversarialVerb: () => runAdversarialVerb,
-  runCalibrateVerb: () => runCalibrateVerb,
-  runCanaryAblation: () => runCanaryAblation,
-  runCensusVerb: () => runCensusVerb,
-  runExtractVerb: () => runExtractVerb,
-  runFeedbackStaging: () => runFeedbackStaging,
-  runFloorVerb: () => runFloorVerb,
-  runGateVerb: () => runGateVerb,
-  runJudgeCalibrateVerb: () => runJudgeCalibrateVerb,
-  runMisdirectionCheck: () => runMisdirectionCheck,
-  runReplayGate: () => runReplayGate,
-  runReplayGateVerb: () => runReplayGateVerb,
-  runReplayVerb: () => runReplayVerb,
-  runReportVerb: () => runReportVerb,
-  runRetireAdversarialVerb: () => runRetireAdversarialVerb,
-  runSafetyScope: () => runSafetyScope,
-  runSeedFromFeedbackVerb: () => runSeedFromFeedbackVerb,
-  runSeedVerb: () => runSeedVerb,
-  selectGateSet: () => selectGateSet,
-  selectedEvalJudgeNames: () => selectedEvalJudgeNames,
-  serializeReplayGateReceipt: () => serializeReplayGateReceipt,
-  slugBranch: () => slugBranch2
-});
-import { GATE2_DEFAULT_MAX_LOWER_TRUST_PER_SCOPE } from "@vostride/agent-qa-schema";
-import { resolveKnowledgeRoot as resolveKnowledgeRoot2 } from "@vostride/agent-qa-core";
-import { createHash as createHash2, randomBytes } from "crypto";
-import { existsSync as existsSync4, lstatSync as lstatSync2, readFileSync as readFileSync5, readdirSync as readdirSync4, realpathSync as realpathSync2 } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import { dirname as dirname11, isAbsolute as isAbsolute2, join as join9, relative, resolve as resolve6 } from "path";
-import {
-  HANDOFF_FILE,
-  RUNS_SUBDIR,
-  loadCompletedRunHandoff,
-  slugBranch
-} from "@vostride/agent-qa-runner-local";
-import {
-  assertBaselineComparator,
-  buildEvalReport,
-  buildSeedingPlan,
-  admitSeedMember,
-  canonicalJson as canonicalJson5,
-  composeBaselineProfileKey,
-  computeBatchKey,
-  computeCorpusDigest,
-  createPanelIdentity,
-  decisionCorrectnessVectors,
-  deriveCensus,
-  renderCensusMarkdown,
-  EXCLUSION_CLASSES,
-  extractRunCassettes,
-  FLOOR_PROTOCOL_MINIMUM,
-  guardClassifierRepeatability,
-  guardCampaignManifest,
-  JUDGE_CONFIG,
-  judgeIdentitySchema,
-  maskCorpusText,
-  partitionParamsOf,
-  projectBaselinePointer,
-  projectDecisionVectorsDocument,
-  projectPartitionManifest,
-  projectRunExclusion,
-  renderBaselineComparatorRefusal,
-  renderFloorRefusal,
-  resolveJudgeFamily,
-  resolveProductPartition,
-  SEED_POLICIES
-} from "@vostride/agent-qa-eval";
-import {
-  COMMITTED_CASSETTES_DIR,
-  DEFAULT_EVAL_CASSETTES_SUBDIR,
-  DEFAULT_EVAL_REPLAYS_SUBDIR,
-  DEFAULT_EVAL_REPORTS_SUBDIR,
-  FloorProtocolError,
-  FsCassetteStore,
-  FsReplayRecordStore,
-  FsReportStore,
-  readReportProfileProof,
-  FsRunArtifactSource,
-  FsScoreStore,
-  assembleScoredBatch,
-  copyJudgeCalibrationToReport,
-  readJudgeCalibration,
-  ablateCanaryStep,
-  locateTargetCassettes,
-  GATE2_AUDIT_SUBDIR,
-  isNovelState,
-  stageFeedbackEntry,
-  admitStagedFeedback,
-  ADVERSARIAL_STAGING_SUBDIR,
-  listStagedAdversarial,
-  refreshAdversarialSplit,
-  retireStagedAdversarialBatch,
-  resolveAdversarialProbeCallCap,
-  resolveAdversarialSeedCap,
-  stageAdversarialProposal,
-  FEEDBACK_STAGING_SUBDIR,
-  readCommittedCorpusDigest,
-  readProbeAttempt,
-  cassetteProductPartition,
-  commitCensus,
-  commitEvalReport,
-  committedExclusionPath,
-  committedNoiseFloorPath,
-  committedPartitionManifestPath,
-  computeReplayProfileFingerprintFor,
-  listBaselinePointers,
-  listCommittedReports,
-  listNoiseFloorArtefacts,
-  loadCassetteBundles,
-  loadLabelEvidence,
-  loadReplayRecord,
-  loadScoreRecord,
-  readCommittedCorpus,
-  readActiveCommittedCorpus,
-  readPartitionManifests,
-  readRunExclusions,
-  replayJudgeRequest,
-  runNoiseFloorMeasurement,
-  runReleaseGate,
-  runLabelCalibration,
-  runJudgeCalibration,
-  maskJudgeCalibrationText,
-  seedCommittedCorpus,
-  sweepCassetteReplays,
-  writeBaselinePointer,
-  writePartitionManifest,
-  writeRunExclusion
-} from "@vostride/agent-qa-eval-local";
-import { runSafetyScope as runSafetyScope2 } from "@vostride/agent-qa-safety-local";
-import {
-  ANALYSIS_FILE,
-  admitAnalysisArtifactForRun,
-  guardRunAnalysisArtifact,
-  resolveRunVerdicts,
-  sha256hex as sha256hex3
-} from "@vostride/agent-qa-schema";
-import {
-  LOCAL_CURATION_CAPABILITIES as LOCAL_CURATION_CAPABILITIES3,
-  resolveRunExecutionContext
-} from "@vostride/agent-qa-agent-local";
-import { renderBaselineComparatorRefusal as renderBaselineComparatorRefusal2, SEED_POLICIES as SEED_POLICIES2 } from "@vostride/agent-qa-eval";
-import { computeCorpusDigest as computeCorpusDigest2, selectGateSet } from "@vostride/agent-qa-eval";
-import { judgeCapabilityOf } from "@vostride/agent-qa-eval";
-import { readActiveCommittedCorpus as readActiveCommittedCorpus2, readCommittedCorpus as readCommittedCorpus2, readGatePostureFor, resolveMinimumGateSet } from "@vostride/agent-qa-eval-local";
-import {
-  assessPanelEligibility,
-  judgeFamiliesIntersect,
-  resolveJudgeFamilies,
-  resolveJudgeCalibrationMinimum
-} from "@vostride/agent-qa-eval";
-import { projectMatcherConfigContract } from "@vostride/agent-qa-eval";
-import { runReplayGate, serializeReplayGateReceipt, readLabelCalibration, readCalibrationGoldIdentity } from "@vostride/agent-qa-eval-local";
-import { listStagedAdversarial as listStagedAdversarial2, readAdversarialRefreshRecords } from "@vostride/agent-qa-eval-local";
-import { canonicalJson as canonicalJson6, markedDecisionCount, previewMarkLabels, resolveMarkLabelTargets, resolveMarkedDecisions, resolveProductPartition as resolveProductPartition2 } from "@vostride/agent-qa-eval";
-import { FsHandoffSource, FsMarkLedger, MARK_INTENT_FILE, MarkLedgerCorruptError, freezeGoldenTrajectory, latestMarkReceiptFor } from "@vostride/agent-qa-eval-local";
-import { HANDOFF_FILE as HANDOFF_FILE2, RUNS_SUBDIR as RUNS_SUBDIR2, slugBranch as slugBranch2 } from "@vostride/agent-qa-runner-local";
-import { runSafetyScope } from "@vostride/agent-qa-safety-local";
-import { createModel as createModel3 } from "@vostride/agent-qa-model";
-import { NO_PROBE_MODEL_REASONS, renderAdversarialProbePrompt } from "@vostride/agent-qa-eval";
-function selectedEvalJudgeNames(config) {
-  if (config.judge !== void 0 && config.judges !== void 0) {
-    throw new EvalJudgeDeclarationError("Set either eval.judge or eval.judges, never both; remove one declaration.");
-  }
-  if (config.judge !== void 0 && typeof config.judge !== "string") {
-    throw new EvalJudgeDeclarationError("eval.judge must be one nonempty registry name; use eval.judges for a list.");
-  }
-  const names = config.judge !== void 0 ? [config.judge] : config.judges === void 0 ? [] : config.judges;
-  if (!Array.isArray(names) || Array.from(names).some((name) => typeof name !== "string" || name.trim().length === 0)) {
-    throw new EvalJudgeDeclarationError("eval.judges must be an array of nonempty registry names.");
-  }
-  if (names.length > JUDGE_CONFIG.maxPanelMembers) {
-    throw new EvalJudgeDeclarationError(`Choose at most ${JUDGE_CONFIG.maxPanelMembers} explicit judge names.`);
-  }
-  return [...names];
-}
-function withJudgeOverrides(judge, modelOverrides) {
-  if (judge === void 0 || modelOverrides === void 0) return judge;
-  return "members" in judge ? { ...judge, members: judge.members.map((member) => ({ ...member, modelOverrides })) } : { ...judge, modelOverrides };
-}
-async function resolveEvalSession(input = {}) {
-  const configPath = input.configPath ?? "agent-qa.config.yaml";
-  const configDir = dirname11(resolve6(configPath));
-  const raw = await loadConfigFile(configPath);
-  if (raw?.eval && typeof raw.eval === "object") selectedEvalJudgeNames(raw.eval);
-  const config = await resolveConfig({ configPath, loadAuthPlugins: input.keyOnly !== true });
-  const evalConfig = mergeEvalConfig(config.eval, input.flags);
-  if (input.keyOnly === true) {
-    return {
-      config,
-      configPath,
-      configDir,
-      evalConfig,
-      mask: () => {
-        throw new Error("A key-only eval session has no declared secrets to mask with");
-      },
-      executionContext: resolveRunExecutionContext()
-    };
-  }
-  const secretStore = await loadEvalSecretStore(config, configDir);
-  const { SecretRedactor: SecretRedactor2 } = await import("@vostride/agent-qa-runner");
-  const redactor = new SecretRedactor2(secretStore);
-  return {
-    config,
-    configPath,
-    configDir,
-    evalConfig,
-    mask: (text) => redactor.redactString(text),
-    executionContext: resolveRunExecutionContext()
-  };
-}
-function committedCorpusMask(session) {
-  const declared = createDeclaredSecretMask(session.configPath);
-  declared.redactor();
-  return declared.mask;
-}
-async function runExtractVerb(session, filters = {}) {
-  return await runSafetyScope2(
-    { executionContext: session.executionContext },
-    async () => sweepAndExtract(resolve6(session.configDir, ".agent-qa"), filters)
-  );
-}
-function sweepAndExtract(agentQaRoot, filters) {
-  const runsRoot = resolve6(agentQaRoot, RUNS_SUBDIR);
-  let runSlugs = listRunSlugsWithHandoff(runsRoot);
-  if (filters.run !== void 0) {
-    const named = filters.run;
-    runSlugs = runSlugs.filter((slug) => slug === named || slug === slugBranch(named));
-    if (runSlugs.length === 0) {
-      throw new EvalNamedInputError("run", named, runsRoot);
-    }
-  }
-  const store = new FsCassetteStore({ root: agentQaRoot });
-  const runsSkipped = [];
-  const completeness = {};
-  let runsFiltered = 0;
-  let cassettesWritten = 0;
-  for (const runSlug of runSlugs) {
-    let extraction;
-    try {
-      const handoff = loadCompletedRunHandoff(resolve6(runsRoot, runSlug, HANDOFF_FILE));
-      if (filters.product !== void 0 && resolveProductPartition(handoff.scope) !== filters.product) {
-        runsFiltered++;
-        continue;
-      }
-      extraction = extractRunCassettes({
-        handoff,
-        artifacts: new FsRunArtifactSource({ root: agentQaRoot, runId: handoff.runId })
-      });
-    } catch (err) {
-      runsSkipped.push({ runSlug, reason: err instanceof Error ? err.message : String(err) });
-      continue;
-    }
-    for (const extracted of extraction.cassettes) {
-      store.write(extracted);
-      cassettesWritten++;
-    }
-    for (const emitted of extraction.report.emitted) {
-      bumpCounter(completeness, emitted.completenessStatus);
-    }
-    for (const skip of extraction.report.skips) {
-      bumpCounter(completeness, skip.reason);
-    }
-  }
-  return {
-    runsSwept: runSlugs.length,
-    runsSkipped,
-    runsFiltered,
-    cassettesWritten,
-    completeness,
-    cassettesRoot: resolve6(agentQaRoot, DEFAULT_EVAL_CASSETTES_SUBDIR)
-  };
-}
-function listRunSlugsWithHandoff(runsRoot) {
-  let entries;
-  try {
-    entries = readdirSync4(runsRoot, { withFileTypes: true });
-  } catch (err) {
-    if (err.code === "ENOENT") return [];
-    throw err;
-  }
-  return entries.filter((entry) => entry.isDirectory() && existsSync4(resolve6(runsRoot, entry.name, HANDOFF_FILE))).map((entry) => entry.name).sort();
-}
-function bumpCounter(counters, key) {
-  counters[key] = (counters[key] ?? 0) + 1;
-}
-function resolveCassettesRoot(session, source) {
-  if (source === "committed") {
-    const cassettesRoot = join9(
-      resolve6(session.configDir, "agent-qa-eval"),
-      COMMITTED_CASSETTES_DIR
-    );
-    return { cassettesRoot, notice: `cassette source: committed root ${cassettesRoot}` };
-  }
-  return {
-    cassettesRoot: join9(resolve6(session.configDir, ".agent-qa"), DEFAULT_EVAL_CASSETTES_SUBDIR)
-  };
-}
-function replayInvocationSpend(entries, seed, modelCalls, started, calibration) {
-  const report = buildEvalReport(entries, void 0, void 0, { declaredSeed: seed, calibration });
-  const cost = report.totalCost;
-  const judgeCost = report.honesty.judge.cost;
-  return {
-    seed: seed ?? null,
-    seedHonored: cost.sampleCount === 0 ? null : report.seedHonored ?? null,
-    decisions: report.headline.perDecisionCost.decisionCount,
-    modelCalls,
-    promptTokens: cost.promptTokens + judgeCost.inputTokens,
-    completionTokens: cost.completionTokens + judgeCost.outputTokens,
-    wallClockMs: Math.max(0, Math.round(performance.now() - started)),
-    sampleCount: cost.sampleCount,
-    samplesMissingTokenUsage: cost.samplesMissingTokenUsage,
-    judgeCost
-  };
-}
-async function runReplayVerb(session, filters = {}, opts = {}) {
-  const started = performance.now();
-  const agentQaRoot = resolve6(session.configDir, ".agent-qa");
-  const source = opts.source ?? "staged";
-  const sourceRoot = resolveCassettesRoot(session, source);
-  const cassettesRoot = sourceRoot.cassettesRoot;
-  const replaysRoot = join9(agentQaRoot, DEFAULT_EVAL_REPLAYS_SUBDIR);
-  const { swept, loaded, loadRefusals } = loadCassetteBundles(cassettesRoot);
-  const activeCorpus = readActiveCommittedCorpus(resolve6(session.configDir, "agent-qa-eval"), agentQaRoot);
-  const activeIds = source !== "committed" ? void 0 : new Set(activeCorpus.snapshot.entries.map((entry) => entry.cassetteId));
-  let selected = activeIds === void 0 ? loaded : loaded.filter((entry) => activeIds.has(entry.cassette.id));
-  if (filters.cassette !== void 0) {
-    const named = filters.cassette;
-    selected = selected.filter((entry) => entry.cassette.id === named);
-    if (selected.length === 0) {
-      throw new EvalNamedInputError("cassette", named, cassettesRoot, "replay");
-    }
-  }
-  if (filters.run !== void 0) {
-    const named = filters.run;
-    selected = selected.filter((entry) => {
-      const head = entry.cassette.id.split("/")[0];
-      return head === named || head === slugBranch(named);
-    });
-    if (selected.length === 0) {
-      throw new EvalNamedInputError("run", named, cassettesRoot, "replay");
-    }
-  }
-  if (filters.product !== void 0) {
-    const named = filters.product;
-    selected = selected.filter((entry) => cassetteProductPartition(entry.cassette) === named);
-  }
-  selected.sort((a, b) => a.cassette.id < b.cassette.id ? -1 : a.cassette.id > b.cassette.id ? 1 : 0);
-  const notices = [];
-  if (sourceRoot.notice !== void 0) notices.push(sourceRoot.notice);
-  notices.push(...activeCorpus.refusals.map((refusal) => `committed read refused ${refusal.path}: ${refusal.reason}`));
-  const zeroJudge = (configured) => ({
-    configured,
-    invoked: 0,
-    settled: 0,
-    abstained: 0,
-    errors: 0,
-    notInvoked: 0
-  });
-  if (selected.length === 0) {
-    notices.push(`empty sweep \u2014 no ${source} cassette bundles matched`);
-    return {
-      batchKey: "empty",
-      swept,
-      replayed: 0,
-      loadRefusals,
-      replayRefusals: {},
-      scored: 0,
-      judge: zeroJudge(selectedEvalJudgeNames(session.evalConfig).length > 0),
-      replaysRoot,
-      source,
-      notices,
-      spend: replayInvocationSpend([], session.evalConfig.seed, 0, started, activeCorpus?.calibration)
-    };
-  }
-  const batchKey = computeBatchKey(selected.map((entry) => entry.cassette.id));
-  const planner = await resolveReplayPlanner(session);
-  const judgeResolution = await resolveEvalJudge(session);
-  if (judgeResolution.notice !== void 0) notices.push(judgeResolution.notice);
-  const recordStore = new FsReplayRecordStore({ root: agentQaRoot });
-  const scoreStore = new FsScoreStore({ root: agentQaRoot });
-  let modelCalls = 0;
-  const { replayed, replayRefusals, replayedDirs, notices: replayNotices } = await sweepCassetteReplays({
-    selected,
-    labelRecords: activeCorpus?.snapshot.labelsById,
-    profile: planner.profile,
-    auth: planner.auth,
-    modelCallObservation: { onProviderCall: () => {
-      modelCalls++;
-    } },
-    ...opts.plannerOverrides !== void 0 ? { modelOverrides: opts.plannerOverrides } : {},
-    ...session.evalConfig.k !== void 0 ? { k: session.evalConfig.k } : {},
-    ...session.evalConfig.seed !== void 0 ? { seed: session.evalConfig.seed } : {},
-    ...judgeResolution.judge !== void 0 ? {
-      judge: withJudgeOverrides(judgeResolution.judge, opts.judgeOverrides)
-    } : {},
-    mask: session.mask,
-    recordStore,
-    scoreStore,
-    replaysRoot,
-    // Progress ALWAYS rides stderr — stdout stays reserved for the rendered DTO.
-    onProgress: (id) => process.stderr.write(`replay: ${id}
-`)
-  });
-  notices.push(...replayNotices);
-  const judge = zeroJudge(judgeResolution.judge !== void 0);
-  let scored = 0;
-  for (const recordDir of replayedDirs) {
-    const replay = loadReplayRecord(recordDir);
-    const load = loadScoreRecord(recordDir);
-    if (replay.kind !== "loaded") {
-      notices.push(`spend replay read refused under ${recordDir}: ${replay.refusal.detail}`);
-    }
-    if (load.kind === "absent") continue;
-    if (load.kind === "refused") {
-      notices.push(`score read refused under ${recordDir}: ${load.refusal.detail}`);
-      continue;
-    }
-    scored++;
-    foldJudgeDispositions(load.record.score, judge);
-  }
-  const spendBatch = assembleScoredBatch({
-    replaysRoot,
-    cassettesRoot,
-    source,
-    recordDirs: replayedDirs,
-    labelRecords: activeCorpus?.snapshot.labelsById,
-    corpusEntriesById: source === "committed" ? activeCorpus.corpusEntriesById : void 0,
-    excludedLabelIds: activeCorpus?.snapshot.excludedLabelIds,
-    calibration: activeCorpus?.calibration
-  });
-  notices.push(...spendBatch.notices);
-  return {
-    batchKey,
-    swept,
-    replayed,
-    loadRefusals,
-    replayRefusals,
-    scored,
-    judge,
-    replaysRoot,
-    source,
-    notices,
-    spend: replayInvocationSpend(spendBatch.entries, session.evalConfig.seed, modelCalls, started, spendBatch.calibration)
-  };
-}
-function foldJudgeDispositions(score, judge) {
-  const entries = score.kind === "leaf" ? [score.entry] : score.kind === "procedure" ? score.entries : [];
-  for (const entry of entries) {
-    if (entry.kind !== "decision") continue;
-    const decision = entry.score;
-    if (decision.kind === "unresolved-tie") {
-      const outcome = decision.judgeOutcome;
-      if (outcome === void 0) continue;
-      if (outcome.kind === "abstained") {
-        judge.abstained++;
-        judge.invoked++;
-      } else if (outcome.kind === "judge-error") {
-        judge.errors++;
-        judge.invoked++;
-      } else {
-        judge.notInvoked++;
-      }
-    } else if (decision.kind === "scored" && decision.judgeSettled !== void 0) {
-      judge.settled++;
-      judge.invoked++;
-    }
-  }
-}
-async function resolveEvalJudge(session) {
-  const names = selectedEvalJudgeNames(session.evalConfig);
-  if (names.length === 0) {
-    return {
-      notice: "no judge configured \u2014 unresolved ties will record not-invoked{no-judge-configured}"
-    };
-  }
-  if (names.length > 1) {
-    const members = [];
-    for (const name of names) members.push(await resolveNamedProfile(name, session.configPath));
-    return { judge: { members }, ...session.evalConfig.judgeAllowSameFamily === true ? { notice: "eval.judgeAllowSameFamily is ignored for a composite judge panel; every member must be disjoint." } : {} };
-  }
-  const resolved = await resolveNamedProfile(names[0], session.configPath);
-  const planner = await resolveReplayPlanner(session);
-  const judgeFamily = resolveJudgeFamily(resolved.profile.model);
-  const plannerFamily = resolveJudgeFamily(planner.profile.model);
-  const overrideActive = session.evalConfig.judgeAllowSameFamily === true;
-  const judge = overrideActive ? { ...resolved, allowSameFamily: true } : resolved;
-  if (judgeFamily !== void 0 && plannerFamily !== void 0 && judgeFamily === plannerFamily && overrideActive) {
-    return {
-      judge,
-      notice: `D-10 override active (eval.judgeAllowSameFamily, owner decision 2026-07-12): judge model "${resolved.profile.model}" and planner model "${planner.profile.model}" share the judge family '${judgeFamily}' \u2014 same-family judging runs and every scored entry discloses familyOverride: same-family-allowed`
-    };
-  }
-  if (judgeFamily === void 0 || plannerFamily === void 0 || judgeFamily === plannerFamily) {
-    return {
-      judge,
-      notice: `judge model "${resolved.profile.model}" and planner model "${planner.profile.model}" resolve to the same or unknown family \u2014 per-cassette judge eligibility will refuse self-judging and ties may record not-invoked`
-    };
-  }
-  return { judge };
-}
-async function resolveReplayPlanner(session) {
-  const plannerName = session.config.use?.llm;
-  if (!plannerName) {
-    throw new Error(
-      "use.llm is not set in the config \u2014 the replay planner is the named use.llm registry entry. Set use.llm in agent-qa.config.yaml."
-    );
-  }
-  return resolveNamedProfile(plannerName, session.configPath);
-}
-async function runJudgeCalibrateVerb(session, opts = {}) {
-  if (opts.replace && !opts.commit) return { kind: "refused", reason: "--replace requires --commit." };
-  const preflight = await preflightJudgePanel(session, { minN: opts.minN });
-  if (preflight.kind === "capability-gap" && !preflight.identity) return {
-    ...await runJudgeCalibration({
-      kind: "capability-gap",
-      reason: preflight.reason,
-      minN: preflight.minN,
-      commit: opts.commit,
-      replace: opts.replace
-    }),
-    entries: preflight.entries
-  };
-  const replayProfile = preflight.kind === "eligible" ? preflight.replayProfile : await resolveReplayProfileDeclaration(session);
-  const fingerprint = computeReplayProfileFingerprintFor({
-    profile: replayProfile,
-    seedPolicy: "declared"
-  });
-  const context = {
-    committedRoot: resolve6(session.configDir, "agent-qa-eval"),
-    agentQaRoot: resolve6(session.configDir, ".agent-qa"),
-    // Saved evidence must prove this actual planner/profile; judging does not rerun a planner.
-    profile: {
-      plannerModelId: replayProfile.model,
-      fingerprint,
-      matcherVersion: (await import("@vostride/agent-qa-eval")).projectMatcherConfigContract().version,
-      judgeModelId: preflight.identity.judgeModelId,
-      judgeVersion: preflight.identity.judgeVersion
-    },
-    identity: preflight.identity,
-    minN: preflight.minN
-  };
-  const result = await runJudgeCalibration(preflight.kind === "eligible" ? { kind: "probe", commit: opts.commit, replace: opts.replace, probe: {
-    ...context,
-    replayProfile,
-    members: preflight.members.map((member) => ({ ...member, modelOverrides: opts.judgeOverrides })),
-    mask: session.mask
-  } } : {
-    kind: "capability-gap",
-    reason: preflight.reason,
-    minN: preflight.minN,
-    publication: context,
-    commit: opts.commit,
-    replace: opts.replace
-  });
-  return maskJudgeCalibrationText({ ...result, entries: preflight.entries }, session.mask);
-}
-function renderJudgeTargetedCalibration(disclosure) {
-  if (disclosure === void 0) {
-    return ["judge-targeted adversarial bait: not recorded (this artifact predates the disclosure)"];
-  }
-  if (disclosure.source === "unavailable") {
-    return [`judge-targeted adversarial bait: not determined (${disclosure.reason})`];
-  }
-  const lines = [
-    `judge-targeted adversarial bait: judge-targeted=${disclosure.judgeTargeted} self-authored-by-this-panel=${disclosure.selfAuthored} observed-in-measured-population=${disclosure.observedInCalibration}`,
-    `adversarial provenance: model-authored=${disclosure.byProvenance.probe} table-derived=${disclosure.byProvenance.table} legacy-unattributed=${disclosure.byProvenance.absent} malformed=${disclosure.byProvenance.malformed} unresolved=${disclosure.metadataUnavailable} of ${disclosure.total} committed members (arms are counted apart, never summed)`
-  ];
-  for (const row of disclosure.byAuthoringModel) {
-    lines.push(`author ${row.authoringModel} (${row.authoringFamily})${row.panelMember ? " [panel member \u2014 self-authored]" : ""}: judge-targeted=${row.judgeTargeted} authored=${row.probeAuthored}`);
-  }
-  lines.push("Bait counts above are RAW: the agreement, interval, per-member rows and minN are not adjusted for them.");
-  return lines;
-}
-async function runCalibrateVerb(session, opts = {}) {
-  const minGold = opts.minGold ?? LABEL_CALIBRATION_MIN_GOLD;
-  if (!Number.isSafeInteger(minGold) || minGold < 2) {
-    return { kind: "refused", reason: "--min-gold must be a safe integer of at least 2." };
-  }
-  if (opts.replace && !opts.commit) return { kind: "refused", reason: "--replace requires --commit." };
-  const result = await runLabelCalibration({
-    committedRoot: resolve6(session.configDir, "agent-qa-eval"),
-    agentQaRoot: resolve6(session.configDir, ".agent-qa"),
-    commit: opts.commit,
-    replace: opts.replace,
-    minGold: { value: minGold, source: opts.minGold === void 0 ? "default" : "cli" }
-  });
-  if ("artifact" in result) return result;
-  const reasons = {
-    refused: "Calibration inputs unavailable or invalid; inspect committed labels and run evidence.",
-    busy: "Another calibration publisher holds the lock; retry after it finishes.",
-    "input-drift": "Calibration inputs changed; retry from the current snapshot.",
-    "publication-failed": "Calibration publication interrupted; retry the identical command.",
-    "write-conflict": "Calibration bytes conflict; review the dry-run, then use --commit --replace to replace the marker. Immutable revision conflicts require inspection."
-  };
-  return { kind: result.kind, reason: reasons[result.kind] };
-}
-function resolveGate2Caps(session, opts = {}) {
-  const maxAblations = opts.maxAblations ?? session.evalConfig.gate2?.maxAblations ?? GATE2_DEFAULT_MAX_ABLATIONS;
-  if (!Number.isSafeInteger(maxAblations) || maxAblations < 1) {
-    throw new TypeError("--max-ablations must be a positive integer");
-  }
-  const maxAblationsSource = opts.maxAblations !== void 0 ? "flag" : session.evalConfig.gate2?.maxAblations !== void 0 ? "config" : "default";
-  const canaryHorizonBuilds = session.evalConfig.gate2?.canaryHorizonBuilds ?? GATE2_DEFAULT_CANARY_HORIZON_BUILDS;
-  const maxLowerTrustPerScope = session.evalConfig.gate2?.maxLowerTrustPerScope ?? GATE2_DEFAULT_MAX_LOWER_TRUST_PER_SCOPE;
-  for (const [name, value] of Object.entries({ canaryHorizonBuilds, maxLowerTrustPerScope })) {
-    if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`eval.gate2.${name} must be a positive integer`);
-  }
-  return {
-    maxAblations,
-    maxAblationsSource,
-    canaryHorizonBuilds,
-    maxLowerTrustPerScope,
-    canaryHorizonBuildsSource: session.evalConfig.gate2?.canaryHorizonBuilds === void 0 ? "default" : "config",
-    maxLowerTrustPerScopeSource: session.evalConfig.gate2?.maxLowerTrustPerScope === void 0 ? "default" : "config"
-  };
-}
-function readCanaryCorpusDigest(session) {
-  const committedRoot = resolve6(session.configDir, "agent-qa-eval");
-  try {
-    lstatSync2(committedRoot);
-  } catch (error) {
-    return error.code === "ENOENT" ? { kind: "no-eval-root" } : { kind: "unavailable", reason: error instanceof Error ? error.message : String(error) };
-  }
-  return readCommittedCorpusDigest({ committedRoot });
-}
-async function runCanaryAblation(session, input) {
-  const committedRoot = resolve6(session.configDir, "agent-qa-eval");
-  const digest2 = readCanaryCorpusDigest(session);
-  if (digest2.kind !== "digest") return digest2;
-  const k = input.k ?? session.evalConfig.k ?? GATE1_DEFAULT_K;
-  if (!Number.isSafeInteger(k) || k < 3 || k % 2 === 0) {
-    throw new TypeError("--k must be an odd integer of at least 3");
-  }
-  const identity = await resolveGateProfileIdentity(session, input.plannerOverrides);
-  const floor = listNoiseFloorArtefacts(committedRoot).artefacts.find(
-    (entry) => entry.artefact.profileKey === identity.profileKey
-  )?.artefact;
-  const baseSeed = input.seed ?? session.evalConfig.seed ?? floor?.seeds[0] ?? 11;
-  const execution = await resolveEvalSession({ configPath: session.configPath });
-  const planner = await resolveReplayPlanner(execution);
-  return ablateCanaryStep({
-    agentQaRoot: input.agentQaRoot,
-    committedRoot,
-    recordId: input.recordId,
-    target: input.target,
-    attributedObservationId: input.attributedObservationId,
-    k,
-    baseSeed,
-    replay: {
-      profile: planner.profile,
-      auth: planner.auth,
-      modelOverrides: input.plannerOverrides,
-      mask: execution.mask
-    }
-  });
-}
-async function readMisdirectionRootPosture(session) {
-  const digest2 = readCanaryCorpusDigest(session);
-  const floorless = !hasNoiseFloorArtefacts(resolve6(session.configDir, "agent-qa-eval"));
-  if (digest2.kind === "no-eval-root" || floorless) return { kind: "no-eval-root" };
-  if (digest2.kind !== "digest") return { kind: "broken-eval-root", reason: "eval-root-unreadable" };
-  const identity = await resolveGateProfileIdentity(session);
-  return {
-    kind: "eval-root",
-    corpusDigest: digest2.corpusDigest,
-    profileDigest: sha256hex3(identity.profileKey)
-  };
-}
-function resolveMisdirectionCaps(_session, opts = {}) {
-  const maxChecks = opts.maxChecks ?? ATTR_DEFAULT_MAX_MISDIRECTION_CHECKS;
-  if (!Number.isSafeInteger(maxChecks) || maxChecks < 0) {
-    throw new TypeError("--max-misdirection-checks must be a non-negative integer");
-  }
-  return { maxChecks, source: opts.maxChecks === void 0 ? "default" : "flag" };
-}
-async function locateMisdirectionDecision(session, target) {
-  const committedRoot = resolve6(session.configDir, "agent-qa-eval");
-  const corpus = readCommittedCorpus(committedRoot);
-  const located = await locateTargetCassettes({
-    committedRoot,
-    agentQaRoot: target.agentQaRoot,
-    gate1Dir: misdirectionAuditDir(target),
-    corpusEntries: corpus.snapshot.entries,
-    target: { runId: target.runId, testId: target.testId, stepIndex: target.stepIndex },
-    source: "handoff"
-  });
-  if (located.kind === "unavailable") {
-    return { kind: "unavailable", reason: located.detail.reason ?? "target-unavailable" };
-  }
-  if (located.cassettes.length !== 1) {
-    return { kind: "unavailable", reason: "ambiguous live step: multiple recorded decisions" };
-  }
-  return { kind: "located", decisionOrdinal: located.cassettes[0].cassette.decisionOrdinal };
-}
-async function runMisdirectionCheck(session, input) {
-  const committedRoot = resolve6(session.configDir, "agent-qa-eval");
-  const digest2 = readCanaryCorpusDigest(session);
-  if (digest2.kind !== "digest") {
-    return { kind: "unavailable", reason: digest2.kind === "no-eval-root" ? "no-eval-root" : digest2.reason };
-  }
-  const k = session.evalConfig.k ?? GATE1_DEFAULT_K;
-  if (!Number.isSafeInteger(k) || k < 3 || k % 2 === 0) {
-    throw new TypeError("eval.k must be an odd integer of at least 3");
-  }
-  const identity = await resolveGateProfileIdentity(session);
-  const floor = listNoiseFloorArtefacts(committedRoot).artefacts.find(
-    (entry) => entry.artefact.profileKey === identity.profileKey
-  )?.artefact;
-  const baseSeed = session.evalConfig.seed ?? floor?.seeds[0] ?? 11;
-  const execution = await resolveEvalSession({ configPath: session.configPath });
-  const planner = await resolveReplayPlanner(execution);
-  const result = await ablateCanaryStep({
-    agentQaRoot: input.agentQaRoot,
-    committedRoot,
-    recordId: input.recordId,
-    target: { runId: input.runId, testId: input.testId, stepIndex: input.stepIndex },
-    attributedObservationId: misdirectionAuditKey(input),
-    k,
-    baseSeed,
-    admission: { failingPathCandidate: input.authorization },
-    replay: {
-      profile: planner.profile,
-      auth: planner.auth,
-      mask: execution.mask
-    }
-  });
-  if (result.kind !== "ablated") return { kind: "unavailable", reason: result.reason };
-  return {
-    kind: "checked",
-    crossCheck: result.crossCheck,
-    seedHonored: result.seedHonored,
-    samples: { k: result.k, seeds: [...result.seeds], modelCalls: result.spend.modelCalls }
-  };
-}
-function misdirectionAuditKey(target) {
-  return `misdirection/${slugBranch(target.runId)}/${slugBranch(target.testId)}/${String(target.stepIndex)}${target.recordId === void 0 ? "" : `/${slugBranch(target.recordId)}`}`;
-}
-function misdirectionAuditDir(target) {
-  return join9(target.agentQaRoot, GATE2_AUDIT_SUBDIR, slugBranch(misdirectionAuditKey(target)));
-}
-function isFeedbackStateNovel(session, input) {
-  const digest2 = readCanaryCorpusDigest(session);
-  if (digest2.kind === "no-eval-root") return false;
-  if (digest2.kind !== "digest") throw new TypeError("feedback corpus unavailable");
-  return isNovelState({ ...input, committedRoot: resolve6(session.configDir, "agent-qa-eval") });
-}
-async function runFeedbackStaging(session, input) {
-  const digest2 = readCanaryCorpusDigest(session);
-  if (digest2.kind !== "digest") return digest2;
-  return stageFeedbackEntry({
-    ...input,
-    committedRoot: resolve6(session.configDir, "agent-qa-eval"),
-    mask: committedCorpusMask(session)
-  });
-}
-async function runSeedFromFeedbackVerb(session, opts) {
-  const stagingDir = join9(opts.agentQaRoot, FEEDBACK_STAGING_SUBDIR);
-  const configArg = `'${resolve6(session.configPath).replaceAll("'", `'"'"'`)}'`;
-  const floorCommand = `agent-qa --config ${configArg} eval floor`;
-  const base = { entries: [], refusals: [], staleReceipts: [], writesStarted: false, failures: [], stagingDir, floorCommand };
-  const digest2 = readCanaryCorpusDigest(session);
-  if (digest2.kind !== "digest") {
-    const reason = digest2.kind === "no-eval-root" ? "no-eval-root" : "corpus-unavailable";
-    return { ...base, kind: "refused", reason, failures: [{ phase: "before-write", reason }] };
-  }
-  try {
-    const receipts = opts.knowledgeRoot !== void 0 && opts.readStandingGateReceipts !== void 0 ? opts.readStandingGateReceipts({ knowledgeRoot: opts.knowledgeRoot }) : [];
-    const result = await admitStagedFeedback({
-      ...opts,
-      committedRoot: resolve6(session.configDir, "agent-qa-eval"),
-      mask: committedCorpusMask(session)
-    });
-    const selected = opts.dryRun ? result.entries : result.admitted;
-    const entries = selected.map((entry) => ({
-      cassetteId: entry.extracted.cassette.id,
-      product: entry.product,
-      split: "natural",
-      source: "canary-feedback",
-      benefit: entry.benefit,
-      attributedObservationId: entry.attributedObservationId,
-      runId: entry.runId,
-      stepIndex: entry.stepIndex,
-      captured_at_ordinal: entry.extracted.cassette.receipt.buildOrdinal
-    }));
-    const moves = opts.dryRun ? entries.length > 0 : result.nextCorpusDigest === void 0 ? void 0 : result.nextCorpusDigest !== result.previousCorpusDigest;
-    const refused = result.refusals.length > 0 || result.failures.length > 0;
-    return {
-      kind: refused ? "refused" : result.entries.length === 0 ? "nothing-staged" : opts.dryRun ? "dry-run" : "admitted",
-      ...refused ? { reason: "admission-refused" } : {},
-      entries,
-      refusals: result.refusals,
-      writesStarted: result.writesStarted,
-      failures: result.failures,
-      staleReceipts: moves === void 0 ? null : moves ? receipts.filter((receipt) => receipt.corpusDigest === result.previousCorpusDigest) : [],
-      previousCorpusDigest: result.previousCorpusDigest,
-      ...result.nextCorpusDigest === void 0 ? {} : { nextCorpusDigest: result.nextCorpusDigest },
-      stagingDir,
-      floorCommand
-    };
-  } catch {
-    return {
-      ...base,
-      kind: "refused",
-      reason: "feedback-unavailable",
-      failures: [{ phase: "before-write", reason: "feedback-unavailable" }],
-      previousCorpusDigest: digest2.corpusDigest
-    };
-  }
-}
-function authoringModelDisclosureOf(model) {
-  return {
-    idDigest: createHash2("sha256").update(model.id, "utf8").digest("hex"),
-    family: model.family
-  };
-}
-function adversarialHostOptions(session) {
-  return {
-    agentQaRoot: resolve6(session.configDir, ".agent-qa"),
-    knowledgeRoot: resolveKnowledgeRoot2(session.config.knowledge, session.configDir),
-    readStandingGateReceipts: LOCAL_CURATION_CAPABILITIES3.readStandingGateReceipts
-  };
-}
-function runRetireAdversarialVerb(session, opts) {
-  const result = retireStagedAdversarialBatch({
-    agentQaRoot: resolve6(session.configDir, ".agent-qa"),
-    committedRoot: resolve6(session.configDir, "agent-qa-eval"),
-    product: opts.product,
-    batchDigest: opts.batch
-  });
-  return {
-    ...result,
-    modelCalls: 0,
-    admitsNothing: true,
-    settledWorkPreserved: true,
-    newMeasurementStaleness: false
-  };
-}
-async function runAdversarialVerb(session, opts) {
-  const committedRoot = resolve6(session.configDir, "agent-qa-eval");
-  const product = opts.product ?? "default";
-  const stagingDir = join9(opts.agentQaRoot, ADVERSARIAL_STAGING_SUBDIR, slugBranch(product));
-  const configArg = `'${resolve6(session.configPath).replaceAll("'", `'"'"'`)}'`;
-  const floorCommand = `agent-qa --config ${configArg} eval floor`;
-  const cap = resolveAdversarialSeedCap(
-    opts.maxSeeds !== void 0 ? { value: opts.maxSeeds, source: "flag" } : session.evalConfig.adversarial?.maxSeedsPerRefresh !== void 0 ? { value: session.evalConfig.adversarial.maxSeedsPerRefresh, source: "config" } : {}
-  );
-  const probeCap = resolveAdversarialProbeCallCap(
-    opts.maxProbeCalls !== void 0 ? { value: opts.maxProbeCalls, source: "flag" } : session.evalConfig.adversarial?.maxProbeCalls !== void 0 ? { value: session.evalConfig.adversarial.maxProbeCalls, source: "config" } : {}
-  );
-  const base = {
-    kind: "refused",
-    product,
-    stagingDir,
-    staged: [],
-    admitted: [],
-    unchanged: [],
-    remaining: [],
-    refusals: [],
-    settledRefusals: [],
-    stagingSkips: [],
-    skips: [],
-    seedsConsidered: 0,
-    seedsDeferred: 0,
-    eligibleSeeds: 0,
-    cap,
-    writesStarted: false,
-    staleReceipts: [],
-    floorCommand,
-    probeCap,
-    spend: { modelCalls: 0, promptTokens: 0, completionTokens: 0, usageKnown: true },
-    probeSkips: [],
-    probeRefusals: []
-  };
-  const digest2 = readCanaryCorpusDigest(session);
-  if (digest2.kind !== "digest") {
-    const reason = digest2.kind === "no-eval-root" ? "no-eval-root" : "corpus-unavailable";
-    return { ...base, kind: "refused", reason };
-  }
-  if (opts.admit === true) {
-    if (opts.batch === void 0) {
-      return { ...base, kind: "refused", reason: "admit-requires-batch" };
-    }
-    let receipts = [];
-    const refreshed = refreshAdversarialSplit({
-      agentQaRoot: opts.agentQaRoot,
-      committedRoot,
-      product,
-      batchDigest: opts.batch,
-      beforeWrites: () => {
-        receipts = opts.knowledgeRoot !== void 0 && opts.readStandingGateReceipts !== void 0 ? opts.readStandingGateReceipts({ knowledgeRoot: opts.knowledgeRoot }) : [];
-      },
-      ...opts.dryRun === void 0 ? {} : { dryRun: opts.dryRun },
-      mask: committedCorpusMask(session)
-    });
-    const moves = refreshed.nextCorpusDigest === void 0 ? refreshed.writesStarted ? void 0 : false : refreshed.nextCorpusDigest !== refreshed.previousCorpusDigest;
-    return {
-      ...base,
-      kind: refreshed.kind,
-      ...refreshed.reason === void 0 ? {} : { reason: refreshed.reason },
-      batchDigest: refreshed.batchDigest,
-      admitted: refreshed.admitted,
-      unchanged: refreshed.unchanged,
-      remaining: refreshed.remaining,
-      refusals: refreshed.refusals,
-      stagingSkips: refreshed.stagingSkips,
-      writesStarted: refreshed.writesStarted,
-      ...refreshed.retirement === void 0 ? {} : { retirement: refreshed.retirement },
-      ...refreshed.lifecycleBusy === void 0 ? {} : { lifecycleBusy: refreshed.lifecycleBusy },
-      staleReceipts: moves === void 0 ? null : moves ? receipts.filter((receipt) => receipt.corpusDigest === refreshed.previousCorpusDigest) : [],
-      ...refreshed.previousCorpusDigest === void 0 ? {} : { previousCorpusDigest: refreshed.previousCorpusDigest },
-      ...refreshed.nextCorpusDigest === void 0 ? {} : { nextCorpusDigest: refreshed.nextCorpusDigest }
-    };
-  }
-  const probe = await resolveProbeBinding(session, opts, product);
-  const result = await stageAdversarialProposal({
-    agentQaRoot: opts.agentQaRoot,
-    committedRoot,
-    product,
-    ...opts.mutators === void 0 ? {} : { mutators: opts.mutators },
-    // Only a NON-default cap is pushed down: the composition owns the recorded default, and
-    // handing it back an unattributed value would have it record an operator choice nobody made.
-    ...cap.source === "default" ? {} : { maxSeeds: cap.value, maxSeedsSource: cap.source },
-    ...probeCap.source === "default" ? {} : { maxProbeCalls: probeCap.value, maxProbeCallsSource: probeCap.source },
-    ...probe.noProbeModel === void 0 ? {} : { noProbeModel: probe.noProbeModel },
-    // A DRY RUN authors nothing. A preview that spends money is not a preview, and there is no
-    // way to un-spend it once the batch it previewed is discarded.
-    ...probe.author === void 0 || opts.dryRun === true ? {} : { probeAuthor: probe.author, authoringModel: probe.authoringModel },
-    ...opts.dryRun === void 0 ? {} : { dryRun: opts.dryRun }
-  });
-  return {
-    ...base,
-    kind: result.kind,
-    ...result.batchDigest === void 0 ? {} : { batchDigest: result.batchDigest },
-    staged: result.staged,
-    refusals: result.refusals,
-    settledRefusals: result.settledRefusals,
-    stagingSkips: result.stagingSkips,
-    skips: result.skips,
-    seedsConsidered: result.seedsConsidered,
-    seedsDeferred: result.seedsDeferred,
-    eligibleSeeds: result.eligibleSeeds,
-    cap: result.cap,
-    tableVersion: result.tableVersion,
-    tableHash: result.tableHash,
-    previousCorpusDigest: digest2.corpusDigest,
-    // Staging commits nothing, so nothing it does can stale a standing receipt.
-    staleReceipts: [],
-    ...result.noProbeModel === void 0 ? {} : { noProbeModel: result.noProbeModel },
-    // The raw id stays on the binding, where derivation and the committed stamp need it. What
-    // leaves on the result is the family and a digest -- see AdversarialVerbResult.
-    ...result.authoringModel === void 0 ? {} : { authoringModel: authoringModelDisclosureOf(result.authoringModel) },
-    probeCap: result.probeCap,
-    spend: result.spend,
-    probeSkips: result.probeSkips,
-    probeRefusals: result.probeRefusals
-  };
-}
-async function resolveProbeBinding(session, opts, product) {
-  const capability = opts.probeCapability ?? await (await Promise.resolve().then(() => (init_adversarial_probe_preflight(), adversarial_probe_preflight_exports))).resolveAdversarialProbeCapability(session);
-  if (capability.kind !== "probe-author") {
-    return { noProbeModel: { kind: "no-probe-model", reason: capability.reason } };
-  }
-  const bind = opts.bindProbeAuthor ?? await defaultProbeAuthorBinder(session);
-  const binding = {
-    onCallAttempted: (attempt) => {
-      const state = readProbeAttempt({
-        agentQaRoot: opts.agentQaRoot,
-        key: {
-          product,
-          seedCassetteId: attempt.seedCassetteId,
-          kind: attempt.kind,
-          promptVersion: attempt.promptVersion
-        }
-      });
-      if (state.kind === "unattempted") {
-        throw new Error("This probe call holds no durable reservation. Nothing reaches a provider before the spend is recorded.");
-      }
-    }
-  };
-  return { author: bind(capability.author, binding), authoringModel: capability.author.authoringModel };
-}
-async function defaultProbeAuthorBinder(session) {
-  const { createAdversarialProbeAuthor: createAdversarialProbeAuthor2 } = await Promise.resolve().then(() => (init_adversarial_probe_author(), adversarial_probe_author_exports));
-  return (author, binding) => createAdversarialProbeAuthor2({
-    author,
-    executionContext: session.executionContext,
-    mask: session.mask,
-    onCallAttempted: binding.onCallAttempted
-  });
-}
-function listAdversarialBatches(session, opts) {
-  void session;
-  return listStagedAdversarial(opts).map((batch) => ({
-    dir: batch.dir,
-    batchDigest: batch.manifest.batchDigest,
-    product: batch.manifest.product,
-    tableVersion: batch.manifest.tableVersion,
-    tableHash: batch.manifest.tableHash,
-    stagedAt: batch.manifest.stagedAt,
-    cases: batch.manifest.cases.map((row) => ({
-      cassetteId: row.cassetteId,
-      seedCassetteId: row.seedCassetteId,
-      mutator: row.mutator,
-      kind: row.kind,
-      tableEntryId: row.tableEntryId
-    }))
-  }));
-}
-function feedbackSeedHostOptions(session) {
-  return {
-    agentQaRoot: resolve6(session.configDir, ".agent-qa"),
-    knowledgeRoot: resolveKnowledgeRoot2(session.config.knowledge, session.configDir),
-    readStandingGateReceipts: LOCAL_CURATION_CAPABILITIES3.readStandingGateReceipts
-  };
-}
-async function runReplayGateVerb(session, candidateId, opts = {}) {
-  const k = opts.k ?? session.evalConfig.k ?? GATE1_DEFAULT_K;
-  if (!Number.isSafeInteger(k) || k < 3 || k % 2 === 0) {
-    throw new TypeError("--k must be an odd integer of at least 3");
-  }
-  const kSource = opts.k !== void 0 ? "flag" : session.evalConfig.k !== void 0 ? "config" : "default";
-  const maxScreens = opts.maxScreens ?? session.evalConfig.gate1?.maxScreens ?? GATE1_DEFAULT_MAX_SCREENS;
-  const maxScreensSource = opts.maxScreens !== void 0 ? "flag" : session.evalConfig.gate1?.maxScreens !== void 0 ? "config" : "default";
-  if (!Number.isSafeInteger(maxScreens) || maxScreens < 1) {
-    throw new TypeError("--max-screens must be a positive integer");
-  }
-  const identity = await resolveGateProfileIdentity(session, opts.plannerOverrides);
-  const profile = await resolveReplayProfileDeclaration(session);
-  let execution;
-  let mask = session.mask;
-  const names = selectedEvalJudgeNames(session.evalConfig);
-  const prepare = () => execution ??= resolveEvalSession({
-    configPath: session.configPath,
-    flags: { judge: names }
-  }).then(async (full) => {
-    if ((await resolveGateProfileIdentity(full, opts.plannerOverrides)).profileKey !== identity.profileKey) {
-      throw new EvalJudgeDeclarationError("Gate profile identity changed before execution; re-run eval replay-gate.");
-    }
-    mask = full.mask;
-    return full;
-  });
-  const declarations = await resolveEvalJudgeDeclarations(session);
-  const lazyJudges = declarations.map(({ name, profile: profile2 }) => ({
-    profile: profile2,
-    modelOverrides: opts.judgeOverrides,
-    resolveAuth: async () => {
-      const full = await prepare();
-      return (await resolveNamedProfile(name, full.configPath)).auth;
-    }
-  }));
-  const committedRoot = resolve6(session.configDir, "agent-qa-eval");
-  const floor = listNoiseFloorArtefacts(committedRoot).artefacts.find(
-    (entry) => entry.path === join9(committedRoot, committedNoiseFloorPath(identity.profileKey)) && entry.artefact.profileKey === identity.profileKey
-  )?.artefact;
-  const { createReplayGateHost: createReplayGateHost2 } = await Promise.resolve().then(() => (init_replay_gate_host(), replay_gate_host_exports));
-  const result = await createReplayGateHost2({
-    ...opts.resolveTrustPriors === void 0 ? {} : { resolveTrustPriors: opts.resolveTrustPriors },
-    // 422 D-14: the lease the caller lent this verb, re-presented to the bridge as a resolver
-    // over the value this call already holds. The bridge calls it once, at its own claim.
-    ...opts.claimAuthority === void 0 ? {} : { resolveClaimAuthority: () => opts.claimAuthority },
-    configPath: session.configPath,
-    agentQaRoot: opts.agentQaRoot ?? resolve6(session.configDir, ".agent-qa"),
-    record: opts.dryRun !== true,
-    session: {
-      ...session,
-      mask: (text) => mask(text)
-    },
-    composition: {
-      identity,
-      baselineWarmup: {
-        configPath: session.configPath,
-        ...names.length > 1 ? { judges: names } : { judge: names[0] }
-      },
-      k,
-      kSource,
-      maxScreens,
-      planner: {
-        profile,
-        modelOverrides: opts.plannerOverrides,
-        resolveAuth: async () => (await resolveReplayPlanner(await prepare())).auth
-      },
-      ...lazyJudges.length > 1 ? { judgeMembers: lazyJudges } : { judge: lazyJudges[0] },
-      judgeOverrideConfigured: names.length <= 1 && session.evalConfig.judgeAllowSameFamily === true,
-      baselineSeed: session.evalConfig.seed !== void 0 ? { seed: session.evalConfig.seed, source: "config" } : { floorSeeds: floor?.seeds ?? [] },
-      clock: opts.clock,
-      onProgress: opts.onProgress
-    }
-  }).run(candidateId);
-  const capNotice = `cap: maxScreens=${maxScreens} (${maxScreensSource})`;
-  return {
-    ...result,
-    maxScreens,
-    maxScreensSource,
-    k,
-    kSource,
-    notices: [...result.notices, ...names.length > 1 && session.evalConfig.judgeAllowSameFamily === true ? ["eval.judgeAllowSameFamily is ignored for a composite judge panel; every member must be disjoint."] : [], capNotice],
-    ...result.kind === "receipt" ? { lines: [...result.lines, capNotice] } : {}
-  };
-}
-async function runFloorVerb(session, opts = {}) {
-  const repeats = opts.repeats ?? FLOOR_DEFAULT_REPEATS;
-  const seeds = [...new Set(opts.seeds ?? FLOOR_DEFAULT_SEEDS)];
-  const bootstrapSeed = opts.bootstrapSeed ?? FLOOR_DEFAULT_BOOTSTRAP_SEED;
-  if (!Number.isSafeInteger(repeats) || repeats < FLOOR_PROTOCOL_MINIMUM.repeats || seeds.length < FLOOR_PROTOCOL_MINIMUM.seeds || !seeds.every(Number.isSafeInteger)) {
-    throw new FloorProtocolError();
-  }
-  if (!Number.isSafeInteger(bootstrapSeed)) throw new TypeError("--bootstrap-seed must be a safe integer");
-  let classifierRepeatability;
-  if (opts.classifierRepeatability !== void 0) {
-    const path = resolve6(session.configDir, opts.classifierRepeatability);
-    let value;
-    try {
-      value = JSON.parse(await readFile2(path, "utf8"));
-    } catch (error) {
-      throw new TypeError(`classifier repeatability unreadable at ${path}: ${error.message}`);
-    }
-    const guarded = guardClassifierRepeatability(value);
-    if (guarded.kind === "rejected") {
-      throw new TypeError(`classifier repeatability rejected at ${path}: ${guarded.reason}`);
-    }
-    classifierRepeatability = guarded.repeatability;
-  }
-  const planner = opts.fromMeasured === void 0 ? await resolveReplayPlanner(session) : { profile: await resolveReplayProfileDeclaration(session) };
-  const judgeResolution = opts.fromMeasured === void 0 ? await resolveEvalJudge(session) : {};
-  const judge = withJudgeOverrides(judgeResolution.judge, opts.judgeOverrides);
-  const { plannerModelId, matcherVersion, judgeModelId, judgeVersion } = await resolveGateProfileIdentity(session, opts.plannerOverrides);
-  if (opts.fromMeasured === void 0 && replayJudgeRequest(judge)?.judgeModelId !== judgeModelId) {
-    throw new EvalJudgeDeclarationError("Floor judge identity changed before execution; re-run eval floor.");
-  }
-  const profileKeyInputs = {
-    plannerModelId,
-    matcherVersion,
-    ...judgeModelId === void 0 ? {} : { judgeModelId, judgeVersion }
-  };
-  const costLines = [];
-  const result = await runNoiseFloorMeasurement({
-    committedRoot: resolve6(session.configDir, "agent-qa-eval"),
-    cassettesRoot: resolveCassettesRoot(session, "committed").cassettesRoot,
-    agentQaRoot: resolve6(session.configDir, ".agent-qa"),
-    ...planner,
-    ...opts.fromMeasured === void 0 ? {} : { fromMeasured: resolve6(session.configDir, opts.fromMeasured) },
-    modelOverrides: opts.plannerOverrides,
-    judge,
-    mask: session.mask,
-    profileKeyInputs,
-    seeds,
-    repeats,
-    bootstrapSeed,
-    classifierRepeatability,
-    explanation: opts.explanation,
-    commit: opts.commit === true,
-    onProgress: (line) => {
-      if (/^floor r\d+ seed=/.test(line)) costLines.push(line);
-      process.stderr.write(line + "\n");
-    }
-  });
-  const notices = [...result.notices];
-  if (judgeResolution.notice !== void 0) notices.unshift(judgeResolution.notice);
-  if (result.committed?.kind === "refused") notices.push(renderFloorRefusal(result.committed.refusal));
-  return {
-    ...result,
-    notices,
-    repeats,
-    seeds,
-    bootstrapSeed,
-    costLines,
-    recordedDefaults: opts.repeats === void 0 && opts.seeds === void 0 && opts.bootstrapSeed === void 0,
-    corpusDigest: result.artefact.corpusDigest
-  };
-}
-async function runGateVerb(session, opts = {}) {
-  if (opts.stagedDir !== void 0 && opts.report === void 0) {
-    throw new TypeError("--staged-dir requires --report <batchKey>");
-  }
-  const declaredSeed = opts.seed ?? session.evalConfig.seed;
-  if (declaredSeed !== void 0 && !Number.isSafeInteger(declaredSeed)) {
-    throw new TypeError("--seed must be a safe integer");
-  }
-  const committedRoot = resolve6(session.configDir, "agent-qa-eval");
-  const agentQaRoot = resolve6(session.configDir, ".agent-qa");
-  const { plannerModelId, judgeModelId, judgeVersion, fingerprint, matcherVersion, profileKey } = await resolveGateProfileIdentity(session, opts.plannerOverrides);
-  const profileKeyInputs = {
-    plannerModelId,
-    matcherVersion,
-    ...judgeModelId === void 0 ? {} : { judgeModelId, judgeVersion }
-  };
-  const floorPath = join9(committedRoot, committedNoiseFloorPath(profileKey));
-  const floorSeed = declaredSeed === void 0 ? listNoiseFloorArtefacts(committedRoot).artefacts.find((entry) => entry.path === floorPath && entry.profileKey === profileKey)?.artefact.seeds[0] : void 0;
-  const seed = declaredSeed ?? floorSeed ?? FLOOR_DEFAULT_SEEDS[0];
-  const seedSource = opts.seed !== void 0 ? "flag" : session.evalConfig.seed !== void 0 ? "config" : floorSeed !== void 0 ? "floor" : "default";
-  const probedDirs = [];
-  const notices = [];
-  let mode;
-  if (opts.report !== void 0) {
-    const choices = opts.stagedDir !== void 0 ? [{ dir: resolve6(session.configDir, opts.stagedDir), label: "--staged-dir" }] : [
-      { dir: join9(agentQaRoot, "eval", "gate", slugBranch(profileKey), "reports"), label: "gate root" },
-      { dir: join9(agentQaRoot, DEFAULT_EVAL_REPORTS_SUBDIR), label: "default staging root" }
-    ];
-    const files = [];
-    let stagedOutputDir;
-    for (const choice of choices) {
-      probedDirs.push(choice.dir);
-      const file = join9(choice.dir, `${slugBranch(opts.report)}.json`);
-      files.push(file);
-      try {
-        lstatSync2(file);
-      } catch (error) {
-        if (error.code === "ENOENT") continue;
-      }
-      stagedOutputDir = choice.dir;
-      notices.push(`gate --report: reading ${file} (${choice.label})`);
-      break;
-    }
-    if (stagedOutputDir === void 0) {
-      return {
-        kind: "refused",
-        refusal: {
-          path: files[files.length - 1],
-          reason: `staged report absent; probed ${files.join(", ")}`
-        },
-        notices,
-        seed,
-        seedSource,
-        probedDirs
-      };
-    }
-    mode = {
-      kind: "report",
-      batchKey: opts.report,
-      stagedOutputDir,
-      profile: await resolveReplayProfileDeclaration(session),
-      modelOverrides: opts.plannerOverrides
-    };
-  } else {
-    const planner = await resolveReplayPlanner(session);
-    const judgeResolution = await resolveEvalJudge(session);
-    if (judgeResolution.notice !== void 0) notices.push(judgeResolution.notice);
-    mode = {
-      kind: "fresh",
-      ...planner,
-      modelOverrides: opts.plannerOverrides,
-      judge: withJudgeOverrides(judgeResolution.judge, opts.judgeOverrides),
-      mask: session.mask,
-      seed,
-      cassettesRoot: resolveCassettesRoot(session, "committed").cassettesRoot,
-      onProgress: (line) => process.stderr.write(line + "\n")
-    };
-  }
-  const result = await runReleaseGate({ committedRoot, agentQaRoot, profileKeyInputs, mode });
-  return { ...result, notices: [...notices, ...result.notices], seed, seedSource, probedDirs };
-}
-function isExclusionVerdict(verdict) {
-  return EXCLUDED_VERDICT_CLASSES.has(verdict.class);
-}
-async function runSeedVerb(session, filters = {}, params = {}) {
-  const agentQaRoot = resolve6(session.configDir, ".agent-qa");
-  const runsRoot = resolve6(agentQaRoot, RUNS_SUBDIR);
-  let runSlugs = listRunSlugsWithHandoff(runsRoot);
-  if (filters.run !== void 0) {
-    const named = filters.run;
-    runSlugs = runSlugs.filter((slug) => slug === named || slug === slugBranch(named));
-    if (runSlugs.length === 0) {
-      throw new EvalNamedInputError("run", named, runsRoot, "seed");
-    }
-  }
-  const committedRoot = resolve6(session.configDir, "agent-qa-eval");
-  const silverPerTestCap = params.silverPerTestCap ?? session.evalConfig.seeding?.silverPerTestCap;
-  const result = {
-    membersExcluded: [],
-    admissionConflicts: [],
-    silverExclusionRows: [],
-    supersededOriginalCount: 0,
-    retirementCounts: { missing: 0, conflict: 0 },
-    runsSwept: runSlugs.length,
-    runsSkipped: [],
-    runsFiltered: 0,
-    runsExcluded: [],
-    runsAdmitted: [],
-    notices: [],
-    handoffsSeeded: 0,
-    seededCount: 0,
-    unchangedCount: 0,
-    refusals: [],
-    pairSkips: 0,
-    silverExclusions: 0,
-    pairCounts: { total: 0, sameState: 0, differingState: 0 },
-    contracts: {},
-    scaffold: {},
-    partitions: [],
-    exclusionsWritten: [],
-    committedRoot
-  };
-  const admitted = [];
-  const initialCommitted = readCommittedCorpus(committedRoot);
-  for (const runSlug of runSlugs) {
-    try {
-      const handoffPath = resolve6(runsRoot, runSlug, HANDOFF_FILE);
-      const located = relative(realpathSync2(agentQaRoot), realpathSync2(handoffPath));
-      if (located === ".." || located.startsWith("../") || located.startsWith("..\\") || isAbsolute2(located)) {
-        throw new Error("seed handoff path is outside the operator run root");
-      }
-      const handoff = loadCompletedRunHandoff(handoffPath);
-      if (slugBranch(handoff.runId) !== runSlug) throw new Error("seed handoff run identity does not match its directory");
-      const product = resolveProductPartition(handoff.scope);
-      if (filters.product !== void 0 && product !== filters.product) {
-        result.runsFiltered++;
-        continue;
-      }
-      const verified = loadLabelEvidence({ snapshot: initialCommitted.snapshot, agentQaRoot, incoming: handoff });
-      if (!verified.handoffs.some((value) => value.runId === handoff.runId)) {
-        throw new Error("seed incoming handoff evidence could not be positively verified before admission");
-      }
-      const analysis = readRunAnalysisArtifact(runsRoot, runSlug, handoff.runId, result.notices);
-      const row = {
-        runSlug,
-        product,
-        verdicts: resolveSeedVerdictRows(analysis.artifact, handoff)
-      };
-      const excluding = row.verdicts.filter(isExclusionVerdict);
-      const memberVerdicts = resolveSeedMemberVerdicts(analysis.artifact, handoff);
-      const eligible = handoff.tests.filter((member) => admitSeedMember(member, memberVerdicts.get(member.testIndex)));
-      const hasEligibleRerun = eligible.some((member) => member.isRerun);
-      if (excluding.length > 0 && !hasEligibleRerun) {
-        result.runsExcluded.push(row);
-        const record = projectRunExclusion({
-          runId: handoff.runId,
-          runSlug,
-          product,
-          verdicts: excluding,
-          analysisDigest: analysis.text === void 0 ? sha256hex3(canonicalJson5(row.verdicts)) : sha256hex3(analysis.text)
-        });
-        const outcome = writeRunExclusion({
-          record,
-          committedRoot
-        });
-        result.exclusionsWritten.push({
-          runSlug,
-          product,
-          path: committedExclusionPath(product, runSlug),
-          outcome: outcome.kind
-        });
-        continue;
-      }
-      const exclusionPath = committedExclusionPath(product, runSlug);
-      if (existsSync4(join9(committedRoot, exclusionPath))) {
-        result.admissionConflicts.push({ runSlug, product, path: exclusionPath, reason: "existing-run-exclusion" });
-        result.notices.push(`seed ${runSlug}: existing run exclusion requires the reviewed exclusion path before admission`);
-        continue;
-      }
-      const testIndexes = new Set(eligible.map((member) => member.testIndex));
-      for (const member of handoff.tests) {
-        const verdict = memberVerdicts.get(member.testIndex);
-        if (!testIndexes.has(member.testIndex) && verdict) {
-          result.membersExcluded.push({ runSlug, product, testIndex: member.testIndex, verdict });
-        }
-      }
-      result.runsAdmitted.push(row);
-      admitted.push({ runSlug, handoff, product, testIndexes });
-    } catch (err) {
-      result.runsSkipped.push({
-        runSlug,
-        reason: err instanceof Error ? err.message : String(err)
-      });
-      continue;
-    }
-  }
-  const manifests = ensurePartitionManifests(session, admitted, committedRoot, result, params);
-  for (const { runSlug, handoff, product, testIndexes } of admitted) {
-    let report;
-    try {
-      const committed = readCommittedCorpus(committedRoot);
-      const evidence = loadLabelEvidence({ snapshot: committed.snapshot, agentQaRoot, incoming: handoff });
-      for (const refusal of evidence.refusals) result.notices.push(`SOFT evidence ${refusal.runId}: ${refusal.reason}`);
-      if (!evidence.handoffs.some((value) => value.runId === handoff.runId)) {
-        throw new Error("seed incoming handoff evidence could not be positively verified");
-      }
-      const mask = committedCorpusMask(session);
-      const admittedHandoff = maskCorpusText(
-        { ...handoff, tests: handoff.tests.filter((member) => testIndexes.has(member.testIndex)) },
-        mask
-      );
-      const populationHandoffs = evidence.handoffs.map((source) => {
-        if (source.runId === handoff.runId) return admittedHandoff;
-        const sourceAnalysis = readRunAnalysisArtifact(runsRoot, slugBranch(source.runId), source.runId, result.notices);
-        const verdicts = resolveSeedMemberVerdicts(sourceAnalysis.artifact, source);
-        return maskCorpusText(
-          { ...source, tests: source.tests.filter((member) => admitSeedMember(member, verdicts.get(member.testIndex))) },
-          mask
-        );
-      });
-      const manifest = manifests.get(product);
-      if (manifest === void 0) {
-        throw new Error(`no committed partition manifest for product ${product}`);
-      }
-      const extraction = extractRunCassettes({
-        handoff: admittedHandoff,
-        artifacts: new FsRunArtifactSource({ root: agentQaRoot, runId: handoff.runId })
-      });
-      const targetEnvironment = resolveTargetEnvironmentForProduct(session.config, product);
-      const plan = buildSeedingPlan({
-        handoff: admittedHandoff,
-        populationContext: { snapshot: committed.snapshot, handoffs: populationHandoffs, marks: evidence.marks },
-        cassettes: extraction.cassettes,
-        // 414 D-07: the split comes from the product's COMMITTED manifest params — the cli adds
-        // no selection or relabel logic of its own.
-        partition: partitionParamsOf(manifest),
-        capturedAt: new Date(handoff.endedAt).toISOString(),
-        ...targetEnvironment === void 0 ? {} : { targetEnvironment },
-        params: {
-          ...silverPerTestCap !== void 0 ? { silverPerTestCap } : {}
-        },
-        mask
-      });
-      report = seedCommittedCorpus({
-        plan,
-        cassettes: extraction.cassettes,
-        committedRoot,
-        mask
-      });
-      for (const skip of report.softEvidence?.skips ?? []) {
-        result.notices.push(`SOFT evidence ${skip.runId}/${skip.testIndex}/${skip.stepIndex}/${skip.attempt}: ${skip.reason}`);
-      }
-    } catch (err) {
-      result.runsSkipped.push({
-        runSlug,
-        reason: err instanceof Error ? err.message : String(err)
-      });
-      continue;
-    }
-    result.handoffsSeeded++;
-    result.seededCount += report.seededCount;
-    result.unchangedCount += report.unchangedCount;
-    result.supersededOriginalCount += report.supersededOriginalCount;
-    result.retirementCounts.missing += report.retirementCounts.missing;
-    result.retirementCounts.conflict += report.retirementCounts.conflict;
-    result.silverExclusionRows.push(...report.silverExclusions.map((row) => ({ ...row, runSlug, product })));
-    result.refusals.push(...report.refusals);
-    result.pairSkips += report.pairSkips.length;
-    result.silverExclusions += report.silverExclusions.length;
-    result.pairCounts.total += report.pairCounts.total;
-    result.pairCounts.sameState += report.pairCounts.sameState;
-    result.pairCounts.differingState += report.pairCounts.differingState;
-    for (const contract of report.contracts) {
-      bumpCounter(result.contracts, contract.outcome);
-    }
-    bumpCounter(result.scaffold, report.scaffold.gitignore);
-    bumpCounter(result.scaffold, report.scaffold.marker);
-  }
-  return result;
-}
-function ensurePartitionManifests(session, admitted, committedRoot, result, params) {
-  const byProduct = /* @__PURE__ */ new Map();
-  const read = readPartitionManifests(committedRoot);
-  for (const manifest of read.manifests) byProduct.set(manifest.product, manifest);
-  result.notices.push(...read.notices);
-  for (const refusal of read.refusals) {
-    result.notices.push(`partition manifest refused at ${refusal.path}: ${refusal.reason}`);
-  }
-  const products = [...new Set(admitted.map((entry) => entry.product))].sort();
-  const { heldOutFraction, privateFraction } = params;
-  const unpartitioned = products.filter((product) => !byProduct.has(product));
-  if (unpartitioned.length > 0 && (heldOutFraction === void 0 || privateFraction === void 0)) {
-    throw new EvalPartitionFlagsRequiredError(unpartitioned);
-  }
-  for (const product of products) {
-    const committed = byProduct.get(product);
-    const relPath = committedPartitionManifestPath(product);
-    if (committed === void 0) {
-      const saltHex = randomBytes(32).toString("hex");
-      const manifest = projectPartitionManifest({
-        product,
-        saltHex,
-        heldOutFraction,
-        privateFraction
-      });
-      const outcome2 = writePartitionManifest({
-        manifest,
-        committedRoot
-      });
-      byProduct.set(product, manifest);
-      result.partitions.push(partitionRow(manifest, relPath, requireManifestWritten(outcome2, product, relPath)));
-      continue;
-    }
-    if (heldOutFraction === void 0 || privateFraction === void 0) {
-      result.partitions.push(partitionRow(committed, relPath, "unchanged"));
-      continue;
-    }
-    const reprojected = projectPartitionManifest({
-      product,
-      saltHex: committed.salt,
-      heldOutFraction,
-      privateFraction
-    });
-    const outcome = writePartitionManifest({
-      manifest: reprojected,
-      committedRoot
-    });
-    result.partitions.push(
-      partitionRow(committed, relPath, requireManifestWritten(outcome, product, relPath))
-    );
-  }
-  return byProduct;
-}
-function partitionRow(manifest, path, outcome) {
-  return {
-    product: manifest.product,
-    path,
-    outcome,
-    saltDigest: sha256hex3(manifest.salt),
-    heldOutFraction: manifest.heldOutFraction,
-    privateFraction: manifest.privateFraction,
-    partitionVersion: manifest.partitionVersion
-  };
-}
-function resolveTargetEnvironmentForProduct(config, product) {
-  const declared = /* @__PURE__ */ new Set();
-  for (const summary of listTargets(config)) {
-    const target = resolveTarget(config, summary.name);
-    if (target.product !== product) continue;
-    if (target.environment === void 0) continue;
-    declared.add(target.environment);
-  }
-  return declared.size === 1 ? [...declared][0] : void 0;
-}
-function requireManifestWritten(outcome, product, path) {
-  if (outcome.kind === "write-conflict") {
-    throw new EvalPartitionManifestConflictError(product, path);
-  }
-  return outcome.kind;
-}
-function readRunAnalysisArtifact(runsRoot, runSlug, runId, notices) {
-  const path = join9(runsRoot, runSlug, ANALYSIS_FILE);
-  if (!existsSync4(path)) return {};
-  try {
-    const text = readFileSync5(path, "utf8");
-    const admission = admitAnalysisArtifactForRun(
-      guardRunAnalysisArtifact(JSON.parse(text)),
-      runId
-    );
-    if (admission.kind === "admitted") return { artifact: admission.artifact, text };
-    notices.push(
-      `${ANALYSIS_FILE} for ${runSlug} records run ${admission.recordedRunId}, not ${admission.resolvingRunId} \u2014 deterministic floor used`
-    );
-    return {};
-  } catch (err) {
-    notices.push(
-      `${ANALYSIS_FILE} unreadable for ${runSlug}: ${err instanceof Error ? err.message : String(err)} \u2014 deterministic floor used`
-    );
-    return {};
-  }
-}
-function resolveSeedVerdictRows(artifact, handoff) {
-  return [...resolveSeedMemberVerdicts(artifact, handoff).entries()].sort(([first], [second]) => first - second).map(([, verdict]) => verdict);
-}
-function resolveSeedMemberVerdicts(artifact, handoff) {
-  const byPerTest = /* @__PURE__ */ new Map();
-  for (const member of handoff.tests) {
-    if (member.rootCause === void 0) continue;
-    byPerTest.set(member.testIndex, {
-      class: member.rootCause.class,
-      producer: member.rootCause.producer
-    });
-  }
-  for (const verdict of resolveRunVerdicts(artifact, handoff)) {
-    byPerTest.set(verdict.perTest, { class: verdict.class, producer: verdict.producer });
-  }
-  return byPerTest;
-}
-async function runReportVerb(session, filters = {}, opts = {}) {
-  if (opts.fromCommitted !== void 0) {
-    if (opts.baseline !== true) throw new TypeError("--from-committed requires --baseline");
-    if (opts.seedPolicy === void 0) {
-      throw new TypeError("--from-committed requires --seed-policy <none|declared>");
-    }
-    if (opts.commit === true) throw new TypeError("--from-committed cannot be combined with --commit");
-    if (!/^[0-9a-f]{64}$/.test(opts.fromCommitted)) {
-      throw new TypeError("--from-committed requires a batchKey of 64 lowercase hexadecimal characters");
-    }
-    if (!SEED_POLICIES.includes(opts.seedPolicy)) {
-      throw new TypeError('--seed-policy must be "none" or "declared"');
-    }
-    const committedRoot2 = resolve6(session.configDir, "agent-qa-eval");
-    const reportList = listCommittedReports(committedRoot2);
-    const requestedFile = join9(committedRoot2, "reports", opts.fromCommitted, "report.json");
-    const entry = reportList.reports.find((candidate) => candidate.batchKey === opts.fromCommitted);
-    if (entry === void 0) {
-      const refusal = reportList.refusals.find((candidate) => candidate.path === requestedFile);
-      throw new EvalNamedInputError(
-        "batchKey",
-        opts.fromCommitted,
-        refusal?.path ?? join9(committedRoot2, "reports"),
-        "designate",
-        refusal?.reason
-      );
-    }
-    if (entry.path !== requestedFile || entry.report.batchKey !== opts.fromCommitted) {
-      throw new EvalNamedInputError(
-        "batchKey",
-        opts.fromCommitted,
-        entry.path,
-        "designate",
-        `report batchKey "${entry.report.batchKey}" does not match the requested directory`
-      );
-    }
-    const notices2 = reportList.refusals.map(
-      (refusal) => `committed read refused ${refusal.path}: ${refusal.reason}`
-    );
-    const designation = await designateReportBaseline(
-      session,
-      entry.report,
-      opts.seedPolicy,
-      opts.plannerOverrides,
-      notices2
-    );
-    return {
-      batchKey: entry.report.batchKey,
-      entries: 0,
-      report: entry.report,
-      committedFile: entry.path,
-      judgeIdentity: entry.report.judgeIdentity === "mixed" ? "mixed" : entry.report.judge === void 0 ? "absent" : "present",
-      source: "committed",
-      ...designation,
-      notices: notices2
-    };
-  }
-  if (opts.baseline === true && opts.commit !== true) {
-    throw new Error(
-      "--baseline requires --commit: the pointer designates a COMMITTED report (413 D-19)"
-    );
-  }
-  const agentQaRoot = resolve6(session.configDir, ".agent-qa");
-  const replaysRoot = join9(agentQaRoot, DEFAULT_EVAL_REPLAYS_SUBDIR);
-  const source = opts.source ?? "staged";
-  const sourceRoot = resolveCassettesRoot(session, source);
-  const cassettesRoot = sourceRoot.cassettesRoot;
-  const notices = [];
-  if (sourceRoot.notice !== void 0) notices.push(sourceRoot.notice);
-  const labelCorpus = readActiveCommittedCorpus(resolve6(session.configDir, "agent-qa-eval"), agentQaRoot);
-  const committedCorpus = source === "committed" ? labelCorpus : void 0;
-  notices.push(...labelCorpus.refusals.map((refusal) => `committed read refused ${refusal.path}: ${refusal.reason}`));
-  const {
-    entries: assembled,
-    judgeBlocks,
-    partitionsById,
-    missingBundleCount,
-    notices: assemblyNotices
-  } = assembleScoredBatch({
-    replaysRoot,
-    cassettesRoot,
-    source,
-    labelRecords: labelCorpus.snapshot.labelsById,
-    excludedLabelIds: labelCorpus.snapshot.excludedLabelIds,
-    ...committedCorpus === void 0 ? {} : {
-      productByCassetteId: new Map(committedCorpus.snapshot.entries.map((entry) => [entry.cassetteId, entry.product])),
-      eligibleCassetteIds: new Set(committedCorpus.snapshot.entries.map((entry) => entry.cassetteId)),
-      corpusEntriesById: committedCorpus.corpusEntriesById
-    }
-  });
-  notices.push(...assemblyNotices);
-  if (assembled.some((entry) => entry.split === void 0)) {
-    notices.push("corpus split ownership unknown; entries without corpus metadata are unassigned");
-  }
-  if (missingBundleCount > 0) {
-    notices.push(
-      `${missingBundleCount} replay record(s) have no ${source} cassette bundle \u2014 label legs absent`
-    );
-  }
-  let entries = assembled;
-  if (filters.cassette !== void 0) {
-    const named = filters.cassette;
-    entries = entries.filter((entry) => entry.cassetteId === named);
-    if (entries.length === 0) {
-      throw new EvalNamedInputError("cassette", named, replaysRoot, "report");
-    }
-  }
-  if (filters.run !== void 0) {
-    const named = filters.run;
-    entries = entries.filter((entry) => {
-      const head = entry.cassetteId.split("/")[0];
-      return head === named || head === slugBranch(named);
-    });
-    if (entries.length === 0) {
-      throw new EvalNamedInputError("run", named, replaysRoot, "report");
-    }
-  }
-  if (filters.product !== void 0) {
-    const named = filters.product;
-    entries = entries.filter((entry) => partitionsById.get(entry.cassetteId) === named);
-  }
-  entries.sort((a, b) => a.cassetteId < b.cassetteId ? -1 : a.cassetteId > b.cassetteId ? 1 : 0);
-  let judgeIdentity;
-  let judgeForReport;
-  let mixedIdentity;
-  if (judgeBlocks.length === 0) {
-    judgeIdentity = "absent";
-    notices.push("no judge identity on any persisted score record \u2014 the report carries no judge block");
-  } else {
-    const identities = judgeBlocks.map((block) => judgeIdentitySchema.strip().parse(block));
-    const first = canonicalJson5(identities[0]);
-    if (identities.every((block) => canonicalJson5(block) === first)) {
-      judgeIdentity = "present";
-      judgeForReport = identities[0];
-    } else {
-      judgeIdentity = "mixed";
-      mixedIdentity = {
-        judgeIdentity: "mixed",
-        judgeModelIds: [...new Set(judgeBlocks.map((block) => block.judgeModelId))].sort()
-      };
-      notices.push(
-        "mixed judge identities across persisted score records \u2014 the report carries no judge block (never fabricated)"
-      );
-    }
-  }
-  const report = buildEvalReport(entries, judgeForReport, mixedIdentity, { calibration: labelCorpus.calibration });
-  const reportSeedPolicy = session.evalConfig.seed !== void 0 ? "declared" : "none";
-  let reportProfileProof;
-  if (report.judge?.panelSize !== void 0) {
-    let calibrationRead;
-    try {
-      const replayProfile = await resolveReplayProfileDeclaration(session);
-      const actualModels = entries.flatMap((entry) => {
-        if ("kind" in entry.outcome) return [];
-        const results = entry.outcome.granularity === "leaf" ? [entry.outcome] : entry.outcome.steps.flatMap((step) => step.kind === "decision" ? [step.result] : []);
-        return results.map((result) => result.replayedModel.modelId);
-      });
-      if (actualModels.length === 0 || actualModels.some((model) => model !== replayProfile.model)) {
-        throw new Error("report replay profile unavailable");
-      }
-      const fingerprint = computeReplayProfileFingerprintFor({
-        profile: replayProfile,
-        seedPolicy: reportSeedPolicy,
-        modelOverrides: opts.plannerOverrides
-      });
-      reportProfileProof = readReportProfileProof({
-        agentQaRoot,
-        replaysRoot,
-        report,
-        entries,
-        fingerprint,
-        corpusDigest: computeCorpusDigest(labelCorpus.snapshot.entries),
-        seed: session.evalConfig.seed
-      });
-      if (!reportProfileProof) throw new Error("report full profile proof unavailable");
-      calibrationRead = readJudgeCalibration({
-        committedRoot: resolve6(session.configDir, "agent-qa-eval"),
-        agentQaRoot,
-        identity: report.judge,
-        profile: {
-          plannerModelId: replayProfile.model,
-          fingerprint,
-          matcherVersion: report.matcherVersion,
-          judgeModelId: report.judge.judgeModelId,
-          judgeVersion: report.judge.judgeVersion
-        }
-      });
-    } catch {
-    }
-    copyJudgeCalibrationToReport(report, calibrationRead);
-    if (calibrationRead?.kind !== "loaded") notices.push("judge calibration unavailable: no matching guarded artifact");
-  }
-  const vectors = decisionCorrectnessVectors(entries, partitionsById);
-  const decisions = projectDecisionVectorsDocument({
-    batchKey: report.batchKey,
-    matcherVersion: report.matcherVersion,
-    vectors
-  });
-  if (reportProfileProof) report.runIdentity = reportProfileProof.runIdentity;
-  const staged = new FsReportStore({ root: agentQaRoot }).save(report, decisions, reportProfileProof?.replayGeneration);
-  const committedRoot = resolve6(session.configDir, "agent-qa-eval");
-  let committed;
-  if (opts.commit === true) {
-    committed = commitEvalReport({
-      report,
-      decisions,
-      markdown: renderEvalReportMarkdown(report),
-      committedRoot
-    });
-  }
-  let baseline;
-  let profileKey;
-  if (opts.baseline === true) {
-    if (committed?.kind !== "committed") {
-      notices.push(
-        `baseline pointer skipped: report commit outcome was ${committed?.kind ?? "absent"}`
-      );
-    } else {
-      const designation = await designateReportBaseline(
-        session,
-        report,
-        reportSeedPolicy,
-        opts.plannerOverrides,
-        notices
-      );
-      profileKey = designation.profileKey;
-      baseline = designation.baseline;
-    }
-  }
-  return {
-    batchKey: report.batchKey,
-    entries: entries.length,
-    report,
-    stagedFile: staged.file,
-    decisionVectorCount: decisions.vectors.length,
-    ...committed !== void 0 ? { committed } : {},
-    judgeIdentity,
-    source,
-    ...baseline !== void 0 ? { baseline } : {},
-    ...profileKey !== void 0 ? { profileKey } : {},
-    notices
-  };
-}
-async function designateReportBaseline(session, report, seedPolicy, plannerOverrides, notices) {
-  const committedRoot = resolve6(session.configDir, "agent-qa-eval");
-  const read = readActiveCommittedCorpus(committedRoot, resolve6(session.configDir, ".agent-qa"));
-  notices.push(...read.notices);
-  for (const refusal of read.refusals) {
-    notices.push(`committed read refused ${refusal.path}: ${refusal.reason}`);
-  }
-  const pointer = projectBaselinePointer({
-    plannerModelId: await resolvePlannerModelId(session),
-    fingerprint: await resolveReplayProfileFingerprint(session, seedPolicy, plannerOverrides),
-    corpusDigest: computeCorpusDigest(read.snapshot.entries),
-    matcherVersion: report.matcherVersion,
-    ...report.judge === void 0 ? {} : {
-      judgeModelId: report.judge.judgeModelId,
-      ...report.judge.judgeVersion === void 0 ? {} : { judgeVersion: report.judge.judgeVersion }
-    },
-    batchKey: report.batchKey
-  });
-  const baseline = writeBaselinePointer({ report, pointer, committedRoot });
-  if (baseline.kind === "refused") notices.push(renderBaselineComparatorRefusal(baseline.refusal));
-  if (seedPolicy === "none" && (baseline.kind === "written" || baseline.kind === "unchanged")) {
-    notices.push(
-      "baseline designated under seed policy none \u2014 eval gate compares against a declared-policy pointer; re-designate with eval report --baseline --from-committed <batchKey> --seed-policy declared"
-    );
-  }
-  return { profileKey: pointer.profileKey, baseline };
-}
-async function resolvePlannerModelId(session) {
-  return (await resolveBaselinePlannerConfig(session)).model;
-}
-async function resolveGateProfileIdentity(session, modelOverrides) {
-  const plannerModelId = await resolvePlannerModelId(session);
-  const fingerprint = await resolveReplayProfileFingerprint(session, "declared", modelOverrides);
-  const judgeProfiles = await resolveEvalJudgeDeclarations(session);
-  const judgeMemberModelIds = judgeProfiles.map((member) => member.profile.model);
-  const judgeIdentity = judgeMemberModelIds.length === 0 ? void 0 : createPanelIdentity(judgeMemberModelIds);
-  const judgeModelId = judgeIdentity?.judgeModelId;
-  const identity = {
-    plannerModelId,
-    fingerprint,
-    matcherVersion: buildEvalReport([]).matcherVersion,
-    ...judgeModelId === void 0 ? {} : { judgeModelId, judgeVersion: JUDGE_CONFIG.judgeVersion }
-  };
-  return {
-    ...identity,
-    profileKey: composeBaselineProfileKey(identity),
-    ...judgeMemberModelIds.length > 1 ? { judgeMemberModelIds } : {}
-  };
-}
-async function resolveEvalJudgeDeclarations(session) {
-  const { resolveNamedConfig: resolveNamedConfig2 } = await Promise.resolve().then(() => (init_llm_utils(), llm_utils_exports));
-  const members = [];
-  for (const name of selectedEvalJudgeNames(session.evalConfig)) {
-    const { config } = await resolveNamedConfig2(name, session.configPath, { keyOnly: true });
-    members.push({ name, profile: {
-      provider: config.provider,
-      model: config.model,
-      auth: { mode: "none" },
-      ...config.baseURL === void 0 ? {} : { baseURL: config.baseURL },
-      ...config.providerHeaders === void 0 ? {} : { headers: config.providerHeaders }
-    } });
-  }
-  return members;
-}
-async function resolveReplayProfileFingerprint(session, seedPolicy, modelOverrides) {
-  const profile = await resolveReplayProfileDeclaration(session);
-  return computeReplayProfileFingerprintFor({ profile, seedPolicy, modelOverrides });
-}
-async function resolveReplayProfileDeclaration(session, namedResolver) {
-  const config = await resolveBaselinePlannerConfig(session, namedResolver);
-  return {
-    provider: config.provider,
-    model: config.model,
-    ...config.baseURL !== void 0 ? { baseURL: config.baseURL } : {},
-    ...config.providerHeaders !== void 0 ? { headers: config.providerHeaders } : {},
-    auth: { mode: "none" }
-  };
-}
-async function resolveBaselinePlannerConfig(session, namedResolver) {
-  const plannerName = session.config.use?.llm;
-  if (!plannerName) {
-    throw new Error(
-      "use.llm is not set in the config \u2014 the baseline profile key is keyed on the replay planner, the named use.llm registry entry. Set use.llm in agent-qa.config.yaml."
-    );
-  }
-  const { resolveNamedConfig: resolveNamedConfig2 } = await Promise.resolve().then(() => (init_llm_utils(), llm_utils_exports));
-  const { config } = await (namedResolver ?? resolveNamedConfig2)(plannerName, session.configPath, { keyOnly: true });
-  return config;
-}
-async function runCensusVerb(session, opts = {}) {
-  const committedRoot = resolve6(session.configDir, "agent-qa-eval");
-  const notices = [];
-  const read = readActiveCommittedCorpus(committedRoot, resolve6(session.configDir, ".agent-qa"));
-  const manifestRead = readPartitionManifests(committedRoot);
-  const exclusionRead = readRunExclusions(committedRoot);
-  notices.push(...read.notices, ...manifestRead.notices);
-  for (const refusal of [...read.refusals, ...manifestRead.refusals, ...exclusionRead.refusals]) {
-    notices.push(`committed read refused ${refusal.path}: ${refusal.reason}`);
-  }
-  let campaign;
-  let campaignManifest;
-  if (opts.campaign !== void 0) {
-    campaignManifest = resolve6(process.cwd(), opts.campaign);
-    const manifest = guardCampaignManifest(JSON.parse(readFileSync5(campaignManifest, "utf8")));
-    campaign = { legs: manifest.legs, manifestDigest: sha256hex3(canonicalJson5(manifest)) };
-  }
-  const reportList = listCommittedReports(committedRoot);
-  const pointerList = listBaselinePointers(committedRoot);
-  for (const refusal of [...reportList.refusals, ...pointerList.refusals]) {
-    notices.push(`committed read refused ${refusal.path}: ${refusal.reason}`);
-  }
-  const reports = [];
-  for (const entry of reportList.reports) {
-    const comparator = assertBaselineComparator(entry.report);
-    const designatedBy = pointerList.pointers.filter((pointer) => pointer.batchKey === entry.batchKey).map((pointer) => pointer.profileKey).sort();
-    notices.push(
-      `cross-check ${entry.batchKey}: report decisions ${entry.report.headline.perDecisionCost.decisionCount} vs corpus cassettes ${read.snapshot.entries.length} \u2014 batch membership differs (batchKey only)`
-    );
-    if (!comparator.ok) notices.push(renderBaselineComparatorRefusal(comparator.refusal));
-    reports.push({ report: entry.report, comparator, designatedBy });
-  }
-  const floorList = listNoiseFloorArtefacts(committedRoot);
-  for (const refusal of floorList.refusals) {
-    notices.push(`committed read refused ${refusal.path}: ${refusal.reason}`);
-  }
-  const noiseFloor = floorList.artefacts.map(({ profileKey, path, artefact }) => {
-    const repeatability = artefact.classifierRepeatability;
-    return {
-      profileKey,
-      path,
-      ...artefact.minimumGateSet.value === void 0 ? {} : { minimumGateSet: artefact.minimumGateSet.value },
-      minimumGateSetDerivation: artefact.minimumGateSet.derivation,
-      ...repeatability === void 0 ? {} : {
-        classifierRepeatability: {
-          n: repeatability.n,
-          k: repeatability.k,
-          ...repeatability.classFlipRate === void 0 ? {} : { classFlipRate: repeatability.classFlipRate },
-          ...repeatability.admitExcludeFlipRate === void 0 ? {} : { admitExcludeFlipRate: repeatability.admitExcludeFlipRate }
-        }
-      }
-    };
-  });
-  const census = deriveCensus({
-    snapshot: read.snapshot,
-    ...read.corpusEntriesById === void 0 ? {} : { corpusEntriesById: read.corpusEntriesById },
-    ...read.retiredMarkedCassetteIds === void 0 ? {} : { retiredMarkedCassetteIds: read.retiredMarkedCassetteIds },
-    ...campaign === void 0 ? {} : { campaign },
-    reports,
-    manifests: manifestRead.manifests,
-    exclusions: exclusionRead.exclusions,
-    schemaVersionsSeen: read.schemaVersionsSeen
-  });
-  let committed;
-  if (opts.commit === true) {
-    committed = commitCensus({
-      census,
-      markdown: renderCensusMarkdown(census),
-      committedRoot
-    });
-  }
-  return {
-    corpusDigest: census.corpusDigest,
-    entryCount: census.entryCount,
-    productsSeen: read.productsSeen,
-    census,
-    ...campaignManifest !== void 0 ? { campaignManifest } : {},
-    ...committed !== void 0 ? { committed } : {},
-    ...noiseFloor.length === 0 ? {} : { noiseFloor },
-    notices
-  };
-}
-async function resolveNamedProfile(name, configPath) {
-  const { resolveNamedConfig: resolveNamedConfig2, resolveModelAuth: resolveModelAuth2, toModelProfileAndAuth: toModelProfileAndAuth2 } = await Promise.resolve().then(() => (init_llm_utils(), llm_utils_exports));
-  const { config } = await resolveNamedConfig2(name, configPath);
-  const auth = await resolveModelAuth2(config.name, config);
-  if (auth.kind === "missing") {
-    throw new Error(
-      `No credentials for LLM config "${config.name}": ${auth.message} Run \`agent-qa auth login\` to authenticate.`
-    );
-  }
-  return toModelProfileAndAuth2(config, auth);
-}
-async function loadEvalSecretStore(config, configDir) {
-  const secretsPath = resolve6(configDir, config.workspace.secretsFile);
-  let content;
-  try {
-    content = await readFile2(secretsPath, "utf-8");
-  } catch {
-    throw new Error(
-      `Secrets file not found or unreadable: ${secretsPath}. Create the file before running eval verbs (it may be empty, but it must exist).`
-    );
-  }
-  try {
-    const { SecretStore: SecretStore2 } = await import("@vostride/agent-qa-runner");
-    return SecretStore2.fromEnvContent(content);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Secrets file is invalid: ${secretsPath}: ${message}`);
-  }
-}
-function mergeEvalConfig(fromConfig, flags) {
-  const configured = selectedEvalJudgeNames(fromConfig ?? {});
-  const names = flags?.judge === void 0 ? configured : selectedEvalJudgeNames(typeof flags.judge === "string" ? { judge: flags.judge } : { judges: flags.judge });
-  const judgeAllowSameFamily = fromConfig?.judgeAllowSameFamily;
-  const k = flags?.k ?? fromConfig?.k;
-  const seed = flags?.seed ?? fromConfig?.seed;
-  const silverPerTestCap = flags?.silverCap ?? fromConfig?.seeding?.silverPerTestCap;
-  return {
-    ...names.length === 1 ? { judge: names[0] } : names.length > 1 ? { judges: names } : {},
-    ...judgeAllowSameFamily !== void 0 ? { judgeAllowSameFamily } : {},
-    ...k !== void 0 ? { k } : {},
-    ...seed !== void 0 ? { seed } : {},
-    ...fromConfig?.gate2 === void 0 ? {} : { gate2: fromConfig.gate2 },
-    ...fromConfig?.adversarial === void 0 ? {} : { adversarial: fromConfig.adversarial },
-    ...silverPerTestCap !== void 0 ? { seeding: { silverPerTestCap } } : {},
-    // 422-09: forwarded WHOLE, exactly as `gate2` and `adversarial` above are. The field-by-field
-    // rebuild this replaces silently dropped every member the schema gained after it was written.
-    ...fromConfig?.gate1 === void 0 ? {} : { gate1: fromConfig.gate1 }
-  };
-}
-var EvalJudgeDeclarationError, EvalNamedInputError, FLOOR_DEFAULT_REPEATS, FLOOR_DEFAULT_SEEDS, FLOOR_DEFAULT_BOOTSTRAP_SEED, LABEL_CALIBRATION_MIN_GOLD, GATE1_DEFAULT_MAX_SCREENS, GATE1_DEFAULT_K, GATE2_DEFAULT_MAX_ABLATIONS, GATE2_DEFAULT_CANARY_HORIZON_BUILDS, ATTR_DEFAULT_MAX_MISDIRECTION_CHECKS, EXCLUDED_VERDICT_CLASSES, EvalPartitionFlagsRequiredError, EvalPartitionManifestConflictError;
-var init_eval_session_composition = __esm({
-  "src/eval-session-composition.ts"() {
-    "use strict";
-    init_config();
-    init_declared_secrets();
-    init_targets();
-    init_promotion_posture();
-    init_eval_report_render();
-    init_judge_panel_preflight();
-    init_judge_panel_preflight();
-    init_adversarial_probe_preflight();
-    init_adversarial_probe_author();
-    EvalJudgeDeclarationError = class extends TypeError {
-      constructor(message) {
-        super(message);
-        this.name = "EvalJudgeDeclarationError";
-      }
-    };
-    EvalNamedInputError = class extends Error {
-      inputKind;
-      inputName;
-      searchRoot;
-      constructor(inputKind, inputName, searchRoot, verb = "extract", detail) {
-        super(
-          detail === void 0 ? `No recorded ${inputKind} named "${inputName}" under ${searchRoot} \u2014 nothing to ${verb}.` : `Cannot ${verb} ${inputKind} "${inputName}" at ${searchRoot}: ${detail}`
-        );
-        this.name = "EvalNamedInputError";
-        this.inputKind = inputKind;
-        this.inputName = inputName;
-        this.searchRoot = searchRoot;
-      }
-    };
-    FLOOR_DEFAULT_REPEATS = 3;
-    FLOOR_DEFAULT_SEEDS = [11, 29];
-    FLOOR_DEFAULT_BOOTSTRAP_SEED = 7;
-    LABEL_CALIBRATION_MIN_GOLD = 20;
-    GATE1_DEFAULT_MAX_SCREENS = 64;
-    GATE1_DEFAULT_K = 3;
-    GATE2_DEFAULT_MAX_ABLATIONS = 4;
-    GATE2_DEFAULT_CANARY_HORIZON_BUILDS = 5;
-    ATTR_DEFAULT_MAX_MISDIRECTION_CHECKS = 4;
-    EXCLUDED_VERDICT_CLASSES = new Set(
-      // 414 D-02: the local literal triplet is gone. `EXCLUSION_CLASSES` is the SAME closed
-      // vocabulary, and it now also decides what the committed exclusion record admits — a second
-      // spelling here could let the seeder drop a run the record schema would refuse to describe.
-      EXCLUSION_CLASSES
-    );
-    EvalPartitionFlagsRequiredError = class extends Error {
-      products;
-      constructor(products) {
-        super(
-          `partition of ${products.join(", ")} requires --held-out-fraction and --private-fraction on its first seed (414 D-07); no default exists`
-        );
-        this.name = "EvalPartitionFlagsRequiredError";
-        this.products = products;
-      }
-    };
-    EvalPartitionManifestConflictError = class extends Error {
-      product;
-      path;
-      constructor(product, path) {
-        super(
-          `partition manifest for ${product} at ${path}: write-conflict \u2014 the committed manifest disagrees with the supplied fractions; changing a manifest is a reviewed git edit and a named migration (414 D-05)`
-        );
-        this.name = "EvalPartitionManifestConflictError";
-        this.product = product;
-        this.path = path;
-      }
+      platform: typedEntry.platform
     };
-  }
-});
-
-// src/index.ts
-init_config();
-init_targets();
-import { getAgentQaVersion } from "@vostride/agent-qa-core";
-export * from "@vostride/agent-qa-core";
+  });
+}
 
 // src/commands/cache.ts
-init_config();
 import { Command } from "commander";
 import pc2 from "picocolors";
-import { readdir, rm, stat } from "fs/promises";
-import { join, resolve, basename } from "path";
+import { dirname as dirname3, resolve } from "path";
+import { purgeActionCache } from "@vostride/agent-qa-agent-local";
 import { DEFAULT_AGENT_QA_CACHE_DIR } from "@vostride/agent-qa-core";
-async function removeCacheEntries(cacheRoot) {
-  let branchDirs;
-  try {
-    branchDirs = await readdir(cacheRoot);
-  } catch (err) {
-    if (err.code === "ENOENT") return 0;
-    throw err;
-  }
-  let purged = 0;
-  for (const branch of branchDirs) {
-    const branchPath = join(cacheRoot, branch);
-    let entryStat;
-    try {
-      entryStat = await stat(branchPath);
-    } catch {
-      continue;
-    }
-    if (!entryStat.isDirectory()) {
-      await rm(branchPath, { force: true });
-      continue;
-    }
-    let files;
-    try {
-      files = await readdir(branchPath);
-    } catch {
-      continue;
-    }
-    for (const file of files) {
-      if (!file.endsWith(".json")) continue;
-      await rm(join(branchPath, file), { force: true });
-      purged++;
-    }
-    await rm(branchPath, { recursive: true, force: true }).catch(() => {
-    });
-  }
-  return purged;
-}
-async function countCacheEntries(cacheRoot) {
-  let branchDirs;
-  try {
-    branchDirs = await readdir(cacheRoot);
-  } catch (err) {
-    if (err.code === "ENOENT") return 0;
-    throw err;
-  }
-  let count2 = 0;
-  for (const branch of branchDirs) {
-    try {
-      const files = await readdir(join(cacheRoot, branch));
-      count2 += files.filter((f) => f.endsWith(".json")).length;
-    } catch {
-    }
-  }
-  return count2;
-}
-async function purgeTest(_testPath, cacheDir) {
-  return removeCacheEntries(resolve(cacheDir));
-}
 async function purgeAll(cacheDir) {
-  const resolvedDir = resolve(cacheDir);
-  const total = await countCacheEntries(resolvedDir);
-  if (total === 0) return 0;
-  return removeCacheEntries(resolvedDir);
+  return purgeActionCache(resolve(cacheDir));
 }
 
 // src/curation/curator-author.ts
@@ -3654,7 +384,7 @@ import {
 } from "@vostride/agent-qa-schema";
 
 // src/curation/emit-candidates.ts
-import { isAbsolute, join as join2 } from "path";
+import { isAbsolute, join } from "path";
 import { z } from "zod";
 import {
   LOCAL_CURATION_CAPABILITIES
@@ -3965,9 +695,7 @@ var trajectoryCompositeValueSchema = z.union([
   z.record(z.string(), procedureJsonValueSchema)
 ]);
 var trajectoryValueSlotSchema = z.object({
-  // WR-04: boolean and numeric action fields are replay semantics, not decoration. Dropping
-  // fill.submit, scroll.maxSwipes/retryOpposite, durations, or scale here would author a
-  // procedure whose behavior differs from the verified trajectory.
+  // Boolean and numeric action fields are replay semantics; dropping one changes the replay.
   observed: z.union([
     z.string(),
     z.number(),
@@ -3975,11 +703,7 @@ var trajectoryValueSlotSchema = z.object({
     trajectoryCompositeValueSchema
   ]),
   source: z.enum(["literal", "test-variable", "masked-secret"]),
-  // G-381-3: the live binding name behind this slot, when the evidence names it —
-  // a test variable matched against Plan 381-41's interpolation provenance, or a secret
-  // recovered from its recorded masked form. `curator-author` forces the covering
-  // parameter to exactly this name so consult-time fillability (D-08, which matches on
-  // binding NAMES) succeeds. Absent when the source is an anonymous literal.
+  // The binding name behind this slot; `curator-author` names the covering parameter after it.
   sourceName: z.string().min(1).optional()
 }).strict();
 var trajectoryStepSchema = z.object({
@@ -4249,7 +973,7 @@ function projectCurationCandidates(handoff, mask) {
 function bindArtifactSources(projection, runDir) {
   return projection.artifactDescriptors.map((descriptor) => ({
     artifactId: descriptor.ref.id,
-    sourcePath: join2(runDir, RUN_EVIDENCE_BLOBS_SUBDIR, descriptor.ref.sha)
+    sourcePath: join(runDir, RUN_EVIDENCE_BLOBS_SUBDIR, descriptor.ref.sha)
   }));
 }
 function incrementReport(report, outcome) {
@@ -4449,9 +1173,9 @@ function buildPrompt(job, neighbors, accounting) {
   const { contextWindow, maxOutput } = accounting.getCeilings();
   const inputBudget = contextWindow - maxOutput;
   if (inputBudget <= 0) return void 0;
-  for (let count2 = limited.length; count2 >= 0; count2 -= 1) {
-    const presented = limited.slice(0, count2);
-    const messages = renderPrompt(job, presented, neighbors.length - count2);
+  for (let count = limited.length; count >= 0; count -= 1) {
+    const presented = limited.slice(0, count);
+    const messages = renderPrompt(job, presented, neighbors.length - count);
     if (accounting.estimate(messages) <= inputBudget) {
       return {
         messages,
@@ -5258,38 +1982,38 @@ function buildCuratorAuthor(deps) {
 }
 
 // src/curation/curation-tail.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import {
-  closeSync as closeSync5,
-  existsSync as existsSync5,
-  fsyncSync as fsyncSync5,
-  openSync as openSync5,
-  readFileSync as readFileSync8,
-  readdirSync as readdirSync5,
-  renameSync as renameSync3,
-  rmSync as rmSync6,
-  writeFileSync as writeFileSync5
+  closeSync as closeSync3,
+  existsSync as existsSync3,
+  fsyncSync as fsyncSync3,
+  openSync as openSync3,
+  readFileSync as readFileSync5,
+  readdirSync,
+  renameSync as renameSync2,
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync3
 } from "fs";
-import { join as join12 } from "path";
-import { resolveKnowledgeRoot as resolveKnowledgeRoot3 } from "@vostride/agent-qa-core";
+import { join as join7 } from "path";
+import { resolveKnowledgeRoot as resolveKnowledgeRoot2 } from "@vostride/agent-qa-core";
 import {
-  LOCAL_CURATION_CAPABILITIES as LOCAL_CURATION_CAPABILITIES5,
+  LOCAL_CURATION_CAPABILITIES as LOCAL_CURATION_CAPABILITIES3,
   QUARANTINE_CLASS_DISPOSITIONS,
   QUARANTINE_FLOOR_ELIGIBILITY
 } from "@vostride/agent-qa-agent-local";
 import {
   EVENTS_FILE,
-  HANDOFF_FILE as HANDOFF_FILE3,
-  RUNS_SUBDIR as RUNS_SUBDIR3,
-  loadCompletedRunHandoff as loadCompletedRunHandoff2,
-  slugBranch as slugBranch3
+  HANDOFF_FILE,
+  RUNS_SUBDIR,
+  loadCompletedRunHandoff,
+  slugBranch
 } from "@vostride/agent-qa-runner-local";
-import { runSafetyScope as runSafetyScope3 } from "@vostride/agent-qa-safety-local";
-import { canonicalJson as canonicalJson8, sha256hex as sha256hex4, CurationSnapshotSchema, CURATION_BREAKDOWN_BUCKETS } from "@vostride/agent-qa-schema";
+import { runSafetyScope } from "@vostride/agent-qa-safety-local";
+import { canonicalJson as canonicalJson3, sha256hex, CurationSnapshotSchema, CURATION_BREAKDOWN_BUCKETS } from "@vostride/agent-qa-schema";
 
 // src/daemon/client.ts
 import { request } from "http";
-import { dirname as dirname5, join as join5 } from "path";
+import { dirname as dirname6, join as join4 } from "path";
 import {
   FunctionInputError,
   FunctionNotBoundError,
@@ -5312,7 +2036,7 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync
 } from "fs";
-import { dirname as dirname4, join as join4 } from "path";
+import { dirname as dirname5, join as join3 } from "path";
 import { LOCAL_DAEMON_CAPABILITIES } from "@vostride/agent-qa-agent-local";
 import { z as z4 } from "zod";
 
@@ -5326,7 +2050,7 @@ import {
 } from "http";
 import { connect } from "net";
 import { tmpdir } from "os";
-import { basename as basename2, dirname as dirname3, join as join3, resolve as resolve2, sep } from "path";
+import { basename, dirname as dirname4, join as join2, resolve as resolve2, sep } from "path";
 import { invokeFunction } from "@vostride/agent-qa-agent";
 import { ANALYTICS_AGENT_PRODUCTS } from "@vostride/agent-qa-analytics";
 import { z as z3 } from "zod";
@@ -5450,7 +2174,7 @@ var daemonRegistrationSchema = z4.object({
   startedAtMs: z4.number().int().nonnegative()
 }).strict();
 function daemonRegistrationPath(agentQaRoot) {
-  return join4(agentQaRoot, DAEMON_REGISTRATION_FILE);
+  return join3(agentQaRoot, DAEMON_REGISTRATION_FILE);
 }
 function readDaemonRegistrationFile(file) {
   let raw;
@@ -5551,15 +2275,7 @@ async function classifyDaemonRegistration(input) {
       );
       switch (verdict.kind) {
         case "fresh":
-        /**
-         * CR-01: `unknown` answers held, with the same holder payload as `fresh`.
-         *
-         * This verdict selects registration deletion and socket unlink, and the two preconditions
-         * are correlated rather than independent — fd exhaustion produces both the failed identity
-         * handshake and the unreadable epoch at once. Treating "I could not read the authority
-         * state" as "nobody holds it" therefore de-registers a live, healthy daemon precisely when
-         * the host is under stress. The refusal is the only recoverable answer.
-         */
+        // `unknown` answers held: fd exhaustion fails both checks at once, so unknown is not free.
         case "unknown":
           return {
             kind: "unreachable-lease-fresh",
@@ -5578,7 +2294,7 @@ async function classifyDaemonRegistration(input) {
 // src/daemon/client.ts
 var DAEMON_NUDGE_TIMEOUT_MS = 5e3;
 function defaultKnowledgeRoot(agentQaRoot) {
-  return join5(dirname5(agentQaRoot), "agent-qa-knowledge");
+  return join4(dirname6(agentQaRoot), "agent-qa-knowledge");
 }
 function parseJson(text, context) {
   try {
@@ -5673,401 +2389,36 @@ async function nudgeDaemon(agentQaRoot, options = {}) {
 }
 
 // src/curation/emit-canary-outcomes.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { isAbsolute as isAbsolute3, join as join10 } from "path";
-import { LOCAL_CURATION_CAPABILITIES as LOCAL_CURATION_CAPABILITIES4 } from "@vostride/agent-qa-agent-local";
-import {
-  admitAnalysisArtifactForRun as admitAnalysisArtifactForRun2,
-  ANALYSIS_FILE as ANALYSIS_FILE2,
-  canonicalJson as canonicalJson7,
-  deriveMemoryOnPathSites,
-  guardRunAnalysisArtifact as guardRunAnalysisArtifact2,
-  misdirectionSourceDigest,
-  normalizeAnchor as normalizeAnchor2,
-  resolveRunVerdicts as resolveRunVerdicts2
-} from "@vostride/agent-qa-schema";
-
-// src/curation/canary-run-state.ts
-import { closeSync as closeSync2, fsyncSync as fsyncSync2, linkSync, mkdirSync as mkdirSync3, openSync as openSync2, readdirSync, readFileSync as readFileSync2, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
-import { join as join6 } from "path";
-import { z as z5 } from "zod";
-import { CROSS_CHECKS, canonicalJson as canonicalJson2, sha256hex } from "@vostride/agent-qa-schema";
-var POLICY_FILE = "canary-policy.json";
-function readRunCanaryPolicy(runDir, runId) {
-  let text;
-  try {
-    text = readFileSync2(join6(runDir, POLICY_FILE), "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return void 0;
-    throw new Error("canary policy unavailable");
-  }
-  const policy = JSON.parse(text);
-  if (typeof policy !== "object" || policy === null || Array.isArray(policy) || Object.keys(policy).sort().join(",") !== "maxAblations,runId,schemaVersion,source" || !("schemaVersion" in policy) || policy.schemaVersion !== 2 || !("runId" in policy) || policy.runId !== runId || !("maxAblations" in policy) || typeof policy.maxAblations !== "number" || !Number.isSafeInteger(policy.maxAblations) || policy.maxAblations < 1 || !("source" in policy) || typeof policy.source !== "string" || !["flag", "config", "default"].includes(policy.source)) {
-    throw new Error("canary policy invalid");
-  }
-  return policy;
-}
-var count = z5.number().int().nonnegative();
-var digest = z5.string().regex(/^[a-f0-9]{64}$/);
-var completionSchema = z5.object({
-  schemaVersion: z5.literal(2),
-  runId: z5.string().min(1),
-  candidateId: z5.string().min(1),
-  attributedObservationId: z5.string().min(1),
-  observedStateDigest: digest,
-  result: z5.union([
-    z5.object({
-      kind: z5.literal("ablated"),
-      crossCheck: z5.enum(CROSS_CHECKS),
-      corpusDigest: digest,
-      k: z5.number().int().min(3).refine((k) => k % 2 === 1),
-      baseSeed: z5.number().int(),
-      seeds: z5.array(z5.number().int()),
-      seedHonored: z5.boolean(),
-      spend: z5.object({ modelCalls: count, screens: count, promptTokens: count, completionTokens: count }).strict(),
-      gate2Dir: z5.string().min(1)
-    }).strict().refine((result) => result.seeds.length === result.k && result.seeds[0] === result.baseSeed),
-    z5.object({ kind: z5.literal("error"), message: z5.literal("ablation-error") }).strict(),
-    z5.object({ kind: z5.literal("unavailable"), reason: z5.literal("ablation-unavailable") }).strict(),
-    z5.object({ kind: z5.literal("no-eval-root") }).strict()
-  ])
-}).strict();
-var COMPLETIONS_DIR = "canary-completions";
-function readCompletedCanaryAblations(runDir, runId) {
-  const dir = join6(runDir, COMPLETIONS_DIR);
-  let names;
-  try {
-    names = readdirSync(dir).sort();
-  } catch (error) {
-    if (error.code === "ENOENT") return [];
-    throw new Error("completed canary evidence unavailable");
-  }
-  return names.filter((name) => !name.startsWith(".")).map((name) => {
-    let value;
-    try {
-      value = completionSchema.parse(JSON.parse(readFileSync2(join6(dir, name), "utf8")));
-    } catch {
-      throw new Error("completed canary evidence invalid");
-    }
-    if (value.runId !== runId || name !== `${sha256hex(value.candidateId)}.json`) {
-      throw new Error("completed canary evidence identity mismatch");
-    }
-    return value;
-  });
-}
-function saveCompletedCanaryAblation(runDir, input) {
-  const value = completionSchema.parse(input);
-  const dir = join6(runDir, COMPLETIONS_DIR);
-  mkdirSync3(dir, { recursive: true });
-  const file = join6(dir, `${sha256hex(value.candidateId)}.json`);
-  const temporary = join6(dir, `.${randomUUID2()}.tmp`);
-  const text = canonicalJson2(value) + "\n";
-  try {
-    writeFileSync2(temporary, text, { flag: "wx", mode: 384 });
-    const fd = openSync2(temporary, "r");
-    try {
-      fsyncSync2(fd);
-    } finally {
-      closeSync2(fd);
-    }
-    try {
-      linkSync(temporary, file);
-    } catch (error) {
-      if (error.code !== "EEXIST" || readFileSync2(file, "utf8") !== text) {
-        throw new Error("completed canary evidence conflict");
-      }
-    }
-    const directory = openSync2(dir, "r");
-    try {
-      fsyncSync2(directory);
-    } finally {
-      closeSync2(directory);
-    }
-  } finally {
-    rmSync3(temporary, { force: true });
-  }
-}
-
-// src/curation/misdirection-run-state.ts
-import {
-  chmodSync as chmodSync2,
-  closeSync as closeSync3,
-  fsyncSync as fsyncSync3,
-  linkSync as linkSync2,
-  mkdirSync as mkdirSync4,
-  openSync as openSync3,
-  readFileSync as readFileSync3,
-  readdirSync as readdirSync2,
-  renameSync as renameSync2,
-  rmSync as rmSync4,
-  statSync,
-  writeFileSync as writeFileSync3
-} from "fs";
-import { randomUUID as randomUUID3 } from "crypto";
-import { dirname as dirname6, join as join7 } from "path";
-import { z as z6 } from "zod";
+import { readFileSync as readFileSync2 } from "fs";
+import { isAbsolute as isAbsolute2, join as join5 } from "path";
+import { LOCAL_CURATION_CAPABILITIES as LOCAL_CURATION_CAPABILITIES2 } from "@vostride/agent-qa-agent-local";
 import {
-  MisdirectionRecordResultSchema,
-  canonicalJson as canonicalJson3,
-  sha256hex as sha256hex2
+  admitAnalysisArtifactForRun,
+  ANALYSIS_FILE,
+  canonicalJson as canonicalJson2,
+  guardRunAnalysisArtifact,
+  normalizeAnchor,
+  resolveRunVerdicts
 } from "@vostride/agent-qa-schema";
-var MISDIRECTION_COMPLETIONS_DIR = "misdirection-completions";
-function misdirectionCheckKeyDigest(key) {
-  return sha256hex2(
-    canonicalJson3({
-      runId: key.runId,
-      perTest: key.perTest,
-      stepIndex: key.stepIndex,
-      decisionOrdinal: key.decisionOrdinal,
-      recordId: key.recordId
-    })
-  );
-}
-var policySchema = z6.object({
-  schemaVersion: z6.literal(2),
-  runId: z6.string().min(1),
-  maxChecks: z6.number().int().nonnegative(),
-  source: z6.enum(["flag", "default"])
-}).strict();
-var reservationSchema = z6.object({
-  schemaVersion: z6.literal(2),
-  runId: z6.string().min(1),
-  perTest: z6.number().int().nonnegative(),
-  stepIndex: z6.number().int().nonnegative(),
-  decisionOrdinal: z6.number().int().nonnegative(),
-  recordId: z6.string().min(1),
-  handoffBaseDigest: z6.string().min(1),
-  briefDigest: z6.string().min(1),
-  corpusDigest: z6.string().min(1),
-  profileDigest: z6.string().min(1)
-}).strict();
-function readDocuments(dir, unavailable) {
-  let names;
-  try {
-    names = readdirSync2(dir).sort();
-  } catch (error) {
-    if (error.code === "ENOENT") return [];
-    throw new Error(unavailable);
-  }
-  return names.filter((name) => !name.startsWith(".")).map((name) => ({ name, text: readFileSync3(join7(dir, name), "utf8") }));
-}
-function readCompletedMisdirectionChecks(runDir, runId) {
-  return readDocuments(
-    join7(runDir, MISDIRECTION_COMPLETIONS_DIR),
-    "completed misdirection evidence unavailable"
-  ).map(({ name, text }) => {
-    let value;
-    try {
-      value = MisdirectionRecordResultSchema.parse(JSON.parse(text));
-    } catch {
-      throw new Error("completed misdirection evidence invalid");
-    }
-    if (value.runId !== runId || name !== `${misdirectionCheckKeyDigest(value)}.json`) {
-      throw new Error("completed misdirection evidence identity mismatch");
-    }
-    return value;
-  });
-}
-var postureSchema = z6.object({
-  schemaVersion: z6.literal(2),
-  runId: z6.string().min(1),
-  kind: z6.enum(["eval-root", "no-eval-root", "broken-eval-root"]),
-  corpusDigest: z6.string().min(1).optional(),
-  profileDigest: z6.string().min(1).optional(),
-  reason: z6.string().min(1).optional()
-}).strict();
 
 // src/curation/canary-credit.ts
-import {
-  actedPair as actedPair3,
-  canonicalJson as canonicalJson4,
-  distilledScreenStateDigest,
-  exercisedAnchors as exercisedAnchors2,
-  normalizeAnchor
-} from "@vostride/agent-qa-schema";
 function emptyCanaryCreditCounters() {
-  return {
-    credited: 0,
-    rideAlongUncredited: 0,
-    ablationCapExceeded: 0,
-    ablationHeld: 0,
-    ablationInconclusive: 0,
-    ablationError: 0,
-    rerunExcluded: 0,
-    nonSignal: { environment: 0, timeout: 0, flake: 0 },
-    staged: 0,
-    stagingRefused: 0
-  };
+  return { rideAlongUncredited: 0, rerunExcluded: 0, nonSignal: { environment: 0, timeout: 0, flake: 0 } };
 }
-async function creditCanaryAttributions(input) {
-  if (!Number.isSafeInteger(input.maxAblations) || input.maxAblations < 1) {
-    throw new TypeError("--max-ablations must be a positive integer");
-  }
+function creditCanaryAttributions(input) {
   const counters = emptyCanaryCreditCounters();
   const attributions = [];
-  let digestRead = false;
-  let corpusDigest;
-  const ablatedCandidates = /* @__PURE__ */ new Set();
-  const completedByCandidate = new Map(input.completedAblations.map((entry) => [entry.candidateId, entry]));
-  let ablationsRun = completedByCandidate.size;
   for (const row of input.attributions) {
     if (row.kind !== "outcome") {
       attributions.push(row);
       continue;
     }
-    const served = row.source === "served-brief";
-    if (served && input.ablation !== void 0 && !digestRead) {
-      digestRead = true;
-      try {
-        const digest2 = await input.ablation.corpusDigest();
-        if (digest2.kind === "digest") corpusDigest = digest2.corpusDigest;
-      } catch {
-      }
-    }
     const outcome = {
       ...row.outcome,
-      stateValidity: "unknown",
-      benefit: row.outcome.runOutcome === "negative" ? "exercised-harmed" : "rode-along",
-      ...served && corpusDigest !== void 0 ? { corpusDigest } : {}
+      benefit: row.outcome.runOutcome === "negative" ? "exercised-harmed" : "rode-along"
     };
-    if (!served || corpusDigest === void 0) delete outcome.corpusDigest;
-    delete outcome.observedStateDigest;
-    delete outcome.ablation;
-    if (served) {
-      const step = input.handoff.tests.find((test) => test.testIndex === outcome.testIndex && test.testId === outcome.testId)?.steps.find((candidate) => candidate.stepIndex === outcome.stepIndex);
-      const live = step?.subActions?.filter((action2) => action2.exchanges !== void 0) ?? [];
-      const action = live.length === 1 ? live[0] : void 0;
-      const acted = action === void 0 ? void 0 : actedSubAction(action);
-      const observed = step !== void 0 && acted !== void 0 && exercisedAnchors2({ ...step, subActions: [acted] }).some((anchor) => canonicalJson4(normalizeAnchor(anchor)) === canonicalJson4(normalizeAnchor(outcome.exercisedAnchor))) ? actedPair3(acted).stateBefore : void 0;
-      if (observed !== void 0) outcome.observedStateDigest = distilledScreenStateDigest(observed);
-      const bundle = input.readBundleStateDigests({
-        knowledgeRoot: input.knowledgeRoot,
-        candidateId: outcome.candidateId
-      });
-      if (outcome.observedStateDigest !== void 0 && bundle.kind === "found" && bundle.digests.length > 0) {
-        outcome.stateValidity = bundle.digests.includes(outcome.observedStateDigest) ? "valid" : "stale";
-      }
-    }
-    let crossCheck = "not-run";
-    let corpusDigestMoved;
-    const completed = completedByCandidate.get(outcome.candidateId);
-    if (outcome.runOutcome === "positive") {
-      if (!served || input.ablation === void 0) {
-        counters.rideAlongUncredited += 1;
-      } else if (outcome.observedStateDigest === void 0) {
-        counters.ablationInconclusive += 1;
-      } else if (ablatedCandidates.has(outcome.candidateId)) {
-        counters.rideAlongUncredited += 1;
-      } else if (completed !== void 0 && (completed.attributedObservationId !== input.observationIdOf(outcome) || completed.observedStateDigest !== outcome.observedStateDigest)) {
-        counters.rideAlongUncredited += 1;
-      } else if (completed === void 0 && ablationsRun >= input.maxAblations) {
-        counters.ablationCapExceeded += 1;
-      } else {
-        ablatedCandidates.add(outcome.candidateId);
-        let result;
-        if (completed !== void 0) result = completed.result;
-        else {
-          ablationsRun += 1;
-          try {
-            result = await input.ablation.ablate({
-              handoff: input.handoff,
-              runDir: input.runDir,
-              candidateId: outcome.candidateId,
-              runId: outcome.runId,
-              testId: outcome.testId,
-              testIndex: outcome.testIndex,
-              stepIndex: outcome.stepIndex,
-              attributedObservationId: input.observationIdOf(outcome)
-            });
-          } catch (error) {
-            result = { kind: "error", message: error instanceof Error ? error.message : String(error) };
-          }
-          input.saveCompletedAblation({
-            schemaVersion: 2,
-            runId: outcome.runId,
-            candidateId: outcome.candidateId,
-            attributedObservationId: input.observationIdOf(outcome),
-            observedStateDigest: outcome.observedStateDigest,
-            result: result.kind === "ablated" ? {
-              kind: "ablated",
-              crossCheck: result.crossCheck,
-              corpusDigest: result.corpusDigest,
-              k: result.k,
-              baseSeed: result.baseSeed,
-              seeds: result.seeds,
-              seedHonored: result.seedHonored,
-              spend: result.spend,
-              gate2Dir: result.gate2Dir
-            } : result.kind === "error" ? { kind: "error", message: "ablation-error" } : result.kind === "unavailable" ? { kind: "unavailable", reason: "ablation-unavailable" } : { kind: "no-eval-root" }
-          });
-        }
-        switch (result.kind) {
-          case "ablated":
-            crossCheck = result.crossCheck;
-            if (corpusDigest !== void 0 && corpusDigest !== result.corpusDigest) corpusDigestMoved = true;
-            outcome.corpusDigest = result.corpusDigest;
-            outcome.ablation = {
-              crossCheck,
-              k: result.k,
-              baseSeed: result.baseSeed,
-              seeds: result.seeds,
-              seedHonored: result.seedHonored,
-              spend: result.spend
-            };
-            if (crossCheck === "flipped") {
-              outcome.benefit = "exercised-benefited";
-              counters.credited += 1;
-            } else if (crossCheck === "held") counters.ablationHeld += 1;
-            else counters.ablationInconclusive += 1;
-            break;
-          case "no-eval-root":
-            counters.rideAlongUncredited += 1;
-            break;
-          case "unavailable":
-            counters.ablationInconclusive += 1;
-            break;
-          case "error":
-            counters.ablationError += 1;
-            break;
-        }
-      }
-    }
-    let staged;
-    if (served && input.ablation !== void 0 && outcome.observedStateDigest !== void 0) {
-      try {
-        const product = input.handoff.scope.tier === "product" && input.handoff.scope.key !== "" && input.handoff.scope.key !== "unknown" ? input.handoff.scope.key : "default";
-        const stateDigest = outcome.observedStateDigest;
-        if (await input.ablation.isNovel({ product, stateDigest })) {
-          const stage = await input.ablation.stage({
-            handoff: input.handoff,
-            runDir: input.runDir,
-            candidateId: outcome.candidateId,
-            runId: outcome.runId,
-            testId: outcome.testId,
-            testIndex: outcome.testIndex,
-            stepIndex: outcome.stepIndex,
-            attributedObservationId: input.observationIdOf(outcome),
-            product,
-            stateDigest,
-            benefit: outcome.benefit
-          });
-          if (stage.kind === "staged") {
-            counters.staged += 1;
-            staged = true;
-          } else if (!["already-staged", "not-novel", "no-eval-root"].includes(stage.kind)) counters.stagingRefused += 1;
-        }
-      } catch {
-        counters.stagingRefused += 1;
-      }
-    }
-    attributions.push({
-      ...row,
-      outcome,
-      crossCheck,
-      ...staged === void 0 ? {} : { staged },
-      ...corpusDigestMoved === void 0 ? {} : { corpusDigestMoved }
-    });
+    if (outcome.runOutcome === "positive") counters.rideAlongUncredited += 1;
+    attributions.push({ ...row, outcome });
   }
   return { attributions, counters };
 }
@@ -6083,7 +2434,7 @@ function resolveAttributionClasses(artifact, handoff) {
   for (const member of handoff.tests) {
     if (member.rootCause !== void 0) classes.set(member.testIndex, member.rootCause.class);
   }
-  for (const verdict of resolveRunVerdicts2(artifact, handoff)) {
+  for (const verdict of resolveRunVerdicts(artifact, handoff)) {
     classes.set(verdict.perTest, verdict.class);
   }
   return classes;
@@ -6091,13 +2442,13 @@ function resolveAttributionClasses(artifact, handoff) {
 function loadRunAnalysisArtifact(runDir, runId) {
   let bytes;
   try {
-    bytes = readFileSync6(join10(runDir, ANALYSIS_FILE2), "utf8");
+    bytes = readFileSync2(join5(runDir, ANALYSIS_FILE), "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw error;
   }
-  const admission = admitAnalysisArtifactForRun2(
-    guardRunAnalysisArtifact2(JSON.parse(bytes)),
+  const admission = admitAnalysisArtifactForRun(
+    guardRunAnalysisArtifact(JSON.parse(bytes)),
     runId
   );
   return admission.kind === "admitted" ? admission.artifact : void 0;
@@ -6108,7 +2459,7 @@ var STALENESS_MISS_REASONS = /* @__PURE__ */ new Set([
   "page-anchor-mismatch"
 ]);
 function normalizedKey(anchor) {
-  return canonicalJson7(normalizeAnchor2(anchor));
+  return canonicalJson2(normalizeAnchor(anchor));
 }
 function nonAttributableFailure(test, resolved) {
   const resolvedClass = resolved.get(test.testIndex);
@@ -6119,45 +2470,6 @@ function attributedOutcome(test, step, resolved) {
   if (nonAttributableFailure(test, resolved)) return void 0;
   return "negative";
 }
-var EXPOSURE_SEPARATOR = "";
-function exposureKey(perTest, stepIndex, recordId) {
-  return [perTest, stepIndex, recordId].join(EXPOSURE_SEPARATOR);
-}
-function flippedExposures(handoff, evidence) {
-  if (evidence === void 0 || evidence.length === 0) return /* @__PURE__ */ new Set();
-  const runId = String(handoff.runId);
-  const baseDigest = misdirectionSourceDigest(handoff);
-  const exposed = /* @__PURE__ */ new Set();
-  for (const test of handoff.tests) {
-    for (const site of deriveMemoryOnPathSites(test.steps)) {
-      exposed.add(exposureKey(test.testIndex, site.stepIndex, site.recordId));
-    }
-  }
-  const flipped = /* @__PURE__ */ new Set();
-  const answered = /* @__PURE__ */ new Set();
-  for (const row of evidence) {
-    if (row.runId !== runId) continue;
-    if (row.handoffBaseDigest !== baseDigest) continue;
-    const key = exposureKey(row.perTest, row.stepIndex, row.recordId);
-    if (!exposed.has(key)) continue;
-    if (answered.has(key)) {
-      flipped.delete(key);
-      continue;
-    }
-    answered.add(key);
-    if (row.crossCheck === "flipped") flipped.add(key);
-  }
-  return flipped;
-}
-function causalRecordsOn(test, step, flipped) {
-  if (flipped.size === 0 || step.verifierVerdict.pass) return [];
-  const ids = [];
-  for (const site of deriveMemoryOnPathSites([step])) {
-    if (!flipped.has(exposureKey(test.testIndex, site.stepIndex, site.recordId))) continue;
-    if (!ids.includes(site.recordId)) ids.push(site.recordId);
-  }
-  return ids;
-}
 function procedureReplayOutcome(test, step, resolved) {
   const source = step.planSource;
   if (source === void 0 || source.kind !== "procedure-replay") return void 0;
@@ -6193,7 +2505,7 @@ function servedCanaryIds(step) {
 }
 function firstMatchingAnchor(candidateAnchors, stepAnchors) {
   const exercisedByKey = new Map(
-    stepAnchors.map((anchor) => [normalizedKey(anchor), normalizeAnchor2(anchor)])
+    stepAnchors.map((anchor) => [normalizedKey(anchor), normalizeAnchor(anchor)])
   );
   for (const candidateAnchor of candidateAnchors) {
     const match = exercisedByKey.get(normalizedKey(candidateAnchor));
@@ -6218,10 +2530,6 @@ function projectCanaryAttributions(input) {
     return resolutionByCandidate.get(id);
   };
   const resolved = resolveAttributionClasses(input.artifact, input.handoff);
-  const flipped = flippedExposures(
-    input.handoff,
-    input.misdirectionEvidence ?? input.handoff.misdirectionEvidence
-  );
   const projected = [];
   for (const test of input.handoff.tests) {
     if (test.isRerun === true) {
@@ -6229,45 +2537,33 @@ function projectCanaryAttributions(input) {
       continue;
     }
     for (const step of test.steps) {
-      projectBriefAttributions(input, test, step, resolveAnchors, resolved, flipped, projected);
+      projectBriefAttributions(input, test, step, resolveAnchors, resolved, projected);
       projectProcedureAttribution(input, test, step, resolveAnchors, resolved, projected);
     }
   }
   return projected;
 }
-function projectBriefAttributions(input, test, step, resolveAnchors, resolved, flipped, projected) {
+function projectBriefAttributions(input, test, step, resolveAnchors, resolved, projected) {
   const runOutcome = attributedOutcome(test, step, resolved);
   const resolvedClass = resolved.get(test.testIndex);
-  const causal = causalRecordsOn(test, step, flipped);
-  const causalSet = new Set(causal);
-  const nonSignal = (candidateId) => {
+  if (runOutcome === void 0) {
     if (resolvedClass === void 0 || !isNonSignalClass(resolvedClass)) return;
-    projected.push({
-      kind: "non-signal",
-      source: "served-brief",
-      class: resolvedClass,
-      candidateId,
-      testId: test.testId,
-      testIndex: test.testIndex,
-      stepIndex: step.stepIndex
-    });
-  };
-  if (runOutcome === void 0 && causal.length === 0) {
-    for (const candidateId of servedCanaryIds(step)) nonSignal(candidateId);
+    for (const candidateId of servedCanaryIds(step)) {
+      projected.push({
+        kind: "non-signal",
+        source: "served-brief",
+        class: resolvedClass,
+        candidateId,
+        testId: test.testId,
+        testIndex: test.testIndex,
+        stepIndex: step.stepIndex
+      });
+    }
     return;
   }
   const stepAnchors = exercisedAnchors(step);
-  if (stepAnchors.length === 0 && causal.length === 0) return;
-  const served = servedCanaryIds(step);
-  const candidateIds = [...served, ...causal.filter((id) => !served.includes(id))];
-  for (const candidateId of candidateIds) {
-    const causalRow = causalSet.has(candidateId);
-    const rowOutcome = causalRow ? "negative" : runOutcome;
-    if (rowOutcome === void 0) {
-      nonSignal(candidateId);
-      continue;
-    }
-    if (!causalRow && stepAnchors.length === 0) continue;
+  if (stepAnchors.length === 0) return;
+  for (const candidateId of servedCanaryIds(step)) {
     const resolution = resolveAnchors(candidateId);
     if (resolution.kind === "unresolved") {
       projected.push({
@@ -6282,20 +2578,16 @@ function projectBriefAttributions(input, test, step, resolveAnchors, resolved, f
       });
       continue;
     }
-    const contacted = firstMatchingAnchor(resolution.anchors, stepAnchors);
-    const fallback = resolution.anchors[0];
-    const exercisedAnchor = contacted ?? (causalRow && fallback !== void 0 ? normalizeAnchor2(fallback) : void 0);
+    const exercisedAnchor = firstMatchingAnchor(resolution.anchors, stepAnchors);
     if (exercisedAnchor === void 0) continue;
     projected.push({
       kind: "outcome",
       source: "served-brief",
-      ...causalRow ? { misdirectionFlipped: true } : {},
       outcome: {
         candidateId,
-        runOutcome: rowOutcome,
-        // 2026-09-07, 418 D-01/D-08: pure projection stays uncredited until ablated.
+        runOutcome,
+        // The credit pass sets the benefit from the run outcome.
         benefit: "rode-along",
-        stateValidity: "unknown",
         runId: String(input.handoff.runId),
         testId: test.testId,
         testIndex: test.testIndex,
@@ -6304,10 +2596,9 @@ function projectBriefAttributions(input, test, step, resolveAnchors, resolved, f
         briefDigest: step.servedBrief.briefDigest,
         attribution: [
           `Candidate ${candidateId}`,
-          `matched ${canonicalJson7(exercisedAnchor)}`,
+          `matched ${canonicalJson2(exercisedAnchor)}`,
           `on test ${test.testIndex} (${test.testId}) step ${step.stepIndex}`,
-          `with ${rowOutcome} verdict`,
-          ...causalRow ? ["after the misdirection cross-check flipped"] : []
+          `with ${runOutcome} verdict`
         ].join(" "),
         exercisedAnchor
       }
@@ -6360,9 +2651,8 @@ function projectProcedureAttribution(input, test, step, resolveAnchors, resolved
     outcome: {
       candidateId: source.procedureId,
       runOutcome,
-      // 2026-09-07, 418 D-01/D-08: pure projection stays uncredited until ablated.
+      // The credit pass sets the benefit from the run outcome.
       benefit: "rode-along",
-      stateValidity: "unknown",
       runId: String(input.handoff.runId),
       testId: test.testId,
       testIndex: test.testIndex,
@@ -6374,7 +2664,7 @@ function projectProcedureAttribution(input, test, step, resolveAnchors, resolved
         `on test ${test.testIndex} (${test.testId}) step ${step.stepIndex}`,
         attributionDetail
       ].join(" "),
-      exercisedAnchor: normalizeAnchor2(anchor)
+      exercisedAnchor: normalizeAnchor(anchor)
     }
   });
 }
@@ -6384,45 +2674,27 @@ function projectCanaryOutcomes(input) {
   );
 }
 async function emitCanaryOutcomes(opts) {
-  if (!isAbsolute3(opts.knowledgeRoot)) throw new TypeError("knowledgeRoot must be absolute");
-  if (!isAbsolute3(opts.runDir)) throw new TypeError("runDir must be absolute");
+  if (!isAbsolute2(opts.knowledgeRoot)) throw new TypeError("knowledgeRoot must be absolute");
+  if (!isAbsolute2(opts.runDir)) throw new TypeError("runDir must be absolute");
   const artifact = loadRunAnalysisArtifact(opts.runDir, String(opts.handoff.runId));
-  const recovered = opts.handoff.misdirectionEvidence === void 0 ? readCompletedMisdirectionChecks(opts.runDir, String(opts.handoff.runId)) : void 0;
   const projected = projectCanaryAttributions({
     handoff: opts.handoff,
     ...artifact === void 0 ? {} : { artifact },
-    ...recovered === void 0 || recovered.length === 0 ? {} : { misdirectionEvidence: recovered },
-    resolveCandidateAnchors: (id) => LOCAL_CURATION_CAPABILITIES4.readCanonicalBundleAnchors({
+    resolveCandidateAnchors: (id) => LOCAL_CURATION_CAPABILITIES2.readCanonicalBundleAnchors({
       knowledgeRoot: opts.knowledgeRoot,
       bundleId: id
     })
   });
-  const credit = opts.credit === void 0 ? void 0 : await creditCanaryAttributions({
-    completedAblations: readCompletedCanaryAblations(opts.runDir, String(opts.handoff.runId)),
-    saveCompletedAblation: (entry) => saveCompletedCanaryAblation(opts.runDir, entry),
-    attributions: projected,
-    handoff: opts.handoff,
-    runDir: opts.runDir,
-    ...opts.credit,
-    knowledgeRoot: opts.knowledgeRoot,
-    observationIdOf: LOCAL_CURATION_CAPABILITIES4.canaryOutcomeObservationId,
-    maxAblations: opts.credit.maxAblations ?? (await Promise.resolve().then(() => (init_eval_session_composition(), eval_session_composition_exports))).GATE2_DEFAULT_MAX_ABLATIONS,
-    readBundleStateDigests: opts.credit.readBundleStateDigests ?? LOCAL_CURATION_CAPABILITIES4.readCanonicalBundleStateDigests
-  });
-  const canary = credit?.counters ?? emptyCanaryCreditCounters();
-  if (credit === void 0) {
-    canary.rideAlongUncredited = projected.filter((row) => row.kind === "outcome" && row.outcome.runOutcome === "positive").length;
-  }
+  const credit = creditCanaryAttributions({ attributions: projected });
   const report = {
-    canary,
+    canary: credit.counters,
     emitted: 0,
     refused: 0,
     unresolved: 0,
     procedure: { emitted: 0, refused: 0, unresolved: 0 },
     details: []
   };
-  const attributions = credit?.attributions ?? projected;
-  for (const attribution of attributions) {
+  for (const attribution of credit.attributions) {
     if (attribution.kind === "rerun-excluded") {
       report.canary.rerunExcluded += 1;
       report.details.push({
@@ -6462,7 +2734,6 @@ async function emitCanaryOutcomes(opts) {
       });
       continue;
     }
-    const causal = attribution.misdirectionFlipped === true;
     let outcome;
     try {
       opts.emit(attribution.outcome);
@@ -6477,10 +2748,6 @@ async function emitCanaryOutcomes(opts) {
     }
     report.details.push({
       benefit: attribution.outcome.benefit,
-      crossCheck: attribution.crossCheck ?? "not-run",
-      ...attribution.staged === void 0 ? {} : { staged: attribution.staged },
-      ...attribution.corpusDigestMoved === void 0 ? {} : { corpusDigestMoved: attribution.corpusDigestMoved },
-      ...causal ? { misdirectionFlipped: true } : {},
       candidateId: attribution.outcome.candidateId,
       testId: attribution.outcome.testId,
       testIndex: attribution.outcome.testIndex,
@@ -6491,42 +2758,126 @@ async function emitCanaryOutcomes(opts) {
   return report;
 }
 
-// src/curation/curation-tail.ts
-init_promotion_posture();
+// src/curation/promotion-line.ts
+function renderPromotionLine(entry) {
+  return entry.promotionPath === void 0 ? `curation: ${entry.candidateId} held: ${entry.promotionHoldReason}` : `curation: ${entry.candidateId} promoted via ${entry.promotionPath}`;
+}
 
 // src/curation/run-curation-context.ts
-init_declared_secrets();
-init_config();
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import {
-  closeSync as closeSync4,
-  fsyncSync as fsyncSync4,
-  linkSync as linkSync3,
-  lstatSync as lstatSync3,
-  openSync as openSync4,
-  readFileSync as readFileSync7,
-  rmSync as rmSync5,
-  writeFileSync as writeFileSync4
+  closeSync as closeSync2,
+  fsyncSync as fsyncSync2,
+  linkSync,
+  lstatSync as lstatSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync4,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync2
 } from "fs";
-import { dirname as dirname12, isAbsolute as isAbsolute4, join as join11, resolve as resolve7 } from "path";
-import { z as z8 } from "zod";
+import { dirname as dirname7, isAbsolute as isAbsolute3, join as join6, resolve as resolve3 } from "path";
+import { z as z5 } from "zod";
+
+// src/composition/declared-secrets.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3, statSync } from "fs";
+import { parse as parseYaml2 } from "yaml";
+import { resolveWorkspacePaths } from "@vostride/agent-qa-core";
+import { SecretRedactor, SecretStore } from "@vostride/agent-qa-runner";
+var DeclaredSecretsUnavailableError = class _DeclaredSecretsUnavailableError extends Error {
+  lines;
+  constructor(lines) {
+    super(lines.join(" "));
+    this.name = "DeclaredSecretsUnavailableError";
+    this.lines = lines;
+  }
+  static required() {
+    return new _DeclaredSecretsUnavailableError([
+      "Error: workspace.secretsFile is required. Run `agent-qa init` or set it in agent-qa.config.yaml."
+    ]);
+  }
+};
+function readDeclaredSecrets(secretsPath) {
+  if (!existsSync2(secretsPath)) {
+    throw new DeclaredSecretsUnavailableError([
+      `Error: Secrets file not found: ${secretsPath}`,
+      "Create the file before running tests. It may be empty, but it must exist."
+    ]);
+  }
+  let content;
+  try {
+    content = readFileSync3(secretsPath, "utf-8");
+  } catch {
+    throw new DeclaredSecretsUnavailableError([
+      `Error: Secrets file could not be read: ${secretsPath}`,
+      "Check the path and file permissions before running tests."
+    ]);
+  }
+  try {
+    return SecretStore.fromEnvContent(content);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new DeclaredSecretsUnavailableError([`Error: Secrets file is invalid: ${message}`]);
+  }
+}
+function resolveSecretsPath(configPath) {
+  const file = parseYaml2(readFileSync3(configPath, "utf-8")) ?? {};
+  const config = mergeConfigs(file, loadEnvOverrides(), {});
+  const configured = config?.workspace?.secretsFile;
+  if (typeof configured !== "string" || configured.trim().length === 0) {
+    throw DeclaredSecretsUnavailableError.required();
+  }
+  const workspace = resolveWorkspacePaths({ config, configPath });
+  return workspace.secretsFile.absolutePath;
+}
+function statKey(path) {
+  const stat = statSync(path);
+  return `${stat.mtimeMs}:${stat.size}:${stat.ino}`;
+}
+function createDeclaredSecretMask(configPath) {
+  let resolved;
+  let cached;
+  const currentSecretsPath = () => {
+    const configKey = statKey(configPath);
+    if (resolved?.configKey !== configKey) {
+      resolved = void 0;
+      resolved = { configKey, secretsPath: resolveSecretsPath(configPath) };
+    }
+    return resolved.secretsPath;
+  };
+  const redactor = () => {
+    const secretsPath = currentSecretsPath();
+    let key;
+    try {
+      key = `${secretsPath}\0${statKey(secretsPath)}`;
+    } catch {
+      key = void 0;
+    }
+    if (key !== void 0 && cached?.key === key) return cached.redactor;
+    const current = new SecretRedactor(readDeclaredSecrets(secretsPath));
+    cached = key === void 0 ? void 0 : { key, redactor: current };
+    return current;
+  };
+  return { mask: (text) => redactor().redactString(text), redactor };
+}
+
+// src/curation/run-curation-context.ts
 var RUN_CONFIG_RECORD_FILE = "run-config.json";
 var RUN_CONFIG_RECORD_SCHEMA_VERSION = 2;
-var runConfigRecordSchema = z8.object({
-  schemaVersion: z8.literal(RUN_CONFIG_RECORD_SCHEMA_VERSION),
-  runId: z8.string().min(1),
-  configPath: z8.string().min(1)
+var runConfigRecordSchema = z5.object({
+  schemaVersion: z5.literal(RUN_CONFIG_RECORD_SCHEMA_VERSION),
+  runId: z5.string().min(1),
+  configPath: z5.string().min(1)
 }).strict();
 function runConfigRecordPath(agentQaRoot, runId) {
-  return join11(completedRunDir(agentQaRoot, runId), RUN_CONFIG_RECORD_FILE);
+  return join6(completedRunDir(agentQaRoot, runId), RUN_CONFIG_RECORD_FILE);
 }
 function readRunConfigRecord(agentQaRoot, runId) {
   const path = runConfigRecordPath(agentQaRoot, runId);
   try {
-    if (!lstatSync3(path).isFile()) return void 0;
-    const parsed = runConfigRecordSchema.safeParse(JSON.parse(readFileSync7(path, "utf8")));
+    if (!lstatSync2(path).isFile()) return void 0;
+    const parsed = runConfigRecordSchema.safeParse(JSON.parse(readFileSync4(path, "utf8")));
     if (!parsed.success) return void 0;
-    if (parsed.data.runId !== runId || !isAbsolute4(parsed.data.configPath)) return void 0;
+    if (parsed.data.runId !== runId || !isAbsolute3(parsed.data.configPath)) return void 0;
     return parsed.data;
   } catch {
     return void 0;
@@ -6554,13 +2905,13 @@ async function resolveRunCurationContext(input) {
   let knowledgeRoot;
   try {
     const config = await resolveConfig({ configPath, loadAuthPlugins: false });
-    knowledgeRoot = resolveConfiguredKnowledgeRoot(config, dirname12(configPath));
+    knowledgeRoot = resolveConfiguredKnowledgeRoot(config, dirname7(configPath));
   } catch {
     return {
       handBack: `Run ${runId} was recorded under ${configPath}, which cannot be read as an agent-qa config, so it is left for a run that can read it.`
     };
   }
-  if (resolve7(knowledgeRoot) !== resolve7(input.drainerKnowledgeRoot)) {
+  if (resolve3(knowledgeRoot) !== resolve3(input.drainerKnowledgeRoot)) {
     return {
       handBack: `Run ${runId} keeps its knowledge in ${knowledgeRoot}; it is left for a run of its own project.`
     };
@@ -6588,18 +2939,18 @@ var CURATION_TAIL_RECEIPT_FILE = "curation-tail-receipt.json";
 var CURATION_TAIL_RECEIPT_SCHEMA_VERSION = 2;
 function defaultOperations() {
   return {
-    loadCompletedRunHandoff: loadCompletedRunHandoff2,
-    resolveKnowledgeRoot: resolveKnowledgeRoot3,
-    runSafetyScope: runSafetyScope3,
+    loadCompletedRunHandoff,
+    resolveKnowledgeRoot: resolveKnowledgeRoot2,
+    runSafetyScope,
     emitCurationCandidates,
-    openKnowledgeReader: LOCAL_CURATION_CAPABILITIES5.openKnowledgeReader,
+    openKnowledgeReader: LOCAL_CURATION_CAPABILITIES3.openKnowledgeReader,
     emitCanaryOutcomes,
-    foldRunOutcomes: LOCAL_CURATION_CAPABILITIES5.foldRunOutcomes,
-    reconcileRunOutcomesProjection: LOCAL_CURATION_CAPABILITIES5.reconcileRunOutcomesProjection,
-    acquireWriterLease: LOCAL_CURATION_CAPABILITIES5.maintenance.acquireWriterLease,
-    releaseLease: LOCAL_CURATION_CAPABILITIES5.maintenance.releaseLease,
+    foldRunOutcomes: LOCAL_CURATION_CAPABILITIES3.foldRunOutcomes,
+    reconcileRunOutcomesProjection: LOCAL_CURATION_CAPABILITIES3.reconcileRunOutcomesProjection,
+    acquireWriterLease: LOCAL_CURATION_CAPABILITIES3.maintenance.acquireWriterLease,
+    releaseLease: LOCAL_CURATION_CAPABILITIES3.maintenance.releaseLease,
     buildCuratorAuthor,
-    drainQueue: LOCAL_CURATION_CAPABILITIES5.drainQueue,
+    drainQueue: LOCAL_CURATION_CAPABILITIES3.drainQueue,
     listCompletedRunDirs,
     readCurationTailReceipt,
     writeCurationTailReceipt,
@@ -6608,15 +2959,15 @@ function defaultOperations() {
   };
 }
 function completedRunDir(agentQaRoot, runId) {
-  return join12(agentQaRoot, RUNS_SUBDIR3, slugBranch3(runId));
+  return join7(agentQaRoot, RUNS_SUBDIR, slugBranch(runId));
 }
 function completedRunsRoot(agentQaRoot) {
-  return join12(agentQaRoot, RUNS_SUBDIR3);
+  return join7(agentQaRoot, RUNS_SUBDIR);
 }
 function listCompletedRunDirs(agentQaRoot) {
   const runsRoot = completedRunsRoot(agentQaRoot);
-  if (!existsSync5(runsRoot)) return [];
-  return readdirSync5(runsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join12(runsRoot, entry.name)).filter((runDir) => existsSync5(join12(runDir, HANDOFF_FILE3))).sort();
+  if (!existsSync3(runsRoot)) return [];
+  return readdirSync(runsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join7(runsRoot, entry.name)).filter((runDir) => existsSync3(join7(runDir, HANDOFF_FILE))).sort();
 }
 function isSortedCandidateIds(value) {
   if (!Array.isArray(value)) return false;
@@ -6628,12 +2979,12 @@ function isSortedCandidateIds(value) {
 function isCanaryCreditCounters(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
   const record = value;
-  if (Object.keys(record).sort().join(",") !== "ablationCapExceeded,ablationError,ablationHeld,ablationInconclusive,credited,nonSignal,rerunExcluded,rideAlongUncredited,staged,stagingRefused") return false;
-  const count2 = (entry) => typeof entry === "number" && Number.isInteger(entry) && entry >= 0;
-  if (!Object.entries(record).every(([key, entry]) => key === "nonSignal" || count2(entry))) return false;
+  if (Object.keys(record).sort().join(",") !== "nonSignal,rerunExcluded,rideAlongUncredited") return false;
+  const count = (entry) => typeof entry === "number" && Number.isInteger(entry) && entry >= 0;
+  if (!Object.entries(record).every(([key, entry]) => key === "nonSignal" || count(entry))) return false;
   const nonSignal = record.nonSignal;
   if (typeof nonSignal !== "object" || nonSignal === null || Array.isArray(nonSignal)) return false;
-  return Object.keys(nonSignal).sort().join(",") === [...NON_SIGNAL_CLASSES].sort().join(",") && Object.values(nonSignal).every(count2);
+  return Object.keys(nonSignal).sort().join(",") === [...NON_SIGNAL_CLASSES].sort().join(",") && Object.values(nonSignal).every(count);
 }
 function isCurationTailReceipt(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
@@ -6644,7 +2995,7 @@ function isCurationTailReceipt(value) {
 function readCurationTailReceipt(runDir) {
   try {
     const parsed = JSON.parse(
-      readFileSync8(join12(runDir, CURATION_TAIL_RECEIPT_FILE), "utf8")
+      readFileSync5(join7(runDir, CURATION_TAIL_RECEIPT_FILE), "utf8")
     );
     return isCurationTailReceipt(parsed) ? parsed : void 0;
   } catch {
@@ -6652,36 +3003,36 @@ function readCurationTailReceipt(runDir) {
   }
 }
 function fsyncFile(file) {
-  const fd = openSync5(file, "r");
+  const fd = openSync3(file, "r");
   try {
-    fsyncSync5(fd);
+    fsyncSync3(fd);
   } finally {
-    closeSync5(fd);
+    closeSync3(fd);
   }
 }
 function writeCurationTailReceipt(runDir, receipt) {
   if (!isCurationTailReceipt(receipt)) throw new TypeError("invalid curation tail receipt");
-  const file = join12(runDir, CURATION_TAIL_RECEIPT_FILE);
-  const staged = join12(runDir, `.${CURATION_TAIL_RECEIPT_FILE}.${randomUUID5()}.tmp`);
+  const file = join7(runDir, CURATION_TAIL_RECEIPT_FILE);
+  const staged = join7(runDir, `.${CURATION_TAIL_RECEIPT_FILE}.${randomUUID3()}.tmp`);
   try {
-    writeFileSync5(staged, `${canonicalJson8(receipt)}
+    writeFileSync3(staged, `${canonicalJson3(receipt)}
 `, { encoding: "utf8", mode: 384 });
     fsyncFile(staged);
-    renameSync3(staged, file);
+    renameSync2(staged, file);
     fsyncFile(runDir);
   } finally {
-    rmSync6(staged, { force: true });
+    rmSync4(staged, { force: true });
   }
 }
 function curationTailHandoffDigest(handoff) {
-  return sha256hex4(canonicalJson8(handoff));
+  return sha256hex(canonicalJson3(handoff));
 }
 function receiptIdentityForHandoff(handoff) {
   return {
     schemaVersion: CURATION_TAIL_RECEIPT_SCHEMA_VERSION,
     runId: String(handoff.runId),
     handoffDigest: curationTailHandoffDigest(handoff),
-    projectionVersion: LOCAL_CURATION_CAPABILITIES5.runOutcomesProjectionVersion
+    projectionVersion: LOCAL_CURATION_CAPABILITIES3.runOutcomesProjectionVersion
   };
 }
 function receiptMatches(receipt, expected) {
@@ -6706,12 +3057,6 @@ function candidateSummaryLine(runId, report) {
   });
   return `Knowledge curation candidates for ${runId}: ${segments.join("; ")}.`;
 }
-function misdirectionHarmLine(runId, rows) {
-  const landed = rows.filter((row) => row.outcome.kind === "emitted");
-  const refused = rows.length - landed.length;
-  const named = rows.map((row) => row.candidateId).join(", ");
-  return `Misdirection harm for ${runId}: ${landed.length} harmed outcome(s) emitted from flipped cross-check evidence regardless of verdict class (${named})${refused === 0 ? "" : `; ${refused} refused by the queue`}.`;
-}
 function curationOutcomeLine(input) {
   if (input.committed <= 0) return void 0;
   const proposed = Math.min(Math.max(input.downgraded, 0), input.committed);
@@ -6779,7 +3124,6 @@ async function curateCompletedRun(input) {
       deprecated: previous.deprecated ?? 0,
       complete: true,
       drainKind: previous.drainKind,
-      candidateIds: previous.candidateIds,
       snapshot: previous.snapshot
     };
   }
@@ -6794,7 +3138,7 @@ async function curateCompletedRun(input) {
   const budgetMs = input.deadlineMs === void 0 ? void 0 : Math.max(0, input.deadlineMs - tailStartedAtMs);
   await operations.runSafetyScope(
     {
-      // SAFE-01: posture is persisted run truth, never an ambient re-detection.
+      // Posture is persisted run truth, never an ambient re-detection.
       executionContext: input.handoff.executionContext
     },
     async () => {
@@ -6805,29 +3149,13 @@ async function curateCompletedRun(input) {
         ...input.mask === void 0 ? {} : { mask: input.mask }
       });
       input.log.info?.(candidateSummaryLine(receiptIdentity.runId, candidates));
-      const reader = operations.openKnowledgeReader({
-        knowledgeRoot: input.knowledgeRoot,
-        priors: input.resolveTrustPriors?.()
-      });
-      const ablation = operations.canaryAblation;
-      const recordedPolicy = readRunCanaryPolicy(input.runDir, String(input.handoff.runId));
-      const caps = ablation === void 0 ? void 0 : recordedPolicy ?? (input.maxAblations !== void 0 ? { maxAblations: input.maxAblations, source: "flag" } : await ablation.resolveCaps?.() ?? {
-        maxAblations: (await Promise.resolve().then(() => (init_eval_session_composition(), eval_session_composition_exports))).GATE2_DEFAULT_MAX_ABLATIONS,
-        source: "default"
-      });
-      if (ablation !== void 0 && recordedPolicy === void 0) input.log.info?.("canary cap: legacy run without recorded policy; using explicit run override or current config/default");
-      if (caps !== void 0) input.log.info?.(`canary cap: maxAblations=${caps.maxAblations} (${caps.source})`);
+      const reader = operations.openKnowledgeReader({ knowledgeRoot: input.knowledgeRoot });
       const canaries = await operations.emitCanaryOutcomes({
         handoff: input.handoff,
         knowledgeRoot: input.knowledgeRoot,
         runDir: input.runDir,
-        emit: reader.emitCanaryOutcome.bind(reader),
-        ...operations.canaryAblation === void 0 ? {} : { credit: { ablation: operations.canaryAblation, maxAblations: caps.maxAblations, readBundleStateDigests: LOCAL_CURATION_CAPABILITIES5.readCanonicalBundleStateDigests } }
+        emit: reader.emitCanaryOutcome.bind(reader)
       });
-      const causalHarm = (canaries.details ?? []).filter((row) => row.misdirectionFlipped === true);
-      if (causalHarm.length > 0) {
-        input.log.info?.(misdirectionHarmLine(receiptIdentity.runId, causalHarm));
-      }
       try {
         const fold = operations.foldRunOutcomes({
           knowledgeRoot: input.knowledgeRoot,
@@ -6852,15 +3180,13 @@ async function curateCompletedRun(input) {
       }));
       const drain = await operations.drainQueue({
         sourceRunId: String(input.handoff.runId),
-        observationIds: (canaries.details ?? []).flatMap((row) => row.candidateId === void 0 || row.outcome.kind !== "emitted" ? [] : [LOCAL_CURATION_CAPABILITIES5.canaryOutcomeObservationId({
+        observationIds: (canaries.details ?? []).flatMap((row) => row.candidateId === void 0 || row.outcome.kind !== "emitted" ? [] : [LOCAL_CURATION_CAPABILITIES3.canaryOutcomeObservationId({
           candidateId: row.candidateId,
           runId: input.handoff.runId,
           testId: row.testId,
           testIndex: row.testIndex,
           stepIndex: row.stepIndex
         })]),
-        priors: input.resolveTrustPriors?.(),
-        ...input.resolvePromotionPosture === void 0 ? {} : { resolvePromotionPosture: input.resolvePromotionPosture },
         knowledgeRoot: input.knowledgeRoot,
         author,
         executionContext: input.handoff.executionContext,
@@ -6902,8 +3228,7 @@ async function curateCompletedRun(input) {
           drainKind: drain.kind,
           handoffHolderPid: drain.kind === "handed-off" ? drain.holder.pid : null,
           candidateIds: sortedCandidateIds(candidates),
-          // WR-08: the counts travel beside the snapshot, which is exactly when the rerun short-circuit
-          // answers from this receipt; a handed-off receipt has no counts of its own to record.
+          // Counts travel with the snapshot, when the rerun short-circuit answers from the receipt.
           ...validated?.success === true ? { snapshot: validated.data, curated, deprecated } : {}
         };
       }
@@ -6948,7 +3273,6 @@ async function curateCompletedRun(input) {
     deprecated,
     complete: true,
     drainKind,
-    candidateIds: completedReceipt.candidateIds,
     ...completedReceipt.snapshot === void 0 ? {} : { snapshot: completedReceipt.snapshot }
   };
 }
@@ -6961,7 +3285,7 @@ async function runCurationTail(opts) {
   let currentHandoff;
   try {
     currentHandoff = operations.loadCompletedRunHandoff(
-      join12(currentRunDir, HANDOFF_FILE3)
+      join7(currentRunDir, HANDOFF_FILE)
     );
   } catch {
     opts.log.warn(
@@ -7003,7 +3327,7 @@ async function runCurationTail(opts) {
       opts.log.warn("curation: run-outcome projection not reconciled (no writer authority)");
     } else if (reconcile.kind === "rebuilt") {
       opts.log.info?.(
-        `curation: run-outcome projection rebuilt at version ${LOCAL_CURATION_CAPABILITIES5.runOutcomesProjectionVersion} (folded ${reconcile.report.folded}, skipped ${reconcile.report.skippedHandoffs} handoff, ${reconcile.report.skippedArtifacts} artifact)`
+        `curation: run-outcome projection rebuilt at version ${LOCAL_CURATION_CAPABILITIES3.runOutcomesProjectionVersion} (folded ${reconcile.report.folded}, skipped ${reconcile.report.skippedHandoffs} handoff, ${reconcile.report.skippedArtifacts} artifact)`
       );
     }
   } catch (error) {
@@ -7025,7 +3349,7 @@ async function runCurationTail(opts) {
   for (const runDir of runDirs) {
     let handoff;
     try {
-      handoff = runDir === currentRunDir ? currentHandoff : operations.loadCompletedRunHandoff(join12(runDir, HANDOFF_FILE3));
+      handoff = runDir === currentRunDir ? currentHandoff : operations.loadCompletedRunHandoff(join7(runDir, HANDOFF_FILE));
     } catch {
       opts.log.warn(`Skipping post-verdict knowledge curation for ${runDir}: handoff is malformed.`);
       continue;
@@ -7047,11 +3371,7 @@ async function runCurationTail(opts) {
         }
         runMask = context.mask;
       }
-      const resolvePromotionPosture = opts.resolvePromotionPostureForRun === void 0 ? opts.resolvePromotionPosture : await opts.resolvePromotionPostureForRun(handoff.buildOrdinal, handoff.scope);
       const folded = await curateCompletedRun({
-        resolveTrustPriors: opts.resolveTrustPriors,
-        ...runDir !== currentRunDir || opts.maxAblations === void 0 ? {} : { maxAblations: opts.maxAblations },
-        ...resolvePromotionPosture === void 0 ? {} : { resolvePromotionPosture },
         runDir,
         handoff,
         knowledgeRoot,
@@ -7133,7 +3453,6 @@ export {
   normalizeConfigForValidation,
   projectCanaryOutcomes,
   purgeAll,
-  purgeTest,
   readAnalyticsPrivacyDeclaration,
   resolveConfig,
   resolveConfiguredKnowledgeRoot,