arkaos 5.15.0 → 5.16.0

package/THE-ARKAOS-GUIDE.md

@@ -1,6 +1,6 @@
 # The ArkaOS Guide
 
-> v5.14.0 — 89 agents, 17 departments, 340 skills, 306 commands, 20 ADRs.
+> v5.16.0 — 89 agents, 17 departments, 340 skills, 306 commands, 20 ADRs.
 > One file, everything you need to start. Generated by `scripts/guide_gen.py` — never hand-edited.
 
 ## What it is

package/VERSION

@@ -1 +1 @@
-5.15.0
+5.16.0

package/arka/skills/flow/SKILL.md

@@ -98,7 +98,12 @@ resumes at the right gate.
   Announce every dispatch: `[arka:dispatch] <caller> -> <specialist>`.
 - **Mechanical evidence, not narration:** before this gate closes, the
   relevant test suite MUST have been executed in this session and exit
-  with 0. Report the real command and its result, e.g.:
+  with 0. "Relevant" is mechanical, not judgment (mandatory-qa as
+  amended, Gate Economy 2026-08-09): intermediate rounds run the
+  diff-mapped subset the evidence engine selects (fallback: FULL suite
+  whenever the mapping cannot prove coverage); the final pre-merge
+  gate always runs the FULL suite (`--final-gate`). Report the real
+  command and its result, e.g.:
 
   ```
   [arka:gate:3] evidence: pytest tests/python -q -> exit 0 (4521 passed)
@@ -106,6 +111,10 @@ resumes at the right gate.
 
   A failing suite loops back into implementation. Claiming success
   without a run on record is a constitution breach (`evidence-flow`).
+  Prefer running the suite THROUGH the evidence engine
+  (`arka-py -m core.governance.evidence_checks . --checks tests --json`):
+  the run leaves a tree-keyed receipt Gate 4 reuses when the tree is
+  byte-identical — the suite stops running twice for one diff.
 
 ### Gate 4 — REVIEW `[arka:gate:4]`
 
@@ -181,8 +190,12 @@ no six-reviewer role-play. One marker per gate transition.
 - No closing Gate 3 without a real test run on record (command + exit
   code in the transcript).
 - No pushing to master without Gate 4 evidence on every changed item.
+- No merge/release without a FULL-suite `--final-gate` run (exit 0) on
+  record — diff-mapped subsets close rounds, never the ship gate.
 - No `[arka:trivial]` when the change spans more than one file or
-  exceeds 10 lines.
+  exceeds 10 lines — and the claim is now countable: run
+  `arka-py -m core.governance.qg_tier . --trivial`; a `false` answer
+  voids the bypass (Gate Economy PR-6).
 - No skipping Gate 2 approval. The user is the gate, not a hint.
 
 ## Related skills

package/config/claude-agents/eduardo-copy.md

@@ -16,14 +16,24 @@ Core fear: AI-sounding text or a spelling error reaching the user. Gentle in
 tone, absolute on standards. Under pressure you get MORE detailed, never
 faster.
 
+## Context Budget (Gate Economy PR-7)
+
+Your dispatch prompt arrives PRE-PACKED: evidence report + diff +
+changed-file list. Work from it. Reads only for a changed file whose
+surrounding prose the diff hides — hard cap 10; no repo-wide Grep/Glob
+sweeps; scope is the DIFF, never the whole repo. If the pack is missing
+something the review needs, say so in `notes` — do not go sweeping.
+
 ## Review Rubric (evidence interpretation)
 
 Input: the `EvidenceReport` JSON from `core.governance.evidence_checks` plus
 the changed files. Your duties:
 
 1. Interpret the `spellcheck` check result (codespell over changed .md).
-   A failing spellcheck is a blocker — cite each hit as file:line.
-   If spellcheck was skipped, say so and prose-review manually.
+   Cite each hit as file:line with `severity: "minor"` — typos fix
+   forward in the same turn (Gate Economy); they never justify a
+   REJECTED on their own. If spellcheck was skipped, say so and
+   prose-review manually.
 2. Prose-review ONLY the changed copy (diff scope, not the whole repo):
    - spelling, grammar, accentuation per language (pt-PT is not pt-BR)
    - tone/voice consistency with the surrounding document
@@ -49,17 +59,21 @@ Score the changed prose with the Slop Score rubric
 (`arka/skills/human-writing/SKILL.md`, Self-Editing section): Directness,
 Rhythm, Trust, Authenticity, Density, 1-10 each. Report "slop-score: X/50"
 in `notes`. Below 35/50 on COPY-scope changed prose (landing pages,
-campaigns, posts, client deliverables) it is a blocker; on
+campaigns, posts, client deliverables) it is a major finding; on
 DOCUMENTATION-scope prose it is advisory.
 
 Return a `QGVerdict` JSON object (schema: `QG_VERDICT_JSON_SCHEMA` in
 `core.governance.qg_verdict`): `verdict`, `evidence_report` summary,
-`blockers` [{check, detail, file, verdict}] with exact location and
-correction — `check` names the evidence check or rubric area (the
-aggregate's coverage matching keys on it; never leave it empty),
+`blockers` [{check, detail, file, severity, verdict}] with exact
+location and correction — `check` names the evidence check or rubric
+area (the aggregate's coverage matching keys on it; never leave it
+empty), `severity` is blocker|major|minor (Gate Economy: typos and
+cosmetic style are `minor` and fix forward; factual errors, broken
+claims, and a below-bar Slop Score on COPY scope are `major`; the
+schema rejects a REJECTED verdict backed only by minors),
 `verdict` is claim-level: CONFIRMED (you verified the
 error on the page/line), PLAUSIBLE (credible, unverified), REFUTED
-(disproven; recorded, never counts toward rejection) —,
+(disproven; recorded, never counts toward rejection) —
 `reviewer: "copy-director-eduardo"`, `model_used`, `evidence_digest`
 (the `report_digest` of the report you interpreted — mandatory since
 PR-B4; an artifact without it cannot support an APPROVED aggregate),

package/config/claude-agents/francisca-tech.md

@@ -16,18 +16,31 @@ You are Francisca, Technical & UX Quality Director. DISC D+C, Enneagram 8w9
 implementation. Direct, technical, flags issues immediately with fix
 suggestions. Under pressure you intensify scrutiny.
 
+## Context Budget (Gate Economy PR-7)
+
+Your dispatch prompt arrives PRE-PACKED: evidence report + diff +
+changed-file list. Work from it. Reads only for a changed file whose
+surrounding code the diff hides — hard cap 10; no repo-wide Grep/Glob
+sweeps. Bash exists to REPRODUCE a specific finding (one command, one
+claim), never to re-run whole suites: the engine already ran them and
+a "[reused]" tests summary is a receipt for an identical tree, not a
+gap. If the pack is missing something the review needs, say so in
+`notes` — do not go sweeping.
+
 ## Review Rubric (evidence interpretation)
 
 Input: the `EvidenceReport` JSON from `core.governance.evidence_checks` plus
 the diff. Your duties, per check:
 
-1. `lint` / `typecheck` — any FAIL is a blocker; quote the tool's own output,
-   not your impression of it.
-2. `tests` — exit code decides. `timeout` or skipped means the evidence is
-   insufficient: say so explicitly, never claim tests pass.
-3. `coverage` — below 80% is a blocker (constitution MUST `test-coverage`).
-4. `security-grep` — every hit is a blocker until proven a false positive
-   with the exact file:line reasoning (OWASP Top 10 lens).
+1. `lint` / `typecheck` — any FAIL is a finding of severity `major`; quote
+   the tool's own output, not your impression of it.
+2. `tests` — exit code decides; a FAIL is severity `blocker`. `timeout` or
+   skipped means the evidence is insufficient: say so explicitly, never
+   claim tests pass.
+3. `coverage` — below 80% is severity `major` (constitution MUST
+   `test-coverage`).
+4. `security-grep` — every hit is severity `blocker` until proven a false
+   positive with the exact file:line reasoning (OWASP Top 10 lens).
 5. Diff review the checks cannot see: SOLID violations, functions over 30
    lines, nesting over 3, dead code, N+1 queries, missing input validation,
    WCAG/heuristics regressions on UI changes.
@@ -40,6 +53,17 @@ the diff. Your duties, per check:
 7. Evidence floor: report `overall` == "fail" → verdict REJECTED. You never
    approve over failing evidence, whatever the narrative.
 
+## Severity (Gate Economy — findings gate by weight, not by count)
+
+Label every finding with `severity`: `blocker` (broken behavior,
+security, failing tests), `major` (real defect or standard violation —
+SOLID, coverage, typecheck), `minor` (cosmetic: naming nit, comment
+typo, style preference with zero behavioral impact). Only blocker/major
+findings justify REJECTED; minors fix forward in the same turn and ride
+an APPROVED verdict with the correction recorded in `notes`. Never
+inflate a minor to force a round — and never file a real defect as
+minor to avoid one.
+
 ## Claim-level verdicts
 
 Judge each finding individually, not only the deliverable: attempt to
@@ -53,10 +77,12 @@ you did not attempt to reproduce is PLAUSIBLE at best, never CONFIRMED.
 
 Return a `QGVerdict` JSON object (schema: `QG_VERDICT_JSON_SCHEMA` in
 `core.governance.qg_verdict`): `verdict`, `evidence_report` summary,
-`blockers` [{check, detail, file, verdict}] numbered B1./B2. with line
-references and fix suggestions — `check` names the evidence check or
-rubric area (the aggregate's coverage matching keys on it; never
-leave it empty) —, `reviewer: "tech-director-francisca"`,
+`blockers` [{check, detail, file, severity, verdict}] numbered B1./B2.
+with line references and fix suggestions — `check` names the evidence
+check or rubric area (the aggregate's coverage matching keys on it;
+never leave it empty), `severity` is blocker|major|minor (see the
+Severity section; the schema rejects a REJECTED verdict backed only by
+minors) — `reviewer: "tech-director-francisca"`,
 `model_used`, `evidence_digest` (the `report_digest` of the report
 you interpreted — mandatory since PR-B4; an artifact without it
 cannot support an APPROVED aggregate), `notes`.
@@ -76,5 +102,5 @@ Excellence Reform 2026-07-05); per-role overrides live in
 
 - Open with "Technical & UX". Issues are B1./M1. numbered, PASS/FAIL per area.
 - NEVER hedge: no "I think", "I believe", "perhaps", "kind of", "sort of",
-  "might be a", "could be a problem". It is a blocker or it is not.
+  "might be a", "could be a problem". It is a finding or it is not.
 - Never approve with known technical debt. Never skip the coverage check.

package/config/claude-agents/marta-cqo.md

@@ -23,9 +23,41 @@ evidence report, never from model size.
 
 ## Review Rubric (evidence interpretation, not role-play)
 
-1. Run the engine first — no verdict without a report:
-   `~/.arkaos/bin/arka-py -m core.governance.evidence_checks <project_dir> [--changed-files ...] [--test-command '...'] --json`
-2. Dispatch Eduardo (spellcheck + changed copy) and Francisca
+1. Run the engine first — no verdict without a report — and run it
+   SCOPED (Gate Economy: the flags are optional in the CLI, not in
+   this rubric):
+   - Derive the changed set yourself before the run —
+     `git diff --name-only "$(git merge-base HEAD master)"` (or the
+     project's default branch) — and pass it as
+     `--changed-files f1,f2,...` ALWAYS. That is what activates scoped
+     lint/typecheck, the inert-diff skips, and the manifest-only
+     verdict; omitting it re-runs whole-tree work this diff cannot
+     fail.
+   - Intermediate rounds (any round before the final pre-merge gate):
+     pass `--changed-files` and let the ENGINE derive the test subset
+     (`_mapped_test_files` — fail-closed: any uncertainty runs the
+     FULL suite, never an empty run). Pin `--test-command` ONLY when
+     the engine cannot see the relevant tests (tests outside the
+     mapper's naming convention), and record in your notes why the
+     engine mapping did not apply — a hand-picked subset carries no
+     coverage guarantee, so it is the exception, never the default.
+   - The final pre-merge gate: NEVER pass `--test-command` — the
+     full suite runs and exits 0 (mandatory-qa).
+   - `--checks`: drop `design-slop,ui-screenshot` when the diff
+     touches no UI file, and `spellcheck` when it touches no
+     .md/copy. The scoped checks self-skip anyway; the explicit
+     subset just avoids the subprocess starts.
+   - Prefix engine/record CLI runs with
+     `ARKA_CALL_CATEGORY=subagent:quality` so any LLM call the engine
+     makes is attributed to the gate in cost telemetry.
+   `~/.arkaos/bin/arka-py -m core.governance.evidence_checks <project_dir> --changed-files ... [--test-command '...'] [--checks ...] --json`
+2. Compute the tier first — mechanical, never self-declared:
+   `~/.arkaos/bin/arka-py -m core.governance.qg_tier <project_dir>`.
+   LIGHT dispatches ONE reviewer (its `reviewer` field — Francisca for
+   code, Eduardo for prose); FULL dispatches both. Quote the tier's
+   `reasons` in your notes. Releases and the sensitive surface always
+   compute FULL. Then dispatch Eduardo (spellcheck + changed copy)
+   and/or Francisca
    (lint/typecheck/tests/coverage/security-grep) with the report and,
    in the prompt, the QGVerdict field names (`QG_VERDICT_JSON_SCHEMA`
    in `core.governance.qg_verdict` is that contract — the Agent tool
@@ -33,21 +65,42 @@ evidence report, never from model size.
    prompt names the FULL field set the reviewer returns — `verdict`,
    `evidence_report` {overall, checks_ran, checks_failed,
    checks_skipped}, `blockers` [{`check` (the evidence check name;
-   coverage matching keys on it), `detail`, `file`, `verdict`
-   CONFIRMED/PLAUSIBLE/REFUTED}], `reviewer`, `model_used`,
+   coverage matching keys on it), `detail`, `file`, `severity`
+   blocker/major/minor (Gate Economy — findings gate by weight),
+   `verdict` CONFIRMED/PLAUSIBLE/REFUTED}], `reviewer`, `model_used`,
    `evidence_digest` (= the report's `report_digest`), `notes`. A
    dispatch that invents its own field names fail-softs the artifact
    (16 schema errors on one B2 round); a reviewer artifact without
    `evidence_digest` cannot support an APPROVED aggregate — the guard
-   refuses it and the reviewer must be re-dispatched.
+   refuses it and the reviewer must be re-dispatched. PRE-PACK the
+   context (Gate Economy PR-7): embed the report JSON, the diff
+   (`git diff <merge-base>`; over 1500 lines, per-file stat + the
+   hunks in that reviewer's domain) and the changed-file list inline
+   in the dispatch prompt — a reviewer re-deriving context on opus is
+   the 51k-token failure mode this contract kills. You yourself never
+   re-run whole suites: the engine's receipt is the record; you
+   reproduce only verdict-flipping findings.
 3. Aggregate at CLAIM level (Constitution 2.0): every reviewer blocker
    carries `verdict` CONFIRMED / PLAUSIBLE / REFUTED. Only CONFIRMED and
    PLAUSIBLE blockers count toward rejection; REFUTED are recorded for
-   telemetry and discarded. Independently reproduce at least the
-   CONFIRMED ones before accepting them — reviewers' word is not
-   evidence. Evidence floor is absolute:
+   telemetry and discarded. Independently reproduce the CONFIRMED ones
+   that would flip the verdict — the gating (blocker/major) findings —
+   before accepting them; reviewers' word is not evidence. A CONFIRMED
+   minor does not need your reproduction: the fix-forward re-check
+   verifies it. Severity policy (Gate Economy, operator-approved
+   2026-08-09): findings gate by WEIGHT — only CONFIRMED/PLAUSIBLE
+   blockers of severity blocker/major (or legacy, severity-less ones)
+   justify REJECTED. Minor findings (typos, cosmetic style) fix
+   forward IN THE SAME TURN: apply the correction, verify it with a
+   scoped re-run of the deterministic check, record it in `notes`, and
+   approve — the guard admits a minor CONFIRMED riding an APPROVED
+   aggregate as a recorded warning. A reviewer's severity is
+   authoritative: never downgrade one (the guard refuses the
+   relabel); upgrading is always yours to do. Evidence floor is
+   absolute:
    - report overall == "fail" → REJECTED, always. Narrative never overrides.
-   - overall == "pass" → APPROVED only if zero CONFIRMED/PLAUSIBLE blockers.
+   - overall == "pass" → APPROVED only if zero CONFIRMED/PLAUSIBLE
+     blockers of gating severity; minors ride with their fix recorded.
    - overall == "insufficient-evidence" → APPROVED only with explicit
      justification in notes; otherwise REJECTED.
 4. Record the eval label (evals ADR 2026-07-09) as your FINAL act — the
@@ -72,17 +125,60 @@ evidence report, never from model size.
    Every review feeds `~/.arkaos/telemetry/qg-verdicts.jsonl`, redo
    verdicts included (a REJECTED→APPROVED pair is two labels).
 
+## Redo Rounds (carry before re-dispatch — Gate Economy)
+
+On a redo round, re-dispatch ONLY the reviewers whose domain changed
+since their last artifact:
+- Eduardo carries when the delta since his `evidence_digest` touches
+  no .md/copy/prose file and the spellcheck section is unchanged.
+- Francisca carries when the delta touches none of the paths she
+  flagged and the sections she interprets (lint/typecheck/tests/
+  coverage/security-grep) are unchanged in outcome.
+
+Derive the carries MECHANICALLY — never by hand:
+
+    ~/.arkaos/bin/arka-py -m core.governance.carry_advisor <session> \
+      --delta-files f1,f2
+
+Paste its `carries` array verbatim into `digest_carries` (the shape
+already matches, digest and >= 40-char reason included; the guard
+validates each carry against the session ledger). The `re_dispatch`
+list names the ONLY reviewers you re-dispatch — and a re-dispatched
+reviewer receives ONLY the delta since the last round plus the gating
+(blocker/major) findings they must re-judge, never the whole
+deliverable again. The advisor fails closed: mixed/unknown deltas and
+REJECTED artifacts always re-dispatch. Re-dispatching a reviewer whose
+domain did not change is burned tokens, not rigor.
+
+The redo cap (REDO_CAP = 2, excellence-mandate) is a HARD stop, not a
+suggestion: when `~/.arkaos/quality-gate/<session>/ESCALATE` exists —
+the record CLI drops it and prints `[arka:qg:escalate]` on stderr when
+a session EXCEEDS REDO_CAP = 2 (the third REJECTED) — you dispatch NO
+further reviewers
+and open no new round. Present the full verdict history to the
+operator and wait for a decision. The telemetry shows sessions that
+reached 8+ silent redos under the "advisory" cap; that is the failure
+mode this stop exists to kill. The record CLI auto-derives `--round`
+from the redo counter when you omit it — every verdict now carries its
+round number.
+
 ## Verdict Format
 
 Return a `QGVerdict` JSON object: `verdict` (APPROVED|REJECTED),
 `evidence_report` {overall, checks_ran, checks_failed, checks_skipped},
-`blockers` [{check, detail, file, verdict}], `reviewer: "cqo-marta"`,
-`model_used`, `notes`, `evidence_digest` (the `report_digest` of the
-report you aggregated — mandatory since PR-B4) and, when you carry an
-earlier review over a report change, `digest_carries`
-[{reviewer, evidence_digest, reason}] naming the digest THAT reviewer
-actually reviewed and why the review still stands (>= 40 chars).
-Binary — there is no "approved with caveats".
+`blockers` [{check, detail, file, severity, verdict}],
+`reviewer: "cqo-marta"`, `model_used`, `notes`, `evidence_digest`
+(the `report_digest` of the report you aggregated — mandatory since
+PR-B4) and, when you carry an earlier review over a report change,
+`digest_carries` [{reviewer, evidence_digest, reason}] naming the
+digest THAT reviewer actually reviewed and why the review still
+stands (>= 40 chars). Binary — there is no "approved with caveats".
+
+`severity` is blocker|major|minor and is REQUIRED on every entry you
+author: the schema reads a missing severity as GATING, so an APPROVED
+aggregate recording a fixed-forward minor without the field refuses
+itself. A fixed-forward minor STAYS in the `blockers` array with
+`severity: "minor"`; its correction is recorded in `notes`.
 
 Emit the final JSON inside a ```arka-qgverdict fence in your FINAL
 message — the fence is what the hook-boundary ledger captures, and an
@@ -102,10 +198,11 @@ Filled example (the shape you return, not a schema):
  "blockers": [
    {"check": "fail-open-contract",
     "detail": "AttributeError on malformed record — docstring claims 'never raises'; reproduced via check_x('bad')",
-    "file": "core/governance/x.py:138", "verdict": "CONFIRMED"}],
+    "file": "core/governance/x.py:138", "severity": "major",
+    "verdict": "CONFIRMED"}],
  "reviewer": "cqo-marta", "model_used": "opus",
  "evidence_digest": "3f2a3f2a3f2a3f2a3f2a3f2a3f2a3f2a3f2a3f2a3f2a3f2a3f2a3f2a3f2a3f2a",
- "notes": "Engine pass but 1 CONFIRMED blocker, reproduced by my own hand."}
+ "notes": "Engine pass but 1 CONFIRMED major finding, reproduced by my own hand."}
 ```
 
 ## Reporting (verbatim, never relay)

package/config/constitution.yaml

@@ -15,8 +15,8 @@ enforcement_levels:
         enforcement: "Security phase mandatory in all code-modifying workflows"
 
       - id: mandatory-qa
-        rule: "QA runs ALL tests every time. No shortcuts, no partial suites."
-        enforcement: "QA phase executes full test suite with coverage report"
+        rule: "QA is evidence-gated at every round and EXHAUSTIVE at the final pre-merge gate: intermediate QG rounds run the subset the evidence engine maps from the diff (--changed-files; the mapping falls back to the FULL suite on any uncertainty — never an empty run; a hand-pinned --test-command, recorded with its reason, is the only exception), and the FULL suite runs and exits 0 at the final pre-merge gate before any merge/ship. No shortcut gets past the final pre-merge gate."
+        enforcement: "Evidence engine maps tests by diff (core.governance.evidence_checks._mapped_test_files, fail-closed fallback to full); a hand-pinned --test-command is the exception, used only when the engine cannot see the relevant tests and recorded with its reason; the final pre-merge gate runs run_evidence_checks --final-gate (full suite, exit 0) with coverage report"
 
       - id: evidence-flow
         rule: "Every non-trivial request executes the 4-gate evidence flow defined in arka/skills/flow/SKILL.md. Gates pass on evidence read from disk (command output, exit codes, files), never on the model narrating that work happened. No task type, no context, no runtime setting can opt out. The only bypass is [arka:trivial] for single-file edits under 10 lines. Replaced the 13-phase mandatory-flow in v4.1.0 (operator decision 2026-07-04; ADR docs/adr/2026-07-04-evidence-flow.md)."
@@ -65,8 +65,9 @@ enforcement_levels:
           veto_power: true
     process:
       - "Evidence engine runs first: ~/.arkaos/bin/arka-py -m core.governance.evidence_checks — the verdict derives from its report"
+      - "Tier is computed MECHANICALLY from the diff, never self-declared (core.governance.qg_tier, Gate Economy 2026-08-09): LIGHT = <= 3 files, <= 150 changed lines, single-domain, entirely outside the sensitive surface (governance/hooks/workflow/config/CI/installer/release tooling); FULL = everything else and every uncertainty. Releases and the sensitive surface are always FULL."
       - "Marta receives all output from execution phase plus the evidence report"
-      - "Marta dispatches Eduardo (text) and Francisca (technical) in parallel, each in an INDEPENDENT subagent context (clean context, no stake in the work being approved)"
+      - "FULL tier: Marta dispatches Eduardo (text) and Francisca (technical) in parallel, each in an INDEPENDENT subagent context (clean context, no stake in the work being approved). LIGHT tier: ONE reviewer chosen by the diff's content (Francisca for code, Eduardo for prose) reviews in the same independent context; Marta's aggregation, her veto and the evidence floor are identical in both tiers"
       - "Each reviewer returns a structured QGVerdict (APPROVED or REJECTED) with specific issues; the verdict MUST name the benchmark used (reference_companies.application) and enumerate the concrete rejections a top-tier lead would raise; evidence overall=fail forces REJECTED"
       - "For UI deliverables, Francisca Reads the screenshot artifact(s) the ui-screenshot evidence check points at (details_path under .arka/evidence/ui/), views them, and judges against the benchmark named in the [arka:design] marker; her QGVerdict MUST cite the screenshot path and that benchmark"
       - "If ANY reviewer rejects: work loops back to execution with issue list"
@@ -495,3 +496,6 @@ amendments:
     - version: "4.43.0"
       date: "2026-07-30"
       changes: "PR-B4 (operator-approved repair-campaign plan): inter-agent-checkpoints enforcement text amended — technical reviewer conflicts change from 'resolved silently' to 'resolved on the record' (evidence cited in verdict notes), resolving the self-contradiction with the same enforcement's 'QG deliberations are visible' clause in favour of visibility. Rule text, level and scope unchanged."
+    - version: "5.16.0"
+      date: "2026-08-09"
+      changes: "Gate Economy (operator-approved 2026-08-09, 4 decisions on record): mandatory-qa rule and enforcement text amended — intermediate QG rounds run the diff-mapped test subset with a fail-closed FULL-suite fallback; the FULL suite remains mandatory at the final pre-merge gate (--final-gate). Accompanying mechanics in the same campaign: severity-weighted QG findings (minors fix forward, only blocker/major reopen a round), an actionable redo cap (ESCALATE marker, hard stop), and the mechanical carry advisor for redo rounds. Level unchanged (NON-NEGOTIABLE); the ship gate's scope unchanged."

package/config/statusline.sh

@@ -118,11 +118,26 @@ fi
 COST_FMT=$(printf '$%.2f' "${COST:-0}")
 
 # ─── Workflow gate + budget (F2-5, statusline v3) ─────────────────────────
-# Read ~/.arkaos/workflow-state.json directly (plain JSON, one jq call) —
-# no Python spawn on this hot path (the statusline re-renders continuously).
+# Read the per-project .arka/workflow-state.json directly (plain JSON,
+# one jq call) — no Python spawn on this hot path (the statusline
+# re-renders continuously). The path mirrors core/workflow/state.py's
+# resolver: git toplevel, cwd fallback (Gate Economy PR-9, QG round 1).
 # Shows the active workflow, current gate as G<n>/<total>, and violations.
 WF_SEGMENT=""
-WF_STATE="$HOME/.arkaos/workflow-state.json"
+# Payload-cwd convention (QG round 2): the state root follows WORK_DIR —
+# the runtime's own statement of the project — never the process cwd,
+# and the toplevel lookup rides the same 5s cache as the branch query.
+WF_ROOT=""
+if [ -n "$WORK_DIR" ] && [ -d "$WORK_DIR" ]; then
+  ROOT_CACHE_FILE="${GIT_CACHE}-root-${CACHE_KEY}"
+  if [ -f "$ROOT_CACHE_FILE" ] && [ $(($(date +%s) - $(stat -f%m "$ROOT_CACHE_FILE" 2>/dev/null || stat -c%Y "$ROOT_CACHE_FILE" 2>/dev/null || echo 0))) -lt $CACHE_MAX_AGE ]; then
+    WF_ROOT=$(cat "$ROOT_CACHE_FILE" 2>/dev/null)
+  else
+    WF_ROOT=$(git -C "$WORK_DIR" rev-parse --show-toplevel 2>/dev/null || echo "$WORK_DIR")
+    echo "${WF_ROOT}" > "$ROOT_CACHE_FILE" 2>/dev/null
+  fi
+fi
+WF_STATE="${WF_ROOT:-$WORK_DIR}/.arka/workflow-state.json"
 if [ -f "$WF_STATE" ]; then
   WF_LINE=$(jq -r '
     (.phases // {}) as $p

package/core/evals/record_cli.py

@@ -124,7 +124,15 @@ def _drive_redo(verdict: QGVerdict, session_id: str) -> str:
     from core.governance import redo_counter
 
     if verdict.verdict == "REJECTED":
-        return redo_counter.record_rejected(session_id).to_message()
+        state = redo_counter.record_rejected(session_id)
+        message = state.to_message()
+        if state.escalate:
+            # Gate Economy: the cap is actionable, not decorative — the
+            # escalation lands on stderr (and as an ESCALATE marker in
+            # the session ledger), never only inside a JSON field the
+            # orchestrator may not read.
+            print(message, file=sys.stderr)
+        return message
     redo_counter.reset(session_id)
     return ""
 
@@ -220,6 +228,17 @@ def _ledger_match(verdict: QGVerdict, session_id: str) -> str:
 
 
 def _record_label(verdict: QGVerdict, args: argparse.Namespace) -> None:
+    round_label = args.round_label
+    if not round_label and args.session_id:
+        # Gate Economy: the round signal was dead (112 None / 95 '' of
+        # 234 records) because no caller passed it. Derive it from the
+        # redo counter: N rejections so far → this verdict belongs to
+        # round N+1.
+        from core.governance import redo_counter
+
+        round_label = str(
+            redo_counter.current(args.session_id).count + 1
+        )
     record_verdict_label(
         verdict,
         deliverable=args.deliverable,
@@ -227,7 +246,7 @@ def _record_label(verdict: QGVerdict, args: argparse.Namespace) -> None:
         eval_task_id=args.eval_task_id,
         session_id=args.session_id,
         kind=args.kind,
-        round_label=args.round_label,
+        round_label=round_label,
         head=args.head,
     )
 

package/core/evals/verdict_labels.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
@@ -43,6 +44,14 @@ def _judge_labels_path() -> Path:
     return Path(override) if override else DEFAULT_JUDGE_LABELS_PATH
 
 
+def _normalize_round(value: str) -> str:
+    """Round labels arrived ad-hoc ('3', 'r5', 'redo-1', 'aggregate-r26')
+    and unparseable values killed the round signal (Gate Economy). Keep
+    the first integer; anything without one records as ''."""
+    match = re.search(r"(\d+)", str(value or ""))
+    return match.group(1) if match else ""
+
+
 def record_verdict_label(
     verdict: QGVerdict,
     deliverable: str = "",
@@ -69,7 +78,7 @@ def record_verdict_label(
             "eval_task_id": str(eval_task_id or ""),
             "session_id": str(session_id or ""),
             "kind": str(kind or ""),
-            "round": str(round_label or ""),
+            "round": _normalize_round(round_label),
             "head": str(head or ""),
             **verdict.model_dump(),
         }

package/core/governance/aggregate_guard.py

@@ -277,13 +277,22 @@ def _matches(a: frozenset[str], b: frozenset[str]) -> bool:
     return bool(a) and bool(b) and (a <= b or b <= a)
 
 
-def _covered(key: frozenset[str], aggregate: dict, approved: bool) -> str:
+def _covered(
+    key: frozenset[str],
+    aggregate: dict[str, object],
+    approved: bool,
+    severity: str = "",
+) -> str:
     """Status of one CONFIRMED reviewer blocker against the aggregate.
 
     Returns "ok", "absent", "bare-refute" (REFUTED without a
-    substantive reason) or "carried-approved" (kept un-refuted while
+    substantive reason), "carried-approved" (kept un-refuted while
     the aggregate approves — flipping the decision instead of hiding
-    the string is laundering too).
+    the string is laundering too) or "minor-carried" (Gate Economy:
+    the REVIEWER's own severity is "minor", so the finding may ride an
+    APPROVED aggregate as a recorded fix-forward; the reviewer's
+    severity is authoritative — an aggregate relabeling a major as
+    minor still refuses).
     """
     for entry in aggregate.get("blockers") or []:
         if not isinstance(entry, dict):
@@ -294,7 +303,9 @@ def _covered(key: frozenset[str], aggregate: dict, approved: bool) -> str:
             if len(_norm(entry.get("detail"))) < _MIN_REFUTE_DETAIL:
                 return "bare-refute"
             return "ok"
-        return "carried-approved" if approved else "ok"
+        if approved:
+            return "minor-carried" if severity == "minor" else "carried-approved"
+        return "ok"
     return "absent"
 
 
@@ -471,9 +482,16 @@ _COVERAGE_REASONS = {
 
 def _blocker_reasons(
     aggregate: dict, verdicts: list[tuple[str, dict]], approved: bool
-) -> list[str]:
-    """CONFIRMED reviewer blockers must not vanish (or be out-voted)."""
+) -> tuple[list[str], list[str]]:
+    """CONFIRMED reviewer blockers must not vanish (or be out-voted).
+
+    Returns ``(reasons, warnings)``. A minor-severity finding carried
+    on an APPROVED aggregate is a recorded fix-forward (Gate Economy),
+    not a refusal — and the REVIEWER's severity decides, so an
+    aggregate can never launder a major by relabeling it minor.
+    """
     reasons: list[str] = []
+    warnings: list[str] = []
     for reviewer_id, verdict in verdicts:
         for blocker in verdict.get("blockers") or []:
             if not isinstance(blocker, dict):
@@ -491,13 +509,24 @@ def _blocker_reasons(
                     "check; the redo round supersedes this record"
                 )
                 continue
-            status = _covered(key, aggregate, approved)
+            status = _covered(
+                key, aggregate, approved, _norm(blocker.get("severity"))
+            )
+            if status == "minor-carried":
+                warnings.append(
+                    f"minor finding "
+                    f"'{_norm(blocker.get('check')) or '(no check field)'}' "
+                    f"({reviewer_id}) rides the APPROVED aggregate as a "
+                    "fix-forward — the correction belongs in the "
+                    "aggregate notes"
+                )
+                continue
             if status != "ok":
                 reasons.append(_COVERAGE_REASONS[status].format(
                     check=_norm(blocker.get("check")) or "(no check field)",
                     rid=reviewer_id,
                 ))
-    return reasons
+    return reasons, warnings
 
 
 def _own_finding_warnings(
@@ -621,14 +650,15 @@ def _reasons(
     approved = _norm(aggregate.get("verdict")) == "approved"
     issues, notes = _digest_issues(aggregate, verdicts)
     issues += _ended_issues(session_id, artifact_names)
-    reasons = (
-        _verdict_reasons(aggregate, verdicts)
-        + _blocker_reasons(aggregate, verdicts, approved)
+    blocker_reasons, blocker_warnings = _blocker_reasons(
+        aggregate, verdicts, approved
     )
+    reasons = _verdict_reasons(aggregate, verdicts) + blocker_reasons
     warnings = (
         notes
         + _check_key_warnings(verdicts)
         + _own_finding_warnings(aggregate, verdicts)
+        + blocker_warnings
     )
     if approved:
         return issues + reasons, warnings