diff --git a/.claude/agents/squad-lead.md b/.claude/agents/squad-lead.md
index 5e659580..087e4f5d 100644
--- a/.claude/agents/squad-lead.md
+++ b/.claude/agents/squad-lead.md
@@ -62,13 +62,15 @@ The orchestrator tells you which **mode** to run:
   - for a bug fix, acceptance criteria the Tester can turn into unit tests (a feature's are the spec's: never
     copy them), and for every criterion its tests in *Tests per criterion* — the Tester writes exactly those
     first. A criterion that words a condition for user-visible text (a status line, a message) is derived from
-    the code path that decides it, and the plan names that path, not a paraphrase of the trigger;
+    the code path that decides it, and the plan names that path, not a paraphrase of the trigger. New
+    user-visible output gets its layout in *Approach* — heading level, list structure, order, when optional
+    notes appear — or the line "layout free for the Tester, approved in step 9": the Tester does not decide it;
   - the **documentation updates**, found by a sweep before they are listed: search the area documents and
     `docs/ARCHITECTURE.md` for every enumeration or "only these …" statement the change extends (routes,
     rules, settings, tables, limits) and list each hit, besides the documents you already know the change
     touches — each update and area document with exactly one owner (Dev, Tester or Lead);
-  - for a feature, `tasks.md`: task groups in build order, each naming the spec's criteria it delivers and the
-    tasks it waits for;
+  - for a feature, `tasks.md`: task groups in build order, each naming the spec's criteria it delivers, the
+    tasks it waits for and a skeleton row for its *Signatures* (or "no new API");
   - the exact **signatures** of every new or changed member (for the Dev's skeleton) and the existing files
     the skeleton must rewrite — a file you call final is one you read and found so;
   - the **test files**, named strictly by *Layout* in `.squad/stack.md` and `docs/UNIT_TESTS.md`, and the
@@ -88,9 +90,12 @@ The orchestrator tells you which **mode** to run:
   - for a new or changed parser, decoder or reader of an external format: the **real sample** of that format
     the plan is built from — a file under the stack's test data layout or attached to the issue, named with
     the variants it covers, which the Tester's tests read instead of hand-typed lines where the format allows.
-    Without one, return `RESULT: ESCALATE` (*Escalation to the Product Manager*: provide a sample, naming the
-    variants the issue mentions, or confirm building from the description with the residual risk recorded in
-    the decision record) and plan on only with the answer;
+    A sample with real private values (addresses, host names, keys, user names) is anonymized by replacing
+    each such field whole, generated from nothing of the real value; before you hand it back, decode every
+    field of the result and compare each against the set of real values, prefixes included, since a grep for
+    the original strings misses a partly replaced field.
+    Without one, return `RESULT: ESCALATE` (*Escalation to the Product Manager*, naming the variants)
+    and plan on only with the answer;
   - an architecture check against `docs/ARCHITECTURE.md`: the guarantees in `.squad/project.md` are not
     weakened without the Product Manager;
   - the **options considered**: each alternative you weighed and why it lost, or "one option" — they decide
@@ -103,7 +108,10 @@ The orchestrator tells you which **mode** to run:
   output, a file system) is checked against the artifact or marked *unverified* — a build output against the
   build the artifact really gets (*Image build check*), never a build from the full working tree. A criterion
   about an escape names the guard that fails when the test input lost its backslash (`.squad/team.md`,
-  *Escapes in files*).
+  *Escapes in files*). A control character a case is about (a bidi override, a zero-width character, a line
+  separator) is written in `plan.md`, `spec.md` and `tasks.md` as a text escape, never as the character
+  itself; before you hand back, check the bytes on disk as *Escapes in files* describes, so the first
+  `plan-check.py` run passes.
 
   For every decision that meets the threshold in `docs/decisions/README.md`, create a `Proposed` record
   from `docs/decisions/_template.md`, add its row to the index in `docs/decisions/README.md` with status
@@ -124,7 +132,9 @@ The orchestrator tells you which **mode** to run:
   *Challenge notes* section into *Challenge*, and decide every choice a *Security notes* entry leaves (the
   option taken and why), folding the section into *Security review*. Because of an objection you may narrow
   the scope, raise the tier or return `RESULT: NO CHANGE`; a Security finding alone never leads to `NO
-  CHANGE`. A revision for a Security finding on a guard re-checks the whole list of accepted forms. Update the
+  CHANGE`. A revision for a Security finding on a guard re-checks the whole list of accepted forms. Move settled
+  material (answered entries, verified facts) to the decision record or area document: a plan over
+  `PLAN_HARD_WORDS` fails `plan-check.py`. Update the
   affected decision records (a rejected option and the reason belong under *Options considered*).
 - `decide` — a loop limit was hit or members disagree. Choose one option and justify it, or escalate: accept
   with justification (after the 2nd `CHANGES_REQUIRED` only for the defects *Loop limits* names, Plan ↔
@@ -143,9 +153,12 @@ The orchestrator tells you which **mode** to run:
   find necessary — a stale or missing record, `docs/ARCHITECTURE.md`, a missing area document — gets its
   owner by file as in `decide` and a delta round: `NOT APPROVED`, or `APPROVED` on that condition.
 
+- `docs` — a documentation task group of the plan: edit only the files of your task rows, check every
+  statement against the final code, report a mismatch in the Dev's passages, run `decision-check.py`.
+
 Output format, always ending with exactly one of these lines:
 
-- `RESULT: DONE` (spec/plan/revise), `RESULT: NO CHANGE — <reason and proposed issue comment>` (spec, plan, or revise after a challenge),
+- `RESULT: DONE` (spec/plan/revise/docs), `RESULT: NO CHANGE — <reason and proposed issue comment>` (spec, plan, or revise after a challenge),
   `RESULT: DECIDED — <option>` (decide),
   `RESULT: APPROVED` / `RESULT: NOT APPROVED — <reasons>` (approve-pr), or
 - `RESULT: ESCALATE — <one question for the Product Manager, the options, your recommendation>`
diff --git a/.claude/agents/squad-reviewer.md b/.claude/agents/squad-reviewer.md
index faf7cadb..21fe2a43 100644
--- a/.claude/agents/squad-reviewer.md
+++ b/.claude/agents/squad-reviewer.md
@@ -43,8 +43,9 @@ areas, guarantees, integration surface, test doubles), `AGENTS.md` and
   formatting the formatter fixes, or praise is left out of the report.
 - **State a documentation fix verbatim.** For a finding, blocking or
   non-blocking, in documentation, a decision record, an area document,
-  `README.md` or a configuration example, give the file, the sentence as it
-  stands and the sentence as it should read, and mark the finding
+  `README.md` or a configuration example, give the file, the whole sentence
+  as it stands and as it should read (never an insertion point such as
+  "add after '…'"), and mark the finding
   `verbatim` (`.squad/routing.md`, *Verbatim documentation fixes*). When the
   fix changes a behavior statement an acceptance criterion or a guarantee in
   `.squad/project.md` relies on, say so: the Lead decides.
diff --git a/.claude/agents/squad-security.md b/.claude/agents/squad-security.md
index 4b8f661b..84799ace 100644
--- a/.claude/agents/squad-security.md
+++ b/.claude/agents/squad-security.md
@@ -38,7 +38,8 @@ the Lead's revision: review the plan's change since your round plus whether your
 in the first `log.md` row, as the only review of the change; from round 2 on, review only the delta since the
 previous round plus whether your earlier findings are resolved. In mode `diff` you also run the Reviewer's
 *Logger arguments* check (`.claude/agents/squad-reviewer.md`) on the changed log calls: a name that matches
-the stack's sensitive-name list is a blocking finding. A verification the Dev reported with its
+the stack's sensitive-name list is a blocking finding. When the issue concerns an exploit measurement, run no probes
+at all: read the Dev's measurement and report what reading cannot verify. A verification the Dev reported with its
 cases and output is evidence: read it against the diff and re-run only what bears on a security area and
 you doubt, instead of repeating the whole comparison.
 
diff --git a/.claude/hooks/git-guard.py b/.claude/hooks/git-guard.py
index dddfbe47..290ce595 100644
--- a/.claude/hooks/git-guard.py
+++ b/.claude/hooks/git-guard.py
@@ -4,7 +4,7 @@
 Every `.claude/agents/squad-*.md` declares this hook in its front matter, so it runs only while a squad
 member is active - the orchestrator (the session that runs the skill) commits, pushes and posts as before.
 It reads the hook input JSON from stdin and, for a `Bash` call, checks every `git` and `gh` invocation in
-the command (also behind `&&`, `;`, `|`, `$(…)` and `git -C <dir>`):
+the command (also behind `&&`, `;`, `|`, `$(…)`, `git -C <dir>`, and inside `bash -c` / `sh -c` / `eval`):
 
 - allowed: read-only Git (`status`, `diff`, `log`, `show`, `ls-files`, `grep`, `rev-parse`, `merge-base`,
   `fetch`, `tag --list` / `--contains`, `branch --list` / `--show-current`, `ls-remote`, `clone`, …),
@@ -48,6 +48,7 @@
 BRANCH_READ = {"-l", "--list", "-a", "-r", "--all", "--remotes", "--show-current", "--contains", "--merged",
                "--no-merged", "-v", "-vv", "--verbose"}
 CONFIG_READ = {"-l", "--list", "--show-origin", "--show-scope"}
+SHELLS = {"sh", "bash", "zsh", "dash", "ksh"}
 
 
 def git_subcommand(tokens):
@@ -138,6 +139,20 @@ def basename(token):
     return token.rsplit("/", 1)[-1]
 
 
+def nested_command(name, args):
+    """The command string a shell runs with `-c` (also `-lc`, `-ec`, …) or `eval` runs, or None."""
+    if name == "eval":
+        return " ".join(args)
+    if name not in SHELLS:
+        return None
+    for i, option in enumerate(args):
+        if not option.startswith("-") or option.startswith("--"):
+            return None
+        if "c" in option[1:]:
+            return args[i + 1] if i + 1 < len(args) else None
+    return None
+
+
 def check_command(command):
     """The first denied invocation in the command as text, or None."""
     for segment in SEGMENT_SPLIT.split(command):
@@ -147,7 +162,10 @@ def check_command(command):
             tokens = segment.split()
         for i, token in enumerate(tokens):
             name = basename(token)
-            if name == "git":
+            nested = nested_command(name, tokens[i + 1:])
+            if nested is not None:
+                found = check_command(nested)
+            elif name == "git":
                 found = git_verdict(tokens[i + 1:])
             elif name == "gh":
                 found = gh_verdict(tokens[i + 1:])
diff --git a/.claude/skills/create-pr/SKILL.md b/.claude/skills/create-pr/SKILL.md
index 78939a43..09ef4e29 100644
--- a/.claude/skills/create-pr/SKILL.md
+++ b/.claude/skills/create-pr/SKILL.md
@@ -49,7 +49,9 @@ repository.
    change instead of collecting review rounds afterwards.
 7. **Push** the branch: `git push -u origin <branch-name>`.
 8. **Open the PR as a draft** (`draft: true`) using the repository's template at
-   `.github/pull_request_template.md`:
+   `.github/pull_request_template.md`. The GitHub tools can rewrite an inline Markdown link in the body into
+   a broken form: write record references as plain paths and check the body with `pull_request_read` after the
+   first write:
    - base branch `main`, unless the user explicitly requests a different base
    - title `[area] Description` per
      [`CONTRIBUTING.md`](../../../docs/CONTRIBUTING.md) — area is one of the
diff --git a/.claude/skills/squad-issue/SKILL.md b/.claude/skills/squad-issue/SKILL.md
index eb6577c6..5c6aaf49 100644
--- a/.claude/skills/squad-issue/SKILL.md
+++ b/.claude/skills/squad-issue/SKILL.md
@@ -56,12 +56,18 @@ every Git and GitHub action yourself, including follow-up issues the Lead decide
      its task notification arrives, add the usage with `--amend-last "<member>" --agent squad-<role> --tokens …
      --tool-uses … --seconds …` (`--step "<step>"` for a row that is no longer the member's last).
    - **Every number is copied from the usage block of a task notification you have in front of you** —
-     never an estimate, a figure from memory or the member's hand-back. A notification that never comes is
-     marked `--unreported`; a wrong trailer is corrected with `--replace-last`, never with a second row.
+     never an estimate, a figure from memory or the member's hand-back. A notification whose summary says the
+     agent is waiting on its own background work is interim: amend with the numbers of the final notification
+     of the same task id (`--replace-last`, with `--step` if the row is no longer the member's last, if the interim
+     ones are already in). A repeated hand-back message is ignored; only the latest notification of a task id
+     counts. A notification that never comes is marked `--unreported`; a wrong trailer is corrected with
+     `--replace-last`, never with a second row.
    - A continued launch gets `--continued` (or `--continued-from "<step cell of the fresh launch>"` when that
      agent is not the member's last fresh launch) on the call that carries its numbers — the amend of its pending
-     row — with the notification's numbers unchanged.
+     row — with the notification's numbers unchanged. Name a fix, delta or revise round as such in its step
+     cell; a continuation at another step than its fresh launch draws a warning (a new mode is a fresh launch).
    - Rows of the Orchestrator, the Product Manager and the User take no metric option.
+   - After step 10 every call — row, amend, summary — needs `--stdin` (step 10); without it, it fails.
    - Everything else, and what each refusal means: `python3 .squad/tools/squad-log.py --help`.
 
    After every member's report, commit and push the files it left in the work folder.
@@ -98,7 +104,8 @@ every Git and GitHub action yourself, including follow-up issues the Lead decide
    tests it hands back as **deferred**. A fix without a reproducing test is acceptable only when the bug
    genuinely needs a live external system — then the PR says so.
 6. **Implement and cover.** For a change without production or test code this is the Dev's edits alone: no
-   `squad-tester`, no *Test with coverage*, no *Coverage gate*. Otherwise launch `squad-dev` in mode `implement` with the plan and the test names. If the
+   `squad-tester`, no *Test with coverage*, no *Coverage gate*. Otherwise launch `squad-dev` in mode `implement`
+   — a fresh launch, never a continuation of its `skeleton` agent — with the plan and the test names. If the
    Dev disputes a test, launch `squad-lead` in mode `decide`; the Tester changes a test only if the Lead says
    so. Run *Test with coverage* and the *Coverage gate* yourself. Launch `squad-tester` in mode `coverage`,
    with the reason, only when the gate fails, the Dev reports uncovered new lines, a resource bound of the
@@ -126,18 +133,21 @@ every Git and GitHub action yourself, including follow-up issues the Lead decide
    - non-blocking findings: *Non-blocking findings*, collected for step 9.
 
    A reviewer or `squad-security` that stops on an API error (`529 Overloaded`; `429`: once the limit has reset) is relaunched
-   unchanged, at most twice; after that report a blocker to the user.
+   unchanged, at most twice; after that report a blocker to the user. A safeguard stop (`invalid_request`, category
+   `cyber`) is not relaunched: escalate to the Product Manager at once (*Loop limits*, Safeguard stop).
 9. **PR approval.** Run *PR approval* (`.squad/routing.md`): the checklist in full, then the record status
-   and `decision-check.py`. Launch `squad-lead` in mode `approve-pr` — with the base ref, the gate output, the
-   review outcome and the open points (after the PR also the finished check-run list) — only for the open
-   decisions it lists; otherwise log "approved by checklist".
+   and `decision-check.py`. Launch `squad-lead` in mode `approve-pr` as a fresh launch (never a continuation
+   of its plan agent) — with the base ref, the gate output, the review outcome and the open points (after the
+   PR also the finished check-run list) — only for the open decisions it lists; otherwise log "approved by
+   checklist".
 10. **Pull request.** Post `plan.md` (none on tiers `docs` and `patch`) and `log.md` as one comment on the
     issue, headed "Squad working record", each inside a collapsed `<details>` block — or, for a `plan.md` too
     long to re-type, a permalink to the last commit that contains it
     (`https://github.com/<owner>/<repo>/blob/<sha>/specs/issue-<number>/plan.md`) plus a summary of tier,
     criteria, decisions and challenge outcome. Then `git rm -r specs/issue-<number>/`, confirm with
     `python3 .squad/tools/scope-check.py --no-specs`, commit ("Remove squad working record") and push. Later
-    log rows go into that comment. Open the PR as `create-pr` step 8 says, without its review loop; a PR the
+    log rows go into that comment: pipe its log table into `squad-log.py … --stdin` and paste the log it prints
+    back (nothing is restored into the repository). Open the PR as `create-pr` step 8 says, without its review loop; a PR the
     session already has for the branch (`list_pull_requests` with `head: "<owner>:<branch>"`) gets its title
     and body updated instead (`update_pull_request`, `draft: true`). The body describes the bug, the fix and
     the reproducing test (or that the fix is not verifiable without a real external system), `Closes
@@ -164,8 +174,8 @@ every Git and GitHub action yourself, including follow-up issues the Lead decide
     contradictory rule, a misbehaving tool, an agent that could not be launched, a step you had to improvise —
     each with the role it concerns and a concrete proposal, file them as *Squad lessons* says (create the
     labels if missing) and link them from the working-record comment; with nothing to learn, add a `no
-    lessons` row instead. Run `python3 .squad/tools/squad-log.py issue-<number> --summary` (restore the log
-    from the comment if needed); exit code 3 names launch rows still without usage — amend them from their
+    lessons` row instead. Run `python3 .squad/tools/squad-log.py issue-<number> --summary` (`--stdin` with the comment's
+    log table); exit code 3 names launch rows still without usage — amend them from their
     notifications or mark them `--unreported`, and run it again. Append the tables exactly as printed (a run
     without them is not wrapped up) to the comment under "Squad run metrics", and report the branch, the PR
     URL, the tier, the `squad` issues (or "no lessons"), the metrics tables and any escalation or Lead
diff --git a/.claude/skills/squad-spec/SKILL.md b/.claude/skills/squad-spec/SKILL.md
index 12df1e5a..0ab9684d 100644
--- a/.claude/skills/squad-spec/SKILL.md
+++ b/.claude/skills/squad-spec/SKILL.md
@@ -46,11 +46,12 @@ cells in `log.md`); steps 4–12 follow `squad-issue` with the changes listed af
 
 ## Steps 4–12: as in `squad-issue`, with these changes
 
-- **Steps 4–6** run per task group from `tasks.md`, in the order its *Depends on* column allows; tick tasks off
-  as they are done. The Tester's tests first are the tests *Tests per criterion* names for the group's
+- **Steps 4–6** run per task group — the *Group* column of `tasks.md`, in table order; tick tasks off as they
+  are done. The Tester's tests first are the tests *Tests per criterion* names for the group's
   criteria. Continue a member for the fix and delta rounds of its task group; the next task group starts with
   a fresh launch (*Continuing a member*), and a later fix round for an earlier group's agent is logged with
-  `--continued-from "<step cell of that group's launch>"`.
+  `--continued-from "<step cell of that group's launch>"`. A group whose task rows belong to the Lead
+  (documentation) is launched as `squad-lead` in mode `docs`, after the groups it waits for.
 - **Code-free changes:** as *Changes without production or test code*; *Verification without tests* then
   covers each criterion of the spec.
 - **Decision records:** features usually involve real design choices, so expect a record in
@@ -61,4 +62,5 @@ cells in `log.md`); steps 4–12 follow `squad-issue` with the changes listed af
   area documents now say what the spec's *Area documents* section promised.
 - **Step 10:** the working record (`spec.md`, `plan.md`, `tasks.md`, `log.md`) is posted to the feature
   request issue if one exists (`Closes #<n>` in the PR), otherwise as the first comment on the PR right after
-  opening it.
+  opening it; every log row and amend after it goes through `squad-log.py … --stdin` on that comment's log
+  table.
diff --git a/.squad/routing.md b/.squad/routing.md
index 49a3f9bd..2e46d2fd 100644
--- a/.squad/routing.md
+++ b/.squad/routing.md
@@ -226,7 +226,8 @@ launch with `--continued` or `--continued-from` (`squad-issue`, step 1); what a
 Commits and pushes to the work branch happen right after intake (`specs/<folder>/log.md`, so a stop hook
 or a crashed session finds no untracked files) and after every further completed step; with *Squash and
 merge* only the PR title and description reach `main`, so intermediate commits may describe the step.
-They never contain secrets. After the PR every push re-triggers CI and the code analysis, so edits are
+They never contain secrets. Before every commit `git symbolic-ref -q HEAD` must name the work branch; a
+detached HEAD is switched back to it first (`git switch <branch>`) and logged with the launch that left it. After the PR every push re-triggers CI and the code analysis, so edits are
 batched and committed once per round.
 
 ### The stop hook
@@ -359,8 +360,10 @@ PR is opened, the branch stays without one, and the user is told so.
   compiling only because of a signature or field change the Dev made itself — mechanically, no assertion touched, listed in
   its report; these are the only cases in which the Dev edits test code. The **Tester** moves them in step 5
   when old and new signature coexist, and checks the Dev's edits in its coverage step.
-- **Dev ↔ Tester disagreements:** if the Dev believes a step-5 test is wrong, the Lead decides (the test
-  is not changed silently). Not counted against a loop limit.
+- **Dev ↔ Tester disagreements:** if the Dev believes a step-5 test's expectation is wrong, the Lead decides
+  (the test is not changed silently). A defect the Dev reproduces without changing the test (a failing fixture
+  or helper, not a disputed expectation) goes to the Tester as a fix round once the orchestrator has verified
+  the reproduction. Not counted against a loop limit.
 - **Code check needs a structural change** (or breaks build/tests): the Code Officer's edit is reverted
   and the item goes to the Dev (or Tester for tests), then the code check runs again. Not counted
   against a loop limit.
@@ -369,12 +372,17 @@ PR is opened, the branch stays without one, and the user is told so.
   cover*) is a plan defect the Lead records with the decision.
 - **After the PR (step 11):** CI or quality-gate failures and review comments are fixed on the same
   branch through steps 7–8 again (delta review), at most 2 fix rounds per failure; then the Lead decides.
+- **Safeguard stop (any member, any step):** an API `invalid_request` of category `cyber` is not an API error:
+  relaunching unchanged loops, and rephrasing the request is a workaround. The orchestrator escalates to the
+  Product Manager at once, naming the finding the member had not reviewed as unverified.
 
 ## Escalation to the Product Manager
 
 The Lead escalates only when it cannot decide responsibly on its own: an ambiguous requirement (a reader of an
 external format without a real sample in the test data or on the issue is one — it asks for the sample, or for the
-confirmation to build from the description with the residual risk recorded in the decision record), a product
+confirmation to build from the description with the residual risk recorded in the decision record; a sample the
+PM supplies stays outside the repository, the Tester builds an anonymized fixture, a test that reads the sample
+from an environment variable checks the fixture against it, and only counts are reported), a product
 decision (behavior change visible to users, breaking a guarantee in `docs/ARCHITECTURE.md` or an accepted decision
 record), or a loop limit where none of its options is clearly right. The escalation is one concise question with
 the options and the Lead's recommendation. Follow-up issues the Lead decides on are created by the orchestrator and
diff --git a/.squad/team.md b/.squad/team.md
index 22c21073..639d6d0b 100644
--- a/.squad/team.md
+++ b/.squad/team.md
@@ -50,7 +50,8 @@ formatter touched is reported as "formatted outside the change", not edited, and
 **Git and GitHub.** Members never run Git write operations and never post to GitHub (no GitHub MCP write tool
 either); the `PreToolUse` hook `.claude/hooks/git-guard.py`, declared in every `squad-*.md`, denies such Bash
 commands. Read-only Git, `git add` and a scratch `git worktree` stay allowed; a member that needs
-anything else reports it.
+anything else reports it. Another revision is read with `git show <sha>:<path>` or in a scratch worktree
+(`git worktree add --detach`), never by checking it out in the repository working tree.
 Session-management tools (`create_session`, `send_message`, `archive_session` and the other remote-session
 tools) belong to the orchestrator alone, also for "handing over" work. Experiments — mutation tests, trial
 edits, baselines — run in a scratch `git worktree`, never in the repository working tree (`git stash` is a
@@ -92,4 +93,7 @@ file with a script; either way check the bytes on disk (`grep -n '\\u' <file>`)
 there exactly as the case needs before reporting the file done — again after *Format*, since a formatter may do
 the same to string literals (*Known pitfalls* in `.squad/stack.md`). A test whose case is about an escape also
 asserts that its input still contains the backslash, so a lost escape fails the run instead of testing the
-wrong input.
+wrong input. A control character a case is about (a bidi override such as U+202E, a zero-width character, a
+line separator) is never written as the character itself into `plan.md`, `spec.md`, `tasks.md` or any other
+working record: it stands there as a text escape (`U+202E`, or `\\u202E` with the doubled backslash), because
+`plan-check.py` and `scope-check.py` reject the character.
diff --git a/.squad/template.json b/.squad/template.json
index b3aece6a..f272afe9 100644
--- a/.squad/template.json
+++ b/.squad/template.json
@@ -1,6 +1,6 @@
 {
   "repository": "LarsLaskowski/Squad-Spec-Repository-Template",
-  "commit": "77cc8827778ec4d13a60ba45557d8ec67cb56596",
+  "commit": "07bdc6fd8b157b0a67694ee8d5399697eeeec55e",
   "profile": "dotnet",
   "profiles": [
     "dotnet"
diff --git a/.squad/tools/analyzer_common.py b/.squad/tools/analyzer_common.py
index 68e2a8b0..673bca1e 100644
--- a/.squad/tools/analyzer_common.py
+++ b/.squad/tools/analyzer_common.py
@@ -1,7 +1,8 @@
 """Helpers shared by the profiles' analyzer gates (`analyzer-check*.py`): git access with a fixed base, and the
 lint pass over changed files no stack analyzer covers — shell scripts (shellcheck), GitHub workflows
 (actionlint) and Dockerfiles (hadolint), plus two SonarQube Cloud shell rules shellcheck does not report
-(`shelldre:S7679`, `shelldre:S7688`). The SessionStart hook installs the three linters
+(`shelldre:S7679`, `shelldre:S7688`), and the control-character check `scope-check.py` and `plan-check.py`
+share. The SessionStart hook installs the three linters
 (`.claude/hooks/install-linters.sh`); a missing one is reported as NOT RUN, never as a pass.
 
 Written by adopt-template. The gates accept one flag, `--lint-only`, and no value: it runs this lint pass alone,
@@ -13,6 +14,7 @@
 import shutil
 import subprocess
 import sys
+import unicodedata
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import squad_settings as settings  # noqa: E402  (per-repository settings next to this script)
@@ -30,6 +32,8 @@
 SINGLE_BRACKET = re.compile(r"(?<![^\s;(!&|])\[\s")
 # `name() {`, `function name {` and `function name() {`; a bare `name {` is not bash, so matching it costs nothing.
 FUNCTION_HEAD = re.compile(r"^\s*(?:function\s+)?[\w.-]+\s*(?:\(\)\s*)?\{")
+CONTROL_CATEGORIES = {"Cc", "Cf", "Zl", "Zp"}
+CONTROL_KEEP = {"\t", "\n", "\r"}
 RULES = {"S7679": "assign this positional parameter to a local variable (shelldre:S7679)",
          "S7688": "use [[ … ]] instead of [ … ] (shelldre:S7688)"}
 
@@ -38,6 +42,13 @@ def git(*args):
     return subprocess.run(["git", *args], capture_output=True, text=True, check=True).stdout
 
 
+def control_characters(text):
+    """The control characters in the text (Unicode categories Cc, Cf, Zl, Zp other than tab and line break), as
+    sorted `U+XXXX` names: a Write tool can turn an escape into the character itself."""
+    return sorted({f"U+{ord(ch):04X}" for ch in text if unicodedata.category(ch) in CONTROL_CATEGORIES
+                   and ch not in CONTROL_KEEP})
+
+
 def merge_base():
     """The merge base of BASE_REF and HEAD; a missing base ref is a clear error, not a traceback."""
     result = subprocess.run(["git", "merge-base", BASE_REF, "HEAD"], capture_output=True, text=True, check=False)
diff --git a/.squad/tools/decision-check.py b/.squad/tools/decision-check.py
index 90dc1e5b..a46a2653 100644
--- a/.squad/tools/decision-check.py
+++ b/.squad/tools/decision-check.py
@@ -13,7 +13,10 @@
   renamed record leaves no stale link behind;
 - once `docs/areas/README.md` lists areas, every area links an existing document in `docs/areas/` and every
   record has an `Area:` field naming a listed area, or `—` for a record about no area (a repository without
-  areas is not checked for this);
+  areas is not checked for this). A released record without the field, which can no longer be edited, takes
+  its area from a `## Area assignment` table (`| Record | Area |`) in a later record instead; it fails when no
+  table names it, two tables disagree or the area is not listed. A table naming a record that has its own
+  `Area:` field, or no record at all, fails as well;
 - a record is *released* once the commit that added it is contained in a release tag (`v*`). A released
   record is never deleted and never changed except for its status becoming `Superseded by NNNN`; an
   unreleased record is never `Superseded` (it is edited in place or deleted instead).
@@ -36,11 +39,13 @@
 DECISIONS_DIR = os.path.join("docs", "decisions")
 AREAS_DIR = os.path.join("docs", "areas")
 NO_AREA = "\u2014"
+AREA_FIELD = "'- **Area:**' line"
 RECORD_NAME = re.compile(r"^(\d{4})-.+\.md$")
 STATUS_LINE = re.compile(r"^- \*\*Status:\*\*(.*)$", re.MULTILINE)
 SUPERSEDES_LINE = re.compile(r"^- \*\*Supersedes:\*\*(.*)$", re.MULTILINE)
 AREA_LINE = re.compile(r"^- \*\*Area:\*\*(.*)$", re.MULTILINE)
 AREA_INDEX_BLOCK = re.compile(r"<!-- project:begin area-index -->(.*?)<!-- project:end area-index -->", re.DOTALL)
+ASSIGNMENT_SECTION = re.compile(r"^## Area assignment[ \t]*\n((?:(?!^## ).)*)", re.MULTILINE | re.DOTALL)
 AREA_LINK = re.compile(r"^\[([^\]]+)\]\(([^)]+\.md)\)$")
 SUPERSEDED_BY = re.compile(r"^Superseded by (\d{4})$")
 NUMBER = re.compile(r"\b(\d{4})\b")
@@ -89,11 +94,23 @@ def load_records(root, errors):
             errors.append(f"{rel}: number {number} is used twice")
         records[number] = {"rel": rel, "status": status, "text": text,
                            "area": area.group(1).strip() if area else None,
+                           "assigns": parse_assignments(text),
                            "supersedes": list(dict.fromkeys(NUMBER.findall(plain(supersedes.group(1)))))
                            if supersedes else []}
     return records
 
 
+def parse_assignments(text):
+    """(number, area) for every `| NNNN | Area |` row of the record's `## Area assignment` section."""
+    section = ASSIGNMENT_SECTION.search(text)
+    rows = []
+    for line in section.group(1).splitlines() if section else []:
+        cells = [plain(cell) for cell in line.strip().split("|")]
+        if len(cells) == 4 and not cells[0] and not cells[-1] and INDEX_NUMBER.match(cells[1]):
+            rows.append((cells[1], cells[2]))
+    return rows
+
+
 def check_links(records, errors):
     for number, record in records.items():
         for older in record["supersedes"]:
@@ -196,16 +213,52 @@ def load_areas(root, errors):
     return areas
 
 
-def check_areas(root, records, errors):
+def collect_assignments(records, errors):
+    """Number -> {area: rel of each record whose `## Area assignment` table gives it that area}."""
+    assigned = {}
+    for record in records.values():
+        for number, area in record["assigns"]:
+            target = records.get(number)
+            if target is None:
+                errors.append(f"{record['rel']}: Area assignment names {number}, which does not exist")
+            elif target["area"] is not None:
+                errors.append(f"{record['rel']}: Area assignment names {number}, which has its own "
+                              f"{AREA_FIELD}")
+            else:
+                assigned.setdefault(number, {}).setdefault(area, []).append(record["rel"])
+    return assigned
+
+
+def assigned_area(number, record, assignments, released, errors):
+    """The area a released record without `Area:` takes from an `## Area assignment` table, or None."""
+    rel = record["rel"]
+    if released is not None and number not in released:
+        errors.append(f"{rel}: no {AREA_FIELD} (an area from {AREAS_DIR}/README.md, or {NO_AREA} for a "
+                      f"record about no area)")
+        return None
+    if not assignments:
+        errors.append(f"{rel}: released without a {AREA_FIELD} and no '## Area assignment' table in a "
+                      f"later record names it")
+        return None
+    if len(assignments) > 1:
+        sources = "; ".join(f"'{area}' in {', '.join(rels)}" for area, rels in assignments.items())
+        errors.append(f"{rel}: Area assignment tables disagree: {sources}")
+        return None
+    return next(iter(assignments))
+
+
+def check_areas(root, records, released, errors):
+    """`released` is the set of released record numbers, or None when it is unknown (no Git
+    history, or release tags not fetched)."""
     areas = load_areas(root, errors)
     if not areas:
         return
-    for record in records.values():
+    assigned = collect_assignments(records, errors)
+    for number, record in records.items():
         area = record["area"]
         if area is None:
-            errors.append(f"{record['rel']}: no '- **Area:**' line (an area from {AREAS_DIR}/README.md, or "
-                          f"{NO_AREA} for a record about no area)")
-        elif area != NO_AREA and area not in areas:
+            area = assigned_area(number, record, assigned.get(number, {}), released, errors)
+        if area is not None and area != NO_AREA and area not in areas:
             errors.append(f"{record['rel']}: area '{area}' is not listed in {AREAS_DIR}/README.md")
 
 
@@ -255,21 +308,25 @@ def check_deleted(root, tags, records, errors):
 
 
 def check_freeze(root, records, errors, warnings):
+    """Checks the released records and returns their numbers; None when that cannot be told."""
     if git(root, "rev-parse", "--git-dir") is None:
         warnings.append("not a Git repository - released records are not checked")
-        return
+        return None
     tags = (git(root, "tag", "--list", RELEASE_TAGS) or "").split()
     if not tags:
         if (git(root, "remote") or "").strip():
             warnings.append(f"no local '{RELEASE_TAGS}' tags although a remote is configured - released records "
                             f"are not checked (run 'git fetch origin main --tags')")
-        return
+            return None
+        return set()
     if (git(root, "rev-parse", "--is-shallow-repository") or "").strip() == "true":
         warnings.append("shallow clone - released records are not checked (fetch the full history and tags)")
-        return
-    for number, tag in find_released(root, records, errors).items():
+        return None
+    released = find_released(root, records, errors)
+    for number, tag in released.items():
         check_released_record(root, records[number], tag, errors)
     check_deleted(root, tags, records, errors)
+    return set(released)
 
 
 def main():
@@ -279,8 +336,8 @@ def main():
     check_links(records, errors)
     check_record_links(root, records, errors)
     check_index(root, records, errors)
-    check_areas(root, records, errors)
-    check_freeze(root, records, errors, warnings)
+    released = check_freeze(root, records, errors, warnings)
+    check_areas(root, records, released, errors)
     for warning in warnings:
         print(f"WARNING: {warning}")
     for error in errors:
diff --git a/.squad/tools/plan-check.py b/.squad/tools/plan-check.py
index 886d924d..31fd2266 100644
--- a/.squad/tools/plan-check.py
+++ b/.squad/tools/plan-check.py
@@ -14,14 +14,22 @@
   another form is reported; every scenario and edge case `E<n>` is named by a criterion or listed under *Out of
   scope*; every open question is answered (`Answered:`) or the section says "none"; `plan.md` defines no
   criterion of its own; every criterion of the spec has a row in the plan's *Tests per criterion* and appears in
-  the *Criteria* column of `tasks.md` (every table of it), and neither names a criterion the spec lacks.
+  the *Criteria* column of `tasks.md` (every table of it), and neither names a criterion the spec lacks; every
+  task row names its *Group* (the unit steps 4–6 run as one launch per member), and a group's rows are
+  consecutive; when the plan's *Signatures* lists any API, every group has a *Skeleton* row (its *Task* cell
+  starts with "Skeleton") or a row saying "no new API", a group the Lead owns alone excepted, and every name in
+  *Signatures* (the identifier of each backticked declaration) appears in a skeleton row of some group.
 - **Bug fix** (no `spec.md`): `plan.md` defines its acceptance criteria, and each has a row in *Tests per
   criterion* (tier `trivial`, which writes no tests first, needs none).
 - **Both:** the *Tier* line names exactly one tier, and the *Security areas touched* line says "none" or lists
   them (it decides the Security plan review); *Verified facts* has at least
   one row, and every row has evidence and a status (`confirmed`, `refuted`, or `unverified` with the measurement
-  that settles it, starting with `to verify:`); no template placeholder is left. A plan longer than `PLAN_MAX_WORDS`
-  (`squad_settings.py`, default 4000) is reported as a warning: a long plan costs every member that reads it.
+  that settles it, starting with `to verify:`); no template placeholder is left; no Markdown file of the work
+  folder contains a control character (`scope-check.py`'s check, here before any member reads the folder). A
+  plan longer than `PLAN_MAX_WORDS` (`squad_settings.py`, default 4000) is reported as a warning, one longer than
+  `PLAN_HARD_WORDS` (default twice that) as a finding: a long plan costs every member that reads it, so the
+  Lead moves settled material (answered challenge entries, facts verified in earlier rounds) into the decision
+  record or the area document.
 
 Ids may be written as ranges (`AC1–AC3`, `S2-S4`); backticks and emphasis around a cell are ignored. A criterion
 without a test, in a plan whose *Verification without tests* section names it, counts as covered.
@@ -39,8 +47,10 @@
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import squad_settings as settings  # noqa: E402  (per-repository settings next to this script)
+from analyzer_common import control_characters  # noqa: E402  (shared helpers next to this script)
 
 PLAN_MAX_WORDS = getattr(settings, "PLAN_MAX_WORDS", 4000)
+PLAN_HARD_WORDS = getattr(settings, "PLAN_HARD_WORDS", 2 * PLAN_MAX_WORDS)
 TIERS = ("trivial", "standard", "security")
 STATUSES = ("confirmed", "refuted", "unverified")
 SPEC_SECTIONS = ["Problem", "Scenarios", "Errors and edge cases", "Non-functional requirements",
@@ -60,6 +70,12 @@
 EMPHASIS = "`*_"
 SPEC = "spec.md"
 NONE = re.compile(r"^\s*(?:[-*]\s+)?none\.?\s*$", re.I)
+SKELETON_ROW = re.compile(r"^skeleton\b", re.I)
+NO_NEW_API = re.compile(r"\bno new API\b", re.I)
+SPAN = re.compile(r"`([^`\n]+)`")
+DECLARATION_KEYWORDS = {"func", "def", "fn", "public", "private", "protected", "internal", "static", "const",
+                        "readonly", "final", "async", "export", "function", "type", "class", "struct", "record",
+                        "interface", "enum", "var", "let", "val", "abstract", "override"}
 TOP_ITEM = re.compile(r"^(?:[-*]|\d+[.)])\s+")
 
 
@@ -237,14 +253,87 @@ def check_facts(plan_parts, errors):
             errors.append(f"plan.md: unverified claim without `to verify:` and its measurement: {claim}")
 
 
-def check_tasks(tasks, criteria, errors):
-    named, found_column = set(), False
+def check_groups(header, rows, errors):
+    """Every task row names its group, and a group's rows are consecutive: steps 4–6 run one group at a time, as
+    one launch per member, in table order."""
+    index = column(header, "group")
+    if index is None:
+        errors.append("tasks.md: a task table without a *Group* column (steps 4–6 run per task group)")
+        return
+    seen, previous = set(), None
+    for row in rows:
+        group = row[index] if len(row) > index else ""
+        if empty(group):
+            errors.append(f"tasks.md: task without a group: | {' | '.join(row)} |")
+            continue
+        if group != previous and group in seen:
+            errors.append(f"tasks.md: the rows of group {group} are not consecutive")
+        seen.add(group)
+        previous = group
+
+
+def signatures_section(plan):
+    parts = sections(plan)
+    return next((body for name, body in parts.items() if name.startswith("Signatures")), "")
+
+
+def signature_names(body):
+    """The identifier of every backticked declaration in the plan's *Signatures* section (`Options.Kernel` and
+    `func (o *Options) Kernel() string` give `Kernel`); a "none" section gives none."""
+    names = []
+    for span in SPAN.findall(COMMENT.sub("", body or "")):
+        call = re.search(r"([A-Za-z_]\w*)\s*\(", span)
+        words = [w for w in re.findall(r"[A-Za-z_][\w.]*", span) if w not in DECLARATION_KEYWORDS]
+        name = words[0].split(".")[-1] if words else ""
+        if call:
+            name = call.group(1)
+        if name and name not in names:
+            names.append(name)
+    return names
+
+
+def group_states(header, rows):
+    """{group: (skeleton or "no new API" stated, owned by the Lead alone)} and the text of the skeleton rows."""
+    group, task, owner = column(header, "group"), column(header, "task"), column(header, "owner")
+    states, skeleton = {}, []
+    for row in rows:
+        if group is None or task is None or len(row) <= max(group, task):
+            continue
+        text = " ".join(row)
+        is_skeleton = bool(SKELETON_ROW.match(row[task]))
+        stated, lead_only = states.get(row[group], (False, True))
+        lead = owner is not None and len(row) > owner and row[owner].lower() == "lead"
+        states[row[group]] = (stated or is_skeleton or bool(NO_NEW_API.search(text)), lead_only and lead)
+        if is_skeleton:
+            skeleton.append(text)
+    return states, "\n".join(skeleton)
+
+
+def check_skeleton(header, rows, signatures, errors):
+    """With API in the plan's *Signatures*, every group has a skeleton row or says "no new API" (a group of the
+    Lead alone writes documentation), and every signature name appears in a skeleton row. Returns the text of the
+    skeleton rows."""
+    states, skeleton = group_states(header, rows)
+    for key, (stated, lead_only) in states.items():
+        if signatures and not (stated or lead_only or empty(key)):
+            errors.append(f"tasks.md: group {key} has no *Skeleton* row and does not say \"no new API\" "
+                          "(the plan's *Signatures* lists API)")
+    return skeleton
+
+
+def check_tasks(tasks, criteria, errors, signatures=()):
+    named, found_column, skeleton = set(), False, ""
     for header, rows in tables(tasks):
         index = column(header, "criteria", "criterion", "tests (ac)", "ac")
         if index is None:
             continue
         found_column = True
         named |= {i for row in rows if len(row) > index for i in ids(row[index], "AC")}
+        check_groups(header, rows, errors)
+        skeleton += check_skeleton(header, rows, signatures, errors)
+    for name in signatures:
+        if not re.search(rf"(?<!\w){re.escape(name)}(?!\w)", skeleton):
+            errors.append(f"tasks.md: the plan's signature `{name}` is named by no skeleton row of any group")
     if not found_column:
         errors.append("tasks.md: no table with a *Criteria* column")
     for criterion in sorted(criteria - named):
@@ -298,12 +387,25 @@ def check_spec_only(folder):
         return ["spec.md is missing"], []
     check_spec(spec, errors)
     check_placeholders(SPEC, spec, errors)
+    check_control_characters(folder, errors)
     return errors, []
 
 
+def check_control_characters(folder, errors):
+    """No Markdown file of the work folder carries a control character: `scope-check.py` would reject it only in
+    the docs step, after every member has read the plan."""
+    for name in sorted(os.listdir(folder)):
+        path = os.path.join(folder, name)
+        if name.endswith(".md") and os.path.isfile(path):
+            found = control_characters(read(path, []) or "")
+            if found:
+                errors.append(f"{name}: control characters {', '.join(found)} (write them as text escapes)")
+
+
 def check(folder):
     """All findings for the work folder, and the warnings."""
     errors, warnings = [], []
+    check_control_characters(folder, errors)
     plan = read(os.path.join(folder, "plan.md"), errors)
     spec = read(os.path.join(folder, SPEC), errors)
     if plan is None:
@@ -317,10 +419,14 @@ def check(folder):
         if tasks is None:
             errors.append("tasks.md is missing")
         else:
-            check_tasks(tasks, criteria, errors)
+            check_tasks(tasks, criteria, errors, signature_names(signatures_section(plan)))
             check_placeholders("tasks.md", tasks, errors)
     words = len(plan.split())
-    if words > PLAN_MAX_WORDS:
+    if words > PLAN_HARD_WORDS:
+        errors.append(f"plan.md has {words} words (PLAN_HARD_WORDS {PLAN_HARD_WORDS}): move settled material "
+                      "(answered challenge entries, facts verified in earlier rounds) into the decision record "
+                      "or the area document")
+    elif words > PLAN_MAX_WORDS:
         warnings.append(f"plan.md has {words} words (PLAN_MAX_WORDS {PLAN_MAX_WORDS}): every member reads it — "
                         "cut what the code, the spec or a decision record already says")
     return errors, warnings
diff --git a/.squad/tools/scope-check.py b/.squad/tools/scope-check.py
index e9844e30..34268ba0 100644
--- a/.squad/tools/scope-check.py
+++ b/.squad/tools/scope-check.py
@@ -36,10 +36,9 @@
 import re
 import subprocess
 import sys
-import unicodedata
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from analyzer_common import BASE_REF, git, merge_base, settings  # noqa: E402  (shared helpers next to this script)
+from analyzer_common import BASE_REF, control_characters, git, merge_base, settings  # noqa: E402  (shared helpers next to this script)
 
 SQUAD_FILES_ALLOWED = {".squad/stack.md", ".squad/project.md"}
 INSTRUCTION_FILES = {"AGENTS.md", "CLAUDE.md", ".github/copilot-instructions.md"}
@@ -50,8 +49,6 @@
 DOCS_TIER_DIRS = ["docs/"]
 DOCS_TIER_EXCLUDED = ["docs/decisions/", "docs/areas/"]
 PROJECT_BLOCK = re.compile(r"<!-- project:begin ([\w-]+) -->\n.*?<!-- project:end \1 -->\n?", re.S)
-CONTROL_CATEGORIES = {"Cc", "Cf", "Zl", "Zp"}
-KEEP = {"\t", "\n", "\r"}
 PATCH_MAX_LINES = getattr(settings, "PATCH_MAX_LINES", 30)
 
 
@@ -95,16 +92,10 @@ def marked_file_changed_outside_blocks(path, base):
     return outside_blocks(before.stdout.lstrip("")) != outside_blocks(read_text(path))
 
 
-def control_characters(path):
-    text = read_text(path)
-    return sorted({f"U+{ord(ch):04X}" for ch in text if unicodedata.category(ch) in CONTROL_CATEGORIES
-                   and ch not in KEEP})
-
-
 def control_character_error(path):
     if not path.endswith(".md") or not os.path.isfile(path):
         return None
-    found = control_characters(path)
+    found = control_characters(read_text(path))
     return f"{path}: control characters {', '.join(found)} (write them as text escapes)" if found else None
 
 
diff --git a/.squad/tools/squad-log.py b/.squad/tools/squad-log.py
index 74b013f2..41a7c72d 100644
--- a/.squad/tools/squad-log.py
+++ b/.squad/tools/squad-log.py
@@ -30,7 +30,10 @@
   each in a fresh launch), `--continued-from "<step>"` names the step cell of the fresh launch whose agent was
   continued: only that launch and its own continuations are subtracted, and the trailer records the step
   (`· continued from <step>`), so a later continuation of either agent is computed against the right rows.
-  `--continued` needs an earlier row of that member with usage, `--continued-from` a fresh launch of that step;
+  `--continued` needs an earlier row of that member with usage, `--continued-from` a fresh launch of that step.
+  A continuation logged at another step number than the fresh launch it continues prints a warning, unless its
+  step cell names a fix, delta or revise round: the first launch of another mode (`skeleton` to `implement`,
+  `tests-first` to `coverage`, `approve-pr`, `decide`) is a fresh launch, not a continuation;
 - the usage block often arrives only after the member's hand-back: `--amend-last MEMBER` with the same
   options adds the trailer to the last row of that member afterwards, so the row can be written as soon as
   the report is in. A row gets its trailer once (a pending one is completed); a second amend is refused. When a
@@ -38,8 +41,10 @@
   came last), `--step "<step>"` selects the last row of the member whose step cell is that text, so an earlier launch row
   is still amended with the tool, never by hand;
 - a row whose trailer is wrong (a launch logged with made-up numbers before its notification arrived) is
-  corrected with `--replace-last MEMBER` and the same options (`--step` selects an earlier row the same way):
-  the trailer of that row is replaced, so the launch is still counted once;
+  corrected with `--replace-last MEMBER` and the same options (`--step` selects an earlier row the same way,
+  also when other rows of the member follow): the trailer of that row, a pending one too, is replaced, so the
+  launch is still counted once. A notification repeated for one task id is no new launch: only the latest
+  numbers of the id are logged, on the same row;
 - a launch whose notification never arrived is marked with `--amend-last MEMBER --unreported --agent
   squad-<role>` (no numbers): the trailer `(opus/medium · usage not reported)` lets the summary count the
   launch, name it as unreported and exit 0, so the table is posted as the tool prints it instead of being
@@ -55,6 +60,11 @@
   model and effort, the summary lists it as incomplete, and `--amend-last` with the numbers completes it — the
   only way to add the numbers later.
 
+- `--stdin` reads the log from standard input instead of `specs/<folder>/log.md`, for the rows after step 10
+  of `squad-issue` removed the folder: pipe the log table of the "Squad working record" comment in, the result
+  of the command goes to standard error and the whole updated log to standard output (paste it back into the
+  comment); `--summary --stdin` prints the summary of that log, nothing is written to the repository;
+
 Usage, from anywhere inside the repository:
     python3 .squad/tools/squad-log.py <work folder> <step> <member> <result> [--agent squad-lead
         --tokens 37445 --tool-uses 6 --seconds 57]
@@ -71,6 +81,8 @@
     python3 .squad/tools/squad-log.py <work folder> "7 Fix" Dev "fixed" --agent squad-dev --tokens 412000
         --tool-uses 9 --seconds 317 --continued-from "6 Implement (rows 9-14)"
     python3 .squad/tools/squad-log.py <work folder> --summary
+    python3 .squad/tools/squad-log.py <work folder> "11 CI" Dev "fixed" --agent squad-dev --tokens 41200
+        --tool-uses 9 --seconds 80 --stdin < log-from-comment.md > log-updated.md
 
 `<work folder>` is the folder's name under `specs/` (`issue-12`, or `specs/issue-12`); it is matched against the
 folders that exist there, never used as a path, so no argument reaches the file system; `--agent` is matched
@@ -89,11 +101,13 @@
 step), 3 when the summary lists launch rows without usage.
 """
 import argparse
+import contextlib
 import datetime
 import os
 import re
 import subprocess
 import sys
+import tempfile
 import unicodedata
 
 CONTROL_CATEGORIES = {"Cc", "Cf", "Zl", "Zp"}
@@ -113,6 +127,8 @@
 ROW = re.compile(rf"^\| (?P<date>{STAMP}) \| (?P<step>(?:[^|\\]|\\\|)*) \| (?P<member>(?:[^|\\]|\\\|)*) \| "
                  r"(?P<result>.*) \|\s*$")
 MIN_TOKENS = 1000
+STEP_NUMBER = re.compile(r"^\s*(\d+)")
+ROUND_OF_SAME_MODE = re.compile(r"\b(?:fix|delta|revis)", re.I)
 FRONT_MATTER_KEY = re.compile(r"^(model|effort):\s*(\S+)\s*$", re.M)
 
 
@@ -181,10 +197,10 @@ def previous_tokens(path, member, skip_last=False, step=None, origin=None):
 
 
 def rows_before(rows, member, step):
-    """The rows before the last row of `member` whose step cell is `step` (both already escaped as cells); all
-    rows when there is no such row."""
+    """The rows before the last row of `member` whose step cell is `step` (both already escaped as cells; with
+    `step` None, the member's last row); all rows when there is no such row."""
     for index in range(len(rows) - 1, -1, -1):
-        if rows[index][2] == member and rows[index][1] == step:
+        if rows[index][2] == member and (step is None or rows[index][1] == step):
             return rows[:index]
     return rows
 
@@ -200,6 +216,32 @@ def continued_launch(path, member, launch, skip_last=False, step=None, origin=No
     return (model, tokens - earlier if tokens >= earlier else tokens, tool_uses, seconds, True, origin)
 
 
+def mode_change_warning(path, member, own_step, origin=None, amending=False, step=None):
+    """A warning, or None, for a continuation logged at another step number than the fresh launch it continues
+    (`origin`, or else the member's last fresh launch) whose step cell names no fix, delta or revise round: the
+    first launch of another mode is a fresh launch (`.squad/routing.md`, *Continuing a member*). With `amending`,
+    the row being amended (the member's last, or its last of `step`) is left out."""
+    with open(path, encoding="utf-8-sig") as handle:
+        rows = parse_rows(handle.read())
+    wanted = cell(member)
+    if amending:
+        rows = rows_before(rows, wanted, None if step is None else cell(step))
+    fresh = [row_step for _, row_step, row_member, result in rows if row_member == wanted
+             and TRAILER.search(result) and not TRAILER.search(result).group("continued")]
+    if origin is not None:
+        continued = cell(origin)
+    elif fresh:
+        continued = fresh[-1]
+    else:
+        continued = None
+    numbers = [STEP_NUMBER.match(text or "") for text in (continued, own_step)]
+    if None in numbers or numbers[0].group(1) == numbers[1].group(1) or ROUND_OF_SAME_MODE.search(own_step):
+        return None
+    return (f"WARNING: '{own_step}' continues {member}'s launch of step '{continued}': a fix, delta or revise "
+            "round continues, but the first launch of another mode is a fresh launch (.squad/routing.md, "
+            "*Continuing a member*)")
+
+
 def resolve_log(root, folder):
     """The `log.md` of the named work folder under `specs/`, or None. The name is compared with the folders
     that exist there and the path is built from the directory listing, so the argument never becomes a path."""
@@ -241,29 +283,29 @@ def agent_launch(root, agent):
 
 def amendable(result, replace):
     """(True, the trailer match or None) when the row may take a new trailer: one without a trailer or with a pending
-    one is amended; one with a full or an unreported trailer is replaced (a pending one is amended, not replaced)."""
+    one is amended; one with any trailer, a pending one included, is replaced."""
     old = ANY_TRAILER.search(result)
     pending = bool(PENDING_TRAILER.search(result))
     if replace:
-        return bool(old) and not pending, old
+        return bool(old), old
     return (not old or pending), old
 
 
-def target_result(path, member, step=None):
-    """The result cell of the row `--amend-last`/`--replace-last` would change, or None."""
+def target_row(path, member, step=None):
+    """(step cell, result cell) of the row `--amend-last`/`--replace-last` would change, or (None, None)."""
     with open(path, encoding="utf-8-sig") as handle:
         rows = parse_rows(handle.read())
     wanted, wanted_step = cell(member), None if step is None else cell(step)
     for _, row_step, row_member, result in reversed(rows):
         if row_member == wanted and (wanted_step is None or row_step == wanted_step):
-            return result
-    return None
+            return row_step, result
+    return None, None
 
 
 def amend_last(path, member, launch, replace=False, step=None):
     """Add the launch trailer to the last row of `member` (with `step`, to its last row of that step); the amended
     row, or None when no such row exists or it already carries a trailer (a pending one is completed). With
-    `replace`, that trailer is replaced instead; a row without one, or with a pending one, is left alone (None)."""
+    `replace`, that trailer is replaced instead; a row without one is left alone (None); a pending one is replaced too."""
     with open(path, "rb") as handle:
         data = handle.read()
     eol = b"\r\n" if b"\r\n" in data else b"\n"
@@ -452,6 +494,8 @@ def build_parser():
     parser.add_argument("--step", dest="at_step", metavar="STEP", help="with --amend-last or --replace-last: the "
                         "member's last row of this step instead of its last row (for a parallel launch whose "
                         "notification arrived after the next row was written)")
+    parser.add_argument("--stdin", action="store_true", help="read the log from standard input instead of "
+                        "specs/<folder>/log.md (step 10 removed the folder): the updated log goes to standard output")
     parser.add_argument("--unreported", action="store_true",
                         help="with --amend-last: the launch's task notification never arrived; the trailer marks "
                              "it as unreported (with --agent or --launch, without numbers)")
@@ -534,17 +578,19 @@ def amend_command(parser, path, folder, member, launch, replace, continued, step
         parser.error(f"{option} needs --agent (or --launch), --tokens, --tool-uses and --seconds (or --unreported)")
     if replace and launch[1] is None:
         parser.error("--unreported marks a row without a trailer: use it with --amend-last")
-    current = target_result(path, member, step) or ""
-    if replace and PENDING_TRAILER.search(current):
-        parser.error("the row's usage is still pending: add it with --amend-last, not --replace-last")
+    own_step, current = target_row(path, member, step)
+    current = current or ""
     # Only a replaced trailer with real numbers is part of the earlier usage a continuation subtracts.
     launch = share_of_round(path, member, launch, continued, replace and bool(TRAILER.search(current)), step, origin)
     if launch is None:
         return 1
+    warning = mode_change_warning(path, member, own_step, origin, True, step) if continued and own_step else None
     row = amend_last(path, member, launch, replace=replace, step=step)
     if row is None:
         print(no_row_message(folder, member, replace, step))
         return 1
+    if warning:
+        print(warning)
     print(row)
     return 0
 
@@ -571,19 +617,15 @@ def row_command(parser, path, args, launch):
     launch = share_of_round(path, args.member, launch, args.continued, origin=args.continued_from)
     if args.continued and launch is None:
         return 1
+    warning = mode_change_warning(path, args.member, cell(args.step), args.continued_from) if args.continued else None
+    if warning:
+        print(warning)
     print(append_row(path, args.step, args.member, args.result, launch=launch))
     return 0
 
 
-def main():
-    parser = build_parser()
-    args = parser.parse_args()
-    toplevel = subprocess.run(["git", "rev-parse", "--show-toplevel"], capture_output=True, text=True, check=False)
-    root = toplevel.stdout.strip() if toplevel.returncode == 0 else os.getcwd()
-    path = resolve_log(root, args.folder)
-    if path is None:
-        print(f"No log.md in {args.folder} (create it from specs/_template/log.md first)")
-        return 1
+def run(parser, args, root, path):
+    """The command the arguments ask for, against the log at `path`; the exit code."""
     if args.summary:
         print(summary(path))
         with open(path, encoding="utf-8-sig") as handle:
@@ -606,5 +648,37 @@ def main():
     return row_command(parser, path, args, launch)
 
 
+def run_on_stdin(parser, args, root):
+    """`--stdin`: the log comes from standard input and lives in a temporary directory only; a command that
+    changes it prints the result to standard error and the whole updated log to standard output."""
+    with tempfile.TemporaryDirectory() as directory:
+        path = os.path.join(directory, "log.md")
+        with open(path, "wb") as handle:
+            handle.write(sys.stdin.buffer.read())
+        if args.summary:
+            return run(parser, args, root, path)
+        with contextlib.redirect_stdout(sys.stderr):
+            code = run(parser, args, root, path)
+        if code == 0:
+            with open(path, "rb") as handle:
+                sys.stdout.buffer.write(handle.read())
+        return code
+
+
+def main():
+    parser = build_parser()
+    args = parser.parse_args()
+    toplevel = subprocess.run(["git", "rev-parse", "--show-toplevel"], capture_output=True, text=True, check=False)
+    root = toplevel.stdout.strip() if toplevel.returncode == 0 else os.getcwd()
+    if args.stdin:
+        return run_on_stdin(parser, args, root)
+    path = resolve_log(root, args.folder)
+    if path is None:
+        print(f"No log.md in {args.folder} (create it from specs/_template/log.md first; after step 10 of the "
+              "squad skills removed the work folder, pipe the working-record comment's log table in with --stdin)")
+        return 1
+    return run(parser, args, root, path)
+
+
 if __name__ == "__main__":
     sys.exit(main())
diff --git a/docs/decisions/README.md b/docs/decisions/README.md
index 7c8b642b..7a5ccaca 100644
--- a/docs/decisions/README.md
+++ b/docs/decisions/README.md
@@ -19,7 +19,9 @@ once in the [area document](../areas/README.md) of the record's area, and the re
   formats, limits, error texts) belong in the area document and are linked from the record.
 - The `Area:` field names the record's area as listed in [`docs/areas/README.md`](../areas/README.md), or `—`
   for a record about the process or about no area. Once areas are defined, every record needs the field. For a
-  released record it is part of the content: it changes only through a new record.
+  released record it is part of the content: it changes only through a new record. A released record without
+  the field gets its area from an `## Area assignment` table (`| Record | Area |`) in a new record; the
+  released record itself stays unedited.
 - Written by the squad Lead (see [`.claude/agents/squad-lead.md`](../../.claude/agents/squad-lead.md));
   anyone may add one for a change made outside the squad.
 - Committed together with the change it explains.
diff --git a/docs/decisions/_template.md b/docs/decisions/_template.md
index 17395202..f82f0cef 100644
--- a/docs/decisions/_template.md
+++ b/docs/decisions/_template.md
@@ -25,3 +25,12 @@ resulting behavior (values, formats, limits) go into the area document, linked h
 
 What becomes easier or harder, accepted limitations, follow-up issues, what would have to change to revisit
 this decision.
+
+## Area assignment
+
+Optional, only once areas are introduced: the area of each released record that has no `Area:` field (the
+released record stays unedited). Delete this section otherwise.
+
+| Record | Area |
+| ------ | ---- |
+| NNNN   | <area from docs/areas/README.md> \| — |
diff --git a/specs/_template/plan.md b/specs/_template/plan.md
index 0fc48811..c9bba1cb 100644
--- a/specs/_template/plan.md
+++ b/specs/_template/plan.md
@@ -53,6 +53,8 @@ read-only check). Otherwise delete this section.
 
 ## Approach
 
+<!-- New user-visible output: its layout, or "layout free for the Tester, approved in step 9" (squad-lead.md). -->
+
 ## Options considered
 
 Each alternative weighed and why it lost — or "one option: <why the fix is the only reasonable one>"
diff --git a/specs/_template/tasks.md b/specs/_template/tasks.md
index dfc8b9a2..7cc8c4a6 100644
--- a/specs/_template/tasks.md
+++ b/specs/_template/tasks.md
@@ -2,10 +2,10 @@
 
 Plan: [plan.md](plan.md) — Status: Draft | Approved
 
-Each task names the acceptance criteria of `spec.md` it delivers (`plan-check.py` reports a criterion no task
-covers) and the tasks it waits for; steps 4–6 run the task groups in this order. Every documentation edit is
-in exactly one row.
+Each task names its criteria, the tasks it waits for and its group (one launch per member in steps 4–6; rows
+consecutive). A group has a "Skeleton" row for its API in *Signatures*, or says "no new API". Each
+documentation edit is in one row.
 
-| # | Task | Files | Criteria | Depends on | Owner | Done |
-| - | ---- | ----- | -------- | ---------- | ----- | ---- |
-| 1 | … | … | AC1 | — | Dev / Tester | [ ] |
+| # | Group | Task | Files | Criteria | Depends on | Owner | Done |
+| - | ----- | ---- | ----- | -------- | ---------- | ----- | ---- |
+| 1 | G1 | … | … | AC1 | — | Dev / Tester | [ ] |