agentic-flow-kit 1.8.2 → 2.0.0

package/locales/en/overrides/.agents/skills/csharp-quality-gates/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: csharp-quality-gates
+description: C# backend quality gates — manual trigger entry for three deterministic gates — CRAP (complexity×coverage), mutation testing, duplicate code; built-in TEMP redirection for the local coverlet collection failure and discrimination of "is 0 coverage a collection fault or genuinely untested", report interpretation criteria, and test-backfill priority ordering; for questions like "is this change covered by tests / which methods should get tests first / is complexity or duplication over threshold / inventory the backend quality status". Command entry .agents/skills/csharp-quality-gates/scripts/quality-gates.mjs.
+---
+
+# csharp-quality-gates — C# backend quality gates (manual trigger)
+
+Backend code maps to ub-mode's three-stage discipline (Uncle Bob's crapper/dryer/mutator do not support C#, so this repo substitutes equivalents):
+
+| ub-mode gate | Uncle Bob original tool | This repo equivalent | Criterion |
+|---|---|---|---|
+| Crapper (Then Make it Right) | crapper | **dotnet-crap** (Crap4DotNet) | `CRAP = CC²×(1-cov)³+CC`, default threshold 30 |
+| Mutator (Then Make it Right) | mutator | **dotnet stryker** (Stryker.NET) | mutation score (killed/total) |
+| Dryer (Then Make it Right) | dryer | **PMD CPD** (`--language cs`) | structural duplication, token count |
+
+Below `qg` refers to `node .agents/skills/csharp-quality-gates/scripts/quality-gates.mjs`.
+
+## Trigger / do not trigger
+
+- **Trigger**: "backend quality status / does this change have test coverage / which methods need tests first / is complexity over threshold / any duplicate code / how to run mutation testing"; changes in `backend/` involving business logic; after completing a batch of tests wanting to verify "are the tests really testing".
+- **Do not trigger**: pure frontend changes (this repo's C# gates do not cover `frontend/`); only want to know "does it compile" (use `commit-check.config.json` build section); only want to know "do tests pass" (just `dotnet test`).
+- **Does not replace** the `verify` gate: this skill is a **manually triggered** diagnostic and inventory tool; it does not enter the commit gate and changes no gate configuration.
+
+## 0. Prerequisite probing
+
+```bash
+qg doctor
+```
+
+Prints item by item whether tools are in place: `dotnet` / `dotnet-crap` / `dotnet-stryker` / `pmd` / `java` / unit test project / solution. When missing, the script prints install commands:
+
+```bash
+dotnet tool install -g Crap4DotNet
+dotnet tool install -g dotnet-stryker
+# PMD: download pmd-dist-<ver>-bin.zip and extract to ~/.agents/tools/pmd/ (the level containing lib/ and conf/)
+```
+
+Actual machine paths are registered in `.agents/notes/runtime-env.local.md` (git-ignore, single-source discipline); the script resolves by `env var → known install location → PATH`, no hardcoded absolute paths.
+
+## 1. The three gates
+
+```bash
+qg coverage                 # run unit tests collecting coverage (TEMP redirection built in)
+qg crap [--threshold 30] [--top 15] [--min-crap N] [--coverage <absolute path>]
+qg dup [--minimum-tokens 100] [--top 10]
+qg mutate "<glob>"          # mutation testing, must be targeted
+qg all                      # coverage → crap → dup (no mutate, too slow)
+```
+
+Exit codes: `0` pass / `1` gate not met (methods over threshold, duplicate blocks, mutation score not met) / `2` usage·configuration·collection failure. **Exit code 2 is never "pass"**, it is "did not run".
+
+Artifacts land in `.agents/tmp/quality-gates/` (git-ignore): coverage XML, `crap-report.json`, Stryker report.
+
+## 2. Collection failure trap (known on this machine, must-read)
+
+**coverlet silently produces 0% coverage under the default TEMP on this machine.**
+
+- Symptom: tests all green, code genuinely calls production services, but cobertura has `lines-covered=0` — every class every line hits is 0.
+- Root cause: coverlet writes instrumented modules to `%TEMP%\<module name>_<guid>` before loading; the file is lost under default TEMP, testhost exits with an **unhandled** `FileNotFoundException` (process -532462766), hit data never reaches the report.
+- Criterion: tests clearly `new XxxService(...)` call production code, yet cobertura is all 0.
+- Fix: `qg coverage` already redirects `TEMP`/`TMP` to `.agents/tmp/quality-gates/tmp`; after redirection measured `lines-covered=23701/37805` (line-rate 0.6269).
+- **Script guard**: when `lines-valid>0 && lines-covered==0`, `coverage` **errors and exits 2**, producing no "zero coverage" conclusion; `crap` also refuses to run on such a file.
+
+> Two other dead ends on the same machine: `--collect:"Code Coverage"` (Microsoft.CodeCoverage) only produces a 0KB empty file; `/p:CollectCoverage=true` requires the `coverlet.msbuild` package (this repo only has `coverlet.collector`). **Do not spend more time on these two.**
+
+## 3. Report interpretation: first distinguish "collection broken" vs "code untested"
+
+Order cannot be reversed — first confirm collection is good, then discuss coverage.
+
+1. **Is collection trustworthy**: look at `qg coverage` output's `lines-covered`. 0 → collection failure (§2), fix collection first, **never treat 0% as a conclusion**.
+2. **CRAP table reading**: sort by CRAP worst to best; the top "both complex and uncovered" are the priority; **do not only look at CRAP absolute value** — a method with CC=2 but 100% coverage has CRAP=2, not a problem.
+3. **Mutation score reading**: a low score has two causes with completely different handling —
+   - (a) **tests ineffective**: few NoCoverage, low kill ratio → assertions too loose, tests pass but do not verify logic;
+   - **this repo empirically is (b)**: many NoCoverage (607/23274 mutants on code paths nobody tests) → **that path lacks tests**, not insufficiently strict assertions. Distinguish before acting.
+4. **Duplication detection reading**: PMD's `--minimum-tokens` is the similarity knob (default 100 ≈ dryer's 0.8 similarity tier); multiple hits within the same file prioritize structural duplication like "three places share the same helper" (`PurchaseOrderService.cs` 2026-10-31 baseline snapshot 451/775 lines, 62 lines/397 tokens; line numbers are baseline values, not current).
+
+## 4. Test-backfill priority
+
+**Criterion = zero coverage ∧ high CRAP**, not CRAP absolute value. The script already sorts by this (`qg crap` output's "zero coverage and over threshold" list).
+
+This repo 2026-10-31 baseline: 1622 total methods, **1264 zero coverage (78%)**, 323 over threshold, of which 319 are also zero coverage. Top:
+
+| Method | CC | CRAP |
+|---|---|---|
+| `PMLService.FinishMatchAsync` | 74 | 5550 |
+| `MaterialCodeImportService.PreviewAsync` | 58 | 3422 |
+| `OutboundOrderService.MatchAndLockCoreAsync` | 53 | 2862 |
+| `MaterialCodeService.CreateAsync` | 51 | 2652 |
+| `MaterialCodeImportService.ValidateImportRowsAsync` | 49 | 2450 |
+
+**Why 78% zero coverage**: services covered only by integration tests are blind spots at the regular tier — `tests/Shipyard.Material.IntegrationTests/` needs a DB; CI mid tier `backend-test` uses `--unit-only` (no test DB), full tier escapes via the shared dev DB because CI does not define `TEST_DB_CONN`. `ExchangeRateImportService` is typical: its only test is in the integration test project; replacing all Excel header strings with `""` in mutation testing still stays all green.
+
+Backfill directions are therefore two: **push DB-free pure logic down to unit tests** (Excel header/template generation, validation criteria), or **configure `TEST_DB_CONN` for CI** to run the real integration tier.
+
+## 5. Output format
+
+After the inventory, conclude in four sections:
+
+- **Current state**: numbers for each of the three gates (coverage line-rate / CRAP over-threshold count and share / duplicate block count / mutation score), noting whether collection is trustworthy.
+- **Risk**: top N methods sorted by "zero coverage ∧ high CRAP", with `file` location.
+- **Cause**: distinguish "tests ineffective" from "code untested"; if the latter, point out the blind-spot source (integration test tier / DB dependency / pure logic not pushed down).
+- **Next steps**: specific to "which method gets which test"; do not stop at "recommend raising coverage".
+
+## 6. This repo's placement and boundaries
+
+- Gate single source: `.agents/hooks/commit-check.config.json` (build section = `dotnet build Shipyard.Material.sln`; **checks section is currently empty**, local commit gate does not run tests). This skill **does not change** this file.
+- Interface with ub-mode: First Make it Work → add tests (give TDD a landing point); Then Make it Right → three gates; Practice → Keep a Log (this skill's conclusions are material for the decision log).
+- Interface with `review-method`: when reviewing a diff, "impact-surface proof" can use this skill's dup/crap as machine evidence.
+- Boundaries: run only the **unit test project** (integration tests need a DB, this machine without DB will hang); Stryker **must be targeted** (full 20k+ mutants unacceptable); write no repository files (except this skill's own directory); do not commit code.

package/locales/en/overrides/.agents/skills/dev-tour/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: dev-tour
+description: Turn spec/plan steps and changed files into an interactive development tour (overview/timeline/data flow/flow diagrams + file tree + change notes on the right). Used for the AI-Native development gap where "the document explains it but you cannot see which files change".
+---
+
+# Development tour (Dev Tour)
+
+## Goal
+Turn "steps × changed files" in workflow documents into a clickable map: left file tree (added/modified/planned badges), center overview/timeline/data-flow/flow diagrams, right per-step change notes and diff. Solves the gap "spec/plan reads fine but you do not know which file the AI is changing".
+
+## Trigger conditions
+- After drafting/confirming a plan (`## 任务拆解` or `## 步骤` + `## 改动方案` persisted) → run `auto-tour.mjs` to auto-start the dashboard and produce a live link.
+- Refresh once after each batch / task completed in Build stage.
+- Before close-out, do scope reconciliation: "actual changes outside the document" appearing in the map must first be explained or backfilled into the plan.
+- User says "can't see which files are changed" "show me the timeline/flow/overview".
+
+## Data contract (write documents this way)
+The generator does not create a separate ledger; it reads documents + git directly:
+
+1. **Steps** (priority high to low)
+   - `## 步骤`: `1. **T1 title**: one-sentence description`
+   - `## 任务拆解`: `- [ ] 1. title` + indented `- 文件：path` / `- 判据：…` / `- 留痕：…`; or `### T1 · title` subheadings (body detail lines close with the step). **Each implementation step has at least one file; pure verification steps state `验证步骤` in the title**
+   - `### 批次 0a：…` headings under `## 改动面` / `## 改动方案`
+   - If none: group by the architecture layer the file belongs to (**layer fallback = parse failure signal**; generator prints a "parse hits" line and the page top shows a warning bar; normalize headings then regenerate; `--strict` rejects production with exit 1)
+2. **Per-step files**
+   - In `## 改动方案` align with step numbers using `- **T1**：` or `### T1`, write backticked paths inside the block.
+   - L1 single-file plans may write `- \`backend/.../Foo.cs\`：what to do` directly in `## 改动方案`; each top-level file entry automatically becomes one station.
+   - Write full paths when possible; only writing `detail.vue` / `MaterialCodePushService.cs` also resolves by same-named repo file and step context, but full paths are most reliable. With multiple same-name candidates the generator scores by step context and guesses one: that file entry carries a `pathGuess` flag (page shows a "guess?" uncertainty badge), hit line counts "path guesses Z"; a unique basename hit is deterministic and not counted as a guess.
+   - Non-backticked mid-path tokens with code extensions and resolvable paths are also collected: bare tokens like `pml/index.vue` in step titles/body/table rows (containing `/` + a known code extension + resolvable to a real repo file) enter the model and are assigned to their step; mixed tokens (`if/else` etc.) are always rejected. When unbound files are assigned by body fallback (basename or layer-word arm) they all get `pathGuess`; the layer-word arm binds only when exactly one step body contains that layer word; ambiguous ones stay unbound and visible as "unassigned".
+   - Table row paths are also collected: `| \`path\` | description |` rows in `## 改动方案` are assigned to the current block/batch anchor (including tables inside `### 批次` subsections); without an anchor they go to "change surface (unassigned)". Task row labels support union-style `1. S1+S2：title` (block anchor matched by member intersection; parenthetical `（**S3**）` also anchors); resolution never fabricates — directory back-inference/anchor splicing must land on real repo files; unresolved paths remain as visibly unresolved.
+3. **Test files**: write in `## 验证计划` or the corresponding step; test steps close automatically.
+4. **Dependencies** (optional, side-arc data source for the flow diagram)
+   - Clause lines in `## 执行顺序` like `依赖：3 依赖 1；4/5 依赖 2 与 3；8 依赖 4~7；10 依赖全部` (arrow chain lines `1 → 2 → 3` are expressed by the main chain itself and do not produce duplicate edges).
+   - Or in task lines `- 依赖：T1、T2`.
+   - Numbers normalized by step sequence / `Tn` / label id; unresolvable references counted into `deps.unresolved` and warned.
+5. **Actual changes**: `git diff --base` automatically fills status, line counts, and diff; files not registered in the document go to "actual changes outside the document" and are not silently dropped.
+
+## Generation / refresh
+```bash
+# static snapshot (default .agents/cache/tours/<type>-<name>.html)
+node .agents/scripts/gen-dev-tour.mjs workflow/plans/<name>.md
+
+# compare the entire committed task (default HEAD = current uncommitted working tree)
+node .agents/scripts/gen-dev-tour.mjs workflow/plans/<name>.md --base origin/main
+
+# model only (debug parsing)
+node .agents/scripts/gen-dev-tour.mjs workflow/plans/<name>.md --json
+
+# gate mode: reject production on layer fallback/no steps/implementation step without files (exit 1; pure verification steps exempt by title)
+node .agents/scripts/gen-dev-tour.mjs workflow/plans/<name>.md --strict
+```
+
+Each generation prints a "parse hits: direct X/Y steps … · path guesses Z" line — if the direct-hit rate <100%, first check whether headings broke the contract, then decide whether to accept fallback grouping; after the hit line it prints "⚠ line N: <title>: <reason>" line by line, locating contract breaches to lines (step has no aligned file block / file block anchor aligns with no step / dependency reference unresolved / layer fallback triggered, corresponding to `parseHealth.issues` `{line,title,kind}` in the model; `pathGuess` and issues are advisory and never participate in `--strict` production rejection). The page-top warning bar consumes the same issues: merged by `kind` into "file block unaligned / step missing files / dependency unresolved" classes, expanded line by line within groups; entries in `step-no-files` whose title contains "验证步骤/单测/UI 实测/静态门" are listed separately as "verification steps" and not counted as to-fix.
+
+Live version (recommended to keep open during Build):
+```bash
+# auto-start dashboard + print this plan's live link (idempotent reuse, no browser popup; failure only warns, does not block)
+node .agents/scripts/auto-tour.mjs workflow/plans/<name>.md
+# → http://127.0.0.1:8933/tour?file=workflow/plans/<name>.md
+
+# start dashboard only, no document specified
+node .agents/scripts/ensure-board.mjs
+```
+The live page pulls `/api/tour` every 5s; document save / working-tree changes redraw automatically, preserving the currently selected step and view.
+
+## Views
+- **Overview**: default grid (one large card per station, read by number); top-right "Layout" switches to a horizontal timeline; "Focus overview" hides left/right columns, 6 stations usually fit in two rows.
+- **Timeline**: arrows connect per-step files by architecture layer (frontend → API → application → domain → infrastructure → DB); test steps add dashed verification arrows.
+- **Data flow**: statically identify cross-file data objects (Dto/entity/table) from diff added lines and document body, show layers and files the object flows through by architecture-layer swimlanes, and list "definition step → usage step" transfer edges; clicking an object links steps/files (data from model dataflow, schema 2; view hidden when no recognized result).
+- **Flow**: plan → steps → verification gate → close-out; verification gate reads `## 验证计划`. When model `deps.edges` is non-empty, the main chain's left thin rail draws side arcs for declared dependencies (transitively reduced; adjacent main-chain edges not drawn twice; pointing to a prior row = anomalous reverse dashed line); hovering a step highlights its upstream/downstream arcs and counterpart steps.
+- **Requirements**: follow "corresponding entry/spec：…" links to read upstream documents (one level, no recursion, at most 3 documents), render this document's goal + upstream intent/spec/incident goals and behavior/acceptance points (model `doc.upstream`); view hidden when no upstream docs, requirement narrative then only this document's purpose.
+- **Verification**: left plan checklist (`## 验证计划`), right actual evidence — local `.agents/verifications.jsonl` preferred, repo `workflow/verify-evidence.md` fallback merged (dedup by ts+head), take the latest 10 within the document date time window (model `evidence`). The association semantics is "verification evidence within the task time window", not per-item binding; the flow verification gate also shows the latest evidence within the window; view hidden when none.
+- **Interlink**: clicking a station/file/step card/timeline message syncs the left tree and right notes; `←/→` switch steps, `Esc` clears; "Follow the flow" auto-plays.
+
+## Applicable scale (verified 2026-11-11)
+Reproduction: `node .agents/tests/tools/gen-synthetic-plan.mjs --bench` (synthetic plan lands in `.agents/cache/tour-perf/`; build timing uses `buildTour({git})` injecting 300 modified files, max of 3 rounds; HTML generated by `gen-dev-tour.mjs --no-diff`, git side is the real working tree at that moment, size dominated by the document side).
+
+| Tier | buildTour (300 diff files injected) | Static HTML size |
+| --- | --- | --- |
+| 10 steps | 317–332 ms | ~100 KB |
+| 30 steps | 348–350 ms | ~131 KB |
+| 60 steps | 474–483 ms | ~178 KB |
+
+Boundary statement: verification covers ≤60 steps / 300 diff files, and within this range build time has no knee (far below 5s); beyond this range unverified, do not conclude by linear extrapolation. Browser-side verification (Chrome, file:// static page, 60-step tier): 1868 DOM nodes per page, 289ms load, six-view switching 14–22ms each — no virtualization needed at this magnitude.
+
+## Boundaries
+- The document is the plan side, git is the actual side; on conflict the map shows split columns (plan / outside document).
+- Does not replace the plan's acceptance criteria and `check-scope.mjs`; it only visualizes the same facts, adding no new source of truth.
+- Generated artifacts default to `.agents/cache/tours/`, not committed; to archive use `--out wiki/...` or screenshots, do not stuff HTML into workflow/.
+- View usage data (`/api/tour/usage`) lands only locally in `.agents/cache/tour-usage.jsonl`, not committed or sent out; after one iteration trim the least-used views by usage rate (data-flow view is the primary observation target), do not build a query aggregation page, use node directly for stats.
+- Engine surface (`.agents/`) changes still go through `check-scripts-syntax` and other gates; this skill waives no gate.
+
+## Acceptance
+- [ ] Document has ≥1 step; each step has at least one file, or is explicitly `验证步骤`.
+- [ ] "Parse hits" has no layer fallback (no page warning bar); fallback = heading contract breach, fix the document first.
+- [ ] "Actual changes outside the document" in the map is empty, or explained/backfilled.
+- [ ] The four views switch without blanks; clicking a file locates the step and diff.
+- [ ] The live page shows "live" next to the title, falls back to "polling" when disconnected.

package/locales/en/overrides/.agents/skills/dream/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: dream
+description: "Offline Dreaming — periodic memory maintenance modeled on Anthropic's memory architecture: run the dream-run audit, read the report, delegate independent-reviewer to check AI Judge samples, write back papercuts/correction notes, and dispose of cold-data candidates; for use by the main agent when executing the Dreaming continuous-run loop within a session."
+---
+
+# dream — Offline Dreaming continuous-run loop
+
+## Triggers
+
+- A `[dream]` advisory appears post-commit (≥7 days since the last audit, or no report).
+- A session-resume rebuild finds `tmp/dream-report-*.md` or `tmp/dream-judge-brief-*.md`.
+- The user explicitly asks to "run the dream audit / Dreaming".
+
+## 1. Run the audit
+
+```bash
+node .agents/scripts/dream-run.mjs              # dry-run: read-only audit + AI sampling brief (default)
+node .agents/scripts/dream-run.mjs --execute    # execute safe fixes (terminal-state artifact archiving + index regeneration only)
+```
+
+- The report lands in `tmp/dream-report-<date>.md` (gitignored); the AI Judge brief lands in `tmp/dream-judge-brief-<date>.md`.
+- `--execute` only performs "terminal-state artifact archiving + index regeneration" and rewrites no document content.
+- Does not auto commit / push (root AGENTS.md prohibition).
+
+## 2. Read the report
+
+Read the latest `tmp/dream-report-*.md`, focusing on:
+
+- A terminal-state artifact archiving (archive-sweep, 21-day window);
+- B index drift and three-way wiki consistency;
+- C full reconciliation (check-loop, hard 6 segments);
+- D error-class candidates (agg-judgments --retire-candidates);
+- E resident-surface budget (rule-budget --all);
+- E2 cold-data candidates (agg-kb-usage --stale-days 90)—access/hit telemetry + confidence decay, see §5;
+- F AI Judge sampling audit brief.
+
+## 3. Verify AI Judge samples
+
+1. Read `tmp/dream-judge-brief-*.md`;
+2. Copy the "Judge delegation template" at the end of the brief to the independent-reviewer role for verification;
+3. Handle the verification conclusion as BLOCK / WARN / OK:
+   - **BLOCK**: correct the workflow document claims against the original evidence (do not auto-commit after the fix);
+   - **WARN**: record a papercut or add evidence;
+   - **OK**: no action.
+
+## 4. Write back
+
+- Error-class candidates: handle via the recurring-error loop in `.agents/skills/papercut-fix/SKILL.md` (≥3 occurrences → establish a rule; placement ladder: type→gate→test→smoke→prompt).
+- Verification findings: correction notes / record in `workflow/papercuts.md`.
+
+## 5. Dispose of cold-data candidates
+
+- Cold-data candidates come from `agg-kb-usage.mjs` (telemetry basis: neither hit by kb-search nor content-updated in the last 90 days).
+- Disposal ladder (adjudicated by the main agent/user):
+  1. Archive: `node .agents/scripts/archive-sweep.mjs --execute` (terminal-state artifacts, 21-day window);
+  2. Update: update the knowledge via the wiki skill;
+  3. Delete: **requires an explicit user instruction** (root AGENTS.md irreversible-operation red line).
+
+## Red lines
+
+- `--execute` only archives + regenerates indexes; it does not rewrite document body text.
+- No auto commit / push; deleting wiki files requires an explicit user instruction.
+- This skill is the execution loop: the AI performs judgment, and deterministic scripts only sample and collect evidence ("deterministic scripts own facts, the model owns judgment").

package/locales/en/overrides/.agents/skills/eval/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: eval
+description: Blind evaluation of skill/prompt changes — A/B arms, same model and same context, a known-answer task set, compute hit rate and Δ; use when asking "is this skill change actually useful".
+---
+
+# eval — Blind evaluation of changes
+
+## Triggers
+
+- You add/modify a skill, prompt, or structure and want to know whether it actually improves behavior.
+- `/reflect` landed a skill change and you need evidence to keep or revert it.
+- Two options are too close to call; use a task set to adjudicate.
+
+## Steps
+
+1. **Define the task set**: 5–10 tasks, each with a **known answer/acceptance criterion**; include both positive and negative cases. Write it as TSV:
+   ```
+   task	expected	a	b
+   ```
+   Leave `a`/`b` empty for now; fill in `pass`/`fail` after running.
+2. **Define two arms**: A = with the new skill/prompt; B = without/the old version. **Same model, same context, same tasks**; the evaluator does not know which arm is which (blind).
+3. **Run**: for each task, run both arms with a **new subagent**, sharing no conclusions; record the actual result against `expected`.
+4. **Compute**: `node .agents/skills/eval/scripts/eval-score.mjs <results.tsv>` → A/B hit rate, Δ, flipped tasks.
+5. **Judge**: Δ is clear and flips are explainable → keep; Δ near 0 or negative → revert/adjust; many flips → task ambiguity, fix the task set first.
+6. **Record it**: put the conclusion in the task document or `workflow/reviews.d/<current month>.md`; update `mechanism-registry.md` for mechanism changes.
+
+## Task-set template
+
+```
+task	expected	a	b
+bug-fix-1	Fix after reproducing the failing case; tests turn green		
+bug-fix-2	Do not modify test assertions; change only the implementation		
+feature-1	New behavior has boundary cases		
+negative-1	Refuse to implement directly without a spec		
+```
+
+## Boundaries
+
+- Small N is noisy; do not claim effectiveness when Δ < 20pp.
+- Without blinding it is not eval—an evaluator who knows the arm assignment will self-fulfill.
+- Do not run both arms with the same model and then use it as the judge; use a different model or a human judge.
+- The task set must separate "the skill helps" from "the model already knew it"; negative cases are the key defense against self-deception.

package/locales/en/overrides/.agents/skills/interrogate/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: interrogate
+description: Multi-model multi-lens adversarial review — different models/lenses independently take apart the same diff, then aggregate and dedupe; use for high-risk PRs, L2/L3 reviews, or when a single-model review leaves you uneasy.
+---
+
+# interrogate — Multi-lens adversarial review
+
+## Triggers
+
+- A high-risk diff (cross-boundary, concurrency, authorization, data migration, public interface).
+- You want one more pass beyond the L2/L3 independent review.
+- A single-model review concludes "looks fine", but you are not convinced.
+
+## Core
+
+**This is not another single-model review pass.** It has different models and different lenses take apart the same diff **independently**, then aggregate and dedupe. Different models catch different real bugs; the same model with a different lens can also catch what a single lens misses.
+
+## Steps
+
+1. **Fix the target**: base/head, spec path, risk level. Do not start until the target is fixed.
+2. **Generate the plan**: `node .agents/skills/interrogate/scripts/interrogate-plan.mjs --base <ref> --head <ref> [--spec <path>]`. It outputs six lenses (correctness / security / quality / performance / tests / spec) plus file slices and prompts for each lens.
+3. **Dispatch in parallel**: one subagent per lens, each reading the diff independently and sharing no conclusions.
+   - Model: follow the `review` role in `.agents/config/model-roles.json` (`heterogeneous: true`); if the host supports model override, use different models; if not, use different agent personas (`reviewer` / `security-reviewer` / `code-simplifier` / `caveman-reviewer`).
+   - Each subagent gets only its own lens prompt + file slice, not the other lenses' conclusions (to prevent anchoring).
+4. **Aggregate**: dedupe by `file:line + issue`; classify P0/P1/P2; separate confirmed from speculative; give a one-line "why it is not an issue" for each noise item.
+5. **Output**: one merged table + "must fix before merge" + "ruled out" + "not covered".
+
+## Output format
+
+| Severity | Location | Issue | Evidence | Fix | Source lens |
+|---|---|---|---|---|---|
+| P0 | `file:line` | … | … | … | security |
+
+- **Must fix before merge**: all P0 + confirmed P1.
+- **Ruled out**: items that looked like issues but checked out not to be; give a reason for each.
+- **Not covered**: surfaces no lens covered (e.g., runtime behavior, external services); state them explicitly.
+
+## Where it lives in this repo
+
+- `review.md` execution flow: L2/L3 high-risk diffs layer this skill on top.
+- `review-method`: the Standards×Spec dual axis + bad-smell walkthrough remains the single-lens baseline; this skill is a parallel supplement.
+- `independent-reviewer`: a single independent review is not replaced; this skill is a multi-model supplement.
+- Machine gates: does not replace `verify` / `check-loop`; this skill only produces a list, and a human still signs off on severity.
+
+## Boundaries
+
+- Multi-model agreement is high signal, not proof; still use `blast-radius` to prove key safety facts.
+- Do not treat "another model said so too" as evidence; evidence remains `file:line` / code that ran.
+- Subagent conclusions must be re-checked yourself; do not pass them through directly.

package/locales/en/overrides/.agents/skills/number-vetting/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: number-vetting
+description: Number vetting — five questions to ask before reporting, citing, or deciding on any measured value (latency/hit rate/coverage/scale); for use by the main agent when writing metrics, gate costs, review outcomes, and performance conclusions.
+---
+
+# number-vetting — Number vetting (five questions)
+
+Before any number enters `workflow/metrics.md`, a `verifications.jsonl` interpretation, a PR body, or an option conclusion, run through every question. If any one cannot be answered → mark it "doubtful" and do not use it as a basis for a decision.
+
+## The five questions
+
+| # | Question | Disqualifying signal |
+|---|---|---|
+| 1 | **Limiting factor**: what is this number bottlenecked by? | Cannot name the bottleneck; counting serial waits into a single item's latency |
+| 2 | **Tuning/environment**: caused by warm cache, parallelism, machine load? | Mixing cold/warm runs; does not reproduce on another machine |
+| 3 | **Error/noise**: how large is the variance? What is the distribution across reruns? | Single sample; the difference is the same order as the noise |
+| 4 | **Basis/window**: sample n, time window, exclusions the same as last time? | The basis changed quietly; comparing directly across model generations |
+| 5 | **End-to-end relevance**: does it measure the segment users perceive? | Microbenchmark improved, end-to-end did not move |
+
+## Verdict and recording
+
+- Three levels: **trustworthy** (all five pass) / **doubtful** (missing 1–2 items; re-check after more measurement) / **unusable** (limiting factor unknown or basis drifted).
+- Record format: `value (sample n / window / basis / k reruns)`; write "not measured" for missing items, never 0.
+- The `{{指标名}}` signature is filled with live values by the data collector (check16); do not fill it by hand.
+
+## Existing conventions in this repo (read first, do not invent another)
+
+- How to read peak %: the "Number vetting" note at the top of `workflow/metrics.md`—resting-state ≈93% is structural; judge pressure by backfill rate, not peak.
+- Cross-model-generation comparisons: read "Model generation baseline" in `workflow/delegations.md` first; do not recompute old monthly snapshots.
+- Gate duration: use `wallMs` from `verifications.jsonl`; green rows before 2026-10-16 lack that key, so fall back to the sum of the individual gates—do not mix the two bases in a comparison.
+
+## Red lines
+
+- Do not write "gates got faster" as "quality improved".
+- Do not use a single run to prove performance; do not hide the long tail behind an average (list the slowest gate separately).

package/locales/en/overrides/.agents/skills/page-refactor/SKILL.md

@@ -0,0 +1,192 @@
+---
+name: page-refactor
+description: Business feature page refactoring executor — refactor any business page/module following the pattern distilled from the purchase order (PO) template — shape inventory → target shape and table selection → build per references/templates.md (list page + create/view/edit entire module, supporting Drawer → overlay detail transition) → full assertion verification. Use when the user asks to "refactor a page / align with the purchase order page / refactor an entire module UI / refactor a list page / refactor a detail page".
+---
+
+# page-refactor — Business module refactoring (PO template pattern)
+
+## Positioning
+
+- **Refactoring scope = the entire feature module**: list page + create + view + edit refactored together, not just layout tweaks. Target shape = what PO / supplier pages look like now; when the current shape is far from target (e.g., Drawer-edit style), follow the "shape transition" path to close the gap.
+- **Construction authority is** `references/templates.md` (S1–S12). This file keeps only inventory, red lines, and acceptance; read templates when entering the construction step, do not load the entire document during inventory. Replace class names (`xx-detail`/`xx-list`) per target page, replace fields/buttons/action set per target page business, keep layout skeleton and mechanisms verbatim.
+- **Fit the target project's current state**: table technology, shared components, and infrastructure are selected according to the target project's actual situation (see "Table technology selection" and "Infrastructure dependencies and degradation table"); do not force new dependencies.
+- **Provenance**: templates distilled from this repository's purchaseOrder and supplier page refactors (2026-10, from commit `e6f33915` onward in a series of iterations), verified through multiple rounds of L1 plan full assertion verification in that series.
+- **Template reference (optional)**: if the target branch has already-refactored template pages (`frontend/src/views/purchase/purchaseOrder/index.vue`, `detail.vue`, `shared.ts` (list/detail shared constants), `frontend/src/views/baseData/supplier/detail.vue`), you may consult them; **when the template does not exist or conflicts with the templates, `references/templates.md` prevails and report the difference to the user** — never overturn the templates with an old template version.
+- **Backfill obligation (anti-drift)**: when this repository's template pages evolve later, backfill the corresponding fragment in `references/templates.md`; if drift is found, first record one line in `workflow/papercuts.md`, do not fix it opportunistically on the spot.
+- **Cross-branch/cross-repo carry**: copy both this file and `references/templates.md`. Copying only this file gives no construction templates. **Authoritative source = these two in this repository**; carried copies do not flow back and drift is the carrier's responsibility. **This repository exception**: host adaptation directories (`.trae/`, `.opencode/`, `.codebuddy/`) hold only pointer shells per repository discipline; full-text copies are forbidden.
+- This skill is a **refactoring pattern knowledge + hard-constraint layer**: when used in this repository it still follows the project workflow (L1 plan → confirmation gate → build → UI verification → close-out); other repositories follow the "Infrastructure dependencies and degradation table".
+
+## Step 0: Shape inventory (mandatory; skipping is a violation)
+
+1. Read the target page `index.vue` / `detail.vue` (if any) / Drawer components (if any), inventory:
+   - **Target shape** (look at business structure, not current implementation): entity has detail lines/related documents → **A master-detail**; entity is pure form without details → **B pure form**; read-only with no edit and no detail → **D pure query**.
+   - **Current shape**: already has overlay detail component → layout-rearrangement path; Drawer editing (create/edit/view inside a Drawer) → **shape transition path** (see "Shape transition construction flow").
+   - **Table technology status**: whether the target project already uses AG Grid (check package.json / existing page imports); if not → list it as an **S12 one-time integration item** (done along with this refactor, not an optional decision).
+   - **Infrastructure status**: probe item by item against the "Infrastructure dependencies and degradation table".
+2. Produce **refactor item list + selection/degradation decisions + open questions** (e.g., whether this page has no batch operations, whether the detail table deserves tabbing) → AskUserQuestion for the user to confirm scope.
+3. Only after user confirmation, create the plan and enter construction. **Skipping inventory and applying templates directly is forbidden.**
+
+### Shape adaptation matrix (target shape × current shape)
+
+| Target shape | Business characteristic | Currently already overlay detail | Currently Drawer-typed (transition) |
+|---|---|---|---|
+| **A master-detail** (PO type) | Entity has detail lines (± related documents) | Apply the full D-1~D-7 set directly | Follow "shape transition construction flow" → new detail.vue (A skeleton) + Drawer business migration and decommission |
+| **B pure form** (supplier type) | Entity is pure form without details | Apply D-1 + D-8 directly; **do not apply upper/lower half tabs / height model** (no detail table; applying them will fail) | Follow "shape transition construction flow" → new detail.vue (B skeleton) + Drawer business migration and decommission |
+| **D pure query** | Read-only list, no edit and no detail | N/A | N/A — only list page refactoring |
+
+> **Mixed shape** (view = overlay, edit/create = Drawer, e.g., the purchase order page at baseline 4d363c4): judge by the "currently Drawer-typed" column — follow the transition path; existing view-state overlay content is also moved into the new detail.vue's view state (carried by the D-2 read-only grid), and old view-state code is decommissioned in the same batch as the original Drawer — dual detail entries for the same entity must not coexist.
+
+## Table technology (list page, unified AG Grid)
+
+**Effect criteria (assertion gate verifies against this)**:
+1. Column order = definition order (checkbox → sequence number → document number…), zero visual order confusion
+2. Column width adapts: primary text columns take remaining width, zero `...` truncation in headers; narrow columns fixed width
+3. Row-action hover overlay replaces the fixed action column (saves an action column width on the order of 280px)
+4. Row scrolling contained inside the table body, zero outer scrollbars; pagination footer pinned to bottom
+
+**Selection rules**:
+- Target project **already uses AG Grid** → build directly per S5-S8.
+- Target project **does not use AG Grid** → **integrate directly as one-time S12** (dependencies + license injection + global visuals + Chinese locale + page-level component template, full set), then build per S5-S8. **Using a-table to simulate equivalent effect is forbidden** — the effect is unreachable and introduces a second table convention, which is a wrong path.
+
+## List page refactoring patterns (4 patterns)
+
+| # | Pattern | Key points |
+|---|---|---|
+| L-1 | Toolbar left/right grouping | Left group document-level (create/export); right group batch buttons linked to checkboxes, `margin-left:auto` to the right + vertical separator; batch eligibility same-source in three places (inline buttons/batch set/checkbox selectable, same guard criteria) |
+| L-2 | Column order and width adaptation | Effect criteria see "Table technology"; implementation see S7 (contiguous leading columns may be pinned left, others not pinned; primary columns flex, narrow columns fixed width) |
+| L-3 | Row-action hover overlay | Remove fixed action column; actions that do not meet eligibility are not rendered, zero-action rows do not pop out; overlay follows the hovered row's inner right edge; DOM event delegation (S6) + action set (S12); confirm with centered Modal.confirm |
+| L-4 | Height chain and pagination footer | Root container pinned to content area + table card `flex:1` takes remainder + footer pinned to bottom; row scrolling contained inside grid, no outer scrollbar (S8) |
+
+## Detail page refactoring patterns (8 patterns; target shape A full set / target shape B only patterns 1 and 8)
+
+| # | Pattern | Key points |
+|---|---|---|
+| D-1 | Top row merged | `DetailPageHeader`: back button + `#meta` (document number/status tag) + `#extra` (action buttons) on the same row; standalone action row forbidden |
+| D-2 | Upper half basic info tab | View state `a-descriptions` → `a-form` read-only grid (`info-grid`), unified with edit state: 4 columns (`lg:6`) / label left-right 106px / compact spacing / long text span 24 |
+| D-3 | Lower half multiple tabs | Detail table + related documents each one tab (`v-model:activeKey`); original title block removed (tab name carries it) |
+| D-4 | Height model | Upper half pure content height (`flex: 0 0 auto`); lower half `min-height: calc(var(--layer-h)/2)` + `grow` to fill; `--layer-h` injected by ResizeObserver (CSS percentages fail in stretchable containers); overflow beyond one screen is taken over by outer `.detail-layer` scrolling |
+| D-5 | Toolbar merged into tab row | Detail action buttons placed in `#rightExtra`'s `.tab-extra-row` (self-contained flex container) + maximize button; saves an entire row |
+| D-6 | Lower half maximized | `is-maximized` (lower half `height:auto` fills) + upper half `is-hidden-by-max` (display:none); toggle shared by both states, closing detail auto-resets |
+| D-7 | In-table scrolling | No outer scrollbar; flex chain `min-height:0` at every layer down to `.ant-table-content` (`overflow-y:auto !important`) |
+| D-8 | Pure form pinned bottom | Target shape B: `.detail-layer` white background (`--bg-container`) + detail root `min-height:100%; flex column` + card `flex:1` + footer `sticky bottom:0` white opaque |
+
+## Shape transition construction flow (Drawer-typed → overlay detail; create/view/edit entire module moved onto overlay)
+
+Transition trigger: target page is currently Drawer-edit typed, and the user's requested refactoring scope includes create/view/edit (full-module refactoring includes them by default).
+
+1. **Read the Drawer's current state thoroughly**: form field bindings, validation rules, save flow (API calls and post-success behavior), view-state content source — transition is **moving, not rewriting**; migrate business logic verbatim. In mixed shape, "view-state content source" = the existing overlay view-state code in index.vue (it is the moving source for view state; likewise read it thoroughly and move it).
+2. **Create `detail.vue`**: target shape A uses the S1-S4 skeleton (upper/lower half tabs), target shape B uses the S9 skeleton (form card + sticky footer) + S11 header component; three-state entry `props.mode: 'create' | 'edit' | 'view'`:
+   - Edit/create state: field bindings, rules, save handler, API imports **moved verbatim** from the Drawer (no opportunistic semantic changes); submission payload field-by-field identical to the original Drawer.
+   - View state: read-only grid (D-2) carries the original view content; action buttons go into `#extra`.
+3. **Mount overlay on list page**: `.detail-layer` + Transition (S8 CSS); all original "create / edit / view" entries changed to open the overlay (`detailState = { mode, id }`).
+4. **Decommission and delete the original Drawer**: editing capability for the same entity **must not have dual entries** — leftover Drawer causes future drift of two submission payloads (reconciliation blind spot); after confirming no other references, delete the whole block. In mixed shape, the existing view-state overlay code is decommissioned in the same batch (view capability has been merged into the new detail.vue; dual detail entries forbidden).
+5. **Reconciliation red line**: transition does not change contracts — API contract, query parameters, submission payload unchanged field by field; post-save list refresh and close behavior aligned with existing convention; eligibility criteria remain same-source in three places.
+
+## Infrastructure dependencies and degradation table (probe before starting; trim refactor items by availability)
+
+| Refactoring capability | Dependency | Degradation when missing in target repo |
+|---|---|---|
+| D-1~D-7 detail page layout | No external dependency (antd suffices) | No degradation needed, fully applicable |
+| D-8 pure form pinned bottom | No external dependency | No degradation needed |
+| DetailPageHeader shared header | Component exists | If missing, create directly from the full S11 text (69 lines, required props + slot contract) |
+| L-1 toolbar grouping / L-4 height chain | No external dependency | No degradation needed |
+| L-2/L-3 table effects (AG Grid) | `ag-grid-community` + `ag-grid-vue3` + `ag-grid-enterprise` (this repo ^35.3.1); Chinese locale module; license key (runtime injection) | **Integrate directly, no degradation**: full S12 migration (dependencies / main.ts registration / license injection mechanism / global visual CSS / locale / component template); once installed and configured, it matches the template's effect |
+| Row action button group | Page-level RowActions-like component | Build the button group per target page action set (the "action eligibility criteria same-source" principle unchanged) |
+| Full assertion verification | This repo `scripts/verify/e2e/harness.mjs` (technical single source) | If missing, write a minimal node CDP probe per the S10 skeleton — the assertion checklist loses no item |
+| Workflow (plan/confirmation gate/close-out) | This repo `AGENTS.md` + `workflow/` | Baseline clauses cover it: refactor plan confirmed by user before starting + full assertion verification + evidence screenshots archived |
+| Notification guard / URL state / other conventions | This repo `utils/notify.ts` / `utils/listUrlQuery.ts` etc. | Follow the target repo's existing convention; this repo's conventions (G-3/LP-1/BC-1/BC-2/BC-4) are mandatory only when the corresponding infrastructure is present |
+
+**AG Grid integration** (when target project does not use it): full integration steps and all configuration templates are in S12 — the three dependencies, main.ts module registration, license key runtime injection mechanism (plaintext key not in repository), global visual CSS, Chinese locale acquisition, CustomTooltip / empty state / document-number link / row-action-set component templates; once installed and configured, it matches the template's effect.
+
+## Trigger conditions
+
+- The user asks to refactor a business feature page/module (list page, create/view/edit, layout rearrangement), or "make it look like the purchase order page".
+
+## Construction templates
+
+S1–S12 are in `references/templates.md`. Read them when entering the construction step; do not load the whole document during inventory.
+Inventory, hard red lines, and verification gates follow this file. When the templates conflict with the template page source, the templates prevail; first record in `workflow/papercuts.md`, do not change the templates on the spot.
+
+## antd pitfall list (must-read before construction; each empirically verified)
+
+| # | Pitfall | Solution (see S snippet) |
+|---|---|---|
+| T1 | a-spin root is actually `.ant-spin-nested-loading`, the custom class on the component **does not land on the root** — class-based selection fails across the chain and the whole area collapses to 0 | Select by antd structural classes (S1) |
+| T2 | `.ant-tabs-extra-content` is not flex by default; a block-level button group pushes the maximize button to the second row | `#rightExtra` contains its own `.tab-extra-row` flex container (S1/S4) |
+| T3 | tabs content area is not flex by default; one broken layer collapses the whole area to 0 | `.ant-tabs / content-holder / content / tabpane-active` each layer `min-height:0` (S1) |
+| T4 | When container height is indeterminate (stretchable), child percentage min-height/height resolution fails | ResizeObserver injects `--layer-h` variable, absolute pixel calculation (S2) |
+| T5 | a-table has another spin layer inside (wrapper > spin > container > table); missing one `.ant-table` flex:1 breaks it and the table body compresses to 0 height | In-table scroll chain includes `.ant-table-wrapper` and both spin layers (S1) |
+| T6 | antd pure horizontal scrolling inlines `overflow-y:hidden`, so table body vertical scroll fails | `overflow-y:auto !important` on `.ant-table-content` (S1) |
+| T7 | `a-row :gutter` negative margins (-4px per side) push out horizontal panel whitespace | Upper-half container explicit `overflow:hidden` (S1) |
+| T8 | antd small screen (<576px) makes label fill the whole row, becoming vertical | Force horizontal label convention `width/flex/padding !important` (S1) |
+| T9 | a-tag pill is filled across the whole column by "baseline zeroed and stretched", becoming a full-column color block | Stretch selector excludes with `:not(.ant-tag)` (S1) |
+| T10 | AG Grid `rowMouseEnter` callback empirically does not fire (neither real nor synthetic mouse) | DOM event delegation mouseover/mouseout (S6) |
+| T11 | AG Grid pinned-left container renders first; pinning middle or action columns left disrupts the "checkbox→sequence→document number" visual order | Only pin a contiguous leading run in definition order; multi-select column uses selectionColumnDef; others not pinned (S7) |
+| T12 | Chrome re-dispatches mouseover on the row revealed after the overlay leaves the DOM; after entering detail the overlay rebuilds and blocks | Toggle overlay display entry to a fuse that opens when detail layer opens (S6) |
+| T13 | Overlay not in scroll viewport, card overflow:hidden, wheel falls through | Overlay manually forwards wheel to `.ag-body-viewport` (S6) |
+| T14 | Global style `.ant-card-body` has `!important` padding, footer pinning fails | High-specificity `padding:0 !important` override (S8) |
+| T15 | Vue reactive Proxy interferes with AG Grid internal state | gridOptions uses a plain object (S7) |
+| T16 | Detail page detail a-table without `:scroll.y` does not vertically scroll the table body by default; "in-table scrolling" silently fails | CSS force chain `.ant-table-content { overflow-y:auto !important }` (S1) |
+
+## Hard red lines (change-forbidden list; violation = rework)
+
+1. **Do not touch the overlay mechanism**: `.detail-layer`'s `position:absolute; inset:0; overflow-y:auto` and the "list instance stays alive" convention preserved verbatim.
+2. **Zero contract change**: API contract, query parameters, submission payload unchanged field by field (shape transition = moving, not rewriting; submission payload reconciled field by field before and after migration); inline buttons/batch eligibility/checkbox selectable same-source in three places; backend error messages displayed as-is.
+3. **No dual editing entries**: after the transition completes, the original Drawer must be decommissioned and deleted — dual entries for the same entity's editing capability cause future submission payload drift (reconciliation blind spot).
+4. **Both states on the same chain must be tested**: when view state and edit/create state share the height chain, **both states must be verified**; testing only one does not pass.
+5. **Minimal change**: only touch target module files + shared component slot-level increments; no opportunistic refactoring, no formatting unrelated code, no fixing unrelated Lint warnings; when moving templates, handlers stay verbatim.
+6. **Keep mechanism comments in sync**: layout changes must synchronize existing mechanism comments in the file (height model/chain comments) to prevent comments and code diverging; mechanism comments within snippets in this document are preserved verbatim when implemented.
+7. **Notifications and list state**: if the target repo has unified notification guards / URL state management infrastructure, always use the infrastructure (e.g., this repo's `utils/notify.ts` / `utils/listUrlQuery.ts`); never bypass.
+
+## Verification gate (full assertion verification; missing items do not pass)
+
+Static gate: `cd frontend && npm run build` (or the target repo's equivalent strict type build gate).
+
+UI verification: headless Chrome CDP probe — this repo's technical details import the single source `scripts/verify/e2e/harness.mjs` (do not hand-write equivalent logic); if the target repo lacks this infrastructure, write your own per the S10 skeleton. One-off probes go in the **git-ignored area outside the repo** (this repo `tmp/e2e/`), screenshot evidence archived; read-only probes leave no dirty data (data produced by the transition save-flow test is deleted precisely by response ID); close all self-started processes at the end. Check the corresponding assertion group per refactor item:
+
+**Detail page (target shape A, when D-1~D-7 are all changed)**
+- [ ] Height chain: upper half pure content height (tall viewport `topH < half`, `clientH == scrollH`); lower half `≥ half`; `top+bottom == layerH` (whole page filled, no bottom whitespace)
+- [ ] No outer scrollbar: `.detail-layer` `scrollHeight == clientHeight` (regular viewport)
+- [ ] In-table scrolling takeover: table body `overflowY == auto`; compressed viewport (e.g., 1440×520) reverse branch — upper half pure content expands, lower half locks to half screen, outer scrolling takes over
+- [ ] Maximized state: upper half `display:none`, `bottomH == layerH` fills, model restores after restore
+- [ ] Toolbar merge: button group centerline aligned with tab nav centerline, tab row not taller, buttons left of the maximize button and inside `.ant-tabs-extra-content`
+- [ ] Two-state regression: view state + edit/create state each run once under the same criteria; edit-state action button functionality does not regress (handler binding unchanged)
+- [ ] Tab switching: each tab header present, switching does not cross-contaminate data
+
+**Detail page (target shape B, D-1/D-8)**
+- [ ] White background fills (including list shorter than one screen); buttons pinned to bottom (shorter than one screen) + sticky pinned to bottom (scrolling beyond one screen, footer.bottom constant at two positions, opaque)
+
+**Shape transition special (Drawer → overlay)**
+- [ ] Three states reachable: list "create" → create-state overlay, "edit" → edit state, "view" → view state, rendered correctly
+- [ ] Save flow does not regress: create/edit save submission payload field-by-field identical to the original Drawer (network payload comparison); after save, list refresh and close behavior aligned with existing convention
+- [ ] Original Drawer decommissioned: no residual Drawer mount on the page, old entry buttons do not trigger old interactions
+- [ ] Form validation does not regress: required-field validation, backend 400 messages displayed as-is per original convention
+
+**List page (L-1~L-4)**
+- [ ] Column order: checkbox → sequence → document number… visual order equals definition order (left pinning only on this contiguous leading run), no `...` truncation in headers
+- [ ] Toolbar: left group/right group each on its side, batch button disabled linked to selection, count correct
+- [ ] hover overlay: rows with available actions pop out on hover and are vertically centered on the row, zero-action rows do not pop out, refresh on row change, delayed hide on leave, overlay does not disappear when hovering itself, overlay wheel scrolls the table, overlay not rebuilt after entering detail layer (real mouse path)
+- [ ] Row scrolling contained inside grid, no outer or page scrollbar; pagination footer pinned to bottom
+
+**General**
+- [ ] Console exceptions cleared (if AG Grid license key is injected there is no trial banner; when not injected the banner is known noise, excluded)
+- [ ] List state restored after closing detail layer (scroll position/filter not lost — overlay mechanism verification)
+
+The probe produces an `N PASS / M FAIL` summary and evidence screenshot paths; backfill task acceptance criteria, then run the close-out flow (this repo `.agents/commands/stages.md` Test chapter).
+
+## Execution flow overview
+
+```
+Trigger this skill
+  → Step 0: read target page inventory (target shape A/B/D × current shape) + AG Grid integration probe + infrastructure degradation probe
+  → produce refactor item list + degradation/open-question decisions → user confirms scope (AskUserQuestion)
+  → create plan (this repo L1; when transition includes new components, the change list is itemized per file) → approach confirmation gate
+  → before construction read references/templates.md (S1–S12)
+  → construction:
+      table infrastructure: target project does not use AG Grid → first integrate one-time per S12 (dependencies/license/visuals/locale/component templates)
+      list page: S5-S8 (toolbar grouping / column order and width / hover overlay / height chain footer)
+      detail page: already overlay → S1-S4 rearrangement; Drawer-typed → "shape transition construction flow" + S1-S4/S9 skeleton creation
+      → self-check the pitfall list T1-T16 item by item
+  → verification gate: build static gate + full assertion verification (including transition specials) → PASS/FAIL summary + screenshot evidence
+  → close-out (backfill acceptance evidence); template/skill drift recorded in papercuts (this repo)
+```