@t275005746/gse 0.1.1 → 0.2.0

package/scripts/audit-learning-promotion.mjs

@@ -0,0 +1,351 @@
+#!/usr/bin/env node
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+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 targetArg = readArg('--target')
+const jsonOnly = args.includes('--json')
+const write = args.includes('--write') || args.includes('--execute')
+
+function readText(filePath) {
+  return fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, '') : ''
+}
+
+function clean(value) {
+  return String(value ?? '').replace(/\s+/g, ' ').trim()
+}
+
+function normalize(value) {
+  return clean(value)
+    .toLowerCase()
+    .replace(/[`"'“”‘’]/g, '')
+    .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+function slugify(value) {
+  return normalize(value)
+    .replace(/[^\w\u4e00-\u9fa5]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48) || 'learning'
+}
+
+function check(id, label, ok, evidence, risk = '') {
+  return { id, label, status: ok ? 'passed' : 'failed', evidence, risk }
+}
+
+const CATEGORY_RULES = [
+  { category: 'encoding', severity: 'high', patterns: [/utf-?8/i, /encoding/i, /mojibake/i, /乱码/, /中文/] },
+  { category: 'shell', severity: 'high', patterns: [/powershell/i, /\bcmd\b/i, /&&/, /shell/i, /windows/i] },
+  { category: 'git', severity: 'high', patterns: [/git/i, /sparse/i, /stage/i, /commit/i, /checkout/i] },
+  { category: 'host-tool', severity: 'high', patterns: [/subagent/i, /dispatch/i, /mcp/i, /lsp/i, /native slash/i, /host/i] },
+  { category: 'evidence', severity: 'high', patterns: [/evidence/i, /jsonl/i, /verified/i, /accepted/i, /close gate/i] },
+  { category: 'browser', severity: 'medium', patterns: [/browser/i, /playwright/i, /screenshot/i, /ui\b/i, /component test/i] },
+  { category: 'project-rule', severity: 'medium', patterns: [/project/i, /canonical/i, /goal map/i, /AGENTS\.md/i, /规则/] },
+  { category: 'release', severity: 'medium', patterns: [/release/i, /registry/i, /marketplace/i, /npm/i, /ci\b/i, /security contact/i] },
+]
+
+function classify(summary, trigger = '', impact = '') {
+  const text = [summary, trigger, impact].join(' ')
+  for (const rule of CATEGORY_RULES) {
+    if (rule.patterns.some((pattern) => pattern.test(text))) {
+      return { category: rule.category, severity: rule.severity }
+    }
+  }
+  return { category: 'project-rule', severity: 'low' }
+}
+
+function promotionFor(count, severity) {
+  if (count >= 5) return { level: 'script-or-skill-update', target: severity === 'high' ? 'script/test plus project guard' : 'template or skill update' }
+  if (count >= 3) return { level: 'guard-or-quality-gate', target: severity === 'high' ? 'project guard or quality gate' : 'project guard candidate' }
+  if (count >= 2) return { level: 'checklist-or-template', target: 'checklist or template update' }
+  return { level: 'learning-note', target: 'keep as learning note' }
+}
+
+function parseLearningEntries(text) {
+  const entries = []
+  let current = null
+  for (const line of text.split(/\r?\n/)) {
+    const heading = line.match(/^##\s+(.+)$/)
+    if (heading) {
+      if (current) entries.push(current)
+      current = { heading: heading[1], trigger: '', summary: '', source: '', impact: '', promotion: '', status: '', occurrences: 1 }
+      continue
+    }
+    if (!current) continue
+    const field = line.match(/^-\s*([^:]+):\s*(.*)$/)
+    if (!field) continue
+    const key = normalize(field[1])
+    const value = clean(field[2])
+    if (key === 'trigger') current.trigger = value
+    if (key === 'summary') current.summary = value
+    if (key === 'source') current.source = value
+    if (key === 'impact') current.impact = value
+    if (key === 'promotion') current.promotion = value
+    if (key === 'status') current.status = value
+    if (key === 'occurrences') current.occurrences = Math.max(1, Number(value) || 1)
+  }
+  if (current) entries.push(current)
+  return entries.filter((entry) => entry.summary)
+}
+
+function groupEntries(entries) {
+  const groups = new Map()
+  for (const entry of entries) {
+    const key = normalize(entry.summary)
+    const existing = groups.get(key) ?? {
+      key,
+      summary: entry.summary,
+      triggerExamples: [],
+      sourceExamples: [],
+      impactExamples: [],
+      entries: [],
+    }
+    existing.entries.push(entry)
+    existing.count = (existing.count ?? 0) + (entry.occurrences ?? 1)
+    if (entry.trigger && !existing.triggerExamples.includes(entry.trigger)) existing.triggerExamples.push(entry.trigger)
+    if (entry.source && !existing.sourceExamples.includes(entry.source)) existing.sourceExamples.push(entry.source)
+    if (entry.impact && !existing.impactExamples.includes(entry.impact)) existing.impactExamples.push(entry.impact)
+    groups.set(key, existing)
+  }
+  return [...groups.values()]
+}
+
+function renderPromotionsMarkdown(report) {
+  const lines = []
+  lines.push('# Learning Promotions')
+  lines.push('')
+  lines.push('Generated: ' + report.generatedAt)
+  lines.push('Source: `.gse/learnings.md`')
+  lines.push('')
+  lines.push('This file is generated by `scripts/audit-learning-promotion.mjs --write`.')
+  lines.push('Review candidates before copying any rule into `.gse/project-guards.md`, `.gse/quality-gates.md`, templates, scripts, or the GSE skill.')
+  lines.push('')
+  lines.push('| ID | Category | Severity | Count | Promotion | Target | Summary |')
+  lines.push('|---|---|---|---:|---|---|---|')
+  for (const item of report.promotions) {
+    lines.push(`| ${item.id} | ${item.category} | ${item.severity} | ${item.count} | ${item.promotionLevel} | ${item.promotionTarget} | ${item.summary.replace(/\|/g, '/')} |`)
+  }
+  if (report.promotions.length === 0) lines.push('| none | - | - | 0 | learning-note | keep recording | No repeated lesson has reached promotion threshold yet. |')
+  lines.push('')
+  lines.push('## Guard Candidates')
+  lines.push('')
+  for (const item of report.promotions.filter((candidate) => ['guard-or-quality-gate', 'script-or-skill-update'].includes(candidate.promotionLevel))) {
+    lines.push(`### ${item.id}`)
+    lines.push('')
+    lines.push('- Guard: ' + item.summary)
+    lines.push('- Severity: ' + item.severity)
+    lines.push('- Trigger: ' + item.category)
+    lines.push('- Check: Confirm this lesson is handled before implementation or close.')
+    lines.push('- Source count: ' + item.count)
+    lines.push('')
+  }
+  return lines.join('\n') + '\n'
+}
+
+export function analyzeLearningPromotions(target) {
+  const resolvedTarget = path.resolve(target)
+  const learningsPath = path.join(resolvedTarget, '.gse', 'learnings.md')
+  const exists = fs.existsSync(learningsPath)
+  const text = exists ? readText(learningsPath) : ''
+  const entries = parseLearningEntries(text)
+  const groups = groupEntries(entries)
+  const promotions = groups.map((group) => {
+    const classification = classify(group.summary, group.triggerExamples.join(' '), group.impactExamples.join(' '))
+    const count = group.count || group.entries.length
+    const promotion = promotionFor(count, classification.severity)
+    return {
+      id: 'LP-' + slugify(group.summary).toUpperCase(),
+      summary: group.summary,
+      category: classification.category,
+      severity: classification.severity,
+      count,
+      promotionLevel: promotion.level,
+      promotionTarget: promotion.target,
+      triggerExamples: group.triggerExamples.slice(0, 3),
+      sourceExamples: group.sourceExamples.slice(0, 3),
+      impactExamples: group.impactExamples.slice(0, 3),
+    }
+  }).sort((a, b) => {
+    const levelOrder = { 'script-or-skill-update': 0, 'guard-or-quality-gate': 1, 'checklist-or-template': 2, 'learning-note': 3 }
+    return (levelOrder[a.promotionLevel] ?? 9) - (levelOrder[b.promotionLevel] ?? 9) || b.count - a.count || a.id.localeCompare(b.id)
+  })
+  const promoted = promotions.filter((item) => item.promotionLevel !== 'learning-note')
+  const guardCandidates = promotions.filter((item) => ['guard-or-quality-gate', 'script-or-skill-update'].includes(item.promotionLevel))
+  const scriptCandidates = promotions.filter((item) => item.promotionLevel === 'script-or-skill-update')
+  const outputPath = path.join(resolvedTarget, '.gse', 'learning-promotions.md')
+  return {
+    target: resolvedTarget,
+    generatedAt: new Date().toISOString(),
+    path: '.gse/learning-promotions.md',
+    source: '.gse/learnings.md',
+    exists,
+    summary: {
+      status: !exists ? 'warning' : 'passed',
+      entries: entries.length,
+      uniqueLessons: groups.length,
+      duplicateGroups: groups.filter((group) => group.entries.length > 1).length,
+      promoted: promoted.length,
+      guardCandidates: guardCandidates.length,
+      scriptCandidates: scriptCandidates.length,
+    },
+    promotions,
+    outputPath,
+    limits: [
+      'Promotion analysis is deterministic and project-generic; it does not hardcode AION or MuseFlow behavior.',
+      'Write mode creates .gse/learning-promotions.md candidates only; project guards and scripts still require deliberate review.',
+      'Missing learnings are a warning, not a hard failure, because new projects may not have lessons yet.',
+    ],
+  }
+}
+
+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 createFixture() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gse-learning-promotion-'))
+  const init = run('init-project.mjs', ['--target', dir, '--mode', 'standard', '--json'])
+  const learningsPath = path.join(dir, '.gse', 'learnings.md')
+  const entry = (date, summary, trigger, source) => [
+    `## ${date} - ${slugify(summary)}`,
+    '',
+    '- Trigger: ' + trigger,
+    '- Summary: ' + summary,
+    '- Source: ' + source,
+    '- Impact: prevents recurring workflow failure',
+    '- Promotion: learning promotion audit fixture',
+    '- Status: learning-note',
+    '',
+  ].join('\n')
+  const text = [
+    '# Learnings',
+    '',
+    entry('2026-07-08', 'Use UTF-8 safe readers before judging Chinese document mojibake', 'encoding review', 'fixture'),
+    entry('2026-07-08', 'Use UTF-8 safe readers before judging Chinese document mojibake', 'encoding review repeat', 'fixture'),
+    entry('2026-07-08', 'Use UTF-8 safe readers before judging Chinese document mojibake', 'encoding review third', 'fixture'),
+    entry('2026-07-08', 'Do not claim real subagent dispatch without host evidence', 'subagent review', 'fixture'),
+    entry('2026-07-08', 'Do not claim real subagent dispatch without host evidence', 'subagent review repeat', 'fixture'),
+    entry('2026-07-08', 'Avoid PowerShell && and use host-appropriate shell syntax on Windows', 'shell failure', 'fixture'),
+    entry('2026-07-08', 'Avoid PowerShell && and use host-appropriate shell syntax on Windows', 'shell failure repeat', 'fixture'),
+    entry('2026-07-08', 'Avoid PowerShell && and use host-appropriate shell syntax on Windows', 'shell failure third', 'fixture'),
+    entry('2026-07-08', 'Avoid PowerShell && and use host-appropriate shell syntax on Windows', 'shell failure fourth', 'fixture'),
+    entry('2026-07-08', 'Avoid PowerShell && and use host-appropriate shell syntax on Windows', 'shell failure fifth', 'fixture'),
+  ].join('\n')
+  fs.writeFileSync(learningsPath, text, 'utf8')
+  return { dir, init }
+}
+
+function audit(target) {
+  const analysis = analyzeLearningPromotions(target)
+  const checks = [
+    check('LP01', 'learning promotion source is present or reported as warning', analysis.exists || analysis.summary.status === 'warning', analysis.exists ? analysis.source : 'missing learnings warning'),
+    check('LP02', 'learning entries parse into normalized groups', !analysis.exists || analysis.summary.uniqueLessons > 0, `${analysis.summary.uniqueLessons} unique lesson(s)`),
+    check('LP03', 'promotion thresholds follow documented upgrade rule', analysis.promotions.every((item) =>
+      (item.count >= 5 && item.promotionLevel === 'script-or-skill-update') ||
+      (item.count >= 3 && item.count < 5 && item.promotionLevel === 'guard-or-quality-gate') ||
+      (item.count >= 2 && item.count < 3 && item.promotionLevel === 'checklist-or-template') ||
+      (item.count < 2 && item.promotionLevel === 'learning-note')
+    ), 'note -> checklist/template -> guard/quality gate -> script/skill'),
+    check('LP04', 'promotion candidates include category and severity', analysis.promotions.every((item) => item.category && item.severity), 'category/severity assigned'),
+    check('LP05', 'write mode is candidate-only', true, 'write mode creates .gse/learning-promotions.md, not project guard mutations'),
+  ]
+  let writeStatus = null
+  if (write) {
+    fs.mkdirSync(path.dirname(analysis.outputPath), { recursive: true })
+    fs.writeFileSync(analysis.outputPath, renderPromotionsMarkdown(analysis), 'utf8')
+    writeStatus = {
+      status: 'written',
+      path: analysis.path,
+      effect: 'candidate-only learning promotion report',
+    }
+  }
+  const passed = checks.filter((item) => item.status === 'passed').length
+  const failed = checks.length - passed
+  return {
+    ...analysis,
+    summary: {
+      ...analysis.summary,
+      status: failed === 0 ? analysis.summary.status : 'failed',
+      passed,
+      failed,
+      total: checks.length,
+    },
+    workflows: {
+      learningPromotion: failed === 0 ? 'verified' : 'failed',
+      candidateWrite: write ? 'verified' : 'dry-run',
+    },
+    write: writeStatus,
+    checks,
+  }
+}
+
+function selfTestReport() {
+  const fixture = createFixture()
+  const fixtureReport = audit(fixture.dir)
+  const missingDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gse-learning-promotion-missing-'))
+  fs.mkdirSync(path.join(missingDir, '.gse'), { recursive: true })
+  const missingReport = analyzeLearningPromotions(missingDir)
+  fs.rmSync(fixture.dir, { recursive: true, force: true })
+  fs.rmSync(missingDir, { recursive: true, force: true })
+  const checks = [
+    check('LPA01', 'init-project supports learning store', fixture.init.status === 0, 'scripts/init-project.mjs'),
+    check('LPA02', 'repeated encoding lesson becomes guard candidate', fixtureReport.promotions.some((item) => item.category === 'encoding' && item.count === 3 && item.promotionLevel === 'guard-or-quality-gate'), 'encoding fixture'),
+    check('LPA03', 'fifth shell occurrence becomes script or skill candidate', fixtureReport.promotions.some((item) => item.category === 'shell' && item.count === 5 && item.promotionLevel === 'script-or-skill-update'), 'shell fixture'),
+    check('LPA04', 'second host-tool lesson becomes checklist/template candidate', fixtureReport.promotions.some((item) => item.category === 'host-tool' && item.count === 2 && item.promotionLevel === 'checklist-or-template'), 'host-tool fixture'),
+    check('LPA05', 'missing learnings is warning not hard failure', missingReport.summary.status === 'warning', 'missing learning store'),
+  ]
+  const passed = checks.filter((item) => item.status === 'passed').length
+  const failed = checks.length - passed
+  return {
+    root,
+    generatedAt: new Date().toISOString(),
+    summary: { status: failed === 0 ? 'passed' : 'failed', passed, failed, total: checks.length },
+    workflows: {
+      learningPromotion: failed === 0 ? 'verified' : 'failed',
+      fixtureCoverage: failed === 0 ? 'verified' : 'failed',
+    },
+    fixture: {
+      promoted: fixtureReport.summary.promoted,
+      guardCandidates: fixtureReport.summary.guardCandidates,
+      scriptCandidates: fixtureReport.summary.scriptCandidates,
+      categories: fixtureReport.promotions.map((item) => item.category),
+    },
+    checks,
+    limits: [
+      'Self-test uses generic shell, encoding, and host-tool lessons.',
+      'No target-project behavior is hardcoded.',
+    ],
+  }
+}
+
+const isCli = process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])
+
+if (isCli) {
+  const report = targetArg ? audit(targetArg) : selfTestReport()
+  if (jsonOnly) console.log(JSON.stringify(report, null, 2))
+  else console.log(JSON.stringify(report, null, 2))
+  if (report.summary.status === 'failed') process.exit(1)
+}

package/scripts/audit-learning-system.mjs

@@ -49,20 +49,28 @@ const dryRun = run('record-learning.mjs', ['--target', target, '--summary', summ
 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 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 promoteDryRun = run('run-gse-command.mjs', ['--root', root, '--target', target, '--command', '/gse learn --promote', '--json'])
+const promoteWriteRun = run('run-gse-command.mjs', ['--root', root, '--target', target, '--command', '/gse learn --promote', '--execute', '--json'])
+const promotionsPath = path.join(target, '.gse', 'learning-promotions.md')
+const promotionsText = fs.existsSync(promotionsPath) ? fs.readFileSync(promotionsPath, '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 commandDry = parseJson(commandDryRun.stdout)
+const commandDryChild = parseJson(commandDry?.execution?.stdout ?? '')
+const commandWrite = parseJson(commandWriteRun.stdout)
+const commandWriteChild = parseJson(commandWrite?.execution?.stdout ?? '')
+const promoteDry = parseJson(promoteDryRun.stdout)
+const promoteDryChild = parseJson(promoteDry?.execution?.stdout ?? '')
+const promoteWrite = parseJson(promoteWriteRun.stdout)
+const promoteWriteChild = parseJson(promoteWrite?.execution?.stdout ?? '')
 
 const checks = [
   check('LRN01', 'record-learning script exists', fs.existsSync(path.join(root, 'scripts', 'record-learning.mjs')), 'scripts/record-learning.mjs'),
@@ -71,10 +79,12 @@ const checks = [
   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'),
-]
+  check('LRN07', 'duplicate summary increments occurrence without appending another entry', duplicateRun.status === 0 && duplicate?.status === 'updated' && afterDuplicate.includes('- Occurrences: 2') && (afterDuplicate.match(new RegExp('- Summary: ' + summary.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')) ?? []).length === 1, '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'),
+  check('LRN10', '/gse learn --promote dry-runs promotion analysis', promoteDryRun.status === 0 && promoteDry?.verb === 'learn' && promoteDryChild?.workflows?.learningPromotion === 'verified', '/gse learn --promote'),
+  check('LRN11', '/gse learn --promote --execute writes candidate-only report', promoteWriteRun.status === 0 && promoteWrite?.verb === 'learn' && promoteWriteChild?.write?.status === 'written' && promotionsText.includes('# Learning Promotions'), '/gse learn --promote --execute'),
+]
 
 const passed = checks.filter((item) => item.status === 'passed').length
 const failed = checks.length - passed
@@ -87,7 +97,7 @@ const report = {
     learningCommand: failed === 0 ? 'verified' : 'failed',
     learningStore: failed === 0 ? 'verified' : 'failed',
   },
-  commands: [waitingRun.command, dryRun.command, writeRun.command, duplicateRun.command, commandDryRun.command, commandWriteRun.command],
+  commands: [waitingRun.command, dryRun.command, writeRun.command, duplicateRun.command, commandDryRun.command, commandWriteRun.command, promoteDryRun.command, promoteWriteRun.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.',

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

@@ -45,10 +45,11 @@ 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 nonExternalIncompleteRows = finalRows.filter((row) => {
+  if (row.status === 'verified') return false
+  if (row.status === 'not-claimed') 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
@@ -57,11 +58,11 @@ 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('LFC04', 'portable-core final-form readiness is accepted when only optional host-native claims remain not-claimed', progress.status === 0 && progress.data?.workflows?.publicAccepted === 'verified' && 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'),
+  check('LFC06', 'public acceptance doctor passes and accepts required GSE core gates', publicAcceptance.status === 0 && publicAcceptance.data?.summary?.failed === 0 && publicAcceptance.data?.summary?.publicAccepted === 'verified', publicAcceptance.command),
+  check('LFC07', 'public acceptance has no pending owner/external gates after optional host-native claims are excluded', pendingGateAreas.length === 0 && expectedPendingAreas.length === 0, pendingGateAreas.join(', ') || 'none'),
+  check('LFC08', 'pending gate command templates are not required when no owner/external gates remain', 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
@@ -91,8 +92,8 @@ const report = {
   })),
   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.',
+    'It does not create optional host-native slash-command evidence.',
+    'A host-native slash claim still requires a per-host accepted invocation record and final readiness re-audit.',
   ],
   checks,
 }

package/scripts/audit-maintenance-cadence.mjs

@@ -0,0 +1,139 @@
+#!/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 check(id, label, ok, evidence, risk = '') {
+  return { id, label, status: ok ? 'passed' : 'failed', evidence, risk }
+}
+
+const maintenance = read('references/maintenance-cadence.md')
+const skill = read('SKILL.md')
+const validationProfile = read('scripts/run-validation-profile.mjs')
+const validator = read('scripts/validate-gse.mjs')
+const commandRunner = read('scripts/run-gse-command.mjs')
+const roadmap = read('references/final-form-roadmap.md')
+const masterPlan = read('.gse/gse-design-master-plan.md')
+
+const requiredAreas = [
+  'Benchmark audit',
+  'Drift audit',
+  'Dependency and security review',
+  'Forward test',
+  'Target-project hardening drill',
+  'Public acceptance doctor',
+  'Installed skill sync',
+  'Active session sync',
+]
+
+const requiredCommands = [
+  'audit-final-form-roadmap.mjs',
+  'audit-learning-drift.mjs',
+  'audit-release-trust.mjs',
+  'forward-test-gse.mjs',
+  'audit-target-hardening-drills.mjs',
+  'audit-public-acceptance-readiness.mjs',
+  'audit-installed-sync.mjs',
+  'audit-session-sync.mjs',
+  'record-session-sync.mjs',
+  'generate-maintenance-snapshot.mjs',
+  'audit-maintenance-snapshot.mjs',
+  'run-gse-command.mjs',
+]
+
+const scriptTargets = [
+  'scripts/audit-final-form-roadmap.mjs',
+  'scripts/audit-learning-drift.mjs',
+  'scripts/audit-release-trust.mjs',
+  'scripts/forward-test-gse.mjs',
+  'scripts/audit-target-hardening-drills.mjs',
+  'scripts/audit-public-acceptance-readiness.mjs',
+  'scripts/audit-installed-sync.mjs',
+  'scripts/audit-session-sync.mjs',
+  'scripts/record-session-sync.mjs',
+  'scripts/generate-maintenance-snapshot.mjs',
+  'scripts/audit-maintenance-snapshot.mjs',
+  'scripts/run-gse-command.mjs',
+]
+
+const checks = [
+  check('MC01', 'maintenance cadence reference exists', exists('references/maintenance-cadence.md'), 'references/maintenance-cadence.md'),
+  check('MC02', 'cadence covers all final-form upkeep areas', requiredAreas.every((term) => maintenance.includes(term)), requiredAreas.join(', ')),
+  check('MC03', 'cadence maps each area to executable commands', requiredCommands.every((term) => maintenance.includes(term)), requiredCommands.join(', ')),
+  check('MC04', 'cadence distinguishes recurring maintenance from external acceptance', maintenance.includes('not a substitute for native host evidence') && maintenance.includes('remaining external gates stay visible'), 'claim boundary'),
+  check('MC05', 'all referenced maintenance scripts exist', scriptTargets.every((target) => exists(target)), scriptTargets.join(', ')),
+  check('MC06', 'skill routing exposes maintenance cadence', skill.includes('references/maintenance-cadence.md') && skill.includes('audit-maintenance-cadence.mjs'), 'SKILL.md'),
+  check('MC07', 'portable command runner exposes /gse maintenance snapshot route', commandRunner.includes('maintenance') && commandRunner.includes('generate-maintenance-snapshot.mjs'), 'scripts/run-gse-command.mjs'),
+  check('MC08', 'validation profile includes maintenance cadence audit', validationProfile.includes('audit-maintenance-cadence.mjs'), 'scripts/run-validation-profile.mjs'),
+  check('MC09', 'consolidated validator includes maintenance cadence audit', validator.includes('audit-maintenance-cadence.mjs'), 'scripts/validate-gse.mjs'),
+  check('MC10', 'final-form roadmap tracks maintenance cadence as Wave 5 capability', roadmap.includes('Maintenance cadence') && roadmap.includes('audit-maintenance-cadence.mjs'), 'references/final-form-roadmap.md'),
+  check('MC11', 'master plan current priority includes maintenance cadence evidence', masterPlan.includes('maintenance cadence') && masterPlan.includes('audit-maintenance-cadence.mjs'), '.gse/gse-design-master-plan.md'),
+]
+
+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: {
+    maintenanceCadence: failed === 0 ? 'verified' : 'failed',
+    externalNativeSlashCommand: 'external-required',
+  },
+  limits: [
+    'This audit verifies recurring maintenance coverage and command wiring.',
+    'It does not prove a real host-native slash command, public CI run, marketplace approval, or owner acceptance.',
+  ],
+  checks,
+}
+
+function renderMarkdown(data) {
+  const lines = []
+  lines.push('# GSE Maintenance Cadence 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('- Maintenance cadence: ' + data.workflows.maintenanceCadence)
+  lines.push('- External native slash command: ' + data.workflows.externalNativeSlashCommand)
+  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)