@t275005746/gse 0.1.0

package/scripts/audit-host-ui-invocation.mjs

@@ -0,0 +1,132 @@
+#!/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 recordPath = readArg('--record')
+const jsonOnly = args.includes('--json')
+
+function read(relativePathOrFullPath) {
+  const fullPath = path.isAbsolute(relativePathOrFullPath) ? relativePathOrFullPath : path.join(root, relativePathOrFullPath)
+  return fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf8').replace(/^\uFEFF/, '') : ''
+}
+
+function exists(relativePath) {
+  return fs.existsSync(path.join(root, relativePath))
+}
+
+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 }
+}
+
+const target = fs.mkdtempSync(path.join(os.tmpdir(), 'gse-host-ui-'))
+fs.mkdirSync(target, { recursive: true })
+fs.writeFileSync(path.join(target, 'AGENTS.md'), '# Host UI Fixture\n', 'utf8')
+const initRun = run('init-project.mjs', ['--target', target, '--mode', 'enterprise', '--json'])
+const adapterRun = run('generate-command-adapter.mjs', ['--target', target, '--host', 'all', '--json'])
+const commandRun = run('run-gse-command.mjs', ['--target', target, '--command', '/gse help', '--json'])
+const adapterData = parseJson(adapterRun.stdout)
+const commandData = parseJson(commandRun.stdout)
+const claudeCommand = read(path.join(target, '.claude', 'commands', 'gse.md'))
+const codexPointer = read(path.join(target, '.codex', 'gse-command.md'))
+const record = recordPath ? read(path.resolve(recordPath)) : ''
+const recordHasEvidence =
+  Boolean(record) &&
+  record.includes('## Host') &&
+  record.includes('## Command') &&
+  record.includes('## Result') &&
+  record.includes('## Evidence') &&
+  /Status:\s*(verified|accepted)/i.test(record)
+
+const checks = [
+  check('HUI01', 'host UI invocation record template exists', exists('assets/templates/host-ui-invocation-record.md'), 'assets/templates/host-ui-invocation-record.md'),
+  check('HUI02', 'portable runner can execute command semantics', commandRun.status === 0 && commandData?.route?.route === 'references/commands.md', '/gse help through run-gse-command.mjs'),
+  check('HUI03', 'Claude command adapter is generated at current native path', adapterRun.status === 0 && fs.existsSync(path.join(target, '.claude', 'commands', 'gse.md')) && claudeCommand.includes('Portable execution path'), '.claude/commands/gse.md'),
+  check('HUI04', 'Codex command pointer is generated without native claim', adapterRun.status === 0 && fs.existsSync(path.join(target, '.codex', 'gse-command.md')) && codexPointer.includes('not proof of a native project-level /gse slash-command mechanism'), '.codex/gse-command.md'),
+  check('HUI05', 'adapter generator labels native support honestly', adapterData?.results?.some((item) => item.host === 'claude' && item.nativeSlashCommand === true) && adapterData?.results?.some((item) => item.host === 'codex' && item.nativeSlashCommand === false), 'generate-command-adapter.mjs result metadata'),
+  check('HUI06', 'commands reference requires host runtime evidence', read('references/commands.md').includes('host-specific smoke') && read('references/commands.md').includes('Do not claim native slash-command support unless the current host exposes it and it was verified.'), 'references/commands.md'),
+  check('HUI07', 'optional real host invocation record is valid when supplied', recordPath ? recordHasEvidence : true, recordPath ? recordPath : 'no --record supplied; template/readiness only'),
+  check('HUI08', 'validator includes host UI invocation audit', read('scripts/validate-gse.mjs').includes('audit-host-ui-invocation.mjs'), 'scripts/validate-gse.mjs'),
+]
+
+fs.rmSync(target, { 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: {
+    hostUiInvocationReadiness: failed === 0 ? 'verified' : 'failed',
+    realHostUiInvocation: recordHasEvidence ? 'verified-by-record' : 'not-verified',
+  },
+  acceptedBy: recordHasEvidence ? 'host invocation record' : 'not accepted; no real host UI invocation record was supplied',
+  limits: [
+    'This audit verifies portable command execution, generated host pointers, and the evidence format for real host UI invocation.',
+    'Without --record, it does not prove a real Codex, Claude Code, Hermes, WorkBuddy, or other UI invoked the command.',
+    'Generated adapters are not runtime proof by themselves.',
+  ],
+  checks,
+}
+
+function renderMarkdown(data) {
+  const lines = []
+  lines.push('# GSE Host UI Invocation 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('- Host UI invocation readiness: ' + data.workflows.hostUiInvocationReadiness)
+  lines.push('- Real host UI invocation: ' + data.workflows.realHostUiInvocation)
+  lines.push('- Accepted by: ' + data.acceptedBy)
+  lines.push('')
+  lines.push('## Checks')
+  lines.push('')
+  for (const item of data.checks) {
+    const marker = item.status === 'passed' ? '[x]' : '[ ]'
+    lines.push('- ' + marker + ' ' + item.id + ' ' + item.label + ': ' + item.evidence)
+  }
+  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-learning-system.mjs

@@ -0,0 +1,103 @@
+#!/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')
+const target = fs.mkdtempSync(path.join(os.tmpdir(), 'gse-learning-audit-'))
+
+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 }
+}
+
+fs.mkdirSync(target, { recursive: true })
+const initRun = run('init-project.mjs', ['--target', target, '--mode', 'lite', '--json'])
+const learningsPath = path.join(target, '.gse', 'learnings.md')
+const before = fs.existsSync(learningsPath) ? fs.readFileSync(learningsPath, 'utf8') : ''
+const summary = 'Prefer UTF-8 safe readers for Chinese docs before judging mojibake'
+
+const waitingRun = run('record-learning.mjs', ['--target', target, '--json'])
+const dryRun = run('record-learning.mjs', ['--target', target, '--summary', summary, '--trigger', 'encoding review', '--source', 'audit fixture', '--json'])
+const afterDryRun = fs.existsSync(learningsPath) ? fs.readFileSync(learningsPath, 'utf8') : ''
+const writeRun = run('record-learning.mjs', ['--target', target, '--summary', summary, '--trigger', 'encoding review', '--source', 'audit fixture', '--impact', 'prevents false mojibake fixes', '--execute', '--json'])
+const afterWrite = fs.existsSync(learningsPath) ? fs.readFileSync(learningsPath, 'utf8') : ''
+const duplicateRun = run('record-learning.mjs', ['--target', target, '--summary', summary, '--trigger', 'encoding review again', '--source', 'audit fixture', '--execute', '--json'])
+const afterDuplicate = fs.existsSync(learningsPath) ? fs.readFileSync(learningsPath, 'utf8') : ''
+const commandDryRun = run('run-gse-command.mjs', ['--root', root, '--target', target, '--command', `/gse learn --summary ${summary} via command --trigger command audit --source run-gse-command`, '--json'])
+const commandWriteRun = run('run-gse-command.mjs', ['--root', root, '--target', target, '--command', '/gse learn --summary Capture tool capability mismatches as reusable lessons --trigger tool mismatch --source command audit', '--execute', '--json'])
+const afterCommandWrite = fs.existsSync(learningsPath) ? fs.readFileSync(learningsPath, 'utf8') : ''
+
+const waiting = parseJson(waitingRun.stdout)
+const dry = parseJson(dryRun.stdout)
+const written = parseJson(writeRun.stdout)
+const duplicate = parseJson(duplicateRun.stdout)
+const commandDry = parseJson(commandDryRun.stdout)
+const commandDryChild = parseJson(commandDry?.execution?.stdout ?? '')
+const commandWrite = parseJson(commandWriteRun.stdout)
+const commandWriteChild = parseJson(commandWrite?.execution?.stdout ?? '')
+
+const checks = [
+  check('LRN01', 'record-learning script exists', fs.existsSync(path.join(root, 'scripts', 'record-learning.mjs')), 'scripts/record-learning.mjs'),
+  check('LRN02', 'learning audit script exists', fs.existsSync(path.join(root, 'scripts', 'audit-learning-system.mjs')), 'scripts/audit-learning-system.mjs'),
+  check('LRN03', 'init-project creates .gse/learnings.md', initRun.status === 0 && fs.existsSync(learningsPath), '.gse/learnings.md'),
+  check('LRN04', 'missing summary returns waiting-for-input without failing', waitingRun.status === 0 && waiting?.status === 'waiting-for-input', 'record-learning without --summary'),
+  check('LRN05', 'dry-run previews learning without modifying file', dryRun.status === 0 && dry?.status === 'ready' && before === afterDryRun && dry?.preview?.includes(summary), 'record-learning dry-run'),
+  check('LRN06', 'execute appends structured learning entry', writeRun.status === 0 && written?.status === 'written' && afterWrite.includes('- Summary: ' + summary) && afterWrite.includes('- Trigger: encoding review') && afterWrite.includes('- Status: learning-note'), 'record-learning --execute'),
+  check('LRN07', 'duplicate summary is skipped without appending again', duplicateRun.status === 0 && duplicate?.status === 'skipped' && afterDuplicate === afterWrite, 'duplicate record-learning --execute'),
+  check('LRN08', '/gse learn dry-runs through portable command runner', commandDryRun.status === 0 && commandDry?.verb === 'learn' && commandDryChild?.status === 'ready', '/gse learn'),
+  check('LRN09', '/gse learn --execute writes through portable command runner', commandWriteRun.status === 0 && commandWrite?.verb === 'learn' && commandWriteChild?.status === 'written' && afterCommandWrite.includes('Capture tool capability mismatches as reusable lessons'), '/gse learn --execute'),
+]
+
+const passed = checks.filter((item) => item.status === 'passed').length
+const failed = checks.length - passed
+const report = {
+  root,
+  target,
+  generatedAt: new Date().toISOString(),
+  summary: { status: failed === 0 ? 'passed' : 'failed', passed, failed, total: checks.length },
+  workflows: {
+    learningCommand: failed === 0 ? 'verified' : 'failed',
+    learningStore: failed === 0 ? 'verified' : 'failed',
+  },
+  commands: [waitingRun.command, dryRun.command, writeRun.command, duplicateRun.command, commandDryRun.command, commandWriteRun.command],
+  limits: [
+    'This verifies deterministic learning capture and duplicate prevention.',
+    'It does not automatically decide which lessons are worth recording; the agent or owner still supplies the summary.',
+  ],
+  checks,
+}
+
+fs.rmSync(target, { recursive: true, force: true })
+
+if (jsonOnly) console.log(JSON.stringify(report, null, 2))
+else console.log(JSON.stringify(report, null, 2))
+
+if (failed > 0) process.exit(1)

package/scripts/audit-local-final-form-completion.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+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), '--root', root, '--json', ...commandArgs], {
+    cwd: root,
+    encoding: 'utf8',
+    windowsHide: true,
+  })
+  let data = null
+  try {
+    data = JSON.parse((result.stdout ?? '').trim())
+  } catch {
+    data = null
+  }
+  return {
+    script,
+    command: [process.execPath, path.join(root, 'scripts', script), '--root', root, '--json', ...commandArgs].join(' '),
+    status: result.status ?? 1,
+    stdout: (result.stdout ?? '').trim(),
+    stderr: (result.stderr ?? '').trim(),
+    data,
+  }
+}
+
+function check(id, label, ok, evidence, risk = '') {
+  return { id, label, status: ok ? 'passed' : 'failed', evidence, risk }
+}
+
+const finalReadiness = run('audit-final-readiness.mjs')
+const progress = run('audit-final-form-progress-report.mjs')
+const publicAcceptance = run('audit-public-acceptance-readiness.mjs')
+const completionReadiness = run('audit-completion-readiness.mjs')
+
+const finalRows = finalReadiness.data?.matrix ?? []
+const nonExternalIncompleteRows = finalRows.filter((row) => {
+  if (row.status === 'verified') return false
+  return !['owner-required', 'external-required'].includes(row.status)
+})
+const pendingGates = publicAcceptance.data?.pendingGates ?? []
+const pendingGateAreas = pendingGates.map((gate) => gate.area)
+const expectedPendingAreas = pendingGateAreas
+
+const checks = [
+  check('LFC01', 'final readiness audit passes', finalReadiness.status === 0 && finalReadiness.data?.summary?.failed === 0, finalReadiness.command),
+  check('LFC02', 'completion readiness audit passes', completionReadiness.status === 0 && completionReadiness.data?.summary?.failed === 0, completionReadiness.command),
+  check('LFC03', 'final-form progress report shows local engineering readiness at 100', progress.status === 0 && progress.data?.workflows?.localEngineeringReadiness === 100, 'localEngineeringReadiness=' + progress.data?.workflows?.localEngineeringReadiness),
+  check('LFC04', 'full final-form readiness remains bounded by owner/external gates', progress.status === 0 && progress.data?.workflows?.publicAccepted === 'not-accepted' && Number(progress.data?.workflows?.pendingGates) > 0, 'publicAccepted=' + progress.data?.workflows?.publicAccepted + '; pendingGates=' + progress.data?.workflows?.pendingGates),
+  check('LFC05', 'all incomplete final readiness rows are owner/external only', nonExternalIncompleteRows.length === 0, nonExternalIncompleteRows.length ? JSON.stringify(nonExternalIncompleteRows) : 'no local incomplete rows'),
+  check('LFC06', 'public acceptance doctor passes and keeps public acceptance unclaimed', publicAcceptance.status === 0 && publicAcceptance.data?.summary?.failed === 0 && publicAcceptance.data?.summary?.publicAccepted === 'not-accepted', publicAcceptance.command),
+  check('LFC07', 'public acceptance pending gates are current external/owner gate set', pendingGateAreas.length > 0 && expectedPendingAreas.every((area) => pendingGateAreas.includes(area)) && pendingGateAreas.length === expectedPendingAreas.length, pendingGateAreas.join(', ')),
+  check('LFC08', 'pending gates expose executable record and preflight commands', pendingGates.length > 0 && pendingGates.every((gate) => gate.recordCommand && gate.preflightCommand && gate.requiredEvidence && gate.owner), 'pending gate command templates'),
+]
+
+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,
+    localEngineeringReadiness: progress.data?.workflows?.localEngineeringReadiness ?? null,
+    fullFinalFormReadiness: progress.data?.workflows?.fullFinalFormReadiness ?? null,
+    pendingGates: progress.data?.workflows?.pendingGates ?? null,
+    publicAccepted: progress.data?.workflows?.publicAccepted ?? null,
+  },
+  workflows: {
+    localFinalFormCompletion: failed === 0 ? 'verified' : 'failed',
+    remainingWorkClass: failed === 0 ? 'owner-external-only' : 'local-work-or-state-inconsistency-present',
+  },
+  remainingOwnerExternalGates: pendingGates.map((gate) => ({
+    area: gate.area,
+    status: gate.status,
+    owner: gate.owner,
+    requiredEvidence: gate.requiredEvidence,
+  })),
+  limits: [
+    'This audit proves local GSE engineering completion boundaries only.',
+    'It does not create public repository settings, public CI, registry publication, marketplace approval, security contact acceptance, native slash-command evidence, or other host runtime evidence.',
+    'A public-final claim still requires accepted owner/external records and final readiness re-audit.',
+  ],
+  checks,
+}
+
+function renderMarkdown(data) {
+  const lines = []
+  lines.push('# GSE Local Final-Form Completion 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('- Local engineering readiness: ' + data.summary.localEngineeringReadiness)
+  lines.push('- Full final-form readiness: ' + data.summary.fullFinalFormReadiness)
+  lines.push('- Public accepted: ' + data.summary.publicAccepted)
+  lines.push('- Remaining work class: ' + data.workflows.remainingWorkClass)
+  lines.push('')
+  lines.push('## Checks')
+  lines.push('')
+  for (const item of data.checks) {
+    const marker = item.status === 'passed' ? '[x]' : '[ ]'
+    lines.push('- ' + marker + ' ' + item.id + ' ' + item.label + ': ' + item.evidence)
+  }
+  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-marketplace-discovery.mjs

@@ -0,0 +1,122 @@
+#!/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 root = path.resolve(readArg('--root', path.join(import.meta.dirname, '..')))
+const jsonOnly = args.includes('--json')
+
+function read(relativePath) {
+  const fullPath = path.join(root, relativePath)
+  return fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf8').replace(/^\uFEFF/, '') : ''
+}
+
+function exists(relativePath) {
+  return fs.existsSync(path.join(root, relativePath))
+}
+
+function readJson(relativePath) {
+  try {
+    return JSON.parse(read(relativePath))
+  } catch {
+    return null
+  }
+}
+
+function check(id, label, ok, evidence, risk = '') {
+  return { id, label, status: ok ? 'passed' : 'failed', evidence, risk }
+}
+
+const listingText = read('assets/marketplace/gse-listing.json')
+const listing = readJson('assets/marketplace/gse-listing.json')
+const marketplaceRef = read('references/marketplace-discovery.md')
+const packaging = read('references/packaging.md')
+const openai = read('agents/openai.yaml')
+const validate = read('scripts/validate-gse.mjs')
+
+const keywords = new Set(Array.isArray(listing?.keywords) ? listing.keywords : [])
+const categories = new Set(Array.isArray(listing?.categories) ? listing.categories : [])
+const entrypoints = new Set(Array.isArray(listing?.entrypoints) ? listing.entrypoints : [])
+const verification = Array.isArray(listing?.verification) ? listing.verification : []
+const hostSupport = Array.isArray(listing?.hostSupport) ? listing.hostSupport : []
+const boundaries = Array.isArray(listing?.boundaries) ? listing.boundaries.join('\n') : ''
+const privateLeakPattern = new RegExp(
+  [
+    ['C:', 'Users', 'Admin'].join('[\\\\\\\\/]'),
+    ['D:', 'codex'].join('[\\\\\\\\/]'),
+    ['hermes', 'workspace'].join('[-_]'),
+    ['node', 'banana'].join('[-_]'),
+  ].join('|'),
+  'i',
+)
+const noPrivateOrLocalLeak =
+  !privateLeakPattern.test(listingText) &&
+  !privateLeakPattern.test(marketplaceRef)
+
+const checks = [
+  check('MD01', 'marketplace listing metadata exists and parses', Boolean(listing), 'assets/marketplace/gse-listing.json'),
+  check('MD02', 'listing has searchable identity and summary', listing?.name === 'gse' && listing?.displayName === 'GSE' && typeof listing?.tagline === 'string' && listing.tagline.length > 20 && typeof listing?.summary === 'string' && listing.summary.includes('Goal-Spec-Evidence'), 'name, displayName, tagline, summary'),
+  check('MD03', 'listing uses natural ecosystem keywords', ['agentic engineering', 'spec-driven development', 'SDD', 'AI coding agent workflow', 'evidence gates', 'goal map'].every((item) => keywords.has(item)), 'keywords'),
+  check('MD04', 'listing classifies project category without keyword stuffing block', categories.has('agentic engineering') && categories.has('software development workflow') && marketplaceRef.includes('Do not add isolated search-term blocks'), 'categories and marketplace reference'),
+  check('MD05', 'listing exposes human and machine entrypoints', ['SKILL.md', 'README.md', 'README.zh-CN.md', 'scripts/run-gse-command.mjs', 'scripts/validate-gse.mjs'].every((item) => entrypoints.has(item)), 'entrypoints'),
+  check('MD06', 'listing exposes validation commands', verification.some((item) => item.includes('validate-gse.mjs')) && verification.some((item) => item.includes('audit-marketplace-discovery.mjs')) && verification.some((item) => item.includes('audit-host-ui-invocation.mjs')), 'verification commands'),
+  check('MD07', 'listing separates host support status from proof', hostSupport.some((item) => item.host.includes('Codex') && item.status === 'documented') && hostSupport.some((item) => item.host.includes('Claude') && item.status === 'documented') && boundaries.includes('native host UI invocation require separate evidence'), 'hostSupport and boundaries'),
+  check('MD08', 'release trust and distribution references are linked', listing?.distribution?.packageScript === 'scripts/package-gse.mjs' && listing?.distribution?.trustPolicy === 'references/release-trust.md' && packaging.includes('references/marketplace-discovery.md'), 'distribution metadata and packaging reference'),
+  check('MD09', 'OpenAI host metadata remains present', openai.includes('display_name: "GSE"') && openai.includes('default_prompt'), 'agents/openai.yaml'),
+  check('MD10', 'validator includes marketplace discovery audit', validate.includes('audit-marketplace-discovery.mjs'), 'scripts/validate-gse.mjs'),
+  check('MD11', 'metadata avoids local/private project leakage', noPrivateOrLocalLeak, 'listing and marketplace reference'),
+]
+
+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: { marketplaceDiscovery: failed === 0 ? 'verified' : 'failed' },
+  acceptedBy: 'not accepted; this audit verifies metadata readiness but does not publish to or receive approval from a marketplace',
+  limits: [
+    'This audit verifies local discovery metadata, not marketplace approval.',
+    'It does not prove maintainer identity, public registry publication, ranking, search indexing, or host-native installation.',
+  ],
+  checks,
+}
+
+function renderMarkdown(data) {
+  const lines = []
+  lines.push('# GSE Marketplace Discovery 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('- Marketplace discovery: ' + data.workflows.marketplaceDiscovery)
+  lines.push('- Accepted by: ' + data.acceptedBy)
+  lines.push('')
+  lines.push('## Checks')
+  lines.push('')
+  for (const item of data.checks) {
+    const marker = item.status === 'passed' ? '[x]' : '[ ]'
+    lines.push('- ' + marker + ' ' + item.id + ' ' + item.label + ': ' + item.evidence)
+  }
+  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-npm-package-metadata.mjs

@@ -0,0 +1,155 @@
+#!/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 jsonOnly = args.includes('--json')
+
+function readJson(relativePath) {
+  const fullPath = path.join(root, relativePath)
+  if (!fs.existsSync(fullPath)) return null
+  try {
+    return JSON.parse(fs.readFileSync(fullPath, 'utf8').replace(/^\uFEFF/, ''))
+  } catch {
+    return null
+  }
+}
+
+function exists(relativePath) {
+  return fs.existsSync(path.join(root, relativePath))
+}
+
+function run(command, commandArgs) {
+  const result = spawnSync(command, commandArgs, {
+    cwd: root,
+    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 }
+}
+
+const pkg = readJson('package.json')
+const packRun = process.platform === 'win32'
+  ? run('cmd', ['/c', 'npm', 'pack', '--dry-run', '--json'])
+  : run('npm', ['pack', '--dry-run', '--json'])
+const packData = parseJson(packRun.stdout)
+const packFiles = new Set((Array.isArray(packData) ? packData[0]?.files : []).map((item) => item.path))
+const packageFiles = new Set(pkg?.files ?? [])
+const requiredPackageFiles = [
+  'SKILL.md',
+  'README.md',
+  'README.zh-CN.md',
+  'LICENSE',
+  'package.json',
+  'scripts/gse.mjs',
+  'scripts/audit-npm-tarball-install.mjs',
+  'scripts/validate-gse.mjs',
+  'scripts/run-gse-command.mjs',
+  'references/commands.md',
+  'references/packaging.md',
+]
+const requiredFilesWhitelist = [
+  'SKILL.md',
+  'README.md',
+  'README.zh-CN.md',
+  'LICENSE',
+  'scripts',
+  'references',
+]
+
+const checks = [
+  check('NPM01', 'package.json exists and parses', Boolean(pkg), 'package.json'),
+  check('NPM02', 'package uses the accepted MIT license', pkg?.license === 'MIT' && exists('LICENSE'), 'license=' + (pkg?.license ?? 'missing')),
+  check('NPM03', 'package declares ESM and Node runtime floor', pkg?.type === 'module' && /^>=18\b/.test(pkg?.engines?.node ?? ''), 'type=' + (pkg?.type ?? 'missing') + ', node=' + (pkg?.engines?.node ?? 'missing')),
+  check('NPM04', 'package exposes gse CLI bin entrypoint', pkg?.bin?.gse === 'scripts/gse.mjs' && exists('scripts/gse.mjs'), 'bin.gse=' + (pkg?.bin?.gse ?? 'missing')),
+  check('NPM05', 'package exposes validation and npm audit scripts', pkg?.scripts?.validate?.includes('validate-gse.mjs') && pkg?.scripts?.['audit:npm']?.includes('audit-npm-package-metadata.mjs') && pkg?.scripts?.['audit:npm-install']?.includes('audit-npm-tarball-install.mjs'), 'scripts.validate, scripts.audit:npm, and scripts.audit:npm-install'),
+  check('NPM06', 'files whitelist includes core skill content', requiredFilesWhitelist.every((item) => packageFiles.has(item)), requiredFilesWhitelist.join(', ')),
+  check('NPM07', 'npm pack dry-run succeeds', packRun.status === 0 && Array.isArray(packData) && packData.length === 1, packRun.command, packRun.stderr),
+  check('NPM08', 'npm pack dry-run includes required runtime files', requiredPackageFiles.every((item) => packFiles.has(item)), requiredPackageFiles.filter((item) => !packFiles.has(item)).join(', ') || 'all required files present'),
+  check('NPM09', 'npm package metadata does not claim registry publication', !pkg?.publishConfig && !pkg?.repository, 'no publishConfig or repository claim until public repo/channel evidence exists'),
+]
+
+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: {
+    npmPackageMetadata: failed === 0 ? 'verified' : 'failed',
+    npmPackDryRun: packRun.status === 0 ? 'verified' : 'failed',
+  },
+  package: pkg
+    ? {
+        name: pkg.name,
+        version: pkg.version,
+        bin: pkg.bin,
+        license: pkg.license,
+        files: pkg.files?.length ?? 0,
+      }
+    : null,
+  commands: [packRun.command],
+  limits: [
+    'This audit verifies Node package metadata and npm pack dry-run only.',
+    'It does not publish GSE to npm, prove package name ownership, prove public repository settings, or prove marketplace approval.',
+  ],
+  checks,
+}
+
+function renderMarkdown(data) {
+  const lines = []
+  lines.push('# GSE npm Package Metadata 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('- npm package metadata: ' + data.workflows.npmPackageMetadata)
+  lines.push('- npm pack dry-run: ' + data.workflows.npmPackDryRun)
+  lines.push('')
+  lines.push('## Checks')
+  lines.push('')
+  for (const item of data.checks) {
+    const marker = item.status === 'passed' ? '[x]' : '[ ]'
+    lines.push('- ' + marker + ' ' + item.id + ' ' + item.label + ': ' + item.evidence)
+  }
+  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)