@aurorajs.dev/catalyst-cli 1.1.3 → 2.0.0

package/dist/templates/monorepo/scripts/backlog/close.test.ts

@@ -20,6 +20,7 @@ import path from 'node:path';
 import { describe, it } from 'node:test';
 import {
   buildAttemptCommitMessage,
+  buildExecutionRecordBlock,
   buildPrCreateArgs,
   buildPrLabelArgs,
   buildPrReviewerArgs,
@@ -29,12 +30,16 @@ import {
   checkBranchNotMerged,
   checkScope,
   collectAttemptDiff,
+  collectChangedFiles,
   collectLeftoverFiles,
   composePrBody,
+  EXECUTION_RECORD_HEADING,
   evaluateAcceptanceGate,
+  evaluateMechanicalCheckResult,
   executeClose,
   findOpenPrUrl,
   formatBlockComment,
+  hasExecutionRecordBlock,
   HUMAN_REVIEW_SECTION_END,
   HUMAN_REVIEW_SECTION_START,
   needsGuidanceQuestion,
@@ -49,8 +54,10 @@ import {
   touchesMirroredRoot,
   upsertHumanReviewSection,
   type CloseRunners,
+  type ExecutionRecordInput,
 } from './close.js';
 import { HUMAN_REVIEW_PATHS } from './guards.js';
+import { STREAM_OUTCOME } from './render.js';
 import { resolveBranch } from './slots.js';
 import { EXECUTION_PATH, LANE, TASK_STATUS, TIER, type Task } from './types.js';
 
@@ -396,10 +403,9 @@ describe('checkScope', () => {
     '.husky/pre-commit',
     '.claude/settings.json',
     '.claude/hooks/inject-prompt-context.ts',
-    // Soft everywhere else (T-31), but `scripts/` — a LOCAL_FORBIDDEN_PATHS extra — still catches
-    // it: design.md decision 6, "scripts/backlog/ stays refused on the local lane even when
-    // declared, because the wider scripts/ extra still catches it".
-    'scripts/backlog/dispatch.ts',
+    // `scripts/` is a LOCAL_FORBIDDEN_PATHS extra: the local lane refuses every `scripts/`
+    // subtree, declared or not, whether or not it is refused everywhere else too.
+    'scripts/bump-version.ts',
     'package.json',
     'backend/package.json',
     'pnpm-lock.yaml',
@@ -418,7 +424,7 @@ describe('checkScope', () => {
 
   // Spec scenario "A local-lane refusal that predates the split still applies": the local lane's
   // three EXTRAS (`.claude/`, `scripts/`, `.git/`) refuse on their own, declared or not, and
-  // regardless of the split. `scripts/backlog/dispatch.ts` above covers `scripts/`; these are the
+  // regardless of the split. `scripts/bump-version.ts` above covers `scripts/`; these are the
   // other two, each with a path that ONLY the broad extra catches — `.claude/skills/…` is not under
   // any hard `.claude/` entry, and `.git/` appears on no other list at all.
   //
@@ -503,22 +509,20 @@ describe('checkScope', () => {
     assert.equal(result.ok, true);
   });
 
-  // T-31: the dispatcher's own sources are SOFT because nothing reads them as instructions and the
-  // dispatcher never runs from the slot — it runs `tsx scripts/backlog/dispatch.ts` from the MAIN
-  // checkout — so the old justification ("edits its own examiner") did not hold at run time and the
-  // frontier lane admits them, marking the pull request instead of failing.
+  // The generator package is SOFT because nothing reads it as instructions and the close never
+  // invokes it, so the frontier lane admits it, marking the pull request instead of failing.
   //
   // SOFT is not INERT, and design.md decision 1 records the two measured mechanisms that make it
   // not: (1) admitting the diff here is exactly what unlocks the triad, whose last step spawns the
   // task's declared `Test command:` with `cwd` = the slot, and `ALLOWED_TEST_SCRIPT` admits
-  // `test:backlog` — a runner over the SLOT's copies of these very files; (2) a failed attempt's
+  // `cli:test` — a runner over the SLOT's own copy of the generator; (2) a failed attempt's
   // tree is pushed to `task/<id>` by `saveWipAndPush` and restored by the retry's
   // `checkout -B task/<id> origin/task/<id>`, a path that opens no pull request and applies no mark.
   for (const forbidden of [
-    'scripts/backlog/close.ts',
-    'scripts/backlog/guards.ts',
-    'scripts/backlog/worker-edit.ts',
-    'scripts/backlog/lanes/local.settings.json',
+    'packages/cli/src/generator/emit.ts',
+    'packages/cli/src/generator/schema.ts',
+    'packages/cli/src/templates/codegen/module.aurora.eta',
+    'packages/cli/bin/run.js',
   ]) {
     it(`frontier: admits ${forbidden} — soft list, marks the PR for human review`, () => {
       const result = checkScope({
@@ -532,6 +536,30 @@ describe('checkScope', () => {
     });
   }
 
+  // `scripts/backlog/` is supervised-only (guard 1e): a change to the dispatcher's own machinery is
+  // an architectural decision, and it ships to every scaffolded application, where no solution task
+  // has any business touching it — so the close refuses it on BOTH lanes, declared or not, exactly
+  // like the two core packages.
+  for (const lane of [LANE.LOCAL, LANE.FRONTIER]) {
+    for (const forbidden of [
+      'scripts/backlog/close.ts',
+      'scripts/backlog/guards.ts',
+      'scripts/backlog/worker-edit.ts',
+      'scripts/backlog/lanes/local.settings.json',
+    ]) {
+      it(`${lane}: fails on ${forbidden} — supervised-only, never soft`, () => {
+        const result = checkScope({
+          lane,
+          changedFiles: [forbidden],
+          declaredFiles: [forbidden],
+        });
+        assert.equal(result.ok, false);
+        assert.deepEqual(result.violatingFiles, [forbidden]);
+        assert.deepEqual(result.humanReviewFiles, []);
+      });
+    }
+  }
+
   // N1: the project `PostToolUse` hook executes `$CLAUDE_PROJECT_DIR/.claude/hooks/format-with-prettier.ts`
   // on every Write/Edit, and `CLAUDE_PROJECT_DIR` is the SLOT — so a hook the worker writes there is
   // code the harness runs as the worker on its very next edit. `.claude/scripts/` runs the same way
@@ -559,7 +587,7 @@ describe('checkScope', () => {
   // `cwd` = the slot, and that script globs `monorepo.mjs`, `backend/*.mjs` and `frontend/*.mjs`
   // inside its OWN directory (derived from `import.meta.url`, i.e. the slot's copy) and spawns each
   // match with the dispatcher's inherited environment. It executes in the slot, so it is HARD on
-  // both lanes — and it is NOT covered by the soft `scripts/backlog/` entry.
+  // both lanes — a different cause from `scripts/backlog/`'s own supervised-only refusal.
   for (const lane of [LANE.LOCAL, LANE.FRONTIER]) {
     for (const forbidden of [
       'scripts/packager/publish.mjs',
@@ -1342,28 +1370,6 @@ describe('resolveBaseBranch / resolveBaseRef', () => {
     assert.equal(dispatchBase, resolveBaseRef(task));
   });
 
-  // T-15: the close must measure a subtask against its parent's REAL branch — the same
-  // `tasksById`-driven resolution `guards.ts`'s `taskBaseBranch` now performs — not just the
-  // `task/<parentId>` deduction. `tasksById` is optional so every test above (no board in hand)
-  // keeps resolving `task/<parentId>`, unchanged.
-  it("resolves a subtask to its parent's DECLARED branch when tasksById carries one", () => {
-    const tasksById = { 'T-10': baseTask({ id: 'T-10', declaredBranch: 'fix/parent-branch-resolution' }) };
-    const task = baseTask({ parentId: 'T-10' });
-    assert.equal(resolveBaseBranch(task, tasksById), 'fix/parent-branch-resolution');
-    assert.equal(resolveBaseRef(task, tasksById), 'origin/fix/parent-branch-resolution');
-  });
-
-  it("never diverges from slots.ts's resolveBranch when the parent declared a real branch", () => {
-    const tasksById = { 'T-10': baseTask({ id: 'T-10', declaredBranch: 'fix/parent-branch-resolution' }) };
-    const task = baseTask({ parentId: 'T-10' });
-    const dispatchBase = resolveBranch({
-      taskId: task.id,
-      parentId: task.parentId,
-      tasksById,
-      remoteBranches: ['main', 'fix/parent-branch-resolution'],
-    }).base;
-    assert.equal(dispatchBase, resolveBaseRef(task, tasksById));
-  });
 });
 
 // ── mirror-regen: the CLI scaffold mirror the drift gate compares against ─────
@@ -1630,6 +1636,93 @@ describe('checkScope — the mirror stays forbidden for the worker itself', () =
   }
 });
 
+// T-93: `packages/cli/src/templates/codegen/` is 944 KB of hand-written `.eta` templates — the
+// CLI's OWN source, not packager output — and `cli-template-drift-check.yml` excludes it from its
+// own drift check by name for that reason. Before this fix `MIRROR_OUTPUT_PREFIXES`' predecessor
+// covered the WHOLE `packages/cli/src/templates/` tree, so a task that declared a `codegen/` file
+// (T-76 intento-1) was rejected as a mirror violation on a legitimate write.
+describe('checkScope — packages/cli/src/templates/codegen/ is hand-written source, not the mirror (T-93)', () => {
+  for (const lane of [LANE.LOCAL, LANE.FRONTIER] as const) {
+    it(`${lane}: a hand-written codegen/ template is admitted, not a mirror violation`, () => {
+      const file = 'packages/cli/src/templates/codegen/some-template.ts.eta';
+      const result = checkScope({ lane, changedFiles: [file], declaredFiles: [file] });
+      assert.equal(result.ok, true, 'codegen/ is CLI source, not packager output');
+      assert.deepEqual(result.violatingFiles, []);
+      assert.deepEqual(result.humanReviewFiles, [file]);
+    });
+  }
+});
+
+// T-93, the other direction of the same narrowing: the three directories the packager actually
+// writes must stay a hard violation exactly as before, even though `codegen/` next to them no
+// longer is.
+describe('checkScope — the real packager mirror stays refused after the codegen/ narrowing (T-93)', () => {
+  for (const lane of [LANE.LOCAL, LANE.FRONTIER] as const) {
+    for (const dir of ['backend', 'frontend', 'monorepo']) {
+      it(`${lane}: a hand-written packages/cli/src/templates/${dir}/ edit is still a mirror violation`, () => {
+        const file = `packages/cli/src/templates/${dir}/some-file.ts`;
+        const result = checkScope({ lane, changedFiles: [file], declaredFiles: [file] });
+        assert.equal(result.ok, false, `${dir}/ is real packager output and must stay refused`);
+        assert.deepEqual(result.violatingFiles, [file]);
+        assert.deepEqual(result.humanReviewFiles, []);
+      });
+    }
+  }
+});
+
+// T-49: the plain `status` half never carries `--ignored`, so a gitignored write (measured incident:
+// `packages/cli/dist/commands/**`, which `packages/cli/.gitignore` hides and `packages/cli/bin/run.js`
+// loads) never reaches `changedFiles` at all — not a hard-list hit, not a soft-list mark, invisible.
+// The fix is a THIRD, pathspec-scoped `--ignored` read, never a blanket one: `git status --ignored
+// --untracked-files=all` over the repo root was measured (2026-09-10, this checkout) at 138184
+// entries, almost all of it pre-existing `node_modules/` content installed at slot provisioning —
+// not written by the attempt — plus `backend/.env` and `backend/.keys` surfacing as "changed" simply
+// for existing. Scoping the pathspec to `packages/cli/dist` avoids both: the volume explosion and the
+// false positives on baseline files no attempt touched.
+describe('collectChangedFiles — the ignored scan (T-49)', () => {
+  it('sees a file written under the gitignored packages/cli/dist, which the plain status call cannot', () => {
+    const calls: string[][] = [];
+    const files = collectChangedFiles({
+      base: 'main',
+      runGit: (args) => {
+        calls.push(args);
+        if (args[0] === 'diff') return '';
+        if (args.includes('--ignored')) return '!! packages/cli/dist/commands/evil.js\0';
+        return ''; // the plain status call never sees an ignored path — the bug this closes.
+      },
+    });
+
+    assert.deepEqual(files, ['packages/cli/dist/commands/evil.js']);
+    assert.deepEqual(calls[2], [
+      'status',
+      '--porcelain',
+      '-z',
+      '--untracked-files=all',
+      '--ignored',
+      '--',
+      'packages/cli/dist',
+    ]);
+  });
+
+  it('does not invent a file when nothing ignored changed', () => {
+    const files = collectChangedFiles({ base: 'main', runGit: () => '' });
+    assert.deepEqual(files, []);
+  });
+
+  it('does not duplicate a path the plain status call already reports', () => {
+    const files = collectChangedFiles({
+      base: 'main',
+      runGit: (args) => {
+        if (args[0] === 'diff') return '';
+        // Same path from both the plain and the ignored call — a rename out of `dist/` mid-attempt
+        // is not plausible, but a Set union must not report it twice regardless of how it got there.
+        return '!! packages/cli/dist/commands/evil.js\0';
+      },
+    });
+    assert.deepEqual(files, ['packages/cli/dist/commands/evil.js']);
+  });
+});
+
 describe('runScopeCheck', () => {
   it('asks git for the committed diff and the working tree, and passes when everything checks out', () => {
     const calls: string[][] = [];
@@ -1646,6 +1739,15 @@ describe('runScopeCheck', () => {
     assert.deepEqual(calls, [
       ['diff', '--name-only', '-z', 'main...HEAD'],
       ['status', '--porcelain', '-z', '--untracked-files=all'],
+      [
+        'status',
+        '--porcelain',
+        '-z',
+        '--untracked-files=all',
+        '--ignored',
+        '--',
+        'packages/cli/dist',
+      ],
     ]);
     assert.deepEqual(result, { ok: true, humanReviewFiles: [] });
   });
@@ -1657,13 +1759,19 @@ describe('runScopeCheck', () => {
   // ADMITTED and merely marked, exactly inverting the mirror-first precedence design.md decision 5
   // makes load-bearing. `-z` is what actually turns quoting off for the whole class, and
   // `--name-only` DOES accept it (measured; the note this replaces claimed otherwise) — the same
-  // fix the `status` half already carries. Reachable on a retry, whose `<base>...HEAD` carries the
-  // previous attempt's WIP commit.
+  // fix the `status` half already carries.
+  //
+  // The file is reported DIRTY here (the plain `status` call), not only committed: T-79 stopped
+  // treating a mirror path found ONLY in `<base>...HEAD` as this attempt's violation — that shape is
+  // indistinguishable from a PRIOR close's own `mirror-regen` output, already sitting in the
+  // branch's history (see the `describe` block below). A worker's hand-write is still caught because
+  // it is dirty on the very attempt that made it, before any close ever commits it — so the quoting
+  // defect this test guards against is exercised on the dirty half, the one still live for a worker.
   for (const mirrorPath of [
     'packages/cli/src/templates/monorepo/backend/src/café.ts',
     'packages/cli/src/templates/monorepo/backend/src/we"ird.ts',
   ]) {
-    it(`reads paths verbatim with -z, so ${mirrorPath} stays a violation`, () => {
+    it(`reads paths verbatim with -z, so a hand-written ${mirrorPath} stays a violation`, () => {
       const calls: string[][] = [];
       const result = runScopeCheck({
         lane: LANE.FRONTIER,
@@ -1671,20 +1779,74 @@ describe('runScopeCheck', () => {
         base: 'main',
         runGit: (args) => {
           calls.push(args);
-          return args[0] === 'diff' ? `${mirrorPath}\0` : '';
+          if (args[0] === 'diff') return '';
+          if (args.includes('--ignored')) return '';
+          return `?? ${mirrorPath}\0`;
         },
       });
 
       assert.deepEqual(
         calls[0],
         ['diff', '--name-only', '-z', 'main...HEAD'],
-        'the diff must be asked with -z, or a quoted path stops matching the mirror prefix',
+        'the diff must still be asked with -z',
       );
-      assert.equal(result.ok, false, 'a mirror path is a violation, never a soft mark');
+      assert.equal(result.ok, false, 'a dirty mirror path is a violation, never a soft mark');
       assert.deepEqual(result.humanReviewFiles, []);
     });
   }
 
+  // T-79: the incident this closes. Attempt 1 touched a mirrored root, so its close's `mirror-regen`
+  // step committed the scaffold mirror into the branch (it can only have arrived there THROUGH a
+  // close — the executor is forbidden from running `git` at all). Attempt 2 resumes on that same
+  // branch and writes nothing new; its own `scope-check` must not re-litigate the previous close's
+  // own output as if the worker had just written it by hand.
+  it('T-79: a mirror file committed by a PRIOR close is not this attempt\'s violation', () => {
+    const priorMirrorFile = 'packages/cli/src/templates/monorepo/scripts/backlog/dispatch.ts';
+    // Acceptance criterion #3's exact shape: the branch carries the previous close's own commit
+    // (the regenerated mirror) PLUS this attempt's own new work — this attempt only marked
+    // acceptance criteria and ran the suite, no code, so its "own work" is a task-view edit left
+    // dirty in the slot (`.backlog/` is not scope-checked, so any dirty leftover file stands in for
+    // it here), never anything under the mirror prefix.
+    const currentAttemptFile = 'backend/src/@app/some-bc/x.service.ts';
+    const result = runScopeCheck({
+      lane: LANE.FRONTIER,
+      declaredFiles: [],
+      base: 'main',
+      runGit: (args) => {
+        // Committed by attempt 1's close: present in the cumulative diff, absent from the working
+        // tree — attempt 2 never touched it.
+        if (args[0] === 'diff') return `${priorMirrorFile}\0`;
+        if (args.includes('--ignored')) return '';
+        // This attempt's own, still-uncommitted change.
+        return `?? ${currentAttemptFile}\0`;
+      },
+    });
+
+    assert.equal(result.ok, true, "a retry must not be blocked by its own close's prior output");
+    assert.deepEqual(result.humanReviewFiles, []);
+  });
+
+  // The complement: a mirror file the CURRENT attempt commits nothing about but leaves DIRTY (a
+  // worker writing to it by hand, undeclared and unauthorised on every lane) is still rejected —
+  // T-79's acceptance criterion #2. Committed history is what earns the exemption, not mere presence.
+  it('T-79: a mirror file the CURRENT attempt writes by hand (dirty) is still rejected', () => {
+    const handWritten = 'packages/cli/src/templates/monorepo/scripts/backlog/rogue.ts';
+    const result = runScopeCheck({
+      lane: LANE.FRONTIER,
+      declaredFiles: [],
+      base: 'main',
+      runGit: (args) => {
+        if (args[0] === 'diff') return '';
+        if (args.includes('--ignored')) return '';
+        return `?? ${handWritten}\0`;
+      },
+    });
+
+    assert.equal(result.ok, false, 'a dirty mirror write is always a violation, on every lane');
+    assert.equal(result.reason, 'scope-check-failed');
+    assert.match(result.question ?? '', new RegExp(handWritten.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+  });
+
   it("diffs against the parent branch for a subtask, so the parent's own commits are not the child's diff", () => {
     const calls: string[][] = [];
     runScopeCheck({
@@ -1833,6 +1995,79 @@ describe('runScopeCheck', () => {
     assert.equal(result.ok, false);
     assert.match(result.reason ?? '', /scope/);
   });
+
+  // T-49: `packages/cli/.gitignore` hides `dist/`, and `packages/cli/bin/run.js` LOADS `dist/`, not
+  // `src/`. Before this fix neither git read carried `--ignored`, so a worker writing straight into
+  // `packages/cli/dist/commands/**` and running it left a clean diff — no scope-check hit, no
+  // human-review mark, no trace in a `Blocked` comment. This is the same soft classification a
+  // TRACKED `packages/cli/` file already gets (`HUMAN_REVIEW_PATHS`), which is why a legitimate
+  // `pnpm cli:build` (also writing under `packages/cli/dist`) does not fail the attempt either.
+  it('marks a write under the gitignored packages/cli/dist for human review, never a hard failure', () => {
+    const result = runScopeCheck({
+      lane: LANE.FRONTIER,
+      declaredFiles: [],
+      base: 'main',
+      runGit: (args) =>
+        args[0] === 'diff'
+          ? ''
+          : args.includes('--ignored')
+            ? '!! packages/cli/dist/commands/generate.js\0'
+            : '',
+    });
+
+    assert.deepEqual(result, {
+      ok: true,
+      humanReviewFiles: ['packages/cli/dist/commands/generate.js'],
+    });
+  });
+});
+
+// T-75: `pnpm cli:build` writes `packages/cli/dist/templates/`, a gitignored COPY of the packager's
+// scaffold (distinct from `MIRROR_OUTPUT_PREFIXES`, `packages/cli/src/templates/{backend,frontend,
+// monorepo}/`, the committed SOURCE mirror). Before this fix, `matchesAnyPathPattern`/
+// `matchesBasename` compared by substring/basename, so
+// `packages/cli/dist/templates/monorepo/package.json` matched the hard
+// `package.json` entry and `.../CLAUDE.md` matched `SLOT_EXECUTED_BASENAMES` — even though neither
+// file is the repo's own `package.json` or `CLAUDE.md`, and `templates/` is never executed inside the
+// slot. Measured incident: T-73's close failed `scope-check-failed` on ~55 such files despite a
+// correct diff, 1930 green tests and an APPROVED review.
+describe('checkScope — packages/cli/dist/templates/ is inert build output, not a hard violation', () => {
+  for (const lane of [LANE.LOCAL, LANE.FRONTIER] as const) {
+    it(`${lane}: a package.json under packages/cli/dist/templates/ is admitted, not a hard violation`, () => {
+      const file = 'packages/cli/dist/templates/monorepo/package.json';
+      const result = checkScope({ lane, changedFiles: [file], declaredFiles: [file] });
+      assert.equal(result.ok, true, 'a scaffold copy is not the repo\'s own package.json');
+      assert.deepEqual(result.violatingFiles, []);
+      assert.deepEqual(result.humanReviewFiles, [file], 'still a packages/cli/ soft-list file');
+    });
+
+    it(`${lane}: a CLAUDE.md under packages/cli/dist/templates/ is admitted, not a hard violation`, () => {
+      const file = 'packages/cli/dist/templates/monorepo/CLAUDE.md';
+      const result = checkScope({ lane, changedFiles: [file], declaredFiles: [file] });
+      assert.equal(result.ok, true, 'a scaffold copy is not the repo\'s own instruction file');
+      assert.deepEqual(result.violatingFiles, []);
+      assert.deepEqual(result.humanReviewFiles, [file], 'still a packages/cli/ soft-list file');
+    });
+
+    // AC #2: the exemption is scoped to `templates/` alone — `packages/cli/bin/run.js` loads the
+    // REST of `dist/` (T-49), so a hard-list name reappearing there must still be caught.
+    it(`${lane}: a package.json under packages/cli/dist/ OUTSIDE templates/ still hard-violates`, () => {
+      const file = 'packages/cli/dist/commands/package.json';
+      const result = checkScope({ lane, changedFiles: [file], declaredFiles: [file] });
+      assert.equal(result.ok, false, 'only templates/ is exempted, not the rest of dist/');
+      assert.deepEqual(result.violatingFiles, [file]);
+    });
+  }
+
+  // AC #4: the hard list still blocks the repo's own package.json/CLAUDE.md, root or workspace,
+  // anywhere OUTSIDE the exempted prefix.
+  for (const file of ['package.json', 'backend/package.json', 'CLAUDE.md', 'backend/CLAUDE.md']) {
+    it(`frontier: ${file} outside packages/cli/dist/templates/ still hard-violates`, () => {
+      const result = checkScope({ lane: LANE.FRONTIER, changedFiles: [file], declaredFiles: [file] });
+      assert.equal(result.ok, false);
+      assert.deepEqual(result.violatingFiles, [file]);
+    });
+  }
 });
 
 // ── collectLeftoverFiles (T-31 round 4) ───────────────────────────────────────
@@ -1845,8 +2080,17 @@ describe('runScopeCheck', () => {
 // same function, so the two cannot disagree by construction.
 
 describe('collectLeftoverFiles', () => {
+  // Reports every file as DIRTY (untracked), not merely committed: `collectLeftoverFiles` runs on
+  // paths that reach a session-level failure or `board-check` BEFORE this attempt's close has ever
+  // committed anything, so its own leftovers are realistically uncommitted — and (T-79) only a
+  // DIRTY mirror path is this attempt's own doing; one found solely in `<base>...HEAD` is a prior
+  // close's own `mirror-regen` output, which `runGit` here never produces on its own.
   const gitAnswering = (changed: readonly string[]) => (args: string[]) =>
-    args[0] === 'diff' ? `${changed.join('\0')}\0` : '';
+    args[0] === 'diff'
+      ? `${changed.join('\0')}\0`
+      : args.includes('--ignored')
+        ? ''
+        : `${changed.map((file) => `?? ${file}`).join('\0')}\0`;
 
   const MIRROR_PATH = 'packages/cli/src/templates/monorepo/scripts/backlog/close.ts';
 
@@ -1861,6 +2105,21 @@ describe('collectLeftoverFiles', () => {
     assert.deepEqual(record.humanReviewFiles, []);
   });
 
+  // T-79: the record must agree with the check's own exemption — a mirror file that is ONLY in the
+  // committed diff, never dirty, is a prior close's own output, not something this attempt left
+  // behind. Naming it as a leftover to clean up would be exactly as wrong as `scope-check` failing
+  // the retry over it.
+  it('T-79: does not report a mirror file committed by a PRIOR close as a leftover', () => {
+    const record = collectLeftoverFiles({
+      lane: LANE.FRONTIER,
+      base: 'origin/main',
+      runGit: (args) => (args[0] === 'diff' ? `${MIRROR_PATH}\0` : ''),
+    });
+
+    assert.deepEqual(record.forbiddenFiles, []);
+    assert.deepEqual(record.humanReviewFiles, []);
+  });
+
   it('reports a hard-list file the retry would restore, instead of saying nothing about it', () => {
     const record = collectLeftoverFiles({
       lane: LANE.FRONTIER,
@@ -1881,22 +2140,23 @@ describe('collectLeftoverFiles', () => {
         '.claude/settings.json',
         'backend/src/@app/iam/x.ts',
         'scripts/backlog/close.ts',
-        'packages/cli/src/index.ts',
+        'packages/cli/src/generator/emit.ts',
       ]),
     });
 
-    assert.deepEqual(record.forbiddenFiles, [MIRROR_PATH, '.claude/settings.json']);
-    assert.deepEqual(record.humanReviewFiles, [
+    assert.deepEqual(record.forbiddenFiles, [
+      MIRROR_PATH,
+      '.claude/settings.json',
       'scripts/backlog/close.ts',
-      'packages/cli/src/index.ts',
     ]);
+    assert.deepEqual(record.humanReviewFiles, ['packages/cli/src/generator/emit.ts']);
   });
 
   // The point of sharing the classification: for the same tree, what the record calls forbidden is
   // exactly what the verdict calls violating (on the frontier lane, where no declaration rule
   // applies), and what it calls soft is what the verdict would have admitted.
   it('agrees with checkScope on the same tree, both kinds', () => {
-    const changed = [MIRROR_PATH, '.claude/settings.json', 'scripts/backlog/close.ts'];
+    const changed = [MIRROR_PATH, '.claude/settings.json', 'packages/cli/src/generator/emit.ts'];
     const record = collectLeftoverFiles({
       lane: LANE.FRONTIER,
       base: 'origin/main',
@@ -1905,21 +2165,38 @@ describe('collectLeftoverFiles', () => {
     const verdict = checkScope({ lane: LANE.FRONTIER, changedFiles: changed, declaredFiles: [] });
 
     assert.deepEqual(record.forbiddenFiles, verdict.violatingFiles);
-    assert.deepEqual(record.humanReviewFiles, ['scripts/backlog/close.ts']);
+    assert.deepEqual(record.humanReviewFiles, ['packages/cli/src/generator/emit.ts']);
   });
 
+  // `scripts/backlog/` is supervised-only (guard 1e): the close refuses it on BOTH lanes, so a
+  // leftover under it is forbidden regardless of which lane left it behind — never the soft bucket.
+  for (const lane of [LANE.LOCAL, LANE.FRONTIER]) {
+    it(`${lane}: reports a scripts/backlog/ leftover as forbidden, never soft`, () => {
+      const record = collectLeftoverFiles({
+        lane,
+        base: 'origin/main',
+        runGit: gitAnswering(['scripts/backlog/close.ts']),
+      });
+
+      assert.deepEqual(record.forbiddenFiles, ['scripts/backlog/close.ts']);
+      assert.deepEqual(record.humanReviewFiles, []);
+    });
+  }
+
   // The local lane refuses three path extras the frontier lane does not (`scripts/`, `.claude/`,
   // `.git/`), so the same leftover tree is classified differently there — by the same function
-  // `checkScope` asks, never by a second opinion.
-  it('applies the local lane own extras, so a soft path refused there is reported as forbidden', () => {
+  // `checkScope` asks, never by a second opinion. An ORDINARY `scripts/` file (never on the soft
+  // list at all) is what demonstrates this: it fails on the local lane by that extra alone, and
+  // passes clean on the frontier lane, which has no such extra.
+  it('applies the local lane own extras, so an ordinary scripts/ file is forbidden there but not on the frontier lane', () => {
     const record = collectLeftoverFiles({
       lane: LANE.LOCAL,
       base: 'origin/main',
-      runGit: gitAnswering(['scripts/backlog/close.ts', 'packages/cli/src/index.ts']),
+      runGit: gitAnswering(['scripts/bump-version.ts', 'packages/cli/src/generator/emit.ts']),
     });
 
-    assert.deepEqual(record.forbiddenFiles, ['scripts/backlog/close.ts']);
-    assert.deepEqual(record.humanReviewFiles, ['packages/cli/src/index.ts']);
+    assert.deepEqual(record.forbiddenFiles, ['scripts/bump-version.ts']);
+    assert.deepEqual(record.humanReviewFiles, ['packages/cli/src/generator/emit.ts']);
   });
 
   it('reads the slot changes with the exact argv the scope check uses, base included', () => {
@@ -1968,20 +2245,6 @@ describe('buildPrCreateArgs', () => {
     assert.equal(args[baseIndex + 1], 'task/T-10');
   });
 
-  // T-15: with the parent's real branch in hand, the PR targets THAT — never task/T-10, which an
-  // interactive-session parent never creates.
-  it("targets the parent's DECLARED branch when tasksById carries one", () => {
-    const args = buildPrCreateArgs({
-      task: baseTask({ parentId: 'T-10' }),
-      branch: 'task/T-12',
-      attempt: 2,
-      title: 'T-12',
-      tasksById: { 'T-10': baseTask({ id: 'T-10', declaredBranch: 'fix/parent-branch-resolution' }) },
-    });
-    const baseIndex = args.indexOf('--base');
-    assert.equal(args[baseIndex + 1], 'fix/parent-branch-resolution');
-  });
-
   // T-8 point 2: with a `taskText` to compose from, the body is `composePrBody`'s rich body, not
   // the old one-liner.
   it('composes the rich body from taskText when one is given, instead of the bare one-liner', () => {
@@ -2644,6 +2907,7 @@ describe('planMechanicalChecks', () => {
         label: 'lint-barrels',
         command: 'pnpm',
         args: ['hr:lint-barrels', '--', 'backend/src/@app/o-auth/session.service.ts'],
+        advisoryStatuses: [2],
       },
       {
         label: 'test',
@@ -2753,6 +3017,7 @@ describe('planMechanicalChecks', () => {
           label: 'lint-barrels',
           command: 'pnpm',
           args: ['hr:lint-barrels', '--', 'backend/src/@api/x.ts'],
+          advisoryStatuses: [2],
         },
       ],
     );
@@ -2834,6 +3099,7 @@ describe('planMechanicalChecks', () => {
         label: 'lint-barrels',
         command: 'pnpm',
         args: ['hr:lint-barrels', '--', 'backend/src/@api/kept.ts'],
+        advisoryStatuses: [2],
       },
     ]);
   });
@@ -2866,6 +3132,80 @@ describe('planMechanicalChecks', () => {
     });
     assert.deepEqual(plan.skippedPrettierFiles, []);
   });
+
+  // T-56: HR-BARRELS-004's exit 2 is `informational`, not `blocking` (`computeExitCode`,
+  // scripts/harness-rules/lint-barrels.ts) — `.husky/pre-commit` already lets it through. Only the
+  // lint-barrels check may declare that tolerance; prettier and the task's own test command have no
+  // such contract and must keep failing on any non-zero status.
+  it('declares exit 2 advisory on the lint-barrels check, and no advisory status on any other check', () => {
+    const plan = planMechanicalChecks({
+      testCommand: 'pnpm --filter aurora-back test session.spec.ts',
+      lintBarrels: true,
+      changedFiles: changed,
+      exists: () => true,
+    });
+    const lintBarrels = plan.checks.find((check) => check.label === 'lint-barrels');
+    assert.deepEqual(lintBarrels?.advisoryStatuses, [2]);
+
+    for (const check of plan.checks) {
+      if (check.label === 'lint-barrels') continue;
+      assert.equal(
+        check.advisoryStatuses,
+        undefined,
+        `${check.label} must declare no advisory status`,
+      );
+    }
+  });
+});
+
+describe('evaluateMechanicalCheckResult', () => {
+  const lintBarrelsCheck = {
+    label: 'lint-barrels',
+    command: 'pnpm',
+    args: ['hr:lint-barrels', '--', 'backend/src/@api/x.ts'],
+    advisoryStatuses: [2],
+  };
+  const prettierCheck = {
+    label: 'prettier --check (aurora-back)',
+    command: 'pnpm',
+    args: ['--filter', 'aurora-back', 'exec', 'prettier', '--check'],
+  };
+
+  it('passes any check on exit 0', () => {
+    assert.deepEqual(evaluateMechanicalCheckResult(lintBarrelsCheck, 0), {
+      ok: true,
+      advisory: false,
+    });
+    assert.deepEqual(evaluateMechanicalCheckResult(prettierCheck, 0), {
+      ok: true,
+      advisory: false,
+    });
+  });
+
+  // AC2, direction 1: a blocking barrels finding (exit 1) still fails the attempt.
+  it('fails lint-barrels on exit 1 — a blocking finding is not declared advisory', () => {
+    assert.deepEqual(evaluateMechanicalCheckResult(lintBarrelsCheck, 1), {
+      ok: false,
+      advisory: false,
+    });
+  });
+
+  // AC2, direction 2: an informational barrels finding (exit 2) is tolerated.
+  it('passes lint-barrels on exit 2 — the declared advisory status', () => {
+    assert.deepEqual(evaluateMechanicalCheckResult(lintBarrelsCheck, 2), {
+      ok: true,
+      advisory: true,
+    });
+  });
+
+  // AC3: prettier declares no advisory status, so it fails on the very same exit code that
+  // lint-barrels tolerates — the tolerance never leaks to a check that did not ask for it.
+  it('fails a check with no advisory contract on exit 2, unlike lint-barrels', () => {
+    assert.deepEqual(evaluateMechanicalCheckResult(prettierCheck, 2), {
+      ok: false,
+      advisory: false,
+    });
+  });
 });
 
 describe('collectAttemptDiff', () => {
@@ -3332,6 +3672,23 @@ describe('formatBlockComment', () => {
     });
     assert.ok(!/prohibid/i.test(comment));
   });
+
+  // T-83: `classifyStreamOutcome` never hands out the literal 'success' as a failure cause (an
+  // `is_error: true` result whose own subtype says 'success' becomes `STREAM_OUTCOME.UNNAMED_FAILURE`
+  // instead). `formatBlockComment` echoes `details.reason` verbatim as the comment's first line, so
+  // this is the one test proving that name — not the raw subtype — is what a person actually reads.
+  it('shows the unnamed-failure name as the reason, never the success subtype it replaces', () => {
+    const comment = formatBlockComment({
+      reason: STREAM_OUTCOME.UNNAMED_FAILURE,
+      branch: 'task/T-13',
+      logPath: '.backlog/.dispatch/T-13/intento-1/run.log',
+      whatToDo: 'Corrige y reencola.',
+      attempt: 1,
+      terminal: false,
+    });
+    assert.match(comment, /unnamed-failure/);
+    assert.ok(!/\bsuccess\b/.test(comment), 'a failed attempt must never read as a success in the reason');
+  });
 });
 
 // ── H14/H15: the PR title, and one casing across both dispatcher-authored commits ─────────────
@@ -3356,3 +3713,220 @@ describe('buildAttemptCommitMessage', () => {
     assert.match(buildWipCommitMessage('T-12'), /^chore\(t-12\)/);
   });
 });
+
+// ── T-68: the «Registro de ejecución» block (`catalyst-backlog/SKILL.md` §12) ────────────────
+
+describe('hasExecutionRecordBlock', () => {
+  it('is true once the notes carry the heading on its own line', () => {
+    assert.ok(hasExecutionRecordBlock(`Some earlier note.\n\n${EXECUTION_RECORD_HEADING}\n\n- **Modo:** headless`));
+  });
+
+  it('is false for notes with no heading, empty notes, and no notes at all', () => {
+    assert.ok(!hasExecutionRecordBlock('Just a regular progress note.'));
+    assert.ok(!hasExecutionRecordBlock(''));
+    assert.ok(!hasExecutionRecordBlock(null));
+    assert.ok(!hasExecutionRecordBlock(undefined));
+  });
+
+  // Fix 4: the heading must be a WHOLE LINE, never a substring — a worker's own progress note can
+  // legitimately mention it in prose without that being the block itself.
+  it('is false when the heading appears only as part of a longer line, never on its own', () => {
+    assert.ok(!hasExecutionRecordBlock(`texto ${EXECUTION_RECORD_HEADING} aquí, no es el bloque real`));
+    assert.ok(!hasExecutionRecordBlock(`${EXECUTION_RECORD_HEADING} — nota al margen`));
+  });
+});
+
+describe('buildExecutionRecordBlock', () => {
+  const baseInput: ExecutionRecordInput = {
+    lane: LANE.LOCAL,
+    attempts: 1,
+    attemptOutcomes: ['completed'],
+    reviewVerdicts: ['pass'],
+    sourcePath: '.backlog/.dispatch/T-12/intento-1',
+  };
+
+  it('writes the heading first, then all eight fields in the fixed §12.1 order', () => {
+    const block = buildExecutionRecordBlock(baseInput);
+    const lines = block.split('\n');
+    assert.equal(lines[0], EXECUTION_RECORD_HEADING);
+    assert.deepEqual(
+      lines.filter((line) => line.startsWith('- **')).map((line) => line.match(/^- \*\*([^*]+):\*\*/)?.[1]),
+      [
+        'Modo',
+        'Resultado del intento 1',
+        'Rondas de corrección',
+        'Arreglos posteriores al merge',
+        'Intervenciones humanas',
+        'Fallos de entorno',
+        'Tiempo de ciclo',
+        'Fuente',
+      ],
+    );
+  });
+
+  it('a single completed, PASSED-review attempt on the local lane: Done, zero rounds, no interventions', () => {
+    const block = buildExecutionRecordBlock(baseInput);
+    assert.match(block, /\*\*Modo:\*\* headless — lane:local/);
+    assert.match(block, /\*\*Resultado del intento 1:\*\* Done/);
+    assert.match(block, /\*\*Rondas de corrección:\*\* 0 — revisor: code-review/);
+    assert.match(block, /\*\*Intervenciones humanas:\*\* 0 — tipo: ninguna/);
+    assert.match(block, /\*\*Fuente:\*\* \.backlog\/\.dispatch\/T-12\/intento-1/);
+  });
+
+  it('a retried task (3 attempts) with an unknown first-attempt outcome reads "reintento", never an invented cause', () => {
+    const block = buildExecutionRecordBlock({
+      ...baseInput,
+      attempts: 3,
+      attemptOutcomes: [],
+      reviewVerdicts: ['fail', 'fail', 'pass'],
+      sourcePath: '.backlog/.dispatch/T-12/intento-3',
+    });
+    assert.match(block, /\*\*Resultado del intento 1:\*\* reintento/);
+    // "Intervenciones humanas" is its OWN count (attempts - 1 = 2, every retry passes through a
+    // human-released Blocked, §10) — deliberately independent of the review-verdict count below.
+    assert.match(block, /\*\*Intervenciones humanas:\*\* 2 — tipo: respuesta a Blocked/);
+  });
+
+  it('a KNOWN first-attempt failure carries its real cause, not just the retry count', () => {
+    const block = buildExecutionRecordBlock({
+      ...baseInput,
+      attempts: 2,
+      attemptOutcomes: ['needs-guidance', 'completed'],
+      reviewVerdicts: [null, 'pass'],
+      sourcePath: '.backlog/.dispatch/T-12/intento-2',
+    });
+    assert.match(block, /\*\*Resultado del intento 1:\*\* Blocked \(needs-guidance\)/);
+  });
+
+  it('a first attempt whose stream said is_error:true with subtype "success" (T-83) never shows "success" as the cause', () => {
+    const block = buildExecutionRecordBlock({
+      ...baseInput,
+      attempts: 2,
+      attemptOutcomes: [STREAM_OUTCOME.UNNAMED_FAILURE, 'completed'],
+      reviewVerdicts: [null, 'pass'],
+      sourcePath: '.backlog/.dispatch/T-12/intento-2',
+    });
+    assert.match(block, /\*\*Resultado del intento 1:\*\* Blocked \(unnamed-failure\)/);
+    assert.doesNotMatch(block, /Blocked \(success\)/);
+  });
+
+  it('a budget cutoff on any attempt is reported as "cuota"', () => {
+    const block = buildExecutionRecordBlock({
+      ...baseInput,
+      attempts: 2,
+      attemptOutcomes: ['budget', 'completed'],
+      reviewVerdicts: [null, 'pass'],
+      sourcePath: '.backlog/.dispatch/T-12/intento-2',
+    });
+    assert.match(block, /\*\*Resultado del intento 1:\*\* Blocked \(budget\)/);
+    assert.match(block, /\*\*Fallos de entorno:\*\* cuota/);
+  });
+
+  it('rule 3 (§12.2): a field with no measured data reads "desconocido", never a guessed "ninguno"', () => {
+    const block = buildExecutionRecordBlock(baseInput);
+    // No budget outcome was ever observed, but LM Studio/network failures are untraceable after
+    // the fact — the field must not claim "ninguno" (measured: it did not happen) for a cause this
+    // module never actually checked.
+    assert.match(block, /\*\*Fallos de entorno:\*\* desconocido/);
+    // §12.2 rule 4: no status-transition timestamp is recorded anywhere today.
+    assert.match(block, /\*\*Tiempo de ciclo:\*\* desconocido/);
+  });
+
+  // ── T-68 latest: `attempts === 0` means the task was never dispatched at all — the dispatcher's
+  // Worktree Gate forces even a SUPERVISADA (interactive) session onto a `task/T-nn` branch, so
+  // step 3 closes it out exactly like a headless one the instant its PR merges. That absence of any
+  // attempt is itself a measurement, not a headless task with zero attempts. ────────────────────
+
+  it('never dispatched (attempts: 0) with a known PR number: supervisada, desconocido interventions, PR as Fuente', () => {
+    const block = buildExecutionRecordBlock({
+      lane: LANE.FRONTIER,
+      attempts: 0,
+      attemptOutcomes: [],
+      reviewVerdicts: [],
+      sourcePath: null,
+      prNumber: 188,
+    });
+    assert.match(block, /\*\*Modo:\*\* supervisada — desconocido/);
+    assert.match(block, /\*\*Resultado del intento 1:\*\* desconocido/);
+    assert.match(block, /\*\*Rondas de corrección:\*\* desconocido — revisor: desconocido/);
+    assert.match(block, /\*\*Intervenciones humanas:\*\* desconocido — tipo: desconocido/);
+    assert.match(block, /\*\*Fuente:\*\* PR #188/);
+  });
+
+  it('never dispatched, PR confirmed to exist but its number could not be read: Fuente reads desconocido, never sin evidencia', () => {
+    const block = buildExecutionRecordBlock({
+      lane: LANE.FRONTIER,
+      attempts: 0,
+      attemptOutcomes: [],
+      reviewVerdicts: [],
+      sourcePath: null,
+      prNumber: 'read-failed',
+    });
+    assert.match(block, /\*\*Fuente:\*\* desconocido/);
+  });
+
+  it('never dispatched, no PR at all: the attempt-derived fields and the source all read "desconocido"/"sin evidencia"', () => {
+    const block = buildExecutionRecordBlock({
+      lane: LANE.FRONTIER,
+      attempts: 0,
+      attemptOutcomes: [],
+      reviewVerdicts: [],
+      sourcePath: null,
+      prNumber: null,
+    });
+    assert.match(block, /\*\*Modo:\*\* supervisada — desconocido/);
+    assert.match(block, /\*\*Resultado del intento 1:\*\* desconocido/);
+    assert.match(block, /\*\*Rondas de corrección:\*\* desconocido — revisor: desconocido/);
+    assert.match(block, /\*\*Intervenciones humanas:\*\* desconocido — tipo: desconocido/);
+    assert.match(block, /\*\*Fuente:\*\* sin evidencia/);
+  });
+
+  it('§12.2 rule 4: "Arreglos posteriores al merge" is always the fixed at-close value', () => {
+    const block = buildExecutionRecordBlock(baseInput);
+    assert.match(block, /\*\*Arreglos posteriores al merge:\*\* ninguno conocido al cierre/);
+  });
+
+  it('an unknown lane degrades ONLY the Modo field to "desconocido" — revisor no longer reads the lane', () => {
+    const block = buildExecutionRecordBlock({ ...baseInput, lane: undefined });
+    assert.match(block, /\*\*Modo:\*\* headless — desconocido/);
+    assert.match(block, /\*\*Rondas de corrección:\*\* 0 — revisor: code-review/);
+  });
+
+  // ── Fix 2: "Rondas de corrección"/"revisor" come from MEASURED review.md data, never a guess ──
+
+  it('a quota-only retry (no review.md on the cut-off attempt, PASS on the real one) reads 0 rounds, not 1', () => {
+    const block = buildExecutionRecordBlock({
+      lane: LANE.LOCAL,
+      attempts: 2,
+      attemptOutcomes: ['budget', 'completed'],
+      // Attempt 1 hit the budget cap before the close's reviewer step ever ran — no review.md.
+      // Attempt 2 completed and passed review. The OLD `attempts - 1` logic would have reported
+      // this as "1 correction round" — a round that never happened.
+      reviewVerdicts: [null, 'pass'],
+      sourcePath: '.backlog/.dispatch/T-12/intento-2',
+    });
+    assert.match(block, /\*\*Rondas de corrección:\*\* 0 — revisor: code-review/);
+  });
+
+  it('one FAIL review.md then a PASS: exactly one correction round, revisor code-review', () => {
+    const block = buildExecutionRecordBlock({
+      lane: LANE.LOCAL,
+      attempts: 2,
+      attemptOutcomes: ['completed', 'completed'],
+      reviewVerdicts: ['fail', 'pass'],
+      sourcePath: '.backlog/.dispatch/T-12/intento-2',
+    });
+    assert.match(block, /\*\*Rondas de corrección:\*\* 1 — revisor: code-review/);
+  });
+
+  it('no review.md at all (typical frontier-lane task): both halves read "desconocido"', () => {
+    const block = buildExecutionRecordBlock({
+      lane: LANE.FRONTIER,
+      attempts: 2,
+      attemptOutcomes: ['completed', 'completed'],
+      reviewVerdicts: [null, null],
+      sourcePath: '.backlog/.dispatch/T-12/intento-2',
+    });
+    assert.match(block, /\*\*Rondas de corrección:\*\* desconocido — revisor: desconocido/);
+  });
+});