harness-everything 0.43.0 → 0.44.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "harness-everything",
       "source": "./",
       "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-      "version": "0.43.0",
+      "version": "0.44.0",
       "author": {
         "name": "Miya Daniel"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-everything",
   "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "author": {
     "name": "Miya Daniel"
   },

package/.github/workflows/ci.yml

@@ -9,12 +9,8 @@ on:
   workflow_call:
 
 jobs:
-  self-regression:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
+  doc-governance:
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v7
         with:
@@ -95,6 +91,19 @@ jobs:
             process.exitCode = 1;
           }
           })();'
+  self-regression:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 24
       - name: Install dependencies for regression suite
         run: npm ci
       - name: Run hermetic self-regression suite

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.44.0](https://github.com/dyphn1/Harness-everything/compare/v0.43.1...v0.44.0) (2026-10-27)
+
+### Features
+
+* **governance:** accept git-aware globs in the base-owned guard ([674a96d](https://github.com/dyphn1/Harness-everything/commit/674a96d7295555926ab3bb1b8ca0204cf59dbad5)), closes [#325](https://github.com/dyphn1/Harness-everything/issues/325)
+
+## [0.43.1](https://github.com/dyphn1/Harness-everything/compare/v0.43.0...v0.43.1) (2026-10-27)
+
+### Bug Fixes
+
+* **governance:** let the guard pass governed content revisions ([31af03d](https://github.com/dyphn1/Harness-everything/commit/31af03d02475e150210cc6b5ba0e5b90fea0163e))
+
+## [Unreleased]
+
+### Fixed
+
+- **doc-governance:** allow regular governed-content revisions and expand base-owned governed/derived globs against Git trees, while retaining review for membership, structural, policy, trust-surface, fixture, and derived-output changes; run the guard in its own CI job.
+
 ## [0.43.0](https://github.com/dyphn1/Harness-everything/compare/v0.42.2...v0.43.0) (2026-10-27)
 
 ### Features

package/ci/mechanism-2ax-doc-lifecycle.test.js

@@ -1667,8 +1667,8 @@ checkCase('2ax. frozen Git-object guard with bootstrap and tamper controls', ()
     return fixtureGit(root, ['rev-parse', 'HEAD']).toString('ascii').trim();
   }
 
-  function createFixture() {
-    const root = workspace('governance-guard-git');
+  function createFixture(name = 'governance-guard-git') {
+    const root = workspace(name);
     fs.mkdirSync(path.join(root, '.fixture-hooks'), { recursive: true });
     fixtureGit(root, ['init', '--quiet']);
     fixtureGit(root, ['config', 'user.name', 'Harness Guard Test']);
@@ -1779,22 +1779,256 @@ checkCase('2ax. frozen Git-object guard with bootstrap and tamper controls', ()
     if (mutation === 'mode') assert.notStrictEqual(item.base.mode, item.candidate.mode, 'oracle mode change is reported');
   }
 
-  for (const relativePath of ['docs/architecture.md', 'docs/governed-index.md']) {
+  const unchanged = runFrozenGuard(fixture, fixture.base, fixture.base);
+  assert.strictEqual(unchanged.status, 0, 'an unchanged tree passes');
+  assert.strictEqual(unchanged.report.verdict, 'PASS');
+
+  const rawIdentity = entry => ({ mode: entry.mode, type: entry.type, oid: entry.oid });
+  const configuredIdentity = (commit, relativePath) => {
+    const tree = parseTreeOracle(fixtureGit(fixture.root, ['ls-tree', '-r', '-z', '--full-tree', commit]));
+    return rawIdentity(tree.get(Buffer.from(relativePath).toString('base64')));
+  };
+  resetFixture(fixture);
+  writeRelative(fixture.root, 'docs/architecture.md', 'changed governed document content\n');
+  const revisedGovernedCandidate = commitFixture(fixture.root, 'revise governed document');
+  const revisedGoverned = runFrozenGuard(fixture, fixture.base, revisedGovernedCandidate);
+  const fixtureStatusBeforeRepeat = fixtureGit(fixture.root, ['status', '--porcelain']);
+  const revisedGovernedRepeat = runFrozenGuard(fixture, fixture.base, revisedGovernedCandidate);
+  const fixtureStatusAfterRepeat = fixtureGit(fixture.root, ['status', '--porcelain']);
+  assert.deepStrictEqual(revisedGovernedRepeat, revisedGoverned, 'identical Git inputs produce an identical report');
+  assert.deepStrictEqual(fixtureStatusAfterRepeat, fixtureStatusBeforeRepeat, 'guard execution does not mutate the fixture repository');
+  assert.strictEqual(revisedGoverned.status, 0, 'regular governed content revision passes');
+  assert.strictEqual(revisedGoverned.report.verdict, 'PASS');
+  const revisedEntry = revisedGoverned.report.policyPreservation.configuredPaths.paths.find(item => item.path === 'docs/architecture.md');
+  assert.strictEqual(revisedEntry.state, 'revised', 'governed content revision is informational');
+  assert.deepStrictEqual(revisedEntry.base, configuredIdentity(fixture.base, 'docs/architecture.md'));
+  assert.deepStrictEqual(revisedEntry.candidate, configuredIdentity(revisedGovernedCandidate, 'docs/architecture.md'));
+  assert.match(revisedEntry.reason, /not semantically validated by the guard/i);
+  assert.ok(revisedGoverned.report.limits.some(limit => /content revisions.*not semantically validated by the guard/i.test(limit)));
+  assert.strictEqual(revisedGoverned.report.policyPreservation.configuredPaths.state, 'pass');
+  assert.deepStrictEqual(revisedGoverned.report.policyPreservation.configuredPaths.missingOrChanged, []);
+
+  resetFixture(fixture);
+  writeRelative(fixture.root, 'docs/governed-index.md', 'changed derived output\n');
+  const derivedCandidate = commitFixture(fixture.root, 'change derived document');
+  const derivedChange = runFrozenGuard(fixture, fixture.base, derivedCandidate);
+  assert.strictEqual(derivedChange.status, 2, 'derived content change still requires review');
+  assert.strictEqual(derivedChange.report.verdict, 'REVIEW_REQUIRED');
+  const derivedEntry = derivedChange.report.policyPreservation.configuredPaths.missingOrChanged.find(item => item.path === 'docs/governed-index.md');
+  assert.ok(derivedEntry, 'derived content change remains in review-required paths');
+  assert.strictEqual(derivedEntry.state, 'review_required');
+  assert.deepStrictEqual(derivedEntry.base, configuredIdentity(fixture.base, 'docs/governed-index.md'));
+  assert.deepStrictEqual(derivedEntry.candidate, configuredIdentity(derivedCandidate, 'docs/governed-index.md'));
+
+  const globPatterns = [
+    'docs/adr/*.md',
+    'empty/*.md',
+    'corpus/one*.md', // portability-lint: allow glob pattern string, never created as a file
+    'corpus/*.md',
+    'deep/**/*.md',
+    'repeat/**/repeat/*.md',
+    'literal.v1/**/*.md'
+  ];
+  const corpusPaths = [
+    'docs/adr/one.md', 'docs/adr/two.md', 'generated/view.md', 'generated/nested/view.md',
+    'corpus/one.md', 'corpus/many-a.md', 'corpus/many-b.md',
+    'deep/zero.md', 'deep/a/b.md',
+    'repeat/repeat/first.md', 'repeat/a/repeat/second.md',
+    'literal.v1/top.md', 'literal.v1/sub/nested.md', 'literalXv1/no.md'
+  ];
+  const globFixture = createFixture('governance-guard-glob-git');
+  resetFixture(globFixture);
+  const globPolicy = {
+    governed: globPatterns.map(pattern => ({ path: pattern, role: 'reference' })),
+    derived: [{ path: 'generated/**/*.md', generator: 'build' }]
+  };
+  writeRelative(globFixture.root, '.agents/harness-everything/project-docs.json', `${JSON.stringify(globPolicy, null, 2)}\n`);
+  for (const relativePath of corpusPaths) writeRelative(globFixture.root, relativePath, `baseline ${relativePath}\n`);
+  globFixture.base = commitFixture(globFixture.root, 'glob policy baseline');
+
+  const globAccepted = runFrozenGuard(globFixture, globFixture.base, globFixture.base);
+  assert.strictEqual(globAccepted.report.verdict, 'PASS', globAccepted.report.errors[0]?.message);
+  const globSummaries = globAccepted.report.policyPreservation.configuredPaths.patterns;
+  assert.ok(globSummaries, 'glob records report their base and candidate member counts');
+  assert.strictEqual(globAccepted.report.policyPreservation.configuredPaths.paths.find(item => item.path === 'docs/adr/one.md').state, 'pass', 'unchanged glob members pass');
+  assert.deepStrictEqual(runFrozenGuard(globFixture, globFixture.base, globFixture.base), globAccepted, 'glob reports are deterministic for identical Git inputs');
+  const lifecycleSource = fs.readFileSync(modulePath, 'utf8');
+  const lifecycleMatcherSource = lifecycleSource.match(/function globToRegExp\(glob\) \{[\s\S]*?\n\}/);
+  assert.ok(lifecycleMatcherSource, 'doc-lifecycle globToRegExp remains available for the consistency check');
+  const lifecycleGlobToRegExp = new Function(`${lifecycleMatcherSource[0]}\nreturn globToRegExp;`)();
+  for (const pattern of globPatterns) {
+    const expected = corpusPaths.filter(relativePath => lifecycleGlobToRegExp(pattern).test(relativePath)).length;
+    const summary = globSummaries.find(item => item.kind === 'governed' && item.path === pattern);
+    assert.ok(summary, `glob summary exists for ${pattern}`);
+    assert.strictEqual(summary.baseMembers, expected, `guard matcher agrees with doc-lifecycle for ${pattern}`);
+    assert.strictEqual(summary.candidateMembers, expected, `candidate matcher agrees with doc-lifecycle for ${pattern}`);
+    const expectedPaths = corpusPaths.filter(relativePath => lifecycleGlobToRegExp(pattern).test(relativePath)).sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
+    const actualPaths = globAccepted.report.policyPreservation.configuredPaths.paths
+      .filter(item => item.kind === 'governed' && item.pattern === pattern).map(item => item.path);
+    assert.deepStrictEqual(actualPaths, expectedPaths, `guard matcher returns the same members as doc-lifecycle for ${pattern}`);
+  }
+  assert.strictEqual(globSummaries.find(item => item.path === 'empty/*.md').baseMembers, 0, 'an empty glob is legal and reports zero members');
+
+  resetFixture(globFixture);
+  writeRelative(globFixture.root, 'docs/adr/one.md', 'revised governed glob member\n');
+  const globRevisionCandidate = commitFixture(globFixture.root, 'revise glob member');
+  const globRevision = runFrozenGuard(globFixture, globFixture.base, globRevisionCandidate);
+  assert.strictEqual(globRevision.status, 0, 'a regular governed glob member revision passes');
+  const globRevisionEntry = globRevision.report.policyPreservation.configuredPaths.paths.find(item => item.path === 'docs/adr/one.md');
+  assert.strictEqual(globRevisionEntry.state, 'revised');
+
+  resetFixture(globFixture);
+  writeRelative(globFixture.root, 'docs/adr/new.md', 'new governed glob member\n');
+  const globAdditionCandidate = commitFixture(globFixture.root, 'add glob member');
+  const globAddition = runFrozenGuard(globFixture, globFixture.base, globAdditionCandidate);
+  assert.strictEqual(globAddition.status, 2, 'a new glob member requires review');
+  assert.strictEqual(globAddition.report.policyPreservation.configuredPaths.paths.find(item => item.path === 'docs/adr/new.md').state, 'review_required');
+
+  resetFixture(globFixture);
+  fixtureGit(globFixture.root, ['rm', '--quiet', '--', 'docs/adr/two.md']);
+  const globDeletionCandidate = commitFixture(globFixture.root, 'delete glob member');
+  const globDeletion = runFrozenGuard(globFixture, globFixture.base, globDeletionCandidate);
+  assert.strictEqual(globDeletion.status, 2, 'a deleted glob member requires review');
+  assert.strictEqual(globDeletion.report.policyPreservation.configuredPaths.paths.find(item => item.path === 'docs/adr/two.md').candidate, null);
+
+  resetFixture(globFixture);
+  fixtureGit(globFixture.root, ['mv', '--', 'docs/adr/one.md', 'docs/adr/renamed.md']);
+  const globRenameCandidate = commitFixture(globFixture.root, 'rename glob member');
+  const globRename = runFrozenGuard(globFixture, globFixture.base, globRenameCandidate);
+  const globRenamePaths = globRename.report.policyPreservation.configuredPaths.paths;
+  assert.strictEqual(globRename.status, 2, 'a rename within a glob requires review');
+  assert.strictEqual(globRenamePaths.find(item => item.path === 'docs/adr/one.md').candidate, null, 'rename retains the old endpoint');
+  assert.strictEqual(globRenamePaths.find(item => item.path === 'docs/adr/renamed.md').base, null, 'rename retains the new endpoint');
+
+  for (const mutation of ['mode', 'symlink', 'gitlink']) {
+    resetFixture(globFixture);
+    if (mutation === 'mode') {
+      const candidate = commitFixture(globFixture.root, 'change glob member mode', 'docs/adr/one.md');
+      const result = runFrozenGuard(globFixture, globFixture.base, candidate);
+      assert.strictEqual(result.status, 2, 'a glob member mode change requires review');
+      assert.strictEqual(result.report.policyPreservation.configuredPaths.paths.find(item => item.path === 'docs/adr/one.md').state, 'review_required');
+      continue;
+    }
+    fs.rmSync(path.join(globFixture.root, 'docs', 'adr', 'one.md'));
+    if (mutation === 'symlink') {
+      const oid = fixtureGit(globFixture.root, ['hash-object', '-w', '--stdin'], Buffer.from('../outside-target.md\n')).toString('ascii').trim();
+      fixtureGit(globFixture.root, ['add', '-A']);
+      fixtureGit(globFixture.root, ['update-index', '--add', '--cacheinfo', `120000,${oid},docs/adr/one.md`]);
+    } else {
+      fixtureGit(globFixture.root, ['add', '-A']);
+      fixtureGit(globFixture.root, ['update-index', '--add', '--cacheinfo', `160000,${globFixture.base},docs/adr/one.md`]);
+    }
+    fixtureGit(globFixture.root, ['commit', '--quiet', '-m', `replace glob member with ${mutation}`]);
+    const candidate = fixtureGit(globFixture.root, ['rev-parse', 'HEAD']).toString('ascii').trim();
+    const result = runFrozenGuard(globFixture, globFixture.base, candidate);
+    assert.strictEqual(result.status, 2, `a glob member ${mutation} requires review`);
+    assert.strictEqual(result.report.policyPreservation.configuredPaths.paths.find(item => item.path === 'docs/adr/one.md').state, 'review_required');
+  }
+
+  resetFixture(globFixture);
+  writeRelative(globFixture.root, 'generated/view.md', 'changed derived glob output\n');
+  const derivedGlobCandidate = commitFixture(globFixture.root, 'change derived glob member');
+  const derivedGlob = runFrozenGuard(globFixture, globFixture.base, derivedGlobCandidate);
+  assert.strictEqual(derivedGlob.status, 2, 'a derived glob member content change requires review');
+  assert.strictEqual(derivedGlob.report.policyPreservation.configuredPaths.paths.find(item => item.path === 'generated/view.md').state, 'review_required');
+
+  if (process.platform !== 'win32') {
+    resetFixture(globFixture);
+    const unusualPath = 'docs/adr/new\nfile.md';
+    const oid = fixtureGit(globFixture.root, ['hash-object', '-w', '--stdin'], Buffer.from('unusual glob member\n')).toString('ascii').trim();
+    fixtureGit(globFixture.root, ['update-index', '--add', '--cacheinfo', `100644,${oid},${unusualPath}`]);
+    fixtureGit(globFixture.root, ['commit', '--quiet', '-m', 'add unusual glob member']);
+    const unusualCandidate = fixtureGit(globFixture.root, ['rev-parse', 'HEAD']).toString('ascii').trim();
+    const unusual = runFrozenGuard(globFixture, globFixture.base, unusualCandidate);
+    assert.strictEqual(unusual.status, 2, 'a glob matches paths containing unusual LF bytes');
+    assert.strictEqual(unusual.report.policyPreservation.configuredPaths.paths.find(item => item.path === unusualPath).state, 'review_required');
+  }
+
+  if (process.platform !== 'win32') {
+    // Known divergence: doc-lifecycle.js still excludes line terminators in glob segments.
+    const newlineGlobFixture = createFixture('governance-guard-newline-glob-git');
+    resetFixture(newlineGlobFixture);
+    writeRelative(newlineGlobFixture.root, '.agents/harness-everything/project-docs.json', `${JSON.stringify({
+      governed: [{ path: 'docs/**/*.md', role: 'reference' }],
+      derived: []
+    }, null, 2)}\n`);
+    writeRelative(newlineGlobFixture.root, 'docs/anchor.md', 'baseline direct child\n');
+    writeRelative(newlineGlobFixture.root, 'docs/a\nb/file.md', 'baseline newline directory member\n');
+    writeRelative(newlineGlobFixture.root, 'docs/a/b/file.md', 'baseline regular directory member\n');
+    newlineGlobFixture.base = commitFixture(newlineGlobFixture.root, 'newline glob policy baseline');
+
+    fixtureGit(newlineGlobFixture.root, ['rm', '--quiet', '--', 'docs/a\nb/file.md']);
+    const newlineDeletionCandidate = commitFixture(newlineGlobFixture.root, 'delete newline directory member');
+    const newlineDeletion = runFrozenGuard(newlineGlobFixture, newlineGlobFixture.base, newlineDeletionCandidate);
+
+    resetFixture(newlineGlobFixture);
+    writeRelative(newlineGlobFixture.root, 'docs/a\nb/new.md', 'new newline directory member\n');
+    const newlineAdditionCandidate = commitFixture(newlineGlobFixture.root, 'add newline directory member');
+    const newlineAddition = runFrozenGuard(newlineGlobFixture, newlineGlobFixture.base, newlineAdditionCandidate);
+
+    resetFixture(newlineGlobFixture);
+    fixtureGit(newlineGlobFixture.root, ['rm', '--quiet', '--', 'docs/a/b/file.md']);
+    const regularDeletionCandidate = commitFixture(newlineGlobFixture.root, 'delete regular directory member');
+    const regularDeletion = runFrozenGuard(newlineGlobFixture, newlineGlobFixture.base, regularDeletionCandidate);
+
+    assert.deepStrictEqual({
+      newlineDirectoryDeletion: newlineDeletion.status,
+      newlineDirectoryAddition: newlineAddition.status,
+      regularDirectoryDeletion: regularDeletion.status
+    }, {
+      newlineDirectoryDeletion: 2,
+      newlineDirectoryAddition: 2,
+      regularDirectoryDeletion: 2
+    }, 'newline-directory deletions and additions require review; regular-directory deletion is the positive control');
+  }
+
+  resetFixture(globFixture);
+  const narrowedPolicy = JSON.parse(fs.readFileSync(path.join(globFixture.root, '.agents/harness-everything/project-docs.json'), 'utf8'));
+  narrowedPolicy.governed[0].path = 'docs/adr/one.md';
+  writeRelative(globFixture.root, '.agents/harness-everything/project-docs.json', `${JSON.stringify(narrowedPolicy, null, 2)}\n`);
+  fixtureGit(globFixture.root, ['rm', '--quiet', '--', 'docs/adr/two.md']);
+  const narrowedCandidate = commitFixture(globFixture.root, 'narrow governed glob');
+  const narrowed = runFrozenGuard(globFixture, globFixture.base, narrowedCandidate);
+  assert.strictEqual(narrowed.status, 2, 'candidate policy cannot narrow base glob coverage');
+  assert.strictEqual(narrowed.report.policyPreservation.governed.state, 'review_required', 'candidate glob changes remain policy review');
+  assert.strictEqual(narrowed.report.policyPreservation.configuredPaths.paths.find(item => item.path === 'docs/adr/two.md').candidate, null);
+
+  for (const unsupported of ['docs/adr/*.md?', 'docs/adr/[a].md', 'docs/adr/{a}.md', '/docs/adr/*.md', 'docs/../*.md']) {
+    resetFixture(globFixture);
+    const invalidPolicy = JSON.parse(fs.readFileSync(path.join(globFixture.root, '.agents/harness-everything/project-docs.json'), 'utf8'));
+    invalidPolicy.governed.push({ path: unsupported, role: 'reference' });
+    writeRelative(globFixture.root, '.agents/harness-everything/project-docs.json', `${JSON.stringify(invalidPolicy, null, 2)}\n`);
+    const invalidCandidate = commitFixture(globFixture.root, `unsupported pattern ${unsupported}`);
+    const invalid = runFrozenGuard(globFixture, globFixture.base, invalidCandidate);
+    assert.strictEqual(invalid.status, 1, `unsupported glob syntax fails closed: ${unsupported}`);
+    assert.strictEqual(invalid.report.verdict, 'FAIL');
+  }
+
+  for (const mutation of ['rename', 'mode', 'symlink']) {
     resetFixture(fixture);
-    writeRelative(fixture.root, relativePath, `changed configured document ${relativePath}\n`);
-    const candidate = commitFixture(fixture.root, `edit configured document ${relativePath}`);
+    const relativePath = 'docs/architecture.md';
+    if (mutation === 'rename') {
+      fixtureGit(fixture.root, ['mv', '--', relativePath, 'docs/renamed-architecture.md']);
+    } else if (mutation === 'symlink') {
+      fs.rmSync(path.join(fixture.root, ...relativePath.split('/')));
+      const oid = fixtureGit(fixture.root, ['hash-object', '-w', '--stdin'], Buffer.from('../outside-target.md\n')).toString('ascii').trim();
+      fixtureGit(fixture.root, ['add', '-A']);
+      fixtureGit(fixture.root, ['update-index', '--add', '--cacheinfo', `120000,${oid},${relativePath}`]);
+      fixtureGit(fixture.root, ['commit', '--quiet', '-m', 'replace governed document with symlink']);
+    }
+    const candidate = mutation === 'symlink'
+      ? fixtureGit(fixture.root, ['rev-parse', 'HEAD']).toString('ascii').trim()
+      : commitFixture(fixture.root, `${mutation} governed document`, mutation === 'mode' ? relativePath : undefined);
     const result = runFrozenGuard(fixture, fixture.base, candidate);
-    assert.strictEqual(result.status, 2, `${relativePath} content change requires review: ${result.stderr}`);
+    assert.strictEqual(result.status, 2, `${mutation} of a governed entry requires review`);
     assert.strictEqual(result.report.verdict, 'REVIEW_REQUIRED');
     const item = result.report.policyPreservation.configuredPaths.missingOrChanged.find(entry => entry.path === relativePath);
-    assert.ok(item, `${relativePath} identity change is reported`);
-    const baseTree = parseTreeOracle(fixtureGit(fixture.root, ['ls-tree', '-r', '-z', '--full-tree', fixture.base]));
-    const candidateTree = parseTreeOracle(fixtureGit(fixture.root, ['ls-tree', '-r', '-z', '--full-tree', candidate]));
-    const key = Buffer.from(relativePath).toString('base64');
-    const rawIdentity = entry => ({ mode: entry.mode, type: entry.type, oid: entry.oid });
-    assert.deepStrictEqual(item.base, rawIdentity(baseTree.get(key)), 'report includes exact baseline Git identity');
-    assert.deepStrictEqual(item.candidate, rawIdentity(candidateTree.get(key)), 'report includes exact candidate Git identity');
-    assert.notStrictEqual(item.base.oid, item.candidate.oid, 'content change is identified by blob OID');
+    assert.ok(item, `${mutation} is reported for the original configured path`);
+    assert.strictEqual(item.state, 'review_required');
+    assert.deepStrictEqual(item.base, configuredIdentity(fixture.base, relativePath));
+    if (mutation === 'rename') assert.strictEqual(item.candidate, null);
+    if (mutation === 'mode') assert.notStrictEqual(item.base.mode, item.candidate.mode);
+    if (mutation === 'symlink') assert.strictEqual(item.candidate.mode, '120000');
   }
 
   resetFixture(fixture);
@@ -1805,6 +2039,17 @@ checkCase('2ax. frozen Git-object guard with bootstrap and tamper controls', ()
   assert.strictEqual(deletedGoverned.report.verdict, 'REVIEW_REQUIRED');
   assert.ok(deletedGoverned.report.policyPreservation.configuredPaths.missingOrChanged.some(item => item.path === 'docs/architecture.md'));
 
+  resetFixture(fixture);
+  const registeredPolicy = JSON.parse(fs.readFileSync(path.join(fixture.root, '.agents/harness-everything/project-docs.json'), 'utf8'));
+  registeredPolicy.governed.push({ path: 'docs/new-governed.md', role: 'reference' });
+  writeRelative(fixture.root, '.agents/harness-everything/project-docs.json', `${JSON.stringify(registeredPolicy, null, 2)}\n`);
+  writeRelative(fixture.root, 'docs/new-governed.md', 'newly registered governed member\n');
+  const registrationCandidate = commitFixture(fixture.root, 'register governed document');
+  const registration = runFrozenGuard(fixture, fixture.base, registrationCandidate);
+  assert.strictEqual(registration.status, 2, 'new-member registration requires review');
+  assert.strictEqual(registration.report.verdict, 'REVIEW_REQUIRED');
+  assert.ok(registration.report.policyPreservation.governed.added.some(item => item.path === 'docs/new-governed.md'));
+
   for (const relativePath of trustedPaths) {
     resetFixture(fixture);
     if (relativePath === '.agents/harness-everything/project-docs.json') {
@@ -1872,6 +2117,71 @@ checkCase('2ax. frozen Git-object guard with bootstrap and tamper controls', ()
   const missingCommit = runFrozenGuard(fixture, fixture.base, '0'.repeat(40));
   assert.notStrictEqual(missingCommit.status, 0);
   assert.notStrictEqual(missingCommit.report.verdict, 'PASS');
+
+  checkCase('2ax. CI workflow keeps the base-owned guard in a failing standalone job', () => {
+    const workflowPath = path.join(REPOSITORY_ROOT, '.github/workflows/ci.yml');
+    const workflow = require('js-yaml').load(fs.readFileSync(workflowPath, 'utf8'));
+    const job = workflow.jobs['doc-governance'];
+    assert.ok(job, 'standalone doc-governance job exists');
+    assert.strictEqual(job['runs-on'], 'ubuntu-latest');
+    assert.notStrictEqual(job['continue-on-error'], true, 'the job does not mask guard failures');
+    assert.ok(job.steps.some(step => step.uses === 'actions/checkout@v7' && step.with['fetch-depth'] === 0), 'job fetches base Git objects');
+    assert.ok(job.steps.some(step => step.uses === 'actions/setup-node@v7' && step.with['node-version'] === 24), 'job provides Node 24');
+    const guardStep = job.steps.find(step => step.name === 'Run base-owned document governance guard');
+    assert.ok(guardStep, 'standalone job owns the guard step');
+    assert.notStrictEqual(guardStep['continue-on-error'], true, 'the guard step propagates nonzero exits');
+    assert.ok(!workflow.jobs['self-regression'].steps.some(step => step.name === guardStep.name), 'self-regression no longer runs the guard');
+    const command = String(guardStep.run || '').trimEnd();
+    const inline = command.match(/^node -e '([\s\S]*)'$/);
+    assert.ok(inline, 'guard step remains a directly executable Node script');
+
+    function simulate(event, base, candidate) {
+      const summaryPath = path.join(tempRoot, `guard-summary-${process.pid}-${Math.random().toString(16).slice(2)}.md`);
+      const result = spawnSync(process.execPath, ['-e', inline[1]], {
+        cwd: fixture.root,
+        encoding: 'utf8',
+        timeout: 20000,
+        env: {
+          ...process.env,
+          HARNESS_GUARD_EVENT: event,
+          HARNESS_GUARD_BASE_SHA: base || '',
+          HARNESS_GUARD_CANDIDATE_SHA: candidate || '',
+          GITHUB_SHA: 'checkout-control',
+          GITHUB_STEP_SUMMARY: summaryPath
+        }
+      });
+      const summary = fs.existsSync(summaryPath) ? fs.readFileSync(summaryPath, 'utf8') : '';
+      fs.rmSync(summaryPath, { force: true });
+      assert.ifError(result.error);
+      return { status: result.status, output: result.stdout, summary };
+    }
+
+    const uncheckedEvent = simulate('push');
+    assert.strictEqual(uncheckedEvent.status, 0);
+    assert.match(uncheckedEvent.output, /UNCHECKED/);
+    const bootstrapEvent = simulate('pull_request', noGuardBase, noGuardCandidate);
+    assert.strictEqual(bootstrapEvent.status, 0, 'missing base verifier remains bootstrap-warning only');
+    assert.match(bootstrapEvent.output, /BOOTSTRAP_UNCHECKED/);
+    assert.match(bootstrapEvent.summary, /BOOTSTRAP_UNCHECKED/);
+    const passEvent = simulate('pull_request', fixture.base, fixture.base);
+    assert.strictEqual(passEvent.status, 0);
+    assert.match(passEvent.output, /"verdict": "PASS"/);
+
+    resetFixture(fixture);
+    writeRelative(fixture.root, 'docs/governed-index.md', 'changed derived output for CI simulation\n');
+    const reviewCandidate = commitFixture(fixture.root, 'simulate guard review failure');
+    const reviewEvent = simulate('pull_request', fixture.base, reviewCandidate);
+    assert.strictEqual(reviewEvent.status, 2, 'REVIEW_REQUIRED stays a failing workflow job');
+    assert.match(reviewEvent.output, /"verdict": "REVIEW_REQUIRED"/);
+
+    for (const exitCode of [1, 3]) {
+      resetFixture(fixture);
+      writeRelative(fixture.root, 'scripts/doc-governance-guard.js', `process.exit(${exitCode});\n`);
+      const base = commitFixture(fixture.root, `simulate base guard exit ${exitCode}`);
+      const result = simulate('pull_request', base, base);
+      assert.strictEqual(result.status, exitCode, `the standalone job propagates guard exit ${exitCode}`);
+    }
+  });
 });
 
 helper.finish();

package/docs/own-repo-governance-e1-plan-2026-10-25-2139.md

@@ -58,7 +58,7 @@ flowchart LR
 | E1 GO | A subsequent explicit owner decision based on the independent assessment, recording rationale, allowed scope, remaining uncertainty, and rollback. Neither elapsed time nor CI nor finishing E1 creates GO. |
 | #320 promotion | Still unauthorized. Generic CDG/Router migration requires E1 GO plus #325 H1–H4/paired evidence and a separate owner decision per proven interface. |
 
-Current disposition for #376: governance boundaries are documented in this plan; P1 inventory/disposition is implemented; and P2 includes a base-object guard wired before `npm ci` in candidate-controlled PR CI. The reviewed PR base `e40864fc24a711b96f583caa8e82f4707152f232` has no verifier, so its first invocation is `BOOTSTRAP_UNCHECKED` and does not execute candidate bytes. The guard now includes Git identities for the `ci/fixtures/doc-lifecycle/scenarios/` oracle tree; changes to those fixtures and to configured governed or derived blobs yield `REVIEW_REQUIRED`. That means independent semantic review is required, not that the content is automatically judged invalid. Ordinary ungoverned edits and new unknown documents remain allowed as `PASS` with unknown/unchecked content validation. The independent review found the earlier fixture gap and left semantic MUST preservation unresolved; re-review of the fixed guard at final exact SHAs is pending. The CI invocation remains candidate-controlled and can be removed; no external required-status check is enabled. E1 qualification is NOT YET ESTABLISHED (0 qualifying cycles); GO is NOT ISSUED. CI evidence is not E1 credit or live-host evidence.
+Current disposition for #376: governance boundaries are documented in this plan; P1 inventory/disposition is implemented; and P2 runs the base-owned guard in a dedicated `doc-governance` job, separate from `self-regression`, so the other CI gates still run when the guard is non-green. The reviewed PR base `e40864fc24a711b96f583caa8e82f4707152f232` has no verifier, so its first invocation is `BOOTSTRAP_UNCHECKED` and does not execute candidate bytes. The guard includes Git identities for the `ci/fixtures/doc-lifecycle/scenarios/` oracle tree; fixture/trust-surface, policy/config, deletion/rename, mode/type, and derived-output changes yield `REVIEW_REQUIRED`. Regular governed-content revisions with the same mode are reported as `revised` with base/candidate identities and pass; the guard does not semantically validate them. That means independent semantic review is required, not that the content is automatically judged invalid. Ordinary ungoverned edits and new unknown documents remain allowed as `PASS` with unknown/unchecked content validation. The independent review found the earlier fixture gap and left semantic MUST preservation unresolved; re-review of the fixed guard at final exact SHAs is pending. The CI invocation remains candidate-controlled and can be removed; no external required-status check is enabled. E1 qualification is NOT YET ESTABLISHED (0 qualifying cycles); GO is NOT ISSUED. CI evidence is not E1 credit or live-host evidence.
 
 ## Candidate inventory and coverage
 
@@ -230,12 +230,14 @@ Private byte-identical backups of all three queue files and this turn's scope, p
 
 | Item | Status |
 |---|---|
-| Integration | On `pull_request`, `.github/workflows/ci.yml` extracts the guard blob from the event base and runs those bytes against the event base/head SHAs before `npm ci`; it logs the blob OID and SHA-256 and reports `GITHUB_SHA` separately. The reviewed base `e40864fc24a711b96f583caa8e82f4707152f232` has no verifier, so the current-base result is `BOOTSTRAP_UNCHECKED`; non-PR events without an external verifier report `UNCHECKED`. Neither path executes candidate guard bytes. |
-| Guarded identities and outcomes | The trust surface includes every Git entry under `ci/fixtures/doc-lifecycle/scenarios/`, compared by raw Git identity (`mode`, `type`, `oid`), so fixture edits, deletions, mode changes, and candidate-only additions yield `REVIEW_REQUIRED`. Configured governed and derived paths also require baseline mode and blob OID identity; a blob change yields `REVIEW_REQUIRED` and requires independent semantic review. This is not an automatic finding that the content is invalid, and the guard does not validate natural-language MUST preservation. Ordinary ungoverned edits and new unknown documents remain `PASS`, with new paths reported `unknown`/`unchecked`. |
-| Verification | The Node 24 focused `ci/mechanism-2ax-doc-lifecycle.test.js` passes the fixture edit/delete/mode/add cases, unchanged-fixture positive control, governed/derived blob-change cases, and ordinary ungoverned/new-unknown controls. Node 24 `--check` on both changed JavaScript files and `git diff --check` passed. Earlier reported checks also include `ci/mechanism-325-f1-doc-check.test.js` (76 PASS), `npm run test:repo-contract`, `npm run test:docs:capabilities`, and a parsed YAML step simulation for bootstrap, push `UNCHECKED`, extracted-guard `PASS`, and `REVIEW_REQUIRED` exit-2 propagation. |
+| Integration | On `pull_request`, the standalone `doc-governance` job extracts the guard blob from the event base and runs those bytes against the exact event base/head SHAs; it logs the blob OID and SHA-256 and reports `GITHUB_SHA` separately. The job does not mask guard failures and runs independently of `self-regression`. The reviewed base `e40864fc24a711b96f583caa8e82f4707152f232` has no verifier, so the current-base result is `BOOTSTRAP_UNCHECKED`; non-PR events without an external verifier report `UNCHECKED`. Neither path executes candidate guard bytes. |
+| Guarded identities and outcomes | The trust surface includes every Git entry under `ci/fixtures/doc-lifecycle/scenarios/`, compared by raw Git identity (`mode`, `type`, `oid`), so fixture edits, deletions, mode changes, and candidate-only additions yield `REVIEW_REQUIRED`. Regular governed-content revisions with the same mode return `PASS` as informational `revised` entries with both Git identities; the guard does not semantically validate revised content. Deletion/rename, mode/type, policy/config or new-member registration, trust-surface/fixture, and derived-output changes still return `REVIEW_REQUIRED`; derived changes retain their regeneration/parity evidence requirement. Ordinary ungoverned edits and new unknown documents remain `PASS`, with new paths reported `unknown`/`unchecked`. |
+| Verification | The Node 24 focused `ci/mechanism-2ax-doc-lifecycle.test.js` covers fixture edit/delete/mode/add, governed revision pass, deletion/rename/mode/symlink review, derived-change review, unchanged-tree and ordinary ungoverned/new-unknown controls, plus the standalone-job step simulation. Node 24 `--check` on both changed JavaScript files and `git diff --check` passed. Earlier reported checks also include `ci/mechanism-325-f1-doc-check.test.js` (76 PASS), `npm run test:repo-contract`, `npm run test:docs:capabilities`, and a parsed YAML step simulation for bootstrap, push `UNCHECKED`, extracted-guard `PASS`, and `REVIEW_REQUIRED` exit-2 propagation. |
 | Evidence / limits | These are deterministic mechanism and local step-simulation results, not hosted GitHub Actions or live-host evidence. Full `npm test` and `verify:all` are not established here. The independent review of the earlier frozen guard found the fixture-oracle gap and left semantic MUST preservation unresolved; independent re-review of the fixed guard against the final exact SHAs remains pending. Candidate-controlled `.github/workflows/ci.yml` can remove the invocation, and no external required-status check is enabled. |
 | E1 / authority | P2 is CI engineering evidence only. E1 remains at 0 qualifying cycles; status is NOT GO / owner GO is NOT ISSUED, and #320 remains unauthorized. |
 
+On 2026-10-27, the base-owned guard added a self-contained POSIX `*`/`**` matcher and expands governed and derived globs from the base and candidate Git trees. New or missing members and non-regular or mode-changed entries remain `REVIEW_REQUIRED`; regular governed revisions remain informational, derived object changes still require review, empty globs report zero members, and candidate policy changes remain review-required.
+
 ### Next session
 
 | Remaining item | Next action / boundary |

package/docs/platform-capabilities.md

@@ -208,8 +208,8 @@ Credited reconciliation for F4 (Claude Code only, pilot ON) is **implemented, wi
 
 ### Own-repository governance guard (PR #376)
 
-On `pull_request`, the self-regression workflow extracts `scripts/doc-governance-guard.js` from the event base commit and runs those bytes against the exact event base/head SHAs before `npm ci`. The ordinary test suite may still run on GitHub's PR checkout SHA, which can be a synthetic merge commit; it is reported separately. The guard never falls back to the candidate copy. The reviewed PR base lacks the verifier, so the current-base result is `BOOTSTRAP_UNCHECKED` in a warning and step summary while the regular regression suite continues; push and workflow-call events without an external PR verifier report `UNCHECKED`. A nonzero result from an extracted verifier remains nonzero.
+On `pull_request`, a standalone `doc-governance` job extracts `scripts/doc-governance-guard.js` from the event base commit and runs those bytes against the exact event base/head SHAs. Its nonzero result fails that job; `self-regression` and the other CI jobs run independently. The ordinary test suite may still run on GitHub's PR checkout SHA, which can be a synthetic merge commit; it is reported separately. The guard never falls back to the candidate copy. PR #376's reviewed base lacked the verifier; that historical bootstrap reported BOOTSTRAP_UNCHECKED without executing candidate bytes. Bases containing the guard (including main at 0ef0541c) execute the base-owned verifier. If a selected PR base lacks the guard, the wrapper retains the warning/step-summary-only bootstrap path with exit 0; this is unverified governance, not PASS. Every nonzero exit from an extracted verifier, including FAIL and BOOTSTRAP_UNCHECKED, fails the governance job. Other CI jobs run independently.
 
-The guard's trust surface includes every Git entry under `ci/fixtures/doc-lifecycle/scenarios/`, compared by raw Git identity (`mode`, `type`, `oid`). Configured governed and derived paths also require baseline mode and blob OID identity. Fixture or configured-blob changes return `REVIEW_REQUIRED`, meaning independent semantic review is required; the guard does not judge whether edited prose still satisfies its MUST obligations. Ordinary ungoverned edits and new unknown documents remain allowed as `PASS`, with unknown content validation visible.
+The guard's trust surface includes every Git entry under `ci/fixtures/doc-lifecycle/scenarios/`, compared by raw Git identity (`mode`, `type`, `oid`). A regular governed-content revision with the same mode returns `PASS` as an informational `revised` entry with both Git identities; the guard does not semantically validate revised content. Deletion/rename, mode/type, policy/config or new-member registration, trust-surface/fixture, and derived-output changes still return `REVIEW_REQUIRED`. Derived changes retain their regeneration/parity evidence requirement. Ordinary ungoverned edits and new unknown documents remain allowed as `PASS`, with unknown content validation visible.
 
 This integration lives in candidate-controlled `.github/workflows/ci.yml` and can be removed by a candidate change. The independent review found the prior fixture-oracle gap; re-review of the fixed guard at final exact SHAs is pending. No external required-status check is enabled, and no live-host evidence is established. This is package and mechanism evidence only; it does not qualify E1. E1 remains at zero qualifying cycles and owner GO is not issued.

package/opencode-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-enforcement",
   "description": "Repository inventory for the opencode enforcement plugin and its standalone helper",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "runtime": "index.mjs",
   "hooks": {
     "verify": "hooks/verify.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
   "main": "harness-everything/scripts/bootstrap.js",
   "bin": {

package/plugins/harness-everything/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/plugins/harness-everything/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "harness-everything",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/sbom.cdx.json

@@ -2,23 +2,23 @@
   "$schema": "https://cyclonedx.org/schema/bom-1.7.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.7",
-  "serialNumber": "urn:uuid:1bad1acf-3464-511b-b36b-492f1409c976",
+  "serialNumber": "urn:uuid:062d938e-8477-5564-9f89-fa21e9121182",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-10-27T06:46:51.060Z",
+    "timestamp": "2026-10-27T10:11:43.769Z",
     "tools": [
       {
         "vendor": "Harness Everything",
         "name": "generate-sbom.js",
-        "version": "0.43.0"
+        "version": "0.44.0"
       }
     ],
     "component": {
       "type": "application",
-      "bom-ref": "pkg:npm/harness-everything@0.43.0",
+      "bom-ref": "pkg:npm/harness-everything@0.44.0",
       "name": "harness-everything",
-      "version": "0.43.0",
-      "purl": "pkg:npm/harness-everything@0.43.0"
+      "version": "0.44.0",
+      "purl": "pkg:npm/harness-everything@0.44.0"
     }
   },
   "components": [
@@ -2033,7 +2033,7 @@
       ]
     },
     {
-      "ref": "pkg:npm/harness-everything@0.43.0",
+      "ref": "pkg:npm/harness-everything@0.44.0",
       "dependsOn": [
         "pkg:npm/%40commitlint/cli@19.8.1",
         "pkg:npm/%40commitlint/config-conventional@19.8.1",

package/scripts/doc-governance-guard.js

@@ -121,9 +121,8 @@ function validateProjectDocs(value, label) {
       if (!isRecord(record) || typeof record.path !== 'string' || !record.path || typeof record[field] !== 'string' || !record[field]) {
         throw new Error(`${label} has a malformed ${kind} record`);
       }
-      if (record.path.startsWith('/') || record.path.split('/').includes('..') || /[*?\[\]]/.test(record.path)) {
-        // shortcut: the baseline registry uses exact Git paths; glob support needs a Git-aware matcher before adoption.
-        throw new Error(`${label} has a non-exact governed or derived path: ${record.path}`);
+      if (record.path.startsWith('/') || record.path.split('/').includes('..') || ['?', '[', ']', '{', '}'].some(char => record.path.includes(char))) {
+        throw new Error(`${label} has an unsupported governed or derived path pattern: ${record.path}`);
       }
       const key = `${kind}:${record.path}`;
       if (seen.has(key)) throw new Error(`${label} has duplicate ${kind} path: ${record.path}`);
@@ -159,8 +158,9 @@ function policyChanges(base, candidate, kind) {
     path: record.path,
     base: record,
     candidate: byPath.get(record.path) || null
-  }));
-  const added = candidate[kind].filter(record => !basePaths.has(record.path));
+  })).sort((left, right) => Buffer.compare(Buffer.from(left.path), Buffer.from(right.path)));
+  const added = candidate[kind].filter(record => !basePaths.has(record.path))
+    .sort((left, right) => Buffer.compare(Buffer.from(left.path), Buffer.from(right.path)));
   return { state: missingOrChanged.length || added.length ? 'review_required' : 'pass', preserved: base[kind].length - missingOrChanged.length, missingOrChanged, added };
 }
 
@@ -173,6 +173,32 @@ function pathText(pathBytes) {
   return Buffer.from(value, 'utf8').equals(pathBytes) ? value : null;
 }
 
+function globToRegExp(glob) {
+  const source = Buffer.from(String(glob).replace(/\\/g, '/'), 'utf8').toString('latin1');
+  let pattern = '^';
+  for (let index = 0; index < source.length; index++) {
+    const char = source[index];
+    if (char === '*' && source[index + 1] === '*') {
+      if (source[index + 2] === '/') {
+        pattern += '(?:[\\s\\S]*/)?';
+        index += 2;
+      } else {
+        pattern += '[\\s\\S]*';
+        index++;
+      }
+    } else if (char === '*') {
+      pattern += '[^/]*';
+    } else {
+      pattern += char.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+    }
+  }
+  return new RegExp(`${pattern}$`);
+}
+
+function matchesConfiguredPath(record, pathBytes, matcher) {
+  return matcher ? matcher.test(pathBytes.toString('latin1')) : Buffer.from(record.path, 'utf8').equals(pathBytes);
+}
+
 function identity(entry) {
   return entry ? { mode: entry.mode, type: entry.type, oid: entry.oid } : null;
 }
@@ -223,18 +249,57 @@ function unknownNewDocuments(baseTree, candidateTree) {
 
 function checkConfiguredPaths(baseTree, candidateTree, config) {
   const details = [];
+  const patterns = [];
   for (const kind of ['governed', 'derived']) {
     for (const record of config[kind]) {
-      const key = pathKey(record.path);
-      const before = baseTree.get(key);
-      const after = candidateTree.get(key);
-      if (!regularBlob(before)) throw new Error(`baseline ${kind} path is missing or not a regular file: ${record.path}`);
-      const identityPreserved = regularBlob(after) && before.mode === after.mode && before.oid === after.oid;
-      details.push({ kind, path: record.path, state: identityPreserved ? 'pass' : 'review_required', base: identity(before), candidate: identity(after) });
+      const glob = record.path.includes('*');
+      const matcher = glob ? globToRegExp(record.path) : null;
+      const collect = sourceTree => {
+        if (!glob) {
+          const key = pathKey(record.path);
+          const entry = sourceTree.get(key);
+          return new Map(entry ? [[key, entry]] : []);
+        }
+        const matches = new Map();
+        for (const [key, entry] of sourceTree) {
+          if (matchesConfiguredPath(record, entry.pathBytes, matcher)) matches.set(key, entry);
+        }
+        return matches;
+      };
+      const baseMembers = collect(baseTree);
+      const candidateMembers = collect(candidateTree);
+      if (!glob && !regularBlob(baseMembers.values().next().value)) {
+        throw new Error(`baseline ${kind} path is missing or not a regular file: ${record.path}`);
+      }
+      if (glob) patterns.push({ kind, path: record.path, baseMembers: baseMembers.size, candidateMembers: candidateMembers.size });
+      const keys = new Set([...baseMembers.keys(), ...candidateMembers.keys()]);
+      for (const key of keys) {
+        const before = baseMembers.get(key) || null;
+        const after = candidateMembers.get(key) || null;
+        const entry = before || after;
+        const sameRegularMode = regularBlob(before) && regularBlob(after) && before.mode === after.mode;
+        const revised = kind === 'governed' && sameRegularMode && before.oid !== after.oid;
+        const identityPreserved = sameRegularMode && before.oid === after.oid;
+        const memberPath = pathText(entry.pathBytes);
+        details.push({
+          kind,
+          ...(glob ? { pattern: record.path } : {}),
+          path: memberPath,
+          ...(memberPath === null ? { pathBase64: key } : {}),
+          state: revised ? 'revised' : identityPreserved ? 'pass' : 'review_required',
+          base: identity(before),
+          candidate: identity(after),
+          ...(revised ? { reason: 'Content revisions are tracked by Git identity but are not semantically validated by the guard.' } : {})
+        });
+      }
     }
   }
-  const failures = details.filter(item => item.state !== 'pass');
-  return { state: failures.length ? 'review_required' : 'pass', paths: details, missingOrChanged: failures };
+  patterns.sort((left, right) => Buffer.compare(Buffer.from(left.kind), Buffer.from(right.kind)) || Buffer.compare(Buffer.from(left.path), Buffer.from(right.path)));
+  details.sort((left, right) => Buffer.compare(Buffer.from(left.pathBase64 || Buffer.from(left.path, 'utf8').toString('base64'), 'base64'), Buffer.from(right.pathBase64 || Buffer.from(right.path, 'utf8').toString('base64'), 'base64'))
+    || Buffer.compare(Buffer.from(left.kind), Buffer.from(right.kind))
+    || Buffer.compare(Buffer.from(left.pattern || ''), Buffer.from(right.pattern || '')));
+  const failures = details.filter(item => item.state === 'review_required');
+  return { state: failures.length ? 'review_required' : 'pass', patterns, paths: details, missingOrChanged: failures };
 }
 
 function parseArgs(argv) {
@@ -270,7 +335,7 @@ function run(argv) {
     reviewAuthority: 'External reviewer only; candidate-controlled approval files or reports are never read.',
     limits: [
       'Candidate-owned CI is not independent enforcement; bootstrap remains unchecked until an external reviewer binds frozen guard bytes to final exact SHAs.',
-      'Document semantics and derived-view parity are not validated; configured documents are required to keep their baseline Git identities.'
+      'Governed content revisions are visible by Git identity but are not semantically validated by the guard; derived-view parity is not validated.'
     ],
     errors: []
   };