@dzhechkov/keysarium 1.7.13 → 1.7.14

package/.dz-manifest.json

@@ -9,7 +9,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "399f8032d0723d371c63c4d94d351614f4a2e11865a6475ab3f1db5c02e45058"
+        "sha256": "8e3d0f7279b85203b4c7a35ae6375f016e607276066e6c73396ac94e58b399cb"
       },
       {
         "path": "README.ru.md",
@@ -21,7 +21,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "3ab5dc27c4025613b6d9d9c5932eff6ef31927190723f63a8fd32b68e462050b"
+        "sha256": "52ff221d4ce111588f31f3940e4374e5ca76eb868753e28560e4ba2b5487d768"
       },
       {
         "path": "src/cli.js",
@@ -385,15 +385,15 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/06-implementation-plan.md",
-        "sha256": "d7a2a4e56b24451da234b1ac4ef440ba9b0370617e1c0cde8ad5f3d575a53209"
+        "sha256": "4eae99dfc266f9c32be3fd302b6a8316924461db8ae5038a169d7a0ec6398e89"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/07-code.md",
-        "sha256": "d5c03890b2b3a34277c73a14d3d7c97741dec1d6c382e87ee4cc6a5a52d938d7"
+        "sha256": "7cd05898db005ad19fbaeb25af3d958d47946f5db195e6969009fd45953e3e30"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/08-qe.md",
-        "sha256": "e2fb5fb869005b05d13fcc52da7ded281bb6758250a1cdf695dace286029d791"
+        "sha256": "4c80cbbae3c4acfb61e4cd0dfbf97e873ef7bded9d41ecaf84959e6fe5e0640f"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/09-fleet-qe.md",
@@ -493,16 +493,24 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/scripts/check-plan-completeness.mjs",
-        "sha256": "8b93949ce4f671d932c5389050db3a3e2750efcbed69681d69f392ccf4d2a168"
+        "sha256": "1c8f8e6ffad01ebdb1bcf6fce6cfb6baae6fe40a9ce377b3894f8addc06c8180"
       },
       {
         "path": "templates/.claude/skills/feature-adr/scripts/check-review-convergence.mjs",
-        "sha256": "6fdacc0ee6c1d2b00029da8d300a574c051895ee98a9c88c9509a39b9bdccc71"
+        "sha256": "91fe091ed7ab8f38340b8ac0fd3194c90b357cb9bab381a86594ac96600ced97"
+      },
+      {
+        "path": "templates/.claude/skills/feature-adr/scripts/expected-target-grammar.mjs",
+        "sha256": "e763efd3af9c7ba71f758f6d6c349b21f2a41ded0420fc165269eab82b6433fb"
       },
       {
         "path": "templates/.claude/skills/feature-adr/scripts/markdown-masker.mjs",
         "sha256": "82c3c48c25f400f3a64d1caba3d47357f3db87460f0746f88706f901eb6ff689"
       },
+      {
+        "path": "templates/.claude/skills/feature-adr/scripts/native-post-ci-evidence.mjs",
+        "sha256": "b19b5491cb42f1e9f2fdefd642e7938640d68fd8bdff991f66fdcebef61f55ae"
+      },
       {
         "path": "templates/.claude/skills/frontend-design/LICENSE.txt",
         "sha256": "0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594"
@@ -1005,5 +1013,5 @@
       }
     ]
   },
-  "signature": "IuyuSO5ojzp0YmewWW4Kmtn854zfx7p7vZmpVXBpzSnV7G24mTKKMJk2QAv0GjtLp9kfiiWwy0WkecuW7nPdCQ=="
+  "signature": "mcdM1pWxiIzC5bkl/QD4KSoJh1L8lBnQLn7KwGZL2ueH3vAvNjOnuef0d02eVjB86skGdmuapJcb5jqZHX/mCw=="
 }

package/README.md

@@ -5,7 +5,7 @@ The bundled Feature ADR projection supports installed-CLI native QE history opt-
 If bytes change before first evaluation, native `evaluate` retains valid old-snapshot receipt origins and conditions while reporting `not-established/native-repair-required`. Follow with explicit `begin-repair` and fresh independent verification of the new snapshot. Recovery preserves authority and the three-cycle ceiling; old evidence never closes changed bytes.
 
 
-Current package version: `1.7.13`. <!-- dz:version -->
+Current package version: `1.7.14`. <!-- dz:version -->
 
 Site: https://aicoding.space · Source: https://github.com/djd1m/dz-harness/tree/main/packages/@dzhechkov/keysarium
 
@@ -562,3 +562,21 @@ terminal `RC_EXIT:0` witness; failure refuses coding/cache access. Admission pre
 and existing `.fa-state/base-ref` (HEAD only when absent); actual coder initialization never resets
 an existing base. Plain uses the same executable helper and mandatory instructions, without an
 automatic dispatcher. Admission observes current bytes; final QE remains the freshness check.
+
+### Literal implementation-plan targets
+
+Feature-ADR K2 completeness, native admission and core plan authority share a raw-text trailing
+`EXPECTED_CODE_TARGETS:` grammar: one uppercase column-zero marker with optional ASCII padding,
+LF-only declaration, nonempty `- ` path rows and trim()-empty blanks through EOF. Suffix headings,
+prose, alternate bullets, CR/CRLF or duplicate raw markers refuse the whole block; markers inside
+examples/comments also count. Payloads stay literal, including backticks and whitespace. Existing
+path authority and native I/O/history bounds still apply. Core establishes no valid subset from
+malformed or rejected/rewritten plan paths. Explicit args retain their separate normalization and
+precedence; coder text remains diagnostic. The standalone grammar helper ships beside the skill's
+native checker and K2 script. No Markdown authenticity is inferred.
+
+Native QE also supports one explicit `begin-post-ci-correction` after the current witnessed fourth cycle is CLOSED. Supply the original `--reviewers`, strict `--owner-approval` declaration (`native-qe-post-ci-owner-approval-1`, including the exact descriptor SHA256), and `--correction-evidence <repo-relative-json-file>`. Core and the installed helper require post-CI capability 2; history and ordinary continuation APIs remain 1. Default ceiling three and the ordinary continuation remain unchanged; the separate fifth target is pinned and no sixth cycle is available.
+
+The canonical local descriptor binds failed CI bytes, one existing test fixture patch, enumerated accepted Git integration, unchanged dependencies, genuine color/neutral full controls and the complete successful mandatory CI identity set. Logs stream within separate 16 MiB/file, four-log/64 MiB bounds; existing source and transaction limits remain unchanged. This is local measured evidence, not remote authentication. Required proof and checkpoints remain obligations. The correction QA namespace must contain exactly its descriptor, referenced proofs and digest-bound `excludedEvidence` supplements, including tracked, untracked and ignored files. Extra entries or changed/missing listed proof block availability; keep inline consent and evolving native/review outputs outside this immutable namespace. Complete fifth receipts may list reviewers in any order; durable closure preserves the original roster order. A mutating evaluate that records loss or replacement invalidates earlier per-reviewer proof verifications; restored bytes require fresh originating receipts bound to the durable observation anchor. Reads and refused prepare do not remember transient loss. Use accepted signed packed local packages before authoritative admission; this change does not publish or activate packages globally.
+
+Schema 2 (`native-qe-post-ci-evidence-2`) adds exact `scope.importedArtifacts` rows (`path`, absent `before`, SHA256 `digest`, byte `size`) for foreign feature history imported by a normal two-parent merge. Schema 1 remains supported with its original closed shape. Selected foreign roots must be absent from the failed/base/preimport trees and have identical complete membership and bytes in accepted, integrated, qualified and current views. Ignored or untracked extras, active-feature/authority paths, source/proof overlap, links and file/directory aliases refuse admission. Imported support shares the existing 2 MiB/file and 16 MiB source aggregate; schema 2 jointly bounds immutable proof/support to 256 files and 256 derived directories. Source manifests remain limited to 256 entries. Support is reobserved by core; recorded loss requires fresh bound originating reviews after restoration.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/keysarium",
-  "version": "1.7.13",
+  "version": "1.7.14",
   "scripts": {},
   "description": "AI Case Research Toolkit for Claude Code — full 7-phase pipeline with feature-adr, dream cycles, background workers, multi-platform support, reward learning, and Cloud.ru AI Factory mapping (--ai-factory flag)",
   "main": "src/cli.js",

package/sbom.json

@@ -25,7 +25,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "399f8032d0723d371c63c4d94d351614f4a2e11865a6475ab3f1db5c02e45058"
+          "content": "8e3d0f7279b85203b4c7a35ae6375f016e607276066e6c73396ac94e58b399cb"
         }
       ]
     },
@@ -59,7 +59,7 @@
         },
         {
           "name": "dz:canonical-json-sha256-v2",
-          "value": "3ab5dc27c4025613b6d9d9c5932eff6ef31927190723f63a8fd32b68e462050b"
+          "value": "52ff221d4ce111588f31f3940e4374e5ca76eb868753e28560e4ba2b5487d768"
         }
       ]
     },
@@ -969,7 +969,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "d7a2a4e56b24451da234b1ac4ef440ba9b0370617e1c0cde8ad5f3d575a53209"
+          "content": "4eae99dfc266f9c32be3fd302b6a8316924461db8ae5038a169d7a0ec6398e89"
         }
       ]
     },
@@ -979,7 +979,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "d5c03890b2b3a34277c73a14d3d7c97741dec1d6c382e87ee4cc6a5a52d938d7"
+          "content": "7cd05898db005ad19fbaeb25af3d958d47946f5db195e6969009fd45953e3e30"
         }
       ]
     },
@@ -989,7 +989,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "e2fb5fb869005b05d13fcc52da7ded281bb6758250a1cdf695dace286029d791"
+          "content": "4c80cbbae3c4acfb61e4cd0dfbf97e873ef7bded9d41ecaf84959e6fe5e0640f"
         }
       ]
     },
@@ -1239,7 +1239,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "8b93949ce4f671d932c5389050db3a3e2750efcbed69681d69f392ccf4d2a168"
+          "content": "1c8f8e6ffad01ebdb1bcf6fce6cfb6baae6fe40a9ce377b3894f8addc06c8180"
         }
       ]
     },
@@ -1249,7 +1249,17 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "6fdacc0ee6c1d2b00029da8d300a574c051895ee98a9c88c9509a39b9bdccc71"
+          "content": "91fe091ed7ab8f38340b8ac0fd3194c90b357cb9bab381a86594ac96600ced97"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "templates/.claude/skills/feature-adr/scripts/expected-target-grammar.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e763efd3af9c7ba71f758f6d6c349b21f2a41ded0420fc165269eab82b6433fb"
         }
       ]
     },
@@ -1263,6 +1273,16 @@
         }
       ]
     },
+    {
+      "type": "file",
+      "name": "templates/.claude/skills/feature-adr/scripts/native-post-ci-evidence.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b19b5491cb42f1e9f2fdefd642e7938640d68fd8bdff991f66fdcebef61f55ae"
+        }
+      ]
+    },
     {
       "type": "file",
       "name": "templates/.claude/skills/frontend-design/LICENSE.txt",

package/templates/.claude/skills/feature-adr/modules/06-implementation-plan.md

@@ -245,10 +245,21 @@ task that implements it: a wrapped continuation line of a list item is not read
 passed would fail this reader, so a plan written before that date may be red on a re-check — move
 the citation onto a task line, or re-check that one plan with `--no-require-task-lines` and say so
 in the checkpoint banner.
+**Literal target declaration:** K2, native source admission and core plan authority read raw text.
+Use exactly one column-zero uppercase `EXPECTED_CODE_TARGETS:` marker (ASCII spaces/tabs after
+it are allowed), followed through EOF by nonempty `- <repo-relative path>` rows and optional
+trim()-empty blank lines. Use LF throughout the declaration; CR/CRLF, another marker, headings,
+prose, fences/comments or alternate/indented bullets after it refuse the whole block. Final LF is
+optional. Markers inside examples/comments count too; this is not a Markdown authenticity check.
+Payloads stay literal: no trimming, backtick removal, slash rewriting or `./` repair. A well-formed
+block still owes the existing path checks; neither malformed grammar nor a rejected/rewritten
+plan path establishes a valid subset. Explicit target args retain their separate normalization
+and precedence; coder text supplies diagnostics only.
+
 What it checks: C1 every ADR **decision** (a `# ADR-NNN` / `## ADR-NNN` heading INSIDE the file, not
 just the filename prefix — a file with several headings owes several plan citations) has a plan task
 citing it · C2 every ADR Confirmation test path is named in the plan · C3 the `EXPECTED_CODE_TARGETS:`
-block parses line by line · C4 the feature's declared acid corpus is named · C5 (WARN) the
+block satisfies the literal trailing grammar and every path passes C3 · C4 the feature's declared acid corpus is named · C5 (WARN) the
 `Inputs read:` line · C8 every requirement id declared in `01_requirements.md` (`FR-N`, `NFR-N`,
 `AC-N`, `C-N`) is cited by the plan by word boundary — WARN with a count by default, FAIL per missing
 id under `--require-requirements` (the pipeline passes this flag; a bare interactive run of the

package/templates/.claude/skills/feature-adr/modules/07-code.md

@@ -60,6 +60,16 @@ retries/re-entry. Refuse a failed initialization before edits. Admission does no
 This is executable Plain guidance with mandatory orchestration, not an automatic Plain dispatcher.
 An unrelated process can change source after admission; ordinary final QE still checks freshness.
 
+The plan's target declaration uses the same literal grammar as K2: exactly one raw column-zero
+uppercase `EXPECTED_CODE_TARGETS:` marker, optional ASCII marker padding, LF-only declaration,
+nonempty dash-space rows and trim()-empty blank lines through EOF. A later heading, prose,
+fence/comment delimiter, alternate bullet, CR or second marker refuses the whole block.
+Raw markers in examples/comments count; no Markdown authenticity is inferred. Path payloads
+are not unquoted, trimmed or repaired. Native containment, symlink/circular exclusions, guard
+provenance, bounded reads and history remain separate authority checks. Core establishes no
+plan targets if grammar or any applicable literal path check fails; coder output remains
+advisory and explicit target args retain their separate precedence and normalization.
+
 ### Current literal context (plain and delegated coding)
 
 Before coding or delegating, run the installed helper beside this module. Set `CONTEXT_HELPER` to
@@ -205,4 +215,4 @@ Tasks completed: {completed}/{total}
 - [ ] ADR decisions reflected in code
 - [ ] No unintended side effects on existing functionality
 - [ ] Change manifest is complete and accurate
-- [ ] No TODO/FIXME/HACK left without justification
+- [ ] No unfinished-work or workaround markers left without justification

package/templates/.claude/skills/feature-adr/modules/08-qe.md

@@ -10,7 +10,7 @@ dz qe-rounds --source native --action prepare --project "$REPO" --feature-dir "$
 
 Bind the actual selected families and use the returned full roster, nonce and revision in the existing QE receipt at `feature/.fa-state/review-convergence-qe-review.json`. An owner-approved family exception must use `owner-exception` and preserve its explicit approval. Call `dz qe-rounds --source native --action evaluate --project "$REPO" --feature-dir "$FEATURE" --json` after actual independent review; missing or incompatible installed core/helper capabilities are NOT ESTABLISHED. No project-local module search, helper override, automatic installation or fake bridge evidence is allowed.
 
-Native history fixes the ceiling at three witnessed cycles, including partial and unresolved originating reviews. Multiple roles, fallback, repeated prepare/evaluate and restart share one cycle. Prepare may refresh artifacts before a review originates. After witnessing, a measured code/design change requires explicit `--action begin-repair` with the actual roster before another review; unchanged third-cycle completion may finish, while a fourth opening is refused. The ceiling applies to formal feature review as well as focused roles. Do not evade it by changing family, host, source or nonce. No-verdict attempts are reported separately. Native `--ceiling` is refused.
+Native history keeps the default ceiling at three witnessed cycles, including partial and unresolved originating reviews. Multiple roles, fallback, repeated prepare/evaluate and restart share one cycle. Prepare may refresh artifacts before a base-cycle review originates; an admitted continuation target is already pinned. After witnessing, a measured code/design change requires explicit `--action begin-repair` with the actual roster before another review; unchanged third-cycle completion may finish, while an ordinary fourth opening is refused. Explicit `begin-continuation` is the one-use owner-bound exception described below; it pins the fourth target before review and never permits cycle five. The ceiling applies to formal feature review as well as focused roles. Do not evade it by changing family, host, source or nonce. No-verdict attempts are reported separately. Native `--ceiling` is refused.
 
 If bytes change after an independent receipt arrives but before its first evaluation, call `--action evaluate` to retain the receipt's valid origins and conditions against its admitted old snapshot. The result remains `not-established` with `native-repair-required`; it never closes current bytes or the historical checkpoint. Then call `--action begin-repair` with the actual roster and obtain fresh independent verification of the new snapshot, including the author delta and original conditions. A missing or invalid origin cannot witness a cycle or authorize repair. Keep the surviving receipt and native authority intact through recovery.
 
@@ -646,3 +646,22 @@ Verdict: {READY | NEEDS FIXES | CONDITIONAL}
 - [ ] Gap detection loop completed with zero remaining gaps (M+)
 - [ ] QCSD quality risks from Step 3.5 verified as mitigated (M+)
 - [ ] QE report created and complete
+
+Native QE keeps its default ceiling at three. `dz qe-rounds --source native --action begin-continuation --project <root> --slug <feature> --reviewers <actual-roster-json> --owner-approval <inline-json>` can admit exactly one additional cycle after three witnessed cycles whose active cycle has never closed. A second ordinary continuation refuses. The target is pinned before its fourth origin; prepare and repair cannot redirect it. Fresh independent receipts, original reviewer conditions, author delta assessment and checkpoint verification still govern closure. An admitted checkpoint remains required if its file is removed or replaced; restore the original checkpoint and obtain independent verification before closure. Prepare retains its digest, and replay rejects a closed continuation without matching checkpoint evidence.
+
+The exact flat declaration has schema `native-qe-owner-approval-1`, a UUIDv4 `approvalId`, nonempty `owner` (≤256 characters), `decision` (≤2048), `evidenceSource` (≤4096), canonical `projectRoot` and `featurePath`, `journalId`, `sequence`, `eventDigest`, `cycleId`, prior `revision` and distinct measured `targetRevision`. Native read-only reporting exposes the predecessor event digest. Inline JSON and its serialized declaration are capped at 16 KiB. Obtain the changed target digest from the bounded artifact manifest; consent must explicitly bind it. No helper fills missing consent or updates stale bindings. Exact committed retries can return the admitted cycle without appending.
+
+This is surviving local owner evidence, not human authentication or acceptance. Core and the CLI-owned installed helper require continuation capability 1 while legacy APIs remain 1. Older readers reject the extended event explicitly. Install only accepted, signed local packed candidates before authoritative use; no npm publication is required. Journal/head/host publication remains conservatively crash detecting under the existing lock, with no filesystem atomicity claim.
+
+
+### One post-CI correction after CLOSED fourth
+
+The separate action is `dz qe-rounds --source native --action begin-post-ci-correction --project <root> --slug <feature> --reviewers <original-roster-json> --owner-approval <strict-inline-json> --correction-evidence <repo-relative-json-file>`. Both installed capabilities must advertise post-CI version 2; history and ordinary continuation APIs remain 1. The current fourth event must be its witnessed CLOSED evaluation. This opens one pinned fifth in the same journal; it cannot be redirected, renewed, repaired into a sixth or substituted by another continuation. Historical fourth receipts remain history.
+
+The declaration keeps the thirteen existing owner bindings, changes schema to `native-qe-post-ci-owner-approval-1`, and requires `evidenceDigest` for the exact canonical descriptor bytes. Descriptor schemas are legacy `native-qe-post-ci-evidence-1` and imported-history `native-qe-post-ci-evidence-2`; compact JSON plus LF, strict finite keys, max128 KiB, no duplicate keys. All referenced immutable proof belongs under the exact feature `qa/post-ci-correction/` namespace. The correction QA namespace must contain exactly its descriptor, referenced proofs and digest-bound `excludedEvidence` supplements, including tracked, untracked and ignored files. Extra entries or changed/missing listed proof block availability; keep inline consent and evolving native/review outputs outside this immutable namespace. Complete fifth receipts may list reviewers in any order; durable closure preserves the original roster order. Archive complete failed CI output with its actual canceled/failing conclusion, exact fixture patch, accepted integration provenance, both successful full baseline modes and the complete successful CI policy/check set. Separate raw logs allow16 MiB each, four distinct logs/64 MiB total using bounded streaming; source/journal/host/manifest/deadline limits do not increase. Hashes and locally asserted policy do not authenticate remote CI or owner identity.
+
+Every original roster role must independently inspect the actual full scope, imported merge resolutions, qualification and unchanged dependencies. Each current review entry adds `postCiEvidenceVerification` with exact keys `{schema,evidenceDigest,revision,nonce,anchorSequence,anchorEventDigest,supported,evidence}`; schema `native-qe-post-ci-verification-1`, supported=true, with actual nonempty independent evidence. Read reports descriptor and current anchor through `postCiCorrection`. The initial anchor is fifth admission; a durably recorded missing/replaced proof or checkpoint evaluation advances it. A generic clean or delta/checkpoint verification cannot replace this extension. Ordinary/legacy reviews reject the unexpected extension.
+
+A missing/replaced required proof or checkpoint blocks acceptance. Mutating evaluate records `native-post-ci-proof-unavailable` without origins, preserving cycle, target, conditions and all history. Restoration plus old same-target receipts remains blocked; fresh per-role proofs must bind the current anchor. Read and refused prepare do not append, and no operation can remember an unobserved loss/restoration. Closure independently binds the complete preserved roster via `postCiEvidenceClosure`; checkpoint closure remains conjunctive. Accept this mechanism's independent QE and required CI, then install its exact signed local packages before any original-feature fifth admission. No global activation or npm publication is implied.
+
+Schema 2 (`native-qe-post-ci-evidence-2`) adds exact `scope.importedArtifacts` rows (`path`, absent `before`, SHA256 `digest`, byte `size`) for foreign feature history imported by a normal two-parent merge. Schema 1 remains supported with its original closed shape. Selected foreign roots must be absent from the failed/base/preimport trees and have identical complete membership and bytes in accepted, integrated, qualified and current views. Ignored or untracked extras, active-feature/authority paths, source/proof overlap, links and file/directory aliases refuse admission. Imported support shares the existing 2 MiB/file and 16 MiB source aggregate; schema 2 jointly bounds immutable proof/support to 256 files and 256 derived directories. Source manifests remain limited to 256 entries. Support is reobserved by core; recorded loss requires fresh bound originating reviews after restoration.

package/templates/.claude/skills/feature-adr/scripts/check-plan-completeness.mjs

@@ -101,6 +101,7 @@ import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { isAbsolute, join, resolve } from 'node:path';
+import { parseExpectedTargetBlock } from './expected-target-grammar.mjs';
 
 const argv = process.argv.slice(2);
 const acidArg = argv.find((a) => a.startsWith('--acid='));
@@ -151,8 +152,8 @@ if (!existsSync(FDIR)) notEstablished(`feature dir absent: ${FDIR}`);
 if (!existsSync(planPath)) notEstablished('06_implementation_plan.md absent');
 const plan = readFileSync(planPath, 'utf-8');
 if (plan.trim().length < 200) notEstablished('plan suspiciously small (<200 chars)');
-// The EXPECTED_CODE_TARGETS block as C3 reads it (C3 below reuses THIS match — one reader).
-const blockM = plan.match(/EXPECTED_CODE_TARGETS:\s*\n((?:\s*[-*]\s*.+\n?)+)/);
+// C3 and task exclusion share the raw trailing declaration boundary, even on malformed input.
+const targetBlock = parseExpectedTargetBlock(plan);
 
 // `## Amendments` as C6 reads it: up to three leading spaces, two to four hashes, trailing text
 // allowed; the section ends at the next level-1..4 heading. Returned as LINE indices over masked
@@ -179,15 +180,11 @@ function findAmendmentsSection(maskedLines) {
 function planTaskText(planText) {
   const lines = maskMarkdown(planText, { unclosed: 'mask' }).split('\n');
   const am = findAmendmentsSection(lines);
-  let tFrom = -1, tTo = -1;
-  if (blockM) {
-    tFrom = planText.slice(0, blockM.index).split('\n').length - 1;
-    tTo = planText.slice(0, blockM.index + blockM[0].length - 1).split('\n').length - 1;
-  }
+  const tFrom = targetBlock.startLine;
   const keep = [];
   for (let i = 0; i < lines.length; i++) {
     if (am.head >= 0 && i >= am.head && i < am.end) continue;
-    if (tFrom >= 0 && i >= tFrom && i <= tTo) continue;
+    if (tFrom >= 0 && i >= tFrom) continue;
     const l = lines[i];
     if (/^ {0,3}#{1,6}\s/.test(l) || /^\s*(?:[-*+]|\d+[.)])\s+/.test(l) || /^\s*\|/.test(l)) keep.push(l);
   }
@@ -408,14 +405,11 @@ function classifyTargetPath(path) {
 
 // C3 — EXPECTED_CODE_TARGETS block, line-level validation
 const listedTargets = new Set();
-if (!blockM) failures.push('C3: no EXPECTED_CODE_TARGETS: block in the plan');
+if (!targetBlock.ok) failures.push(`C3: EXPECTED_CODE_TARGETS declaration refused — ${targetBlock.reason}`);
 else {
-  const lines = blockM[1].split('\n').map(s => s.trim()).filter(Boolean);
-  if (lines.length === 0) failures.push('C3: EXPECTED_CODE_TARGETS block is empty');
-  for (const ln of lines) {
-    const path = ln.replace(/^[-*]\s*/, '').replace(/`/g, '').trim();
+  for (const path of targetBlock.targets) {
     const reasons = classifyTargetPath(path);
-    if (reasons.length) failures.push(`C3: target line rejected: "${safe(ln)}" — ${reasons.join(', ')}`);
+    if (reasons.length) failures.push(`C3: target line rejected: "${safe(path)}" — ${reasons.join(', ')}`);
     else listedTargets.add(path);
   }
 }

package/templates/.claude/skills/feature-adr/scripts/check-review-convergence.mjs

@@ -12,6 +12,8 @@ import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, open
 import { dirname, relative, resolve, sep } from 'node:path'
 import { execFileSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
+import { parseExpectedTargetBlock } from './expected-target-grammar.mjs'
+import { measureNativePostCiEvidence } from './native-post-ci-evidence.mjs'
 
 export const SCHEMA = 'fa-review-convergence-1'
 const phases = ['ideation', 'qe']
@@ -34,9 +36,9 @@ function checkpointProof(p) {
   return dictionary(p, ['checkpointDigest', 'evidence', 'supported', 'route', 'findings', 'reportDigest']) && hash(p.checkpointDigest) && text(p.evidence) && p.supported === true && ['native', 'mode-b', 'fallback'].includes(p.route) && array(p.findings) && p.findings.every(v => dictionary(v, ['digest', 'conditionId']) && hash(v.digest) && text(v.conditionId)) && (p.reportDigest === null || hash(p.reportDigest))
 }
 function reviewerFamily(stage) { return stage.qeReviewerUsed === 'codex-fallback' ? 'codex' : stage.qeReviewerUsed }
-function reviewerEntry(r, roster) {
+function reviewerEntry(r, roster, postCi = false) {
   const owners = roster.map(p => p.id)
-  return !(!dictionary(r, ['reviewer', 'family', 'independent', 'verdict', 'conditions', 'verifications', 'newRisks', 'authorAssessmentChecked', 'deltaVerification', 'checkpointVerification'], ['reviewer', 'family', 'independent', 'verdict', 'conditions', 'verifications', 'newRisks', 'authorAssessmentChecked', 'deltaVerification']) || !owners.includes(r.reviewer) || roster.find(p => p.id === r.reviewer)?.family !== r.family || r.independent !== true || !['clean', 'conditional', 'no-go'].includes(r.verdict) || !array(r.conditions) || !r.conditions.every(c => condition(c, owners) && c.owner === r.reviewer) || !array(r.verifications) || !risks(r.newRisks, owners) || !r.newRisks.conditions.every(c => c.owner === r.reviewer) || typeof r.authorAssessmentChecked !== 'boolean')
+  return !(!dictionary(r, ['reviewer', 'family', 'independent', 'verdict', 'conditions', 'verifications', 'newRisks', 'authorAssessmentChecked', 'deltaVerification', 'checkpointVerification', ...(postCi ? ['postCiEvidenceVerification'] : [])], ['reviewer', 'family', 'independent', 'verdict', 'conditions', 'verifications', 'newRisks', 'authorAssessmentChecked', 'deltaVerification']) || !owners.includes(r.reviewer) || roster.find(p => p.id === r.reviewer)?.family !== r.family || r.independent !== true || !['clean', 'conditional', 'no-go'].includes(r.verdict) || !array(r.conditions) || !r.conditions.every(c => condition(c, owners) && c.owner === r.reviewer) || !array(r.verifications) || !risks(r.newRisks, owners) || !r.newRisks.conditions.every(c => c.owner === r.reviewer) || typeof r.authorAssessmentChecked !== 'boolean')
 }
 function result(phase, verdict, revision, reasons, unresolved = []) { return { schema: SCHEMA, phase, verdict, revision, unresolved, reasons } }
 
@@ -53,7 +55,7 @@ function hostProblem(host) {
   if (host.conditions.some(c => c.scope.some(path => !manifest.some(p => p.path === path)))) return 'host-condition-scope-unbound'
   return null
 }
-export function evaluateReviewConvergence(host, receipt, currentManifest, originOnly = false) {
+export function evaluateReviewConvergence(host, receipt, currentManifest, originOnly = false, postCi = false) {
   const phase = host?.phase
   const refuse = reason => result(phase || 'qe', 'not-established', host?.snapshot?.revision || null, [reason], (array(host?.conditions) ? host.conditions : []).map(c => c?.id))
   const problem = hostProblem(host)
@@ -78,7 +80,7 @@ export function evaluateReviewConvergence(host, receipt, currentManifest, origin
     }
   }
   for (const r of receipt.reviews) {
-    if (!reviewerEntry(r, host.reviewers)) return refuse('reviewer-contract-invalid')
+    if (!reviewerEntry(r, host.reviewers, postCi)) return refuse('reviewer-contract-invalid')
     if (Object.hasOwn(r, 'checkpointVerification') && !checkpointProof(r.checkpointVerification)) return refuse('checkpoint-verification-contract-invalid')
     if (receipt.author && !r.authorAssessmentChecked) return refuse('author-risk-assessment-not-reviewed')
     if (receipt.author) {
@@ -150,14 +152,9 @@ function pathsFor(repo, feature, phase, native = false) {
   if (phase === 'qe') {
     const planFile = safePath(repo, prefix + '/06_implementation_plan.md', false)
     const plan = native ? new TextDecoder('utf-8', { fatal: true }).decode(nativeBytes(planFile, 2 * 1024 * 1024)) : readFileSync(planFile, 'utf8')
-    const block = plan.split(/^EXPECTED_CODE_TARGETS:\s*$/m)
-    if (block.length !== 2) throw Error('target-block-missing-or-duplicate')
-    const planned = block[1].split('\n').filter(line => line.trim()).map(line => {
-      const match = /^- (.+)$/.exec(line)
-      if (!match) throw Error('target-block-malformed')
-      return match[1]
-    })
-    if (!planned.length) throw Error('target-block-empty')
+    const block = parseExpectedTargetBlock(plan)
+    if (!block.ok) throw Error(block.reason)
+    const planned = block.targets
     const baseFile = resolve(feature, '.fa-state/base-ref')
     const base = existsSync(baseFile) ? (native ? nativeBytes(baseFile, 256 * 1024).toString('utf8') : readFileSync(baseFile, 'utf8')).trim() : 'HEAD'
     if (!/^[A-Za-z0-9_./:-]+$/.test(base) || base.startsWith('-')) throw Error('base-ref-invalid')
@@ -165,13 +162,13 @@ function pathsFor(repo, feature, phase, native = false) {
     // Exact index membership includes staged additions/intent-to-add. The selected
     // base proves deletions; descendants and unrelated history confer no authority.
     const proof = [['ls-files', '--cached', '-z', '--', guard], ['ls-tree', '-r', '--name-only', '-z', base, '--', guard]].map(command =>
-      execFileSync('git', command, { cwd: repo, encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, ...(native ? { timeout: 2000, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } } : {}) }).split('\0').includes(guard))
+      execFileSync('git', native ? ['-c', 'diff.autoRefreshIndex=false', ...command] : command, { cwd: repo, encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, ...(native ? { timeout: 2000, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } } : {}) }).split('\0').includes(guard))
     const allowedGuard = p => p === guard && proof.some(Boolean)
     if (planned.some(p => /^(features|\.dz|\.agentic-qe|roam)\//.test(p) && !allowedGuard(p))) throw Error('circular-review-target')
     paths.push(...planned)
     // Additions/deletions are discovered by the host, not the author delta request.
     for (const command of [['diff', '--no-renames', '--name-only', '-z', base, '--'], ['ls-files', '--others', '--exclude-standard', '-z']]) {
-      const names = execFileSync('git', command, { cwd: repo, encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, ...(native ? { timeout: 2000, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } } : {}) }).split('\0').filter(Boolean)
+      const names = execFileSync('git', native ? ['-c', 'diff.autoRefreshIndex=false', ...command] : command, { cwd: repo, encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, ...(native ? { timeout: 2000, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } } : {}) }).split('\0').filter(Boolean)
       paths.push(...names.filter(p => allowedGuard(p) || !p.startsWith('features/') && !p.startsWith('.dz/') && !p.startsWith('.agentic-qe/') && !p.startsWith('roam/') && p !== 'architecture/map.json'))
     }
   }
@@ -332,6 +329,8 @@ export function runGate({ action, repo, feature, phase, reviewers }) {
 
 // Only the CLI supplies this capability. The default standalone runGate remains synchronous.
 export const NATIVE_REVIEW_API_VERSION = 1
+export const NATIVE_REVIEW_CONTINUATION_API_VERSION = 1
+export const NATIVE_REVIEW_POST_CI_CORRECTION_API_VERSION = 2
 function nativeNames(dir) {
   if (!existsSync(dir)) return []
   const st = lstatSync(dir)
@@ -366,18 +365,22 @@ function nativeManifest(repo, paths) {
     return { path, digest: bytes === null ? null : digest(bytes) }
   })
 }
-function nativeReceipt(host, receipt, manifest) {
+function nativeReceipt(host, receipt, manifest, postCi = false) {
   // Reuse the unchanged strong aggregate gate with just the originating subset roster.
   // Missing reviewers can prevent closure without invalidating a structurally valid partial origin.
   if (!host || host.phase !== 'qe' || !dictionary(receipt, ['schema', 'phase', 'nonce', 'revision', 'reviews', 'author']) || receipt.schema !== SCHEMA || receipt.phase !== 'qe' || receipt.nonce !== host.snapshot.nonce || receipt.revision !== host.snapshot.revision || !array(receipt.reviews, 16) || !receipt.reviews.length || new Set(receipt.reviews.map(r => r?.reviewer)).size !== receipt.reviews.length) return null
-  if (!receipt.reviews.every(r => reviewerEntry(r, host.reviewers))) return null
-  const checked = evaluateReviewConvergence(host, receipt, manifest, true)
+  if (!receipt.reviews.every(r => reviewerEntry(r, host.reviewers, postCi))) return null
+  const checked = evaluateReviewConvergence(host, receipt, manifest, true, postCi)
   if (checked.verdict === 'not-established') return null
   return receipt.reviews.map(r => ({ reviewer: r.reviewer, family: r.family }))
 }
-export function runNativeReviewGate({ action, repo, feature, reviewers, api }) {
+export function runNativeReviewGate({ action, repo, feature, reviewers, ownerApproval, correctionEvidence, api }) {
   if (!api || api.version !== 1 || typeof api.transact !== 'function') throw Error('native-core-capability-not-established')
-  if (!['prepare', 'evaluate', 'begin-repair'].includes(action)) throw Error('native-action-invalid')
+  if (!['prepare', 'evaluate', 'begin-repair', 'begin-continuation', 'begin-post-ci-correction'].includes(action)) throw Error('native-action-invalid')
+  if (action === 'begin-continuation' && api.continuationVersion !== 1) throw Error('native-continuation-capability-not-established')
+  if (!['begin-continuation', 'begin-post-ci-correction'].includes(action) && ownerApproval !== undefined) throw Error('native-owner-approval-action-invalid')
+  if (action === 'begin-post-ci-correction' && (api.postCiCorrectionVersion !== 2 || typeof api.validateEvidence !== 'function')) throw Error('native-post-ci-capability-not-established')
+  if (action !== 'begin-post-ci-correction' && correctionEvidence !== undefined) throw Error('native-post-ci-evidence-action-invalid')
   repo = realpathSync(repo); feature = realpathSync(resolve(repo, feature))
   const prefix = relative(repo, feature).split(sep).join('/')
   if (!prefix || prefix.startsWith('../') || api.projectRoot !== repo || api.featurePath !== feature) throw Error('native-feature-binding-invalid')
@@ -420,8 +423,9 @@ export function runNativeReviewGate({ action, repo, feature, reviewers, api }) {
       if (!r.verifications.every(v => dictionary(v, ['id', 'revision', 'classification', 'evidence', 'implementationVerified']) && text(v.id) && hash(v.revision) && kinds.includes(v.classification) && text(v.evidence) && typeof v.implementationVerified === 'boolean') || new Set(r.verifications.map(v => v.id)).size !== r.verifications.length) throw Error('native-ideation-verification-invalid')
     }
   }
+  const nativeState = api.read?.(), postCi = Boolean(nativeState?.postCiCorrection?.used)
   let checkpoint = null
-  if (observed[2] !== null) {
+  try { if (observed[2] !== null) {
     if (observed[2].length && observed[2][observed[2].length - 1] !== 10) throw Error('native-checkpoint-candidate-torn')
     for (const line of new TextDecoder('utf-8', { fatal: true }).decode(observed[2]).split('\n').filter(Boolean)) {
       const entry = JSON.parse(line)
@@ -429,11 +433,13 @@ export function runNativeReviewGate({ action, repo, feature, reviewers, api }) {
       if (entry.stage === 'qe') checkpoint = { checkpointDigest: digest(JSON.stringify(entry.result)), checkpoint: entry.result }
     }
   }
+  } catch (error) { if (!postCi) throw error }
   const directoryFence = () => ({ adr: nativeNames(safePath(repo, prefix + '/03_adr')), bridge: nativeNames(safePath(repo, prefix + '/.fa-state/qe-bridge')), fragments: nativeNames(stateDir).filter(n => /^native-qe-(history\.jsonl|head\.json)\..*\.tmp$/.test(n)) })
   const membership = directoryFence()
   const paths = pathsFor(repo, feature, 'qe', true).concat((host?.conditions || []).flatMap(c => c.scope))
   const manifest = nativeManifest(repo, paths)
   if (action !== 'evaluate' && (!array(reviewers, 16) || !reviewers.length || !reviewers.every(r => dictionary(r, ['id', 'family']) && text(r.id) && ['codex', 'claude', 'owner-exception'].includes(r.family)) || new Set(reviewers.map(r => r.id)).size !== reviewers.length)) throw Error('reviewers-invalid')
+  const correction = action === 'begin-post-ci-correction' ? measureNativePostCiEvidence({ repo, featurePath: prefix, evidencePath: correctionEvidence, previous: nativeState?.postCiCorrection?.evidence?.predecessorHost?.snapshot?.manifest || nativeState?.snapshot?.manifest, current: manifest, validate: api.validateEvidence }) : null
   const observationDigest = digest(JSON.stringify({ files: observed.slice(1).map(b => b === null ? null : digest(b)), membership, manifest }))
   const checkpointClosure = host && receipt && checkpoint ? reconcileCheckpoint(host, receipt, checkpoint, repo, feature, observed[7]) : null
   return api.transact(action, active => {
@@ -451,18 +457,19 @@ export function runNativeReviewGate({ action, repo, feature, reviewers, api }) {
     if (!active && (observed[1] !== null || host && (host.reviewSeen || host.rework || host.conditions.length) || checkpoint)) throw Error('native-surviving-review-evidence-refuses-admission')
     if (active && (!host || !same(host.snapshot, active.snapshot))) throw Error('native-host-admitted-snapshot-mismatch')
     const revision = digest(JSON.stringify(manifest))
-    const priorOrigins = nativeReceipt(host, receipt, host?.snapshot.manifest)
-    if (action === 'prepare' && host && host.snapshot.revision !== revision && (active?.witnessed || priorOrigins)) throw Error('native-repair-required')
+    const priorOrigins = nativeReceipt(host, receipt, host?.snapshot.manifest, Boolean(active?.postCiCorrection?.used))
+    if (action === 'prepare' && host && host.snapshot.revision !== revision && (active?.witnessed || priorOrigins) && !active?.continuation) throw Error('native-repair-required')
     if (action === 'evaluate') {
       if (!active || !host) throw Error('native-prepare-required')
       const drift = !same(manifest, host.snapshot.manifest)
       // A surviving receipt may witness admitted A after bytes become B. It cannot
       // accept B: retain A and its origins, then require a separate begin-repair.
       // Current bytes still participate in the observation digest and every fence.
-      const origins = priorOrigins
+      const origins = active?.postCiCorrection?.used && priorOrigins ? host.reviewers.filter(r => priorOrigins.some(o => o.reviewer === r.id && o.family === r.family)).map(r => ({ reviewer: r.id, family: r.family })) : priorOrigins
       let verdict = drift ? result('qe', 'not-established', host.snapshot.revision, ['native-repair-required'])
-        : receipt === null ? result('qe', 'not-established', revision, [receiptProblem || 'reviewer-receipt-missing']) : evaluateReviewConvergence(host, receipt, manifest)
+        : receipt === null ? result('qe', 'not-established', revision, [receiptProblem || 'reviewer-receipt-missing']) : evaluateReviewConvergence(host, receipt, manifest, false, Boolean(active?.postCiCorrection?.used))
       // Closure is deliberately stronger than originating partial/unresolved evidence.
+      if (verdict.verdict === 'closed' && active.continuation && active.checkpointDigest && checkpoint?.checkpointDigest !== active.checkpointDigest) verdict = result('qe', 'not-established', revision, ['native-continuation-checkpoint-unavailable-or-changed'])
       if (verdict.verdict === 'closed' && checkpoint && !checkpointClosure) verdict = result('qe', 'not-established', revision, ['historical-checkpoint-own-verification-missing'])
       const preserved = new Map(host.conditions.map(c => [c.id, c]))
       if (origins) {
@@ -471,15 +478,23 @@ export function runNativeReviewGate({ action, repo, feature, reviewers, api }) {
       }
       if (drift) verdict.unresolved = [...preserved.keys()]
       if (verdict.verdict === 'closed' && checkpointClosure) verdict = { ...verdict, checkpointClosure }
-      const next = { ...host, conditions: [...preserved.values()], reviewSeen: host.reviewSeen || Boolean(origins), changedPaths: verdict.verdict === 'closed' ? [] : host.changedPaths }
+      if (verdict.verdict === 'closed' && active.postCiCorrection?.used) {
+        const p = active.postCiCorrection, bound = { evidenceDigest: p.evidence.approval.evidenceDigest, revision: host.snapshot.revision, nonce: host.snapshot.nonce, anchorSequence: p.anchorSequence, anchorEventDigest: p.anchorEventDigest }
+        const required = ['schema', ...Object.keys(bound), 'supported', 'evidence']
+        const proofs = host.reviewers.map(r => ({ reviewer: r.id, family: r.family, verification: receipt.reviews.find(v => v.reviewer === r.id && v.family === r.family)?.postCiEvidenceVerification }))
+        const valid = proofs.every(({ verification: v }) => dictionary(v, required) && v.schema === 'native-qe-post-ci-verification-1' && Object.keys(bound).every(k => v[k] === bound[k]) && v.supported === true && text(v.evidence))
+        verdict = valid ? { ...verdict, postCiEvidenceClosure: { ...bound, origins: proofs } } : result('qe', 'not-established', revision, ['native-post-ci-origin-verification-missing-or-stale'])
+      }
+      const next = { ...host, conditions: [...preserved.values()], reviewSeen: host.reviewSeen || Boolean(origins), changedPaths: verdict.verdict === 'closed' && !active.postCiCorrection?.used ? [] : host.changedPaths }
       return { host: next, snapshot: host.snapshot, origins: origins || [], receiptDigest: observed[1] === null ? null : digest(observed[1]), reason: origins ? null : verdict.reasons[0] || 'native-no-valid-origin', observationDigest, result: verdict, admission: false }
     }
     const bound = bindReviewers(host, reviewers, checkpoint)
     const snapshot = active?.snapshot.revision === revision ? active.snapshot : host?.snapshot.revision === revision ? host.snapshot : { nonce: randomUUID(), revision, manifest }
     const old = new Map((host?.snapshot.manifest || []).map(p => [p.path, p.digest])), current = new Map(manifest.map(p => [p.path, p.digest]))
-    const changedPaths = host && host.snapshot.revision !== revision ? [...new Set([...old.keys(), ...current.keys()])].filter(p => old.get(p) !== current.get(p)).sort() : host?.changedPaths || []
+    const deltaPaths = host && host.snapshot.revision !== revision ? [...new Set([...old.keys(), ...current.keys()])].filter(p => old.get(p) !== current.get(p)).sort() : host?.changedPaths || []
+    const changedPaths = ['begin-continuation', 'begin-post-ci-correction'].includes(action) ? [...new Set([...(host?.changedPaths || []), ...deltaPaths])].sort() : deltaPaths
     const next = { schema: SCHEMA, phase: 'qe', reviewers: bound, snapshot, conditions: host?.conditions || [], reviewSeen: host?.reviewSeen || false, rework: Boolean(host && (host.rework || host.reviewSeen && host.snapshot.revision !== revision)), changedPaths }
-    return { host: next, snapshot, origins: [], receiptDigest: null, reason: null, observationDigest, result: { ...result('qe', 'prepared', revision, []), nonce: snapshot.nonce, manifest, reviewers: bound, conditions: next.conditions, checkpointDigest: checkpoint?.checkpointDigest || null }, admission: !active }
+    return { host: next, snapshot, origins: [], receiptDigest: null, reason: null, observationDigest, result: { ...result('qe', 'prepared', revision, []), nonce: snapshot.nonce, manifest, reviewers: bound, conditions: next.conditions, checkpointDigest: active?.continuation ? active.checkpointDigest : checkpoint?.checkpointDigest || null }, admission: !active, ...(['begin-continuation', 'begin-post-ci-correction'].includes(action) ? { ownerApproval } : {}), ...(correction ? { correctionEvidence: correction } : {}) }
   })
 }
 

package/templates/.claude/skills/feature-adr/scripts/expected-target-grammar.mjs

@@ -0,0 +1,22 @@
+/** Raw-text trailing declaration grammar. Path authority is a separate layer. */
+export function parseExpectedTargetBlock(text) {
+  const lines = String(text || '').split('\n');
+  const markers = [];
+  for (let i = 0; i < lines.length; i++) {
+    const match = /^EXPECTED_CODE_TARGETS:[ \t]*\r?$/.exec(lines[i]);
+    if (match && match[0] === lines[i]) markers.push(i);
+  }
+  const startLine = markers.length ? markers[0] : -1;
+  if (markers.length !== 1) return { ok: false, targets: [], startLine, reason: 'target-block-missing-or-duplicate' };
+  if (lines.slice(startLine).some(line => line.includes('\r'))) return { ok: false, targets: [], startLine, reason: 'target-block-malformed' };
+  const targets = [];
+  for (const line of lines.slice(startLine + 1)) {
+    if (!line.trim()) continue;
+    const match = /^- (.+)$/.exec(line);
+    // Full-line equality also refuses a final U+2028/U+2029 that $ can match before.
+    if (!match || match[0] !== line) return { ok: false, targets: [], startLine, reason: 'target-block-malformed' };
+    targets.push(match[1]);
+  }
+  if (!targets.length) return { ok: false, targets: [], startLine, reason: 'target-block-empty' };
+  return { ok: true, targets, startLine };
+}

package/templates/.claude/skills/feature-adr/scripts/native-post-ci-evidence.mjs

@@ -0,0 +1,213 @@
+// Local measured Git/file provenance, never remote policy or reviewer authentication.
+import { createHash } from 'node:crypto'
+import { constants, closeSync, fstatSync, lstatSync, openSync, opendirSync, readSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { execFileSync } from 'node:child_process'
+import { performance } from 'node:perf_hooks'
+const sha = s => createHash('sha256').update(s).digest('hex')
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b)
+const fail = s => { throw Error('native-post-ci-' + s) }
+function safe(repo, path) {
+  if (typeof path !== 'string' || path.startsWith('/') || /[\\\x00-\x1f]/.test(path) || path.split('/').some(p => !p || p === '.' || p === '..')) fail('path-invalid')
+  let file = repo
+  for (const part of path.split('/')) { file = resolve(file, part); if (lstatSync(file).isSymbolicLink()) fail('symlink') }
+  return file
+}
+function read(repo, proof, limit, selection = null, identity = null, imported = false, deadline = () => {}) {
+  const file = safe(repo, proof.path), st = lstatSync(file)
+  identity?.(proof.path, st); deadline()
+  if (!st.isFile() || st.size > limit || imported && (st.nlink !== 1 || st.size !== proof.size)) fail('file-type-or-limit')
+  const fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW), h = createHash('sha256')
+  const buffer = Buffer.alloc(65536), sample = selection ? Buffer.alloc(selection.length) : null
+  const chunks = limit <= 128 * 1024 ? [] : null
+  let count = 0, copied = 0
+  try {
+    const first = fstatSync(fd)
+    if (!first.isFile() || first.ino !== st.ino || first.dev !== st.dev || first.size !== st.size) fail('file-identity-changed')
+    while (true) {
+      deadline(); const n = readSync(fd, buffer, 0, buffer.length, null); if (!n) break
+      if (count + n > limit) fail('file-limit')
+      h.update(buffer.subarray(0, n)); if (chunks) chunks.push(Buffer.from(buffer.subarray(0, n)))
+      if (selection) { const start = Math.max(count, selection.offset), end = Math.min(count + n, selection.offset + selection.length); if (end > start) { buffer.copy(sample, start - selection.offset, start - count, end - count); copied += end - start } }
+      count += n
+    }
+    const end = fstatSync(fd), current = lstatSync(file), digest = h.digest('hex')
+    if (count !== st.size || end.size !== st.size || current.ino !== end.ino || current.dev !== end.dev || current.isSymbolicLink() || !current.isFile() || proof.digest && proof.digest !== digest || selection && copied !== selection.length) fail('file-short-changed-or-digest')
+    if (imported && (first.nlink !== 1 || end.nlink !== 1 || current.nlink !== 1 || end.dev !== st.dev || end.ino !== st.ino || current.size !== st.size || end.mtimeMs !== st.mtimeMs || current.mtimeMs !== st.mtimeMs || count !== proof.size)) fail('imported-identity-or-size-changed')
+    return { bytes: chunks ? Buffer.concat(chunks) : null, sample, digest, count }
+  } finally { closeSync(fd) }
+}
+// Only directories implied by immutable admitted paths may exist; Git ignore rules confer no exemption.
+function inventory(repo, prefix, paths, imported = [], identity = null, deadline = () => {}) {
+  const files = new Set(paths), directories = new Map([[prefix.slice(0, -1), new Set()]])
+  if (files.size !== paths.length) fail('proof-overlap')
+  for (const r of imported) { files.add(r.path); const root = r.path.split('/').slice(0, 2).join('/'); if (!directories.has(root)) directories.set(root, new Set()) }
+  for (const path of files) {
+    const root = path.startsWith(prefix) ? prefix.slice(0, -1) : path.split('/').slice(0, 2).join('/')
+    const parts = path.slice(root.length + 1).split('/'); let dir = root
+    for (let i = 0; i < parts.length; i++) { directories.get(dir).add(parts[i]); if (i < parts.length - 1) { dir += '/' + parts[i]; if (!directories.has(dir)) directories.set(dir, new Set()) } }
+  }
+  if ([...directories.keys()].some(p => files.has(p))) fail('proof-file-directory-overlap')
+  if (identity && (files.size > 256 || directories.size > 256)) fail('immutable-inventory-limit')
+  const result = []
+  for (const [dir, expected] of directories) {
+    deadline(); const file = safe(repo, dir), before = lstatSync(file); if (!before.isDirectory()) fail('inventory-directory-type')
+    const entries = [], fd = opendirSync(file)
+    try { let entry; while ((entry = fd.readSync())) { if (entries.length >= 256 || !expected.has(entry.name)) fail('inventory-unlisted-or-limit'); entries.push(entry.name) } } finally { fd.closeSync() }
+    if (entries.length !== expected.size) fail('inventory-missing')
+    for (const path of [dir, ...entries.sort().map(name => dir + '/' + name)]) { const st = lstatSync(safe(repo, path)); deadline(); identity?.(path, st, !files.has(path)); if (path === dir && (st.ino !== before.ino || st.dev !== before.dev) || (files.has(path) ? !st.isFile() : !st.isDirectory())) fail('inventory-entry-type-or-identity'); result.push([path, st.dev, st.ino, st.size, st.mtimeMs]) }
+  }
+  return result
+}
+// Strict bounded parsers are exported for non-spawning adversarial framing controls.
+export function parseImportedTree(bytes) {
+  if (bytes.length > 4194304 || bytes.length && bytes.at(-1) !== 0) fail('imported-tree-framing')
+  let text; try { text = new TextDecoder('utf8', { fatal: true }).decode(bytes) } catch { fail('imported-tree-encoding') }
+  const entries = text.split('\0').slice(0, -1), seen = new Set()
+  return entries.map(line => {
+    const m = /^(100644|100755) blob ([a-f0-9]{40}|[a-f0-9]{64}) +([0-9]+)\t([^\x00-\x1f]+)$/.exec(line)
+    if (!m || seen.has(m[4]) || !Number.isSafeInteger(Number(m[3])) || Number(m[3]) > 2097152) fail('imported-tree-entry')
+    seen.add(m[4]); return { path: m[4], mode: m[1], oid: m[2], size: Number(m[3]) }
+  })
+}
+export function parseImportedBatch(bytes, expected) {
+  if (bytes.length > 4194304) fail('imported-batch-limit')
+  const result = new Map(); let offset = 0
+  for (const row of expected) {
+    const newline = bytes.indexOf(10, offset)
+    if (newline < offset || newline - offset > 100 || result.has(row.oid) || !Number.isSafeInteger(row.size) || row.size < 0 || row.size > 2097152) fail('imported-batch-header')
+    const header = bytes.subarray(offset, newline).toString('ascii')
+    if (header !== row.oid + ' blob ' + row.size) fail('imported-batch-identity')
+    const end = newline + 1 + row.size
+    if (end >= bytes.length || bytes[end] !== 10) fail('imported-batch-short-or-delimiter')
+    result.set(row.oid, sha(bytes.subarray(newline + 1, end))); offset = end + 1
+  }
+  if (offset !== bytes.length) fail('imported-batch-trailing')
+  return result
+}
+export function importedIdentityRegistry() {
+  const files = new Map(), dirs = new Map()
+  return (path, st, directory = false) => { const registry = directory ? dirs : files, id = st.dev + ':' + st.ino, prior = registry.get(id); if (prior !== undefined && prior !== path) fail('imported-identity-alias'); registry.set(id, path) }
+}
+function observeImported(repo, rows, current, identity) {
+  const start = performance.now(), deadline = () => { if (performance.now() - start > 2000) fail('observation-deadline-exceeded') }
+  const sources = []; let total = 0
+  for (const row of current) {
+    deadline(); let st
+    try { st = lstatSync(safe(repo, row.path)) } catch (e) { if (row.digest === null && e.code === 'ENOENT') continue; throw e }
+    if (row.digest === null || !st.isFile() || st.size > 2097152) fail('current-source-type-size-or-absence')
+    identity(row.path, st); total += st.size; if (total > 16777216) fail('source-support-aggregate-limit')
+    sources.push([row.path, st.dev, st.ino, st.size, st.mtimeMs, st.nlink])
+  }
+  for (const row of rows) {
+    deadline(); const st = lstatSync(safe(repo, row.path)); total += st.size
+    if (total > 16777216) fail('source-support-aggregate-limit')
+    read(repo, row, 2097152, null, identity, true, deadline)
+    sources.push([row.path, st.dev, st.ino, st.size, st.mtimeMs, st.nlink])
+  }
+  return sources
+}
+export function measureNativePostCiEvidence({ repo, featurePath, evidencePath, previous, current, validate }) {
+  const prefix = featurePath + '/qa/post-ci-correction/'
+  if (!evidencePath?.startsWith(prefix) || typeof validate !== 'function') fail('descriptor-path-or-capability-invalid')
+  const descriptor = read(repo, { path: evidencePath }, 128 * 1024)
+  let evidence
+  try { evidence = JSON.parse(new TextDecoder('utf8', { fatal: true }).decode(descriptor.bytes)) } catch { fail('descriptor-malformed') }
+  if (!descriptor.bytes.equals(Buffer.from(JSON.stringify(evidence) + '\n'))) fail('descriptor-noncanonical')
+  validate(evidence, { featurePath, previous, current })
+  const q = evidence.qualification, s = evidence.scope, u = s.upstream, f = evidence.failure
+  const proofPaths = [evidencePath, ...new Set([f.log, q.color.log, q.neutral.log, q.ci.log].map(p => p.path)), s.fixture.patch.path, u.acceptanceEvidence.path, ...evidence.excludedEvidence.map(p => p.path)]
+  const importedRows = evidence.schema === 'native-qe-post-ci-evidence-2' ? s.importedArtifacts : [], identity = importedRows.length ? importedIdentityRegistry() : null
+  const supportObservation = identity ? observeImported(repo, importedRows, current, identity) : null
+  const membership = inventory(repo, prefix, proofPaths, importedRows, identity)
+  const witnesses = new Map(); let aggregate = 0
+  for (const p of new Map([f.log, q.color.log, q.neutral.log, q.ci.log].map(p => [p.path, p])).values()) {
+    const mode = [q.color, q.neutral].find(m => m.log.path === p.path)
+    const measured = read(repo, p, 16 * 1024 * 1024, mode?.witness)
+    aggregate += measured.count; if (aggregate > 64 * 1024 * 1024) fail('log-aggregate-limit')
+    if (mode) witnesses.set(p.path, measured.sample)
+  }
+  for (const p of [s.fixture.patch, u.acceptanceEvidence, ...evidence.excludedEvidence]) read(repo, p, p === s.fixture.patch ? 64 * 1024 : 128 * 1024)
+  validate(evidence, { featurePath, previous, current, witnesses })
+  // Diff's explicit stat-cache refresh can write even with optional locks disabled.
+  const git = (args, input) => execFileSync('git', ['-c', 'diff.autoRefreshIndex=false', ...args], { cwd: repo, input, timeout: 2000, maxBuffer: 4 * 1024 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_NO_REPLACE_OBJECTS: '1' } })
+  const commit = (id, kind = 'commit') => { const got = git(['rev-parse', '--verify', id + '^{' + kind + '}']).toString().trim(); if (got !== id) fail('git-object-not-exact'); return got }
+  for (const id of [f.headCommit, q.sourceCommit, u.baseCommit, u.acceptedCommit, u.integrationCommit]) commit(id)
+  commit(u.integrationTree, 'tree')
+  const ancestry = git(['merge-base', u.baseCommit, u.acceptedCommit]).toString().trim()
+  if (ancestry !== u.baseCommit) fail('upstream-base-not-ancestor')
+  const info = git(['show', '-s', '--format=%P%n%T', u.integrationCommit]).toString().trim().split('\n'), parents = info[0].split(' ')
+  if (parents.length !== 2 || parents[1] !== u.acceptedCommit || info[1] !== u.integrationTree) fail('integration-parents-or-tree-invalid')
+  const preimport = parents[0]
+  // Missing blobs are established from bounded tree membership, never an ignored git error.
+  const totals = new Map()
+  const cache = new Map()
+  const blob = (tree, path) => {
+    const key = tree + ':' + path
+    if (cache.has(key)) return cache.get(key)
+    const entry = git(['ls-tree', '-z', tree, '--', path]).toString('utf8').split('\0').filter(Boolean)
+    if (!entry.length) { const absent = { kind: 'absent' }; cache.set(key, absent); return absent }
+    const match = /^100(?:644|755) blob ([a-f0-9]+)\t(.+)$/.exec(entry[0])
+    if (entry.length !== 1 || !match || match[2] !== path) fail('git-blob-type-invalid')
+    const bytes = git(['cat-file', 'blob', match[1]])
+    if (bytes.length > 2 * 1024 * 1024) fail('git-source-size-limit')
+    totals.set(tree, (totals.get(tree) || 0) + bytes.length); if (totals.get(tree) > 16 * 1024 * 1024) fail('git-source-aggregate-limit')
+    const state = { kind: 'bytes', digest: sha(bytes) }; cache.set(key, state); return state
+  }
+  const expected = r => r.digest === null ? { kind: 'absent' } : { kind: 'bytes', digest: r.digest }
+  for (const r of previous) {
+    if (!same(blob(f.headCommit, r.path), expected(r)) || !same(blob(preimport, r.path), expected(r))) fail('closed-source-mapping-invalid')
+  }
+  for (const r of current) {
+    if (!same(blob(q.sourceCommit, r.path), expected(r))) fail('qualified-source-mapping-invalid')
+    if (r.path !== s.fixture.path && !s.reviewArtifacts.some(a => a.path === r.path) && !same(blob(u.integrationTree, r.path), expected(r))) fail('integration-candidate-mapping-invalid')
+  }
+  for (const r of u.rows) {
+    // Manifest absence does not prove Git absence. An unenrolled file may already
+    // exist at the failed head; it must remain byte-identical until the import.
+    const prior = r.before.kind === 'absent' ? blob(f.headCommit, r.path) : r.before.kind === 'bytes' ? r.before : { kind: 'absent' }
+    if (r.before.kind === 'absent' && prior.kind === 'bytes' && (same(r.upstream, prior) || same(r.integrated, prior))) fail('import-not-changed')
+    if (!same(blob(preimport, r.path), prior) || !same(blob(u.acceptedCommit, r.path), r.upstream) || !same(blob(u.integrationTree, r.path), r.integrated)) fail('import-blob-mapping-invalid')
+  }
+  for (const r of s.workflowDependencies) {
+    if (![preimport, u.acceptedCommit, u.integrationTree, q.sourceCommit].every(t => same(blob(t, r.path), r.after))) fail('workflow-git-enrollment-invalid')
+    const actual = read(repo, { path: r.path, digest: r.after.digest }, 2 * 1024 * 1024)
+    if (actual.digest !== r.after.digest) fail('workflow-current-invalid')
+  }
+  if (importedRows.length) {
+    const roots = [...new Set(importedRows.map(r => r.path.split('/').slice(0, 2).join('/')))]
+    for (const tree of new Set([f.headCommit, u.baseCommit, preimport])) if (git(['ls-tree', '-z', tree, '--', ...roots]).length) fail('imported-root-preexists')
+    const trees = [u.acceptedCommit, u.integrationTree, q.sourceCommit], inventories = []
+    for (const tree of trees) {
+      const entries = parseImportedTree(git(['ls-tree', '-r', '-l', '-z', tree, '--', ...roots])).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)
+      if (entries.length !== importedRows.length || entries.some((r, i) => r.path !== importedRows[i].path || r.size !== importedRows[i].size)) fail('imported-tree-membership-or-size')
+      for (const r of entries) { const key = tree + ':' + r.path; if (!cache.has(key)) { totals.set(tree, (totals.get(tree) || 0) + r.size); cache.set(key, { kind: 'bytes', digest: importedRows.find(p => p.path === r.path).digest }) } }
+      if ((totals.get(tree) || 0) > 16777216) fail('git-source-aggregate-limit')
+      inventories.push(entries)
+    }
+    if (!inventories.every(rows => same(rows, inventories[0]))) fail('imported-tree-bytes-changed')
+    const objects = [...new Map(inventories[0].map(r => [r.oid, r])).values()], hashes = new Map()
+    let batch = [], size = 0
+    const flush = () => { if (!batch.length) return; const parsed = parseImportedBatch(git(['cat-file', '--batch'], Buffer.from(batch.map(r => r.oid).join('\n') + '\n')), batch); for (const [oid, hash] of parsed) hashes.set(oid, hash); batch = []; size = 0 }
+    for (const row of objects) { const bytes = row.size + 102; if (size + bytes > 4194304) flush(); batch.push(row); size += bytes } flush()
+    if (inventories[0].some((r, i) => hashes.get(r.oid) !== importedRows[i].digest)) fail('imported-blob-digest')
+  }
+  const patch = git(['diff', '--no-ext-diff', '--no-textconv', '--binary', f.headCommit, q.sourceCommit, '--', s.fixture.path])
+  if (patch.length > 64 * 1024 || sha(patch) !== s.fixture.patch.digest) fail('fixture-patch-mismatch')
+  const exceptions = new Set(['base-ref', 'checkpoints.jsonl', 'native-qe-history.jsonl', 'native-qe-head.json', 'review-convergence-qe-host.json', 'review-convergence-qe-review.json', 'review-convergence-ideation-host.json', 'review-convergence-ideation-review.json'].map(p => featurePath + '/.fa-state/' + p).concat([featurePath + '/08_qe_report.md', featurePath + '/07_code_changes/report.md', featurePath + '/07_code_changes/change_manifest.md']))
+  const allowedExcluded = path => proofPaths.includes(path) || importedRows.some(r => r.path === path) || exceptions.has(path)
+  // Compare all source tree deltas too: a qualified manifest cannot hide unrelated edits.
+  const payload = new Set(current.map(r => r.path))
+  const qualifiedChanges = git(['diff', '--no-renames', '--name-only', '-z', preimport, q.sourceCommit, '--']).toString('utf8').split('\0').filter(Boolean)
+  if (qualifiedChanges.some(p => !payload.has(p) && !allowedExcluded(p))) fail('unqualified-commit-path')
+  for (const args of [['diff', '--no-renames', '--name-only', '-z', q.sourceCommit, '--'], ['ls-files', '--others', '--exclude-standard', '-z']]) {
+    const changed = git(args).toString('utf8').split('\0').filter(Boolean)
+    if (changed.some(p => !payload.has(p) && !allowedExcluded(p))) fail('unqualified-current-path')
+  }
+  const imported = git(['diff', '--no-renames', '--name-only', '-z', preimport, u.integrationCommit, '--']).toString('utf8').split('\0').filter(Boolean)
+  if (imported.some(p => !u.rows.some(r => r.path === p) && !s.reviewArtifacts.some(r => r.path === p) && !allowedExcluded(p))) fail('unaccounted-integration-path')
+  // Fixed Git facts are computed outside the journal lock; the ordinary index/HEAD/source fence rechecks current bytes.
+  if (identity && !same(supportObservation, observeImported(repo, importedRows, current, identity))) fail('imported-observation-changed')
+  if (!same(membership, inventory(repo, prefix, proofPaths, importedRows, identity))) fail('inventory-observation-changed')
+  return { evidencePath, evidence }
+}