bmad-method-test-architecture-enterprise 2.0.2 → 2.0.3

package/.claude-plugin/marketplace.json

@@ -31,16 +31,14 @@
       "name": "bmad-method-test-architecture-enterprise",
       "source": "./",
       "description": "Master Test Architect module for quality strategy, test generation in red and expand modes with automatic run-and-heal, combined framework and CI setup, CI/CD quality gates, and structured testing education. The CI and ATDD commands remain available with existing customizations. Part of the BMad Method ecosystem.",
-      "version": "2.0.2",
+      "version": "2.0.3",
       "author": {
         "name": "Murat K Ozcan (TEA Creator) & Brian (BMad) Madison"
       },
       "skills": [
         "./skills/bmod-tea",
         "./skills/bmad-tea",
-        "./skills/bmad-testarch-atdd",
         "./skills/bmad-testarch-automate",
-        "./skills/bmad-testarch-ci",
         "./skills/bmad-testarch-evaluate",
         "./skills/bmad-testarch-framework",
         "./skills/bmad-testarch-nfr",

package/README.md

@@ -50,7 +50,7 @@ npx skills add https://github.com/bmad-code-org/bmad-method-test-architecture-en
 
 ## Start with one skill
 
-Ten commands start the eight skills: Framework includes CI setup; Automate includes red and expand modes.
+Eight commands start the eight workflows: Framework includes CI setup; Automate includes red and expand modes.
 
 In Claude Code, Cursor, and Windsurf, type `/bmad-testarch-test-design` in chat.
 In Codex, type `$bmad-testarch-test-design`.
@@ -73,10 +73,10 @@ Evaluate:
 
 Framework and CI setup share one skill, `bmad-testarch-framework`.
 Ask for framework only, CI only, or both; TEA infers the scope from your prompt and asks "Do you want CI too?" once when CI scope is unclear in an interactive session. An unattended request with unclear scope runs framework setup only and states that CI was excluded.
-`/bmad-testarch-ci` and the `CI` menu code still work and start the same skill's CI setup, with your existing CI customizations.
+Request CI setup through `/bmad-testarch-framework` or the agent's `CI` menu code. Existing CI customizations remain usable.
 Create, Resume, Validate, and Edit remain available for the selected setup scope.
 
-Automation uses `red` mode before implementation and `expand` mode for existing code. Your prompt selects the mode. `/bmad-testarch-atdd` and `AT` default to red; `/bmad-testarch-automate` and `TA` default to expand. Existing commands and customization files keep working. Create runs execute the generated tests and repair test issues for up to three rounds. Red confirms the intended missing behavior; expand aims for passing coverage and reports product defects.
+Automation uses `red` mode before implementation and `expand` mode for existing code. Request red mode through `/bmad-testarch-automate` or the agent's `AT` menu code; the direct command defaults to expand. Existing customization files and saved progress remain usable. Create runs execute the generated tests and repair test issues for up to three rounds. Red confirms the intended missing behavior; expand aims for passing coverage and reports product defects.
 
 For Codex, replace the leading `/` in the table with `$`.
 The agent menu also accepts `GATE` to route you through test review, NFR evidence audit, and trace Phase 2.

package/cli/evaluate.js

@@ -29,6 +29,8 @@
  *                                             compare a scored run's evidence with baseline/ through eval-quality's
  *                                             compareDominance (compared, first-run or refused, every one exit 0), or
  *                                             with --accept replace baseline/ with a byte-identical snapshot of the run
+ *   tea-evaluate status --evaluation <path> [--run <invocationId>] [--follow]
+ *                                             show the latest run's progress, or follow it until it ends
  *   tea-evaluate ci --evaluation <path> --tier <pr|merge|scheduled|release>
  *                                             run exactly the checks ci/evaluation-ci-plan.json places on the tier, in
  *                                             plan order, each one's exit, stdout and stderr kept under
@@ -130,6 +132,7 @@ const { runRunCommand } = require('./lib/evaluate/run');
 const { runCompareCommand } = require('./lib/evaluate/compare');
 const { runScoreCommand } = require('./lib/evaluate/score');
 const { runCiCommand } = require('./lib/evaluate/ci');
+const { runStatusCommand } = require('./lib/evaluate/status');
 const { TIERS } = require('./lib/evaluate/ci-plan');
 const { escapeUnprintable, findingLine } = require('./lib/evaluate/finding-lines');
 const { calibrationInputsOf } = require('./lib/evaluate/records-calibration');
@@ -265,6 +268,17 @@ function compareCommand(options) {
   return runDriven('compare', runCompareCommand, options, { run: options.run, accept: options.accept === true });
 }
 
+async function statusCommand(options) {
+  const folder = folderFrom(options);
+  const result = await runStatusCommand(folder, {
+    run: options.run,
+    follow: options.follow === true,
+    emit: (line) => process.stdout.write(`${NAME} status: ${escapeUnprintable(line)}\n`),
+  });
+  if (result.exitCode !== 0) process.stderr.write(`${NAME} status: ${escapeUnprintable(result.message)}\n`);
+  return result.exitCode;
+}
+
 async function ciCommand(options) {
   if (!TIERS.includes(options.tier)) {
     throw new UsageError(
@@ -278,7 +292,7 @@ function buildProgram(run) {
   const program = new Command();
   program
     .name(NAME)
-    .description('Validate, digest, preflight, run, score, compare and run the CI tiers of an Evaluate evaluation folder.')
+    .description('Validate, digest, preflight, run, score, compare, report status and run the CI tiers of an Evaluate evaluation folder.')
     .showHelpAfterError()
     .exitOverride()
     .configureOutput({ writeErr: (text) => process.stderr.write(text) });
@@ -338,6 +352,13 @@ function buildProgram(run) {
     .option('--run <invocationId>', 'the run to compare or accept; the most recent run when omitted')
     .option('--accept', 'replace baseline/ with a byte-identical snapshot of the run; refused for a dirty run')
     .action((options) => run(compareCommand, options));
+  program
+    .command('status')
+    .description("Show the newest run's progress, or follow it until completion; --run selects a specific invocation.")
+    .option('--evaluation <path>', 'the evaluation folder, or its evaluation.json')
+    .option('--run <invocationId>', 'the run to inspect; the most recent run when omitted')
+    .option('--follow', 'print progress changes and periodic heartbeats until the run ends')
+    .action((options) => run(statusCommand, options));
   program
     .command('ci')
     .description(
@@ -377,7 +398,9 @@ async function main(argv) {
     return await pending;
   } catch (error) {
     if (error instanceof UsageError) {
-      process.stderr.write(`${NAME}: ${error.message}\nUsage: ${NAME} <check|digest|preflight|run|score|compare|ci> --evaluation <path>\n`);
+      process.stderr.write(
+        `${NAME}: ${error.message}\nUsage: ${NAME} <check|digest|preflight|run|score|compare|status|ci> --evaluation <path>\n`,
+      );
       return EXIT_CODES.usage;
     }
     if (error instanceof CorpusIndexError) {

package/cli/lib/evaluate/confinement-audit.js

@@ -6,8 +6,8 @@
  * runtime reads. `confinement.js` holds the boundary and decides what each
  * sandbox grants; this module only observes.
  *
- *   Seatbelt     the target's profile reports every `file-read-data` it allows
- *                outside the grants (`with report`) and tags each file rule it
+ *   Seatbelt     the target's profile refuses ungranted `file-read-data` and
+ *                reports those refusals, tagging each file rule it
  *                holds with a random token of the sandbox (`with message`).
  *                The kernel logs a report as `Sandbox: <name>(<pid>) allow|
  *                deny(1) <operation> <real path>` with the token on the next

package/cli/lib/evaluate/confinement.js

@@ -147,7 +147,7 @@
  *                as the isolation manifest's `observedMounts`, which
  *                eval-quality holds against the allowed mounts and records as
  *                an isolation violation (Story 1.60). Seatbelt reports each
- *                read its profile allows outside the grants (`with report`) and
+ *                ungranted read its profile refuses and
  *                tags every file rule with a token of the sandbox (`with
  *                message`), and a `/usr/bin/log stream` child the runtime owns
  *                writes the kernel's reports of that token to a file beneath
@@ -463,15 +463,17 @@ function seatbeltLayerProfile(evaluationFolder, gitDirectory = null, hooksDirect
  * A `connect()` to a path-based unix socket is refused anywhere but the workspace, the private directories, the home and the two system services in `SEATBELT_SYSTEM_SOCKETS` (Story 1.87).
  * The rule names a path, so it holds for a socket bound after the call started.
  *
- * With `audit` (`{ token, exempt }`), the kernel reports what the profile allows or refuses.
+ * Read grants restrict file data to the workspace, system roots and explicitly declared dependencies.
+ * With `audit` (`{ token }`), the kernel reports refusals with the sandbox token.
  * Every file rule that denies carries the sandbox's token (`with message`).
- * One rule reports each `file-read-data` the profile allows outside `exempt` (the paths the sandbox may read, and the root directory itself) with the same token (`with report`).
+ * Every ungranted `file-read-data` is denied even when its diagnostic is lost by the unified log.
  * That rule is placed before every rule that follows it, so a later grant (the home, a call directory, the git directory's own entry) overrides it.
- * Without `audit` the profile is the one every earlier story generated, byte for byte.
+ * The same read boundary applies when a qualification port carries no observer.
  */
 function seatbeltTargetProfile({
   workspace,
   writable,
+  readable = [],
   evaluationFolder,
   git = null,
   privateRoot = null,
@@ -485,11 +487,8 @@ function seatbeltTargetProfile({
   const socketRules = seatbeltSocketRules(allowed);
   const socketRoutes = (candidates) => candidates.map((entry) => `(remote unix-socket ${entry})`).join('\n  ');
   const tagged = audit === null ? '' : ` (with message "${audit.token}")`;
-  // Seatbelt decides an operation by the rules that name it before the rules that name its wildcard, so the report rule
-  // (which names `file-read-data`) would override every later `file-read*` rule, whatever their order; an audited profile
-  // therefore names `file-read-data` in each rule that governs reads, which keeps the textual order (the last matching rule
-  // wins) the unaudited profile relies on.
-  const reads = audit === null ? 'file-read*' : 'file-read-data file-read*';
+  // Specific data-read grants outrank wildcard rules in Seatbelt. Every protected denial and re-grant must name the data operation.
+  const reads = 'file-read-data file-read*';
   const subpaths = (candidate) => spellings(candidate).map((entry) => `(subpath "${assertProfileSafePath(entry, refuseUnsafePath)}")`);
   // A denial of reads and writes of `paths`; an audited profile names `file-read-data` and tags it (see `reads`).
   const denials = (paths) => [`(deny ${reads} file-write*\n  ${paths.join('\n  ')}${tagged})`];
@@ -542,18 +541,12 @@ function seatbeltTargetProfile({
           `(allow file-read-metadata\n  ${reachableAncestors.flatMap(literals).join('\n  ')})`,
           `(allow network-outbound\n  ${socketRoutes(reachable.flatMap(subpaths))})`,
         ];
-  // What the sandbox may read is not reported; every other read the profile allows is (macOS reports by real path, so both spellings are named).
-  const reportRule =
-    audit === null
-      ? []
-      : [
-          `(allow file-read-data\n  (require-all\n    ${[
-            ...EXACT_GRANTS.map((entry) => `(require-not (literal "${entry}"))`),
-            ...audit.exempt
-              .flatMap(spellings)
-              .map((entry) => `(require-not (subpath "${assertProfileSafePath(entry, refuseUnsafePath)}"))`),
-          ].join('\n    ')})\n  (with report)${tagged})`,
-        ];
+  // Kernel enforcement is independent of the lossy log: ungranted data reads are refused even if their diagnostic is dropped.
+  // Keep the specific operation in later denials/re-grants so Seatbelt's wildcard precedence cannot reopen protected paths.
+  const reportRule = [
+    `(deny file-read-data${tagged})`,
+    `(allow file-read-data\n  ${[...EXACT_GRANTS.map((entry) => `(literal "${entry}")`), ...readable.flatMap(subpaths)].join('\n  ')})`,
+  ];
   // A target's git tries to write the worktree's own entry and the private repository (the index lock of a `git status`), which
   // the profile refuses and the target's git expects to fail; the refusal carries no token, so it is not an observed mount.
   const quiet =
@@ -1457,15 +1450,13 @@ function targetSandbox({
         const profile = seatbeltTargetProfile({
           workspace,
           writable: grants,
+          readable: readRoots([...grants, ...readable]),
           evaluationFolder,
           git,
           privateRoot,
           rootHome,
           rootGrants: callDirectories,
-          audit:
-            observer === null
-              ? null
-              : { token: observer.token, exempt: readRoots([...grants, ...readable]), quiet: [...ownGitEntries(), ...linked] },
+          audit: observer === null ? null : { token: observer.token, quiet: [...ownGitEntries(), ...linked] },
         });
         // `env` runs outside the sandbox and after the watchdog hop that starts every target, which is where Node adds the host's `NODE_V8_COVERAGE` to the environment; the sandbox then starts the target without it, as Bubblewrap's `--unsetenv` does.
         return {

package/cli/lib/evaluate/isolation-allowlist.js

@@ -115,7 +115,7 @@ function chanceMountNotes(legs, folder) {
  * @param {object} options
  * @param {string[]} options.mounts the offending paths, as the audit reported them
  * @param {string} options.folder the evaluation folder, for the neutral form of each path
- * @param {'legs'|'trials'} options.who
+ * @param {'legs'|'denied-legs'|'trials'} options.who
  * @returns {string|null}
  */
 function mountRefusal({ mounts, folder, who }) {
@@ -124,9 +124,11 @@ function mountRefusal({ mounts, folder, who }) {
   const named = mounts.slice(0, NAMED_PATHS).map((mount) => `mount outside allowlist: ${neutral(mount)}`);
   const list = `${named.join('; ')}${mounts.length > named.length ? `; and ${mounts.length - named.length} more` : ''}`;
   const finding =
-    who === 'legs'
-      ? `isolation manifest violation: every preflight leg opened ${mounts.length} path(s) outside the allowlist (${list}), so every trial will too, and \`score\` refuses a trial that does (exit 3).`
-      : `isolation manifest violation: the trials opened ${mounts.length} path(s) outside the allowlist, so \`score\` would exit 3 (${list}).`;
+    who === 'denied-legs'
+      ? `isolation manifest violation: every preflight leg attempted access to ${mounts.length} path(s) outside the allowlist (${list}); the kernel refused those accesses (exit 3).`
+      : who === 'legs'
+        ? `isolation manifest violation: every preflight leg opened ${mounts.length} path(s) outside the allowlist (${list}), so every trial will too, and \`score\` refuses a trial that does (exit 3).`
+        : `isolation manifest violation: the trials opened ${mounts.length} path(s) outside the allowlist, so \`score\` would exit 3 (${list}).`;
   return [
     finding,
     'If they are the files of a target that launches from outside its workspace, use one of two setups: make the registry `target` a path inside `launch.root` (for example `node_modules/.bin/tea-skill-runner` over a copy workspace, or a git workspace with `workspace.provision`), or keep the bare name and list the directories it runs from in `systemPaths`, with the bin directory that holds its link on `PATH`.',

package/cli/lib/evaluate/preflight.js

@@ -513,6 +513,8 @@ function runPreflightCommand(folder, { partition, requirePartition = false, ...o
  * @param {Set<string>|null} [options.selectedProbeIds] the probes the partition selects; every probe when null
  * @param {NodeJS.ProcessEnv} [options.env]
  * @param {(line: string) => void} [options.log]
+ * @param {number} [options.progressIntervalMs] heartbeat interval, for tests and long-running runs
+ * @param {number} [options.progressStartedAt] invocation start time, before setup
  * @param {(context: object) => PreflightOutcome|null|Promise<PreflightOutcome|null>} [options.prepare]
  * @param {(context: object) => Promise<PreflightOutcome>} [options.afterVerdict]
  * @returns {Promise<PreflightOutcome>}
@@ -520,10 +522,11 @@ function runPreflightCommand(folder, { partition, requirePartition = false, ...o
 async function runPipeline(folder, options) {
   // The invocation's run directory and run.json, held in memory, so its end is
   // recorded from what the runtime knows, never from a file read back.
-  const state = { writer: null, run: null, sealed: false, retractUnlessSealed: [] };
+  const state = { writer: null, run: null, sealed: false, retractUnlessSealed: [], progressTimer: null, finishProgress: null };
   try {
     return await recordEnd(await pipeline(folder, options, state), state);
   } finally {
+    if (state.progressTimer !== null) clearInterval(state.progressTimer);
     // The directories the run made stay held open until here, so none of
     // their inode numbers can pass to a directory the target makes.
     state.writer?.close();
@@ -543,6 +546,7 @@ function recordEnd(outcome, state) {
     const failed = [];
     for (const [what, step] of [
       ...state.retractUnlessSealed.map((file) => [`remove ${file}`, () => state.writer.remove(file)]),
+      ['record final progress', () => state.finishProgress?.('stopped')],
       ['record this end in run.json', () => state.writer.replaceJson('run.json', state.run)],
     ]) {
       try {
@@ -574,6 +578,8 @@ async function pipeline(
     selectedProbeIds = null,
     partition,
     seed,
+    progressIntervalMs = 30_000,
+    progressStartedAt,
   },
   state,
 ) {
@@ -658,6 +664,7 @@ async function pipeline(
     }
   };
   const onSignal = (name) => {
+    if (state.progressTimer !== null) clearInterval(state.progressTimer);
     removeScratch();
     if (journal) {
       try {
@@ -671,6 +678,7 @@ async function pipeline(
       for (const file of [...retractOnSignal, ...state.retractUnlessSealed]) state.writer.remove(file);
       state.run.outcome = { stage: 'signal', exitCode: null, signal: name, message: `stopped by ${name} before it finished` };
       if (state.run.command === 'run') state.run.completed = false;
+      state.finishProgress?.('stopped');
       state.writer.replaceJson('run.json', state.run);
     } catch {
       // The signal still ends the process; run.json keeps its last state.
@@ -735,6 +743,11 @@ async function pipeline(
     log(
       `pristine workspace, ${pristine.kind === 'git-worktree' ? `a detached worktree at ${pristine.commit}` : `a temp copy${pristine.dirty ? ' of the working tree' : ''}`}: ${pristine.root}`,
     );
+    if (pristine.kind === 'git-worktree' && sharedState) {
+      log(
+        'Git worktrees share repository refs, config and hooks. Keep Git writes in every worktree of this repository paused until this command ends, or use a dedicated clone for concurrent work.',
+      );
+    }
     // The evaluation folder is read from the working tree (the workspaces
     // leave it out), so uncommitted work in it reaches the run, which is then
     // dirty: no committed state names what it measured.
@@ -766,6 +779,8 @@ async function pipeline(
       runsDirectory,
       invocationId,
       seed: runSeed,
+      progressStartedAt,
+      progressIntervalMs,
       retractOnSignal,
       scratch,
       state,
@@ -826,6 +841,8 @@ async function runInWorkspaces({
   runsDirectory,
   invocationId,
   seed,
+  progressStartedAt,
+  progressIntervalMs,
   retractOnSignal,
   scratch,
   state,
@@ -877,9 +894,65 @@ async function runInWorkspaces({
     adopterTree: { repository: before.repository === null ? null : REPOSITORY, unchanged: null },
     refused: [],
   };
+  const progressStarted = progressStartedAt ?? Date.now();
+  const progressCreatedAt = Date.now();
+  const progressCreatedTick = globalThis.performance.now();
+  const setupBeforeRecordMs = Math.max(0, progressCreatedAt - progressStarted);
+  let phaseStartedTick = progressCreatedTick;
+  if (command === 'run') {
+    run.progress = {
+      phase: 'setup',
+      detail: 'Preparing the run',
+      startedAt: new Date(progressStarted).toISOString(),
+      updatedAt: new Date(progressCreatedAt).toISOString(),
+      phaseStartedAt: new Date(progressStarted).toISOString(),
+      phaseElapsedMs: setupBeforeRecordMs,
+      elapsedMs: setupBeforeRecordMs,
+      phaseDurationsMs: {},
+      completedTrials: 0,
+      totalTrials: null,
+      usage: null,
+    };
+  }
   state.run = run;
   const writeRun = () => writer.replaceJson('run.json', run);
   writeRun();
+  const progress = (phase, fields = {}) => {
+    if (command !== 'run' || state.sealed) return;
+    const now = Date.now();
+    const tick = globalThis.performance.now();
+    const sinceCreated = Math.max(0, tick - progressCreatedTick);
+    if (phase !== run.progress.phase) {
+      const prior = run.progress.phase;
+      const priorDuration = Math.max(0, tick - phaseStartedTick) + (prior === 'setup' ? setupBeforeRecordMs : 0);
+      run.progress.phaseDurationsMs[prior] = (run.progress.phaseDurationsMs[prior] ?? 0) + priorDuration;
+      phaseStartedTick = tick;
+      run.progress.phase = phase;
+      run.progress.phaseStartedAt = new Date(now).toISOString();
+    }
+    Object.assign(run.progress, fields, {
+      updatedAt: new Date(now).toISOString(),
+      elapsedMs: setupBeforeRecordMs + sinceCreated,
+      phaseElapsedMs: Math.max(0, tick - phaseStartedTick) + (phase === 'setup' ? setupBeforeRecordMs : 0),
+    });
+    writeRun();
+  };
+  state.finishProgress = (phase) => progress(phase, { detail: phase === 'complete' ? 'Run sealed' : 'Run stopped' });
+  if (command === 'run') {
+    state.progressTimer = setInterval(() => {
+      try {
+        progress(run.progress.phase);
+        log(
+          `progress: ${run.progress.phase}; ${run.progress.completedTrials ?? '?'}/${run.progress.totalTrials ?? '?'} trials; ${Math.floor(run.progress.elapsedMs / 1000)}s elapsed`,
+        );
+      } catch (error) {
+        // A progress write is guarded like every other run-directory write. The main
+        // pipeline will detect the same changed directory at its next verification.
+        log(`progress could not be recorded: ${error.message}`);
+      }
+    }, progressIntervalMs);
+    state.progressTimer.unref?.();
+  }
 
   // The run keeps its own copy of the contract this partition runs, so every stage below reads the
   // same bytes and the verdict can be reproduced from the run directory alone.
@@ -951,6 +1024,7 @@ async function runInWorkspaces({
     }
   };
 
+  progress('qualification', { detail: 'Qualifying probes and clean controls' });
   const qualified = [];
   const policyPath = path.join(folder, POLICY_PATH);
   const policy = fs.existsSync(policyPath) ? readJson(policyPath) : null;
@@ -1192,6 +1266,7 @@ async function runInWorkspaces({
     // Every leg has a port, and so a home, of its own.
     resetHome() {},
   };
+  progress('preflight', { detail: 'Running preflight legs and verdict' });
   try {
     const recorder = recordingPort({
       pristine: { label: 'pristine', cwd: workspaceDirectory(pristine), port: auditedLegs },
@@ -1286,11 +1361,12 @@ async function runInWorkspaces({
   // A passed `preflight` is refused when every leg of the pristine workspace opened a path outside the allowlist: a target that lives
   // outside its workspace loads its own files on every launch, so every trial opens them too, and `score` refuses a trial that does
   // (exit 3). `run` judges the trials' own manifests, the set `score` judges, so it does not refuse on the legs.
-  if (afterVerdict === null && verdict.exitCode === 0) {
+  // Seatbelt can refuse an undeclared runner before it produces a passing leg. Preserve the captured denial's path and setup guidance.
+  if (afterVerdict === null && (verdict.exitCode === 0 || confinement.mode === 'seatbelt')) {
     const refusal = mountRefusal({
       mounts: mountsOfEveryLeg(legMounts, [`${pristine.kind} pristine`]),
       folder,
-      who: 'legs',
+      who: confinement.mode === 'seatbelt' ? 'denied-legs' : 'legs',
     });
     if (refusal !== null) return outcome({ stage: 'leg', exitCode: 3, message: refusal });
   }
@@ -1325,6 +1401,7 @@ async function runInWorkspaces({
       writer,
       run,
       writeRun,
+      progress,
       treeUnchanged,
       retractUnlessSealed: state.retractUnlessSealed,
       markSealed: () => {

package/cli/lib/evaluate/run.js

@@ -236,11 +236,12 @@ function refusal({ folder, selectedProbeIds = null }) {
  *   (`before-state.js`) may fail its baseline, and the run is marked so it is never accepted as a baseline
  * @param {NodeJS.ProcessEnv} [options.env]
  * @param {(line: string) => void} [options.log]
+ * @param {number} [options.progressIntervalMs] heartbeat interval used by integration tests
  * @returns {Promise<PreflightOutcome>}
  */
 function runRunCommand(
   folder,
-  { fromWorkingTree = false, partition, trials, seed, beforeState = false, env = process.env, log = () => {} } = {},
+  { fromWorkingTree = false, partition, trials, seed, beforeState = false, env = process.env, log = () => {}, progressIntervalMs } = {},
 ) {
   if (trials !== undefined && !(Number.isInteger(trials) && trials >= 1))
     return Promise.resolve(
@@ -260,7 +261,7 @@ function runRunCommand(
   } catch {
     // The pipeline's check reports malformed source files with authoring findings; it keeps the partition, so a development
     // run still does not open the held-out plan.
-    return runPipeline(folder, { command: 'run', partition, fromWorkingTree, seed, env, log });
+    return runPipeline(folder, { command: 'run', partition, fromWorkingTree, seed, env, log, progressIntervalMs });
   }
   if (selection.refusal !== undefined) return Promise.resolve(new PreflightOutcome({ stage: 'check', ...selection.refusal }));
   const { selectedProbeIds } = selection;
@@ -276,6 +277,8 @@ function runRunCommand(
     seed,
     env,
     log,
+    progressIntervalMs,
+    progressStartedAt: started,
     prepare: async (context) => {
       const refused = refusal({ ...context, selectedProbeIds });
       if (refused !== null) return refused;
@@ -1148,6 +1151,8 @@ async function runTrialSets(given) {
     sealed,
   } = context;
   const { treeUnchanged, stop, log, snapshot } = context;
+  const progress = context.progress ?? (() => {});
+  progress('clean-control-qualification', { detail: 'Qualifying clean controls' });
 
   const cleanControls = await qualifyCleanControls({ ...context, seed: run.seed });
   // The gameability probes the shared pipeline qualified before the verdict.
@@ -1214,8 +1219,19 @@ async function runTrialSets(given) {
   const { kind } = snapshot.layer.evaluator;
   if (kind === 'records') {
     if (sealed === null) throw noStages();
+    // Imported sets can share arm work, and the importer does not attest to
+    // complete usage reports. Leave both the trial count and cost unknown.
+    progress('records-import', {
+      detail: 'Importing existing evaluator records',
+      completedTrials: null,
+      totalTrials: null,
+      usage: null,
+    });
     return concludeImportedRecords({ ...context, arms, refusedIds });
   }
+  const trialCount = snapshot.trials ?? evaluation.trials;
+  const totalTrials = arms.length * trialCount;
+  progress('trial-preparation', { detail: 'Preparing scored trials', totalTrials });
   if (convertsRows(kind)) {
     // A command evaluator and a sealed-brief agent read the brief the run sealed, as its bytes were written.
     if (sealed === null) throw noStages();
@@ -1242,6 +1258,7 @@ async function runTrialSets(given) {
 
   let calibrationDigest = null;
   if ((contract.rubrics ?? []).length > 0) {
+    progress('calibration', { detail: 'Calibrating rubric judge' });
     const { layer } = snapshot;
     const judgeItem = async ({ rubric, criterion, response, responseKind }) => {
       const stepId = /^\/interactions\/([^/]+)/.exec(criterion.evidence)?.[1];
@@ -1357,7 +1374,6 @@ async function runTrialSets(given) {
     }
   }
 
-  const trialCount = snapshot.trials ?? evaluation.trials;
   if (sealed === null) throw noStages();
   const { contractDigest, sealedBriefDigest } = sealed;
   const { conditions, layer } = snapshot;
@@ -1439,12 +1455,22 @@ async function runTrialSets(given) {
   };
 
   // A sealed-brief agent chooses its own calls, so its verdicts count only once it agrees with itself on the arms it will judge.
-  if (kind === 'sealed-brief-agent') await qualifyEvaluator({ ...context, arms, sealing });
+  if (kind === 'sealed-brief-agent') {
+    progress('evaluator-qualification', { detail: 'Qualifying evaluator agreement' });
+    await qualifyEvaluator({ ...context, arms, sealing });
+  }
+
+  let completedTrials = 0;
+  let reportedUse = ZERO;
+  let missingReports = 0;
+  progress('trials', { detail: 'Running scored trials', totalTrials, completedTrials });
 
   for (const arm of arms) {
     arm.trials = [];
     for (let trialIndex = 1; trialIndex <= trialCount; trialIndex += 1) {
-      log(`${arm.conditionArm}: trial ${trialIndex} of ${trialCount}`);
+      const trialDetail = `${arm.conditionArm}: trial ${trialIndex} of ${trialCount}`;
+      log(trialDetail);
+      progress('trials', { detail: trialDetail, completedTrials });
       const trial = await runTrial({ ...context, arm, trialIndex });
       const versionReadBegan = Date.now();
       const agentMoved = await agentVersionChange(context);
@@ -1452,6 +1478,19 @@ async function runTrialSets(given) {
         throw stop({ stage: 'trial', exitCode: 12, message: `the installed agent version could not be held after a trial: ${agentMoved}` });
       trial.elapsedMs += Date.now() - versionReadBegan;
       arm.trials.push(trial);
+      reportedUse = addUsage(reportedUse, trial.resourceUse);
+      missingReports += trial.unreportedSteps.length;
+      completedTrials += 1;
+      progress('trials', {
+        detail: `${trialDetail} completed`,
+        completedTrials,
+        usage: {
+          trialCostUsd: missingReports === 0 && completedTrials === totalTrials ? reportedUse.costUsd : null,
+          reportedTrialCostUsd: reportedUse.costUsd,
+          missingReports,
+          scope: 'trials-only',
+        },
+      });
       // Read after every trial, so a target that writes into the project stops the run at once.
       treeUnchanged('trials');
     }
@@ -1493,6 +1532,7 @@ async function runTrialSets(given) {
   // wrote, and the run directory nothing else, before any trial set is written.
   writer.verify('after the trials');
 
+  progress('sealing', { detail: 'Sealing trial sets and evidence' });
   const trialSets = [];
   const recordDigests = {};
   const manifestDigests = {};
@@ -2103,6 +2143,7 @@ async function completeRun(
   // runtime wrote, before run.json says completed; that write is the run's last.
   treeUnchanged('sealing', { record: false });
   writer.verify('after the trial sets were sealed');
+  context.progress?.('complete', { detail: 'Run sealed' });
   Object.assign(run, {
     artifacts,
     contractDigest: sealed.contractDigest,