@dzhechkov/keysarium 1.7.11 → 1.7.13

package/.dz-manifest.json

@@ -9,7 +9,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "a81456ef7ae79788d7859aab9a2238c541bb61a41b9d289a27ae6992119538db"
+        "sha256": "399f8032d0723d371c63c4d94d351614f4a2e11865a6475ab3f1db5c02e45058"
       },
       {
         "path": "README.ru.md",
@@ -21,7 +21,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "844c32f67fc8ed8099a388aa53f597a100371c6a693d4b99730a5808593a4843"
+        "sha256": "3ab5dc27c4025613b6d9d9c5932eff6ef31927190723f63a8fd32b68e462050b"
       },
       {
         "path": "src/cli.js",
@@ -373,7 +373,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/03.5-ideation-swarm.md",
-        "sha256": "b6e505083c1b8bc92243379b72ff4667b5b91ef65fd9c2ef7407129018b3e56b"
+        "sha256": "798c04595c5b0f8c5688334413c744b6d1dda6f9ad9d4fab263c96dcc2c4187e"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/04-ddd.md",
@@ -393,7 +393,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/08-qe.md",
-        "sha256": "4aa7ef1dea08b8d1995d968a317da5d36a4859ec299637bdc60170cf577c87af"
+        "sha256": "e2fb5fb869005b05d13fcc52da7ded281bb6758250a1cdf695dace286029d791"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/09-fleet-qe.md",
@@ -497,7 +497,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/scripts/check-review-convergence.mjs",
-        "sha256": "09c74f1441d9c42603fbb84402e6826cf96535d209be9802e0e4b2fea01dac7d"
+        "sha256": "6fdacc0ee6c1d2b00029da8d300a574c051895ee98a9c88c9509a39b9bdccc71"
       },
       {
         "path": "templates/.claude/skills/feature-adr/scripts/markdown-masker.mjs",
@@ -1005,5 +1005,5 @@
       }
     ]
   },
-  "signature": "p0J0fnCC54JAc14pg5UuIgUGtG8u7YLxPlBS6YEXl4qUf5yCqWGZ4g6Bs2Tz8XSfIg1uHkBkAAczkeGaKeBeBw=="
+  "signature": "IuyuSO5ojzp0YmewWW4Kmtn854zfx7p7vZmpVXBpzSnV7G24mTKKMJk2QAv0GjtLp9kfiiWwy0WkecuW7nPdCQ=="
 }

package/README.md

@@ -1,6 +1,11 @@
 # @dzhechkov/keysarium
 
-Current package version: `1.7.11`. <!-- dz:version -->
+The bundled Feature ADR projection supports installed-CLI native QE history opt-in with a fixed three-cycle ceiling and explicit repair. Its canonical helper/guidance remain synchronized; compatible core/CLI capabilities are required, and historical bridge behavior remains available.
+
+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 -->
 
 Site: https://aicoding.space · Source: https://github.com/djd1m/dz-harness/tree/main/packages/@dzhechkov/keysarium
 
@@ -34,6 +39,13 @@ Required missing or incomplete context refuses coding. This helper is separate f
 > whether a lesson describes a method or a person, and says so: that judgement is the agent's, per
 > the teach protocol. See `skills/goap-research-ed25519/SKILL.md`.
 
+Feature-adr structural `implementationVerified:true` has phase-specific meaning: ideation verifies
+corrected ADR, architecture and phase artifacts at the current revision/nonce, without claiming
+production code or implementation tests exist; QE requires actual implementation and relevant tests.
+False or missing structural verification still blocks. Receipt fields, boolean strength, originating
+reviewer ownership, phase/nonce/manifest binding and legacy receipt compatibility remain unchanged.
+The gate checks receipt consistency and freshness; independent reviewers judge the evidence.
+
 ## Growth engine (reverse-engineering-unicorn M5)
 ### What M5 produces, since 0.2.0 / 1.7.5 / 1.6.0
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/keysarium",
-  "version": "1.7.11",
+  "version": "1.7.13",
   "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": "a81456ef7ae79788d7859aab9a2238c541bb61a41b9d289a27ae6992119538db"
+          "content": "399f8032d0723d371c63c4d94d351614f4a2e11865a6475ab3f1db5c02e45058"
         }
       ]
     },
@@ -59,7 +59,7 @@
         },
         {
           "name": "dz:canonical-json-sha256-v2",
-          "value": "844c32f67fc8ed8099a388aa53f597a100371c6a693d4b99730a5808593a4843"
+          "value": "3ab5dc27c4025613b6d9d9c5932eff6ef31927190723f63a8fd32b68e462050b"
         }
       ]
     },
@@ -939,7 +939,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "b6e505083c1b8bc92243379b72ff4667b5b91ef65fd9c2ef7407129018b3e56b"
+          "content": "798c04595c5b0f8c5688334413c744b6d1dda6f9ad9d4fab263c96dcc2c4187e"
         }
       ]
     },
@@ -989,7 +989,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "4aa7ef1dea08b8d1995d968a317da5d36a4859ec299637bdc60170cf577c87af"
+          "content": "e2fb5fb869005b05d13fcc52da7ded281bb6758250a1cdf695dace286029d791"
         }
       ]
     },
@@ -1249,7 +1249,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "09c74f1441d9c42603fbb84402e6826cf96535d209be9802e0e4b2fea01dac7d"
+          "content": "6fdacc0ee6c1d2b00029da8d300a574c051895ee98a9c88c9509a39b9bdccc71"
         }
       ]
     },

package/templates/.claude/skills/feature-adr/modules/03.5-ideation-swarm.md

@@ -91,6 +91,15 @@ on every pass. Reviewer verifications have closed fields
 `{id, revision, classification, evidence, implementationVerified}`. Only the originating independent
 role can verify its own condition at the current revision; author/lead/scribe assertions cannot.
 
+`implementationVerified` is phase-specific for both condition verifications and
+`deltaVerification`. In phase `ideation`, structural `implementationVerified:true` means the
+originating independent reviewer verified the corrected ADR, architecture and phase artifacts at
+the current revision/nonce; it does not claim production code or implementation tests exist. In
+phase `qe`, structural `implementationVerified:true` requires independent verification of the
+actual implementation and relevant tests at the current revision/nonce. False or missing structural
+verification remains blocking in both phases. Field names, boolean strength, originating ownership,
+phase/nonce/manifest binding and legacy receipt compatibility are unchanged.
+
 Rework requires the actual author object
 `{addressed, changedScope, classification, delta, evidence, newRisks}`. Addressed IDs name prior
 conditions; changedScope includes ALL host-measured changes and affected dependencies. Delta/evidence
@@ -98,9 +107,9 @@ explain the actual fix. Both author and reviewer `newRisks` require explicit ass
 conditions array, including an explicit none-identified assessment when empty. The reviewer must set
 `authorAssessmentChecked:true` and supply independent
 `deltaVerification:{classification,evidence,implementationVerified}`. Structural changes affect
-behavior, contracts, safeguards, architecture or acceptance meaning and require affected implementation
-and test verification. Wording changes affect expression only; the independent reviewer checks that
-classification, so an author's wording label cannot weaken structural verification.
+behavior, contracts, safeguards, architecture or acceptance meaning and require phase-specific
+structural verification as defined above. Wording changes affect expression only; the independent
+reviewer checks that classification, so an author's wording label cannot weaken structural verification.
 
 Focused scope is outstanding conditions plus actual changes and affected dependencies. New serious
 risks always expand that scope. Retain ALL conditions and serious primary/precision findings until

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

@@ -1,5 +1,24 @@
 # Step 8: Quality Engineering
 
+### Native history through the installed CLI
+
+For an explicitly native review, use the actual installed producer before dispatching any formal QE role:
+
+```bash
+dz qe-rounds --source native --action prepare --project "$REPO" --feature-dir "$FEATURE" --reviewers '[{"id":"qe-primary","family":"codex"}]' --json
+```
+
+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.
+
+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.
+
+Omit `--action` for read-only native reporting; omitted `--source` retains the historical bridge reader. Locally bound native/bridge collisions refuse either selection with both locations rather than unioning or resetting. A reviewed legacy QE host cannot retrospectively initialize a zero history. Initial admission allows only the documented surviving-evidence matrix; parseable ideation state alone is permitted.
+
+The helper runs at most four Git calls before locking (2s and 4 MiB per call), then rechecks bounded authoritative bytes, index, directory candidates and known artifacts in one short directory-lock transaction. Limits are 256 artifact paths, 2 MiB per artifact, 16 MiB aggregate artifacts, 256 KiB host/receipt/head, 2 MiB checkpoints, a separate 4 MiB index metadata fence, 8 MiB journal, 1024 events and 256 directory candidates. The 2s monotonic budget is checked before authoritative writes; lock stale/timeout are explicitly 30s/5s. Returned late I/O refuses, but synchronous I/O cannot be interrupted. This fenced observation does not serialize arbitrary external editors or prove reviewer authenticity or deletion of all writable evidence. Commit failures preserve paths and report possible partial writes; never delete authority or reconstruct zero to resume.
+
+
 > Verify the implementation through testing, review, and validation.
 
 ## When
@@ -84,6 +103,15 @@ on every pass. Reviewer verifications have closed fields
 `{id, revision, classification, evidence, implementationVerified}`. Only the originating independent
 role can verify its own condition at the current revision; author/lead/scribe assertions cannot.
 
+`implementationVerified` is phase-specific for both condition verifications and
+`deltaVerification`. In phase `ideation`, structural `implementationVerified:true` means the
+originating independent reviewer verified the corrected ADR, architecture and phase artifacts at
+the current revision/nonce; it does not claim production code or implementation tests exist. In
+phase `qe`, structural `implementationVerified:true` requires independent verification of the
+actual implementation and relevant tests at the current revision/nonce. False or missing structural
+verification remains blocking in both phases. Field names, boolean strength, originating ownership,
+phase/nonce/manifest binding and legacy receipt compatibility are unchanged.
+
 Rework requires the actual author object
 `{addressed, changedScope, classification, delta, evidence, newRisks}`. Addressed IDs name prior
 conditions; changedScope includes ALL host-measured changes and affected dependencies. Delta/evidence
@@ -91,9 +119,9 @@ explain the actual fix. Both author and reviewer `newRisks` require explicit ass
 conditions array, including an explicit none-identified assessment when empty. The reviewer must set
 `authorAssessmentChecked:true` and supply independent
 `deltaVerification:{classification,evidence,implementationVerified}`. Structural changes affect
-behavior, contracts, safeguards, architecture or acceptance meaning and require affected implementation
-and test verification. Wording changes affect expression only; the independent reviewer checks that
-classification, so an author's wording label cannot weaken structural verification.
+behavior, contracts, safeguards, architecture or acceptance meaning and require phase-specific
+structural verification as defined above. Wording changes affect expression only; the independent
+reviewer checks that classification, so an author's wording label cannot weaken structural verification.
 
 Focused scope is outstanding conditions plus actual changes and affected dependencies. New serious
 risks always expand that scope. Retain ALL conditions and serious primary/precision findings until

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

@@ -1,8 +1,14 @@
 #!/usr/bin/env node
 // Host checkpoint lineage, not a reviewer-supplied prior array, owns historical conditions.
 // This checks consistency/freshness; it does not authenticate models or judge their evidence.
+// For structural condition/delta verification, implementationVerified:true is phase-specific:
+// ideation = independently verified corrected ADR, architecture and phase artifacts at the
+// current revision/nonce, without claiming production code or implementation tests exist;
+// qe = independently verified actual implementation and relevant tests at that revision/nonce.
+// False/missing remains blocking in both phases; field names, boolean strength, origin ownership,
+// phase/nonce/manifest binding and legacy receipt compatibility are unchanged.
 import { createHash, randomUUID } from 'node:crypto'
-import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, writeFileSync } from 'node:fs'
+import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, opendirSync, readSync, readFileSync, readdirSync, realpathSync, renameSync, writeFileSync } from 'node:fs'
 import { dirname, relative, resolve, sep } from 'node:path'
 import { execFileSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
@@ -47,7 +53,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) {
+export function evaluateReviewConvergence(host, receipt, currentManifest, originOnly = 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)
@@ -55,7 +61,7 @@ export function evaluateReviewConvergence(host, receipt, currentManifest) {
   const owners = host.reviewers.map(r => r.id)
   if (!same(host.snapshot.manifest, currentManifest) || digest(JSON.stringify(currentManifest)) !== host.snapshot.revision) return refuse('artifact-manifest-changed')
   if (!dictionary(receipt, ['schema', 'phase', 'nonce', 'revision', 'reviews', 'author']) || receipt.schema !== SCHEMA || receipt.phase !== phase || receipt.nonce !== host.snapshot.nonce || receipt.revision !== host.snapshot.revision) return refuse('receipt-phase-or-revision-invalid')
-  if (!array(receipt.reviews, 16) || receipt.reviews.length !== owners.length || new Set(receipt.reviews.map(r => r?.reviewer)).size !== owners.length) return refuse('reviewer-set-invalid')
+  if (!array(receipt.reviews, 16) || (originOnly ? !receipt.reviews.length || receipt.reviews.length > owners.length : receipt.reviews.length !== owners.length) || new Set(receipt.reviews.map(r => r?.reviewer)).size !== receipt.reviews.length) return refuse('reviewer-set-invalid')
   const all = new Map(host.conditions.map(c => [c.id, c]))
   const verified = new Set()
   const reasons = []
@@ -129,7 +135,7 @@ function writeJson(path, value) {
   writeFileSync(temporary, JSON.stringify(value, null, 2) + '\n', { flag: 'wx' })
   renameSync(temporary, path)
 }
-function pathsFor(repo, feature, phase) {
+function pathsFor(repo, feature, phase, native = false) {
   const prefix = relative(repo, feature).split(sep).join('/')
   if (!prefix || prefix.startsWith('../')) throw Error('feature-must-be-inside-repo')
   safePath(repo, prefix, false)
@@ -137,12 +143,13 @@ function pathsFor(repo, feature, phase) {
   if (phase === 'qe') targets.push('06_implementation_plan.md', '03.5_ideation_report.md')
   const adr = safePath(repo, prefix + '/03_adr')
   if (existsSync(adr) && !lstatSync(adr).isDirectory()) throw Error('adr-not-directory')
-  const decisions = existsSync(adr) ? readdirSync(adr).filter(p => /^[0-9]{3}-.+\.md$/.test(p)).sort() : []
+  const decisions = existsSync(adr) ? (native ? nativeNames(adr) : readdirSync(adr)).filter(p => /^[0-9]{3}-.+\.md$/.test(p)).sort() : []
   if (phase === 'ideation' && !decisions.length) throw Error('adr-missing')
   const paths = targets.filter(p => existsSync(resolve(feature, p))).concat(decisions.map(p => '03_adr/' + p)).map(p => prefix + '/' + p)
   for (const required of phase === 'ideation' ? ['01_requirements.md', '05_architecture.md'] : ['01_requirements.md', '06_implementation_plan.md']) if (!paths.includes(prefix + '/' + required)) throw Error('design-input-missing:' + required)
   if (phase === 'qe') {
-    const plan = readFileSync(safePath(repo, prefix + '/06_implementation_plan.md', false), 'utf8')
+    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 => {
@@ -152,19 +159,19 @@ function pathsFor(repo, feature, phase) {
     })
     if (!planned.length) throw Error('target-block-empty')
     const baseFile = resolve(feature, '.fa-state/base-ref')
-    const base = existsSync(baseFile) ? readFileSync(baseFile, 'utf8').trim() : 'HEAD'
+    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')
     const guard = '.dz/guard.json'
     // 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 }).split('\0').includes(guard))
+      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))
     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 }).split('\0').filter(Boolean)
+      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)
       paths.push(...names.filter(p => allowedGuard(p) || !p.startsWith('features/') && !p.startsWith('.dz/') && !p.startsWith('.agentic-qe/') && !p.startsWith('roam/') && p !== 'architecture/map.json'))
     }
   }
@@ -201,7 +208,7 @@ function qeCheckpoint(repo, feature) {
 function seriousFindings(source) {
   return (array(source?.gaps) ? source.gaps : []).filter(gap => [gap.sev, gap.severity, gap.priority].some(v => /(?:^|[^A-Z0-9])(BLOCKER|CRITICAL|HIGH|P0|P1)(?:$|[^A-Z0-9])/.test(String(v || '').toUpperCase())))
 }
-function reconcileCheckpoint(host, receipt, measured, repo, feature) {
+function reconcileCheckpoint(host, receipt, measured, repo, feature, knownReport) {
   if (!measured) return null
   const stage = measured.checkpoint
   for (const [base, source, family, missing] of [
@@ -222,7 +229,8 @@ function reconcileCheckpoint(host, receipt, measured, repo, feature) {
     }
     if (base === 'qe-precision' && missing) {
       const file = safePath(repo, relative(repo, feature).split(sep).join('/') + '/08_qe_report.md', false)
-      const report = readFileSync(file)
+      const report = knownReport === undefined ? readFileSync(file) : knownReport
+      if (report === null) return null
       if (digest(report) !== proof.reportDigest || !/## Primary QE pass/.test(report.toString()) || !/## Precision QE pass/.test(report.toString()) || !/Combined Step-8 grade:/.test(report.toString())) return null
     }
   }
@@ -322,6 +330,159 @@ export function runGate({ action, repo, feature, phase, reviewers }) {
   return verdict
 }
 
+// Only the CLI supplies this capability. The default standalone runGate remains synchronous.
+export const NATIVE_REVIEW_API_VERSION = 1
+function nativeNames(dir) {
+  if (!existsSync(dir)) return []
+  const st = lstatSync(dir)
+  if (!st.isDirectory() || st.isSymbolicLink()) throw Error('native-directory-unsafe:' + dir)
+  const names = [], fd = opendirSync(dir)
+  try { let entry; while ((entry = fd.readSync())) { names.push(entry.name); if (names.length > 256) throw Error('native-directory-candidate-limit:' + dir) } }
+  finally { fd.closeSync() }
+  return names.sort()
+}
+function nativeBytes(file, limit) {
+  let st
+  try { st = lstatSync(file) } catch (error) { if (error.code === 'ENOENT') return null; throw error }
+  if (!st.isFile() || st.isSymbolicLink()) throw Error('native-file-unsafe:' + file)
+  if (st.size > limit) throw Error('native-file-limit:' + file)
+  const fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW)
+  try {
+    const opened = fstatSync(fd)
+    if (!opened.isFile() || opened.ino !== st.ino || opened.dev !== st.dev) throw Error('native-file-changed:' + file)
+    const bytes = Buffer.alloc(limit + 1); let n = 0
+    while (n <= limit) { const got = readSync(fd, bytes, n, bytes.length - n, null); if (!got) break; n += got }
+    if (n > limit) throw Error('native-file-limit:' + file)
+    return bytes.subarray(0, n)
+  } finally { closeSync(fd) }
+}
+function nativeManifest(repo, paths) {
+  if (new Set(paths).size > 256) throw Error('native-artifact-path-limit')
+  let total = 0
+  return [...new Set(paths)].sort().map(path => {
+    const bytes = nativeBytes(safePath(repo, path), 2 * 1024 * 1024)
+    total += bytes?.length || 0
+    if (total > 16 * 1024 * 1024) throw Error('native-artifact-aggregate-limit')
+    return { path, digest: bytes === null ? null : digest(bytes) }
+  })
+}
+function nativeReceipt(host, receipt, manifest) {
+  // 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 (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 }) {
+  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')
+  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')
+  safePath(repo, prefix, false)
+  const stateDir = safePath(repo, prefix + '/.fa-state')
+  const hostFile = safePath(repo, prefix + '/.fa-state/review-convergence-qe-host.json')
+  const receiptFile = safePath(repo, prefix + '/.fa-state/review-convergence-qe-review.json')
+  const checkpointFile = safePath(repo, prefix + '/.fa-state/checkpoints.jsonl')
+  const baseFile = safePath(repo, prefix + '/.fa-state/base-ref')
+  // Index bytes fence staging changes; no Git is run by the locked callback.
+  let gitDir = resolve(repo, '.git')
+  const gitStat = lstatSync(gitDir)
+  if (gitStat.isFile()) {
+    const match = /^gitdir: ([^\r\n]+)\r?\n?$/.exec(nativeBytes(gitDir, 256 * 1024).toString('utf8'))
+    if (!match) throw Error('native-gitdir-invalid')
+    gitDir = realpathSync(resolve(repo, match[1]))
+  } else if (!gitStat.isDirectory() || gitStat.isSymbolicLink()) throw Error('native-gitdir-invalid')
+  const indexFile = resolve(gitDir, 'index')
+  const measuredFiles = [hostFile, receiptFile, checkpointFile, baseFile, indexFile,
+    safePath(repo, prefix + '/.fa-state/review-convergence-ideation-host.json'),
+    safePath(repo, prefix + '/.fa-state/review-convergence-ideation-review.json'),
+    safePath(repo, prefix + '/08_qe_report.md'),
+    ...(gitStat.isFile() ? [resolve(repo, '.git')] : []), resolve(gitDir, 'HEAD')]
+  const limits = measuredFiles.map(f => f === indexFile ? 4 * 1024 * 1024 : f === checkpointFile ? 2 * 1024 * 1024 : 256 * 1024)
+  const observed = measuredFiles.map((f, i) => nativeBytes(f, limits[i]))
+  const json = (index) => observed[index] === null ? null : JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(observed[index]))
+  const host = json(0)
+  let receipt = null, receiptProblem = null
+  try { receipt = json(1) } catch { receiptProblem = 'reviewer-receipt-malformed' }
+  if (observed[0] !== null && (hostProblem(host) || host.phase !== 'qe')) throw Error(hostProblem(host) || 'native-host-phase-invalid')
+  if (observed[3] !== null && !/^[A-Za-z0-9_./:-]+$/.test(observed[3].toString('utf8').trim())) throw Error('native-base-ref-invalid')
+  const ideationHost = json(5), ideationReceipt = json(6)
+  if (observed[5] !== null && (hostProblem(ideationHost) || ideationHost.phase !== 'ideation')) throw Error('native-ideation-state-invalid')
+  if (observed[6] !== null) {
+    if (!ideationHost || !dictionary(ideationReceipt, ['schema', 'phase', 'nonce', 'revision', 'reviews', 'author']) || ideationReceipt.schema !== SCHEMA || ideationReceipt.phase !== 'ideation' || !text(ideationReceipt.nonce) || !hash(ideationReceipt.revision) || !array(ideationReceipt.reviews, 16) || !ideationReceipt.reviews.length || new Set(ideationReceipt.reviews.map(r => r?.reviewer)).size !== ideationReceipt.reviews.length || !ideationReceipt.reviews.every(r => reviewerEntry(r, ideationHost.reviewers) && (!Object.hasOwn(r, 'checkpointVerification') || checkpointProof(r.checkpointVerification)))) throw Error('native-ideation-receipt-invalid')
+    const owners = ideationHost.reviewers.map(r => r.id), author = ideationReceipt.author
+    if (author !== null && (!dictionary(author, ['addressed', 'changedScope', 'classification', 'delta', 'evidence', 'newRisks']) || !strings(author.addressed) || !strings(author.changedScope, true) || !kinds.includes(author.classification) || !text(author.delta) || !text(author.evidence) || !risks(author.newRisks, owners))) throw Error('native-ideation-author-invalid')
+    for (const r of ideationReceipt.reviews) {
+      if (author ? !dictionary(r.deltaVerification, ['classification', 'evidence', 'implementationVerified']) || !kinds.includes(r.deltaVerification.classification) || !text(r.deltaVerification.evidence) || typeof r.deltaVerification.implementationVerified !== 'boolean' : r.deltaVerification !== null) throw Error('native-ideation-delta-invalid')
+      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')
+    }
+  }
+  let checkpoint = null
+  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)
+      if (!entry || typeof entry !== 'object' || typeof entry.stage !== 'string' || !entry.stage || typeof entry.inputHash !== 'string' || !entry.inputHash || !Object.hasOwn(entry, 'result') || entry.result === null) throw Error('native-checkpoint-candidate-invalid')
+      if (entry.stage === 'qe') checkpoint = { checkpointDigest: digest(JSON.stringify(entry.result)), checkpoint: entry.result }
+    }
+  }
+  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 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 => {
+    if (realpathSync(repo) !== repo || realpathSync(feature) !== feature) throw Error('native-project-feature-observation-changed')
+    const currentGit = lstatSync(resolve(repo, '.git'))
+    if (currentGit.ino !== gitStat.ino || currentGit.dev !== gitStat.dev) throw Error('native-gitdir-observation-changed')
+    // Only descriptor/known-path work here; no discovery through runGate, Git, model or network.
+    measuredFiles.forEach((file, i) => { const bytes = nativeBytes(file, limits[i]); if ((bytes === null) !== (observed[i] === null) || bytes !== null && !bytes.equals(observed[i])) throw Error('native-observation-changed:' + file) })
+    const currentMembership = directoryFence()
+    if (currentMembership.bridge.some(n => /^(signoff-|failed-).*\.json$/.test(n))) throw Error('native-bridge-source-collision:' + stateDir + '/native-qe-history.jsonl:' + stateDir + '/qe-bridge')
+    if (!same(membership, currentMembership)) throw Error('native-candidate-membership-changed')
+    if (!same(manifest, nativeManifest(repo, paths))) throw Error('native-artifact-observation-changed')
+    if (membership.bridge.some(n => /^(signoff-|failed-).*\.json$/.test(n))) throw Error('native-bridge-source-collision:' + stateDir + '/native-qe-history.jsonl:' + stateDir + '/qe-bridge')
+    if (membership.fragments.length) throw Error('native-temporary-fragment')
+    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')
+    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
+      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)
+      // Closure is deliberately stronger than originating partial/unresolved evidence.
+      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) {
+        for (const r of receipt.reviews) for (const c of r.conditions.concat(r.newRisks.conditions)) preserved.set(c.id, c)
+        if (receipt.author) for (const c of receipt.author.newRisks.conditions) if (c.scope.every(path => host.snapshot.manifest.some(p => p.path === path))) preserved.set(c.id, c)
+      }
+      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 }
+      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 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 }
+  })
+}
+
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
   let phase = 'qe'
   try {