@nurix/etna 0.20.9 → 0.20.11

package/data/catalog/rules/cloudflare.md

@@ -1,3 +1,11 @@
+---
+paths:
+  - "**/wrangler.*"
+  - "**/.dev.vars*"
+  - "**/worker/**"
+  - "**/workers/**"
+  - "**/src/**/*.ts"
+---
 # Cloudflare Worker
 
 Conventions for Cloudflare Workers — `wrangler.jsonc` setup, vars and secrets, and code shape (dispatch, errors, modules, WebSockets). Schema design doctrine is the `schema-design` skill.

package/data/catalog/rules/database.md

@@ -1,3 +1,13 @@
+---
+paths:
+  - "**/*.sql"
+  - "**/migrations/**"
+  - "**/drizzle/**"
+  - "**/drizzle.config.*"
+  - "**/schema.ts"
+  - "**/schema/**"
+  - "**/db/**"
+---
 # Database
 
 Naming and the fixed column vocabulary for relational schemas in **every** Nurix project — one concept, one name, everywhere. Written for SQLite / Cloudflare D1 + Drizzle; a Postgres project keeps the same column names and semantics with native types (`uuid`, `timestamptz`, `boolean`). **Design doctrine — what earns a table, state vs. logs, junctions, FK policy, uniqueness traps — is the `schema-design` skill; consult it before any schema change.**

package/data/catalog/rules/frontend.md

@@ -1,3 +1,13 @@
+---
+paths:
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/*.ts"
+  - "**/*.css"
+  - "**/*.html"
+  - "**/tailwind.config.*"
+  - "**/vite.config.*"
+---
 # Frontend
 
 Tailwind v4 + shadcn-based UI conventions for **web** apps — styling, the `@nurix/components` library, the `design.md` token artifact, and design-skill routing — plus the TypeScript conventions every package compiles under.

package/data/catalog/rules/pnpm.md

@@ -1,3 +1,12 @@
+---
+paths:
+  - "**/package.json"
+  - "**/pnpm-workspace.yaml"
+  - "**/pnpm-lock.yaml"
+  - "**/.npmrc"
+  - "**/tsconfig*.json"
+  - "**/turbo.json"
+---
 # pnpm — `@nurix/*` Workspaces: naming, boundaries, and consuming
 
 How a `@nurix/*` repo is **named**, **structured**, and how its packages are **consumed** — every repo takes the workspace shape, single-package frontends included. Publishing and CLI design live in the `nustack` skill, not here — no `nustack` skill in the runtime ⇒ ask before crossing the publish boundary.

package/data/catalog/rules/react-native.md

@@ -1,3 +1,13 @@
+---
+paths:
+  - "**/app.json"
+  - "**/app.config.*"
+  - "**/eas.json"
+  - "**/metro.config.*"
+  - "**/babel.config.*"
+  - "**/app/**"
+  - "**/*.tsx"
+---
 # React Native + Expo
 
 How mobile apps are built — distilled from a hand-crafted reference app, the gold standard for *style*. The rule is **scale-aware**: a few-screen app takes the lean form, a feature/auth-heavy app the full form; where a section offers both, the graduation trigger is stated.

package/data/catalog/rules/rust-desktop.md

@@ -1,3 +1,11 @@
+---
+paths:
+  - "**/*.rs"
+  - "**/Cargo.toml"
+  - "**/Cargo.lock"
+  - "**/tauri.conf.json"
+  - "**/src-tauri/**"
+---
 # Rust Desktop Apps (Tauri 2)
 
 How native desktop apps are built: a **Rust core + web-frontend** shell — the cargo/JS dual workspace, the Rust↔TS contract seam, native-capability handling, and signed distribution. This rule governs everything on the **Rust and OS side of the webview boundary**; the webview UI is a normal web app, unchanged by being hosted in a webview. Scale-aware: a single-window tool with no native capabilities skips §2's workspace and §4's actor (graduation trigger in §2); a capability-rich app (audio, permissions, background work, sibling processes) takes the full shape.

package/data/catalog/rules/temporal.md

@@ -1,3 +1,12 @@
+---
+paths:
+  - "**/workflows/**"
+  - "**/activities/**"
+  - "**/*.workflow.ts"
+  - "**/*.activity.ts"
+  - "**/worker.ts"
+  - "**/temporal/**"
+---
 # Temporal
 
 Workflow and activity conventions for Temporal-backed services — the determinism boundary, file layout, registration, retry defaults, and starting workflows.

package/data/harness-index.json

@@ -1,5 +1,5 @@
 {
-    "fingerprint": "7d1e7785bd0c",
+    "fingerprint": "7d6e2acfe663",
     "harnesses": {
         "code": {
             "plugin": "code",

package/data/harnesses/code/CLAUDE.md

@@ -33,14 +33,15 @@ Three peer modes, then a verification gate and a Completion step — enter where
 
 > Brainstorm entry needs a **basis** — a reference document or a one-shot brain dump; drip-sized asks (a bug fix, one button) are too small and get redirected. A **pillar** is a recorded strategic principle from a past brainstorm: in-progress sessions live under `docs/research/`, harvested ones under `docs/history/brainstorms/`, harvested doctrine under `docs/architecture/`. The LLD is the feature doc itself — `docs/features/{feature}.md`, design intent first, extended in place at Completion.
 
-> **Two stops, and only two.** The work between them runs without asking. The **plan pass** ends at a finished plan — written, boundary-checked, amendments folded, both ledgers in place — shown once; a plan that still owes a gate is not finished and is not shown as finished. The **build pass** ends at a discharged gate — the code written, driven, fixed, pinned, every ledger row in its Outcome cell — and stops before the freeze. What the user decides is the gated plan (stop 1) and the freeze-and-commit (stop 2); running a gate is never a question put to the user.
+> **Two stops, and only two.** The work between them runs without asking. The **plan pass** ends at a finished plan — written, boundary-checked, amendments folded, both ledgers in place — shown once; a plan that still owes a gate is not finished and is not shown as finished. The **build pass** ends at a discharged gate — the code written, driven, fixed, pinned, every ledger row in its Outcome cell, the plan's documents certified (`Polygraph:` written) — and stops before the freeze. What the user decides is the gated plan (stop 1) and the freeze-and-commit (stop 2); running a gate is never a question put to the user.
 
 > **The lightweight lane:** a change touching one module, **at most ~10 files, none on a contract-heavy surface** (db schema, wire envelopes, auth, events, env/config — the `boundary` skill's list), and under about **three days'** work skips the modes above entirely — the ad-hoc regime of `.claude/rules/testing.md` applies: make the change, drive it, then pin it in the same unit of work if it alters promised behavior, cover it with a changelog row. The predicate is mechanical; when in doubt, the `boundary` diff scan is the tiebreak, not self-assessment.
 
 **On Plan Completion:**
 
-1. **The verification gate is the tail of the build pass, never a separate ask** **[override]** — the moment the unit's code is written the session opens it: drives the real surface, fixes what driving finds, pins once, discharges. What is the user's call is the freeze and the commit — "commit" / "ship it" triggers step 2, not the gate, which has already run. This keeps the runtime's finish-the-task default inside the build and removes it from the freeze. The gate requires the plan's Test Obligations ledger to exist (proof the plan gates ran) and discharges every row into its **Outcome** cell, driving the real surface before pinning tests — `.claude/rules/testing.md`. A plan with outstanding obligations stays open, whatever the code does.
-2. **Discharge, then freeze — in one edit.** Discharge the Doc Obligations ledger (every row into exactly one outcome: **updated** — the doc now states what the code does; **owes nothing**, with the reason; **blocked** — → a backlog item, so the debt outlives the frozen plan), fill the Completed date, and flip `Status: Complete` **in the same edit**: the flip freezes the file instantly, so anything left for a second edit is unreachable. For each discharged row's doc: flip `status: active` if it was `draft`, extend it in place, and confirm its `owns:` globs against the actual code — the ledger, not memory, says how many docs that is.
+1. **The verification gate is the tail of the build pass, never a separate ask** **[override]** — the moment the unit's code is written the session opens it: drives the real surface, fixes what driving finds, pins once, discharges. What is the user's call is the freeze and the commit — "commit" / "ship it" triggers step 3, not the gates, which have already run. This keeps the runtime's finish-the-task default inside the build and removes it from the freeze. The gate requires the plan's Test Obligations ledger to exist (proof the plan gates ran) and discharges every row into its **Outcome** cell, driving the real surface before pinning tests — `.claude/rules/testing.md`. A plan with outstanding obligations stays open, whatever the code does.
+2. **Certify the documents — the polygraph gate, still inside the build pass.** Once every Doc Obligations row has its outcome, run the `polygraph` skill in gate mode over the docs the plan touched (every row discharged **updated**, plus every `Spec:` doc): claim by claim against the code, corrections applied, and the plan's `Gates:` line rewritten from `Polygraph: pending` to `Polygraph: passed YYYY-MM-DD (…)`. A plan that touched no document writes `Polygraph: owes nothing — {reason}` by hand instead. A plan frozen while the segment still reads `pending` raises a `needs-session:` queue row and fails CI — the gate is a judgment obligation, enforced the same way as the doc ledger, never a wall.
+3. **Discharge, then freeze — in one edit.** Discharge the Doc Obligations ledger (every row into exactly one outcome: **updated** — the doc now states what the code does; **owes nothing**, with the reason; **blocked** — → a backlog item, so the debt outlives the frozen plan), fill the Completed date, and flip `Status: Complete` **in the same edit**: the flip freezes the file instantly, so anything left for a second edit is unreachable. For each discharged row's doc: flip `status: active` if it was `draft`, extend it in place, and confirm its `owns:` globs against the actual code — the ledger, not memory, says how many docs that is.
 3. Record the gate's results in the changelog entry, and confirm every section of `docs/tests/{feature}.md` carries its `Pinned:` trace — the checklist itself is authored at the gate (step 1), not written up afterwards.
 
 **On Brainstorm Close** (when a session ends, not when a plan completes): close + harvest is the skill's `stop` procedure — converge, a user-approved harvest manifest, apply, then a uselessness test; conclusions disperse by scope (architecture docs, decision records, backlog), the record moves from `docs/research/{topic}-brainstorm/` to `docs/history/brainstorms/{topic}/`, and the user decides whether the moved folder is deleted or committed.
@@ -78,6 +79,7 @@ Boundaries are **diagnosed, not documented** — the `boundary` skill derives th
 
 ### Documentation — close the loop
 
+- **When a document's truth is in question — "is this doc still right?", a feature that drifted from its doc, a folder nobody has audited — invoke the `polygraph` skill (audit mode) on that target**: one doc, feature, folder, or code path, never the whole tree by reflex. Docs health (dead globs, lint, placement) is the `maintenance` agent; blast radius is `boundary`.
 - **Invoke the `documentation` skill when creating a doc, or when an edit changes a doc's structure or claims** — apply its templates and `references/style-guide.md`: truth documents stay present-tense; history lives only in `docs/history/` records. Records written from a template already in context (a changelog entry, a backlog row) skip the invocation.
 - **[override]** Keep `docs/` updated when code changes affect documented behavior. This file is the standing request for those docs: creating and updating them is part of the work, even if the runtime defaults to never creating documentation files unprompted.
 - After plan completion **[override]**: write the `docs/history/changelog/` entry as a **draft** immediately, while the context is fresh — no confirmation needed — and append its `docs/history/CHANGELOG.md` row; the commit fills what the draft left open and freezes it. Non-plan work needs no separate prompt: every non-exempt commit carries its own entry (the `changelog` rule).
@@ -130,7 +132,7 @@ The single policy for sub-agent dispatch — when to fan out, at what tier, and
 - **A dispatch is scoped to minutes and read before anything else starts.** One file, one sweep — never a build. The dispatching agent reads the result before moving on, and never leaves a sub-agent as the only thing running while it does something else: a sub-agent's state is invisible until someone looks, so an hour-long dispatch that dies is discovered an hour late, with nothing to show for the hour.
 - **Small or judgment work stays inline.** A task finishable in a handful of tool calls is faster done than briefed. **Never delegate judgment by reflex** — a second opinion is for a high-stakes call or an explicit request.
 - **A delegated result is a report, not verifiable ground truth** — verify load-bearing results directly.
-- **Tiers**: mechanical fan-out → the cheapest capable tier; judgment-heavy delegation → the session's standard tier; the strongest tier **only** on explicit user request. The session itself defaults to the standard tier, entering the strongest only by explicit user switch. Model names live in Runtime Notes.
+- **Tiers**: mechanical fan-out → the cheapest capable tier; judgment-heavy delegation → the session's standard tier; the strongest tier **only** on explicit user request. The session itself defaults to the standard tier, entering the strongest only by explicit user switch. Model names live in Runtime Notes. **A rostered agent whose definition pins `model:` and `effort:` is dispatched at that pin** — the pin is the tier decision, made once at authoring; a skill that dispatches such an agent never re-picks per dispatch, and a session running hot cannot drag it up.
 - **An explicit user directive about tier, cost, or delegation overrides this section.**
 
 ---

package/data/harnesses/code/agents/polygraph-applier.md

@@ -0,0 +1,24 @@
+---
+name: polygraph-applier
+description: Applies one packet of verified polygraph rows to exactly the documents the packet names, re-checking every citation first. Dispatched by the polygraph skill only; never on its own.
+tools: Read, Edit, Write, Grep, Glob, Bash
+model: sonnet
+effort: medium
+maxTurns: 15
+---
+
+# Polygraph applier
+
+You are an APPLIER in a truth audit. You receive the path of a **packet** and the path of its **context pack**. The packet names your editable docs (`doc:` lines) and your rows, with any bounce notes — read them; a bounced row's note says exactly what is wrong and where.
+
+1. Read the pack, then the packet. Each row is quoted in full inside the packet; never open the run's findings file to find your rows.
+2. **Re-check each row's citations against today's tree before editing.** This re-check is the audit's real gate: a claim that does not reproduce resolves `refuted-on-apply`, never as an edit that bends the doc to a stale claim.
+3. Edit **only** the docs your packet names. A fix that belongs in another doc is `needs-cross-doc`, naming that file precisely — your note is how the row is re-routed. Frozen records (completed plans, changelog entries, archived docs) are `exempt-frozen`. A subject awaiting an owner ruling is `blocked-on-question`, no edit.
+4. Style: present tense; no history narration; the repo's unbuilt-marker convention is the only sanctioned qualifier; preserve frontmatter and tooling metadata. Run the repo's doc lint over every doc touched, with repo-root-relative paths, and fix blocking findings.
+5. Write `apply-{doc}.psv` beside the packet — `id|outcome|note`, outcome ∈ `applied` · `needs-cross-doc` · `refuted-on-apply` · `exempt-frozen` · `blocked-on-question` · `skipped`.
+
+**The audit never edits code.** A row whose fix is a source change — a comment, a rename, a bug — is `skipped` with a note for the register; markdown anywhere, package and root READMEs included, is yours. Rulings in the pack outrank every recorded decision.
+
+Tree state: re-check every citation against today's tree before acting. READ-ONLY outside the packet's docs and your outcome file. Read budget: the pack and the packet are your reading list — grep before you read; never read a file over 20 KB without a line range; read a file once; one shell block per question.
+
+Return **at most 120 words**: counts per outcome, docs touched, the lint result, and anything for the register.

package/data/harnesses/code/agents/polygraph-finder.md

@@ -0,0 +1,31 @@
+---
+name: polygraph-finder
+description: Sweeps one document against the code it describes for the polygraph skill — one row per claim, cited, into a partial file. Dispatched by the skill only; never on its own.
+tools: Read, Grep, Glob, Bash, Write
+model: sonnet
+effort: medium
+maxTurns: 25
+---
+
+# Polygraph finder
+
+You are a FINDER in a truth audit. You receive the path of a **context pack** and the path of your **partial file**; the pack is your whole reading list, and the partial is your one write.
+
+Docs state the target design; code is presumed correct unless a standing decision **names** it for retirement — the pack's precedent section decides, and a match means the precedent names your subject (quote the naming words into evidence; a resembling thing is not a match; unsure → QUESTION).
+
+1. Read the pack in full. It names the document, its `owns:` globs resolved to today's files, the precedent quotations, the register rows already tracking this subject, and the rulings that bind.
+2. Read the document once, whole — it is the one file you always read in full. Then check each claim it makes against the code: grep for the mechanism, open the passage with a line range, cite `file:line`.
+3. Write one row per claim to the partial file, **no header**, exactly ten pipe-separated fields: `id|subject|claim|evidence|counter_evidence|verdict|confidence|depends_on|status|resolution`. A literal `|` becomes `¦`, a newline `; `. Verdicts: `COHERENT` (emit at the unit you audited, so coverage is countable) · `MISDESCRIBED` · `UNDOCUMENTED` · `UNBUILT` · `RESIDUE` · `CONTESTED` · `QUESTION`. `id` is `{doc-stem}-NNN`; `status` is `open`; `resolution` is empty; `confidence` is an honest 0–1.
+4. Sweep the other direction once: code inside the `owns:` globs that no claim in the document covers is an `UNDOCUMENTED` row — after the precedent test.
+
+Rules that bind every row:
+
+- **No citation, no row** — `file:line`, or the exact command and its result. Prove or refute; never confirm by plausibility.
+- **A negative claim about a long document quotes the passage you read** — the sentence you believe wrong, or the section where the missing statement should live. Unsupported negative claims are the dominant false-positive class.
+- **An already-tracked finding is skipped** unless your evidence adds something new; cite the register row as `already-registered: path:line` in `counter_evidence`.
+- **A document that should not exist** — its subject gone, its authority absorbed by a sibling — is one `QUESTION` row proposing deletion or merge, with the inbound-reference count.
+- **Rulings in the pack outrank every recorded decision.**
+
+Tree state: re-check every citation against today's tree before writing it. **READ-ONLY everywhere except your partial file.** Read budget: the pack is your reading list — read nothing outside it without naming in your return why the pack was insufficient. Grep before you read; never read a file over 20 KB without a line range; read a file once. Compose one shell block per question, not one call per file — your turn cap is your tool budget.
+
+Return **at most 120 words**: the partial's path, the row count, up to three findings, and limitations. Findings go in the file, never in the return.

package/data/harnesses/code/agents/polygraph-verifier.md

@@ -0,0 +1,20 @@
+---
+name: polygraph-verifier
+description: Blind re-derivation of polygraph claims the primary doubts — claim and subject only, no prior evidence — into a verify file. Dispatched by the polygraph skill only; never on its own.
+tools: Read, Grep, Glob, Bash, Write
+model: sonnet
+effort: low
+maxTurns: 12
+---
+
+# Polygraph verifier
+
+You are a VERIFIER in a truth audit. You receive a **queue file** of items — `id`, `subject`, `claim` — deliberately with no prior evidence, reasoning, or verdict, and the path of your **output file**.
+
+1. Read the queue. For each item, re-derive the claim from the tree: find the mechanism, read the passage with a line range, decide.
+2. Judge each: `CONFIRMED` (true as stated) · `REFUTED` (false) · `ADJUSTED` (true in substance, wrong in a particular — say which). Cite exactly, `file:line`.
+3. Write the output file, one line per item: `id|check|confidence|citations|note`. A literal `|` becomes `¦`.
+
+**A wrong confirmation is worse than an honest REFUTED.** Never infer from the claim's wording what the finder saw; derive from the tree. Read budget: grep before you read; never read a file over 20 KB without a line range; read a file once; one shell block per question. READ-ONLY everywhere except your output file.
+
+Return **at most 120 words**: the file path and counts per check.

package/data/harnesses/code/codex/agents/polygraph-applier.toml

@@ -0,0 +1,21 @@
+# dropped Claude tools: Read, Edit, Write, Grep, Glob, Bash
+name = "polygraph-applier"
+description = "Applies one packet of verified polygraph rows to exactly the documents the packet names, re-checking every citation first. Dispatched by the polygraph skill only; never on its own."
+developer_instructions = '''
+
+# Polygraph applier
+
+You are an APPLIER in a truth audit. You receive the path of a **packet** and the path of its **context pack**. The packet names your editable docs (`doc:` lines) and your rows, with any bounce notes — read them; a bounced row's note says exactly what is wrong and where.
+
+1. Read the pack, then the packet. Each row is quoted in full inside the packet; never open the run's findings file to find your rows.
+2. **Re-check each row's citations against today's tree before editing.** This re-check is the audit's real gate: a claim that does not reproduce resolves `refuted-on-apply`, never as an edit that bends the doc to a stale claim.
+3. Edit **only** the docs your packet names. A fix that belongs in another doc is `needs-cross-doc`, naming that file precisely — your note is how the row is re-routed. Frozen records (completed plans, changelog entries, archived docs) are `exempt-frozen`. A subject awaiting an owner ruling is `blocked-on-question`, no edit.
+4. Style: present tense; no history narration; the repo's unbuilt-marker convention is the only sanctioned qualifier; preserve frontmatter and tooling metadata. Run the repo's doc lint over every doc touched, with repo-root-relative paths, and fix blocking findings.
+5. Write `apply-{doc}.psv` beside the packet — `id|outcome|note`, outcome ∈ `applied` · `needs-cross-doc` · `refuted-on-apply` · `exempt-frozen` · `blocked-on-question` · `skipped`.
+
+**The audit never edits code.** A row whose fix is a source change — a comment, a rename, a bug — is `skipped` with a note for the register; markdown anywhere, package and root READMEs included, is yours. Rulings in the pack outrank every recorded decision.
+
+Tree state: re-check every citation against today's tree before acting. READ-ONLY outside the packet's docs and your outcome file. Read budget: the pack and the packet are your reading list — grep before you read; never read a file over 20 KB without a line range; read a file once; one shell block per question.
+
+Return **at most 120 words**: counts per outcome, docs touched, the lint result, and anything for the register.
+'''

package/data/harnesses/code/codex/agents/polygraph-finder.toml

@@ -0,0 +1,28 @@
+# dropped Claude tools: Read, Grep, Glob, Bash, Write
+name = "polygraph-finder"
+description = "Sweeps one document against the code it describes for the polygraph skill — one row per claim, cited, into a partial file. Dispatched by the skill only; never on its own."
+developer_instructions = '''
+
+# Polygraph finder
+
+You are a FINDER in a truth audit. You receive the path of a **context pack** and the path of your **partial file**; the pack is your whole reading list, and the partial is your one write.
+
+Docs state the target design; code is presumed correct unless a standing decision **names** it for retirement — the pack's precedent section decides, and a match means the precedent names your subject (quote the naming words into evidence; a resembling thing is not a match; unsure → QUESTION).
+
+1. Read the pack in full. It names the document, its `owns:` globs resolved to today's files, the precedent quotations, the register rows already tracking this subject, and the rulings that bind.
+2. Read the document once, whole — it is the one file you always read in full. Then check each claim it makes against the code: grep for the mechanism, open the passage with a line range, cite `file:line`.
+3. Write one row per claim to the partial file, **no header**, exactly ten pipe-separated fields: `id|subject|claim|evidence|counter_evidence|verdict|confidence|depends_on|status|resolution`. A literal `|` becomes `¦`, a newline `; `. Verdicts: `COHERENT` (emit at the unit you audited, so coverage is countable) · `MISDESCRIBED` · `UNDOCUMENTED` · `UNBUILT` · `RESIDUE` · `CONTESTED` · `QUESTION`. `id` is `{doc-stem}-NNN`; `status` is `open`; `resolution` is empty; `confidence` is an honest 0–1.
+4. Sweep the other direction once: code inside the `owns:` globs that no claim in the document covers is an `UNDOCUMENTED` row — after the precedent test.
+
+Rules that bind every row:
+
+- **No citation, no row** — `file:line`, or the exact command and its result. Prove or refute; never confirm by plausibility.
+- **A negative claim about a long document quotes the passage you read** — the sentence you believe wrong, or the section where the missing statement should live. Unsupported negative claims are the dominant false-positive class.
+- **An already-tracked finding is skipped** unless your evidence adds something new; cite the register row as `already-registered: path:line` in `counter_evidence`.
+- **A document that should not exist** — its subject gone, its authority absorbed by a sibling — is one `QUESTION` row proposing deletion or merge, with the inbound-reference count.
+- **Rulings in the pack outrank every recorded decision.**
+
+Tree state: re-check every citation against today's tree before writing it. **READ-ONLY everywhere except your partial file.** Read budget: the pack is your reading list — read nothing outside it without naming in your return why the pack was insufficient. Grep before you read; never read a file over 20 KB without a line range; read a file once. Compose one shell block per question, not one call per file — your turn cap is your tool budget.
+
+Return **at most 120 words**: the partial's path, the row count, up to three findings, and limitations. Findings go in the file, never in the return.
+'''

package/data/harnesses/code/codex/agents/polygraph-verifier.toml

@@ -0,0 +1,17 @@
+# dropped Claude tools: Read, Grep, Glob, Bash, Write
+name = "polygraph-verifier"
+description = "Blind re-derivation of polygraph claims the primary doubts — claim and subject only, no prior evidence — into a verify file. Dispatched by the polygraph skill only; never on its own."
+developer_instructions = '''
+
+# Polygraph verifier
+
+You are a VERIFIER in a truth audit. You receive a **queue file** of items — `id`, `subject`, `claim` — deliberately with no prior evidence, reasoning, or verdict, and the path of your **output file**.
+
+1. Read the queue. For each item, re-derive the claim from the tree: find the mechanism, read the passage with a line range, decide.
+2. Judge each: `CONFIRMED` (true as stated) · `REFUTED` (false) · `ADJUSTED` (true in substance, wrong in a particular — say which). Cite exactly, `file:line`.
+3. Write the output file, one line per item: `id|check|confidence|citations|note`. A literal `|` becomes `¦`.
+
+**A wrong confirmation is worse than an honest REFUTED.** Never infer from the claim's wording what the finder saw; derive from the tree. Read budget: grep before you read; never read a file over 20 KB without a line range; read a file once; one shell block per question. READ-ONLY everywhere except your output file.
+
+Return **at most 120 words**: the file path and counts per check.
+'''

package/data/harnesses/code/harness.json

@@ -1,7 +1,7 @@
 {
   "harness": "code",
   "name": "code",
-  "version": "3.14.7",
+  "version": "3.15.1",
   "files": [
     ".prettierignore",
     ".prettierrc.json",
@@ -25,5 +25,5 @@
     }
   ],
   "docsRoot": "docs",
-  "digest": "80ccc743454e"
+  "digest": "b00642c1a47d"
 }

package/data/harnesses/code/hooks/awareness.mjs

@@ -13,7 +13,8 @@ import {
   resolveProjectDir,
   buildIndex,
   buildEdgeIndex,
-  scanFeatureDocs,
+  scanOwningDocs,
+  isOwningDocPath,
   owningDocs,
   owningDoc,
   listRepoFiles,
@@ -35,7 +36,7 @@ import {
 } from "./lib/state.mjs";
 import { readSafe, relIfInside, today, SOURCE_EXT, commandRoot, docsRoot } from "./lib/repo.mjs";
 import { sweepResolvedRows, docLint, hasHeaderComment } from "./lib/sweep.mjs";
-import { listPlans } from "./lib/plans.mjs";
+import { listPlans, polygraphVerdict } from "./lib/plans.mjs";
 import { frozenStatusAtHead } from "./lib/frozen.mjs";
 import { undischargedDocRows } from "./lib/ledger.mjs";
 import { approvedPackages, rejectedPackages } from "./lib/approved.mjs";
@@ -164,7 +165,7 @@ function driftBanner(projectDir) {
   // Re-verify before counting: the walls must act on conditions that are live NOW, not on rows
   // that happen to still be written down.
   const swept = sweepResolvedRows(projectDir, repoFiles);
-  const docs = scanFeatureDocs(projectDir);
+  const docs = scanOwningDocs(projectDir);
   const dead = deadGlobs(projectDir, repoFiles, docs);
   const queueRows = readQueue(projectDir);
   const counts = countRows(queueRows);
@@ -311,7 +312,8 @@ function detectorForFile(projectDir, rel, meta, rows) {
     if (rel.startsWith(`${root}/history/plans/`)) {
       const planText = readSafe(path.join(projectDir, rel));
       resolveRows(projectDir, (row) => row.kind === "needs-session" && row.body.includes(rel));
-      if (/^\*\*Status:\*\*\s*Complete\b/m.test(planText) && undischargedDocRows(planText).length > 0) {
+      const complete = /^\*\*Status:\*\*\s*Complete\b/m.test(planText);
+      if (complete && undischargedDocRows(planText).length > 0) {
         rows.push(
           formatNeedsSessionRow({
             date: meta.date,
@@ -320,6 +322,19 @@ function detectorForFile(projectDir, rel, meta, rows) {
           })
         );
       }
+      // Whether the plan's documents are TRUE is the polygraph skill's judgment, not a hook's — so
+      // the gate's trace (the `Polygraph:` segment of the Gates line) is raised the same way the doc
+      // ledger is: a `needs-session:` row while it reads `pending` on a Complete plan. A plan with no
+      // segment predates the gate or runs under a harness that ships no polygraph — out of contract.
+      if (complete && polygraphVerdict(planText) === "pending") {
+        rows.push(
+          formatNeedsSessionRow({
+            date: meta.date,
+            description: `${rel} reached Status: Complete with its documents uncertified — run the polygraph skill (gate mode) and write its Polygraph: segment`,
+            refs: rel,
+          })
+        );
+      }
     }
     if (rel.startsWith(`${root}/`)) {
       const findings = docLint(projectDir, rel);
@@ -534,8 +549,10 @@ function postToolUse(projectDir, payload) {
     const rel = relIfInside(projectDir, input.file_path || input.notebook_path);
     if (rel) detectorForFile(projectDir, rel, meta, rows);
     const root = docsRoot(projectDir);
-    // Editing a feature doc's frontmatter can orphan globs the same way a rename can.
-    if (rel && rel.startsWith(`${root}/features/`)) detectRenames(projectDir, "git mv", meta, rows);
+    // Editing an owning doc's frontmatter can orphan globs the same way a rename can. The test is
+    // the scan's own predicate, not a `features/` prefix — a package or system doc owns code too,
+    // and a folder guess here silently stops checking the moment a genre lands somewhere else.
+    if (rel && isOwningDocPath(projectDir, rel)) detectRenames(projectDir, "git mv", meta, rows);
     // A manifest or history file written by a non-Bash tool is the same evasion surface.
     if (rel && (path.posix.basename(rel) === "package.json" || rel.startsWith(`${root}/history/`))) {
       detectOutcomes(projectDir, meta, rows);

package/data/harnesses/code/hooks/lib/ownership.mjs

@@ -1,6 +1,6 @@
 // harness/code/hooks/lib/ownership.mjs — frontmatter scan + owns:-glob resolution, shared by the
 // hook entrypoints (awareness, compliance) and the CI checks so gates and pipeline cannot disagree.
-// Everything here is read-only over docs/features/ and the source tree; no network, no deps.
+// Everything here is read-only over the docs tree and the source tree; no network, no deps.
 
 import fs from "node:fs";
 import path from "node:path";
@@ -81,7 +81,7 @@ export function field(block, key) {
       // A bare key may continue as an indented inline array on the next line, or a `- item` block.
       // The array may span several lines, so join through the closing bracket before parsing —
       // reading only the first line yields a bare "[", which parses to [] and makes the whole doc
-      // look like it owns nothing. `scanFeatureDocs` skips such docs, so the failure is invisible:
+      // look like it owns nothing. `scanOwningDocs` skips such docs, so the failure is invisible:
       // the doc drops out of the ownership index and out of every dead-glob count.
       const next = (lines[i + 1] || "").trim();
       if (next.startsWith("[")) {
@@ -114,13 +114,38 @@ export function asList(v) {
   return (Array.isArray(v) ? v : [v]).map((s) => String(s).trim()).filter(Boolean);
 }
 
-// Scan docs/features/**/*.md and return one entry per feature doc that declares owns:.
+// Folders under the docs root that never hold an owning document, whatever their frontmatter says.
+// `history/` is frozen records — a completed plan's frontmatter is history, not a live claim on code;
+// `research/` is working material that has not been folded into the truth tree yet.
+const NON_OWNING_DIRS = new Set(["history", "research"]);
+
+// True when a repo-relative docs path is one the ownership scan reads — the same predicate
+// `scanOwningDocs` filters by, exported so callers cannot drift from it. A hook asking "could
+// editing this file have orphaned a glob?" must ask exactly this question, not a folder guess.
+export function isOwningDocPath(projectDir, relPath) {
+  const rel = String(relPath).split(path.sep).join("/");
+  const root = docsRoot(projectDir);
+  if (!rel.startsWith(`${root}/`) || !rel.endsWith(".md") || rel.includes(".bkp.")) return false;
+  return !NON_OWNING_DIRS.has(rel.slice(root.length + 1).split("/")[0]);
+}
+
+// Scan the docs tree and return one entry per document that declares owns:.
 // Shape: { doc (repo-relative, /-separated), owns[], module, keywords[], status }.
-export function scanFeatureDocs(projectDir) {
-  const featuresDir = path.join(projectDir, docsRoot(projectDir), "features");
-  // *.bkp.* files are install-time backups awaiting the maintenance fold — a backed-up feature
-  // doc still carries owns: frontmatter, and scanning it would double-own every path it names.
-  const files = listMarkdown(featuresDir).filter((f) => !f.includes(".bkp."));
+//
+// OWNERSHIP IS A FRONTMATTER FACT, NOT A FOLDER FACT. This scanned `docs/features/` alone, which
+// silently un-owned every path claimed by a genre living elsewhere — a `type: package` doc under
+// `docs/architecture/packages/`, a `type: system` doc under `docs/architecture/systems/`. Their
+// globs parsed fine and matched real files; nothing failed, the paths simply read as unowned in
+// the generated index and in the drift report, which is the one failure mode neither surfaces.
+export function scanOwningDocs(projectDir) {
+  const root = path.join(projectDir, docsRoot(projectDir));
+  // *.bkp.* files are install-time backups awaiting the maintenance fold — a backed-up doc
+  // still carries owns: frontmatter, and scanning it would double-own every path it names.
+  const files = listMarkdown(root).filter((f) => {
+    if (f.includes(".bkp.")) return false;
+    const rel = path.relative(root, f).split(path.sep);
+    return !NON_OWNING_DIRS.has(rel[0]);
+  });
   const docs = [];
   for (const file of files) {
     let text;
@@ -146,10 +171,17 @@ export function scanFeatureDocs(projectDir) {
 
 // Build the ownership index text from every feature doc's frontmatter.
 export function buildIndex(projectDir) {
-  // Total markdown under docs/features/, counted independently of scanFeatureDocs — which
-  // drops a doc carrying no owns:, making a parse failure and a doc that owns nothing look alike.
-  const total = listMarkdown(path.join(projectDir, docsRoot(projectDir), "features")).length;
-  const docs = scanFeatureDocs(projectDir);
+  // Every document eligible to own, counted independently of scanOwningDocs — which drops a doc
+  // carrying no owns:, making a parse failure and a doc that owns nothing look alike. Genres that
+  // never own (checklists, operations notes) sit in this total, so `skipped` is a ceiling on the
+  // parse failures rather than a count of them; it is a smell to look at, not a gate.
+  const root = path.join(projectDir, docsRoot(projectDir));
+  const total = listMarkdown(root).filter((f) => {
+    if (f.includes(".bkp.")) return false;
+    const rel = path.relative(root, f).split(path.sep);
+    return !NON_OWNING_DIRS.has(rel[0]);
+  }).length;
+  const docs = scanOwningDocs(projectDir);
   const lines = [];
   let deprecated = 0;
   for (const entry of docs) {
@@ -171,7 +203,7 @@ export function buildIndex(projectDir) {
   if (lines.length === 0) return "";
   lines.sort();
   const header =
-    "# Ownership index (generated) — owning feature doc · module · status, then the code regions it governs.\n" +
+    "# Ownership index (generated) — owning doc · module · status, then the code regions it governs.\n" +
     "# Match the file or topic you're about to touch, then read the owning doc before changing it.\n";
   const indexed = docs.length - deprecated;
   const skipped = total - docs.length;
@@ -179,7 +211,7 @@ export function buildIndex(projectDir) {
   if (deprecated > 0) notes.push(`${deprecated} deprecated`);
   if (skipped > 0) notes.push(`${skipped} with no owns:`);
   const footer = notes.length
-    ? `\n# (${indexed}/${total} feature doc(s) indexed - ${notes.join(", ")})`
+    ? `\n# (${indexed}/${total} doc(s) indexed - ${notes.join(", ")})`
     : "";
   return header + lines.join("\n") + footer;
 }
@@ -270,11 +302,11 @@ export function globToRegExp(glob) {
   return new RegExp(`^${re}$`);
 }
 
-// Feature docs owning the given repo-relative path (deprecated docs excluded).
+// Documents owning the given repo-relative path (deprecated docs excluded).
 export function owningDocs(projectDir, relPath, docs) {
   const rel = relPath.split(path.sep).join("/");
   const out = [];
-  for (const entry of docs || scanFeatureDocs(projectDir)) {
+  for (const entry of docs || scanOwningDocs(projectDir)) {
     if (entry.status === "deprecated") continue;
     if (entry.owns.some((g) => globToRegExp(g).test(rel))) out.push(entry);
   }
@@ -305,12 +337,12 @@ export function listRepoFiles(projectDir) {
   return out;
 }
 
-// Globs across all feature docs that match zero files on disk.
+// Globs across all owning docs that match zero files on disk.
 // Returns [{ glob, doc }]; pass precomputed file/doc lists to amortize the walks.
 export function deadGlobs(projectDir, repoFiles, docs) {
   const files = repoFiles || listRepoFiles(projectDir);
   const dead = [];
-  for (const entry of docs || scanFeatureDocs(projectDir)) {
+  for (const entry of docs || scanOwningDocs(projectDir)) {
     if (entry.status === "deprecated") continue;
     for (const glob of entry.owns) {
       const re = globToRegExp(glob);
@@ -376,7 +408,7 @@ export function owningDoc(projectDir, relPath, docs) {
 export function overlaps(projectDir, repoFiles, docs) {
   const files = repoFiles || listRepoFiles(projectDir);
   const owners = [];
-  for (const entry of docs || scanFeatureDocs(projectDir)) {
+  for (const entry of docs || scanOwningDocs(projectDir)) {
     if (entry.status === "deprecated") continue;
     for (const glob of entry.owns) {
       const s = specificity(glob);

package/data/harnesses/code/hooks/lib/plans.mjs

@@ -28,7 +28,16 @@ export function inPlanScope(rel, scope) {
   });
 }
 
-// Every plan in the folder, parsed once: { file, status, gates, scope, hasLedger,
+// The plan's Polygraph gate, read from its Gates line: 'pending' · 'passed' · 'owes nothing' ·
+// null when the line carries no segment (a plan that predates the gate, or a repo whose harness
+// ships no polygraph — both out of contract, both pass).
+export function polygraphVerdict(text) {
+  const gates = (/^\*\*Gates:\*\*\s*(.+)$/m.exec(text || "") || [])[1] || "";
+  const m = /Polygraph:\s*(pending|passed|owes nothing)\b/i.exec(gates);
+  return m ? m[1].toLowerCase() : null;
+}
+
+// Every plan in the folder, parsed once: { file, status, gates, polygraph, scope, hasLedger,
 // hasDocLedger, ledgerRows }. `gates` is null on legacy plans (pre-Gates format).
 export function listPlans(projectDir) {
   const dir = path.join(projectDir, docsRoot(projectDir), "history", "plans");
@@ -47,6 +56,7 @@ export function listPlans(projectDir) {
       file,
       status,
       gates: (/^\*\*Gates:\*\*\s*(.+)$/m.exec(text) || [])[1]?.trim() || null,
+      polygraph: polygraphVerdict(text),
       scope: planScopePaths(text),
       hasLedger: /^##\s+Test Obligations\b/m.test(text),
       hasDocLedger: /^##\s+Doc Obligations\b/m.test(text),

package/data/harnesses/code/rules/cloudflare.md

@@ -1,3 +1,11 @@
+---
+paths:
+  - "**/wrangler.*"
+  - "**/.dev.vars*"
+  - "**/worker/**"
+  - "**/workers/**"
+  - "**/src/**/*.ts"
+---
 # Cloudflare Worker
 
 Conventions for Cloudflare Workers — `wrangler.jsonc` setup, vars and secrets, and code shape (dispatch, errors, modules, WebSockets). Schema design doctrine is the `schema-design` skill.

package/data/harnesses/code/rules/database.md

@@ -1,3 +1,13 @@
+---
+paths:
+  - "**/*.sql"
+  - "**/migrations/**"
+  - "**/drizzle/**"
+  - "**/drizzle.config.*"
+  - "**/schema.ts"
+  - "**/schema/**"
+  - "**/db/**"
+---
 # Database
 
 Naming and the fixed column vocabulary for relational schemas in **every** Nurix project — one concept, one name, everywhere. Written for SQLite / Cloudflare D1 + Drizzle; a Postgres project keeps the same column names and semantics with native types (`uuid`, `timestamptz`, `boolean`). **Design doctrine — what earns a table, state vs. logs, junctions, FK policy, uniqueness traps — is the `schema-design` skill; consult it before any schema change.**

package/data/harnesses/code/rules/frontend.md

@@ -1,3 +1,13 @@
+---
+paths:
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/*.ts"
+  - "**/*.css"
+  - "**/*.html"
+  - "**/tailwind.config.*"
+  - "**/vite.config.*"
+---
 # Frontend
 
 Tailwind v4 + shadcn-based UI conventions for **web** apps — styling, the `@nurix/components` library, the `design.md` token artifact, and design-skill routing — plus the TypeScript conventions every package compiles under.