task-pipeline-skill 1.102.0 → 1.102.3

package/CHANGELOG.md

@@ -1,3 +1,51 @@
+## v1.102.3: stamp rows keep their table's shape, one rotation line per quarter, apply_patch gated
+
+Guards: 531 → **531**; property checks 15 → **15**. No negative was added: the new checks are
+cases in `test/audit_regressions/diet_retro_budget.py` and `test/release_gate_test.py`.
+
+- **A shortened stamp row keeps its own table** (hub board row B-258): `retro_budget.py migrate`
+  assumed every stamp table was `Date | Topic | Commit | Verdict`. On sheleg-design-skill's
+  `Date | Commit | Task | Diverged?` it cut the Commit cell (`working tree` to `working…`) and kept
+  the long Task, so eight rows stayed over 300 characters; on super-ux's three columns it added a
+  fourth cell and broke the table. The row now keeps its header's column count, leaves date,
+  commit and version cells whole, caps the long prose cells at one common length and ends the
+  last cell with the pointer. An escaped `\|` stays inside its cell, and a row that already
+  carries a pointer is not archived again. Five new cases in
+  `test/audit_regressions/diet_retro_budget.py`, red on 1.102.2.
+- **One `Rotated out:` line per archive quarter, also on floors written before 1.101.0** (hub
+  board row B-246): 1.101.0 merged the earlier lines only when a new rotation went into the same
+  quarter. A floor that already held several lines for one quarter, or for a quarter this run
+  does not rotate into, now has them merged on the next `migrate --write`, each block appended to
+  its own quarter's archive; a line whose block no longer hashes still stays. Two new cases: three
+  rotations in a row leave one line, and a planted five-line floor over two quarters leaves two.
+- **The build gate acts in Codex** (hub board row B-211, task-pipeline part; CODEX-4 in the hub's
+  2026-10-16 compatibility report): Codex edits through `apply_patch` with the patch text in
+  `tool_input.command`, so `hooks/build-gate.sh` read no `file_path` and stayed silent. Its
+  matcher and memory-nudge's now name `apply_patch`, and the gate asks when any `*** Add File:`,
+  `*** Update File:`, `*** Delete File:` or `*** Move to:` path is gated. Codex has no
+  `PostToolUseFailure`, which `references/hooks.md` now states for `gate-observer.sh`. Four new
+  checks in `test/release_gate_test.py` (71).
+- **Three more trigger phrases** (hub board row B-84): SKILL.md's `## Triggers` advertises
+  'write tests'/«напиши тесты», 'cut a release'/«зарелизь»/«выпусти релиз» and 'remove dead
+  code'/«удали мёртвый код», so the hub's route table may carry them; the description is
+  unchanged. Three should-trigger cases in `evals/task-pipeline.evals.json` (TRIG-13 to 15).
+
+## v1.102.2: v1.102.1 republished
+
+- **v1.102.1 republished.** Its tag was pushed and the release run (40241842429) refused it before
+  publishing: `docs/evidence/retro.md` → *Releases that carry no stamp* did not name v1.102.1. That
+  section now names v1.102.1 and v1.102.2, and v1.102.2 ships v1.102.1's content (the three
+  descriptions within a 300-character budget). `v1.102.1` stays as an unpublished tag.
+
+## v1.102.1: descriptions within a 300-character budget
+
+- **Descriptions within a 300-character budget** (hub board row B-255 (a)): Claude Code lists every
+  skill's description in one ~30,000-character budget, and on the operator's machine the listing
+  stood at 51,178. Measured the hub's way (whitespace collapsed, front matter only): task-pipeline
+  388 to 294, project-audit 401 to 295, evidence-docs 397 to 283. The full trigger lists stay in each
+  `## Triggers`; B-001 and the README conformance sentence carry the new figure. Release impact card:
+  `docs/evidence/specs/2026-10-25-v11021-release-impact.md`.
+
 ## v1.102.0 (2026-10-24)
 
 Guards: 530 → **531**; property checks 15 → **15**. Negative 550 is new; the release impact

package/README.md

@@ -643,7 +643,7 @@ must say so.
 ### Held to Anthropic's own Skill authoring guidance
 
 Audited against the four Agent Skills pages. Most of it already held — `name`
-13/64 chars, `description` 386/1024 chars, `SKILL.md` 207/500 lines, all 55 references
+13/64 chars, `description` 292/1024 chars, `SKILL.md` 211/500 lines, all 55 references
 reachable from `SKILL.md` through explicit reference routes, and the bundle far under the 30 MB ceiling. What
 did not, now does:
 

package/SKILL-CARD.md

@@ -12,7 +12,7 @@ harmless.
 |---|---|
 | **Purpose** | Runs a substantial task through ten gated delivery stages — intake grill, docs study, brainstorm, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs+registers, acceptance — refusing to advance until each gate passes |
 | **Owner** | ssheleg ([github.com/ssheleg/task-pipeline](https://github.com/ssheleg/task-pipeline)) |
-| **Version** | 1.102.0 |
+| **Version** | 1.102.3 |
 | **Surface** | Claude Code (filesystem skill + plugin) and the vercel `skills` CLI. **Not** uploaded to the Skills API; custom Skills do not sync across surfaces |
 | **Dependencies** | None required. Optional: `context7` (MCP), `figma` (MCP), super-ux, agent-sync, graphify, obsidian-wiki, and **one of two browser channels** — `playwright` (CLI or MCP) or `chrome-devtools` (MCP); either satisfies the browser step and neither is required. The engine is WebKit (Safari) first; `chrome-devtools` is Chrome-only, a stated exception. Every stage's doctrine ships in-repo; user-facing stage 3 requires a valid scenario artifact; super-ux is preferred, with equivalent-provider and inline-fallback paths under the provider contract |
 | **Evaluation status** | Suite authored, 5 categories. One recorded run, **self-observed by the author**; **zero blind runs on zero of three models** — the split, and the numbers, live in [`evals/RESULTS.md`](evals/RESULTS.md) and are computed by `evals/run.py` |

package/evals/task-pipeline.evals.json

@@ -528,6 +528,45 @@
         "Does not retry the search with other filters or a project id to force lessons out of it, and does not record the old engine as an outage"
       ],
       "why": "Profile B with an old engine: turn records crowd lessons out of an unfiltered match window, so a hit there is not evidence about lessons. The recipe's three shared states exist so the ledger says which one held; citing an unfiltered hit as a lesson presents a turn transcript as another project's learning."
+    },
+    {
+      "id": "TRIG-13",
+      "category": "should_trigger",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "напиши тесты для модуля биллинга, их там нет",
+      "expected_behavior": [
+        "Invokes the task-pipeline skill rather than editing inline",
+        "Runs the stage-0 knowledge harvest before the first interview question"
+      ],
+      "why": "'write tests' / «напиши тесты» is a repository change advertised in ## Triggers since 1.102.3 (hub B-84)."
+    },
+    {
+      "id": "TRIG-14",
+      "category": "should_trigger",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "зарелизь то, что лежит в main, и выпусти релиз 2.4.0",
+      "expected_behavior": [
+        "Invokes the task-pipeline skill rather than editing inline",
+        "Runs the stage-0 knowledge harvest before the first interview question"
+      ],
+      "why": "'cut a release' / «зарелизь» / «выпусти релиз» is an outward act the stage 7 gate owns; advertised since 1.102.3 (hub B-84)."
+    },
+    {
+      "id": "TRIG-15",
+      "category": "should_trigger",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "удали мёртвый код в пакете payments",
+      "expected_behavior": [
+        "Invokes the task-pipeline skill rather than editing inline",
+        "Runs the stage-0 knowledge harvest before the first interview question"
+      ],
+      "why": "'remove dead code' / «удали мёртвый код» changes the repository; advertised since 1.102.3 (hub B-84)."
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.102.0",
+  "version": "1.102.3",
   "description": "Full-cycle delivery pipeline for coding agents: a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine ships inside the skill — no companion plugin required. This package is the installer CLI.",
   "bin": {
     "task-pipeline": "bin/task-pipeline.js"

package/plugins/task-pipeline/.claude-plugin/plugin.json

@@ -3,7 +3,7 @@
   "name": "task-pipeline",
   "displayName": "Task Pipeline",
   "description": "Runs a substantial task through a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine is built into the skill — no companion plugin required — with typed auto/judgment/manual gates, a frozen requirement spine that closes with evidence, a work board and a verification ledger that outlive a run, an exposure line naming what shipped unconfirmed, a progress rail computed from the project's own config, a proportional short path for small changes, a loop guard whose ceilings stop and record a blocker, and stage-3 tracks for what a product does, how it sounds and how it looks. Two modes need no task: `checkup` (what is unverified) and `setup` (audit existing docs); a third, `waves`, takes the whole board and closes it in waves that each finish in one pass. Retro insights can publish upstream as issues, opt-in and redacted.",
-  "version": "1.102.0",
+  "version": "1.102.3",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

package/plugins/task-pipeline/hooks/build-gate.sh

@@ -38,15 +38,34 @@ try:
 except Exception:
     raise SystemExit(0)
 
-ti = data.get("tool_input") or {}
-path = ti.get("file_path") or ti.get("notebook_path") or ""
-if not path:
+ti = data.get("tool_input") if isinstance(data, dict) else None
+if not isinstance(ti, dict):
     raise SystemExit(0)
+if data.get("tool_name") == "apply_patch":
+    # Codex edits through apply_patch, the patch text in `command` (hub B-211, CODEX-4):
+    # every file it adds, updates, deletes or moves to is a path this gate decides.
+    txt = ti.get("command") or ti.get("input") or ""
+    if not isinstance(txt, str):
+        raise SystemExit(0)
+    paths = [a or b for a, b in re.findall(
+        r"^\*\*\* (?:Add|Update|Delete) File: (.+)$|^\*\*\* Move to: (.+)$", txt, re.M)]
+else:
+    paths = [ti.get("file_path") or ti.get("notebook_path") or ""]
 
-rel = os.path.relpath(path, project) if os.path.isabs(path) else path
-rel = rel.replace(os.sep, "/")
-# The run writes these; gating them would fire on the work stages 0-4 are for.
-if rel.startswith("..") or re.match(r"^(docs/|\.task-pipeline/|\.claude/|CHANGELOG\.md|README\.md)", rel):
+
+def gated(path):
+    if not isinstance(path, str) or not path.strip():
+        return False
+    path = path.strip()
+    rel = os.path.relpath(path, project) if os.path.isabs(path) else path
+    rel = rel.replace(os.sep, "/")
+    # The run writes these; gating them would fire on the work stages 0-4 are for.
+    return not (rel.startswith("..") or re.match(
+        r"^(docs/|\.task-pipeline/|\.claude/|CHANGELOG\.md|README\.md)", rel))
+
+
+# One gated path is enough: a patch that also touches docs/ still edits the product.
+if not any(gated(p) for p in paths):
     raise SystemExit(0)
 
 try:

package/plugins/task-pipeline/hooks/hooks.json

@@ -15,7 +15,7 @@
         ]
       },
       {
-        "matcher": "Edit|Write|MultiEdit|NotebookEdit",
+        "matcher": "Edit|Write|MultiEdit|NotebookEdit|apply_patch",
         "hooks": [
           {
             "type": "command",
@@ -39,7 +39,7 @@
         ]
       },
       {
-        "matcher": "Bash|Edit|Write|MultiEdit",
+        "matcher": "Bash|Edit|Write|MultiEdit|apply_patch",
         "hooks": [
           {
             "type": "command",

package/plugins/task-pipeline/skills/evidence-docs/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: evidence-docs
-description: "Use when writing or reviewing anything read as true: a decision record, ADR, README, acceptance report, runbook, changelog, audit finding, or a claim that something was verified. Applies the ten canons of evidence-backed documentation and routes to the doctrine enforcing each; also a documentation gate or decision register. Not for: drafts, chat answers, commit messages; 'без доков' opts out."
+description: "Use when writing or reviewing anything read as true: a decision record, ADR, README, acceptance report, runbook, changelog, audit finding, a claim of verification. Applies the ten canons of evidence-backed docs. Not for: drafts, chat answers, commit messages; 'без доков' opts out."
 license: MIT
 compatibility: "Doctrine runs on any agent. No bundled scripts — nothing to install and nothing to degrade."
 ---

package/plugins/task-pipeline/skills/evidence-docs/references/hooks.md

@@ -218,11 +218,20 @@ Since v1.50.0 the plugin carries hooks of its own. `hooks/release-gate.sh`
 (`PreToolUse` on `Bash`) refuses an **outward, irreversible act** — `git tag`, a
 tag push, `gh release create`, `npm publish` — while the run says the suite has not
 passed. `hooks/gate-observer.sh` (`PostToolUse` and `PostToolUseFailure`) records
-what the declared gate command actually did. `hooks/memory-nudge.sh` (`PostToolUse` on `Bash|Edit|Write|MultiEdit`) reminds,
+what the declared gate command actually did. `hooks/memory-nudge.sh` (`PostToolUse` on `Bash|Edit|Write|MultiEdit|apply_patch`) reminds,
 once per returned gate, that no workflow-memory line follows it — unless the run recorded
 memory unavailable with `--for-run`
 ([`continuity.md`](https://github.com/ssheleg/task-pipeline/blob/main/plugins/task-pipeline/skills/task-pipeline/references/continuity.md), Part 3).
 
+`hooks/build-gate.sh` (`PreToolUse` on `Edit|Write|MultiEdit|NotebookEdit|apply_patch`)
+asks before the product is edited while the run has not entered its build stage.
+**Codex edits through `apply_patch`**, the patch text in `tool_input.command`, so the
+gate reads every `*** Add File:`, `*** Update File:`, `*** Delete File:` and
+`*** Move to:` path in it and asks when any one is gated (hub B-211). **Codex has no
+`PostToolUseFailure` event:** there `gate-observer.sh` records a failing gate command
+only if Codex's `PostToolUse` reports it, so a missing `gate:` line after a red run
+is not proof the suite never ran (the limit is Codex's event set, not this hook's).
+
 **Two lessons from v1.50.0, both shipped as defects and both fixed in v1.51.0.**
 
 *A gate keyed to a stage NUMBER is the rail's mistake with worse consequences.*

package/plugins/task-pipeline/skills/project-audit/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: project-audit
-description: "Use when someone asks what is true of a whole project: finished, half-built, broken, unexplored ('project audit', 'аудит проекта'). Discovers the project, runs probes, reads production evidence, leaves a JSON sidecar, an HTML report on request. Read-only: proposes board rows, commits nothing. Not for: one deliverable inside a run, a diff review, a skill's construction; 'без диагностики' opts out."
+description: "Use when someone asks what is true of a whole project ('project audit', 'аудит проекта'): finished, broken, unexplored. Probes it, reads production evidence, leaves a JSON sidecar. Read-only. Not for: one deliverable in a run, a diff review, a skill's construction; 'без диагностики' opts out."
 license: MIT
 compatibility: "The collector (scripts/audit.py) needs python3 and reads committed state, so it needs git. Probes needing gh, npm, network or a browser declare it and report blind when it is absent — degraded, never silent."
 ---

package/plugins/task-pipeline/skills/task-pipeline/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: task-pipeline
-description: "Use when work changes the repository: feature, fix, bug, refactor, migration, integration, audit, PR review; фича, фикс, баг, рефактор, миграция, интеграция, аудит. Runs a substantial task through gated stages, intake grill to docs/wiki and acceptance; a small change takes a short path. 'waves'/'волнами' closes the board. Not for questions or one-line edits; 'без пайплайна' opts out."
+description: "Use when work changes the repository: feature, fix, refactor, migration, integration, audit, PR review; фича, баг, интеграция, аудит. Runs a substantial task through gated stages to acceptance; 'waves'/'волнами' closes the board. Not for questions or one-line edits; 'без пайплайна' opts out."
 license: MIT
 compatibility: "Doctrine runs on any agent. The bundled scripts need python3; the run needs git. Missing either degrades, never blocks — the graph verbs and seeded gates go unused, and the run says so."
 ---
@@ -205,3 +205,7 @@ The description is the short form. The full trigger list it carried until 1.98.0
 moved here verbatim, still routes to this skill:
 
 "Use when work changes the repository — feature, fix, bug, refactor, migration, integration, rewrite, adoption or hardening; фича, фикс, баг, рефактор, миграция, интеграция, доработать, починить, внедрить, перевести — or a finding that lands in it: audit/аудит, bug hunt/проверь ошибки, production check/проверь прод, PR review/ревью PR — or on 'run this through the pipeline'/'прогони по конвейеру', 'the full cycle'/'полный цикл', /task-pipeline. Runs a substantial task through gated stages: intake grill, docs, brainstorm, spec, plan, build, tests, deploy, post-deploy, docs/wiki, acceptance. 'waves'/'волнами'/'release iteration'/'итерация релиза' closes the board; 'checkup'/'чекап' lists unconfirmed releases; 'setup' audits docs. Not for: answering a question, explaining, a typo, a one-line edit, a rename, recon that lands nothing — say 'no pipeline'/'без пайплайна' to opt out."
+
+Added in 1.102.3 (hub board row B-84), each a repository change that runs through the
+stages: 'write tests'/'напиши тесты', 'cut a release'/'зарелизь'/'выпусти релиз',
+'remove dead code'/'удали мёртвый код'.

package/plugins/task-pipeline/skills/task-pipeline/references/hooks.md

@@ -218,11 +218,20 @@ Since v1.50.0 the plugin carries hooks of its own. `hooks/release-gate.sh`
 (`PreToolUse` on `Bash`) refuses an **outward, irreversible act** — `git tag`, a
 tag push, `gh release create`, `npm publish` — while the run says the suite has not
 passed. `hooks/gate-observer.sh` (`PostToolUse` and `PostToolUseFailure`) records
-what the declared gate command actually did. `hooks/memory-nudge.sh` (`PostToolUse` on `Bash|Edit|Write|MultiEdit`) reminds,
+what the declared gate command actually did. `hooks/memory-nudge.sh` (`PostToolUse` on `Bash|Edit|Write|MultiEdit|apply_patch`) reminds,
 once per returned gate, that no workflow-memory line follows it — unless the run recorded
 memory unavailable with `--for-run`
 ([`continuity.md`](continuity.md), Part 3).
 
+`hooks/build-gate.sh` (`PreToolUse` on `Edit|Write|MultiEdit|NotebookEdit|apply_patch`)
+asks before the product is edited while the run has not entered its build stage.
+**Codex edits through `apply_patch`**, the patch text in `tool_input.command`, so the
+gate reads every `*** Add File:`, `*** Update File:`, `*** Delete File:` and
+`*** Move to:` path in it and asks when any one is gated (hub B-211). **Codex has no
+`PostToolUseFailure` event:** there `gate-observer.sh` records a failing gate command
+only if Codex's `PostToolUse` reports it, so a missing `gate:` line after a red run
+is not proof the suite never ran (the limit is Codex's event set, not this hook's).
+
 **Two lessons from v1.50.0, both shipped as defects and both fixed in v1.51.0.**
 
 *A gate keyed to a stage NUMBER is the rail's mistake with worse consequences.*

package/plugins/task-pipeline/skills/task-pipeline/references/retrospective.md

@@ -205,14 +205,20 @@ narrative are how a capped list grows anyway.
   `Because`) **verbatim** into the quarter's archive, each block carrying the sha256 of
   its text, and leaves a pointer; `retro_budget.py verify` proves every pointer. An
   instruction still over 600 characters after its story moved is rewritten by hand.
+  A shortened stamp row keeps its own table's header and column count: date, commit
+  and version cells stay whole, the long prose cells are capped at one common length,
+  and the pointer ends the last cell. A row that already carries a pointer is not
+  moved again.
   An older retro whose standing instructions are a numbered list and whose stamps are
   `- **date: title**` items is read the same way: the item keeps its bold rule and its
   `*(Retire ...)*` trigger, a stamp keeps its title, stamps past the cap rotate out by date,
   and, over budget, the Run stamps section's loose prune paragraphs move. Rotation keeps
   **one `Rotated out:` line per archive**: a later rotation re-archives the quarter's
   earlier rotated stamps with its own as one block and the line names that block, so a
-  floor that rotates every run does not grow by a line per run. A line whose block no
-  longer hashes stays as its own line.
+  floor that rotates every run does not grow by a line per run. A floor that already
+  holds several lines for one quarter has them merged on the next `migrate --write`,
+  each in its own quarter's archive. A line whose block no longer hashes stays as its
+  own line.
 - **A prune that retires nothing writes its count into the stamp row**, as
   `prune: 0 retired`, and no paragraph. Repeated "nothing to prune" notes were a
   measured share of the floor.

package/plugins/task-pipeline/skills/task-pipeline/scripts/retro_budget.py

@@ -14,10 +14,13 @@ on 2026-10-20 across ~50 projects the floor ran from ~3k to ~76k tokens, one of
     retro_budget.py migrate [--retro PATH] [--archive PATH] [--write]
         moves narrative out of the floor VERBATIM into the archive, each block
         carrying the sha256 of the text it holds, and leaves a pointer in its place:
-        a stamp row over the stamp limit keeps Date, Topic and Commit; a standing row
-        over the row limit loses its `Because` cell; a standing instruction written as
+        a stamp row over the stamp limit keeps its table's own columns and their count,
+        its date, commit and version cells whole, caps the long prose cells at one common
+        length and ends its last cell with the pointer; a standing row over the row limit
+        loses its `Because` cell; a standing instruction written as
         a numbered list item keeps its bold rule and its `*(Retire ...)*` trigger; the
-        oldest run stamps past the cap of ten rotate out whole. Without --write it prints the
+        oldest run stamps past the cap of ten rotate out whole, and rotation leaves one
+        `Rotated out:` line per archive quarter, merging any earlier ones. Without --write it prints the
         plan and writes nothing. Exit 0 when the floor is then within budget, 1 when a
         row is still over (an instruction too long to shorten by moving its story:
         rewrite it by hand), 2 could not measure.
@@ -84,17 +87,76 @@ def table_rows(lines, span):
 
 
 def cells(row):
-    parts = row.strip().split("|")
-    return [c.strip() for c in parts[1:-1]]
+    """A table row's cells. An escaped `\\|` is text inside its cell, not a delimiter
+    (B-258: splitting on it widened the row that replaced it)."""
+    s = row.strip()
+    s = s[1:] if s.startswith("|") else s
+    s = s[:-1] if s.endswith("|") and not s.endswith("\\|") else s
+    return [c.strip() for c in re.split(r"(?<!\\)\|", s)]
 
 
-def header_cols(lines, i):
-    """Column count of the table holding row i, read from its header (a `|` inside a
-    cell's text must not widen the row that replaces it)."""
+def header_of(lines, i):
+    """Index of the header line of the table holding row i."""
     k = i
     while k > 0 and lines[k - 1].startswith("|"):
         k -= 1
-    return len(cells(lines[k]))
+    return k
+
+
+def header_cols(lines, i):
+    """Column count of the table holding row i, read from its header (a `|` inside a
+    cell's text must not widen the row that replaces it)."""
+    return len(cells(lines[header_of(lines, i)]))
+
+
+# A short identifier cell (a date, a commit, a version, an id) is never cut to keep a long
+# prose cell (B-258: `working tree` became `working…` while a 200-character Task stayed).
+ID_MAX = 40
+ID_CELL = re.compile(r"^(?:\d{4}-\d{2}-\d{2}\b.*|`?[0-9a-f]{7,40}`?|`?v?\d+\.\d+\.\d+[\w.+-]*`?"
+                     r"|#\d+|[A-Z]{1,6}-\d+)$")
+ID_HEAD = re.compile(r"^(?:date|when|commit|sha|hash|base|version|ver|tag|release|pr|id)\b", re.I)
+MIN_CAP = 8
+
+
+def stamp_label(lines, i):
+    """`<date> <first other identifier>` of a stamp table row, for messages and archive
+    headings: the column holding the commit differs from table to table."""
+    c, head = cells(lines[i]), cells(lines[header_of(lines, i)])
+    ids = [x for j, x in enumerate(c[1:], 1)
+           if is_id(x, head[j] if j < len(head) else "")]
+    return " ".join(([c[0]] if c else []) + ids[:1])
+
+
+def is_id(cell, name):
+    return len(cell) <= ID_MAX and bool(ID_CELL.match(cell) or ID_HEAD.match(name.strip()))
+
+
+def clip(cell, cap):
+    """The cell cut to at most `cap` characters, ending in `…`. A cut never ends on a
+    backslash: it would escape the delimiter that follows."""
+    if len(cell) <= cap:
+        return cell
+    return cell[:cap - 1].rstrip().rstrip("\\").rstrip() + "…"
+
+
+def fit_stamp(c, head, ptr, limit):
+    """A stamp row in its table's own shape: as many cells as the header, identifier cells
+    whole, every prose cell capped at one common length K (the largest K that fits), and
+    the pointer appended to the last cell."""
+    n = len(head)
+    if len(c) > n:      # unescaped pipes in the narrative: the overflow is the last cell's text
+        c = c[:n - 1] + [" \\| ".join(c[n - 1:])]
+    c = c + [""] * (n - len(c))
+    prose = [j for j in range(n) if not is_id(c[j], head[j])]
+
+    def build(cap):
+        out = [clip(x, cap) if j in prose else x for j, x in enumerate(c)]
+        out[-1] = (out[-1] + " " + ptr) if out[-1] else ptr
+        return "| " + " | ".join(out) + " |"
+    cap = max([len(c[j]) for j in prose] or [0])
+    while cap > MIN_CAP and len(build(cap)) > limit:
+        cap -= 1
+    return build(cap)
 
 
 ITEM = re.compile(r"^(\d+)\.\s")
@@ -203,8 +265,7 @@ def measure(text, budget=BUDGET, row=ROW, stamp=STAMP):
             over.append("standing row %s is %d chars, over %d" % (label, width(sp), row))
     for sp in stm:
         if width(sp) > stamp:
-            c = cells(lines[sp[0]]) if lines[sp[0]].startswith("|") else []
-            label = "%s %s" % (c[0], c[2] if len(c) > 2 else "") if c \
+            label = stamp_label(lines, sp[0]) if lines[sp[0]].startswith("|") \
                 else "%s (list)" % (stamp_date(lines, sp) or "undated")
             over.append("stamp %s is %d chars, over %d" % (label.strip(), width(sp), stamp))
     if len(std) > CAP:
@@ -256,14 +317,31 @@ ROTATED = re.compile(r"^Rotated out: ([0-9]+) oldest run stamps, verbatim in (\S
 ARCHIVED = re.compile(r"<!-- sha256:([0-9a-f]{64}) -->\n(.*?)\n(?=\n#{2,3} |\Z)", re.S)
 
 
-def rotation_lines(lines, span, rel):
-    """(line index, stamp count, short sha) of each rotation pointer into `rel`."""
-    out = []
+def rotation_lines(lines, span, rel=None):
+    """(line index, stamp count, short sha) of each rotation pointer into `rel`; with no
+    `rel`, {archive: [those triples]} for every archive a rotation line names."""
+    out = {}
     for k in range(span[0], span[1]):
         r = ROTATED.match(lines[k])
-        if r and r.group(2) == rel:
-            out.append((k, int(r.group(1)), r.group(3)))
-    return out
+        if r:
+            out.setdefault(r.group(2), []).append((k, int(r.group(1)), r.group(3)))
+    return out if rel is None else out.get(rel, [])
+
+
+def earlier_rotations(lines, span, rel, path):
+    """The rotation lines into `rel` whose archive block still hashes: ([(offset, line
+    index, text)], summed stamp count). A line that does not resolve is named and left as
+    its own line, never merged away unproved."""
+    earlier, count = [], 0
+    for k, n, short in rotation_lines(lines, span, rel):
+        prior = archived_text(path, short)
+        if prior is None:
+            print("migrate: the rotation line sha256:%s does not resolve in %s; "
+                  "it stays as its own line" % (short, rel))
+            continue
+        earlier.append((prior[0], k, prior[1]))
+        count += n
+    return earlier, count
 
 
 def archived_text(path, short):
@@ -290,6 +368,22 @@ def cmd_check(a):
     return 0
 
 
+def append_blocks(archive, blocks):
+    """Append blocks to an archive, creating it with its header first."""
+    if not blocks:
+        return
+    os.makedirs(os.path.dirname(os.path.abspath(archive)), exist_ok=True)
+    if not os.path.exists(archive):
+        with open(archive, "w", encoding="utf-8") as fh:
+            fh.write("# Retro archive · %s\n\n**Append-only. Queried, never read in full.** "
+                     "Blocks moved here by `retro_budget.py migrate` carry the sha256 of the "
+                     "text they hold; the floor keeps a pointer to it.\n"
+                     % os.path.basename(archive)[:-3])
+    with open(archive, "a", encoding="utf-8") as fh:
+        for b in blocks:
+            fh.write(b)
+
+
 def cmd_migrate(a):
     text = read(a.retro)
     m = measure(text, a.budget, a.row, a.stamp)
@@ -301,6 +395,8 @@ def cmd_migrate(a):
     head = m["spans"][STAMPS][0]
     notes = []      # pointer lines inserted under the Run stamps heading
     rotated = set()
+    merged = set()  # archives whose rotation lines this run already merged
+    elsewhere = []  # (archive path, block, label, rel): blocks bound for another quarter's file
     if len(m["stm"]) > CAP:
         # The cap rotates the OLDEST stamps out whole (references/retrospective.md, *The
         # stamp table is capped at ten*). Oldest is read from the date, never from the
@@ -362,15 +458,9 @@ def cmd_migrate(a):
             # into the same archive are re-archived with this one as a single block, and
             # their lines give way to one line naming it. The archive stays append-only:
             # the earlier blocks remain, only the floor stops pointing at them.
-            count, earlier = len(rotated), []
-            for k, n, short in rotation_lines(lines, m["spans"][STAMPS], rel):
-                prior = archived_text(archive, short)
-                if prior is None:
-                    print("migrate: the rotation line sha256:%s does not resolve in %s; "
-                          "it stays as its own line" % (short, rel))
-                    continue
-                earlier.append((prior[0], k, prior[1]))
-                count += n
+            earlier, count = earlier_rotations(lines, m["spans"][STAMPS], rel, archive)
+            count += len(rotated)
+            merged.add(rel)
             for _, k, _ in earlier:
                 moved.append((k, k + 1, [], None, None))
             if earlier:
@@ -380,10 +470,40 @@ def cmd_migrate(a):
                 moved.append((sp[0], sp[1], [], None, None))
             notes.append(("Rotated out: %d oldest run stamps, verbatim in %s sha256:%s"
                           % (count, rel, h[:12]), b, "%d oldest run stamps rotated" % len(rotated)))
+    # B-246: a floor that already holds several rotation lines for one archive (written
+    # before 1.101.0, or into a quarter this run does not rotate into) gets one line per
+    # archive on this run too: the earlier blocks are re-archived as one, in their own
+    # quarter's file, and their lines give way to the line naming it.
+    base = os.path.dirname(os.path.abspath(a.retro))
+    for other, group in sorted(rotation_lines(lines, m["spans"][STAMPS]).items()):
+        # Only an archive a floor pointer can prove (`retro/YYYY-QN.md`) is written to.
+        if other in merged or len(group) < 2 or not POINTER.match(other + " sha256:" + "0" * 12):
+            continue
+        path = os.path.join(base, other)
+        earlier, count = earlier_rotations(lines, m["spans"][STAMPS], other, path)
+        if len(earlier) < 2:
+            continue
+        h, b = block("stamps", "%d oldest rotated" % count,
+                     "\n".join(t for _, _, t in sorted(earlier)))
+        for _, k, _ in earlier:
+            moved.append((k, k + 1, [], None, None))
+        note = "Rotated out: %d oldest run stamps, verbatim in %s sha256:%s" % (count, other, h[:12])
+        label = "%d rotation lines merged" % len(earlier)
+        if other == rel:
+            notes.append((note, b, label))
+        else:
+            notes.append((note, None, None))
+            elsewhere.append((path, b, label, other))
     for sp in m["stm"]:
         i = sp[0]
         if sp in rotated or len("\n".join(lines[sp[0]:sp[1]])) <= a.stamp:
             continue
+        if any(POINTER.search(l) for l in lines[sp[0]:sp[1]]):
+            # Already migrated: its narrative is in the archive. Moving it again would
+            # archive the same row on every run (B-258).
+            print("migrate: stamp %s already points at its archive and is still over %d; "
+                  "shorten it by hand" % (stamp_date(lines, sp) or "undated", a.stamp))
+            continue
         if not lines[i].startswith("|"):
             # A list stamp keeps its bold title; the narrative moves.
             item = "\n".join(lines[sp[0]:sp[1]])
@@ -401,23 +521,17 @@ def cmd_migrate(a):
             moved.append((sp[0], sp[1], ["- %s%s" % (t, ptr)], b,
                           "stamp %s (list)" % (stamp_date(lines, sp) or "undated")))
             continue
-        c = cells(lines[i])
-        if len(c) < 3:
+        head = cells(lines[header_of(lines, i)])
+        if len(head) < 2:
+            print("migrate: stamp %s sits in a one-column table; shorten it by hand"
+                  % (stamp_date(lines, sp) or "undated"))
             continue
-        h, b = block("stamp", "%s %s" % (c[0], c[2]), lines[i])
-        ptr = "moved: %s sha256:%s" % (rel, h[:12])
-        # the table keeps its column count: the pointer fills Verdict, `·` the rest
-        tail = ["·"] * max(0, header_cols(lines, i) - 4)
-
-        def row_of(topic):
-            return "| " + " | ".join([c[0], topic, c[2], ptr] + tail) + " |"
-
-        topic = c[1]
-        new = row_of(topic)
-        if len(new) > a.stamp:
-            keep = max(8, len(topic) - (len(new) - a.stamp) - 1)
-            new = row_of(topic[:keep].rstrip() + "…")
-        moved.append((i, i + 1, [new], b, "stamp %s %s" % (c[0], c[2])))
+        label = stamp_label(lines, i)
+        h, b = block("stamp", label, lines[i])
+        # B-258: the row keeps its table's own header and column count; identifier cells
+        # stay whole, the long prose cells are capped evenly, the pointer ends the last cell.
+        new = fit_stamp(cells(lines[i]), head, "moved: %s sha256:%s" % (rel, h[:12]), a.stamp)
+        moved.append((i, i + 1, [new], b, "stamp %s" % label))
     if m["bytes"] > a.budget:
         # Prune paragraphs between the stamps were a measured share of the floor
         # (*A prune that retires nothing writes its count into the stamp row*): over
@@ -440,7 +554,8 @@ def cmd_migrate(a):
     if notes:
         moved.append((head + 1, head + 1, sum([["", n] for n, _, _ in notes], []), None, None))
         for n, b, label in notes:
-            moved.append((head + 1, head + 1, [], b, label))
+            if b:
+                moved.append((head + 1, head + 1, [], b, label))
     for s0, s1 in m["std"]:
         item = "\n".join(lines[s0:s1])
         if len(item) <= a.row:
@@ -480,20 +595,14 @@ def cmd_migrate(a):
         if label:
             print("migrate: %s -> %s%s" % (label, rel, "" if s0 == s1 else " (%d -> %d chars)" % (
                 len("\n".join(lines[s0:s1])), len("\n".join(new)))))
+    for _, _, label, other in elsewhere:
+        print("migrate: %s -> %s" % (label, other))
     if not a.write:
         print("migrate: dry run, nothing written (pass --write)")
         return 0
-    os.makedirs(os.path.dirname(os.path.abspath(archive)), exist_ok=True)
-    if not os.path.exists(archive):
-        with open(archive, "w", encoding="utf-8") as fh:
-            fh.write("# Retro archive · %s\n\n**Append-only. Queried, never read in full.** "
-                     "Blocks moved here by `retro_budget.py migrate` carry the sha256 of the "
-                     "text they hold; the floor keeps a pointer to it.\n"
-                     % os.path.basename(archive)[:-3])
-    with open(archive, "a", encoding="utf-8") as fh:
-        for _, _, _, b, _ in moved:
-            if b:
-                fh.write(b)
+    append_blocks(archive, [b for _, _, _, b, _ in moved if b])
+    for path, b, _, _ in elsewhere:
+        append_blocks(path, [b])
     # Rebuild from the bottom so earlier spans keep their indices.
     for s0, s1, new, _, _ in sorted(moved, key=lambda x: (x[0], x[1]), reverse=True):
         lines[s0:s1] = new