@t275005746/gse 0.1.1 → 0.1.2

package/references/host-adapters.md

@@ -2,11 +2,13 @@
 
 Use this when a project needs GSE to work across Codex, Claude Code, Hermes/AION-style runtimes, WorkBuddy, Copilot-style agents, Gemini-style agents, or another agent host. Use `references/compatibility.md` to check host support status and adoption evidence before making capability claims.
 
-## Core Rule
-
-`.gse/` is the portable source of truth. Host-specific folders are adapters.
-
-Adapters may expose commands, hooks, skills, MCP servers, indexes, or local UI metadata for one host, but they must point back to `.gse/` for project policy, goals, evidence, quality gates, and learning rules.
+## Core Rule
+
+`.gse/` is the portable source of truth. Host-specific folders are adapters.
+
+Adapters may expose commands, hooks, skills, MCP servers, indexes, or local UI metadata for one host, but they must point back to `.gse/` for project policy, goals, evidence, quality gates, and learning rules.
+
+Process skills such as OpenSpec, Superpowers, Comet, and GSE can define workflow discipline, specs, roles, evidence, and quality gates. They do not create host-native slash commands, real subagent dispatch, browser automation, MCP servers, LSP indexes, CI runners, or host UI integration. Treat those as host capabilities and verify them through records before claiming support.
 
 ## Adapter Decision
 
@@ -17,7 +19,7 @@ Create or update a host adapter only when at least one condition is true:
 - A host-specific capability needs a short pointer to `.gse/` to avoid duplicate policy.
 - A migration is needed from an existing `.claude/`, `.codex/`, `.agents/`, or runtime-specific workflow into `.gse/`.
 
-Do not create host folders just for decoration. If the host capability is unknown, document it as `unknown` in `.gse/project-profile.md` or `.gse/tooling.md`.
+Do not create host folders just for decoration. If the host capability is unknown, document it as `unknown` in `.gse/project-profile.md`, `.gse/tooling.md`, or `.gse/host-capabilities.md`.
 
 ## Supported Host Shapes
 
@@ -75,9 +77,9 @@ node <gse-skill>/scripts/audit-host-runtime-invocation-drill.mjs --root <skill-o
 
 The drill writes temporary records for Claude, Codex, Hermes/AION-style, WorkBuddy, and generic hosts, then audits native versus portable evidence counts. It proves the record/audit mechanics only; it does not prove real host runtime support.
 
-Generated adapters are not runtime proof. A host capability becomes verified only when a persistent host invocation record exists and the audit can parse it.
-
-Minimum fields:
+Generated adapters are not runtime proof. A host capability becomes verified only when a persistent host invocation record exists and the audit can parse it.
+
+Minimum fields:
 
 - Host name and adapter path.
 - Source of truth: always `.gse/` unless the project explicitly says otherwise.
@@ -85,7 +87,33 @@ Minimum fields:
 - Unverified or unavailable capabilities.
 - How to start meaningful work in this host.
 - Safety and permissions.
-- Drift check owner or cadence.
+- Drift check owner or cadence.
+
+## Host Capability Records
+
+Use `.gse/host-capabilities.md` to keep a compact, auditable status table for host-native and tool capabilities:
+
+- `native-slash-command`
+- `browser`
+- `mcp`
+- `lsp`
+- `subagent`
+- `ci`
+
+Status vocabulary: `verified`, `documented`, `unknown`, `unavailable`, `external-required`.
+
+Rules:
+
+- `verified` needs concrete project or host evidence.
+- Native slash-command support cannot be verified from portable `run-gse-command.mjs` output.
+- `documented` and `external-required` rows must include a claim boundary.
+- Missing records are a continuation warning for new projects; invalid or overclaimed records fail the host capability audit.
+
+Audit command:
+
+```text
+node <gse-skill>/scripts/audit-host-capabilities.mjs --target <project-root> --json
+```
 
 ## Tool Status Rules
 

package/references/learning-system.md

@@ -21,15 +21,31 @@ Learnings keep long projects from repeating mistakes.
 
 Use `references/drift-audit.md` when a repeated lesson suggests stale docs, stale project-profile facts, stale host adapters, stale tool assumptions, or stale evidence state.
 
-- First occurrence: learning note.
-- Second occurrence: checklist or template update.
-- Third occurrence: project rule or quality gate.
-- Fifth occurrence: script, test, or dedicated skill.
+- First occurrence: learning note.
+- Second occurrence: checklist or template update.
+- Third occurrence: project guard, project rule, or quality gate.
+- Fifth occurrence: script, test, or dedicated skill.
+
+Use `scripts/audit-learning-promotion.mjs --target <project-root> --json` to classify and count repeated lessons. The audit is read-only by default. Use `/gse learn --promote --execute` only to write `.gse/learning-promotions.md` candidate output; it does not mutate `.gse/project-guards.md`, `.gse/quality-gates.md`, templates, scripts, or skill files without a deliberate follow-up change.
+
+Use `scripts/audit-learning-drift.mjs --root <gse-skill> --target <project-root> --json` after promotion analysis. It checks whether promoted guard or script candidates are covered by project guards, quality gates, `/gse continue`, `/gse close`, or a focused audit script. Uncovered high-severity candidates are surfaced as warnings so the next slice can deliberately promote them.
+
+Promotion categories:
+
+- `shell`: shell syntax, host command behavior, Windows/Unix command differences.
+- `encoding`: UTF-8, mojibake, localized document handling.
+- `evidence`: JSONL, evidence levels, stale records, close gates.
+- `browser`: browser smoke, Playwright, screenshot, component-test downgrade.
+- `git`: sparse checkout, staging, commit boundaries.
+- `host-tool`: subagents, MCP, LSP, native slash commands, host runtime claims.
+- `project-rule`: canonical plans, AGENTS.md, local project conventions.
+- `release`: CI, registry, marketplace, security contact, release evidence.
 
 ## Suggested Stores
 
-- `.gse/learnings.md` for portable project lessons.
-- `.learnings/` when the project already uses that convention.
-- `AGENTS.md` for durable project rules.
-- ADRs for architectural decisions.
+- `.gse/learnings.md` for portable project lessons.
+- `.gse/project-guards.md` for recurring preflight rules promoted from lessons.
+- `.learnings/` when the project already uses that convention.
+- `AGENTS.md` for durable project rules.
+- ADRs for architectural decisions.
 

package/references/maintenance-cadence.md

@@ -0,0 +1,51 @@
+# GSE Maintenance Cadence
+
+GSE final form requires recurring checks, not only one-time release proof. This cadence keeps benchmark coverage, drift detection, security review, forward testing, and target-project drills visible while host-native slash-command evidence remains an external gate.
+
+## Cadence Table
+
+| Area | Trigger | Minimum Cadence | Evidence | Command |
+|---|---|---|---|---|
+| Benchmark audit | Non-trivial GSE capability change or new comparable engineering skill | Monthly or before release | `.gse/benchmark-audits/` entry or roadmap update | `node scripts/audit-final-form-roadmap.mjs --root . --json` |
+| Drift audit | Project guard, learning, adapter, command, or state model changes | Weekly or before close | Learning drift and state freshness output | `node scripts/audit-learning-drift.mjs --root . --target . --json` |
+| Dependency and security review | Release, install, package, registry, CI, or external input changes | Monthly or before release | Release trust, CI readiness, and public acceptance outputs | `node scripts/audit-release-trust.mjs --root . --json` |
+| Forward test | Non-trivial routing, command, scaffold, validation, or package change | Before release and after major workflow changes | Fixture or fresh-session forward-test evidence | `node scripts/forward-test-gse.mjs --root . --json` |
+| Target-project hardening drill | GSE adoption, continue, close, host capability, or learning behavior changes | Weekly or before public release | Read-only target drill output | `node scripts/audit-target-hardening-drills.mjs --root . --json` |
+| Public acceptance doctor | Public release, registry, marketplace, host, or owner evidence changes | Before release or public claim | Pending owner/external gate report | `node scripts/audit-public-acceptance-readiness.mjs --root . --json` |
+| Command runner smoke | `/gse` command routing, portable command wrapper, or short-entry behavior changes | Every command-router change | Portable runner output from `scripts/run-gse-command.mjs` | `node scripts/run-gse-command.mjs --root . --target . --command "/gse maintenance" --json --compact` |
+| Installed skill sync | Any capability upgrade shipped from source to installed skill | Every capability upgrade | Installed-copy hash comparison and command smoke from `scripts/audit-installed-sync.mjs` | `node scripts/audit-installed-sync.mjs --root . --installed-root <installed-skill-dir> --json` |
+| Active session sync | Any capability upgrade that should reach active GSE-using sessions | Every capability upgrade when active sessions exist | Honest sent, archived, unavailable, failed, or skipped records from `scripts/record-session-sync.mjs` plus `scripts/audit-session-sync.mjs` | `node scripts/audit-session-sync.mjs --root . --require-installed --require-thread <thread-id> --json` |
+
+## Maintenance Snapshot
+
+Use a snapshot when the goal is to prove that the recurring checks actually ran, not only that the cadence is documented.
+
+```powershell
+node scripts/generate-maintenance-snapshot.mjs --root . --target . --installed-root <installed-skill-dir> --execute --json
+```
+
+The canonical output is `.gse/maintenance/latest-maintenance-snapshot.json` plus a Markdown sibling. Without `--installed-root`, the installed-sync row is package-only and must not be used as installed-copy freshness proof.
+
+For an installed package smoke, use package mode so source-worktree-only roadmap and release-bundle freshness checks do not become false blockers:
+
+```powershell
+node scripts/generate-maintenance-snapshot.mjs --root <installed-skill-dir> --target <installed-skill-dir> --package-smoke --skip-release-bundle --json
+```
+
+Package smoke proves the installed copy can run the maintenance command set. The source repository remains responsible for canonical roadmap, release bundle, and installed-root freshness evidence.
+
+## Close Rule
+
+Maintenance evidence is not a substitute for native host evidence, public CI, marketplace approval, or owner acceptance. It only proves that GSE has a repeatable upkeep loop and that remaining external gates stay visible.
+
+Before claiming a maintenance-sensitive slice complete, run:
+
+```powershell
+node scripts/audit-maintenance-cadence.mjs --root . --json
+node scripts/generate-maintenance-snapshot.mjs --root . --target . --installed-root <installed-skill-dir> --execute --json
+node scripts/audit-maintenance-snapshot.mjs --root . --json
+node scripts/run-gse-command.mjs --root . --target . --command "/gse maintenance" --json --compact
+node scripts/audit-installed-sync.mjs --root . --installed-root <installed-skill-dir> --json
+node scripts/audit-session-sync.mjs --root . --json
+node scripts/run-validation-profile.mjs --target . --profile lite --json
+```

package/references/project-guards.md

@@ -0,0 +1,52 @@
+# Project Guards
+
+Project guards are reusable preflight rules promoted from repeated project lessons.
+
+They sit between learning notes and hard quality gates:
+
+```text
+lesson -> project guard -> quality gate -> script/test/skill update
+```
+
+Use guards when a mistake is likely to recur across sessions, but the rule still needs project context.
+
+## Guard File
+
+Default project-local path:
+
+```text
+.gse/project-guards.md
+```
+
+The file uses a small table so humans can edit it and scripts can audit it:
+
+| ID | Guard | Severity | Trigger | Check | Status |
+|---|---|---|---|---|---|
+| UTF8-DOC | Use UTF-8-safe readers for Chinese or multilingual docs before judging mojibake. | high | Chinese docs or encoding complaint | Read with Node UTF-8 or another UTF-8-safe viewer; run the project encoding check when docs changed. | active |
+
+## Default Guard Set
+
+- `WIN-SHELL`: shell syntax must match the active host.
+- `SPARSE-GIT`: sparse checkout must be checked before staging generated workflow folders.
+- `UTF8-DOC`: multilingual docs need UTF-8-safe reads and encoding checks.
+- `EVIDENCE-STALE`: stale or broken evidence is a preflight issue.
+- `UI-EVIDENCE`: UI/browser downgrades must be labeled explicitly.
+- `SUBAGENT-HONEST`: subagent dispatch claims require real host evidence.
+- `SYNC-NO-INTERRUPT`: cross-thread GSE upgrade sync must not interrupt a running project session.
+
+## Continue Behavior
+
+`/gse continue` reads `.gse/project-guards.md` when present and returns an active guard summary in the compact packet.
+
+Missing guard files are a warning for mature projects, not a hard failure. Broken state or evidence remains the hard preflight failure.
+
+## Promotion
+
+- First occurrence: record in `.gse/learnings.md`.
+- Second occurrence: update a checklist, template, or guard candidate.
+- Third occurrence: promote to `.gse/project-guards.md` or `.gse/quality-gates.md`.
+- Fifth occurrence: automate as a script, test, or skill update.
+
+Do not hardcode product-specific behavior into the GSE skill. AION and MuseFlow can supply examples and evidence, but project guards must stay generic.
+
+Cross-thread sync is a guard-sensitive action: prefer evidence records, release notes, or owner action notes. Send a message to another active project session only when it is idle or the owner explicitly asks for immediate sync.

package/references/quality-gates.md

@@ -6,13 +6,19 @@ Pick gates by task risk.
 
 - Outcome matches request.
 - Scope did not expand silently.
-- Acceptance has evidence.
-- Evidence status uses `evidence-taxonomy.md`: result, verified, or accepted.
-- Do not claim `verified` or `accepted` when evidence only proves `result`.
-- Dirty worktree contains only intended files; use `references/file-ownership.md` when ownership or pre-existing changes are unclear.
+- Acceptance has evidence.
+- Evidence status uses `evidence-taxonomy.md`: result, verified, or accepted.
+- Evidence level uses `evidence-taxonomy.md`: `result`, `verified-unit`, `verified-component`, `verified-api`, `verified-browser`, `verified-ci`, `accepted-owner`, `accepted-release`, or `external-required`.
+- Do not claim `verified` or `accepted` when evidence only proves `result`.
+- Do not describe `verified-component` or `verified-api` as `verified-browser`; record a downgrade when browser proof was required but only component/API proof ran.
+- Dirty worktree contains only intended files; use `references/file-ownership.md` when ownership or pre-existing changes are unclear.
+- Close checks must surface role-dispatch honesty, staged/unstaged/untracked worktree state, and staged generated/test artifacts before a slice is called complete.
 - Final answer states evidence and remaining risk.
-- Use `references/recovery.md` when work is interrupted, verification fails, rollback/resume decisions are needed, or another agent/session must continue.
-- Use `references/review.md` when task risk requires spec compliance, code quality, architecture drift, security/privacy, regression, or evidence review.
+- Use `references/recovery.md` when work is interrupted, verification fails, rollback/resume decisions are needed, or another agent/session must continue.
+- Check `.gse/project-guards.md` through `/gse continue` or `scripts/audit-project-guards.mjs` when recurring lessons may affect the slice.
+- Check `.gse/host-capabilities.md` through `/gse continue` or `scripts/audit-host-capabilities.mjs` before claiming native slash-command, browser, MCP, LSP, subagent, or CI support.
+- Check learning drift through `/gse continue` or `scripts/audit-learning-drift.mjs` before closing repeated-failure lessons as enforced.
+- Use `references/review.md` when task risk requires spec compliance, code quality, architecture drift, security/privacy, regression, or evidence review.
 - Use `references/domain-quality-gates.md` when task risk involves security/privacy, performance/cost, accessibility, resilience/recovery, UI/browser, API/state, data/migration, model/tool routing, or release/operations concerns.
 - Use `references/architecture-health.md` when the task touches structural boundaries, coupling, source-of-truth drift, ownership, dependency/security risk, performance/resilience, migration, or release impact.
 - Use `references/forward-test.md` for non-trivial GSE skill, scaffold, router, role, adapter, release, recovery, or packaging changes.
@@ -63,11 +69,12 @@ node <gse-skill>/scripts/run-validation-profile.mjs --target <project-root> --pr
 
 Use this runner when a host, user, or future agent needs a stable command instead of hand-selecting individual audit scripts.
 
-## UI Gates
-
-- Component test or browser smoke for visible behavior.
-- Screenshot or visual inspection for layout-sensitive work.
-- Loading, empty, error, success, retry, and cancelled states covered when relevant.
+## UI Gates
+
+- Component test or browser smoke for visible behavior.
+- Screenshot or visual inspection for layout-sensitive work.
+- Use `verified-component` for component-only UI proof and `verified-browser` for browser/screenshot-backed UI proof.
+- Loading, empty, error, success, retry, and cancelled states covered when relevant.
 
 ## Agent/Product Gates
 

package/references/role-dispatch-fallback.md

@@ -0,0 +1,54 @@
+# Role Dispatch Fallback
+
+Use this reference when real subagent tools are unavailable, unknown, or not appropriate for the current slice.
+
+GSE must never turn role names into fake delegation. A role packet is evidence that the work boundary was explicit; it is not evidence that a real subagent ran unless the host produced current dispatch evidence.
+
+## Required Roles
+
+The portable fallback set is:
+
+| Role | Purpose | Default write access | Fallback output |
+|---|---|---|---|
+| Planner | Define outcome, scope, acceptance, evidence, risk, and next action. | docs/state only | Slice plan with non-goals and selected gates |
+| Locator | Locate files, symbols, commands, existing tests, and ownership boundaries. | read-only | File/function/test map and relevant patterns |
+| Implementer | Make the bounded code or document change. | assigned files only | Diff summary and files changed |
+| Verifier | Run focused tests, smokes, audits, or structural checks. | evidence/test output only | Commands, results, evidence level, residual risk |
+| Reviewer | Review spec compliance, regression risk, quality, and missing tests. | read-only | Findings or explicit no-findings report |
+| Docs/Evidence | Record slice evidence, state changes, release notes, and learnings. | docs/evidence only | Evidence record and state/doc update summary |
+| Release | Check release, public, owner, CI, package, and host-runtime boundaries. | docs/release only | Release readiness and external gate summary |
+
+## Fallback Packet Requirements
+
+Every auditable role packet, whether real or sequential, must state:
+
+- Execution mode: `real-subagent`, `sequential-role`, or `handoff-session`.
+- Real delegation used: `yes` or `no`.
+- Host/tool used and tool status.
+- Fallback reason when real delegation is not used.
+- Role, objective, allowed files, forbidden files, and expected output.
+- Role output evidence.
+- Verification command or check.
+- Evidence level.
+- Stop condition.
+- Claim boundary.
+
+## Claim Boundary
+
+- `real-subagent` means a current host dispatch tool created an agent/task and returned evidence.
+- `sequential-role` means the main agent executed the role checklist locally.
+- `handoff-session` means another human or agent session owns the work after handoff.
+- File/tool parallelism is not subagent dispatch.
+- A role packet without dispatch evidence can still prove disciplined fallback, but it cannot prove real multi-agent execution.
+
+## Close Rule
+
+Before a slice closes, the coordinator should be able to answer:
+
+1. Which roles were required for this slice?
+2. Which roles ran as real delegation, sequential fallback, or handoff?
+3. What files or evidence did each role touch?
+4. What verification or review did each role produce?
+5. What claim must not be made because a tool was unavailable?
+
+`scripts/audit-close-gate.mjs` enforces the no-fake-dispatch boundary when `.gse/agents/role-fallback-packets.md` is present: a row that says real delegation was used must also have verified tool status.

package/references/tool-adapters.md

@@ -1,6 +1,8 @@
 # Tool Adapters
 
-GSE has few hard requirements. Tools enhance the workflow when available.
+GSE has few hard requirements. Tools enhance the workflow when available.
+Use markdown fallback when optional tools are unavailable.
+Do not treat optional tools as hard prerequisites.
 
 ## Minimum Tools
 
@@ -31,7 +33,7 @@ Avoid broad reads of generated outputs, logs, lockfiles, or historical archives
 
 Use `references/drift-audit.md` when recorded tool status, command assumptions, MCP, LSP/index, browser, CI, package manager, or deployment facts may be stale.
 
-Use `project-profile.md` to record tool connections and status.
+Use `.gse/project-profile.md`, `.gse/tooling.md`, and `.gse/host-capabilities.md` to record tool connections and status.
 
 Status vocabulary:
 
@@ -40,7 +42,15 @@ Status vocabulary:
 - `unknown`: not confirmed.
 - `unavailable`: expected but missing or failing.
 
-Project-specific commands and standards override generic recommendations. If the project says to use `pnpm`, `bun`, `make`, a custom smoke script, a specific LSP/index, or a private MCP server, follow that after verifying it is present or documenting its status.
+Project-specific commands and standards override generic recommendations. If the project says to use `pnpm`, `bun`, `make`, a custom smoke script, a specific LSP/index, or a private MCP server, follow that after verifying it is present or documenting its status.
+
+For the standard host/tool capability table, run:
+
+```text
+node <gse-skill>/scripts/audit-host-capabilities.mjs --target <project-root> --json
+```
+
+This audit checks native slash-command, browser, MCP, LSP/index, subagent dispatch, and CI rows. It labels missing records as a warning, but fails invalid statuses, `verified` rows without evidence, and native slash-command overclaims based only on portable command output.
 
 ## Model Routing
 

package/scripts/audit-close-gate-hardening.mjs

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+const args = process.argv.slice(2)
+
+function readArg(name, fallback = null) {
+  const index = args.indexOf(name)
+  if (index === -1) return fallback
+  return args[index + 1] ?? fallback
+}
+
+const root = path.resolve(readArg('--root', path.join(import.meta.dirname, '..')))
+const jsonOnly = args.includes('--json')
+
+function run(command, commandArgs, cwd) {
+  const result = spawnSync(command, commandArgs, {
+    cwd,
+    encoding: 'utf8',
+    windowsHide: true,
+  })
+  return {
+    command: [command, ...commandArgs].join(' '),
+    status: result.status ?? 1,
+    stdout: (result.stdout ?? '').trim(),
+    stderr: (result.stderr ?? '').trim(),
+  }
+}
+
+function runNode(script, commandArgs, cwd = root) {
+  return run(process.execPath, [path.join(root, 'scripts', script), ...commandArgs], cwd)
+}
+
+function write(filePath, text) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, text, 'utf8')
+}
+
+function rolePacket(realDelegationUsed = 'no', toolStatus = 'unknown') {
+  const plannerMode = realDelegationUsed === 'yes' ? 'real-subagent' : 'sequential-role'
+  const rows = [
+    ['Planner', plannerMode, realDelegationUsed, toolStatus, 'Plan', 'fixture plan', 'Plan accepted', 'read-only'],
+    ['Locator', 'sequential-role', 'no', 'unknown', 'File map', 'fixture map', 'Files identified', 'read-only'],
+    ['Implementer', 'sequential-role', 'no', 'unknown', 'Patch', 'fixture patch', 'Patch complete', 'assigned files'],
+    ['Verifier', 'sequential-role', 'no', 'unknown', 'Test results', 'fixture tests', 'Focused checks pass', 'evidence only'],
+    ['Reviewer', 'sequential-role', 'no', 'unknown', 'Review notes', 'fixture review', 'No blocking findings', 'read-only'],
+    ['Docs/Evidence', 'sequential-role', 'no', 'unknown', 'Evidence log', 'fixture evidence', 'Evidence recorded', 'docs/evidence only'],
+    ['Release', 'sequential-role', 'no', 'unknown', 'Claim boundary', 'fixture release', 'External gates visible', 'read-only'],
+  ]
+  return [
+    '# Role Fallback Packets',
+    '',
+    '| Role | Mode | Real delegation used | Tool status | Fallback output | Evidence | Stop condition | Write access |',
+    '|---|---|---|---|---|---|---|---|',
+    ...rows.map((row) => '| ' + row.join(' | ') + ' |'),
+    '',
+  ].join('\n')
+}
+
+function createProject(label, options = {}) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gse-close-hardening-' + label + '-'))
+  write(path.join(dir, '.gse', 'README.md'), '# GSE\n')
+  write(path.join(dir, '.gse', 'project-profile.md'), '# Project Profile\n')
+  write(path.join(dir, '.gse', 'goal-map.md'), '# Goal Map\n\nNext action: close fixture.\n')
+  write(path.join(dir, '.gse', 'quality-gates.md'), '# Quality Gates\n\n- Evidence required.\n')
+  write(path.join(dir, '.gse', 'evidence', '2026-07-08.md'), '# Evidence\n\nVerified fixture.\n')
+  write(
+    path.join(dir, '.gse', 'state.json'),
+    JSON.stringify(
+      {
+        schemaVersion: 1,
+        projectName: 'close-hardening-fixture',
+        mode: 'standard',
+        phase: 'verify',
+        currentSlice: {
+          id: 'close-hardening-fixture',
+          outcome: 'Fixture close gate hardening.',
+          status: 'verified',
+          nextAction: 'Close fixture.',
+        },
+        toolStatuses: {
+          browser: 'unknown',
+          lsp: 'unknown',
+          mcp: 'unknown',
+          subagents: 'unknown',
+          ci: 'unknown',
+        },
+        lastEvidence: '.gse/evidence/2026-07-08.md',
+        residualRisks: [],
+      },
+      null,
+      2,
+    ) + '\n',
+  )
+  write(
+    path.join(dir, '.gse', 'evidence', 'index.jsonl'),
+    JSON.stringify({
+      date: '2026-07-08',
+      recordType: 'slice',
+      status: 'verified',
+      evidenceLevel: 'verified-unit',
+      requiredEvidenceLevel: 'verified-unit',
+      summary: 'Fixture close gate hardening evidence.',
+      evidenceFile: '.gse/evidence/2026-07-08.md',
+      commands: ['node scripts/audit-close-gate.mjs --target <fixture> --json'],
+      nextAction: 'Close fixture.',
+    }) + '\n',
+  )
+  write(
+    path.join(dir, '.gse', 'agents', 'role-fallback-packets.md'),
+    rolePacket(options.realDelegationUsed ?? 'no', options.toolStatus ?? 'unknown'),
+  )
+  run('git', ['init'], dir)
+  run('git', ['config', 'user.email', 'gse-fixture@example.local'], dir)
+  run('git', ['config', 'user.name', 'GSE Fixture'], dir)
+  run('git', ['add', '.'], dir)
+  run('git', ['commit', '-m', 'fixture'], dir)
+  return dir
+}
+
+function parseReport(result) {
+  try {
+    return JSON.parse(result.stdout)
+  } catch (error) {
+    return { parseError: error.message, stdout: result.stdout, stderr: result.stderr }
+  }
+}
+
+function getCheck(report, id) {
+  return report.checks?.find((item) => item.id === id) ?? null
+}
+
+function check(id, label, ok, evidence, risk = '') {
+  return { id, label, status: ok ? 'passed' : 'failed', evidence, risk }
+}
+
+const cleanDir = createProject('clean')
+const fakeDir = createProject('fake-dispatch', { realDelegationUsed: 'yes', toolStatus: 'unknown' })
+const dirtyDir = createProject('dirty')
+write(path.join(dirtyDir, 'src', 'changed.txt'), 'dirty fixture\n')
+const generatedDir = createProject('generated')
+write(path.join(generatedDir, 'output', 'playwright', 'screen.png'), 'generated artifact\n')
+run('git', ['add', 'output/playwright/screen.png'], generatedDir)
+
+const cleanReport = parseReport(runNode('audit-close-gate.mjs', ['--target', cleanDir, '--json']))
+const fakeReport = parseReport(runNode('audit-close-gate.mjs', ['--target', fakeDir, '--json']))
+const dirtyReport = parseReport(runNode('audit-close-gate.mjs', ['--target', dirtyDir, '--json']))
+const generatedReport = parseReport(runNode('audit-close-gate.mjs', ['--target', generatedDir, '--json']))
+
+const checks = [
+  check('CGH01', 'clean fixture close gate is ready with honest role fallback', cleanReport.summary?.status === 'ready' && getCheck(cleanReport, 'CG10')?.status === 'passed' && getCheck(cleanReport, 'CG11')?.status === 'passed' && getCheck(cleanReport, 'CG12')?.status === 'passed', 'clean close gate fixture'),
+  check('CGH02', 'fake real-subagent claim fails close gate', fakeReport.summary?.status === 'not-ready' && getCheck(fakeReport, 'CG10')?.status === 'failed', getCheck(fakeReport, 'CG10')?.evidence ?? 'missing CG10'),
+  check('CGH03', 'dirty worktree is surfaced before close', dirtyReport.summary?.status === 'ready-with-warnings' && getCheck(dirtyReport, 'CG11')?.status === 'warning', getCheck(dirtyReport, 'CG11')?.evidence ?? 'missing CG11'),
+  check('CGH04', 'staged generated artifacts fail close gate', generatedReport.summary?.status === 'not-ready' && getCheck(generatedReport, 'CG12')?.status === 'failed', getCheck(generatedReport, 'CG12')?.evidence ?? 'missing CG12'),
+]
+
+for (const dir of [cleanDir, fakeDir, dirtyDir, generatedDir]) {
+  fs.rmSync(dir, { recursive: true, force: true })
+}
+
+const passed = checks.filter((item) => item.status === 'passed').length
+const failed = checks.length - passed
+const report = {
+  root,
+  generatedAt: new Date().toISOString(),
+  summary: {
+    status: failed === 0 ? 'passed' : 'failed',
+    passed,
+    failed,
+    total: checks.length,
+  },
+  workflows: {
+    closeGateHardening: failed === 0 ? 'verified' : 'failed',
+    fakeDispatchCloseGate: failed === 0 ? 'verified' : 'failed',
+    fileOwnershipCloseGate: failed === 0 ? 'verified' : 'failed',
+  },
+  checks,
+  limits: [
+    'This audit verifies close-gate mechanics with local fixtures.',
+    'It does not prove real subagent dispatch or native slash-command host support.',
+  ],
+}
+
+if (jsonOnly) console.log(JSON.stringify(report, null, 2))
+else console.log(JSON.stringify(report, null, 2))
+if (failed > 0) process.exit(1)