@t275005746/gse 0.1.1 → 0.1.2

package/scripts/audit-completion-plan-drill.mjs

@@ -0,0 +1,230 @@
+#!/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 parseJson(text) {
+  try { return JSON.parse(text) } catch { return null }
+}
+
+function check(id, label, ok, evidence, risk = '') {
+  return { id, label, status: ok ? 'passed' : 'failed', evidence, risk }
+}
+
+function write(filePath, text) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, text, 'utf8')
+}
+
+function createFixture() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gse-completion-plan-drill-'))
+  write(path.join(dir, 'package.json'), JSON.stringify({ scripts: { 'check:encoding': 'node scripts/check-encoding.mjs' } }, null, 2) + '\n')
+  write(path.join(dir, 'scripts', 'run-gse-command.mjs'), '#!/usr/bin/env node\n')
+  write(path.join(dir, 'scripts', 'check-encoding.mjs'), '#!/usr/bin/env node\n')
+  write(path.join(dir, 'references', 'final-readiness.md'), '# Final Readiness\n')
+  write(path.join(dir, 'docs', 'productization-architecture.md'), '# Productization\n')
+  write(path.join(dir, '.gse', 'README.md'), '# GSE\n')
+  write(path.join(dir, '.gse', 'project-profile.md'), '# Project Profile\n\n- Product/system name: Completion Plan Fixture\n')
+  write(path.join(dir, '.gse', 'goal-map.md'), '# Goal Map\n\n- Active slice: Completion plan fixture.\n- Next action: Run completion plan drill.\n')
+  write(path.join(dir, '.gse', 'quality-gates.md'), '# Quality Gates\n\n- Evidence required.\n')
+  write(path.join(dir, '.gse', 'session-sync.jsonl'), '')
+  write(path.join(dir, '.gse', 'state.json'), JSON.stringify({
+    schemaVersion: 1,
+    projectName: 'completion-plan-fixture',
+    mode: 'standard',
+    canonicalPlan: 'docs/productization-architecture.md',
+    phase: 'execute',
+    currentSlice: {
+      id: 'completion-plan-fixture',
+      outcome: 'Completion plan fixture.',
+      status: 'planned',
+      nextAction: 'Run completion plan drill.',
+    },
+    toolStatuses: { browser: 'unknown', lsp: 'unknown', mcp: 'unknown', subagents: 'unknown', ci: 'unknown' },
+    lastEvidence: '.gse/evidence/2026-07-09.md',
+    residualRisks: [],
+  }, null, 2) + '\n')
+  write(path.join(dir, '.gse', 'evidence', 'index.jsonl'), JSON.stringify({
+    date: '2026-07-09',
+    recordType: 'slice',
+    status: 'verified',
+    evidenceLevel: 'verified-unit',
+    requiredEvidenceLevel: 'verified-unit',
+    summary: 'Completion plan fixture evidence.',
+    evidenceFile: '.gse/evidence/2026-07-09.md',
+    commands: ['fixture'],
+    nextAction: 'Run completion plan drill.',
+  }) + '\n')
+  write(path.join(dir, '.gse', 'evidence', '2026-07-09.md'), '# Evidence\n')
+  write(path.join(dir, '.gse', 'maintenance', 'latest-maintenance-snapshot.json'), JSON.stringify({
+    schemaVersion: 1,
+    root: dir,
+    target: dir,
+    generatedAt: '2026-07-09T00:00:00.000Z',
+    summary: { status: 'passed', passed: 9, failed: 0, total: 9, installedSyncMode: 'verified', releaseBundleChecked: true },
+    workflows: { maintenanceSnapshot: 'verified', installedSync: 'verified', releaseBundleFreshness: 'verified' },
+    results: [],
+  }, null, 2) + '\n')
+
+  run('git', ['init'], dir)
+  run('git', ['config', 'user.email', 'gse-fixture@example.invalid'], dir)
+  run('git', ['config', 'user.name', 'GSE Fixture'], dir)
+  run('git', ['add', '.'], dir)
+  run('git', ['commit', '-m', 'baseline'], dir)
+  return dir
+}
+
+function continuePacket(target) {
+  const result = run(process.execPath, [path.join(root, 'scripts', 'generate-continue-packet.mjs'), '--root', root, '--target', target, '--json'], root)
+  return { result, data: parseJson(result.stdout) }
+}
+
+function activeIds(data) {
+  return (data?.compactState?.completionPlan?.conditionalCloseCommands ?? [])
+    .filter((item) => item.active)
+    .map((item) => item.id)
+    .sort()
+}
+
+function hasExactly(data, expected) {
+  const actual = activeIds(data)
+  const sortedExpected = [...expected].sort()
+  return actual.length === sortedExpected.length && actual.every((item, index) => item === sortedExpected[index])
+}
+
+function drill(label, mutate, expectedActiveIds) {
+  const fixture = createFixture()
+  try {
+    if (mutate) mutate(fixture)
+    const { result, data } = continuePacket(fixture)
+    return {
+      label,
+      command: result.command,
+      status: result.status,
+      expectedActiveIds: [...expectedActiveIds].sort(),
+      actualActiveIds: activeIds(data),
+      activeCommands: data?.compactState?.completionPlan?.activeCloseCommands ?? [],
+      changedPaths: data?.compactState?.completionPlan?.changedPaths ?? [],
+      ignoredGeneratedPaths: data?.compactState?.completionPlan?.ignoredGeneratedPaths ?? [],
+      ignoredGeneratedPathCount: data?.compactState?.completionPlan?.ignoredGeneratedPathCount ?? 0,
+      ok: result.status === 0 && hasExactly(data, expectedActiveIds),
+    }
+  } finally {
+    fs.rmSync(fixture, { recursive: true, force: true })
+  }
+}
+
+const drills = [
+  drill('clean worktree activates no conditionals', null, []),
+  drill('docs change activates encoding only', (dir) => { write(path.join(dir, 'docs', 'usage.md'), '# Usage\n') }, ['encoding']),
+  drill('script capability change activates installed sync, maintenance, and session sync', (dir) => { write(path.join(dir, 'scripts', 'new-capability.mjs'), '#!/usr/bin/env node\n') }, ['installed-sync', 'maintenance-snapshot', 'session-sync']),
+  drill('reference change activates docs, capability, release, maintenance, and session sync checks', (dir) => { write(path.join(dir, 'references', 'new-reference.md'), '# Reference\n') }, ['encoding', 'installed-sync', 'maintenance-snapshot', 'release-bundle', 'session-sync']),
+  drill('public acceptance change activates encoding, release bundle, and maintenance only', (dir) => { write(path.join(dir, '.gse', 'acceptance', 'new-acceptance.md'), '# Acceptance\n') }, ['encoding', 'maintenance-snapshot', 'release-bundle']),
+  drill('evidence index change activates encoding only', (dir) => {
+    fs.appendFileSync(path.join(dir, '.gse', 'evidence', 'index.jsonl'), JSON.stringify({
+      date: '2026-07-09',
+      recordType: 'drill',
+      status: 'verified',
+      evidenceLevel: 'verified-unit',
+      requiredEvidenceLevel: 'verified-unit',
+      summary: 'Additional drill evidence.',
+      evidenceFile: '.gse/evidence/2026-07-09.md',
+      commands: ['fixture'],
+      nextAction: 'Continue drill.',
+    }) + '\n', 'utf8')
+  }, ['encoding']),
+  drill('untracked generated artifacts stay visible but activate no conditionals', (dir) => {
+    write(path.join(dir, 'node_modules', '.bin', 'tool'), '')
+    write(path.join(dir, 'pnpm-lock.yaml'), 'lockfileVersion: 9.0\n')
+  }, []),
+  drill('tracked lockfile change remains actionable', (dir) => {
+    write(path.join(dir, 'pnpm-lock.yaml'), 'lockfileVersion: 9.0\n')
+    run('git', ['add', 'pnpm-lock.yaml'], dir)
+    run('git', ['commit', '-m', 'add tracked lockfile'], dir)
+    write(path.join(dir, 'pnpm-lock.yaml'), 'lockfileVersion: 9.0\nsettings:\n  strictPeerDependencies: false\n')
+  }, ['encoding']),
+]
+
+const checks = [
+  check('CPD01', 'clean worktree does not falsely activate conditional close commands', drills[0].ok, drills[0].actualActiveIds.join(',') || 'none'),
+  check('CPD02', 'docs-only dirty worktree activates encoding only', drills[1].ok, `actual=${drills[1].actualActiveIds.join(',') || 'none'}`),
+  check('CPD03', 'script capability changes activate installed-sync, maintenance, and session-sync without encoding', drills[2].ok, `actual=${drills[2].actualActiveIds.join(',') || 'none'}`),
+  check('CPD04', 'reference changes activate all relevant docs/capability/release close checks', drills[3].ok, `actual=${drills[3].actualActiveIds.join(',') || 'none'}`),
+  check('CPD05', 'public acceptance changes activate release checks without installed/session sync', drills[4].ok, `actual=${drills[4].actualActiveIds.join(',') || 'none'}`),
+  check('CPD06', 'evidence index changes activate encoding without release/capability checks', drills[5].ok, `actual=${drills[5].actualActiveIds.join(',') || 'none'}`),
+  check('CPD07', 'generated/noisy untracked paths do not activate conditional close commands', drills[6].ok && drills[6].changedPaths.length === 0 && drills[6].ignoredGeneratedPathCount >= 2, `actual=${drills[6].actualActiveIds.join(',') || 'none'} ignored=${drills[6].ignoredGeneratedPaths.join(',') || 'none'}`),
+  check('CPD08', 'tracked lockfile changes remain actionable and can trigger configured close checks', drills[7].ok && drills[7].changedPaths.includes('pnpm-lock.yaml') && drills[7].ignoredGeneratedPathCount === 0, `actual=${drills[7].actualActiveIds.join(',') || 'none'} changed=${drills[7].changedPaths.join(',') || 'none'}`),
+  check('CPD09', 'non-release capability maintenance uses skip-release-bundle', drills[2].activeCommands.some((item) => item.includes('generate-maintenance-snapshot.mjs') && item.includes('--skip-release-bundle')), drills[2].activeCommands.join(' | ')),
+  check('CPD10', 'release-sensitive maintenance keeps full release bundle freshness', drills[3].activeCommands.some((item) => item.includes('generate-maintenance-snapshot.mjs') && !item.includes('--skip-release-bundle')), drills[3].activeCommands.join(' | ')),
+]
+
+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: {
+    completionPlanDrill: failed === 0 ? 'verified' : 'failed',
+    cleanWorktreeFalsePositiveGuard: drills[0].ok ? 'verified' : 'failed',
+    dirtyWorktreeConditionalRouting: failed === 0 ? 'verified' : 'failed',
+  },
+  drills,
+  checks,
+  limits: [
+    'This audit verifies portable /gse continue completionPlan routing in temporary git fixtures.',
+    'It does not execute the close commands; it verifies whether the correct commands become active for each worktree state.',
+    'Native host slash-command behavior remains a host-specific adapter claim and is not covered by this drill.',
+  ],
+}
+
+function renderMarkdown(data) {
+  const lines = []
+  lines.push('# GSE Completion Plan Drill Audit')
+  lines.push('')
+  lines.push('Generated: ' + data.generatedAt)
+  lines.push('Root: ' + data.root)
+  lines.push('')
+  lines.push('## Summary')
+  lines.push('')
+  lines.push('- Status: ' + data.summary.status)
+  lines.push('- Checks: ' + data.summary.passed + '/' + data.summary.total)
+  lines.push('')
+  lines.push('## Drills')
+  lines.push('')
+  for (const item of data.drills) {
+    lines.push('- ' + (item.ok ? '[x]' : '[ ]') + ' ' + item.label + ': expected `' + item.expectedActiveIds.join(',') + '`, actual `' + item.actualActiveIds.join(',') + '`')
+  }
+  lines.push('')
+  lines.push('## Limits')
+  lines.push('')
+  for (const item of data.limits) lines.push('- ' + item)
+  return lines.join('\n') + '\n'
+}
+
+if (jsonOnly) console.log(JSON.stringify(report, null, 2))
+else console.log(renderMarkdown(report))
+
+if (failed > 0) process.exit(1)

package/scripts/audit-completion-readiness.mjs

@@ -100,8 +100,9 @@ const localCapabilityAudits = [
   'audit-release-owner-action-plan.mjs',
   'audit-public-release-checklist.mjs',
   'audit-release-owner-action-plan-drill.mjs',
-  'audit-final-form-progress-report.mjs',
-  'audit-local-final-form-completion.mjs',
+  'audit-final-form-progress-report.mjs',
+  'audit-final-form-roadmap.mjs',
+  'audit-local-final-form-completion.mjs',
   'audit-final-form-stale-copy.mjs',
   'audit-npm-tarball-install.mjs',
   'audit-npm-publish-dry-run.mjs',
@@ -206,9 +207,11 @@ const requiredArtifacts = [
   'scripts/generate-public-release-checklist.mjs',
   'scripts/audit-public-release-checklist.mjs',
   'scripts/audit-release-owner-action-plan-drill.mjs',
-  'scripts/generate-final-form-progress-report.mjs',
-  'scripts/audit-final-form-progress-report.mjs',
-  'scripts/audit-local-final-form-completion.mjs',
+  'scripts/generate-final-form-progress-report.mjs',
+  'scripts/audit-final-form-progress-report.mjs',
+  'references/final-form-roadmap.md',
+  'scripts/audit-final-form-roadmap.mjs',
+  'scripts/audit-local-final-form-completion.mjs',
   'scripts/audit-final-form-stale-copy.mjs',
   'scripts/audit-npm-tarball-install.mjs',
   'scripts/audit-npm-publish-dry-run.mjs',
@@ -240,7 +243,7 @@ const checks = [
   check('CR05', 'current slice preserves required GSE slice fields after acceptance', currentSlice.includes('## Outcome') && currentSlice.includes('## Scope') && currentSlice.includes('## Acceptance') && currentSlice.includes('## Evidence Plan') && currentSlice.includes('## Risk') && currentSlice.includes('## Next Action'), '.gse/current-slice.md'),
   check('CR06', 'goal map records v1 execution-state work as verified', goalMap.includes('GSE-008') && goalMap.includes('Productize v1.0 execution-state workflow') && goalMap.includes('verified') && goalMap.includes('audit-v1-target-validation.mjs'), '.gse/goal-map.md'),
   check('CR07', 'evidence log records owner-approved external acceptance', ownerAcceptanceRecorded, '.gse/evidence/2026-07-05.md'),
-  check('CR08', 'final-form limits are explicit after current scope can be claimed', masterPlan.includes('Remaining final-form work is host-native slash-command support with real host runtime evidence.') && goalMap.includes('Final-form gaps'), 'control docs keep final-form limits scoped'),
+  check('CR08', 'final-form limits are explicit after current scope can be claimed', masterPlan.includes('The Final Form Roadmap now lives in `references/final-form-roadmap.md`') && masterPlan.includes('live claim boundary') && (goalMap.includes('Native slash command') || goalMap.includes('host-native slash-command support')) && goalMap.includes('Final-form gaps'), 'control docs keep final-form limits scoped'),
 ]
 
 const passed = checks.filter((item) => item.status === 'passed').length

package/scripts/audit-continue-preflight.mjs

@@ -0,0 +1,234 @@
+#!/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(script, commandArgs) {
+  const result = spawnSync(process.execPath, [path.join(root, 'scripts', script), ...commandArgs], {
+    cwd: root,
+    encoding: 'utf8',
+    windowsHide: true,
+  })
+  return {
+    command: [process.execPath, path.join(root, 'scripts', script), ...commandArgs].join(' '),
+    status: result.status ?? 1,
+    stdout: (result.stdout ?? '').trim(),
+    stderr: (result.stderr ?? '').trim(),
+  }
+}
+
+function parseJson(text) {
+  try {
+    return JSON.parse(text)
+  } catch {
+    return null
+  }
+}
+
+function check(id, label, ok, evidence, risk = '') {
+  return { id, label, status: ok ? 'passed' : 'failed', evidence, risk }
+}
+
+function fixture(invalidEvidence = false) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gse-continue-audit-'))
+  fs.mkdirSync(path.join(dir, '.gse', 'evidence'), { recursive: true })
+  fs.mkdirSync(path.join(dir, '.gse', 'maintenance'), { recursive: true })
+  fs.mkdirSync(path.join(dir, 'scripts'), { recursive: true })
+  fs.mkdirSync(path.join(dir, 'references'), { recursive: true })
+  fs.mkdirSync(path.join(dir, 'docs'), { recursive: true })
+  fs.writeFileSync(path.join(dir, '.gse', 'README.md'), '# GSE\n', 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'project-profile.md'), '# Project Profile\n\n- Product/system name: Continue Fixture\n', 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'goal-map.md'), '# Goal Map\n\n- Active slice: Continue fixture.\n- Next action: Run continue audit.\n', 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'quality-gates.md'), '# Quality Gates\n\n- Evidence required.\n', 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'session-sync.jsonl'), '', 'utf8')
+  fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ scripts: { 'check:encoding': 'node scripts/check-encoding.mjs' } }, null, 2) + '\n', 'utf8')
+  fs.writeFileSync(path.join(dir, 'scripts', 'run-gse-command.mjs'), '#!/usr/bin/env node\n', 'utf8')
+  fs.writeFileSync(path.join(dir, 'references', 'final-readiness.md'), '# Final Readiness\n', 'utf8')
+  fs.writeFileSync(path.join(dir, 'docs', 'productization-architecture.md'), '# Productization\n', 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'state.json'), JSON.stringify({
+    schemaVersion: 1,
+    projectName: 'continue-fixture',
+    mode: 'standard',
+    canonicalPlan: 'docs/productization-architecture.md',
+    phase: 'execute',
+    currentSlice: {
+      id: 'continue-fixture',
+      outcome: 'Continue fixture.',
+      status: 'planned',
+      nextAction: 'Run continue audit.',
+    },
+    toolStatuses: {
+      browser: 'unknown',
+      lsp: 'unknown',
+      mcp: 'unknown',
+      subagents: 'unknown',
+      ci: 'unknown',
+    },
+    lastEvidence: '.gse/evidence/2026-07-08.md',
+    residualRisks: ['risk one', 'risk two', 'risk three', 'risk four'],
+    riskArchive: [
+      {
+        archivedAt: '2026-07-08',
+        risk: 'archived risk',
+        resolution: 'fixture resolution',
+      },
+    ],
+  }, null, 2) + '\n', 'utf8')
+  fs.writeFileSync(
+    path.join(dir, '.gse', 'evidence', 'index.jsonl'),
+    invalidEvidence
+      ? '{"date":"2026-07-08"\n'
+      : JSON.stringify({
+        date: '2026-07-08',
+        recordType: 'slice',
+        status: 'verified',
+        evidenceLevel: 'verified-unit',
+        requiredEvidenceLevel: 'verified-unit',
+        summary: 'Continue fixture evidence.',
+        evidenceFile: '.gse/evidence/2026-07-08.md',
+        commands: ['fixture'],
+        nextAction: 'Run continue audit.',
+      }) + '\n',
+    'utf8',
+  )
+  fs.writeFileSync(path.join(dir, '.gse', 'evidence', '2026-07-08.md'), '# Evidence\n', 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'maintenance', 'latest-maintenance-snapshot.json'), JSON.stringify({
+    schemaVersion: 1,
+    root: dir,
+    target: dir,
+    installedRoot: null,
+    generatedAt: '2026-07-08T00:00:00.000Z',
+    summary: {
+      status: 'passed',
+      passed: 9,
+      failed: 0,
+      total: 9,
+      installedSyncMode: 'package-only',
+      releaseBundleChecked: false,
+    },
+    workflows: {
+      maintenanceSnapshot: 'verified',
+      installedSync: 'package-only',
+      releaseBundleFreshness: 'skipped',
+    },
+    results: [],
+  }, null, 2) + '\n', 'utf8')
+  spawnSync('git', ['init'], { cwd: dir, encoding: 'utf8', windowsHide: true })
+  return dir
+}
+
+function verifiedSliceFixture() {
+  const dir = fixture(false)
+  const statePath = path.join(dir, '.gse', 'state.json')
+  const goalMapPath = path.join(dir, '.gse', 'goal-map.md')
+  const state = JSON.parse(fs.readFileSync(statePath, 'utf8'))
+  state.currentSlice.status = 'verified'
+  state.currentSlice.nextAction = 'Open the next fixture slice with a deliberately long machine-readable reason that should remain available to successor agents even when the display reason is compacted for the short entry prompt and JSON packet overview.'
+  state.residualRisks = [
+    'A deliberately long actionable risk should become the first next-slice candidate when the current next action is only a meta instruction, because successor agents need concrete work instead of a process reminder.',
+  ]
+  fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf8')
+  fs.writeFileSync(goalMapPath, '# Goal Map\n\n- Active slice: Continue fixture verified.\n- Next action: Open the next fixture slice with a deliberately long machine-readable reason that should remain available to successor agents even when the display reason is compacted for the short entry prompt and JSON packet overview.\n', 'utf8')
+  return dir
+}
+
+const validFixture = fixture(false)
+const invalidFixture = fixture(true)
+const verifiedFixture = verifiedSliceFixture()
+const directValid = run('generate-continue-packet.mjs', ['--root', root, '--target', validFixture, '--json'])
+const directInvalid = run('generate-continue-packet.mjs', ['--root', root, '--target', invalidFixture, '--json'])
+const directVerified = run('generate-continue-packet.mjs', ['--root', root, '--target', verifiedFixture, '--json'])
+const commandValid = run('run-gse-command.mjs', ['--root', root, '--target', validFixture, '--command', '/gse continue', '--json'])
+const commandCompact = run('run-gse-command.mjs', ['--root', root, '--target', validFixture, '--command', '/gse continue', '--json', '--compact'])
+const commandInvalid = run('run-gse-command.mjs', ['--root', root, '--target', invalidFixture, '--command', '/gse continue', '--json'])
+const gseSelf = run('run-gse-command.mjs', ['--root', root, '--target', root, '--command', '/gse continue', '--json', '--compact'])
+
+const validData = parseJson(directValid.stdout)
+const invalidData = parseJson(directInvalid.stdout)
+const verifiedData = parseJson(directVerified.stdout)
+const commandValidData = parseJson(commandValid.stdout)
+const commandCompactData = parseJson(commandCompact.stdout)
+const commandInvalidData = parseJson(commandInvalid.stdout)
+const gseSelfData = parseJson(gseSelf.stdout)
+const runnerSource = fs.readFileSync(path.join(root, 'scripts', 'run-gse-command.mjs'), 'utf8')
+const skillSource = fs.readFileSync(path.join(root, 'SKILL.md'), 'utf8')
+const commandsSource = fs.readFileSync(path.join(root, 'references', 'commands.md'), 'utf8')
+const promptLines = String(validData?.prompt ?? '').split(/\r?\n/).filter(Boolean)
+
+const checks = [
+  check('CPF01', 'continue packet generator exists', fs.existsSync(path.join(root, 'scripts', 'generate-continue-packet.mjs')), 'scripts/generate-continue-packet.mjs'),
+  check('CPF02', '/gse continue routes through continue packet generator', runnerSource.includes("runNode('generate-continue-packet.mjs'") && runnerSource.includes("route: 'scripts/generate-continue-packet.mjs'"), 'scripts/run-gse-command.mjs'),
+  check('CPF03', 'valid fixture returns passed preflight and compact active-risk state', directValid.status === 0 && validData?.summary?.status === 'passed' && validData?.compactState?.riskCount === 4 && validData?.compactState?.activeRiskCount === 4 && validData?.compactState?.archivedRiskCount === 1 && validData?.compactState?.totalRiskCount === 5 && validData?.compactState?.topRisks?.length === 3, directValid.command),
+  check('CPF04', 'bad evidence index is a hard preflight failure', directInvalid.status !== 0 && invalidData?.summary?.status === 'failed' && invalidData?.preflight?.failures?.some((item) => item.id === 'CP03'), directInvalid.command),
+  check('CPF04b', 'bad evidence index returns concrete repair actions before implementation', directInvalid.status !== 0 && invalidData?.preflight?.failures?.some((item) => item.id === 'CP15') && invalidData?.compactState?.stateRepair?.repairActions?.some((item) => item.id === 'SR03'), directInvalid.command),
+  check('CPF05', 'portable /gse continue exposes structured preflight wrapper', commandValid.status === 0 && commandValidData?.execution?.command?.includes('generate-continue-packet.mjs') && commandValidData?.execution?.stdout?.includes('"compactState"'), commandValid.command),
+  check('CPF06', 'compact mode returns packet without wrapper diagnostics', commandCompact.status === 0 && commandCompactData?.compactState?.projectName === 'continue-fixture' && !commandCompact.stdout.includes('"execution"'), commandCompact.command),
+  check('CPF07', 'portable command fails when preflight has hard failures', commandInvalid.status !== 0 && commandInvalidData?.execution?.status !== 0 && commandInvalidData?.execution?.stdout?.includes('"status": "failed"'), commandInvalid.command),
+  check('CPF08', 'GSE self continue surfaces final acceptance status without treating optional host-native claims as blocked gates', gseSelf.status === 0 && ['passed', 'warning'].includes(gseSelfData?.summary?.status) && (gseSelfData?.compactState?.blockedGates?.length ?? 0) === 0 && gseSelfData?.ownerExternalGateSummary?.publicAccepted === 'verified', gseSelf.command),
+  check('CPF09', 'SKILL.md routes short continuation to hard preflight packet', skillSource.includes('generate-continue-packet.mjs') && skillSource.includes('Short continuation packet'), 'SKILL.md'),
+  check('CPF10', 'commands reference documents hard preflight semantics', commandsSource.includes('hard preflight') && commandsSource.includes('generate-continue-packet.mjs'), 'references/commands.md'),
+  check('CPF11b', 'continue packet surfaces historical evidence review queue', validData?.preflight?.checks?.some((item) => item.id === 'CP13') && validData?.compactState?.evidenceReviewQueue && typeof validData.compactState.evidenceReviewQueue.needsReview === 'number', 'compactState.evidenceReviewQueue'),
+  check('CPF11', 'continue packet surfaces state repair readiness', validData?.preflight?.checks?.some((item) => item.id === 'CP15') && validData?.compactState?.stateRepair?.status === 'clean', 'scripts/generate-continue-packet.mjs'),
+  check('CPF12', 'continue packet surfaces latest maintenance snapshot freshness', validData?.preflight?.checks?.some((item) => item.id === 'CP20') && validData?.compactState?.maintenanceSnapshot?.status === 'passed' && validData?.compactState?.maintenanceSnapshot?.installedSync === 'package-only', 'scripts/generate-continue-packet.mjs'),
+  check('CPF13', 'continue packet keeps owner/external records out of core workflow blockers', validData?.limits?.some((item) => item.includes('not GSE core workflow blockers')) && !validData?.limits?.some((item) => item.includes('block final acceptance')) && !fs.readFileSync(path.join(root, 'scripts', 'generate-continue-packet.mjs'), 'utf8').includes('Blocked final-acceptance gates'), 'scripts/generate-continue-packet.mjs'),
+  check('CPF14', 'continue packet exposes exact completion plan and close commands', Array.isArray(validData?.compactState?.completionPlan?.requiredCloseCommands) && validData.compactState.completionPlan.requiredCloseCommands.some((item) => item.includes('run-validation-profile.mjs')) && validData.compactState.completionPlan.requiredCloseCommands.some((item) => item.includes('/gse close')) && validData.compactState.completionPlan.requiredSteps.some((item) => item.includes('evidence/index.jsonl')), 'compactState.completionPlan'),
+  check('CPF15', 'continue packet activates conditional close commands from detected changed capability/docs/release files', validData?.compactState?.completionPlan?.conditionalCloseCommands?.some((item) => item.id === 'encoding' && item.active && item.command.includes('pnpm check:encoding')) && validData?.compactState?.completionPlan?.conditionalCloseCommands?.some((item) => item.id === 'installed-sync' && item.active && item.command.includes('audit-installed-sync.mjs')) && validData?.compactState?.completionPlan?.conditionalCloseCommands?.some((item) => item.id === 'release-bundle' && item.active && item.command.includes('generate-release-bundle.mjs')) && validData?.compactState?.completionPlan?.conditionalCloseCommands?.some((item) => item.id === 'session-sync' && item.active && item.command.includes('audit-session-sync.mjs')), 'compactState.completionPlan.conditionalCloseCommands'),
+  check('CPF16', 'continue packet exposes core/release/host-adapter gate taxonomy', validData?.compactState?.gateTaxonomy?.core?.blocking === true && validData?.compactState?.gateTaxonomy?.release?.scope?.includes('public release') && validData?.compactState?.gateTaxonomy?.hostAdapter?.scope?.includes('native slash-command') && validData?.compactState?.gateTaxonomy?.rule?.includes('block only the specific public, release, or host claim'), 'compactState.gateTaxonomy'),
+  check('CPF17', 'continue packet prompt is short-entry actionable instead of long-goal prose', promptLines.length <= 6 && validData?.prompt?.includes('GSE continue:') && validData?.prompt?.includes('Root:') && validData?.prompt?.includes('Slice:') && validData?.prompt?.includes('Next:') && validData?.prompt?.includes('Mode: continue-current-slice') && validData?.prompt?.includes('Do: one verifiable slice') && validData?.prompt?.includes('risks=4 active/1 archived') && !validData?.prompt?.includes('Run one verifiable slice, record evidence'), 'compact prompt line count and required action fields'),
+  check('CPF18', 'verified current slice switches short entry into open-next-slice mode', directVerified.status === 0 && verifiedData?.compactState?.nextSliceMode?.action === 'open-next-slice' && verifiedData?.compactState?.nextSliceMode?.currentSliceVerified === true && verifiedData?.prompt?.includes('Mode: open-next-slice'), directVerified.command),
+  check('CPF19', 'verified current slice exposes machine-readable next-slice candidates', directVerified.status === 0 && Array.isArray(verifiedData?.compactState?.nextSliceCandidates) && verifiedData.compactState.nextSliceCandidates.length >= 1 && verifiedData.compactState.nextSliceCandidates.every((item) => item.id && item.title && item.source && item.reason && item.fullReason && item.acceptanceHint && item.suggestedProfile), 'compactState.nextSliceCandidates'),
+  check('CPF20', 'unverified slice does not force next-slice candidates', directValid.status === 0 && validData?.compactState?.nextSliceMode?.action === 'continue-current-slice' && Array.isArray(validData?.compactState?.nextSliceCandidates) && validData.compactState.nextSliceCandidates.length === 0, 'compactState.nextSliceCandidates'),
+  check('CPF21', 'next-slice candidates do not claim native slash-command support', directVerified.status === 0 && !JSON.stringify(verifiedData?.compactState?.nextSliceCandidates ?? []).toLowerCase().includes('native slash-command'), 'compactState.nextSliceCandidates claim boundary'),
+  check('CPF22', 'next-slice candidates keep full machine reasons separate from short display reasons', directVerified.status === 0 && verifiedData?.compactState?.nextSliceCandidates?.every((item) => item.fullReason.length >= item.reason.length) && verifiedData?.compactState?.nextSliceCandidates?.some((item) => item.fullReason.length > item.reason.length), 'compactState.nextSliceCandidates.fullReason'),
+  check('CPF23', 'next-slice candidates prefer concrete gaps over meta open-next-slice reminders', directVerified.status === 0 && verifiedData?.compactState?.nextSliceCandidates?.[0]?.source === '.gse/state.json residualRisks' && !verifiedData.compactState.nextSliceCandidates[0].fullReason.toLowerCase().includes('open the next fixture slice'), 'compactState.nextSliceCandidates ranking'),
+  check('CPF24', 'next-slice candidates include structured action packets for short-entry takeover', directVerified.status === 0 && verifiedData?.compactState?.nextSliceCandidates?.every((item) => item.actionPacket?.candidateType && item.actionPacket?.outcomeHint && item.actionPacket?.scopeHint && item.actionPacket?.acceptanceHint && item.actionPacket?.evidenceHint && item.actionPacket?.riskHint && item.actionPacket?.nextActionHint && Array.isArray(item.actionPacket?.focusedChecks) && item.actionPacket.focusedChecks.length >= 1), 'compactState.nextSliceCandidates.actionPacket'),
+  check('CPF25', 'continue packet separates session sync evidence from target-session adoption', validData?.preflight?.checks?.some((item) => item.id === 'CP21') && validData?.compactState?.sessionSyncBoundary?.boundary === 'sync-records-do-not-prove-adoption' && validData?.compactState?.sessionSyncBoundary?.adoptionProven === false && validData?.compactState?.sessionSyncBoundary?.limits?.some((item) => item.includes('not target-session adoption')), 'compactState.sessionSyncBoundary'),
+]
+
+fs.rmSync(validFixture, { recursive: true, force: true })
+fs.rmSync(invalidFixture, { recursive: true, force: true })
+fs.rmSync(verifiedFixture, { 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: {
+    continueHardPreflight: failed === 0 ? 'verified' : 'failed',
+    stateCompaction: failed === 0 ? 'verified' : 'failed',
+    ownerExternalGateBoundary: failed === 0 ? 'verified' : 'failed',
+    completionPlan: failed === 0 ? 'verified' : 'failed',
+    gateTaxonomy: failed === 0 ? 'verified' : 'failed',
+    shortEntryPrompt: failed === 0 ? 'verified' : 'failed',
+    nextSliceMode: failed === 0 ? 'verified' : 'failed',
+    nextSliceCandidates: failed === 0 ? 'verified' : 'failed',
+    nextSliceActionPackets: failed === 0 ? 'verified' : 'failed',
+    sessionSyncAdoptionBoundary: failed === 0 ? 'verified' : 'failed',
+  },
+  commands: [directValid.command, directInvalid.command, directVerified.command, commandValid.command, commandCompact.command, commandInvalid.command, gseSelf.command],
+  checks,
+  limits: [
+    'This audit verifies portable /gse continue semantics and compact packet output.',
+    'It does not prove native host slash-command execution.',
+    'Owner/external records are surfaced as public/release/host-specific claim evidence, not GSE core workflow blockers.',
+  ],
+}
+
+if (jsonOnly) console.log(JSON.stringify(report, null, 2))
+else console.log(JSON.stringify(report, null, 2))
+
+if (failed > 0) process.exit(1)