@aurorajs.dev/catalyst-cli 1.0.2 → 2.0.0

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

@@ -0,0 +1,2499 @@
+/**
+ * close.ts — the dispatch close: mechanical scope check per lane, the happy-path planner, and the
+ * runner-driven executor that saves work before ever releasing a slot.
+ *
+ * Implements `specs/backlog-task-dispatcher/spec.md` — "Dispatch close ordering", "Failure path
+ * preserves work before blocking", "Retry reuses the same branch and prior context"; and
+ * `specs/headless-harness-execution/spec.md` — "Security paths never dispatch to the local lane"
+ * (the close-time re-check against the real diff, design.md decision (j): checked once before
+ * launch against DECLARED files in `guards.ts`, and again here against the REAL diff).
+ *
+ * Two layers, deliberately separate (design.md — Component design, `close` row):
+ *
+ *   - `planClose(input)` is a PURE function: given a fully-known outcome (success, or a failure
+ *     with its real push result already known), it returns the ordered steps to take. No side
+ *     effects, no filesystem, no process — this is what `close.test.ts` asserts orderings against
+ *     directly.
+ *   - `executeClose(plan, runners, context)` WALKS a plan, invoking the caller's injected runners.
+ *     When a mechanical step (scope-check/format-lint-test/reviewer/ac-check/open-pr) reports
+ *     failure — or when the given plan starts directly at `save-work` (a session-level failure:
+ *     needs-guidance, timeout, budget exhaustion, crash — the worker never got to run any
+ *     mechanical step at all) — it diverts: calls the `saveWork` runner for the REAL push result,
+ *     then calls `planClose` again internally (single source of truth for the block-vs-keep-slot
+ *     decision and the terminal-attempt flag) to resolve the tail, and executes that tail through
+ *     the matching runners. This is why the WIP commit always precedes the slot release in the
+ *     recorded call order, never the reverse (design.md decision (k)).
+ */
+import {
+  HUMAN_REVIEW_PATHS,
+  LOCAL_FORBIDDEN_PATHS,
+  matchesAnyPathPattern,
+  matchesBasename,
+  resolveTestCommand,
+  SECURITY_PATH_PATTERNS,
+  SLOT_EXECUTED_BASENAMES,
+  SLOT_EXECUTED_PATHS,
+  SUPERVISED_ONLY_PATHS,
+  taskBaseBranch,
+} from './guards.js';
+import { STREAM_OUTCOME } from './render.js';
+// Type-only on `reviewer.ts`'s own side (`import type { MechanicalStepResult } from './close.js'`),
+// so this value import creates no runtime cycle — see this section's own header comment.
+import { REVIEWER_VERDICT } from './reviewer.js';
+import {
+  ACCEPTANCE_CRITERIA_HEADING,
+  DEFINITION_OF_DONE_HEADING,
+  findOwnedDefinitionOfDone,
+  findUncheckedAcceptanceCriteria,
+  findUnownedUncheckedDefinitionOfDone,
+  parseChecklistItems,
+  parseFilesToTouch,
+  parseParentId,
+  parseTaskStatus,
+  parseTaskTitle,
+  parseTestCommand,
+} from './task-view.js';
+import { DEFAULT_DISPATCH_LIMITS, LANE, TASK_STATUS, type Lane, type Task } from './types.js';
+
+// ── Mechanical scope check (design.md decision (i); path criteria: T-31) ───────
+//
+// The path criteria this check reads — `SLOT_EXECUTED_PATHS`/`SLOT_EXECUTED_BASENAMES` (hard,
+// refused on both lanes), `HUMAN_REVIEW_PATHS` (soft, admitted and marked), and
+// `LOCAL_FORBIDDEN_PATHS` (the hard list plus the local lane's own extras) — live in
+// `guards.ts`, alongside `SECURITY_PATH_PATTERNS`: a
+// criterion checked BOTH before launch (against DECLARED files, guard 1c) and here (against the
+// REAL diff) belongs with the other guard-1 checks, and this module already imports `guards.js`, so
+// keeping the lists here would close an import cycle the moment a guard needed them too. See that
+// module's own doc comments for the worked examples and the T-31 measurements behind each entry.
+
+export interface CheckScopeInput {
+  lane: Lane;
+  changedFiles: readonly string[];
+  declaredFiles: readonly string[];
+  /**
+   * The subset of `changedFiles` NOT yet committed on this branch (T-79) — `collectChangedFileSets`'s
+   * working-tree half: dirty, untracked, or written under a watched gitignored path. Omitted (or
+   * `undefined`) keeps every mirror-output path in `changedFiles` judged exactly as before this field
+   * existed — the right default for a caller with only a flat, already-merged file list and no way to
+   * tell a prior close's own committed output apart from this attempt's. See `isMirrorViolation`'s
+   * doc comment for why only a DIRTY mirror path may be judged once this is given.
+   */
+  workingTreeFiles?: readonly string[];
+}
+
+export interface ScopeCheckResult {
+  ok: boolean;
+  violatingFiles: string[];
+  /**
+   * Files this attempt's diff reaches on the SOFT list, reported only when `ok` — a mixed diff that
+   * also hits the hard list reports the hard-list violation instead, per design.md decision 5's
+   * evaluation order (mirror prefix → hard list → soft list), and never softens by naming both.
+   * `dispatch.ts`'s `openPr` runner threads this into the pull request's human-review mark.
+   */
+  humanReviewFiles: string[];
+}
+
+const SIBLING_TEST_SUFFIX = /\.(spec|test)\.[cm]?[jt]sx?$/;
+
+/**
+ * Whether a declared entry covers a changed file. Three shapes, all of them things a person writing
+ * "Files to touch" actually means:
+ *
+ *   - an exact path — the literal case;
+ *   - an entry ending in `/` — the whole subtree under it ("this module is mine");
+ *   - the sibling `.spec.ts`/`.test.ts` of a declared source file — TDD is mandatory for a
+ *     dispatched task, so declaring `x.service.ts` and then failing the scope check for writing
+ *     `x.service.spec.ts` would punish the executor for obeying the harness.
+ */
+function isDeclared(file: string, declaredFiles: readonly string[]): boolean {
+  return declaredFiles.some((declared) => {
+    if (declared === file) {
+      return true;
+    }
+    if (declared.endsWith('/')) {
+      return file.startsWith(declared);
+    }
+    return (
+      SIBLING_TEST_SUFFIX.test(file) &&
+      file.replace(SIBLING_TEST_SUFFIX, '') === declared.replace(/\.[cm]?[jt]sx?$/, '')
+    );
+  });
+}
+
+/**
+ * Every file this attempt reaches under one of the packager's OWN output roots — see
+ * `MIRROR_OUTPUT_PREFIXES` below. Anchored (a prefix, not a substring) so only the real output
+ * roots match, and case-INSENSITIVE like every sibling matcher in this module: this repo is
+ * developed on a case-insensitive filesystem, where `Packages/CLI/src/Templates/…` names the same
+ * file on disk, and a case-sensitive check let that spelling slip past the mirror-first precedence
+ * into the soft branch and be merely marked (T-31 round 2).
+ */
+function isMirrorOutput(file: string): boolean {
+  const lower = file.toLowerCase();
+  return MIRROR_OUTPUT_PREFIXES.some((prefix) => lower.startsWith(prefix));
+}
+
+/**
+ * T-79: a mirror-output file is a violation for THIS attempt only when it is also DIRTY —
+ * uncommitted, in `workingTreeFiles` (`collectChangedFileSets`'s working-tree half: untracked,
+ * modified, or written under a watched gitignored path). A mirror-output file present ONLY in the
+ * committed diff (`<base>...HEAD`) can never be the worker's own doing: the executor is forbidden
+ * from running `git` at all (`collectAttemptDiff`'s doc comment), so nothing it writes is ever
+ * committed by anything other than a close. On a retry, `<base>...HEAD` is cumulative across every
+ * PRIOR attempt's commits — a PREVIOUS close's own `mirror-regen` step (below) regenerates the
+ * scaffold and its output travels in that close's own commit (`runMirrorRegen`'s doc comment: "the
+ * mirror travels in the attempt's own commit"). Re-checking that already-produced output against the
+ * NEXT attempt's scope is the T-78 incident this closes: the close blocking the retry with its own
+ * prior output, over files the retrying attempt never touched.
+ *
+ * `workingTreeFiles === null` keeps every direct `checkScope` caller that has no working-tree
+ * distinction to offer (most of this module's own tests, and any future caller with only a flat
+ * changed-files list) on today's behaviour: every mirror path is judged, exactly as before this
+ * fix — the safe default when "was this committed by a close, or written by hand" cannot be told
+ * apart at all.
+ *
+ * A worker's OWN hand-write under the mirror prefix is unaffected and still a hard violation
+ * (acceptance criterion #2) ON THE ATTEMPT THAT MAKES IT: it is dirty then, since nothing commits it
+ * until AFTER scope-check has already run and, on a violation, blocked the attempt before mirror-regen
+ * or any commit ever happens.
+ *
+ * Known, accepted residual (not closed by this fix, and deliberately out of `close.ts`'s own scope):
+ * "committed ⇒ produced by a close" is true, but NOT equivalent to "committed ⇒ produced by
+ * `mirror-regen`". `divert` (`executeClose`) calls `saveWork` on EVERY mechanical failure, including
+ * `scope-check`'s own — and `saveWork`'s WIP commit `git add -A`s the WHOLE working tree
+ * unconditionally, sweeping in a hand-written mirror violation right alongside everything else, the
+ * same run it was rejected on. A RETRY on that same branch then sees the violation as committed, not
+ * dirty, and this function exempts it — a worker's hand-write laundered through its own rejection.
+ * Reaching this requires a human to re-queue a `Blocked` task without reading why it blocked (the
+ * `scope-check-failed` reason names the exact file); closing it fully means either `saveWork` itself
+ * excludes files `scope-check` just rejected, or a `mirror-regen` commit is marked apart from a WIP
+ * one — both changes belong to `saveWork`'s own "preserve work before blocking" contract in
+ * `dispatch.ts`, outside this task's declared files.
+ */
+function isMirrorViolation(file: string, workingTreeFiles: ReadonlySet<string> | null): boolean {
+  return isMirrorOutput(file) && (workingTreeFiles === null || workingTreeFiles.has(file));
+}
+
+/**
+ * `pnpm cli:build`'s BUILD output — distinct from `MIRROR_OUTPUT_PREFIXES`
+ * (`packages/cli/src/templates/{backend,frontend,monorepo}/`, the packager's committed SOURCE
+ * mirror, checked above): this is `packages/cli/dist/templates/`, a gitignored COPY of that same
+ * scaffold that `tsc`/`esbuild`
+ * rewrite on every build. It is read only when a generated project is scaffolded — never executed
+ * inside the slot (T-75).
+ *
+ * Before this exemption, a file here reached `forbiddenPaths` by ACCIDENT: `matchesAnyPathPattern`
+ * and `matchesBasename` compare by substring/basename, so
+ * `packages/cli/dist/templates/monorepo/package.json` contains the hard entry `package.json`, and
+ * `packages/cli/dist/templates/monorepo/CLAUDE.md` matches `SLOT_EXECUTED_BASENAMES` — even though
+ * neither file is the repo's own `package.json` or `CLAUDE.md`. 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.
+ *
+ * Scoped to `templates/` alone, not to all of `packages/cli/dist/`: `packages/cli/bin/run.js` loads
+ * the REST of `dist/` (`IGNORED_SCAN_PATHS`'s doc comment, T-49), so that part must stay watched. A
+ * file under this prefix still falls through to the soft `packages/cli/` match
+ * (`HUMAN_REVIEW_PATHS`) below, same as any other `packages/cli/` file — exempted from the HARD list
+ * only, never dropped from the diff or from human review.
+ */
+const CLI_DIST_TEMPLATES_PREFIX = 'packages/cli/dist/templates/';
+
+function isCliDistTemplateOutput(file: string): boolean {
+  return file.toLowerCase().startsWith(CLI_DIST_TEMPLATES_PREFIX.toLowerCase());
+}
+
+/** The two kinds of path a changed-file set holds, each file in exactly ONE of them. */
+export interface PathClassification {
+  /**
+   * The mirror output and the lane's own refused paths — a violation on any lane that reaches them,
+   * and (on the failure path) the leftovers a person has to clean out of the slot by hand.
+   */
+  forbiddenFiles: string[];
+  /**
+   * The soft-list hits: `HUMAN_REVIEW_PATHS`, as substrings, among the files NEITHER of the two
+   * checks above claimed. Admitted by the close and marked for a human.
+   */
+  humanReviewFiles: string[];
+}
+
+/**
+ * The paths this LANE refuses outright. The frontier lane refuses the hard list; the local lane
+ * refuses the same list plus its own three extras (`LOCAL_FORBIDDEN_PATHS`) and every security path,
+ * since a local worker runs with the developer's own credentials.
+ *
+ * `SUPERVISED_ONLY_PATHS` is refused on BOTH, and so appears in both arms: guard 1e already blocks a
+ * task that DECLARES one before a slot is spent, but a task that only DISCOVERS the need mid-attempt
+ * declared nothing for that guard to read — the frontier lane does not judge a diff against
+ * `Files to touch:` at all. Without this the change would reach a pull request, which is exactly
+ * what the list exists to prevent (see its doc comment in `guards.ts`).
+ */
+function forbiddenPathsFor(lane: Lane): readonly string[] {
+  return lane === LANE.LOCAL
+    ? [...SECURITY_PATH_PATTERNS, ...LOCAL_FORBIDDEN_PATHS, ...SUPERVISED_ONLY_PATHS]
+    : [...SLOT_EXECUTED_PATHS, ...SUPERVISED_ONLY_PATHS];
+}
+
+/**
+ * Every file in `files` placed in exactly one bucket, in design.md decision 5's fixed order: the
+ * mirror-output prefix first, then (T-75) the `packages/cli/dist/templates/` build-output
+ * exemption, then the lane's refused paths (plus `SLOT_EXECUTED_BASENAMES`, matched by file name at
+ * any depth), then — only for what neither claimed — the soft list.
+ *
+ * The ONE place that order lives, because two callers need the same answer for two different
+ * purposes and round 3 shipped them as two independent readings that disagreed (T-31 round 4):
+ * `checkScope` turns this into a VERDICT (may this attempt proceed?), and `collectLeftoverFiles`
+ * turns it into a RECORD (what did this attempt leave behind, whatever the verdict). Sharing the
+ * classification is what makes "the record classifies the tree the way the check would" true by
+ * construction instead of by two prose comments agreeing.
+ *
+ * `workingTreeFiles` (T-79) is the dirty/untracked half of the same attempt's changes — see
+ * `isMirrorViolation`'s doc comment for why only THAT half may judge a mirror-output path.
+ */
+function classifyChangedPaths(
+  files: readonly string[],
+  forbiddenPaths: readonly string[],
+  workingTreeFiles: ReadonlySet<string> | null,
+): PathClassification {
+  const forbiddenFiles: string[] = [];
+  const humanReviewFiles: string[] = [];
+  for (const file of files) {
+    if (isMirrorOutput(file)) {
+      if (isMirrorViolation(file, workingTreeFiles)) {
+        forbiddenFiles.push(file);
+      }
+      continue;
+    }
+    if (
+      !isCliDistTemplateOutput(file) &&
+      (matchesAnyPathPattern(file, forbiddenPaths) || matchesBasename(file, SLOT_EXECUTED_BASENAMES))
+    ) {
+      forbiddenFiles.push(file);
+      continue;
+    }
+    if (matchesAnyPathPattern(file, HUMAN_REVIEW_PATHS)) {
+      humanReviewFiles.push(file);
+    }
+  }
+  return { forbiddenFiles, humanReviewFiles };
+}
+
+/**
+ * Local: every changed file must have been declared before launch, AND none may match a security
+ * path (the close-time half of the double check — the pre-launch half is `guards.ts`'s
+ * `checkSecurityPathOnLocal`, over DECLARED files only) or a `LOCAL_FORBIDDEN_PATHS` entry. Being
+ * declared is not enough for the second list: a task may not authorise itself into the harness's
+ * own machinery — `.backlog/` included, since declaring the board would authorise a worker to edit
+ * the criteria it is judged against. A SOFT-list file is admissible on this lane too, but only when
+ * DECLARED and caught by no `LOCAL_FORBIDDEN_PATHS` extra (design.md decision 6) — today only
+ * `packages/cli/`, which none of those extras reach.
+ *
+ * Frontier: no declared-files allowlist (see `guards.ts`'s `SLOT_EXECUTED_PATHS` doc comment) —
+ * only the hard list, checked against the real diff regardless of declaration.
+ *
+ * `SLOT_EXECUTED_BASENAMES` (the instruction file) is checked on BOTH branches, matched by file
+ * name at any depth and case-insensitively — see its own doc comment in `guards.ts` for the two
+ * measured mechanisms that keep it hard.
+ *
+ * Both lanes evaluate in the SAME fixed order (design.md decision 5), because the two patterns
+ * overlap as substrings: the mirror-output prefix first — `packages/cli/src/templates/…` would
+ * otherwise also match the soft `packages/cli/` pattern and silently become a marked PR instead of
+ * a violation — then the lane's refused paths, then (only once nothing violated) the soft list. That
+ * order is `classifyChangedPaths`, shared with the failure path's own record: the two must agree
+ * about a path, and round 3 shipped them as separate readings that did not.
+ */
+export function checkScope(input: CheckScopeInput): ScopeCheckResult {
+  const workingTreeFiles = input.workingTreeFiles ? new Set(input.workingTreeFiles) : null;
+  const classified = classifyChangedPaths(
+    input.changedFiles,
+    forbiddenPathsFor(input.lane),
+    workingTreeFiles,
+  );
+  // The declared-files allowlist is the local lane's own rule and the one part of the verdict that is
+  // not a property of the PATH: it asks what the task promised, which a record of leftovers cannot.
+  const undeclared =
+    input.lane === LANE.LOCAL
+      ? input.changedFiles.filter(
+          (file) => !isMirrorOutput(file) && !isDeclared(file, input.declaredFiles),
+        )
+      : [];
+  const violatingFiles = Array.from(new Set([...classified.forbiddenFiles, ...undeclared]));
+  return {
+    ok: violatingFiles.length === 0,
+    violatingFiles,
+    humanReviewFiles: violatingFiles.length === 0 ? classified.humanReviewFiles : [],
+  };
+}
+
+// ── Base ref: the one answer to "what does this task branch off, and merge back into?" ────
+
+/**
+ * The BRANCH a task's work merges back into: `main` normally, the parent's branch for a subtask
+ * (design.md decision (e) — the parent integrates to `main` with one PR, so `main` never holds half
+ * a decomposed change). This is the name `gh pr create --base` takes, which is why it is not the
+ * remote-tracking form below.
+ *
+ * Delegates to `guards.ts`'s `taskBaseBranch` — the ONE place this naming convention lives, per
+ * T-14 (2026-09-08). This function used to compute `task/<parentId>` on its own, and `slots.ts`'s
+ * branch resolution used to compute its OWN answer independently; T-4.1 measured the two silently
+ * disagreeing on a subtask whose parent branch was not yet pushed (`slots.ts` fell back to
+ * `origin/main`, this function kept assuming `task/<parentId>` regardless), producing a
+ * `scope-check-failed` diffing against a ref dispatch never created. `guards.ts`'s pre-launch guard
+ * (`checkParentBranchOnRemote`) refuses that dispatch before a slot is ever taken, so this function
+ * no longer needs to check the remote itself — by the time a close runs, the branch is guaranteed to
+ * exist — but it MUST keep consulting the same naming function `slots.ts` does, so the two can never
+ * diverge again.
+ */
+export function resolveBaseBranch(task: Task): string {
+  return taskBaseBranch(task);
+}
+
+/**
+ * The REF the work is measured against and branched from: `origin/<base branch>`. Remote-tracking,
+ * not local: a reusable slot's local `main` is whatever the last `git fetch` left behind and can be
+ * days stale, which would diff the attempt against the wrong base and branch new work off it.
+ * A subtask still measures against its PARENT's branch — diffing a child against `main` would
+ * report every file the parent already changed as this child's scope violation.
+ */
+export function resolveBaseRef(task: Task): string {
+  return `origin/${resolveBaseBranch(task)}`;
+}
+
+// ── Scope check over the REAL diff ─────────────────────────────────────────────
+
+export interface RunScopeCheckInput {
+  lane: Lane;
+  declaredFiles: readonly string[];
+  /** From `resolveBaseRef` — `main`, or the parent's branch for a subtask. */
+  base: string;
+  /** Runs `git` in the slot and returns its stdout; injected so this never needs a real repo. */
+  runGit: (args: string[]) => string;
+}
+
+/** `XY<space><path>` — the two status columns, a separator, then the path, all the way to the NUL. */
+const PORCELAIN_ENTRY = /^(..) (.+)$/s;
+
+/** A rename or a copy is the one entry shape that carries a SECOND path (its source) after it. */
+const PORCELAIN_HAS_SOURCE_PATH = /^[RC]|^.[RC]/;
+
+/**
+ * Every path `git status --porcelain -z --untracked-files=all` reports as dirty, untracked files
+ * included.
+ *
+ * `-z` rather than the default line format, because that format is lossy on exactly the paths this
+ * check exists to catch: a filename with a space, a quote or a newline comes back quoted and
+ * C-escaped, so the string compared against the task's declared allowlist is not the path on disk.
+ * With `-z` each entry is terminated by a NUL and nothing is escaped.
+ *
+ * A rename/copy is ONE entry followed by a SECOND NUL-terminated field holding its SOURCE path
+ * (measured: `R  new name.txt\0old.txt\0`). Only the new path is a file the attempt produced, so
+ * the source field is consumed and dropped — left in, it read as a phantom changed file that the
+ * task never declared and the scope check duly failed on.
+ */
+function parsePorcelainPaths(output: string): string[] {
+  const fields = output.split('\0');
+  const paths: string[] = [];
+  for (let index = 0; index < fields.length; index += 1) {
+    const match = PORCELAIN_ENTRY.exec(fields[index]);
+    if (!match) {
+      continue;
+    }
+    paths.push(match[2]);
+    if (PORCELAIN_HAS_SOURCE_PATH.test(match[1])) {
+      index += 1;
+    }
+  }
+  return paths.filter(Boolean);
+}
+
+/**
+ * Runs the close's mechanical scope verification against the slot's real changes and feeds them to
+ * `checkScope`. Three git reads, unioned, because any one alone leaves a hole:
+ *
+ *   - `git diff --name-only -z <base>...HEAD` covers what the attempt COMMITTED. Three dots, not
+ *     two: `...` compares against the merge base, so commits that landed on `base` after the
+ *     branch started are not reported as this task's changes. `-z` because quoting is ON by
+ *     default: without it a path holding a `"`, a backslash, a newline or a non-ASCII byte comes
+ *     back wrapped in `"…"` with C-escapes, and the string then compared against the path lists is
+ *     not the path on disk. Measured consequence (T-31 review): a quoted
+ *     `packages/cli/src/templates/…` fails `isMirrorOutput`'s anchored `startsWith` while still
+ *     matching the unanchored soft pattern `packages/cli/`, so a hand-written mirror edit would be
+ *     admitted and merely marked — the exact inversion of the mirror-first precedence. Round 2
+ *     replaced the first fix, `-c core.quotepath=false`, which covers ONLY the non-ASCII half of
+ *     that class and left `"`/backslash/newline paths quoted; `--name-only` does accept `-z`
+ *     (measured), so the committed half now reads NUL-separated exactly as the `status` half does.
+ *   - `git status --porcelain --untracked-files=all` covers what it did NOT commit. The executor is
+ *     explicitly forbidden from invoking `git` at all (the lane's deny list blocks it), so a normal
+ *     successful attempt leaves everything in the working tree — checking HEAD alone would let a
+ *     scope violation through by simply not committing it, and an untracked new file never appears
+ *     in a `git diff` under any flags.
+ *   - the same `status` call, scoped to `IGNORED_SCAN_PATHS` and with `--ignored` added, covers what
+ *     neither of the two above can see at all: a write under a path the repo's OWN `.gitignore`
+ *     hides (T-49). Deliberately NOT a blanket `--ignored` over the whole tree — see
+ *     `IGNORED_SCAN_PATHS`'s doc comment for the 138184-entry volume that was measured and rejected.
+ *
+ * A `git` failure fails the check rather than passing it: an unverifiable diff is exactly the case
+ * design.md decision (i) refuses to trust ("the 4-bit probe produced scope creep while reporting
+ * success").
+ */
+export interface CollectChangedFilesInput {
+  base: string;
+  runGit: (args: string[]) => string;
+}
+
+/**
+ * Where a THIRD, gitignore-aware git read is scoped (T-49). Neither the `diff` half above nor the
+ * plain `status` half carries `--ignored`, so a write under a gitignored path never reached
+ * `changedFiles` at all — measured incident: `packages/cli/.gitignore` hides `dist/`, and
+ * `packages/cli/bin/run.js` LOADS `dist/`, not `src/`, so a worker that wrote its payload there and
+ * ran it left a clean diff: no scope-check hit, no human-review mark, no trace in a `Blocked`
+ * comment.
+ *
+ * The obvious fix — add `--ignored` to the plain `status` call, repo-wide — was measured and
+ * rejected (2026-09-10, this checkout): `git status --porcelain -z --untracked-files=all --ignored`
+ * with no pathspec returned 138184 entries, almost all of it pre-existing `node_modules/` content
+ * installed at slot PROVISIONING (every dispatched attempt gets a `pnpm install` before it starts,
+ * per the root `CLAUDE.md`'s dispatched-worker section) and therefore not written by the attempt at
+ * all — plus `backend/.env` and `backend/.keys` surfacing as "changed" simply for existing. That
+ * volume, repeated on every close of every task, and those two paths landing in a changed-files list
+ * at all, is worse than the hole it closes.
+ *
+ * A pathspec-scoped `--ignored` read avoids both: `git status --ignored -- packages/cli/dist` reads
+ * ONLY that gitignored subtree, so the reachable answer stays "did this attempt touch the one
+ * directory the incident named", never "list everything gitignored in the repo". `node_modules/`
+ * stays deliberately OUT of this list: it is already `SLOT_EXECUTED_PATHS`-hard, and the one attack
+ * this scan exists to catch there — a worker `git add -f`-ing a tampered dependency — already
+ * surfaces in the plain `diff`/`status` halves above, since a forced add overrides the ignore rule
+ * that hides it. Scoping this list to it too would buy nothing but the 138184-entry regression just
+ * measured.
+ */
+const IGNORED_SCAN_PATHS: readonly string[] = ['packages/cli/dist'];
+
+/**
+ * `collectChangedFiles`'s two halves, kept APART (T-79) rather than merged: `committed` is what
+ * `<base>...HEAD` reports, cumulative across every attempt this branch ever had; `workingTree` is
+ * dirty, untracked, or written under a watched gitignored path — necessarily THIS attempt's own
+ * doing, since the executor never commits anything itself. `checkScope`'s mirror-output judgment
+ * (`isMirrorViolation`) needs exactly this split; nothing else in this module does, which is why
+ * `collectChangedFiles` below stays the merged, single-list answer every other caller already reads.
+ */
+export interface ChangedFileSets {
+  committed: string[];
+  workingTree: string[];
+}
+
+/**
+ * The three git reads `collectChangedFiles` used to run inline, now shared with `checkScope`'s
+ * working-tree split (T-79) so both halves come from the SAME three calls instead of running git
+ * twice per close step. See `collectChangedFiles`'s doc comment (below) for why each of the three
+ * reads exists; this function only changes how their results are GROUPED, not what they ask git.
+ */
+export function collectChangedFileSets(input: CollectChangedFilesInput): ChangedFileSets {
+  // No `trim()` on the entries. `-z` already means "nothing is escaped", and trimming would rewrite
+  // exactly the paths that flag exists to preserve: a filename with a leading or trailing space, a
+  // tab or a newline would be compared against the path lists and the declared allowlist under a
+  // spelling that is not the path on disk. The trailing empty field the terminating NUL leaves is
+  // dropped by `filter(Boolean)`, which is all the trim was ever doing here — and the `status` half
+  // (`parsePorcelainPaths`) never trimmed, so the two halves disagreed on the same path.
+  const committed = input
+    .runGit(['diff', '--name-only', '-z', `${input.base}...HEAD`])
+    .split('\0')
+    .filter(Boolean);
+  const dirty = parsePorcelainPaths(
+    input.runGit(['status', '--porcelain', '-z', '--untracked-files=all']),
+  );
+  const ignored = parsePorcelainPaths(
+    input.runGit([
+      'status',
+      '--porcelain',
+      '-z',
+      '--untracked-files=all',
+      '--ignored',
+      '--',
+      ...IGNORED_SCAN_PATHS,
+    ]),
+  );
+  return { committed, workingTree: [...new Set([...dirty, ...ignored])] };
+}
+
+/**
+ * Every repo-relative path this attempt produced: what it COMMITTED (`<base>...HEAD`), what it left
+ * dirty or untracked, and what it wrote under a gitignored path this module knows to watch
+ * (`IGNORED_SCAN_PATHS`, T-49). Exported because the mechanical triad scopes its Prettier and barrels
+ * runs to exactly this set — running them repo-wide fails every attempt on someone else's diff.
+ * Throws on a git failure; the callers turn that into a mechanical failure with the reason.
+ */
+export function collectChangedFiles(input: CollectChangedFilesInput): string[] {
+  const sets = collectChangedFileSets(input);
+  return [...new Set([...sets.committed, ...sets.workingTree])];
+}
+
+/** `runScopeCheck`'s return, widened with the soft-list files `dispatch.ts`'s `openPr` runner reads (T-31). */
+export interface ScopeCheckStepResult extends MechanicalStepResult {
+  humanReviewFiles: string[];
+}
+
+export function runScopeCheck(input: RunScopeCheckInput): ScopeCheckStepResult {
+  let sets: ChangedFileSets;
+  try {
+    sets = collectChangedFileSets({ base: input.base, runGit: input.runGit });
+  } catch (error) {
+    return {
+      ok: false,
+      reason: 'scope-check-failed',
+      question: `git no se pudo ejecutar: ${String(error)}`,
+      humanReviewFiles: [],
+    };
+  }
+
+  const changedFiles = [...new Set([...sets.committed, ...sets.workingTree])];
+  const result = checkScope({
+    lane: input.lane,
+    changedFiles,
+    declaredFiles: input.declaredFiles,
+    // T-79: only a DIRTY mirror-output path is judged as this attempt's violation — a committed-only
+    // one is a prior close's own `mirror-regen` output. See `isMirrorViolation`'s doc comment.
+    workingTreeFiles: sets.workingTree,
+  });
+  if (!result.ok) {
+    return {
+      ok: false,
+      reason: 'scope-check-failed',
+      question: `Ficheros fuera del alcance declarado: ${result.violatingFiles.join(', ')}`,
+      humanReviewFiles: [],
+    };
+  }
+
+  return { ok: true, humanReviewFiles: result.humanReviewFiles };
+}
+
+export interface CollectLeftoverFilesInput extends CollectChangedFilesInput {
+  /** Which paths are refused, and therefore which of the two buckets a leftover lands in. */
+  lane: Lane;
+}
+
+/**
+ * What the slot's current tree holds, CLASSIFIED and with no verdict attached — the informational
+ * counterpart of `runScopeCheck`, for the close paths that never run it (T-31 rounds 3 and 4): a
+ * session-level failure's plan starts at `save-work`, and `board-check` diverts before
+ * `scope-check`, so in both cases `checkScope` is never called and the `Blocked` comment would
+ * otherwise name nothing at all while the failed tree is pushed to `task/<id>` and restored into the
+ * slot by the retry.
+ *
+ * Deliberately NOT `runScopeCheck`: that function reports `humanReviewFiles: []` whenever the diff
+ * violates, which is the right answer for a verdict and the wrong one for a record. A worker that
+ * stopped with `needs-guidance` may well have left BOTH kinds behind, and the person releasing the
+ * task needs to be told about both.
+ *
+ * Round 3 filtered the tree through the soft list alone, which reported a mirror-output path — the
+ * one prefix refused on both lanes — as a soft-list file the close admits, and said nothing at all
+ * about `.claude/settings.json`. Both halves now come from `classifyChangedPaths`, the same function
+ * `checkScope` reads, so the record and the verdict cannot classify a path differently — including
+ * (T-79) the same working-tree split, so a PRIOR close's committed mirror output is not named here
+ * as a leftover to clean up either; see `isMirrorViolation`'s doc comment.
+ *
+ * Throws on a `git` failure; `executeClose` records that as "none found" rather than failing a close
+ * that has already failed.
+ */
+export function collectLeftoverFiles(input: CollectLeftoverFilesInput): PathClassification {
+  const sets = collectChangedFileSets(input);
+  const changedFiles = [...new Set([...sets.committed, ...sets.workingTree])];
+  return classifyChangedPaths(changedFiles, forbiddenPathsFor(input.lane), new Set(sets.workingTree));
+}
+
+// ── mirror-regen: keeping the CLI scaffold mirror in step with the attempt ────
+
+/**
+ * Where the packager WRITES. `scripts/packager/publish.mjs` mirrors `backend/`, `frontend/` and the
+ * monorepo root into these three directories, and `.github/workflows/cli-template-drift-check.yml`
+ * fails a PR whose committed mirror no longer matches its sources.
+ *
+ * Measured defect (PR #96, dispatched task T-3): the attempt edited `backend/src/@app/iam/**` and
+ * `frontend/src/app/domains/admin/apps/iam/**`, both mirrored roots, and the PR failed that gate.
+ * The worker could not fix it — these prefixes are refused on both lanes regardless of the T-31
+ * split (`packages/cli/` itself is soft, but its OWN generated mirror never is: `checkScope` checks
+ * these prefixes first, before either path list) — and no close step regenerated the mirror either,
+ * so ANY dispatched task touching a mirrored root could never pass CI on its own. This step closes
+ * that.
+ *
+ * Deliberately these THREE directories, not the whole `packages/cli/src/templates/` tree (T-93):
+ * the sibling `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`'s own drift check
+ * excludes it by name for that same reason. Treating it as mirror output made a legitimate
+ * hand-written `.eta` edit a hard scope violation on every attempt that declared it (T-76
+ * intento-1) even though nothing the packager writes ever lands there.
+ */
+const MIRROR_OUTPUT_PREFIXES = [
+  'packages/cli/src/templates/backend/',
+  'packages/cli/src/templates/frontend/',
+  'packages/cli/src/templates/monorepo/',
+] as const;
+
+/**
+ * The packager's own output root, subtracted from the mirrored-root list. The drift-check filter
+ * does not list it today — but if it ever did, a mirror file appearing in the diff would make this
+ * step regenerate on its own output, so the subtraction is what keeps "changed a SOURCE root" the
+ * question being asked.
+ */
+const MIRROR_OUTPUT_ROOT = 'packages/cli';
+
+/**
+ * `paths:` followed by its quoted list. Deliberately the SAME shape
+ * `scripts/packager/drift-check-paths.test.mjs` parses with — that test fails when a
+ * `copyMonorepo()` glob is missing from this list, which is precisely why the workflow is read at
+ * runtime here instead of the dispatcher keeping a second, silently divergent copy of the roots.
+ */
+const WORKFLOW_PATHS_BLOCK = /paths:\n((?:[ \t]*-[ \t]*'[^']*'\n?)+)/;
+
+/** A `/**`-suffixed glob is a subtree; anything else is one exact path. */
+const SUBTREE_GLOB_SUFFIX = '/**';
+
+/**
+ * The source roots the packager mirrors, read off the drift-check workflow's `paths:` filter.
+ * Returns `[]` when the workflow carries no parseable list — the caller treats that as "unknown",
+ * not as "nothing", since an unverifiable answer here is the same class of problem
+ * `runScopeCheck` refuses to trust.
+ */
+export function parseMirroredRoots(workflowYaml: string): string[] {
+  const block = WORKFLOW_PATHS_BLOCK.exec(workflowYaml);
+  if (!block) {
+    return [];
+  }
+  return [...block[1].matchAll(/'([^']+)'/g)]
+    .map((match) => match[1])
+    .filter((root) => root !== MIRROR_OUTPUT_ROOT && !root.startsWith(`${MIRROR_OUTPUT_ROOT}/`));
+}
+
+/**
+ * Whether this attempt changed anything the packager reads. A `backend/**`-shaped root matches its
+ * whole subtree; every other entry (`package.json`, `openspec/config.yaml`, `.prettierrc`) is an
+ * EXACT path — the packager copies that one file and no other, so matching it as a prefix would
+ * regenerate the whole mirror over an unrelated `backend-tools/package.json.bak`.
+ */
+export function touchesMirroredRoot(
+  changedFiles: readonly string[],
+  roots: readonly string[],
+): boolean {
+  const matches = (file: string, root: string): boolean => {
+    if (!root.endsWith(SUBTREE_GLOB_SUFFIX)) {
+      return file === root;
+    }
+    const directory = `${root.slice(0, -SUBTREE_GLOB_SUFFIX.length)}/`;
+    return file.startsWith(directory);
+  };
+  return changedFiles.some((file) => roots.some((root) => matches(file, root)));
+}
+
+export interface RunMirrorRegenInput {
+  /** From `resolveBaseRef` — the same base the scope check and the triad measure against. */
+  base: string;
+  /** Runs `git` in the slot; throws carry the child's stderr (the caller folds it in). */
+  runGit: (args: string[]) => string;
+  /**
+   * `.github/workflows/cli-template-drift-check.yml` as it stands IN THE SLOT, or `null` when the
+   * repo has none. A generated project is the `null` case: `copyMonorepo()` ships
+   * `scripts/backlog/**` but neither `.github/**` nor `scripts/packager/**`, so there is no mirror
+   * to keep there and no gate to satisfy.
+   */
+  driftCheckWorkflow: string | null;
+  /** Runs `node scripts/packager/publish.mjs` in the slot; throws on failure. */
+  runPackager: () => void;
+}
+
+export interface MirrorRegenResult extends MechanicalStepResult {
+  /** Whether the packager actually ran, as opposed to the step finding nothing to do. */
+  regenerated: boolean;
+  /** The mirror paths the regen left in the working tree, for the log. */
+  mirrorFiles: string[];
+}
+
+/** A factory, not a shared constant: every caller gets its own `mirrorFiles` array to hold. */
+const mirrorRegenSkipped = (): MirrorRegenResult => ({
+  ok: true,
+  regenerated: false,
+  mirrorFiles: [],
+});
+
+const mirrorRegenFailure = (question: string): MirrorRegenResult => ({
+  ok: false,
+  reason: 'mirror-regen-failed',
+  question,
+  regenerated: false,
+  mirrorFiles: [],
+});
+
+/**
+ * Regenerates the CLI scaffold mirror when — and only when — the attempt touched a root the
+ * packager reads. The regen's output lands in the working tree and is picked up by the `git add -A`
+ * `open-pr` already runs, so the mirror travels in the attempt's own commit and its PR passes the
+ * drift gate.
+ *
+ * It is NOT unconditional: `publish.mjs` is a repo-wide copy of `backend/`, `frontend/` and half the
+ * root, and running it on an attempt that changed a `cliter/*.aurora.yaml` and nothing else would
+ * spend that cost — and put a several-thousand-file mirror diff in front of the reviewer — for no
+ * reason at all.
+ *
+ * The scope check's silence about `packages/cli/src/templates/**` is the STEP ORDER, not a hole in
+ * the path lists: `scope-check` already returned its verdict over the pre-regen file set, so a
+ * mirror path the WORKER wrote by hand is still a violation, and this dispatcher-owned output
+ * simply arrives after the judging is done.
+ */
+export function runMirrorRegen(input: RunMirrorRegenInput): MirrorRegenResult {
+  if (input.driftCheckWorkflow === null) {
+    return mirrorRegenSkipped();
+  }
+
+  const roots = parseMirroredRoots(input.driftCheckWorkflow);
+  if (roots.length === 0) {
+    return mirrorRegenFailure(
+      'cli-template-drift-check.yml existe pero no se pudo leer su lista paths:, así que no se sabe qué raíces ' +
+        'espeja el packager. Sin esa lista el espejo no se puede regenerar con criterio.',
+    );
+  }
+
+  let changedFiles: string[];
+  try {
+    changedFiles = collectChangedFiles({ base: input.base, runGit: input.runGit });
+  } catch (error) {
+    return mirrorRegenFailure(`git no se pudo ejecutar: ${String(error)}`);
+  }
+
+  if (!touchesMirroredRoot(changedFiles, roots)) {
+    return mirrorRegenSkipped();
+  }
+
+  try {
+    input.runPackager();
+  } catch (error) {
+    return mirrorRegenFailure(
+      `el packager falló al regenerar el espejo del scaffold: ${String(error)}`,
+    );
+  }
+
+  // Re-read AFTER the regen: the mirror files it just wrote are part of this attempt's diff from
+  // here on — the reviewer reads them, and `open-pr`'s `git add -A` commits them.
+  let afterRegen: string[];
+  try {
+    afterRegen = collectChangedFiles({ base: input.base, runGit: input.runGit });
+  } catch (error) {
+    return mirrorRegenFailure(`git no se pudo ejecutar tras regenerar el espejo: ${String(error)}`);
+  }
+
+  const mirrorFiles = afterRegen.filter((file) =>
+    MIRROR_OUTPUT_PREFIXES.some((prefix) => file.startsWith(prefix)),
+  );
+  return { ok: true, regenerated: true, mirrorFiles };
+}
+
+export interface CollectAttemptDiffInput {
+  base: string;
+  runGit: (args: string[]) => string;
+}
+
+/**
+ * The whole diff an attempt produced, for the reviewer to read: what it committed
+ * (`<base>...HEAD`) plus what it left in the working tree (`diff HEAD`). Both halves matter for the
+ * same reason `runScopeCheck` reads both — the executor is forbidden from running `git`, so a
+ * successful attempt usually has committed nothing at all, and handing the reviewer an empty diff
+ * would earn a `VERDICT: pass` on code it never saw.
+ *
+ * The intent-to-add FIRST is what makes the second half honest. No `git diff` under any flags
+ * renders an UNTRACKED file, and on a dispatched attempt every created file is untracked — the
+ * executor is forbidden from running git, so nothing ever staged them. The reviewer was handed a
+ * diff with every new file silently missing and approved code it never saw. `add -N -A` registers
+ * their paths in the index without their content, which is exactly what makes them appear in the
+ * next `diff HEAD`.
+ *
+ * Side effect, deliberate and harmless: the slot's index is left carrying those intent-to-add
+ * entries. Every path that continues from here (`open-pr`, the failure path's WIP auto-save) runs
+ * `git add -A` over the whole tree anyway, so nothing downstream can observe the difference.
+ *
+ * THROWS on a git failure instead of returning a note. A note reads to the reviewer as the diff
+ * itself, so "git blew up" became "there is nothing here to object to" and the attempt passed the
+ * one gate meant to be adversarial. The caller turns the throw into a `reviewer-failed` step.
+ */
+export function collectAttemptDiff(input: CollectAttemptDiffInput): string {
+  input.runGit(['add', '-N', '-A', '--', '.']);
+  const parts = [input.runGit(['diff', `${input.base}...HEAD`]), input.runGit(['diff', 'HEAD'])]
+    .map((part) => part.trim())
+    .filter(Boolean);
+  return parts.length > 0 ? parts.join('\n') : '(sin cambios detectables en el slot)';
+}
+
+// ── PR creation args ───────────────────────────────────────────────────────────
+
+export interface BuildPrCreateArgsInput {
+  task: Task;
+  branch: string;
+  attempt: number;
+  title: string;
+  /**
+   * `backlog task view <id> --plain`, re-read right before the PR is opened. When given, the body
+   * is `composePrBody`'s rich composition (T-8 point 2); omitted keeps the legacy one-line body —
+   * a caller with no board text to hand (or one not yet updated to pass it) gets exactly the same
+   * behaviour this function had before `composePrBody` existed.
+   */
+  taskText?: string;
+  /** `lanes.json`'s `attempts` cap, shown alongside the attempt number in the composed body. */
+  maxAttempts?: number;
+  /**
+   * Soft-list files `checkScope` reported for this attempt (T-31). Threaded into the body's
+   * human-review section — the mark's unfailable half, since it is one argv with the body the PR
+   * is created with. Empty or omitted → no section at all.
+   */
+  humanReviewFiles?: readonly string[];
+}
+
+export interface FindOpenPrInput {
+  branch: string;
+  /** Runs `gh` and returns its stdout; injected so this never needs a network or a real repo. */
+  runGh: (args: string[]) => string;
+}
+
+/** `gh` says this when the branch has no PR at all — the one failure that means "go create one". */
+const NO_PR_FOUND = /no pull requests? found/i;
+
+/**
+ * The URL of the PR already OPEN on this branch, or `null` when there is none to reuse.
+ *
+ * A retry pushes to the same `task/T-nn` branch, so `pr create` on the second attempt fails with
+ * "a pull request for branch … already exists" — failing a close whose code is already on the
+ * remote, with a perfectly good PR open. Asking first turns that into a reuse.
+ *
+ * Only "no pull requests found" counts as absence. A revoked token or a dead network is not an
+ * absent PR, and swallowing it would have the close create a duplicate the moment `gh` recovered,
+ * so it propagates.
+ */
+export function findOpenPrUrl(input: FindOpenPrInput): string | null {
+  let raw: string;
+  try {
+    raw = input.runGh(['pr', 'view', input.branch, '--json', 'url,state']);
+  } catch (error) {
+    if (NO_PR_FOUND.test(String(error))) {
+      return null;
+    }
+    throw error;
+  }
+  const parsed = JSON.parse(raw) as { url?: string; state?: string };
+  return parsed.state === 'OPEN' && parsed.url ? parsed.url : null;
+}
+
+/**
+ * The body a pull request currently has, so a mark can be added to it without discarding what is
+ * already written there (`upsertHumanReviewSection`). Throws on a `gh` or JSON failure: the caller
+ * must be able to tell "the body is empty" from "I could not read the body", because only the first
+ * one may be safely overwritten.
+ */
+export function readPrBody(branch: string, runGh: (args: string[]) => string): string {
+  const parsed = JSON.parse(runGh(['pr', 'view', branch, '--json', 'body'])) as { body?: string };
+  return parsed.body ?? '';
+}
+
+// ── PR body composition (T-8 point 2) ─────────────────────────────────────────
+
+/**
+ * A `--plain` section heading followed by its dashed underline — the SAME shape
+ * `task-view.ts`'s own (unexported) `SECTION_HEADING` matches. Duplicated here rather than
+ * exported from there: `task-view.ts` owns the fields the dispatcher DECIDES on (status, AC/DoD,
+ * the two conventions), while the description and the implementation-notes PROSE below are read
+ * only for the PR body a human reads — a narrower, presentation-only concern that belongs beside
+ * `buildPrCreateArgs`, not inside the board parser.
+ */
+const ANY_SECTION_HEADING = /^[^\S\n]*\S[^\n]*:[^\S\n]*\n-+[^\S\n]*$/m;
+const DESCRIPTION_HEADING = /^Description:[^\S\n]*\n-+[^\S\n]*$/m;
+const IMPLEMENTATION_NOTES_HEADING = /^(?:Implementation Notes|Notes):[^\S\n]*\n-+[^\S\n]*$/m;
+
+/**
+ * T-8 defect 13: the Implementation Notes section is WORKER-authored prose — written mid-run
+ * through `worker-edit.ts`'s `--notes`/`--append-notes`, with no length limit of its own — spliced
+ * verbatim into a PUBLIC PR body. A long report also grows the `gh pr create --body` argv with no
+ * cap. `sanitizeCommentBody` already carries this exact discipline (a char cap, standalone-`---`
+ * stripping) for the `Blocked` comment; reused here rather than duplicated, with its own tail — the
+ * full text is not lost, it stays readable on the task itself, never in `review.md` or `run.log`.
+ */
+const NOTES_TRUNCATION_TAIL = '\n\n(truncado; ver las notas completas en el tablero)';
+
+/**
+ * The prose under one `--plain` section heading, up to the NEXT heading (or the end of the text).
+ * `null` when `headingPattern` is absent — a task that declares no description, or a worker that
+ * never left any notes, is not an error here; the caller renders that as "nothing to show".
+ */
+function sectionProse(taskText: string, headingPattern: RegExp): string | null {
+  const heading = headingPattern.exec(taskText);
+  if (!heading) {
+    return null;
+  }
+  const rest = taskText.slice(heading.index + heading[0].length);
+  const nextHeading = ANY_SECTION_HEADING.exec(rest);
+  const body = (nextHeading ? rest.slice(0, nextHeading.index) : rest).trim();
+  return body.length > 0 ? body : null;
+}
+
+export interface ComposePrBodyInput {
+  /** The composed PR title (see `buildPrTitle`), or `null` to fall back to the bare task id. */
+  title: string | null;
+  taskId: string;
+  /** `backlog task view <id> --plain`, re-read right before the PR is opened. */
+  taskText: string;
+  /** The attempt this PR was opened from. */
+  attempt: number;
+  /** `lanes.json`'s `attempts` cap; shown alongside the attempt number when given. */
+  maxAttempts?: number;
+  /** Soft-list files `checkScope` reported (T-31); empty or omitted → no human-review section. */
+  humanReviewFiles?: readonly string[];
+}
+
+/**
+ * How many soft-list paths any mark renders in full. The list is worker-influenced (it is derived
+ * from the attempt's own diff) and it is spliced into a PUBLIC pull request body and into the `gh`
+ * argv, which is the same unbounded-splice defect T-8 point 13 fixed for the worker's
+ * implementation notes with `sanitizeCommentBody`. A generated module or a wide refactor under
+ * `packages/cli/` produces hundreds of paths, so the count carries what the truncation drops: the
+ * complete list is in the diff the reviewer is being sent to read anyway.
+ */
+const MAX_MARKED_FILES = 40;
+
+/**
+ * The markers that delimit the human-review section inside a pull request body. HTML comments, so
+ * GitHub renders nothing for them, and they are what `upsertHumanReviewSection` finds the section
+ * by on a rewrite.
+ */
+export const HUMAN_REVIEW_SECTION_START = '<!-- dispatcher:human-review:start -->';
+export const HUMAN_REVIEW_SECTION_END = '<!-- dispatcher:human-review:end -->';
+
+/**
+ * How many CHARACTERS of rendered paths any mark splices, and how long a single path may be. The
+ * count cap above bounds how MANY entries appear and says nothing about their size: forty paths of
+ * four kilobytes each is a 160 KB section in a public pull request body and in a `gh` argv. Two
+ * budgets rather than one, so a single pathological path cannot consume the whole list.
+ *
+ * This cap does NOT keep the `Blocked` comment's actionable line alive, and round 3's docstring
+ * claimed it did. Measured (T-31 round 4): 40 soft paths of ~60 chars fill this budget and a
+ * 1900-char worker report fills most of the rest, and the comment came to EXACTLY
+ * `MAX_COMMENT_CHARS` with `whatToDo` cut off — a list budget that is half the comment budget and
+ * knows nothing about what the rest of the comment already used cannot bound the total.
+ * `formatBlockComment` budgets its lists against the room the comment has LEFT for exactly that
+ * reason; this stays the ceiling that applies wherever there is no such room to measure (the PR body
+ * and the `gh` argv).
+ */
+const MAX_MARKED_LIST_CHARS = 2000;
+const MAX_MARKED_PATH_CHARS = 200;
+
+/**
+ * One path as it may be spliced into a pull request body, a `gh` argv or a board comment. Paths
+ * reach here VERBATIM from `git diff -z` / `git status -z` (that is the whole point of `-z`), so
+ * every byte a filename may legally hold arrives intact — including the ones that break the
+ * channels this list travels through:
+ *
+ *   - `<` and `>` are escaped, so a rendered path can never spell an HTML comment and therefore
+ *     never spell `HUMAN_REVIEW_SECTION_START`/`_END`. Measured defect (T-31 round 3): a file named
+ *     with the literal end marker inside it put a second copy of that marker in the middle of the
+ *     list, so `upsertHumanReviewSection`'s `indexOf(END)` landed mid-list and the next rewrite
+ *     sliced at the wrong offset — destroying the human text the delimited section exists to keep.
+ *     The escapes render as the literal characters on GitHub, so nothing is lost to a reader.
+ *   - control characters (a newline, a tab, a NUL) become `?`: one changed file must render as one
+ *     entry, or a single path silently becomes several bullets, or several comma-separated names.
+ *   - the path itself is capped, so one entry cannot swallow the whole budget below.
+ *
+ * ONE rendering for both channels, decided in T-31 round 4 rather than left implicit: the escapes
+ * render back as `<` and `>` on GitHub and appear LITERALLY (`&lt;`) in a `Blocked` comment read
+ * through `backlog task view --plain`, where there are no markers to protect. A second, channel-aware
+ * renderer would mean two code paths over worker-supplied bytes — the class of thing this function
+ * exists to keep to one — for a cosmetic gain: `packages/cli/x&lt;y&gt;.ts` still identifies the file
+ * on a board a person is reading in order to go and look at it. So the escape is unconditional, and
+ * the board channel shows it.
+ */
+function renderMarkedPath(file: string): string {
+  const escaped = file
+    .replace(/[\u0000-\u001f\u007f]/g, '?')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+  return escaped.length > MAX_MARKED_PATH_CHARS
+    ? `${escaped.slice(0, MAX_MARKED_PATH_CHARS)}…`
+    : escaped;
+}
+
+interface CappedFileList {
+  shown: readonly string[];
+  omitted: number;
+}
+
+/**
+ * `files` RENDERED (see `renderMarkedPath`) and capped on both budgets — the entry count and
+ * `charBudget` characters of paths — plus how many entries were dropped. The caller renders `omitted`
+ * so the reviewer knows the list is partial; the complete set is in the diff they are being sent to
+ * read.
+ *
+ * `charBudget` defaults to `MAX_MARKED_LIST_CHARS`, which is the right answer for the pull-request
+ * body (a body has no other budget to share). `formatBlockComment` passes a SMALLER one: what the
+ * comment has left after everything that must survive it.
+ */
+function capFileList(
+  files: readonly string[],
+  charBudget: number = MAX_MARKED_LIST_CHARS,
+): CappedFileList {
+  const shown: string[] = [];
+  let used = 0;
+  for (const file of files) {
+    if (shown.length >= MAX_MARKED_FILES) {
+      break;
+    }
+    const rendered = renderMarkedPath(file);
+    // The `shown.length > 0` clause is what keeps a single over-budget path from rendering an empty
+    // list: one entry always gets in, truncated by `MAX_MARKED_PATH_CHARS` if need be.
+    if (used + rendered.length > charBudget && shown.length > 0) {
+      break;
+    }
+    shown.push(rendered);
+    used += rendered.length;
+  }
+  return { shown, omitted: files.length - shown.length };
+}
+
+/** The capped list on ONE line, for a comment that has no room for a bullet list. */
+function formatFileList(files: readonly string[], charBudget?: number): string {
+  const { shown, omitted } = capFileList(files, charBudget);
+  return omitted > 0 ? `${shown.join(', ')} (y ${omitted} más)` : shown.join(', ');
+}
+
+/**
+ * The mark's unfailable half (design.md decision 8, T-31): a section naming the soft-list files a
+ * pull request reaches, so a person reviewing it sees WHY before they see the diff. `null` when
+ * `files` is empty — the caller renders that as "no section at all", not an empty heading.
+ *
+ * The membership is rendered FROM `HUMAN_REVIEW_PATHS`, never spelled out in the prose: the
+ * hard-coded sentence this replaces named `CLAUDE.md` among the soft entries and went stale the
+ * moment that basename went back to hard (T-31 round 2) — the exact prose/code drift this whole
+ * change exists to undo.
+ */
+function humanReviewSection(files: readonly string[]): string | null {
+  if (files.length === 0) {
+    return null;
+  }
+  const { shown, omitted } = capFileList(files);
+  const list = shown.map((file) => `- ${file}`).join('\n');
+  const tail = omitted > 0 ? `\n- (y ${omitted} ficheros más; ver el diff completo)` : '';
+  const membership = HUMAN_REVIEW_PATHS.map((pattern) => `\`${pattern}\``).join(', ');
+  return (
+    `${HUMAN_REVIEW_SECTION_START}\n` +
+    '## Revisión humana requerida\n\n' +
+    `Este intento tocó rutas de la lista blanda (${membership}): admitidas por el cierre, pero ` +
+    'nadie automático las ha juzgado. Requieren lectura humana antes de fusionar:\n\n' +
+    `${list}${tail}\n` +
+    HUMAN_REVIEW_SECTION_END
+  );
+}
+
+/**
+ * `currentBody` with the human-review section for `files` written into it: replacing the delimited
+ * section already there, or appended when there is none. Everything outside the markers is
+ * returned byte-for-byte.
+ *
+ * Why this is not a recomposition (T-31 round 2). `gh pr edit --body` is a full REPLACEMENT, and
+ * the pull requests this mark rewrites are precisely the ones a person was asked to read and
+ * annotate — the retry flow reuses the same branch, so the second attempt's rewrite landed on a
+ * body a reviewer may have been editing. "The body is a deterministic function of the task"
+ * (design.md decision 8) is true of the dispatcher-authored half and false of every word a human
+ * added, and a mark that destroys the review it asks for is worse than no mark.
+ *
+ * An empty `files` returns the body untouched: there is nothing to mark, and removing a section a
+ * previous attempt legitimately added is not this function's call to make.
+ *
+ * A MALFORMED or REPEATED marker arrangement is resolved deterministically rather than falling
+ * through to the append branch (T-31 round 3 — that fall-through accumulated a second section on
+ * every retry, since the pair stayed malformed and the next rewrite appended again). The body is
+ * walked once, left to right, and each dispatcher-authored region is dropped while everything
+ * between the regions is kept:
+ *
+ *   - a START with a later END — the ordinary case — is a section: dropped, and the FIRST one is
+ *     where the new section is written;
+ *   - a SECOND (third, …) full pair is another section, dropped the same way. Round 3 spliced from
+ *     the first START to the LAST END instead, which swallowed everything between the two sections —
+ *     measured (T-31 round 4) on exactly the bodies this fix exists to repair, since the pre-round-3
+ *     code appended a second section on every retry and open pull requests already hold that shape;
+ *   - a START with no END after it is a TRUNCATED section (the dispatcher's own tail, cut short by
+ *     a failed write), so the drop runs from that START to the end of the body;
+ *   - an END with no START before it is a stray marker, removed so it cannot pair with the START
+ *     this call writes. Only the invisible marker comment goes; every word around it survives.
+ *
+ * The result therefore always holds exactly ONE well-ordered pair, which makes the next rewrite the
+ * ordinary case again — and no text a person wrote OUTSIDE a section is ever removed.
+ */
+export function upsertHumanReviewSection(currentBody: string, files: readonly string[]): string {
+  const section = humanReviewSection(files);
+  if (section === null) {
+    return currentBody;
+  }
+  // Everything the walk keeps, in order, with `null` marking where the new section goes.
+  const kept: Array<string | null> = [];
+  let cursor = 0;
+  while (cursor <= currentBody.length) {
+    const start = currentBody.indexOf(HUMAN_REVIEW_SECTION_START, cursor);
+    if (start === -1) {
+      kept.push(dropStrayEndMarkers(currentBody.slice(cursor)));
+      break;
+    }
+    kept.push(dropStrayEndMarkers(currentBody.slice(cursor, start)));
+    if (!kept.includes(null)) {
+      kept.push(null);
+    }
+    const end = currentBody.indexOf(
+      HUMAN_REVIEW_SECTION_END,
+      start + HUMAN_REVIEW_SECTION_START.length,
+    );
+    if (end === -1) {
+      // A truncated section: the rest of the body is the dispatcher's own half-written tail.
+      break;
+    }
+    cursor = end + HUMAN_REVIEW_SECTION_END.length;
+  }
+
+  if (!kept.includes(null)) {
+    const body = kept.join('');
+    return body.length > 0 ? `${body}\n\n${section}` : section;
+  }
+  return kept.map((piece) => (piece === null ? section : piece)).join('');
+}
+
+/**
+ * `text` with every END marker deleted and every other byte kept. Applied to the stretches BETWEEN
+ * sections, where an END belongs to no section and would otherwise pair with the START this rewrite
+ * writes — the marker comment is invisible on GitHub, so nothing a reader sees is lost.
+ */
+function dropStrayEndMarkers(text: string): string {
+  return text.split(HUMAN_REVIEW_SECTION_END).join('');
+}
+
+/**
+ * Composes the close's PR body FROM the task, mechanically — no summarization beyond "read the
+ * sections `task-view.ts` and this module already parse, render them under their own heading".
+ * `close.test.ts` asserts this composed STRING directly; it never calls `gh`, so nothing here needs
+ * a network or a real repo to verify.
+ *
+ * Before this existed, the body was the single line `Dispatched attempt N for <id>.` — a PR a
+ * reviewer had to open the task board to understand at all. Every section here answers a question
+ * that line left to a second lookup: what the task is FOR (description), what the worker actually
+ * DID (implementation notes, when it left any), what it PROVED (the AC list, each with its checked
+ * state — the only "evidence" this format carries structurally; nothing here fabricates a
+ * per-criterion narrative the worker never wrote), and how many tries it took (attempt statistics).
+ */
+export function composePrBody(input: ComposePrBodyInput): string {
+  // `input.title` already IS the composed PR title (`buildPrTitle(task.id, task.title)`, applied by
+  // the caller — `buildPrCreateArgs` below, and `dispatch.ts` before that) — running it through
+  // `buildPrTitle` a second time here used to prefix the id twice (`# T-8: T-8: <title>`), because
+  // `buildPrTitle` has no way to tell "already composed" from "bare title" apart. Use it as-is; only
+  // fall back to the bare task id when there is no title to show at all.
+  const heading = input.title ?? input.taskId;
+  const sections: string[] = [`# ${heading}`];
+
+  const description = sectionProse(input.taskText, DESCRIPTION_HEADING);
+  sections.push(`## Resumen\n\n${description ?? '(la tarea no declara descripción)'}`);
+
+  const notes = sectionProse(input.taskText, IMPLEMENTATION_NOTES_HEADING);
+  if (notes) {
+    sections.push(
+      `## Notas de implementación\n\n${sanitizeCommentBody(notes, NOTES_TRUNCATION_TAIL)}`,
+    );
+  }
+
+  const criteria = parseChecklistItems(input.taskText, ACCEPTANCE_CRITERIA_HEADING);
+  const acBody =
+    criteria.length > 0
+      ? criteria.map((item) => `- [${item.checked ? 'x' : ' '}] ${item.text}`).join('\n')
+      : '(sin criterios de aceptación declarados)';
+  sections.push(`## Criterios de aceptación\n\n${acBody}`);
+
+  const attemptLine = input.maxAttempts
+    ? `Intento ${input.attempt} de ${input.maxAttempts}.`
+    : `Intento ${input.attempt}.`;
+  sections.push(`## Estadísticas del intento\n\n${attemptLine}`);
+
+  const reviewSection = humanReviewSection(input.humanReviewFiles ?? []);
+  if (reviewSection) {
+    sections.push(reviewSection);
+  }
+
+  return sections.join('\n\n');
+}
+
+/** The exact `gh` argv for the close's PR, with `--base` resolved by `resolveBaseBranch`. */
+export function buildPrCreateArgs(input: BuildPrCreateArgsInput): string[] {
+  const body = input.taskText
+    ? composePrBody({
+        title: input.title,
+        taskId: input.task.id,
+        taskText: input.taskText,
+        attempt: input.attempt,
+        maxAttempts: input.maxAttempts,
+        humanReviewFiles: input.humanReviewFiles,
+      })
+    : `Dispatched attempt ${input.attempt} for ${input.task.id}.`;
+  return [
+    'pr',
+    'create',
+    '--base',
+    resolveBaseBranch(input.task),
+    '--head',
+    input.branch,
+    '--title',
+    input.title,
+    '--body',
+    body,
+  ];
+}
+
+// ── The human-review mark's two best-effort halves (design.md decision 8, T-31) ──
+//
+// Both are a SEPARATE `gh pr edit` call, deliberately: a label the repository does not have would
+// otherwise fail `gh pr create` itself and turn a green attempt into a blocked task with a WIP
+// commit, and a rejected reviewer must not take the label down with it. `dispatch.ts`'s `openPr`
+// runner applies both, wrapped so a failure is RECORDED (the attempt's own log) and never fatal.
+
+/** The GitHub label a soft-list attempt's pull request is marked with. Created once, by hand (task 5.1). */
+export const HARNESS_REVIEW_LABEL = 'harness-review';
+
+/** `gh pr edit <branch> --add-label harness-review`. */
+export function buildPrLabelArgs(branch: string): string[] {
+  return ['pr', 'edit', branch, '--add-label', HARNESS_REVIEW_LABEL];
+}
+
+/**
+ * `gh pr edit <branch> --body <body>` — the mark's BODY half on the reuse branch only.
+ *
+ * On a newly created pull request the body travels inside `gh pr create --body`
+ * (`buildPrCreateArgs`), which is what makes it the half that cannot fail. A retry pushes to the
+ * same branch and REUSES the pull request already open on it, so there is no create call to carry
+ * it: without this the reused body would never name the soft-list files, and the mark would rest
+ * entirely on the two calls design.md decision 8 explicitly allows to fail. Best-effort like them —
+ * the push has already updated the pull request by the time this runs.
+ */
+export function buildPrBodyArgs(branch: string, body: string): string[] {
+  return ['pr', 'edit', branch, '--body', body];
+}
+
+/** `gh pr edit <branch> --add-reviewer <handle>` — `reviewer` is `lanes.json`'s optional `harnessReviewer`. */
+export function buildPrReviewerArgs(branch: string, reviewer: string): string[] {
+  return ['pr', 'edit', branch, '--add-reviewer', reviewer];
+}
+
+// ── The WIP auto-save commit message ──────────────────────────────────────────
+
+/**
+ * The message the failure path's WIP commit uses. It stays a Conventional Commit even though the
+ * dispatcher's own commits run with `--no-verify` (a slot's hooks are files the worker could have
+ * just written): this is what lands on `task/T-nn` for a person to read, and `close.test.ts` runs
+ * it through the repo's real commitlint so the machine's history reads like everyone else's.
+ *
+ * The scope is the task id lowercased — the same casing `buildAttemptCommitMessage` uses, so both
+ * dispatcher-authored commits are greppable with one pattern.
+ */
+export function buildWipCommitMessage(taskId: string): string {
+  return `chore(${taskId.toLowerCase()}): wip dispatcher auto-save`;
+}
+
+/** The green path's commit, in the same shape and casing as the WIP auto-save above. */
+export function buildAttemptCommitMessage(taskId: string, attempt: number): string {
+  return `feat(${taskId.toLowerCase()}): dispatched attempt ${attempt}`;
+}
+
+/**
+ * The PR title: `<id>: <task title>`. The id alone was unreadable on a list of open PRs — every
+ * dispatched PR looked the same and had to be opened to find out what it was. A title that could
+ * not be read back off the board falls back to the bare id rather than to a placeholder.
+ */
+export function buildPrTitle(taskId: string, title: string | null): string {
+  const trimmed = title?.trim();
+  return trimmed ? `${taskId}: ${trimmed}` : taskId;
+}
+
+// ── The mechanical triad (format, barrels lint, scoped test) ──────────────────
+
+export interface MechanicalCheck {
+  label: string;
+  command: string;
+  args: string[];
+  /**
+   * Non-zero exit statuses this check treats as advisory, not a failure — the check's OWN
+   * pass/fail contract. Absent (every check but lint-barrels) means any non-zero status still
+   * fails, unchanged from before this field existed. Declared per check, not read from the exit
+   * code by the evaluation loop, so a future check never inherits a tolerance it did not ask for.
+   */
+  advisoryStatuses?: readonly number[];
+}
+
+export interface MechanicalCheckOutcome {
+  /** False only when the status is neither zero nor declared advisory — this fails the attempt. */
+  ok: boolean;
+  /** True when a non-zero status passed because the check declared it advisory. */
+  advisory: boolean;
+}
+
+/**
+ * Turns a check's raw exit status into pass/fail, honouring the check's OWN advisory contract
+ * instead of hardcoding a status number here. Exit 0 always passes; any other status passes ONLY
+ * when the check declares it advisory (today: lint-barrels' exit 2 — HR-BARRELS-004's
+ * `informational` tier, the same contract `.husky/pre-commit` already honours). A status the
+ * check does not name still fails, so a check added later inherits no tolerance silently.
+ */
+export function evaluateMechanicalCheckResult(
+  check: MechanicalCheck,
+  status: number,
+): MechanicalCheckOutcome {
+  if (status === 0) {
+    return { ok: true, advisory: false };
+  }
+  if (check.advisoryStatuses?.includes(status)) {
+    return { ok: true, advisory: true };
+  }
+  return { ok: false, advisory: false };
+}
+
+export interface PlanMechanicalChecksInput {
+  /** The task's declared `Test command:` line, or `null` when it declared none. */
+  testCommand: string | null;
+  /** Whether the repo exposes the barrels linter (`pnpm hr:lint-barrels`). */
+  lintBarrels: boolean;
+  /** Repo-relative paths the attempt actually changed — `runScopeCheck`'s union of diff + status. */
+  changedFiles: readonly string[];
+  /**
+   * Whether a repo-relative path is still on disk in the slot. A DELETED file is a changed file, and
+   * both `prettier --check` and the barrels linter fail outright on a path that is not there — so a
+   * legitimate deletion would fail the triad. Injected rather than read here so this stays pure.
+   */
+  exists: (repoRelativePath: string) => boolean;
+}
+
+export interface MechanicalPlan {
+  checks: MechanicalCheck[];
+  /** Set when the declared test command was refused; the triad fails with exactly this reason. */
+  refusal: string | null;
+  /** Changed files no workspace's Prettier covers — the caller logs them, nothing runs on them. */
+  skippedPrettierFiles: string[];
+}
+
+const LINT_BARRELS_SCRIPT = 'hr:lint-barrels';
+
+/**
+ * The workspaces that actually ship Prettier, longest prefix first so `packages/core-back/` wins
+ * over a shorter accidental match. `npx prettier` at the repo root exits 127 — Prettier is NOT a
+ * root dependency here — so a repo-wide `npx prettier --check .` was a triad that could never pass.
+ */
+const PRETTIER_WORKSPACES: readonly { prefix: string; packageName: string }[] = [
+  { prefix: 'packages/core-back/', packageName: '@aurorajs.dev/core-back' },
+  { prefix: 'packages/core-front/', packageName: '@aurorajs.dev/core-front' },
+  { prefix: 'backend/', packageName: 'aurora-back' },
+  { prefix: 'frontend/', packageName: 'aurora-front' },
+];
+
+/**
+ * Files under a prettier workspace that must never reach `--write`: drizzle-kit's own OUTPUT
+ * (`migration.sql` and `snapshot.json`), not hand-written code. Measured (T-6.1, first real
+ * frontier dispatch): the repo's shipped `snapshot.json` files are NOT prettier-formatted
+ * (`prettier --check` warns on every one, 432 KB each), so a `--write` would rewrite a tool-owned
+ * artifact into a huge noise-only diff — and `migration.sql` has no inferrable parser at all.
+ * Excluded from both prettier buckets entirely; still counted for the scope check like any other
+ * changed file.
+ */
+const PRETTIER_TOOL_OWNED_PREFIXES: readonly string[] = [
+  'backend/src/database/migrations/drizzle/',
+];
+
+/**
+ * The roots HR-BARRELS governs (`scripts/harness-rules/lint-barrels.ts`'s `collectGoverned`).
+ * Passing the linter a file outside them makes it lint code the rule was never written for; passing
+ * it nothing at all makes it sweep the WHOLE repo, which is red on `main` today for pre-existing
+ * violations in generated frontend code — either way the attempt gets blamed for someone else's diff.
+ */
+const BARRELS_GOVERNED_PREFIXES: readonly string[] = [
+  'backend/src/@api/',
+  'backend/src/@app/',
+  'backend/src/@bridges/',
+  'backend/src/@aurora/',
+  'frontend/src/app/domains/admin/apps/',
+];
+
+/**
+ * The ordered mechanical checks a green close must pass, cheapest first and scoped to THIS
+ * attempt's changed files: Prettier per workspace that has it, the barrels linter over the governed
+ * `.ts` files, then the task's own test command. Scoping is the whole point — a repo-wide run would
+ * fail every attempt on pre-existing violations the task never touched, so the triad would be an
+ * alarm that always fires.
+ *
+ * A missing test command drops the step (the caller logs the gap); a REFUSED one fails the triad,
+ * because "the command is not allowed" is a real problem a person has to look at, not a gap.
+ */
+export function planMechanicalChecks(input: PlanMechanicalChecksInput): MechanicalPlan {
+  const checks: MechanicalCheck[] = [];
+  const skippedPrettierFiles: string[] = [];
+
+  // Deleted paths drop out before anything is planned over them: neither tool can read a file that
+  // is correctly gone, and reporting one as a "skipped prettier file" would misname a deletion.
+  const presentFiles = input.changedFiles.filter((file) => input.exists(file));
+
+  const byWorkspace = new Map<string, { packageName: string; files: string[] }>();
+  for (const file of presentFiles) {
+    // Tool-owned output IS covered by a prettier workspace, so it does not belong in
+    // `skippedPrettierFiles` either — that list means "no workspace covers this", and reporting a
+    // deliberate exclusion there would misname it as a coverage gap for a person to chase.
+    if (PRETTIER_TOOL_OWNED_PREFIXES.some((prefix) => file.startsWith(prefix))) {
+      continue;
+    }
+    const workspace = PRETTIER_WORKSPACES.find((candidate) => file.startsWith(candidate.prefix));
+    if (!workspace) {
+      skippedPrettierFiles.push(file);
+      continue;
+    }
+    const bucket = byWorkspace.get(workspace.prefix) ?? {
+      packageName: workspace.packageName,
+      files: [],
+    };
+    // `pnpm --filter <pkg> exec` runs in the package directory, so the paths must be relative to it.
+    bucket.files.push(file.slice(workspace.prefix.length));
+    byWorkspace.set(workspace.prefix, bucket);
+  }
+
+  for (const { prefix, packageName } of PRETTIER_WORKSPACES) {
+    const bucket = byWorkspace.get(prefix);
+    if (bucket) {
+      // Format, THEN verify. design.md decision (h) puts the format hook in the close "where a
+      // deterministic script enforces them": a bare `--check` only reports, and the executor is
+      // never asked to run Prettier, so an indentation nit failed a whole attempt over something
+      // the close can fix in place. The `--check` after the write is not redundant — it is what
+      // proves the write actually took (a syntax error makes Prettier rewrite nothing).
+      for (const mode of ['--write', '--check'] as const) {
+        checks.push({
+          label: `prettier ${mode} (${packageName})`,
+          command: 'pnpm',
+          // `--ignore-unknown` because a file prettier has no parser for (measured: a `.sql` file,
+          // "No parser could be inferred") otherwise exits 2 and fails the whole triad over a file
+          // prettier was never going to format anyway. `--` because a changed path beginning with a
+          // dash is otherwise read as a flag.
+          args: [
+            '--filter',
+            packageName,
+            'exec',
+            'prettier',
+            mode,
+            '--ignore-unknown',
+            '--',
+            ...bucket.files,
+          ],
+        });
+      }
+    }
+  }
+
+  const barrelsFiles = presentFiles.filter(
+    (file) =>
+      file.endsWith('.ts') && BARRELS_GOVERNED_PREFIXES.some((prefix) => file.startsWith(prefix)),
+  );
+  if (input.lintBarrels && barrelsFiles.length > 0) {
+    checks.push({
+      label: 'lint-barrels',
+      command: 'pnpm',
+      args: [LINT_BARRELS_SCRIPT, '--', ...barrelsFiles],
+      // HR-BARRELS-004's `informational` severity maps to exit 2 (`computeExitCode`,
+      // scripts/harness-rules/lint-barrels.ts) — the same status `.husky/pre-commit` already lets
+      // through. Only THIS check owns that tolerance; prettier and the test step declare none.
+      advisoryStatuses: [2],
+    });
+  }
+
+  const testCommand = resolveTestCommand(input.testCommand);
+  if (testCommand.kind === 'refused') {
+    return { checks, refusal: testCommand.reason, skippedPrettierFiles };
+  }
+  if (testCommand.kind === 'ok') {
+    checks.push({ label: 'test', command: testCommand.command, args: testCommand.args });
+  }
+
+  return { checks, refusal: null, skippedPrettierFiles };
+}
+
+// ── The pre-PR acceptance gate (design.md's close diagram, `AC`) ──────────────
+
+/**
+ * The "scoped tests pass" Definition-of-Done default, and what the gate says when it is still
+ * unticked. Exported so `dispatch.ts` uses the SAME pattern for the tick as the gate uses for the
+ * check — two regexes that drifted apart would make the gate unpassable or toothless.
+ */
+export const DOD_SCOPED_TESTS = /scoped tests pass/i;
+
+const NO_TEST_COMMAND_QUESTION =
+  'la tarea no declara Test command: nada probó este intento, así que "scoped tests pass" no puede darse por cumplido.';
+
+/**
+ * The gate that stands between a finished attempt and its PR. It judges ACCEPTANCE CRITERIA — what
+ * the task asked for — plus any Definition-of-Done item no close step proves. The dispatcher-owned
+ * DoD defaults are excluded and ticked by the close itself once the step that proves them passed
+ * (`task-view.ts`'s `DISPATCHER_OWNED_DOD_PATTERNS`): blocking on them here would fail every green
+ * attempt on bookkeeping the worker was never asked to do.
+ *
+ * A task with NO acceptance criteria fails: there is then nothing to verify the work against, so a
+ * pass would mean "the gate approved something it could not read".
+ */
+export function evaluateAcceptanceGate(taskText: string): MechanicalStepResult {
+  if (parseChecklistItems(taskText, ACCEPTANCE_CRITERIA_HEADING).length === 0) {
+    return {
+      ok: false,
+      reason: 'ac-check-failed',
+      question: 'la tarea no declara criterios de aceptación',
+    };
+  }
+
+  // The one dispatcher-owned item this gate still judges. The triad ticks it ONLY when a test
+  // command actually ran and passed, so an unticked one here means nothing tested this attempt —
+  // and excluding it as "dispatcher-owned" let exactly that reach a PR with the box ticked by
+  // nobody. Guard 1 refuses an undeclared `Test command:` before launch; this is the second half
+  // of the same rule, against the board as it stands at the gate.
+  if (findOwnedDefinitionOfDone(taskText, DOD_SCOPED_TESTS).length > 0) {
+    return { ok: false, reason: 'ac-check-failed', question: NO_TEST_COMMAND_QUESTION };
+  }
+
+  const pending = [
+    ...findUncheckedAcceptanceCriteria(taskText).map((item) => `AC #${item.index}: ${item.text}`),
+    ...findUnownedUncheckedDefinitionOfDone(taskText).map(
+      (item) => `DoD #${item.index}: ${item.text}`,
+    ),
+  ];
+  if (pending.length === 0) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    reason: 'ac-check-failed',
+    question: `Quedan criterios sin marcar con evidencia:\n- ${pending.join('\n- ')}`,
+  };
+}
+
+// ── Board integrity: the task still says what it said at launch ───────────────
+
+export interface CheckBoardIntegrityInput {
+  /** `backlog task view <id> --plain`, re-read AFTER the worker exited. */
+  taskText: string;
+  /** The task as it was SNAPSHOTTED at launch — the contract the attempt was dispatched under. */
+  task: Task;
+}
+
+/**
+ * The first close gate: the board still describes the task the dispatcher launched.
+ *
+ * The worker holds the dispatcher's `worker-edit.ts` wrapper on its own task for its whole run — it
+ * has to, since that is its only channel for ticking criteria and recording notes. The wrapper is
+ * the BARRIER (it reads the whole argv before anything reaches the CLI); this gate is the DETECTOR
+ * behind it, for the case where a permission rule silently fails to match anyway:
+ *
+ *   - **status**: a worker that set itself to `Done` gets a maintenance sweep reading a finished
+ *     task nobody verified; one that set itself to `Queued` gets dispatched again by the next pass
+ *     while this close is still running. Anything but `In Progress` fails the attempt.
+ *   - **checklist texts**: the pre-PR gate and the reviewer both judge the attempt against exactly
+ *     these criteria, so a criterion rewritten into something the attempt can meet is a gate the
+ *     thing under test authored itself. Only the TEXTS are compared — the checked state is what the
+ *     worker is supposed to change, and comparing it would fail every correct run.
+ *   - **title, `Files to touch:` and `Test command:`**: the rest of the contract the attempt is
+ *     judged against — the title names the PR, the declared files are the allowlist the scope check
+ *     runs, and the test command is what the triad executes. All three are description text the
+ *     board write channel can reach, so all three are compared against the launch snapshot.
+ *   - **`Parent:`**: it decides the PR's base branch (`resolveBaseBranch`) and the ref the attempt
+ *     is diffed against. A parent that appeared after launch would open the PR against a branch the
+ *     task never declared; one that vanished diffs a child against `main`, reporting every file the
+ *     parent already changed as this attempt's scope violation.
+ *
+ * An unreadable view fails closed: it is indistinguishable from a task that no longer exists.
+ */
+export function checkBoardIntegrity(input: CheckBoardIntegrityInput): MechanicalStepResult {
+  const status = parseTaskStatus(input.taskText);
+  if (status !== TASK_STATUS.IN_PROGRESS) {
+    return {
+      ok: false,
+      reason: 'status-changed-by-worker',
+      question: `El tablero ya no dice "In Progress" para esta tarea, sino "${status}": el worker cambió su propio estado, así que el cierre no puede fiarse de él.`,
+    };
+  }
+
+  const drifted = (heading: string, snapshot: readonly string[]): string | null => {
+    const current = parseChecklistItems(input.taskText, heading).map((item) => item.text);
+    return current.length === snapshot.length &&
+      current.every((text, index) => text === snapshot[index])
+      ? null
+      : `${heading}: se esperaba [${snapshot.join(' | ')}] y el tablero dice [${current.join(' | ')}]`;
+  };
+
+  const changed = (
+    label: string,
+    snapshot: string | null,
+    current: string | null,
+  ): string | null =>
+    snapshot === current
+      ? null
+      : `${label}: se esperaba "${snapshot ?? ''}" y el tablero dice "${current ?? ''}"`;
+
+  const differences = [
+    drifted(ACCEPTANCE_CRITERIA_HEADING, input.task.acceptanceCriteria),
+    drifted(DEFINITION_OF_DONE_HEADING, input.task.definitionOfDone),
+    changed('Title', input.task.title ?? null, parseTaskTitle(input.taskText)),
+    changed('Parent', input.task.parentId ?? null, parseParentId(input.taskText)),
+    changed(
+      'Files to touch',
+      input.task.filesToTouch.join(', '),
+      parseFilesToTouch(input.taskText).join(', '),
+    ),
+    changed('Test command', input.task.testCommand, parseTestCommand(input.taskText)),
+  ].filter((difference): difference is string => difference !== null);
+
+  if (differences.length > 0) {
+    return {
+      ok: false,
+      reason: 'ac-tampered',
+      question:
+        'Los criterios, el título o el alcance cambiaron desde el lanzamiento (worker o persona). Re-encolar vuelve a ' +
+        `tomar la instantánea.\n- ${differences.join('\n- ')}`,
+    };
+  }
+  return { ok: true };
+}
+
+// ── Close plan (discriminated union of steps) ─────────────────────────────────
+
+export interface BlockDetails {
+  reason: string;
+  question?: string;
+  branch: string;
+  compareUrl?: string;
+  logPath: string;
+  whatToDo: string;
+  /** The attempt number a retry would run as (current attempt + 1). */
+  attempt: number;
+  /** True once the attempt that just failed reached the configured attempt cap — no retry left. */
+  terminal: boolean;
+  /**
+   * The soft-list files `checkScope` ADMITTED for this attempt (T-31 round 2), when the scope check
+   * got that far. On the green path the mark lives on the pull request; on this path there is no
+   * pull request at all — `planClose`'s failure plan is `save-work` then `block`, with no `open-pr`
+   * step — so the `Blocked` comment is the only channel that reaches a person, and it names them.
+   * Empty or omitted → no section in the comment.
+   */
+  humanReviewFiles?: readonly string[];
+  /**
+   * The REFUSED paths the failed attempt left in the slot: the mirror output and the lane's hard
+   * list (T-31 round 4). Only the probe on a failure with no scope check behind it produces these —
+   * a `scope-check-failed` verdict already names its violations in `question`. They are reported as
+   * violations and never merged into the list above: the retry restores this tree into the slot from
+   * `task/<id>`, so the person releasing the task is the one who has to clean it out.
+   */
+  forbiddenFiles?: readonly string[];
+}
+
+export type CloseStep =
+  | { kind: 'board-check' }
+  | { kind: 'scope-check' }
+  | { kind: 'format-lint-test' }
+  | { kind: 'mirror-regen' }
+  | { kind: 'reviewer' }
+  | { kind: 'ac-check' }
+  | { kind: 'open-pr' }
+  | { kind: 'release-slot' }
+  | { kind: 'recompute-parent' }
+  | { kind: 'drain' }
+  | { kind: 'save-work' }
+  | { kind: 'block'; details: BlockDetails }
+  | { kind: 'block-keep-slot'; details: BlockDetails };
+
+export type ClosePlan = CloseStep[];
+
+const WHAT_TO_DO_RETRY =
+  'Corrige el motivo y mueve la tarea a Queued para reintentar en la misma rama.';
+const whatToDoTerminal = (maxAttempts: number): string =>
+  `Se agotaron los ${maxAttempts} intentos de dispatch; revisa el fallo manualmente, no se reintentará solo.`;
+
+interface BuildBlockDetailsInput {
+  reason: string;
+  question?: string;
+  branch: string;
+  compareUrl?: string;
+  logPath: string;
+  /** The attempt that just ran and failed. */
+  attempt: number;
+  /** `lanes.json`'s `attempts`; guard 5 caps on the same number, so both must read one source. */
+  maxAttempts: number;
+  /** The soft-list files the scope check admitted before a later step failed — see `BlockDetails`. */
+  humanReviewFiles?: readonly string[];
+  /** The refused paths the failed attempt left behind, when nothing classified them earlier. */
+  forbiddenFiles?: readonly string[];
+}
+
+function buildBlockDetails(input: BuildBlockDetailsInput): BlockDetails {
+  const terminal = input.attempt >= input.maxAttempts;
+  return {
+    reason: input.reason,
+    question: input.question,
+    branch: input.branch,
+    compareUrl: input.compareUrl,
+    logPath: input.logPath,
+    whatToDo: terminal ? whatToDoTerminal(input.maxAttempts) : WHAT_TO_DO_RETRY,
+    attempt: input.attempt + 1,
+    terminal,
+    humanReviewFiles: input.humanReviewFiles ?? [],
+    forbiddenFiles: input.forbiddenFiles ?? [],
+  };
+}
+
+// ── The branch-already-merged guard (T-8 point 4) ─────────────────────────────
+
+const BRANCH_ALREADY_MERGED_REASON = 'branch-already-merged';
+
+const branchAlreadyMergedQuestion = (branch: string): string =>
+  `La PR de ${branch} ya consta como mergeada. El cierre no empuja más commits a esa rama: nunca ` +
+  'llegarían al padre y se perderían en silencio (medido en T-6.3, dos commits tardíos). Revisa a ' +
+  'mano si el trabajo de este intento sigue haciendo falta — puede que ya esté cubierto por la PR ' +
+  'mergeada, o que haga falta una tarea nueva a partir de ahí.';
+
+export interface CheckBranchNotMergedInput {
+  /** The branch a push is about to target. */
+  branch: string;
+  /**
+   * The SAME `isPrMerged(branch): boolean` seam `maintenance.ts`'s `Gh` collaborator already asks
+   * (`dispatch.ts`'s `realGh`) — reused rather than duplicated, per T-8 point 4's own wording.
+   */
+  isPrMerged: (branch: string) => boolean;
+  logPath: string;
+  /** The attempt that is ABOUT to push (and that discovers the branch already merged, if it has). */
+  attempt: number;
+  /** `lanes.json`'s `attempts`; defaults to the shipped cap when the caller has no config. */
+  maxAttempts?: number;
+}
+
+/**
+ * T-8 point 4: the close never pushes to a branch whose PR already shows as merged — measured
+ * incident, two late commits of T-6.3 were pushed to a branch whose PR was already merged and
+ * never reached the parent, lost silently. A caller runs this BEFORE any push (both the WIP
+ * auto-save and the green path's own commit-and-push are pushes) and gets back either:
+ *
+ *   - `null` — the branch is not merged; proceed with `planClose` exactly as before this guard
+ *     existed;
+ *   - a ready `ClosePlan` — `[{ kind: 'block-keep-slot', details }]`, ONLY. No `save-work` at all:
+ *     pushing a WIP commit here is precisely the mistake this guards against, so the save-before-
+ *     release ordering (design.md decision (k)) does not apply — there is nothing safe to save by
+ *     pushing. No `release-slot` either: the unpublished work stays the only copy, held in the slot
+ *     for a person to inspect and rescue by hand, the same as a push that exhausted every retry.
+ *
+ * The returned plan runs through the ordinary `executeClose` like any other — `block-keep-slot`
+ * reached directly (with no `save-work` ahead of it) calls `runners.blockKeepSlot` exactly as the
+ * `divert`-produced one does.
+ */
+export function checkBranchNotMerged(input: CheckBranchNotMergedInput): ClosePlan | null {
+  if (!input.isPrMerged(input.branch)) {
+    return null;
+  }
+  const details = buildBlockDetails({
+    reason: BRANCH_ALREADY_MERGED_REASON,
+    question: branchAlreadyMergedQuestion(input.branch),
+    branch: input.branch,
+    logPath: input.logPath,
+    attempt: input.attempt,
+    maxAttempts: input.maxAttempts ?? DEFAULT_DISPATCH_LIMITS.maxAttempts,
+  });
+  return [{ kind: 'block-keep-slot', details }];
+}
+
+/** `backlog task edit --comment` refuses a body carrying a standalone `---` line outright. */
+const STANDALONE_RULE_LINE = /^[^\S\n]*-{3,}[^\S\n]*$/gm;
+const MAX_COMMENT_CHARS = 4000;
+const TRUNCATION_TAIL = '\n\n(truncado; ver review.md)';
+
+/**
+ * Makes a body the `backlog` CLI will actually accept. Two failure modes, both measured: a
+ * standalone `---` line is reserved (exit 1, no comment written at all), and an unbounded body —
+ * a reviewer verdict embeds a whole findings list — makes the comment unreadable. A rejected
+ * comment is not a cosmetic loss: the `Blocked` comment is the ONLY channel telling a person why
+ * the task stopped, so losing it turns a diagnosable failure into a silent one.
+ *
+ * `tail` defaults to pointing at `review.md` (the reviewer-verdict case this was written for); a
+ * caller truncating a DIFFERENT source of truth — `needsGuidanceQuestion` below points at
+ * `run.log`, since that is where the worker's full report actually survives — passes its own.
+ */
+export function sanitizeCommentBody(body: string, tail: string = TRUNCATION_TAIL): string {
+  const withoutRules = body.replace(STANDALONE_RULE_LINE, '___');
+  if (withoutRules.length <= MAX_COMMENT_CHARS) {
+    return withoutRules;
+  }
+  return `${withoutRules.slice(0, MAX_COMMENT_CHARS - tail.length)}${tail}`;
+}
+
+const RUN_LOG_TRUNCATION_TAIL = '\n\n(truncado; ver run.log)';
+
+/**
+ * The `Blocked` comment's `question` for a `needs-guidance` outcome: the worker's own final report
+ * (`render.ts`'s `extractResultText` — the terminal `result` event's `result` field), sanitized the
+ * same way every other question is, but capped with a tail pointing at `run.log` rather than
+ * `review.md` — `run.log` is where the FULL report (T-6's split summary and its three design
+ * decisions) survives once this truncates it, not a reviewer verdict.
+ *
+ * There is, as of this writing, no parser that extracts a structured `questions:` block (the
+ * escalation-protocol shape `catalyst-delegation/SKILL.md` documents) out of that text — so the
+ * whole report becomes the question, prose or not. `undefined` in, `undefined` out: a stream with
+ * no terminal `result` event (or one whose `result` field is empty) leaves the comment naming just
+ * the outcome, as it did before this function existed.
+ */
+export function needsGuidanceQuestion(resultText: string | undefined): string | undefined {
+  if (resultText === undefined || resultText.trim().length === 0) {
+    return undefined;
+  }
+  return sanitizeCommentBody(resultText, RUN_LOG_TRUNCATION_TAIL);
+}
+
+/**
+ * The failure path's own record, one line per kind (T-31 round 4). Two lines rather than one, because
+ * the two kinds ask a person for different things: a refused leftover has to be removed from the
+ * slot's tree before the retry restores it again, while a soft-list one has to be READ.
+ */
+const FORBIDDEN_LEFTOVERS_PREFIX =
+  '\nRutas prohibidas que el intento dejó en el slot (el reintento las restaura; revísalas a mano): ';
+const SOFT_LIST_LEFTOVERS_PREFIX =
+  '\nRutas de la lista blanda tocadas por el intento (requieren lectura humana): ';
+
+/** The tail a report truncated INSIDE the comment carries; the whole one is in the log named above. */
+const QUESTION_TRUNCATION_TAIL = '\n\n(pregunta truncada; ver el log del intento)';
+
+/**
+ * One `prefix: <capped list>` line, or nothing at all — an empty list has no line, and neither does a
+ * `room` too small to hold the prefix plus one path. `room` is what the comment has left, prefix
+ * included.
+ */
+function leftoverLine(prefix: string, files: readonly string[], room: number): string {
+  if (files.length === 0 || room - prefix.length <= 0) {
+    return '';
+  }
+  return `${prefix}${formatFileList(files, room - prefix.length)}`;
+}
+
+/** `text` cut to `budget` chars with `tail` marking the cut, or nothing when not even `tail` fits. */
+function truncateTo(text: string, budget: number, tail: string): string {
+  if (text.length <= budget) {
+    return text;
+  }
+  if (budget <= tail.length) {
+    return '';
+  }
+  return `${text.slice(0, budget - tail.length)}${tail}`;
+}
+
+/**
+ * The `Blocked` comment carries everything design.md decision (m) says a person needs to act.
+ *
+ * Composed under an explicit PRIORITY, because `sanitizeCommentBody` truncates from the END and the
+ * last line is the only actionable one — round 3 let a full file list plus a worker report push it off
+ * the comment (measured, T-31 round 4: exactly 4000 chars, no `whatToDo`). In the order things must
+ * survive:
+ *
+ *   1. the reason, the branch/compare/log pointers and `whatToDo` — dispatcher-authored and bounded
+ *      by the ids and paths they name, so they are never budgeted;
+ *   2. the two leftover lines, against the room those leave;
+ *   3. the worker's own report (`question`), against what is left after that. It is by far the
+ *      longest part, it is the only one a worker authors, and it survives in full in the `run.log`
+ *      the comment names two lines above.
+ */
+export function formatBlockComment(details: BlockDetails): string {
+  const head = details.reason;
+  const pointers =
+    `\nRama: ${details.branch}` +
+    (details.compareUrl ? `\nPR/compare: ${details.compareUrl}` : '') +
+    `\nLog: ${details.logPath}`;
+  const action = `\n${details.whatToDo}`;
+
+  let room = MAX_COMMENT_CHARS - (head.length + pointers.length + action.length);
+  const forbidden = leftoverLine(FORBIDDEN_LEFTOVERS_PREFIX, details.forbiddenFiles ?? [], room);
+  room -= forbidden.length;
+  const softList = leftoverLine(SOFT_LIST_LEFTOVERS_PREFIX, details.humanReviewFiles ?? [], room);
+  room -= softList.length;
+  const question = details.question
+    ? truncateTo(`\n${details.question}`, Math.max(0, room), QUESTION_TRUNCATION_TAIL)
+    : '';
+
+  return sanitizeCommentBody([head, question, pointers, forbidden, softList, action].join(''));
+}
+
+// ── The «Registro de ejecución» block (T-68; `catalyst-backlog/SKILL.md` §12) ────────────────
+//
+// Every task carries, once, an eight-field record of how its headless dispatch went, appended to
+// its notes at the `Done` transition. `close.ts`'s own `planClose`/`executeClose` never set `Done`
+// (this module never does) — `maintenance.ts` does, from TWO places: step 3 (a leaf task, merged PR
+// -> `Done`) and `recomputeParent` (a parent whose children are all `Done` and whose own PR merged —
+// §12 says "every task", a parent included). Both gather the raw facts (`Task.attempts`, each
+// attempt's classified stream outcome, each attempt's `review.md` verdict, the current notes text
+// scoped to the notes section for the idempotence check) and hand them here. Composing the block
+// from those facts is PURE, exactly like `planClose` above — `close.test.ts` asserts it directly,
+// with no filesystem or `backlog` CLI involved.
+//
+// §12.2 rule 3's three "empty" values are NOT interchangeable, and this is where that distinction
+// is enforced: `desconocido` marks a field this function had no real signal for; `ninguno`/`ninguna`
+// is reserved for a field it actually measured and found absent. An LM Studio or network failure is
+// real but structurally untraceable by the time this runs — `entry.ts`'s `onLocalModelMissing`
+// writes only a `Blocked` COMMENT (never a file under `.backlog/.dispatch/`), and that comment is
+// routinely overwritten by every later transition — so "Fallos de entorno" can positively detect
+// only a budget cutoff (`STREAM_OUTCOME.BUDGET`) and reads `desconocido`, never `ninguno`, when it
+// finds none: this measures ONE of three possible causes, not all three.
+//
+// `attempts === 0` means the dispatcher never launched a single attempt for this task — the root
+// `CLAUDE.md`'s Worktree Gate forces EVERY task onto a `task/T-nn` branch, supervisada (interactive)
+// sessions included, so step 3/`recomputeParent` close such a task the moment its PR merges, exactly
+// like a headless one. That absence of any attempt IS a measurement, not a headless task with zero
+// attempts: this composer records it as `Modo: supervisada`, `Intervenciones humanas: desconocido`
+// (the dispatcher has no visibility into a supervisada session's own human steps), and points
+// `Fuente` at the merged PR — the only trace left with no attempt directory to point at instead.
+//
+// The idempotence sentinel (`hasExecutionRecordBlock`, below) applies identically to a supervisada
+// task: if a person already appended their own block to its notes by hand, this composer never
+// runs at all — the caller's `readNotes`/`hasExecutionRecordBlock` check short-circuits first.
+
+export const EXECUTION_RECORD_HEADING = '## Registro de ejecución';
+
+/**
+ * A WHOLE LINE, not a substring: `notes.includes(EXECUTION_RECORD_HEADING)` also matched a report
+ * that merely MENTIONS the heading in prose ("texto ## Registro de ejecución aquí"), which is real
+ * text a worker's own notes can legitimately contain. `EXECUTION_RECORD_HEADING` carries no regex
+ * metacharacter (`#` and letters only), so it is safe to anchor directly.
+ */
+const EXECUTION_RECORD_HEADING_LINE = new RegExp(`^${EXECUTION_RECORD_HEADING}$`, 'm');
+
+/**
+ * §12.3's sentinel: `true` once `notes` already carries the heading on its OWN line — the
+ * maintenance pass's own idempotence check. `notes` must already be scoped to the notes SECTION
+ * (`task-view.ts`'s `notesRegion`) by the caller: this function has no way to tell a heading
+ * legitimately written in the notes apart from one that merely appears in the description or a
+ * comment the CLI's `--plain` view happens to also carry.
+ */
+export function hasExecutionRecordBlock(notes: string | null | undefined): boolean {
+  return typeof notes === 'string' && EXECUTION_RECORD_HEADING_LINE.test(notes);
+}
+
+const UNKNOWN_FIELD = 'desconocido';
+const POST_MERGE_FIXES_AT_CLOSE = 'ninguno conocido al cierre';
+// §12.2 rule 4: no status-transition timestamp survives anywhere today (the task front matter
+// keeps only `created_date`/`updated_date`, and Backlog.md's `onStatusChange` payload is gone the
+// instant the callback returns) — `desconocido` unconditionally, rather than an attempt directory's
+// own mtime, which shifts every time ANY file inside it is written and would silently misreport the
+// exact window it claims to measure.
+const CYCLE_TIME_UNKNOWN = UNKNOWN_FIELD;
+
+export interface ExecutionRecordInput {
+  /** The task's `lane:` label at close time — decides the "Modo" motivo. */
+  lane: Lane | undefined;
+  /** `Task.attempts` — the number of `intento-N` directories this task's dispatch record holds. */
+  attempts: number;
+  /**
+   * Each attempt's classified terminal outcome (`render.ts`'s `StreamOutcome`), attempt 1 first,
+   * `null` where the stream could not be read. Shorter than `attempts` — or entirely empty — when
+   * the caller could not read every attempt; a missing entry reads as "unknown", never as success.
+   */
+  attemptOutcomes: readonly (string | null)[];
+  /**
+   * Each attempt's `review.md` verdict (`reviewer.ts`'s `ReviewerVerdict`, parsed by
+   * `parseReviewerVerdict` — reused, never reimplemented), attempt 1 first, `null` where the
+   * attempt has no `review.md` at all. Only the local lane's close ever runs the reviewer, so this
+   * is empty (or all-`null`) for every frontier-lane task — its own worker runs whatever gates it
+   * runs, invisible to the dispatcher, and "Rondas de corrección"/"revisor" must say so honestly
+   * (`desconocido`) rather than guess from the lane label, which a quota cutoff or a crash makes
+   * wrong (a retry with no review at all is not a correction ROUND).
+   */
+  reviewVerdicts: readonly (string | null)[];
+  /** `.backlog/.dispatch/<id>/intento-<N>` of the LAST attempt, or `null` with no attempt at all. */
+  sourcePath: string | null;
+  /**
+   * Only consulted when `attempts === 0` (`sourceLine`'s own JSDoc) — Fuente's PR-based fallback
+   * for a task the dispatcher never launched. Three states, matched to §12.2 rule 3's own three
+   * "empty" values:
+   *  - a `number`: the PR is known — `Fuente` reads `PR #<n>`.
+   *  - `'read-failed'`: the caller already confirmed a PR exists (step 3/`recomputeParent` only
+   *    ever reach this with a CONFIRMED merged PR) but could not read its number — `Fuente` reads
+   *    `desconocido`, never `sin evidencia`: the PR is real, only the read failed.
+   *  - `null` (default): no PR is known to exist at all — `Fuente` reads `sin evidencia`, rule 3's
+   *    OWN definition ("no attempt directory AND no PR").
+   */
+  prNumber?: number | 'read-failed' | null;
+}
+
+/**
+ * "Rondas de corrección" + its "revisor", from MEASURED `review.md` data only (§12.2 rule 3) — never
+ * from the retry count (a quota cutoff or a crash retries with no review at all) or from the lane
+ * label (the frontier lane's close never runs a reviewer the dispatcher can see). `desconocido` for
+ * BOTH halves when no attempt has a `review.md` at all — there is nothing to count.
+ */
+function correctionRounds(verdicts: readonly (string | null)[]): { rounds: string; revisor: string } {
+  if (!verdicts.some((verdict) => verdict !== null)) {
+    return { rounds: UNKNOWN_FIELD, revisor: UNKNOWN_FIELD };
+  }
+  const failCount = verdicts.filter((verdict) => verdict === REVIEWER_VERDICT.FAIL).length;
+  return { rounds: String(failCount), revisor: 'code-review' };
+}
+
+/**
+ * "Resultado del intento 1": the first attempt's OWN outcome when it is known — carrying its real
+ * cause into the record (AC1's "Blocked cause if there was one") — degrading to the template's
+ * cause-free `reintento` when only the retry COUNT is known (a later, close-level failure that
+ * never touched the stream, e.g. a scope violation), and to `desconocido` with no attempt at all.
+ */
+function firstAttemptResult(attempts: number, firstOutcome: string | null): string {
+  if (attempts <= 0) {
+    return UNKNOWN_FIELD;
+  }
+  if (firstOutcome !== null && firstOutcome !== STREAM_OUTCOME.COMPLETED) {
+    return `Blocked (${firstOutcome})`;
+  }
+  return attempts === 1 ? 'Done' : 'reintento';
+}
+
+/** See this section's own header comment for why absence here is `desconocido`, never `ninguno`. */
+function environmentFailures(outcomes: readonly (string | null)[]): string {
+  return outcomes.includes(STREAM_OUTCOME.BUDGET) ? 'cuota' : UNKNOWN_FIELD;
+}
+
+/**
+ * `attempts === 0` is read as "the dispatcher never launched this task": the root `CLAUDE.md`'s
+ * Worktree Gate puts supervisada (interactive) sessions on `task/T-nn` branches too, precisely so
+ * the reconciler closes them the same way. Its motivo is recorded nowhere the dispatcher can read,
+ * hence `desconocido`.
+ *
+ * Not an exact equivalence: `entry.ts` sets `In Progress` and writes the lock BEFORE
+ * `beginAttempt` creates `intento-1`, so a crash in that window leaves a dispatched task at zero
+ * attempts (documented beside `countAttempts` in `attempt.ts`). Step 1's PID-based dead-lock sweep
+ * blocks such a task before step 3 can close it, which is what keeps this reading safe — not the
+ * count itself.
+ */
+function neverDispatched(attempts: number): boolean {
+  return attempts === 0;
+}
+
+/** "Modo": `supervisada` once `neverDispatched`, `headless — lane:<lane>` otherwise (unchanged). */
+function modeLine(attempts: number, lane: Lane | undefined): string {
+  if (neverDispatched(attempts)) {
+    return `supervisada — ${UNKNOWN_FIELD}`;
+  }
+  return lane ? `headless — lane:${lane}` : `headless — ${UNKNOWN_FIELD}`;
+}
+
+/**
+ * "Intervenciones humanas": `attempts - 1` retries, each measured through a human-released `Blocked`
+ * (§10) — unchanged for a dispatched task. `desconocido` once `neverDispatched`: the dispatcher has
+ * no visibility at all into a supervisada session's own human interventions (§12.2 rule 3 — this is
+ * "no data", never a measured "ninguna" nobody actually measured).
+ */
+function humanInterventionsLine(attempts: number): string {
+  if (neverDispatched(attempts)) {
+    return `${UNKNOWN_FIELD} — tipo: ${UNKNOWN_FIELD}`;
+  }
+  const rounds = Math.max(0, attempts - 1);
+  return `${rounds} — tipo: ${rounds > 0 ? 'respuesta a Blocked' : 'ninguna'}`;
+}
+
+/**
+ * "Fuente": the last attempt directory for a dispatched task (unchanged). For a `neverDispatched`
+ * task the attempt directory never existed, so the PR is the only trace left — see
+ * `ExecutionRecordInput.prNumber`'s own JSDoc for the three states this reads.
+ */
+function sourceLine(
+  attempts: number,
+  sourcePath: string | null,
+  prNumber: number | 'read-failed' | null | undefined,
+): string {
+  if (!neverDispatched(attempts)) {
+    return sourcePath ?? 'sin evidencia';
+  }
+  if (typeof prNumber === 'number') {
+    return `PR #${prNumber}`;
+  }
+  if (prNumber === 'read-failed') {
+    return UNKNOWN_FIELD;
+  }
+  return 'sin evidencia';
+}
+
+/** Composes the eight-field block (§12.1's template), fixed order, one field per line (§12.2 rule 2). */
+export function buildExecutionRecordBlock(input: ExecutionRecordInput): string {
+  const { rounds, revisor } = correctionRounds(input.reviewVerdicts);
+  return [
+    EXECUTION_RECORD_HEADING,
+    '',
+    `- **Modo:** ${modeLine(input.attempts, input.lane)}`,
+    `- **Resultado del intento 1:** ${firstAttemptResult(input.attempts, input.attemptOutcomes[0] ?? null)}`,
+    `- **Rondas de corrección:** ${rounds} — revisor: ${revisor}`,
+    `- **Arreglos posteriores al merge:** ${POST_MERGE_FIXES_AT_CLOSE}`,
+    `- **Intervenciones humanas:** ${humanInterventionsLine(input.attempts)}`,
+    `- **Fallos de entorno:** ${environmentFailures(input.attemptOutcomes)}`,
+    `- **Tiempo de ciclo:** ${CYCLE_TIME_UNKNOWN}`,
+    `- **Fuente:** ${sourceLine(input.attempts, input.sourcePath, input.prNumber)}`,
+  ].join('\n');
+}
+
+export interface PlanCloseSuccessInput {
+  outcome: 'success';
+  lane: Lane;
+}
+
+export interface PlanCloseFailureInput {
+  outcome: 'failure';
+  lane: Lane;
+  reason: string;
+  question?: string;
+  branch: string;
+  compareUrl?: string;
+  logPath: string;
+  /** The attempt that just ran and failed. */
+  attempt: number;
+  /** Already known: `saveWork`'s WIP commit-and-push already ran by the time this is called. */
+  pushSucceeded: boolean;
+  /** `lanes.json`'s `attempts`; defaults to the shipped cap when the caller has no config. */
+  maxAttempts?: number;
+}
+
+export type PlanCloseInput = PlanCloseSuccessInput | PlanCloseFailureInput;
+
+/**
+ * Pure planner. Success returns the happy-path order (spec: "Dispatch close ordering") — starting
+ * at `board-check`, since everything after it reads the board the worker could have edited —
+ * `reviewer` inserted only for the local lane, `ac-check` always present, matching the design.md
+ * close diagram (`SR -- accepted --> AC` for local, `RV -- frontier --> AC` directly). Failure
+ * always starts at `save-work` (spec: "Failure path preserves work before blocking"): a successful
+ * push is followed by `block` then `release-slot` (save always precedes release); a failed push
+ * stops at `block-keep-slot` with no release step at all, so the reconciler retries the push
+ * instead of reusing a worktree holding the only copy (design.md decision (k)).
+ */
+export function planClose(input: PlanCloseInput): ClosePlan {
+  if (input.outcome === 'success') {
+    // `board-check` FIRST: every step after it trusts what the board says — the scope check reads
+    // the declared files, the triad the test command, the pre-PR gate and the reviewer the
+    // acceptance criteria. Verifying the board last would mean verifying it after acting on it.
+    //
+    // `mirror-regen` sits between the triad and the reviewer, and BOTH edges are load-bearing:
+    //   - AFTER `format-lint-test`, because that step runs `prettier --write` over the attempt's own
+    //     source files. A mirror regenerated before it would be a byte-copy of the UNFORMATTED
+    //     source and would be stale again the moment the triad rewrote it — the exact drift this
+    //     step exists to close.
+    //   - BEFORE `reviewer` and `ac-check`, because the reviewer judges the diff that will actually
+    //     be pushed. Regenerating afterwards would put thousands of mirror lines in the PR that no
+    //     reviewer ever saw, and would leave the gate reading a tree the PR does not contain.
+    //   - AFTER `scope-check`, which is what keeps `packages/cli/` forbidden for the WORKER: the
+    //     scope verdict is taken over the pre-regen file set, so a hand-written mirror edit is still
+    //     a violation, and this dispatcher-owned output arrives after the judging is done.
+    const steps: ClosePlan = [
+      { kind: 'board-check' },
+      { kind: 'scope-check' },
+      { kind: 'format-lint-test' },
+      { kind: 'mirror-regen' },
+    ];
+    if (input.lane === LANE.LOCAL) {
+      steps.push({ kind: 'reviewer' });
+    }
+    steps.push(
+      { kind: 'ac-check' },
+      { kind: 'open-pr' },
+      { kind: 'release-slot' },
+      { kind: 'recompute-parent' },
+      { kind: 'drain' },
+    );
+    return steps;
+  }
+
+  const details = buildBlockDetails({
+    ...input,
+    maxAttempts: input.maxAttempts ?? DEFAULT_DISPATCH_LIMITS.maxAttempts,
+  });
+  if (!input.pushSucceeded) {
+    return [{ kind: 'save-work' }, { kind: 'block-keep-slot', details }];
+  }
+  return [{ kind: 'save-work' }, { kind: 'block', details }, { kind: 'release-slot' }];
+}
+
+// ── executeClose: runner-driven walk, injectable so tests never touch git/gh/pnpm ─────
+
+export interface MechanicalStepResult {
+  ok: boolean;
+  reason?: string;
+  question?: string;
+}
+
+export interface OpenPrResult extends MechanicalStepResult {
+  compareUrl?: string;
+}
+
+export interface SaveWorkResult {
+  pushSucceeded: boolean;
+}
+
+export interface CloseRunners {
+  boardCheck: () => MechanicalStepResult;
+  /**
+   * Narrower than the other mechanical runners on purpose: the caller reads `humanReviewFiles` off
+   * this result to mark the pull request (T-31), and typing it as a bare `MechanicalStepResult`
+   * erased exactly the field the whole mark depends on. `executeClose` only ever reads the
+   * `MechanicalStepResult` half, which `ScopeCheckStepResult` extends.
+   */
+  scopeCheck: () => ScopeCheckStepResult;
+  formatLintTest: () => MechanicalStepResult;
+  mirrorRegen: () => MechanicalStepResult;
+  reviewer: () => MechanicalStepResult;
+  acCheck: () => MechanicalStepResult;
+  openPr: () => OpenPrResult;
+  releaseSlot: () => void;
+  recomputeParent: () => void;
+  drain: () => void;
+  saveWork: () => SaveWorkResult;
+  /**
+   * What the slot's CURRENT tree holds, classified into refused and soft-list paths — asked for on
+   * every divert that no `scope-check` preceded (T-31 rounds 3 and 4): a session-level failure, whose
+   * plan starts at `save-work`, and a `board-check` failure, the one mechanical step that diverts
+   * before the scope check. Informational, never a verdict: it answers "what did this attempt leave
+   * behind", not "may it". Its failure is not the close's failure, so a throw is caught and recorded
+   * as "none found".
+   */
+  leftoverFiles: () => PathClassification;
+  block: (details: BlockDetails) => void;
+  blockKeepSlot: (details: BlockDetails) => void;
+}
+
+export interface ExecuteCloseContext {
+  lane: Lane;
+  /** The attempt currently running (1-based). */
+  attempt: number;
+  branch: string;
+  logPath: string;
+  /** `lanes.json`'s `attempts`; defaults to the shipped cap when the caller has no config. */
+  maxAttempts?: number;
+}
+
+/** Reads the failure fields already baked into a `block`/`block-keep-slot` step's details. */
+function peekFailureContext(
+  step: CloseStep | undefined,
+): { reason: string; question?: string; compareUrl?: string } | null {
+  if (step && (step.kind === 'block' || step.kind === 'block-keep-slot')) {
+    return {
+      reason: step.details.reason,
+      question: step.details.question,
+      compareUrl: step.details.compareUrl,
+    };
+  }
+  return null;
+}
+
+/**
+ * Walks `plan` in order, invoking the matching runner per step. A mechanical step's failure — or
+ * a plan that starts directly at `save-work` (a session-level failure with no mechanical step
+ * attempted) — diverts into the save-before-release failure sequence: `saveWork` runs for real,
+ * then `block` (push ok, followed by `releaseSlot`) or `blockKeepSlot` (push failed, no release)
+ * runs with freshly computed `BlockDetails`, so the recorded call order always has `saveWork`
+ * before any release, never after.
+ */
+export function executeClose(
+  plan: ClosePlan,
+  runners: CloseRunners,
+  context: ExecuteCloseContext,
+): string[] {
+  const executed: string[] = [];
+  // The leftover files the `Blocked` comment names (T-31 rounds 2 and 4). That path opens no pull
+  // request to mark, so the comment is the only channel a person ever sees them through. Two sources,
+  // never both: the scope check's own verdict when it ran, and the `leftoverFiles` probe when the
+  // divert happened before it (a session-level failure, or `board-check`).
+  let humanReviewFiles: readonly string[] = [];
+  let forbiddenFiles: readonly string[] = [];
+  // Whether anything has classified this attempt's tree yet. Keyed on the CLASSIFICATION rather than
+  // on the plan shape, so no future step ordering can reintroduce a divert that records nothing.
+  let classified = false;
+
+  /**
+   * Runs one mechanical runner, turning a THROW into an ordinary failure result. A `git`, `gh` or
+   * `pnpm` shell-out that blows up (binary missing, ENOENT on the slot, a JSON parse of empty
+   * output) would otherwise escape `executeClose` entirely and skip the save-before-release path —
+   * the one thing design.md decision (k) forbids. The slot stays held and the work stays unsaved.
+   */
+  const attempt = (label: string, run: () => MechanicalStepResult): MechanicalStepResult => {
+    try {
+      return run();
+    } catch (error) {
+      return { ok: false, reason: `${label}-crashed`, question: String(error) };
+    }
+  };
+
+  const divert = (
+    reason: string,
+    question: string | undefined,
+    compareUrl: string | undefined,
+  ): void => {
+    // Asked BEFORE `saveWork`, whose WIP commit is what moves the working tree — and only when
+    // nothing has classified the tree yet: re-reading git after a step failed would report a
+    // DIFFERENT file set (`mirrorRegen` may have written the mirror by then), the recomputation
+    // design.md decision 8 forbids for the PR mark.
+    if (!classified) {
+      classified = true;
+      try {
+        ({ humanReviewFiles, forbiddenFiles } = runners.leftoverFiles());
+      } catch (error) {
+        console.error('close.ts: leftoverFiles threw; blocking with no leftover record:', error);
+      }
+    }
+    // A throwing `saveWork` is treated as a FAILED push: the slot is kept for the recovery retry
+    // rather than released over work that may never have been committed.
+    let pushSucceeded: boolean;
+    try {
+      ({ pushSucceeded } = runners.saveWork());
+    } catch (error) {
+      console.error('close.ts: saveWork threw; keeping the slot for recovery:', error);
+      pushSucceeded = false;
+    }
+    executed.push('saveWork');
+
+    const details = buildBlockDetails({
+      reason,
+      question,
+      compareUrl,
+      branch: context.branch,
+      logPath: context.logPath,
+      attempt: context.attempt,
+      maxAttempts: context.maxAttempts ?? DEFAULT_DISPATCH_LIMITS.maxAttempts,
+      humanReviewFiles,
+      forbiddenFiles,
+    });
+
+    if (pushSucceeded) {
+      runners.block(details);
+      executed.push('block');
+      runners.releaseSlot();
+      executed.push('releaseSlot');
+    } else {
+      runners.blockKeepSlot(details);
+      executed.push('blockKeepSlot');
+    }
+  };
+
+  for (let index = 0; index < plan.length; index += 1) {
+    const step = plan[index];
+    switch (step.kind) {
+      case 'board-check': {
+        const result = attempt('board-check', runners.boardCheck);
+        executed.push('boardCheck');
+        if (!result.ok) {
+          divert(result.reason ?? 'board-check-failed', result.question, undefined);
+          return executed;
+        }
+        break;
+      }
+      case 'scope-check': {
+        // Typed against the runner directly, not through `attempt`'s `MechanicalStepResult`: the
+        // soft-list field is exactly what a widened type erases. A THROW is still an ordinary
+        // failure, with nothing admitted.
+        let result: ScopeCheckStepResult;
+        try {
+          result = runners.scopeCheck();
+        } catch (error) {
+          result = {
+            ok: false,
+            reason: 'scope-check-crashed',
+            question: String(error),
+            humanReviewFiles: [],
+          };
+        }
+        executed.push('scopeCheck');
+        if (!result.ok) {
+          // The verdict already names its violating files in `question`, so this divert has its
+          // record: nothing left to probe for.
+          classified = true;
+          divert(result.reason ?? 'scope-check-failed', result.question, undefined);
+          return executed;
+        }
+        humanReviewFiles = result.humanReviewFiles;
+        classified = true;
+        break;
+      }
+      case 'format-lint-test': {
+        const result = attempt('format-lint-test', runners.formatLintTest);
+        executed.push('formatLintTest');
+        if (!result.ok) {
+          divert(result.reason ?? 'format-lint-test-failed', result.question, undefined);
+          return executed;
+        }
+        break;
+      }
+      case 'mirror-regen': {
+        const result = attempt('mirror-regen', runners.mirrorRegen);
+        executed.push('mirrorRegen');
+        if (!result.ok) {
+          divert(result.reason ?? 'mirror-regen-failed', result.question, undefined);
+          return executed;
+        }
+        break;
+      }
+      case 'reviewer': {
+        const result = attempt('reviewer', runners.reviewer);
+        executed.push('reviewer');
+        if (!result.ok) {
+          divert(result.reason ?? 'reviewer-rejected', result.question, undefined);
+          return executed;
+        }
+        break;
+      }
+      case 'ac-check': {
+        const result = attempt('ac-check', runners.acCheck);
+        executed.push('acCheck');
+        if (!result.ok) {
+          divert(result.reason ?? 'ac-check-failed', result.question, undefined);
+          return executed;
+        }
+        break;
+      }
+      case 'open-pr': {
+        const result = attempt('open-pr', runners.openPr) as OpenPrResult;
+        executed.push('openPr');
+        if (!result.ok) {
+          divert(result.reason ?? 'open-pr-failed', result.question, result.compareUrl);
+          return executed;
+        }
+        break;
+      }
+      case 'release-slot':
+        runners.releaseSlot();
+        executed.push('releaseSlot');
+        break;
+      case 'recompute-parent':
+        runners.recomputeParent();
+        executed.push('recomputeParent');
+        break;
+      case 'drain':
+        runners.drain();
+        executed.push('drain');
+        break;
+      case 'save-work': {
+        // The plan already starts here: a session-level failure (needs-guidance, timeout, budget,
+        // crash) with no mechanical step attempted. The failure's reason/question travel in the
+        // block/block-keep-slot step the caller's planClose call already built right after this
+        // one — peek it, then let `divert` recompute authoritative details from the REAL push
+        // result (which may differ from what the caller assumed when it built this plan).
+        //
+        // No `scope-check` step ran on this plan — `needs-guidance`, a timeout, an exhausted budget
+        // and a crash are the most common non-green outcomes there are — so `divert` is the one that
+        // probes the slot for the record. The tree they leave behind is pushed to `task/<id>` by
+        // `saveWork` and restored into the slot by the retry, so "a failed close names the leftover
+        // files in the `Blocked` comment instead" has to hold here or it holds almost nowhere
+        // (design.md decision 8, its Risks entry, and the skill all promise it unconditionally).
+        const failureContext = peekFailureContext(plan[index + 1]);
+        divert(
+          failureContext?.reason ?? 'session-failed',
+          failureContext?.question,
+          failureContext?.compareUrl,
+        );
+        return executed;
+      }
+      case 'block':
+        // `planClose` never produces this reached directly — `divert` always precedes it with
+        // `save-work` and handles it itself. `checkBranchNotMerged` (T-8 point 4) is the one
+        // producer that DOES start a plan directly at a block step (`block-keep-slot`, never this
+        // one, since it never pushes); this case exists so the executor stays correct for either
+        // shape rather than silently doing nothing for a plan it does not recognise.
+        runners.block(step.details);
+        executed.push('block');
+        break;
+      case 'block-keep-slot':
+        runners.blockKeepSlot(step.details);
+        executed.push('blockKeepSlot');
+        break;
+    }
+  }
+  return executed;
+}