@t275005746/gse 0.1.0

package/scripts/generate-final-acceptance-packet.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+import fs from 'node:fs'
+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 displayRoot = readArg('--display-root', '<gse-root>')
+const out = path.resolve(readArg('--out', path.join(root, '.gse', 'acceptance', 'final-acceptance-packet.md')))
+const jsonOnly = args.includes('--json')
+const dryRun = args.includes('--dry-run')
+const force = args.includes('--force')
+
+function runAudit() {
+  const result = spawnSync(process.execPath, [path.join(root, 'scripts', 'audit-final-readiness.mjs'), '--root', root, '--json'], {
+    cwd: root,
+    encoding: 'utf8',
+    windowsHide: true,
+  })
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      error: 'audit-final-readiness failed',
+      stdout: result.stdout?.trim() ?? '',
+      stderr: result.stderr?.trim() ?? '',
+    }
+  }
+  try {
+    return { ok: true, data: JSON.parse(result.stdout) }
+  } catch (error) {
+    return { ok: false, error: 'audit-final-readiness did not return valid JSON', detail: error.message }
+  }
+}
+
+function runPublicDoctor() {
+  const result = spawnSync(process.execPath, [path.join(root, 'scripts', 'audit-public-acceptance-readiness.mjs'), '--root', root, '--json'], {
+    cwd: root,
+    encoding: 'utf8',
+    windowsHide: true,
+  })
+  if (result.status !== 0) return { ok: false, gates: new Map() }
+  try {
+    const data = JSON.parse(result.stdout)
+    return {
+      ok: true,
+      gates: new Map((data.pendingGates ?? []).map((gate) => [gate.area, gate])),
+    }
+  } catch {
+    return { ok: false, gates: new Map() }
+  }
+}
+
+function actionFor(row, publicGate) {
+  if (publicGate?.recordCommand) {
+    const parts = [
+      'Attach the real owner/external evidence, then run `' + publicGate.recordCommand + '`.',
+    ]
+    if (publicGate.preflightCommand) parts.push('Preflight with `' + publicGate.preflightCommand + '`.')
+    return parts.join(' ')
+  }
+  if (row.area === 'License decision') {
+    return 'Run `node scripts/record-public-release.mjs --root __GSE__ --license-status selected --spdx __SPDX_ID__ --license-file __LICENSE_FILE__ --approved-by __OWNER__ --decision-date __YYYY_MM_DD__ --evidence-status accepted` after the owner chooses a license, or record `--license-status not-public` with owner approval.'
+  }
+  if (row.area === 'Public security contact') {
+    return 'Update `SECURITY.md` with an owner-approved vulnerability disclosure path before public release acceptance.'
+  }
+  if (row.area === 'Public registry publication') {
+    return 'Publish only through the chosen public channel, then record the package URL, version, digest, date, and verification command in release evidence.'
+  }
+  if (row.area === 'Marketplace approval') {
+    return 'Submit the marketplace/catalog listing, wait for real approval or publication evidence, then attach the listing URL and review status.'
+  }
+  if (row.area === 'Native slash command') {
+    return 'Use the host runtime to invoke a real native slash command and record it with `scripts/record-host-invocation.mjs` using native slash-command evidence.'
+  }
+  if (row.area === 'Other host runtime invocation') {
+    return 'Run GSE in each claimed host, record invocation evidence with `scripts/record-host-invocation.mjs`, then re-run host runtime audits.'
+  }
+  return 'Provide explicit owner or external evidence, then re-run final readiness and close gate audits.'
+}
+
+function renderPacket(audit) {
+  const publicDoctor = runPublicDoctor()
+  const matrix = audit.matrix ?? []
+  const verified = matrix.filter((row) => row.status === 'verified')
+  const pending = matrix.filter((row) => row.status !== 'verified')
+  const lines = []
+  lines.push('# GSE Final Acceptance Packet')
+  lines.push('')
+  lines.push('Generated: ' + new Date().toISOString())
+  lines.push('Root: ' + displayRoot)
+  lines.push('')
+  lines.push('## Purpose')
+  lines.push('')
+  lines.push('Turn the final-readiness matrix into an executable owner/external acceptance checklist. This packet is not acceptance by itself; it is the handoff plan for the evidence that cannot be produced locally.')
+  lines.push('')
+  lines.push('## Current Claim Boundary')
+  lines.push('')
+  lines.push('- Local readiness: ' + (audit.workflows?.finalReadinessMatrix ?? 'unknown'))
+  lines.push('- Public accepted: ' + (audit.workflows?.publicAccepted ?? 'unknown'))
+  lines.push('- Verified rows: ' + verified.length)
+  lines.push('- Pending owner/external rows: ' + pending.length)
+  lines.push('')
+  lines.push('## Verified Local Capabilities')
+  lines.push('')
+  for (const row of verified) lines.push('- ' + row.area + ': verified; evidence: ' + row.evidence)
+  lines.push('')
+  lines.push('## Pending Acceptance Gates')
+  lines.push('')
+  for (const row of pending) {
+    lines.push('### ' + row.area)
+    lines.push('')
+    lines.push('- Status: ' + row.status)
+    lines.push('- Current evidence: ' + row.evidence)
+    lines.push('- Required action: ' + actionFor(row, publicDoctor.gates.get(row.area)))
+    lines.push('- Acceptance rule: do not mark accepted until the evidence is real, dated, and re-audited.')
+    lines.push('')
+  }
+  lines.push('## Re-Verification Commands')
+  lines.push('')
+  lines.push('```bash')
+  lines.push('node scripts/audit-final-readiness.mjs --root __GSE__ --json')
+  lines.push('node scripts/audit-public-acceptance-readiness.mjs --root __GSE__ --json')
+  lines.push('node scripts/audit-public-release-decision.mjs --root __GSE__ --json')
+  lines.push('node scripts/audit-host-runtime-invocations.mjs --root __GSE__ --json')
+  lines.push('node scripts/validate-gse.mjs --root __GSE__ --json')
+  lines.push('node scripts/audit-close-gate.mjs --target __GSE__ --json')
+  lines.push('```')
+  lines.push('')
+  lines.push('## Anti-Overclaim Rules')
+  lines.push('')
+  lines.push('- Do not claim public release acceptance until public security contact, repository settings, CI, publication, marketplace, and host-runtime evidence are accepted.')
+  lines.push('- Do not claim marketplace availability until an actual marketplace or catalog record exists.')
+  lines.push('- Do not claim native slash-command support from portable text-command routing.')
+  lines.push('- Do not claim support for a host until that host has its own runtime invocation record.')
+  lines.push('- Keep owner-required and external-required gates visible in status reports until they are re-audited as verified.')
+  lines.push('')
+  lines.push('## Next Action')
+  lines.push('')
+  lines.push('Run the public acceptance doctor, collect the owner-required decisions first, then record public channel and host-runtime evidence as those external systems become available.')
+  return lines.join('\n') + '\n'
+}
+
+const audit = runAudit()
+if (!audit.ok) {
+  console.error(JSON.stringify({ status: 'failed', ...audit }, null, 2))
+  process.exit(1)
+}
+
+const packet = renderPacket(audit.data)
+if (!dryRun) {
+  if (fs.existsSync(out) && !force) {
+    console.error(JSON.stringify({ status: 'failed', reason: 'output exists; pass --force to overwrite', out }, null, 2))
+    process.exit(1)
+  }
+  fs.mkdirSync(path.dirname(out), { recursive: true })
+  fs.writeFileSync(out, packet, 'utf8')
+}
+
+const report = {
+  status: 'ready',
+  root,
+  out,
+  dryRun,
+  written: dryRun ? 0 : 1,
+  summary: {
+    verifiedRows: audit.data.matrix.filter((row) => row.status === 'verified').length,
+    pendingRows: audit.data.matrix.filter((row) => row.status !== 'verified').length,
+    publicAccepted: audit.data.workflows?.publicAccepted ?? 'unknown',
+  },
+}
+
+if (jsonOnly) console.log(JSON.stringify(report, null, 2))
+else console.log(packet)

package/scripts/generate-final-form-progress-report.mjs

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+import fs from 'node:fs'
+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 out = path.resolve(readArg('--out', path.join(root, '.gse', 'acceptance', 'final-form-progress-report.md')))
+const jsonOut = path.resolve(readArg('--json-out', path.join(root, '.gse', 'acceptance', 'final-form-progress-report.json')))
+const displayRoot = readArg('--display-root', '<gse-root>')
+const force = args.includes('--force')
+const dryRun = args.includes('--dry-run')
+const jsonOnly = args.includes('--json')
+
+function run(command, commandArgs) {
+  const result = spawnSync(command, commandArgs, {
+    cwd: root,
+    encoding: 'utf8',
+    windowsHide: true,
+  })
+  return {
+    status: result.status ?? 1,
+    stdout: (result.stdout ?? '').trim(),
+    stderr: (result.stderr ?? '').trim(),
+    command: [command, ...commandArgs].join(' '),
+  }
+}
+
+function parseJson(text) {
+  try {
+    return JSON.parse(text)
+  } catch {
+    return null
+  }
+}
+
+function countBy(rows, status) {
+  return rows.filter((row) => row.status === status).length
+}
+
+function percent(numerator, denominator) {
+  if (!denominator) return 0
+  return Math.round((numerator / denominator) * 100)
+}
+
+const finalReadiness = run(process.execPath, [path.join(root, 'scripts', 'audit-final-readiness.mjs'), '--root', root, '--json'])
+const publicAcceptance = run(process.execPath, [path.join(root, 'scripts', 'audit-public-acceptance-readiness.mjs'), '--root', root, '--json'])
+const publicAcceptanceCommandDryRunDrill = run(process.execPath, [path.join(root, 'scripts', 'audit-public-acceptance-command-dry-run-drill.mjs'), '--root', root, '--json'])
+const hostRuntime = run(process.execPath, [path.join(root, 'scripts', 'audit-host-runtime-invocations.mjs'), '--root', root, '--json'])
+
+const finalReadinessData = parseJson(finalReadiness.stdout)
+const publicAcceptanceData = parseJson(publicAcceptance.stdout)
+const hostRuntimeData = parseJson(hostRuntime.stdout)
+
+const matrix = finalReadinessData?.matrix ?? []
+const verifiedRows = countBy(matrix, 'verified')
+const ownerRequiredRows = countBy(matrix, 'owner-required')
+const externalRequiredRows = countBy(matrix, 'external-required')
+const acceptedRows = countBy(matrix, 'accepted')
+const totalRows = matrix.length
+const localReadyRows = verifiedRows + acceptedRows
+const publicAccepted = finalReadinessData?.workflows?.publicAccepted ?? 'unknown'
+const pendingGates = publicAcceptanceData?.pendingGates ?? matrix.filter((row) => row.status !== 'verified')
+const licenseDecisionVerified = matrix.some((row) => row.area === 'License decision' && (row.status === 'verified' || row.status === 'accepted'))
+const cannotClaim = [
+  ...(licenseDecisionVerified ? [] : ['owner-selected license acceptance unless accepted owner evidence exists']),
+  'public security contact acceptance unless accepted owner evidence exists',
+  'public repository settings unless real repository evidence exists',
+  'public CI unless a real successful public CI run is recorded',
+  'registry or marketplace publication unless real publication evidence exists',
+  'native slash-command support unless real host runtime evidence exists',
+]
+
+const localRows = totalRows - ownerRequiredRows - externalRequiredRows
+const localEngineeringScore = percent(localReadyRows, localRows)
+const finalFormScore = publicAccepted === 'verified' ? 100 : percent(localReadyRows, totalRows)
+const status = publicAccepted === 'verified' ? 'accepted' : 'verified-with-external-blockers'
+
+const report = {
+  schemaVersion: 1,
+  generatedAt: new Date().toISOString(),
+  root: displayRoot,
+  status,
+  scores: {
+    localEngineeringReadiness: localEngineeringScore,
+    fullFinalFormReadiness: finalFormScore,
+    scoringBasis: 'local engineering excludes owner-required and external-required rows; full final-form counts every readiness row',
+  },
+  readiness: {
+    totalRows,
+    localRows,
+    verifiedRows,
+    acceptedRows,
+    ownerRequiredRows,
+    externalRequiredRows,
+    publicAccepted,
+    pendingGateCount: pendingGates.length,
+  },
+  blockers: pendingGates.map((gate) => ({
+    area: gate.area,
+    status: gate.status,
+    owner: gate.owner ?? (gate.status === 'owner-required' ? 'project owner' : 'external system or host'),
+    evidence: gate.currentEvidence ?? gate.evidence ?? '',
+    recordCommand: gate.recordCommand ?? null,
+    preflightCommand: gate.preflightCommand ?? null,
+    requiredEvidence: gate.requiredEvidence ?? 'Record accepted owner/external evidence and re-run final readiness.',
+  })),
+  verifiedCapabilities: matrix.filter((row) => row.status === 'verified' || row.status === 'accepted').map((row) => ({
+    area: row.area,
+    status: row.status,
+    evidence: row.evidence,
+  })),
+  commandEvidence: {
+    finalReadiness: { status: finalReadiness.status, command: 'node scripts/audit-final-readiness.mjs --root __GSE__ --json' },
+    publicAcceptance: { status: publicAcceptance.status, command: 'node scripts/audit-public-acceptance-readiness.mjs --root __GSE__ --json' },
+    publicAcceptanceCommandDryRunDrill: { status: publicAcceptanceCommandDryRunDrill.status, command: 'node scripts/audit-public-acceptance-command-dry-run-drill.mjs --root __GSE__ --json' },
+    hostRuntime: { status: hostRuntime.status, command: 'node scripts/audit-host-runtime-invocations.mjs --root __GSE__ --json' },
+  },
+  hostRuntime: {
+    nativeSlashCommandRecords: hostRuntimeData?.inventory?.nativeSlashCommandRecords ?? 0,
+    portableTextCommandRecords: hostRuntimeData?.inventory?.portableTextCommandRecords ?? 0,
+    totalRecords: hostRuntimeData?.inventory?.totalRecords ?? 0,
+  },
+  claimBoundary: {
+    mayClaimLocalEngineeringReadiness: finalReadiness.status === 0,
+    mayClaimPublicAcceptedFinalForm: publicAccepted === 'verified' && pendingGates.length === 0,
+    cannotClaim,
+  },
+}
+
+function renderMarkdown(data) {
+  const lines = []
+  lines.push('# GSE Final-Form Progress Report')
+  lines.push('')
+  lines.push('Generated: ' + data.generatedAt)
+  lines.push('Root: ' + data.root)
+  lines.push('')
+  lines.push('## Summary')
+  lines.push('')
+  lines.push('- Status: ' + data.status)
+  lines.push('- Local engineering readiness: ' + data.scores.localEngineeringReadiness + '%')
+  lines.push('- Full final-form readiness: ' + data.scores.fullFinalFormReadiness + '%')
+  lines.push('- Scoring basis: ' + data.scores.scoringBasis)
+  lines.push('- Public accepted: ' + data.readiness.publicAccepted)
+  lines.push('- Matrix rows: ' + data.readiness.verifiedRows + ' verified, ' + data.readiness.ownerRequiredRows + ' owner-required, ' + data.readiness.externalRequiredRows + ' external-required, ' + data.readiness.totalRows + ' total')
+  lines.push('- Local rows: ' + data.readiness.localRows)
+  lines.push('')
+  lines.push('## Remaining Blockers')
+  lines.push('')
+  if (data.blockers.length === 0) {
+    lines.push('- None reported by final readiness. Re-run close gate and release audits before claiming completion.')
+  } else {
+    for (const blocker of data.blockers) {
+      lines.push('- ' + blocker.area + ': ' + blocker.status)
+      lines.push('  - Owner: ' + blocker.owner)
+      lines.push('  - Evidence now: ' + blocker.evidence)
+      lines.push('  - Required evidence: ' + blocker.requiredEvidence)
+      if (blocker.preflightCommand) lines.push('  - Preflight command: `' + blocker.preflightCommand + '`')
+      if (blocker.recordCommand) lines.push('  - Record command: `' + blocker.recordCommand + '`')
+    }
+  }
+  lines.push('')
+  lines.push('## Verified Capabilities')
+  lines.push('')
+  for (const item of data.verifiedCapabilities) {
+    lines.push('- ' + item.area + ': ' + item.status + ' (' + item.evidence + ')')
+  }
+  lines.push('')
+  lines.push('## Claim Boundary')
+  lines.push('')
+  lines.push('- May claim local engineering readiness: ' + data.claimBoundary.mayClaimLocalEngineeringReadiness)
+  lines.push('- May claim public accepted final form: ' + data.claimBoundary.mayClaimPublicAcceptedFinalForm)
+  for (const item of data.claimBoundary.cannotClaim) lines.push('- Cannot claim ' + item)
+  lines.push('')
+  lines.push('## Verification Commands')
+  lines.push('')
+  for (const item of Object.values(data.commandEvidence)) {
+    lines.push('- `' + item.command + '`')
+  }
+  return lines.join('\n') + '\n'
+}
+
+if (!dryRun) {
+  for (const target of [out, jsonOut]) {
+    if (fs.existsSync(target) && !force) {
+      throw new Error(`Refusing to overwrite ${target}; pass --force`)
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true })
+  }
+  fs.writeFileSync(out, renderMarkdown(report), 'utf8')
+  fs.writeFileSync(jsonOut, JSON.stringify(report, null, 2) + '\n', 'utf8')
+}
+
+if (jsonOnly) {
+  console.log(JSON.stringify({ status: dryRun ? 'ready' : 'written', out, jsonOut, summary: report.readiness, scores: report.scores }, null, 2))
+} else {
+  console.log(renderMarkdown(report))
+}

package/scripts/generate-host-adapter.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import fs from 'node:fs'
+import path from 'node:path'
+
+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 target = path.resolve(readArg('--target', process.cwd()))
+const hostArg = readArg('--host', 'all')
+const force = args.includes('--force')
+const jsonOnly = args.includes('--json')
+
+const hostConfigs = {
+  codex: {
+    title: 'Codex Adapter',
+    path: path.join('.codex', 'gse-adapter.md'),
+    bullets: [
+      'Read `.gse/project-profile.md` before using host-specific tools.',
+      'Mark subagent, MCP, browser, and LSP capabilities as verified only after current-session evidence.',
+      'Use `references/compatibility.md` and `references/drift-audit.md` when adapter claims and current tools disagree.',
+    ],
+  },
+  claude: {
+    title: 'Claude Code Adapter',
+    path: path.join('.claude', 'gse-adapter.md'),
+    bullets: [
+      'Commands and agents should point back to `.gse/` for goals, evidence, quality gates, and learning rules.',
+      'Do not copy the goal map, quality gates, or evidence log into this folder.',
+      'Use `references/compatibility.md` and `references/drift-audit.md` when adapter claims and current tools disagree.',
+    ],
+  },
+}
+
+function render(config) {
+  return [
+    '# ' + config.title,
+    '',
+    'Source of truth: `.gse/`.',
+    '',
+    ...config.bullets.map((item) => '- ' + item),
+    '',
+    'Capability status vocabulary: `verified`, `documented`, `unknown`, `unavailable`.',
+    '',
+  ].join('\n')
+}
+
+function writeAdapter(host) {
+  const config = hostConfigs[host]
+  if (!config) return { host, status: 'invalid', path: null }
+  const fullPath = path.join(target, config.path)
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true })
+  if (!force && fs.existsSync(fullPath)) return { host, status: 'skipped', path: fullPath, relativePath: config.path }
+  fs.writeFileSync(fullPath, render(config).replace(/\n/g, '\r\n'), 'utf8')
+  return { host, status: 'written', path: fullPath, relativePath: config.path }
+}
+
+const hosts = hostArg === 'all' ? Object.keys(hostConfigs) : hostArg.split(',').map((item) => item.trim()).filter(Boolean)
+const invalid = hosts.filter((host) => !hostConfigs[host])
+if (invalid.length) {
+  console.error('Invalid --host value: ' + invalid.join(', ') + '. Expected codex, claude, or all.')
+  process.exit(1)
+}
+
+const results = hosts.map(writeAdapter)
+const report = { target, force, hosts, results }
+
+if (jsonOnly) console.log(JSON.stringify(report, null, 2))
+else console.log(JSON.stringify(report, null, 2))

package/scripts/generate-host-runtime-evidence-handoff.mjs

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+import fs from 'node:fs'
+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
+}
+
+function hasArg(name) {
+  return args.includes(name)
+}
+
+const root = path.resolve(readArg('--root', path.join(import.meta.dirname, '..')))
+const out = path.resolve(readArg('--out', path.join(root, '.gse', 'acceptance', 'host-runtime-evidence-handoff.md')))
+const displayRoot = readArg('--display-root', '<gse-root>')
+const jsonOnly = hasArg('--json')
+const dryRun = hasArg('--dry-run')
+const force = hasArg('--force')
+
+function read(relativePath) {
+  const fullPath = path.join(root, relativePath)
+  return fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf8').replace(/^\uFEFF/, '') : ''
+}
+
+function run(command, commandArgs) {
+  const result = spawnSync(command, commandArgs, {
+    cwd: root,
+    encoding: 'utf8',
+    windowsHide: true,
+  })
+  return {
+    status: result.status ?? 1,
+    stdout: (result.stdout ?? '').trim(),
+    stderr: (result.stderr ?? '').trim(),
+    command: [command, ...commandArgs].join(' '),
+  }
+}
+
+function parseJson(text) {
+  try {
+    return JSON.parse(text)
+  } catch {
+    return null
+  }
+}
+
+function runHostAudit() {
+  const result = run(process.execPath, [path.join(root, 'scripts', 'audit-host-runtime-invocations.mjs'), '--root', root, '--json'])
+  if (result.status !== 0) {
+    return { ok: false, error: 'host runtime invocation audit failed', result }
+  }
+  const data = parseJson(result.stdout)
+  if (!data) return { ok: false, error: 'host runtime invocation audit returned invalid JSON', result }
+  return { ok: true, data, command: result.command }
+}
+
+function hostRowsFromCompatibility() {
+  const text = read('references/compatibility.md')
+  const rows = []
+  let inHostMatrix = false
+  for (const line of text.split(/\r?\n/)) {
+    if (line.trim() === '## Host Matrix') {
+      inHostMatrix = true
+      continue
+    }
+    if (inHostMatrix && line.startsWith('## ')) break
+    if (!inHostMatrix) continue
+    if (!line.startsWith('| ')) continue
+    if (line.includes('---') || line.includes('Host family')) continue
+    const cells = line.split('|').map((item) => item.trim()).filter(Boolean)
+    if (cells.length < 6) continue
+    rows.push({
+      hostFamily: cells[0],
+      adapterLocation: cells[1],
+      sourcePointer: cells[2],
+      currentStatus: cells[3].replace(/`/g, ''),
+      evidence: cells[4],
+      fallback: cells[5],
+    })
+  }
+  return rows
+}
+
+function commandFor(hostFamily) {
+  const safeHost = hostFamily.replace(/\|/g, '').replace(/\s+/g, ' ').trim()
+  return [
+    'node __GSE__/scripts/record-host-invocation.mjs',
+    '--root __PROJECT_OR_GSE__',
+    `--host "${safeHost}"`,
+    '--host-version "__VERSION_OR_UNKNOWN__"',
+    '--project "__PROJECT_NAME__"',
+    '--adapter-path "__HOST_ADAPTER_OR_POINTER__"',
+    '--invocation-method "__NATIVE_SLASH_COMMAND_OR_PORTABLE_TEXT_COMMAND_OR_HOST_UI_COMMAND_OR_RUNTIME_BRIDGE__"',
+    '--command "/gse continue"',
+    '--status verified',
+    '--evidence-owner "__PERSON_OR_AGENT__"',
+    '--evidence "__THREAD_ID_TRANSCRIPT_SCREENSHOT_TERMINAL_OUTPUT_OR_HOST_LOG__"',
+    '--portable-text-command true|false',
+    '--native-slash-command true|false',
+    '--generated-pointer true|false',
+    '--owner-acceptance-required false',
+    '--out __PROJECT_OR_GSE__/.gse/evidence/host-invocations/__DATE__-__HOST__-gse.md',
+  ].join(' ')
+}
+
+function renderHandoff(audit, hostRows) {
+  const inventory = audit.inventory ?? {}
+  const lines = []
+  lines.push('# GSE Host Runtime Evidence Handoff')
+  lines.push('')
+  lines.push('Generated: ' + new Date().toISOString())
+  lines.push('Root: ' + displayRoot)
+  lines.push('')
+  lines.push('## Purpose')
+  lines.push('')
+  lines.push('Turn cross-host support into auditable runtime evidence. Generated adapters, docs, or command pointers are useful setup, but they are not proof that a host actually invoked GSE.')
+  lines.push('')
+  lines.push('## Current Runtime Evidence')
+  lines.push('')
+  lines.push('- Host runtime invocation records: ' + (inventory.records ?? 0))
+  lines.push('- Verified or accepted records: ' + (inventory.closeableRecords ?? 0))
+  lines.push('- Hosts with records: ' + (inventory.hosts?.length ? inventory.hosts.join(', ') : 'none'))
+  lines.push('- Native slash-command records: ' + (inventory.nativeSlashCommandRecords ?? 0))
+  lines.push('- Portable text-command records: ' + (inventory.portableTextCommandRecords ?? 0))
+  lines.push('- Audit command: `node scripts/audit-host-runtime-invocations.mjs --root __GSE_OR_PROJECT__ --json`')
+  lines.push('')
+  lines.push('## Host Evidence Plan')
+  lines.push('')
+  for (const host of hostRows) {
+    lines.push('### ' + host.hostFamily)
+    lines.push('')
+    lines.push('- Adapter location: ' + host.adapterLocation)
+    lines.push('- Current matrix status: ' + host.currentStatus)
+    lines.push('- Existing evidence: ' + host.evidence)
+    lines.push('- Fallback: ' + host.fallback)
+    lines.push('- Required runtime proof: a persistent record under `.gse/evidence/host-invocations/` produced by `record-host-invocation.mjs` or manually matching the same fields.')
+    lines.push('- Record command:')
+    lines.push('')
+    lines.push('```bash')
+    lines.push(commandFor(host.hostFamily))
+    lines.push('```')
+    lines.push('')
+  }
+  lines.push('## Verification')
+  lines.push('')
+  lines.push('Run these commands after adding host evidence:')
+  lines.push('')
+  lines.push('```bash')
+  lines.push('node scripts/audit-host-runtime-invocations.mjs --root __GSE_OR_PROJECT__ --json')
+  lines.push('node scripts/audit-final-readiness.mjs --root __GSE_OR_PROJECT__ --json')
+  lines.push('node scripts/validate-gse.mjs --root __GSE_OR_PROJECT__ --json')
+  lines.push('```')
+  lines.push('')
+  lines.push('## Anti-Overclaim')
+  lines.push('')
+  lines.push('- Do not claim native slash-command support from generated pointers or portable text-command records.')
+  lines.push('- Do not claim a host is supported without a host runtime invocation record for that host.')
+  lines.push('- Do not mark a host record accepted when `owner-acceptance-required` is true.')
+  lines.push('- Keep host capability status separate from portable `.gse/` workflow status.')
+  lines.push('- Treat subagents, MCP, LSP, browser tools, hooks, and plugins as host/session-specific until current evidence proves them.')
+  lines.push('')
+  lines.push('## Next Action')
+  lines.push('')
+  lines.push('Record real invocation evidence for Claude Code-style, Hermes/AION-style, WorkBuddy/other IDE agents, and any host-native slash-command mechanism that becomes available.')
+  return lines.join('\n') + '\n'
+}
+
+const audit = runHostAudit()
+if (!audit.ok) {
+  console.error(JSON.stringify({ status: 'failed', root, out, error: audit.error, auditResult: audit.result }, null, 2))
+  process.exit(1)
+}
+
+const hostRows = hostRowsFromCompatibility()
+const handoff = renderHandoff(audit.data, hostRows)
+
+if (!dryRun) {
+  if (fs.existsSync(out) && !force) {
+    console.error(JSON.stringify({ status: 'exists', root, out, error: 'output exists; pass --force to overwrite' }, null, 2))
+    process.exit(1)
+  }
+  fs.mkdirSync(path.dirname(out), { recursive: true })
+  fs.writeFileSync(out, handoff, 'utf8')
+}
+
+const report = {
+  status: dryRun ? 'ready' : 'written',
+  root,
+  out,
+  dryRun,
+  hostAuditCommand: audit.command,
+  summary: {
+    hostFamilies: hostRows.length,
+    records: audit.data.inventory?.records ?? 0,
+    nativeSlashCommandRecords: audit.data.inventory?.nativeSlashCommandRecords ?? 0,
+    portableTextCommandRecords: audit.data.inventory?.portableTextCommandRecords ?? 0,
+  },
+}
+
+if (jsonOnly) console.log(JSON.stringify(report, null, 2))
+else console.log(handoff)