@chrono-meta/fh-gate 3.0.0 → 3.1.1

package/plugins/fh-qp/skills/qp/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: qp
+description: QP (Quality Platform) router — takes a web URL or a desktop app name and runs the plan → run → regress loop (qp-plan, qp-run, qp-regress) end to end, or routes to one stage. Classifies the target (public vs profile-required), probes which adapter the session has (Playwright MCP for web, computer-use MCP for desktop), and writes every artifact with a typed engine/adapter marker. Triggers on "test this website for me", "run a QA pass on this app", "check the app end to end", "이 사이트 QA 돌려줘", "이 앱 테스트해줘", "회귀 돌려줘".
+user-invocable: true
+allowed-tools: ["Read", "Bash", "Write", "Glob", "Grep"]
+model: sonnet
+origin: chamber run fh-qa-generic (2026-09-05) — generic edition of a field QA harness's P·A·R loop; zero domain constants
+---
+
+# qp — Quality Platform router
+
+One entry point for people who want to **dynamically test a web or desktop app with a QA lens from inside Claude Code**.
+Three stages, each its own skill, each leaving files:
+
+| stage | skill | you get |
+|---|---|---|
+| **P**lan | `qp-plan` | `qp/plan/inventory.md` (surfaces the app exposes) + `qp/plan/tcs.tsv` (test cases) |
+| **A**utomation (run) | `qp-run` | `qp/run/<ts>/verdicts.tsv` + masked evidence (DOM snapshots or screenshots) |
+| **R**egression | `qp-regress` | `qp/regress/<ts>/surface_reach.txt` + per-TC delta vs the previous run |
+
+Glossary (one line each, because a first-time reader asked): **TC** = test case · **inventory** = the list of screens/routes/menus the app exposes · **MTM** = each finding is labeled *as planned* / *differs from the plan document* / *code differs* · **precondition** = what must already be true before a step runs (logged in, page loaded), checked not assumed — a failure before it is met is `BLOCKED`, not `FAIL` · **surface_reach** = how many TCs actually left the entry screen · **engine** = which machinery drove the run (see §Engine).
+
+## Step 0 — classify the target (mechanical, never by eye)
+
+```
+bash plugins/fh-qp/scripts/qp_tools.sh target-class <https://… | app:NAME> [--profile <file>]
+```
+| result | rc | what you do |
+|---|---|---|
+| `PUBLIC` | 0 | proceed |
+| `PROFILE_OK` | 0 | proceed with the profile |
+| `PROFILE_REQUIRED` | 4 | **stop.** Say: *"this target is not public; QP needs a profile file — copy `plugins/fh-qp/qp_profile.example.yaml` to a gitignored path, fill the host/app, and re-run with `--profile`."* Do not improvise a run against a private host. |
+| `UNKNOWN` | 10 | stop, report the target form QP accepts |
+
+## Step 1 — probe the adapter (mechanical; unknown ≠ present)
+
+List the MCP tool names this session actually has (from your tool list — do not guess), then:
+```
+bash plugins/fh-qp/scripts/qp_tools.sh adapter-probe --need web|desktop --tools "<comma-separated tool names>"
+```
+`ADAPTER=… evidence=dom|pixel` → proceed and **write that line into every artifact header**.
+`HARNESS_ERROR` (rc 10) → **stop.** Write `qp/HARNESS_ERROR.txt` with the reason and tell the user which MCP to connect (Playwright MCP for web · computer-use MCP for desktop). This is not a pass and not a skip.
+
+## Engine — typed capability vs MCP fallback (form C)
+
+- If a QA harness has **registered** a typed capability whose id ends in `:par` (check `.claude/capabilities/**/*.cap` and `bash scripts/cluster_capability_scan.sh` when in an FH hub), call its `entry` and merge constraints **strictest-wins** (`capability_composition_contract.md`). Engine marker: `engine=capability:<id>`.
+- Otherwise drive the target yourself through the adapter from Step 1. Engine marker: `engine=mcp-fallback adapter=<name> evidence=dom|pixel`.
+- **As of 2026-09-05 no such capability is registered anywhere** — the fallback is the only path that exists. If the user explicitly asks for the capability engine (`--engine capability`) and none is registered → `HARNESS_ERROR reason=capability-not-registered`, never a silent fallback.
+- Desktop (`evidence=pixel`) is the **weaker edition**: no DOM, so `verify` closes only by screenshot text you can read, and surface_reach hashes screenshots, not DOM. Say so in the report header.
+
+## Step 2 — run the stages
+
+`qp <target>` = plan → run → regress in order, stopping at the first `HARNESS_ERROR`. `qp plan|run|regress <target>` = one stage. Each stage skill carries its own Done When.
+
+## Done When
+1. Target classified with a `target-class` line recorded in `qp/plan/inventory.md` header · **[mandatory-pass]** — rc is the check.
+2. Adapter probed and `ADAPTER=` or `HARNESS_ERROR` written to a file · **[mandatory-pass]** — file exists and matches the probe output.
+3. Every artifact header carries `engine=` and `evidence=` · **[measured]** — `grep -L 'engine=' qp/**/*.md qp/**/*.tsv` is empty.
+4. Stages chained in P→A→R order with no stage skipped silently · **[judged — pairing: the lane `scripts/test_fh_qp_lanes.sh` and the per-stage Done When files]**.
+
+## Independently executable
+Needs only `bash` + the session's MCP adapter. No other FH skill is required. Inside an FH hub the capability scan is optional.
+
+## Not this skill
+Mobile (deferred). Verifying FH itself (use FH's own gates). Fixing the app.

package/plugins/fh-qp/skills/qp-plan/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: qp-plan
+description: Prepare stage of QP — builds a surface inventory of a web page or desktop app (routes, menus, forms, dialogs), checks it is MECE (no overlap, nothing missing that is visible), and designs test cases as a TSV with preconditions and expected values whose SOURCE is named. Works without a spec document (then expected values come from the inventory, not a plan). Triggers on "what should I test on this page", "make a test plan for this app", "list the screens of this app", "테스트 케이스 뽑아줘", "이 화면 인벤토리 만들어줘".
+user-invocable: true
+allowed-tools: ["Read", "Bash", "Write", "Glob", "Grep"]
+model: sonnet
+origin: chamber run fh-qa-generic (2026-09-05)
+---
+
+# qp-plan — Prepare (inventory → MECE → TCs)
+
+Input: a target that passed `qp_tools.sh target-class` (PUBLIC or PROFILE_OK) and an adapter line from `adapter-probe`. Optional: a plan/spec document path (`--plan <file>`). Optional profile.
+
+## 1. Surface inventory — observe, do not guess
+Open the entry route with the adapter (web: navigate + accessibility snapshot; desktop: screenshot). Record every **navigable surface** you can see: links/routes, menu items, buttons that open a dialog, forms, tabs. One row each:
+
+```
+| id | kind (route·menu·dialog·form·tab) | label as shown | how reached (from which surface, which action) | observed? (yes/no) |
+```
+Rules: ⓐ **do not invent routes** — a surface is listed only if you saw its trigger; ⓑ parameterised routes (`/item/:id`) are listed as `ROUTE_PARAMETERIZED`, not filled with a made-up id; ⓒ if the entry route did not load → stop with `HARNESS_ERROR reason=entry-unreachable`. Write `qp/plan/inventory.md` with the header lines `target-class: …` (the tool's literal output), `ADAPTER=… evidence=dom|pixel` (the probe's literal output), `engine=mcp-fallback` (or `engine=capability:<id>` only if the `qp` router found a registered capability — never a browser name; a floor-tier sim wrote `engine=chromium` when this line did not say so, 2026-09-05), `plan_doc: <path|NONE>`.
+
+## 2. MECE check
+Walk the inventory once more against the snapshot: any visible navigable element not in the list → add it (**missing**); any two rows reaching the same surface → merge (**overlap**). Write the count of each fix under `## MECE` in inventory.md. Zero fixes is a legitimate value; an unstated count is not.
+
+## 3. Test-case design — `qp/plan/tcs.tsv`
+Tab-separated, header row:
+```
+tc_id	surface_id	precondition	step_verb	step_target	expected	expected_source	priority
+```
+- `step_verb` ∈ `navigate click input verify` (one verb per row; a multi-step TC is several rows sharing `tc_id`).
+- `expected_source` ∈ `PLAN_DOC INVENTORY CODE HUMAN` — **where the expected value came from**. With no plan document every row is `INVENTORY` (or `HUMAN` if the user told you). This field is what lets `qp-run` label a finding *differs from plan* vs *code differs*; a TC without it cannot be run.
+- `precondition` is what must be true before step 1 (e.g. `at:/`, `logged-in`). Write `none` explicitly when there is none.
+- **At least one TC must carry a state-changing verb (`click` or `input`)** — a verify-only plan never exercises the runner (`qp_tools.sh run-verbs` enforces this on the run output).
+- Minimum: inventory ≥ 5 surfaces, TCs ≥ 3 for a first pass; say when the target is too small to reach that (a one-page site can be).
+
+## Done When
+1. `qp/plan/inventory.md` exists with the four header lines and ≥1 observed surface · **[mandatory-pass]**.
+2. `qp/plan/tcs.tsv` parses: every row has 8 fields, `step_verb` and `expected_source` in their enums, ≥1 click/input row · **[measured]** — `awk -F'\t' 'NF!=8' tcs.tsv` prints nothing; `run-verbs` on the later verdicts is OK.
+3. No surface in the inventory was invented (each has `observed? yes` or a `ROUTE_PARAMETERIZED` mark) · **[judged — pairing: a second session re-opens the entry route and diffs the inventory; the lane's residency/zero-constant grep on the plan files]**.
+
+## Independently executable
+Yes — bash + adapter. Does not need `qp-run`.

package/plugins/fh-qp/skills/qp-regress/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: qp-regress
+description: Regression stage of QP — re-executes a previous run's test cases unchanged, computes surface_reach (how many TCs left the entry screen, as a ratio over ALL TCs), and reports the per-TC delta against the earlier run so a "no change" claim is per case, not an aggregate. Triggers on "did anything regress since last run", "re-run last week's QA pass", "compare this run with the previous one", "회귀 확인해줘", "지난 런이랑 비교해줘".
+user-invocable: true
+allowed-tools: ["Read", "Bash", "Write", "Glob", "Grep"]
+model: sonnet
+origin: chamber run fh-qa-generic (2026-09-05)
+---
+
+# qp-regress — Regression (re-run unchanged → surface_reach → delta)
+
+Input: a baseline `qp/run/<ts>/` and the same `qp/plan/tcs.tsv`. Output: `qp/regress/<ts>/`.
+
+## 1. Re-run unchanged
+Execute the baseline's TCs with `qp-run` **without editing them**. Editing a TC to make it pass is a new run, not a regression — say so if the user asks for it.
+
+## 2. surface_reach — did the batch leave the entry screen?
+```
+bash plugins/fh-qp/scripts/qp_tools.sh surface-reach qp/run/<new-ts>/evidence.tsv
+```
+| result | meaning |
+|---|---|
+| `REACHED n/n` | every TC observed a screen other than the modal (entry) one |
+| `PARTIAL k/n` | some did — report **which** did not, by tc_id |
+| `NOT_REACHED 0/n` | the whole batch sat on one screen (a login wall, a dead env). Every FAIL in that run is **unmeasured**, not a detection — write that sentence in the report |
+| `UNMEASURED` (rc 10) | no evidence file / empty — not a zero |
+Denominator is **all TCs**, including ones that never executed; write `surface_reach.txt` with the raw line.
+
+## 3. Per-TC delta — `delta.tsv`
+```
+tc_id	baseline_status	new_status	changed	note
+```
+One row per TC. `changed=yes` on any status change **or** on a same-status verdict whose `closure` moved from MACHINE to JUDGMENT (the check got weaker). A run where every row is `changed=no` may say "no regression"; a run reported only as "12 PASS both times" may not — the aggregate hides a swap.
+
+## 4. Report — `report.md`
+First 8 lines: target · engine/adapter/evidence · `#mtm:` state · surface_reach line · counts PASS/FAIL/BLOCKED/AMBIGUOUS new vs baseline · number of `changed=yes` · the sentence for NOT_REACHED if it applies · what was **not** measured (unexecuted TCs, dropped screenshots).
+
+## Done When
+1. `surface_reach.txt` holds a `REACHED|PARTIAL|NOT_REACHED|UNMEASURED` line produced by the tool · **[mandatory-pass]**.
+2. `delta.tsv` has one row per TC in the baseline · **[measured]** — row count equals distinct tc_ids.
+3. A NOT_REACHED run's report contains the "FAILs are unmeasured" sentence · **[measured]** — grep.
+4. The delta's `changed` column reflects real behavior change, not selector drift · **[judged — pairing: for each `changed=yes`, the before/after DOM snapshots are attached and a second session confirms the element moved, not the locator]**.
+
+## Independently executable
+Yes — needs a baseline run dir in the documented shape and bash.

package/plugins/fh-qp/skills/qp-run/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: qp-run
+description: Automation stage of QP — executes the test cases from qp-plan against the live app through the session's adapter (Playwright MCP for web, computer-use MCP for desktop), records one verdict per step with a closed status, an MTM branch, whether the step was closed by machine evidence or left to judgment, and masks emails/tokens/passwords out of the evidence before saving. Triggers on "run these test cases", "execute the QA plan against the site", "drive the app through the TCs", "TC 실행해줘", "플랜대로 돌려줘".
+user-invocable: true
+allowed-tools: ["Read", "Bash", "Write", "Glob", "Grep"]
+model: sonnet
+origin: chamber run fh-qa-generic (2026-09-05)
+---
+
+# qp-run — Automation (execute → verdict → mask)
+
+Input: `qp/plan/tcs.tsv` + the adapter/engine lines from `qp/plan/inventory.md`. Output dir: `qp/run/<YYYYMMDD-HHMM>/`.
+
+## 0. MTM state — decide once, write it first
+`#mtm:` is the first line of `verdicts.tsv`:
+| value | when |
+|---|---|
+| `ACTIVE` | a plan document was given **and** you opened it (path recorded) |
+| `UNAVAILABLE` | no plan document — expected values come from the inventory; the branch *differs from plan* is **unreachable** and the vocabulary collapses to AS_PLANNED / CODE_DIFFERS |
+| `FAILED` | a plan document was given but could not be read — say so; do not fall back silently |
+| `DISABLED` | the user turned it off (reason recorded) |
+`UNAVAILABLE` and `FAILED` are different events; never merge them.
+
+## 1. Precondition first — attribution, not blocking
+Before step 1 of each TC, establish its `precondition`. Navigation you can do (`at:/about`) you do; state you cannot create (`logged-in`, `has-an-order`) you mark `UNMET_UNEXECUTABLE`. A step-1 failure under an unmet precondition is **`BLOCKED`**, not `FAIL` — you never reached the screen, so it is not a claim about the app. Only step 1 is re-attributed; later steps failed after arrival.
+
+## 2. Execute each step, observe before and after
+web: accessibility snapshot before → action → snapshot after. desktop: screenshot before/after. Save each observation as `<tc_id>_step<N>_{before,after}.{md,png}` and append its stable id from `bash plugins/fh-qp/scripts/qp_tools.sh screen-id <file>` (a content hash — Playwright MCP ref tokens change every navigation, so a raw file hash is NOT stable; measured 2026-09-05) to `evidence.tsv` (`tc_id<TAB>step<TAB>screen_hash`) — this file is what `qp-regress` reads.
+
+## 3. Verdict row per step — `verdicts.tsv` (7 tab-separated fields)
+```
+tc_id	status	branch	closure	verb	assertion	expected_source
+```
+- `status` ∈ `PASS FAIL BLOCKED AMBIGUOUS` (AMBIGUOUS = could not map the step to one element: 0 candidates or a tie).
+- `branch` ∈ `AS_PLANNED DIFFERS_FROM_PLAN CODE_DIFFERS NONE`. `DIFFERS_FROM_PLAN` only under `#mtm: ACTIVE` and only with `expected_source=PLAN_DOC`. `CODE_DIFFERS` needs `expected_source` `CODE` or `PLAN_DOC`. `NONE` only for BLOCKED/AMBIGUOUS.
+- `closure` = `MACHINE` **only if** `assertion` names the check that closed it (`text-visible:About`, `url==…`, `element-count==3`). An empty assertion with `MACHINE` is invalid — that is the muscle-not-skeleton hole this field exists to close. Everything you decided by reading a screenshot is `JUDGMENT`.
+- Validate before you finish: `bash plugins/fh-qp/scripts/qp_tools.sh mtm-check verdicts.tsv` must print `OK`; `run-verbs verdicts.tsv` must print `OK` (≥1 click/input actually executed).
+
+## 4. Mask, then save — original 0
+Every text artifact goes through `qp_tools.sh mask <in> <out>` and only `<out>` is kept; delete `<in>`. `RESIDUE` (rc 5) → do not keep the file; report which artifact. Typed secret values (from the profile's `*_env`) are read from the environment at type-time and never written. Screenshots that show a filled password field are kept only if the field is masked in the image (crop or overlay); otherwise drop the screenshot and say so.
+
+## Done When
+1. `verdicts.tsv` passes `mtm-check` and `run-verbs` · **[mandatory-pass]** — rc 0 both.
+2. `evidence.tsv` has ≥1 row per executed TC · **[measured]**.
+3. Masking: `grep -cE '@|Bearer|eyJ' <saved artifacts>` is 0 outside `__REDACTED_*__` markers · **[measured]** — the lane reproduces it on a known-dirty fixture.
+4. Every BLOCKED verdict names its unmet precondition; every JUDGMENT closure says what was read · **[judged — pairing: `qp-regress` re-runs the same TCs and flags verdicts that flip without a DOM change; a second session reviews BLOCKED rows against the before-snapshots]**.
+
+## Independently executable
+Yes, given a `tcs.tsv` in the documented shape (hand-written is fine) and an adapter.

package/scripts/chamber_run.sh

@@ -168,12 +168,17 @@ fi
 _stamp "step-4-done"; echo "  ✓ step 4: $NPERS blind persona sections present (isolation-gate satisfied)"
 _witness_record "$WS/SIM_NOTES.md"
 
-# STEP 5 — Emission Gate. Require a VERDICT: EMIT | PARTIAL-EMIT | KILL.
+# STEP 5 — Emission Gate. Require a VERDICT: EMIT | PARTIAL-EMIT | KILL | CURATED | NOT-APPLICABLE.
+# 🟥 2026-09-04: the doctrine re-routed two outcomes on 2026-08-17 (§3-SCREEN-2026-08-17 — net-new
+#    shortfall → CURATED, judgment-shaped candidate → NOT-APPLICABLE) and this regex kept parsing the
+#    OLD vocabulary for 18 days; run #16 had to file «KILL + CURATED 재료 동봉» to get past it, and the
+#    pre-registered taxonomy known-pair (5 old runs → CURATE) could not be replayed at all. A runner that
+#    rejects the doctrine's own words is [[feedback_rule_misdescribes_its_own_machine]] in the code half.
 if [ ! -f "$WS/EMISSION_VERDICT.md" ]; then
   cat > "$WS/EMISSION_VERDICT.md" <<EOF
 # Emission Gate Verdict — $SLUG (chamber run)
 
-VERDICT: <EMIT | PARTIAL-EMIT | KILL>
+VERDICT: <EMIT | PARTIAL-EMIT | KILL | CURATED | NOT-APPLICABLE>
 
 ## Judged: does the simulation hold?  (+ mechanical anchor: overlap grep / gate verdicts / reproduced flows)
 
@@ -183,11 +188,11 @@ EOF
   echo "  ⛔ step 5 BLOCKED: decide WITH the operator (HITL), record VERDICT in $WS/EMISSION_VERDICT.md, re-run."; exit 1
 fi
 # PARTIAL-EMIT listed FIRST in every alternation so it is never mis-extracted as its EMIT substring.
-VERDICT=$(grep -ioE '^VERDICT:[[:space:]]*(PARTIAL-EMIT|EMIT|KILL)' "$WS/EMISSION_VERDICT.md" 2>/dev/null | head -1 | grep -ioE 'PARTIAL-EMIT|EMIT|KILL' | head -1 | tr 'a-z' 'A-Z')
+VERDICT=$(grep -ioE '^VERDICT:[[:space:]]*(PARTIAL-EMIT|EMIT|KILL|CURATED|NOT-APPLICABLE)' "$WS/EMISSION_VERDICT.md" 2>/dev/null | head -1 | grep -ioE 'PARTIAL-EMIT|EMIT|KILL|CURATED|NOT-APPLICABLE' | head -1 | tr 'a-z' 'A-Z')
 # a bare "## Verdict:" prose line (run #3 style) also counts if it names KILL/EMIT
-[ -z "$VERDICT" ] && VERDICT=$(grep -ioE 'VERDICT[: *]+\**(PARTIAL-EMIT|EMIT|KILL)' "$WS/EMISSION_VERDICT.md" 2>/dev/null | grep -ioE 'PARTIAL-EMIT|EMIT|KILL' | head -1 | tr 'a-z' 'A-Z')
+[ -z "$VERDICT" ] && VERDICT=$(grep -ioE 'VERDICT[: *]+\**(PARTIAL-EMIT|EMIT|KILL|CURATED|NOT-APPLICABLE)' "$WS/EMISSION_VERDICT.md" 2>/dev/null | grep -ioE 'PARTIAL-EMIT|EMIT|KILL|CURATED|NOT-APPLICABLE' | head -1 | tr 'a-z' 'A-Z')
 if [ -z "$VERDICT" ]; then
-  echo "  ⛔ step 5 BLOCKED: no VERDICT (EMIT|PARTIAL-EMIT|KILL) found in $WS/EMISSION_VERDICT.md, re-run."; exit 1
+  echo "  ⛔ step 5 BLOCKED: no VERDICT (EMIT|PARTIAL-EMIT|KILL|CURATED|NOT-APPLICABLE) found in $WS/EMISSION_VERDICT.md, re-run."; exit 1
 fi
 _stamp "step-5-done"; echo "  ✓ step 5: Emission Gate verdict = $VERDICT"
 _witness_record "$WS/EMISSION_VERDICT.md"
@@ -269,6 +274,10 @@ case "$VERDICT" in
                 echo "                 existing asset / the skeleton (no new asset). Workspace stays as evidence." ;;
   KILL) echo "TERMINUS (KILL): first-class success — a cheap run prevented a speculative/reinvention build."
         echo "                 No emit. Workspace stays as the evidence record; seen-filter will skip re-listing it." ;;
+  CURATED) echo "TERMINUS (CURATED): net-new shortfall is not a kill (§3-SCREEN-2026-08-17) — hand the maker the"
+           echo "                 prior-art list, the closest existing asset, and the delta it does not cover." ;;
+  NOT-APPLICABLE) echo "TERMINUS (NOT-APPLICABLE): judgment-shaped candidate — not this incubator's output form."
+                  echo "                 Route to doctrine (a rule/lens), not to a build. Workspace stays as evidence." ;;
 esac
 echo "chamber run '$SLUG' COMPLETE (STATUS: step-7-done, verdict $VERDICT)."
 # EMIT/PARTIAL-EMIT 인데 순서 증인이 없으면 **비영 종료**한다. KILL 은 영향 없다 —

package/scripts/com.forge-harness.live-eval.plist

@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <!-- Replace every /path/to/... below with your own absolute paths before installing.
+         Follows the same template shape as scripts/com.forge-harness.daily-report.plist —
+         see that file's own comments for the general launchd-on-macOS caveats (sleep/wake
+         does not guarantee the exact minute, StandardOutPath dirs must pre-exist). -->
+    <key>Label</key>
+    <string>com.forge-harness.live-eval</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>/bin/bash</string>
+        <string>/path/to/forge-harness/scripts/probe_live_eval.sh</string>
+        <!-- 🟥 COST + API-KEY DECISION IS THE OPERATOR'S — this template ships with NO default
+             the subset / ids limiter flags limiter, i.e. installing it as-is runs the FULL selected set (12
+             probes x 2 calls = 24 live `claude -p` invocations) every night. Read
+             scripts/probe_live_eval.sh's own header (§COST) before installing, and add a
+             a subset or ids argument argument here if a nightly full-set run is not what you
+             want. This plist is a template, not a recommendation of scope. -->
+        <!-- 🟥 reps=3 (2026-09-06). 이 인자가 없으면 reps=1 이고, 그때의 pass_rate 로는 문턱을
+             정할 수 없다 — 실측: 유효 런 3 개 재채점에서 12 프로브 중 5 개가 flaky, 같은 코퍼스
+             15 분 간격 두 런에서 4 개가 뒤집혔고 관측 pass_rate 는 0.50/0.67/0.67 이었다(단일 rep
+             노이즈 폭 > 문턱까지의 거리). 판정은 과반, 분산은 리포트 `reps(pass/ran)` 칸에 남는다.
+             ⚠️ 비용이 3 배다: 24 → **72** 회 `claude -p`. 줄이려면 the subset / ids limiter flags 를 같이 줘라. -->
+        <string>--reps</string>
+        <string>3</string>
+    </array>
+
+    <!-- 매일 02:30 (야간, 다른 cron 과 안 겹치는 시간대 — frontier-digest=09:00, daily-report=07:30
+         과 분리). 잠자는 중이면 launchd 가 깨어난 뒤 한 번 돌린다(정각 보장 아님). -->
+    <key>StartCalendarInterval</key>
+    <dict>
+        <key>Hour</key><integer>2</integer>
+        <key>Minute</key><integer>30</integer>
+    </dict>
+
+    <key>RunAtLoad</key>
+    <false/>
+
+    <key>StandardOutPath</key>
+    <string>/path/to/forge-harness/tracks/_meta/logs/live_eval_out.log</string>
+    <key>StandardErrorPath</key>
+    <string>/path/to/forge-harness/tracks/_meta/logs/live_eval_err.log</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <!-- must include wherever `claude` and `python3` resolve for this user.
+             /opt/homebrew/bin included so Homebrew's `gtimeout` (Apple Silicon prefix; Intel's
+             /usr/local/bin is already below) resolves — stock macOS ships no `timeout(1)` at
+             all, and scripts/probe_live_eval.sh's runner (sim_isolated_run.sh) falls back to a
+             bash-native watchdog if NEITHER resolves, so this is an optimization, not a hard
+             requirement: the run still enforces its timeout without this entry, just via the
+             slower fallback path. See sim_isolated_run.sh's own §timeout(1) RESOLUTION header
+             (measured 2026-09-05: the first unpatched run here died 12/12 FAILED-TO-RUN because
+             this PATH had neither `timeout` nor `gtimeout` AND the fallback did not exist yet). -->
+        <string>/path/to/home/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+        <key>HOME</key>
+        <string>/path/to/home</string>
+    </dict>
+</dict>
+</plist>
+
+<!--
+INSTALL (manual — no launchd_wiring_check.sh render- helper exists for this plist yet; unlike
+com.forge-harness.daily-report.plist, this one is not wired into that renderer, so every
+/path/to/... above must be hand-edited before `launchctl load`):
+
+  1. cp scripts/com.forge-harness.live-eval.plist ~/Library/LaunchAgents/com.forge-harness.live-eval.plist
+  2. Edit every /path/to/... above to this checkout's absolute path and your $HOME.
+  3. mkdir -p tracks/_meta/logs   (StandardOutPath/StandardErrorPath dirs must pre-exist)
+  4. launchctl load ~/Library/LaunchAgents/com.forge-harness.live-eval.plist
+  5. Verify: launchctl list | grep com.forge-harness.live-eval
+
+UNINSTALL:
+  launchctl unload ~/Library/LaunchAgents/com.forge-harness.live-eval.plist
+  rm ~/Library/LaunchAgents/com.forge-harness.live-eval.plist
+
+The nightly run appends its record to tracks/_meta/live_eval_<date>.md (created fresh each run —
+not append-only; a stale prior day's file is left alone, per date, exactly like
+tracks/_meta/daily_report_<date>.md and tracks/_meta/frontier_digest_<date>.md).
+-->

package/scripts/compaction_probe.sh

@@ -70,41 +70,15 @@ do_seal() {
 
     echo "## 운영자 발화 (이 세션)"
     if [ -f "$transcript" ]; then
-      python3 - "$transcript" <<'PY' 2>/dev/null || echo "- (전사본 파싱 실패 — 원본: $transcript)"
-import json,sys
-n=0
-skipped_tool=skipped_meta=skipped_other=0
-for line in open(sys.argv[1], errors='replace'):
-    try: d=json.loads(line)
-    except Exception: continue
-    if d.get('type')!='user': continue
-    m=d.get('message') or {}
-    c=m.get('content')
-    # ⚠️ 초판은 "실발화=str · 툴결과=list" 로 갈랐다. **틀렸다** — 이미지/파일을 첨부한 실발화는
-    # list 다(high 리뷰 실측: 전사본 25개에서 그런 발화 18건이 구조적으로 안 보였다). 더 나쁜 건
-    # self-test 픽스처가 같은 가정을 인코딩해서 **초록이 그 결함을 보증**했다는 것이다.
-    # 이제 list 는 text 블록을 꺼내 쓰고, tool_result 만 제외한다.
-    if isinstance(c,str):
-        t=c
-    elif isinstance(c,list):
-        if any(isinstance(b,dict) and b.get('type')=='tool_result' for b in c):
-            skipped_tool+=1; continue
-        parts=[b.get('text','') for b in c if isinstance(b,dict) and b.get('type')=='text']
-        if not parts:
-            skipped_other+=1; continue          # 이미지-only 등 — 셈에서 지우지 않고 센다
-        t=' '.join(parts)
-    else:
-        skipped_other+=1; continue
-    t=' '.join(t.split())
-    if not t: skipped_other+=1; continue
-    if t.startswith('<') or t.startswith('/'):   # 슬래시 커맨드·메타 봉투 제외
-        skipped_meta+=1; continue
-    n+=1
-    print(f"{n}. {t[:200]}")
-# **제외분을 반드시 인쇄한다.** 합계만 찍으면 그 원장이 완전한 것처럼 읽힌다 — `not found ≠ 0`.
-print(f"\n합계: {n}건" if n else "- (발화 0건)")
-print(f"제외: tool_result {skipped_tool} · 메타/커맨드 {skipped_meta} · 텍스트없음 {skipped_other}")
-PY
+      # 🟥 추출 로직은 `scripts/transcript_utterances.py` 가 **단일 소스**다 (2026-09-05).
+      #    인라인 heredoc 이었을 때 두 번째 소비처(`utterance_intake.sh` — 발화 착지 검사)를
+      #    붙이려면 사본이 생겼고, 전처리 두 벌은 «한쪽만 통과하는 입력이 다른 쪽에서 무음
+      #    드롭» 이다(`[[feedback_divergent_leniency_duplicate_normalizers]]`).
+      #    출력은 **바이트 동일**해야 한다 — `scripts/test_utterance_intake_lanes.sh` L10 이
+      #    골든으로 고정하고, L12/L12b 가 되돌림으로 «정말 이 파일을 통해 도는가» 를 잰다.
+      #    추출기가 없거나 죽으면 비영 종료 → 아래 폴백 문구가 그대로 뜬다(무음 아님).
+      python3 "$REPO_ROOT/scripts/transcript_utterances.py" "$transcript" --format seal 2>/dev/null \
+        || echo "- (전사본 파싱 실패 — 원본: $transcript)"
     else
       echo "- 🟥 전사본 경로 없음: $transcript"
     fi

package/scripts/directional_diff_gate.sh

@@ -106,6 +106,15 @@ b64_decode() {
 TMP=$(mktemp -d) || { echo "HARNESS-ERROR: mktemp failed"; exit 10; }
 trap 'rm -rf "$TMP"' EXIT
 
+# ── has_nul: binary detection ──────────────────────────────────────────────────
+# ONE implementation, called by check_path AND by --self-test. Until 2026-09-05 this was defined
+# twice, byte-identical, once inside each caller — so the self-test exercised ITS OWN copy and a
+# broken production copy stayed green (3-arm mutation: production-only break → rc=0). The file
+# already pinned the one-implementation rule for compute_lost and loss_token; this was the one
+# helper that escaped it. NOT `grep -q $'\x00'`: bash cannot hold a NUL in a string, so that
+# collapses to the EMPTY pattern and every text file is declared binary. Strip-and-compare.
+has_nul() { LC_ALL=C tr -d '\000' < "$1" | cmp -s - "$1" || return 0; return 1; }
+
 # ── compute_lost: the verdict, as multiset arithmetic ───────────────────────────
 #   $TMP/lost = R − L   (occurrences the remote has that the upload does not)
 # ONE implementation, called by check_path AND by --self-test — two copies of the same
@@ -234,7 +243,6 @@ check_path() { # $1=repo $2=base_sha $3=path
   # NOT `grep -q $'\x00'`: bash cannot hold a NUL in a string, so `$'\x00'` collapses to
   # the EMPTY pattern, grep matches every line, and every text file is declared binary —
   # a total over-block that looks like a strict check. Strip-and-compare instead.
-  has_nul() { LC_ALL=C tr -d '\000' < "$1" | cmp -s - "$1" || return 0; return 1; }
   if has_nul "$prev" || has_nul "$path"; then
     echo "  🟥 $path — UNDECIDABLE: binary content (NUL bytes); a line-wise direction"
     echo "       verdict over binary is not a measurement."
@@ -360,13 +368,17 @@ self_test() {
   # (h) NUL detection. The first draft used `grep -q $'"'"'\x00'"'"'`, which bash collapses to the
   #     EMPTY pattern — every text file matched and every push would have been declared
   #     binary/UNDECIDABLE. Both directions are pinned so that regression cannot return.
-  has_nul() { LC_ALL=C tr -d '\000' < "$1" | cmp -s - "$1" || return 0; return 1; }
   printf 'plain text\n' > "$TMP/tn"
   has_nul "$TMP/tn" && r=BINARY || r=TEXT
   t "plain text is not misread as binary" TEXT "$r"
   printf 'a\000b\n' > "$TMP/tn"
   has_nul "$TMP/tn" && r=BINARY || r=TEXT
   t "a file with NUL bytes is detected as binary" BINARY "$r"
+  # (h2) The pair above measures PRODUCTION only if there is exactly ONE definition — a second,
+  #      self-test-local copy made this suite green while the production copy was broken
+  #      (2026-09-05, 3-arm mutation). Pin the count so the shadow copy cannot return.
+  t "has_nul is defined exactly once (the self-test measures the production copy)" 1 \
+    "$(grep -c '^has_nul() {' "$0" | tr -d ' ')"
 
   # (i) 404 must be the HTTP status, not any stderr containing "not found".
   #     `gh: command not found` used to be accepted as "new file at base" → fail-open.

package/scripts/frontier_digest_autopilot.sh

@@ -210,7 +210,10 @@ PROMPT="$(cat "$PROMPT_FILE")"
 rm -f "$PROMPT_FILE"
 
 _log "Stage 2 starting (timeout ${ATTEMPT_TIMEOUT_SECS}s)"
-"$CLAUDE_BIN" -p --permission-mode bypassPermissions "$PROMPT" >> "$LOG_FILE" 2>&1 &
+# 프롬프트는 `-p` 바로 뒤(positional-first) — Stage 1 러너와 같은 계약(2026-09-05, variadic 플래그 뒤
+# positional 은 먹힌다). FD_MODEL 은 Stage 1 과 같은 변수로 핀한다: /model 로 저장한 기본 모델이
+# `claude -p` 무인 런에도 적용되므로, 무인 잡의 모델은 plist 가 명시한다(운영자 결정 2026-09-05).
+"$CLAUDE_BIN" -p "$PROMPT" --permission-mode bypassPermissions ${FD_MODEL:+--model "$FD_MODEL"} >> "$LOG_FILE" 2>&1 &
 CLAUDE_PID=$!
 DEADLINE=$((SECONDS + ATTEMPT_TIMEOUT_SECS))
 while kill -0 "$CLAUDE_PID" 2>/dev/null && [ "$SECONDS" -lt "$DEADLINE" ]; do

package/scripts/map_postprocess.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""docs/map 의 archify 산출 HTML 에 붙이는 재생성-후 후처리 — 두 가지만 한다.
+
+  (1) reader-width floor  뷰어의 `MIN_READER_WIDTH = 960` 상수를 뷰포트 비례 하한으로 바꾼다.
+      archify 뷰어는 «스크롤 없이 다 담기» 를 목표로 폭을 줄이는데, 세로 예산이 모자라면
+      1728px 화면에서도 960px 로 바닥을 친다(실측 2026-09-06: 1728×950 → 960). 지도는
+      «한 화면에 담기» 보다 «넓게 읽기» 가 목적이라 하한을 화면 비례로 올린다.
+      실측 효과(1728×950, fh_process): 960 → 1382.  가로 오버플로 없음(1280×800 → 1216).
+
+  (2) SVG 재생성      HTML 안의 유일한 <svg> + 뷰어 <style> 을 심은 정적 벡터를 다시 만든다.
+      기존 커밋본 두 장(fh_trust.dataflow.svg · fh_assets.architecture.svg)에 대해
+      바이트 동일 재현을 known-pair 로 확인하고 만든 추출기다.
+
+fail-closed: 기대한 리터럴이 없으면(렌더러 버전 드리프트) 종료코드 3 으로 멈춘다 —
+조용히 «패치할 게 없었다» 로 넘어가면 다음 발행이 옛 동작으로 나간다.
+
+  usage: map_postprocess.py <file.html> [...]   실제 적용
+         map_postprocess.py --check <file.html> [...]   적용 여부만 보고(쓰기 없음)
+exit: 0 적용/이미적용  ·  3 리터럴 부재(드리프트)  ·  4 인자/파일 오류
+"""
+import re
+import sys
+
+OLD = 'var MIN_READER_WIDTH = 960;'
+NEW = ('var MIN_READER_WIDTH = Math.min(1440, '
+       'Math.max(960, Math.round(window.innerWidth * 0.80)));')
+
+
+def build_svg(html: str) -> str:
+    styles = re.findall(r'<style[^>]*>(.*?)</style>', html, re.S)
+    if len(styles) != 1:
+        raise ValueError(f'expected exactly 1 <style> block, got {len(styles)}')
+    m = re.search(r'<svg\b.*?</svg>', html, re.S)
+    if not m:
+        raise ValueError('no <svg> block found')
+    svg = m.group(0).replace('<svg ', '<svg xmlns="http://www.w3.org/2000/svg" ', 1)
+    tag_end = svg.index('>') + 1
+    return ('<?xml version="1.0" encoding="UTF-8"?>\n'
+            + svg[:tag_end] + '<style><![CDATA[\n' + styles[0] + '\n]]></style>'
+            + svg[tag_end:])
+
+
+def process(path: str, check_only: bool) -> int:
+    try:
+        html = open(path, encoding='utf-8').read()
+    except OSError as exc:
+        print(f'ERROR  {path}: {exc}', file=sys.stderr)
+        return 4
+    has_old, has_new = OLD in html, NEW in html
+    if not has_old and not has_new:
+        print(f'DRIFT  {path}: neither the original nor the patched reader-width '
+              f'literal is present — archify version drift, patch NOT applied',
+              file=sys.stderr)
+        return 3
+    if check_only:
+        print(f'{"PATCHED" if has_new else "UNPATCHED"}  {path}')
+        return 0
+    patched = html.replace(OLD, NEW) if has_old else html
+    svg_path = re.sub(r'\.html$', '.svg', path)
+    # 쓰기 전에 둘 다 만들어 둔다 — 중간에 실패하면 «반쯤 적용된 트리»가 남고,
+    # 특히 open(...,'w') 은 예외가 나기 전에 이미 대상을 0바이트로 잘라 놓는다(L6 가 잡았다).
+    try:
+        svg = build_svg(patched)
+    except ValueError as exc:
+        print(f'ERROR  {svg_path}: {exc} — nothing written', file=sys.stderr)
+        return 3
+    if has_old:
+        open(path, 'w', encoding='utf-8').write(patched)
+        print(f'PATCH  {path}: reader-width floor -> viewport-proportional')
+    else:
+        print(f'SKIP   {path}: already patched (idempotent)')
+    open(svg_path, 'w', encoding='utf-8').write(svg)
+    print(f'SVG    {svg_path}')
+    return 0
+
+
+def main(argv):
+    check_only = '--check' in argv
+    files = [a for a in argv if not a.startswith('--')]
+    if not files:
+        print(__doc__, file=sys.stderr)
+        return 4
+    worst = 0
+    for path in files:
+        worst = max(worst, process(path, check_only))
+    return worst
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))