cadet-agent 0.30.0 → 0.32.0

package/package.json

@@ -1,37 +1,37 @@
-{
-  "name": "cadet-agent",
-  "version": "0.30.0",
-  "description": "Cross-IDE agent framework for Unity/C# game-development — one-command install",
-  "type": "module",
-  "bin": {
-    "cadet-agent": "bin/cli.mjs"
-  },
-  "scripts": {
-    "test": "node --test test/*.test.mjs",
-    "lint": "lychee --offline --include-fragments \"**/*.md\"",
-    "verify": "npm test && npm run lint"
-  },
-  "files": [
-    "bin/",
-    "src/"
-  ],
-  "keywords": [
-    "cadet",
-    "cadet-agent",
-    "unity",
-    "game-development",
-    "ai-agent",
-    "copilot",
-    "cursor",
-    "claude-code"
-  ],
-  "license": "CC-BY-4.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/naishtech/cadet-agent.git"
-  },
-  "homepage": "https://github.com/naishtech/cadet-agent#readme",
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}
+{
+  "name": "cadet-agent",
+  "version": "0.32.0",
+  "description": "Cross-IDE agent framework for Unity/C# game-development — one-command install",
+  "type": "module",
+  "bin": {
+    "cadet-agent": "bin/cli.mjs"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "lint": "lychee --offline --include-fragments \"**/*.md\"",
+    "verify": "npm test && npm run lint"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "keywords": [
+    "cadet",
+    "cadet-agent",
+    "unity",
+    "game-development",
+    "ai-agent",
+    "copilot",
+    "cursor",
+    "claude-code"
+  ],
+  "license": "CC-BY-4.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/naishtech/cadet-agent.git"
+  },
+  "homepage": "https://github.com/naishtech/cadet-agent#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/cli.mjs

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { install, sync } from './install.mjs';
@@ -6,7 +6,9 @@ import {
   validateState, migrateStateFile, readState, writeState, evaluateTransition, applyTransition,
   workItemIdOf, loadPolicy, RunLedger, loadRun, listRuns, cleanupRuns, buildReport, formatReport,
   runVerificationLoop, commandForGate, detectCapabilities, runsDir, gitChangedFiles, PolicyError, StateError,
-  detectRepoRole, describeRepoRole,
+  detectRepoRole, describeRepoRole, GATES, manualConfirmation,
+  parseTestInventory, parseStoryCriteria, compareCoverage, describeCoverageGaps,
+  createEvidence, newId, computeInputTreeHash, hashCriteria,
 } from './harness/index.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -39,7 +41,9 @@ function showHelp() {
     cadet-agent state transition --to <phase>   Enforce the transition matrix + evidence
 
     cadet-agent harness record      Append a sanitized span/evidence/decision event
+    cadet-agent harness confirm     Record manual-confirmation evidence (writes ledger + state)
     cadet-agent harness verify      Run a bounded, classified verification loop
+    cadet-agent harness verify-acs  Verify declared AC↔test coverage against a test report
     cadet-agent harness report      Summarize budget consumption and failures
     cadet-agent harness cleanup     Apply the retention policy to .cadet/runs/
     cadet-agent harness capabilities  Report available CLI/Unity/MCP/hook/token/cost telemetry
@@ -49,9 +53,13 @@ function showHelp() {
     --source       Release API URL override (for forked deployments)
     --format       human|json (default: human)
     --to           Target phase (state transition)
-    --gate         Gate name (harness verify)
+    --gate         Gate name (harness verify|confirm)
     --command      Command override (harness verify)
-    --files        Comma-separated relevant files to bind evidence to (harness verify)
+    --files        Comma-separated relevant files to bind evidence to (harness verify|confirm)
+    --reason       Why automation was unavailable (harness confirm)
+    --expires-at   ISO-8601 expiry bounding the confirmation (harness confirm)
+    --environment  key=value,... describing what was verified (harness confirm)
+    --scope        Comma-separated scope of the confirmation (harness confirm)
     --agents-md    keep|overwrite|merge for an existing AGENTS.md (init/sync)
     --yes, -y      Never prompt; keep existing files (non-interactive installs)
     --help, -h    Show this help
@@ -77,8 +85,14 @@ function parseArgs(argv) {
       case '--run': opts.runId = argv[++i]; break;
       case '--type': opts.type = argv[++i]; break;
       case '--reason': opts.reason = argv[++i]; break;
+      case '--expires-at': opts.expiresAt = argv[++i]; break;
+      case '--environment': opts.environment = argv[++i]; break;
+      case '--scope': opts.scope = (argv[++i] || '').split(',').map((s) => s.trim()).filter(Boolean); break;
       case '--evidence-status': opts.evidenceStatus = argv[++i]; break;
       case '--files': opts.files = (argv[++i] || '').split(',').map((s) => s.trim()).filter(Boolean); break;
+      case '--story': opts.story = argv[++i]; break;
+      case '--report': opts.report = argv[++i]; break;
+      case '--write-coverage': opts.writeCoverage = true; break;
       case '--older-than-ms': opts.olderThanMs = Number(argv[++i]); break;
       case '--agents-md': opts.agentsMd = argv[++i]; break;
       case '--yes': case '-y': opts.yes = true; break;
@@ -96,6 +110,28 @@ function emit(opts, human, json) {
   }
 }
 
+/**
+ * Parse `--environment "projectPath=...,editorVersion=...,tool=...,host=..."`
+ * into an object. Unknown keys are preserved: an unusual environment is still
+ * evidence, and silently dropping a field would misrepresent what was verified.
+ */
+function parseEnvironment(raw) {
+  const env = {};
+  if (!raw) return env;
+  for (const part of String(raw).split(',')) {
+    const eq = part.indexOf('=');
+    if (eq === -1) {
+      const key = part.trim();
+      if (key) env[key] = true;
+      continue;
+    }
+    const key = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (key) env[key] = value;
+  }
+  return env;
+}
+
 function fail(opts, message, code = json => json.exitCode || 1, json = {}) {
   const exitCode = code(json);
   if (opts.format === 'json') {
@@ -127,8 +163,12 @@ async function cmdState(opts) {
       );
       return;
     }
-    // Pass rootDir so stale/foreign evidence is caught at validation time.
-    const result = validateState(state, { rootDir: opts.targetDir });
+    // Pass rootDir so stale/foreign evidence is caught at validation time, and
+    // the resolved policy so strict-closure rules are actually enforced. Without
+    // the policy, `strictClosure` was invisible here and every strict rule was
+    // silently skipped — the feature would "install cleanly and do nothing".
+    const policy = loadPolicy(opts.targetDir);
+    const result = validateState(state, { rootDir: opts.targetDir, strictClosure: policy.strictClosure });
     const role = detectRepoRole(opts.targetDir);
     const repoRoleDetail = describeRepoRole(role);
     if (opts.format === 'json') {
@@ -212,6 +252,137 @@ async function cmdHarness(opts) {
     return;
   }
 
+  if (sub === 'confirm') {
+    const gate = opts.gate;
+    if (!gate) fail(opts, 'harness confirm requires --gate <gate>');
+    if (!GATES.includes(gate)) fail(opts, `unknown gate "${gate}". Valid gates: ${GATES.join(', ')}`);
+
+    const { exists, state } = readState(opts.targetDir);
+    if (!exists) fail(opts, 'No .cadet/state.json found. Initialise state before recording confirmation.', () => 2);
+
+    const strict = policy.strictClosure?.enabled === true ? policy.strictClosure : null;
+    const mc = strict?.manualConfirmation || null;
+    // One reference instant for the whole command, captured before any work.
+    // Reading Date.now() at the check instead made the validity boundary
+    // non-deterministic: process latency absorbed a small overage, so the same
+    // input could pass or fail run to run.
+    const requestedAt = new Date();
+
+    // Collect EVERY missing field so the caller fixes the record in one pass,
+    // rather than discovering one omission per invocation.
+    const missing = [];
+    if (mc?.requireReason !== false && strict && (!opts.reason || String(opts.reason).trim() === '')) missing.push('--reason');
+    if (mc?.requireExpiresAt !== false && strict) {
+      if (!opts.expiresAt) missing.push('--expires-at');
+      else if (Number.isNaN(Date.parse(opts.expiresAt))) missing.push('--expires-at (not an ISO-8601 date-time)');
+    }
+    if (mc?.requireEnvironment !== false && strict && (!opts.environment || String(opts.environment).trim() === '')) missing.push('--environment');
+    if (mc?.requireScope !== false && strict && (!opts.scope || opts.scope.length === 0)) missing.push('--scope');
+    if (missing.length) {
+      fail(opts, `strictClosure requires manual-confirmation metadata. Missing: ${missing.join(', ')}.`, () => 1, { ok: false, gate, code: 'strict-metadata-missing', missing });
+    }
+
+    // A gate listed in disallowManualFor may never be satisfied by a human
+    // assertion; point at the automated path instead of accepting the record.
+    if (strict && Array.isArray(strict.disallowManualFor) && strict.disallowManualFor.includes(gate)) {
+      fail(opts, `manual-confirmation is not permitted for gate "${gate}" under strictClosure.disallowManualFor; run "cadet-agent harness verify --gate ${gate}" instead.`, () => 1, { ok: false, gate, code: 'manual-disallowed' });
+    }
+
+    // Bound the validity window: an expiry far in the future is how a manual
+    // assertion silently becomes permanent. Measured against `requestedAt`, the
+    // single instant captured at command start, so the boundary is deterministic
+    // and agrees with `validateState` (which anchors to the present too).
+    if (mc?.maxValidityMs !== null && mc?.maxValidityMs !== undefined && opts.expiresAt) {
+      const window = Date.parse(opts.expiresAt) - requestedAt.getTime();
+      if (Number.isFinite(window) && window > mc.maxValidityMs) {
+        fail(opts, `requested validity ${window}ms exceeds strictClosure.manualConfirmation.maxValidityMs (${mc.maxValidityMs}ms).`, () => 1, { ok: false, gate, code: 'validity-exceeded', requestedMs: window, maxValidityMs: mc.maxValidityMs });
+      }
+    }
+
+    // Freshness binding mirrors `harness verify`: never record a gate against an
+    // unknown input tree unless the repository explicitly opted out.
+    const allowEmpty = policy?.allowEmptyFreshness === true;
+    let relevantFiles;
+    if (opts.files && opts.files.length) {
+      relevantFiles = opts.files.map((f) => f.replace(/\\/g, '/'));
+    } else {
+      const changed = gitChangedFiles(opts.targetDir);
+      if (!changed.available) {
+        if (!allowEmpty) {
+          fail(opts, `cannot establish freshness coverage: ${changed.reason}. Pass --files <paths>, or enable allowEmptyFreshness in .cadet/harness.json.`, () => 1, { ok: false, gate, code: 'freshness-unavailable' });
+        }
+        relevantFiles = [];
+      } else {
+        relevantFiles = changed.files;
+      }
+    }
+
+    const workItemId = state ? workItemIdOf(state) : 'unscoped';
+    const phase = state?.session?.currentPhase || 'implementation';
+    // Reuse the command-start instant so the recorded createdAt and the validity
+    // check describe the same moment.
+    const at = requestedAt;
+    const environment = parseEnvironment(opts.environment);
+
+    const { evidence } = manualConfirmation({
+      gate,
+      workItemId,
+      phase,
+      projectPath: environment.projectPath || null,
+      editorVersion: environment.editorVersion || null,
+      scope: opts.scope || [],
+      reason: opts.reason || null,
+      expiresAt: opts.expiresAt || null,
+      environment,
+      relevantFiles,
+      rootDir: opts.targetDir,
+      approvedBy: opts.approvedBy || 'user',
+      at,
+    });
+
+    // Ledger first, then state. The ledger is append-only and merely references
+    // the evidence id; state.json carries the gate claim. Writing state first
+    // would let an interruption leave a gate claimed true with no ledger entry.
+    // This order fails toward "less proven", never "claimed but unbacked".
+    const ledger = new RunLedger({
+      targetDir: opts.targetDir,
+      policy,
+      runId: state?.activeRunId || null,
+      workItemId,
+      phase,
+    });
+    ledger.addEvidence(evidence);
+    ledger.addDecision({
+      kind: 'manual-confirmation',
+      reason: opts.reason || 'manual confirmation recorded',
+      gate,
+      evidenceId: evidence.evidenceId,
+      approvedBy: evidence.approvedBy || 'user',
+    });
+    ledger.finalize({ status: 'ok' });
+    const ledgerPath = ledger.persist();
+
+    const next = { ...state };
+    const prior = Array.isArray(state.gateEvidence) ? state.gateEvidence : [];
+    next.gateEvidence = [
+      // Immutability: supersede prior passing evidence, never delete it.
+      ...prior.map((e) => (e.gate === gate && (e.status === 'passed' || e.status === 'manual-confirmation')
+        ? { ...e, status: 'superseded', supersededBy: evidence.evidenceId }
+        : e)),
+      evidence,
+    ];
+    next.gates = { ...(state.gates || {}), [gate]: true };
+    writeState(opts.targetDir, next);
+
+    const superseded = prior.filter((e) => e.gate === gate && (e.status === 'passed' || e.status === 'manual-confirmation')).length;
+    emit(
+      opts,
+      `✅ Recorded manual confirmation for gate "${gate}". Evidence: ${evidence.evidenceId}\n   Ledger: ${ledgerPath}`,
+      { ok: true, gate, evidenceId: evidence.evidenceId, runId: ledger.runId, path: ledgerPath, stateUpdated: true, superseded },
+    );
+    return;
+  }
+
   if (sub === 'record') {
     const { state } = readState(opts.targetDir);
     const ledger = new RunLedger({
@@ -372,6 +543,164 @@ async function cmdHarness(opts) {
     return;
   }
 
+  if (sub === 'verify-acs') {
+    // Mechanical AC↔test verification (contract v4). Declared tests must appear
+    // in the inventory of a run that actually executed them; a name that was
+    // never written cannot be asserted into coverage.
+    if (!opts.story) fail(opts, 'harness verify-acs requires --story <path>');
+    const { exists, state } = readState(opts.targetDir);
+    const strict = policy.strictClosure?.enabled === true;
+    const workItemId = state ? workItemIdOf(state) : 'unscoped';
+    const phase = state?.session?.currentPhase || 'implementation';
+
+    let criteria;
+    try {
+      ({ criteria } = parseStoryCriteria(opts.story));
+    } catch (err) {
+      fail(opts, `cannot parse story "${opts.story}": ${err.message}`, () => 1, { ok: false, code: 'story-parse', story: opts.story });
+    }
+    if (criteria.length === 0) {
+      fail(opts, `story "${opts.story}" declares no acceptance criteria (expected a "## Acceptance Criteria" section).`, () => 1, { ok: false, code: 'no-criteria', story: opts.story });
+    }
+
+    // Resolve the inventory: an explicit --report, else the artifact of the most
+    // recent passing testsPassed evidence. Neither resolving is `blocked`, never
+    // a pass — an unproven inventory cannot satisfy coverage.
+    let reportText = null;
+    let reportSource = null;
+    let reportPath = null;
+    if (opts.report) {
+      try {
+        reportText = readFileSync(opts.report, 'utf-8');
+        reportSource = 'explicit';
+        reportPath = opts.report;
+      } catch (err) {
+        fail(opts, `cannot read --report "${opts.report}": ${err.message}`, () => 1, { ok: false, code: 'report-unreadable', report: opts.report });
+      }
+    } else if (exists) {
+      const prior = Array.isArray(state.gateEvidence) ? state.gateEvidence : [];
+      const passing = prior
+        .filter((e) => e.gate === 'testsPassed' && e.status === 'passed' && e.artifactPath)
+        .sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+      const newest = passing[0];
+      if (newest) {
+        try {
+          reportText = readFileSync(newest.artifactPath, 'utf-8');
+          reportSource = 'testsPassed-evidence';
+          reportPath = newest.artifactPath;
+        } catch { /* fall through to blocked */ }
+      }
+    }
+    if (reportText === null) {
+      const detail = { ok: false, story: opts.story, blocked: true, code: 'no-test-report', reason: 'no test report available: pass --report <path>, or run `cadet-agent harness verify --gate testsPassed` first so its artifact can be read.' };
+      if (opts.format === 'json') emit(opts, '', detail);
+      else console.error(`❌ ${detail.reason}`);
+      process.exit(1);
+    }
+
+    const inventory = parseTestInventory(reportText);
+    const coverage = compareCoverage(criteria, inventory);
+    const gaps = describeCoverageGaps(coverage);
+
+    // Under strict closure an unknown/empty inventory can never prove coverage,
+    // even if every AC declared no tests in a way that looked consistent.
+    const unknownInventory = inventory.format === 'unknown' || inventory.names.length === 0;
+    const effectiveOk = coverage.ok && !unknownInventory;
+
+    if (!strict) {
+      // v2/v3 parity: report, write nothing, exit 0.
+      if (opts.format === 'json') {
+        emit(opts, '', { ok: effectiveOk, story: opts.story, ac: coverage.ac, inventorySize: coverage.inventorySize, format: inventory.format, gateSet: false, reportPath });
+      } else if (effectiveOk) {
+        console.log(`✅ AC coverage verified for ${opts.story} (${coverage.ac.length} criteria, ${coverage.inventorySize} tests in inventory).`);
+        console.log('   strictClosure is off — reported only, state.json unchanged.');
+      } else {
+        console.error(`⚠️  AC coverage gaps in ${opts.story} (strictClosure off — reported only):`);
+        if (unknownInventory) console.error(`   no test inventory could be derived from ${reportPath || 'the report'} (format: ${inventory.format}).`);
+        for (const g of gaps) console.error(g);
+      }
+      if (!effectiveOk) process.exit(1);
+      return;
+    }
+
+    if (!effectiveOk) {
+      const detail = { ok: false, story: opts.story, ac: coverage.ac, inventorySize: coverage.inventorySize, format: inventory.format, gateSet: false, code: unknownInventory ? 'inventory-unknown' : 'coverage-gap' };
+      if (opts.format === 'json') emit(opts, '', detail);
+      else {
+        console.error(`❌ Cannot set acceptanceCriteriaValidated for ${opts.story}:`);
+        if (unknownInventory) console.error(`   no test inventory could be derived from ${reportPath || 'the report'} (format: ${inventory.format}). An unparseable report proves nothing.`);
+        for (const g of gaps) console.error(g);
+      }
+      process.exit(1);
+    }
+
+    const at = new Date();
+    const criteriaStrings = coverage.ac.flatMap((a) => [a.id, ...a.declared]);
+    const nowIso = at.toISOString();
+    const evidence = createEvidence({
+      evidenceId: newId(),
+      workItemId,
+      acceptanceCriterionId: null,
+      phase,
+      gate: 'acceptanceCriteriaValidated',
+      status: 'passed',
+      command: `harness verify-acs --story ${opts.story}`,
+      result: `AC coverage verified: ${coverage.ac.length} criteria, inventory ${coverage.inventorySize} (${inventory.format})`,
+      exitCode: 0,
+      inputTreeHash: computeInputTreeHash(opts.targetDir, [opts.story, ...(reportPath ? [reportPath] : [])]),
+      criteriaHash: hashCriteria(criteriaStrings),
+      relevantFiles: [opts.story, ...(reportPath ? [reportPath] : [])].map((f) => f.replace(/\\/g, '/')),
+      createdAt: at,
+      expiresAt: null,
+      freshnessPolicy: 'current-story',
+      source: 'automated',
+    });
+
+    let coveragePath = null;
+    if (opts.writeCoverage) {
+      const base = opts.story.replace(/\.md$/, '');
+      coveragePath = `${base}.coverage.json`;
+      const doc = {
+        schemaVersion: 1,
+        story: opts.story.replace(/\\/g, '/'),
+        generatedAt: nowIso,
+        ac: coverage.ac,
+        inventorySize: coverage.inventorySize,
+        format: inventory.format,
+      };
+      try { writeFileSync(coveragePath, `${JSON.stringify(doc, null, 2)}\n`, 'utf-8'); } catch { coveragePath = null; }
+    }
+
+    // Ledger first, then state — the v3 ordering: fail toward "less proven".
+    const ledger = new RunLedger({ targetDir: opts.targetDir, policy, runId: state?.activeRunId || null, workItemId, phase });
+    ledger.addEvidence(evidence);
+    ledger.addDecision({ kind: 'stop', reason: `AC coverage verified via ${reportSource}`, scope: `${coverage.ac.length} criteria` });
+    ledger.finalize({ status: 'ok' });
+    const ledgerPath = ledger.persist();
+
+    if (exists) {
+      const next = { ...state };
+      const priorEv = Array.isArray(state.gateEvidence) ? state.gateEvidence : [];
+      next.gateEvidence = [
+        ...priorEv.map((e) => (e.gate === 'acceptanceCriteriaValidated' && (e.status === 'passed' || e.status === 'manual-confirmation')
+          ? { ...e, status: 'superseded', supersededBy: evidence.evidenceId }
+          : e)),
+        evidence,
+      ];
+      next.gates = { ...(state.gates || {}), acceptanceCriteriaValidated: true };
+      writeState(opts.targetDir, next);
+    }
+
+    if (opts.format === 'json') {
+      emit(opts, '', { ok: true, story: opts.story, ac: coverage.ac, inventorySize: coverage.inventorySize, format: inventory.format, gateSet: exists, coveragePath, evidenceId: evidence.evidenceId, runId: ledger.runId, path: ledgerPath });
+    } else {
+      console.log(`✅ acceptanceCriteriaValidated for ${opts.story} (${coverage.ac.length} criteria, inventory ${coverage.inventorySize}, ${inventory.format}).`);
+      console.log(`   Ledger: ${ledgerPath}`);
+      if (coveragePath) console.log(`   Coverage: ${coveragePath}`);
+    }
+    return;
+  }
+
   if (sub === 'report') {
     const runs = listRuns(opts.targetDir);
     const target = opts.runId || runs[0]?.runId;
@@ -391,7 +720,7 @@ async function cmdHarness(opts) {
     return;
   }
 
-  fail(opts, `Unknown harness subcommand: ${sub || '(none)'}. Use record|verify|report|cleanup|capabilities.`);
+  fail(opts, `Unknown harness subcommand: ${sub || '(none)'}. Use record|confirm|verify|verify-acs|report|cleanup|capabilities.`);
 }
 
 export async function run(argv) {

package/src/harness/index.mjs

@@ -8,7 +8,8 @@
 export {
   PHASES, GATES, TRANSITIONS, EVIDENCE_STATUSES, RETRY_CLASSES, CONTEXT_TIERS,
   DEFAULT_BUDGETS, HARD_CEILINGS, DEFAULT_ARCHIVE_LIMITS, DEFAULT_OUTPUT_POLICY,
-  DEFAULT_RETENTION, DEFAULT_ESTIMATION, DEFAULT_HOOK_POLICY,
+  DEFAULT_RETENTION, DEFAULT_ESTIMATION, DEFAULT_HOOK_POLICY, DEFAULT_STRICT_CLOSURE,
+  EXCEPTION_CATEGORIES, EXCEPTION_EXPIRY_DAYS, EXCEPTION_REQUIRES_REVIEW_NOTE, AGENT_OWNED_GATES,
   validatePolicy, defaultPolicy, loadPolicy, budgetForScope, policyPath, PolicyError,
 } from './policy.mjs';
 
@@ -22,9 +23,9 @@ export {
 } from './util.mjs';
 
 export {
-  STATE_VERSION, validateState, migrateStateV1toV2, migrateStateFile,
+  STATE_VERSION, READABLE_STATE_VERSIONS, validateState, migrateStateV1toV2, migrateStateFile,
   createEvidence, computeInputTreeHash, workItemIdOf, evidenceFreshness,
-  latestEvidenceForGate, activeExceptions, requiredGates, evaluateTransition,
+  latestEvidenceForGate, activeExceptions, requiredGates, evaluateTransition, resolveStrict,
   applyTransition, resetGatesForNewWorkItem, statePathFor, readState, writeState, writeJsonAtomic, StateError,
 } from './state.mjs';
 
@@ -62,3 +63,9 @@ export {
 export {
   REPO_ROLES, REPO_ROLE_MARKER, detectRepoRole, isFrameworkSourceWithoutWorkItem, describeRepoRole,
 } from './repo-role.mjs';
+
+export {
+  INVENTORY_FORMATS, COVERAGE_STATUSES, DEFAULT_MAX_REPORT_BYTES, DEFAULT_MAX_INVENTORY_ENTRIES,
+  normalizeTestName, parseTestInventory, parseStoryCriteria, parseStoryCriteriaText,
+  compareCoverage, describeCoverageGaps,
+} from './verify-acs.mjs';