@t275005746/gse 0.1.0 → 0.1.2

package/scripts/generate-continue-packet.mjs

@@ -0,0 +1,1214 @@
+#!/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'
+import { readProjectGuards } from './audit-project-guards.mjs'
+import { analyzeEvidenceLevels } from './audit-evidence-levels.mjs'
+import { analyzeEvidenceReviewQueue } from './audit-evidence-review-queue.mjs'
+import { readRoleDispatchFallback } from './audit-role-dispatch-fallback.mjs'
+import { auditStateRepair } from './audit-state-repair.mjs'
+import { analyzeLearningPromotions } from './audit-learning-promotion.mjs'
+import { auditLearningDrift } from './audit-learning-drift.mjs'
+import { readHostCapabilities } from './audit-host-capabilities.mjs'
+import { auditToolFallbackPolicy } from './audit-tool-fallback-policy.mjs'
+
+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 selfTest = args.includes('--self-test') || !targetArg
+
+function readText(filePath) {
+  return fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, '') : ''
+}
+
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) return { exists: false, ok: false, data: null, error: 'missing' }
+  try {
+    return { exists: true, ok: true, data: JSON.parse(readText(filePath)), error: '' }
+  } catch (error) {
+    return { exists: true, ok: false, data: null, error: error.message }
+  }
+}
+
+function readJsonl(filePath) {
+  if (!fs.existsSync(filePath)) return { exists: false, ok: false, records: [], error: 'missing' }
+  const lines = readText(filePath)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+  const records = []
+  for (const [index, line] of lines.entries()) {
+    try {
+      records.push(JSON.parse(line))
+    } catch (error) {
+      return { exists: true, ok: false, records, error: `line ${index + 1}: ${error.message}` }
+    }
+  }
+  return { exists: true, ok: true, records, error: '' }
+}
+
+function readMaintenanceSnapshot(target) {
+  const snapshotPath = path.join(target, '.gse', 'maintenance', 'latest-maintenance-snapshot.json')
+  const snapshot = readJson(snapshotPath)
+  if (!snapshot.ok) {
+    return {
+      exists: snapshot.exists,
+      status: snapshot.exists ? 'invalid' : 'missing',
+      generatedAt: null,
+      summary: null,
+      installedSync: null,
+      releaseBundleFreshness: null,
+      installedSyncMode: 'unknown',
+      path: snapshotPath,
+      error: snapshot.error,
+    }
+  }
+  const data = snapshot.data
+  return {
+    exists: true,
+    status: data?.summary?.status ?? 'unknown',
+    generatedAt: data?.generatedAt ?? null,
+    summary: data?.summary ?? null,
+    installedSync: data?.workflows?.installedSync ?? 'unknown',
+    releaseBundleFreshness: data?.workflows?.releaseBundleFreshness ?? 'unknown',
+    installedSyncMode: data?.summary?.installedSyncMode ?? 'unknown',
+    path: snapshotPath,
+    error: '',
+  }
+}
+
+function readSessionSyncBoundary(target) {
+  const recordPath = path.join(target, '.gse', 'session-sync.jsonl')
+  const parsed = readJsonl(recordPath)
+  if (!parsed.exists) {
+    return {
+      exists: false,
+      valid: true,
+      totalRecords: 0,
+      statusCounts: {},
+      installedSyncRecorded: false,
+      latestInstalledSync: null,
+      latestThreadOutcomes: [],
+      adoptionProven: false,
+      boundary: 'no-session-sync-records',
+      latestRecords: [],
+      error: '',
+      limits: [
+        'Missing session sync records mean no active-session notification evidence is being claimed.',
+        'Installed-copy sync and cross-session adoption are separate claims.',
+      ],
+    }
+  }
+  if (!parsed.ok) {
+    return {
+      exists: true,
+      valid: false,
+      totalRecords: parsed.records.length,
+      statusCounts: {},
+      installedSyncRecorded: false,
+      latestInstalledSync: null,
+      latestThreadOutcomes: [],
+      adoptionProven: false,
+      boundary: 'invalid-session-sync-records',
+      latestRecords: [],
+      error: parsed.error,
+      limits: [
+        'Invalid session sync JSONL cannot support installed-copy or active-session sync claims.',
+        'Repair .gse/session-sync.jsonl before relying on sync evidence.',
+      ],
+    }
+  }
+
+  const statusCounts = {}
+  for (const record of parsed.records) {
+    const status = record.status || 'unknown'
+    statusCounts[status] = (statusCounts[status] || 0) + 1
+  }
+  const installedRecords = parsed.records.filter((record) => record.status === 'installed-sync')
+  const threadMap = new Map()
+  for (const record of parsed.records) {
+    if (record.threadId) threadMap.set(record.threadId, record)
+  }
+  const latestThreadOutcomes = [...threadMap.entries()].map(([threadId, record]) => ({
+    threadId,
+    status: record.status,
+    method: record.method,
+    project: record.project ?? null,
+    recordedAt: record.recordedAt ?? null,
+  }))
+  const adoptionProven = parsed.records.some((record) => record.adoptionProven === true || record.adoptionStatus === 'verified')
+
+  return {
+    exists: true,
+    valid: true,
+    totalRecords: parsed.records.length,
+    statusCounts,
+    installedSyncRecorded: installedRecords.length > 0,
+    latestInstalledSync: installedRecords.at(-1) ?? null,
+    latestThreadOutcomes,
+    adoptionProven,
+    boundary: adoptionProven ? 'adoption-recorded' : 'sync-records-do-not-prove-adoption',
+    latestRecords: parsed.records.slice(-5),
+    error: '',
+    limits: [
+      'Session sync records prove notification attempts or installed-copy parity, not target-session adoption by default.',
+      'A target session is adopted only when a future record explicitly carries adoptionProven=true or adoptionStatus=verified with matching evidence.',
+      'Unavailable, skipped, failed, archived, and sent outcomes must stay honest transport outcomes rather than adoption claims.',
+    ],
+  }
+}
+
+function exists(target, relativePath) {
+  return fs.existsSync(path.join(target, relativePath))
+}
+
+function firstMatch(text, regex) {
+  const match = text.match(regex)
+  return match ? match[1].trim() : ''
+}
+
+function cleanInlineValue(value) {
+  return String(value || '').trim().replace(/[.銆?锛歖]+$/, '').trim()
+}
+
+function findCanonicalPlan(target, state) {
+  if (state?.canonicalPlan) return state.canonicalPlan
+  const texts = [
+    readText(path.join(target, '.gse', 'README.md')),
+    readText(path.join(target, '.gse', 'project-profile.md')),
+    readText(path.join(target, '.gse', 'goal-map.md')),
+  ].join('\n')
+  const match = texts.match(/docs\/[A-Za-z0-9._/-]*?(?:architecture|productization)[A-Za-z0-9._/-]*?\.md/)
+  if (match) return match[0]
+  for (const fallback of [
+    'docs/aion-productization-architecture.md',
+    'docs/museflow-ai-film-productization-architecture.md',
+  ]) {
+    if (exists(target, fallback)) return fallback
+  }
+  return ''
+}
+
+function runNode(script, commandArgs, cwd = root) {
+  const result = spawnSync(process.execPath, [path.join(root, 'scripts', script), ...commandArgs], {
+    cwd,
+    encoding: 'utf8',
+    windowsHide: true,
+  })
+  const stdout = (result.stdout ?? '').trim()
+  let data = null
+  try {
+    data = JSON.parse(stdout)
+  } catch {
+    data = null
+  }
+  return {
+    command: [process.execPath, path.join(root, 'scripts', script), ...commandArgs].join(' '),
+    status: result.status ?? 1,
+    ok: (result.status ?? 1) === 0,
+    data,
+    stdout,
+    stderr: (result.stderr ?? '').trim(),
+  }
+}
+
+function listGitChanges(target) {
+  const result = spawnSync('git', ['-C', target, 'status', '--porcelain=v1'], {
+    cwd: target,
+    encoding: 'utf8',
+    windowsHide: true,
+  })
+  if ((result.status ?? 1) !== 0) {
+    return {
+      status: 'unavailable',
+      paths: [],
+      error: (result.stderr ?? '').trim() || 'git status failed',
+    }
+  }
+  const entries = (result.stdout ?? '')
+    .split(/\r?\n/)
+    .filter((line) => line.trim())
+    .map((line) => {
+      const x = line[0] ?? ' '
+      const y = line[1] ?? ' '
+      const rawPath = line.slice(3).replace(/\\/g, '/')
+      const normalizedPath = rawPath.includes(' -> ') ? rawPath.split(' -> ').pop() : rawPath
+      return {
+        code: x + y,
+        path: normalizedPath,
+        staged: x !== ' ' && x !== '?',
+        unstaged: y !== ' ' && y !== '?',
+        untracked: x === '?' && y === '?',
+      }
+    })
+  return { status: 'available', entries, paths: entries.map((entry) => entry.path), error: '' }
+}
+
+function hasPackageScript(target, scriptName) {
+  const packageJson = readJson(path.join(target, 'package.json'))
+  return Boolean(packageJson.ok && packageJson.data?.scripts?.[scriptName])
+}
+
+const generatedArtifactPatterns = [
+  /^node_modules\//,
+  /^output\//,
+  /^playwright-report\//,
+  /^test-results\//,
+  /^coverage\//,
+  /^\.nyc_output\//,
+  /^\.turbo\//,
+  /^\.next\//,
+  /^dist\//,
+  /^build\//,
+]
+
+const transientLockfiles = new Set([
+  'pnpm-lock.yaml',
+  'package-lock.json',
+  'yarn.lock',
+  'bun.lockb',
+])
+
+function isGeneratedOrTransientChange(entry) {
+  const normalized = entry.path.replace(/\\/g, '/')
+  if (generatedArtifactPatterns.some((pattern) => pattern.test(normalized))) return true
+  return entry.untracked && transientLockfiles.has(normalized)
+}
+
+function buildCompletionPlan(target, state, maintenanceSnapshot) {
+  const gitChanges = listGitChanges(target)
+  const changedEntries = gitChanges.entries ?? gitChanges.paths.map((item) => ({ path: item, untracked: false, staged: false, unstaged: true }))
+  const ignoredGeneratedPaths = changedEntries.filter(isGeneratedOrTransientChange).map((entry) => entry.path)
+  const actionableEntries = changedEntries.filter((entry) => !isGeneratedOrTransientChange(entry))
+  const changedPaths = actionableEntries.map((entry) => entry.path)
+  const hasGseScripts = fs.existsSync(path.join(target, 'scripts', 'run-gse-command.mjs'))
+  const hasEncodingCheck = hasPackageScript(target, 'check:encoding')
+  const validationProfile = state?.mode === 'enterprise' ? 'lite' : 'lite'
+  const docsOrLearningChanged = changedPaths.some((item) =>
+    item === 'SKILL.md' ||
+    item === 'README.md' ||
+    item === 'README.zh-CN.md' ||
+    item === 'CHANGELOG.md' ||
+    item.startsWith('docs/') ||
+    item.startsWith('references/') ||
+    item.startsWith('.gse/') ||
+    /\.(md|mdx|json|jsonl|ya?ml)$/i.test(item),
+  )
+  const capabilityChanged = changedPaths.some((item) =>
+    item === 'SKILL.md' ||
+    item === 'package.json' ||
+    item.startsWith('scripts/') ||
+    item.startsWith('references/') ||
+    item.startsWith('assets/') ||
+    item.startsWith('agents/') ||
+    item.startsWith('.github/') ||
+    item === 'README.md' ||
+    item === 'README.zh-CN.md',
+  )
+  const releaseSensitiveChanged = changedPaths.some((item) =>
+    item.startsWith('.gse/acceptance/') ||
+    item.startsWith('.gse/release-bundles/') ||
+    item === 'references/' ||
+    item.startsWith('references/') ||
+    item.startsWith('assets/marketplace/') ||
+    item.startsWith('scripts/generate-release') ||
+    item.startsWith('scripts/audit-release') ||
+    item.startsWith('scripts/package-gse') ||
+    item.startsWith('scripts/install-gse') ||
+    item.includes('public-release') ||
+    item.includes('final-readiness') ||
+    item.includes('packaging'),
+  )
+  const installedSyncStale =
+    capabilityChanged &&
+    hasGseScripts &&
+    maintenanceSnapshot.installedSyncMode !== 'verified'
+
+  const requiredCloseCommands = [
+    `node scripts/run-validation-profile.mjs --target . --profile ${validationProfile} --json`,
+    'node scripts/run-gse-command.mjs --root . --target . --command "/gse close" --json',
+  ]
+  const conditionalCloseCommands = [
+    {
+      id: 'encoding',
+      active: docsOrLearningChanged && hasEncodingCheck,
+      when: 'docs, markdown, JSON/JSONL, YAML, evidence, or learning files changed and package.json exposes check:encoding',
+      command: 'cmd /c pnpm check:encoding',
+    },
+    {
+      id: 'installed-sync',
+      active: capabilityChanged && hasGseScripts,
+      when: 'GSE capability files changed and an installed skill copy must stay fresh',
+      command: 'node scripts/audit-installed-sync.mjs --root . --installed-root C:\\Users\\Admin\\.codex\\skills\\gse --json',
+    },
+    {
+      id: 'maintenance-snapshot',
+      active: (capabilityChanged || releaseSensitiveChanged) && hasGseScripts,
+      when: 'capability, release, package, or maintenance-sensitive files changed',
+      command: releaseSensitiveChanged
+        ? 'node scripts/generate-maintenance-snapshot.mjs --root . --target . --installed-root C:\\Users\\Admin\\.codex\\skills\\gse --execute --json'
+        : 'node scripts/generate-maintenance-snapshot.mjs --root . --target . --installed-root C:\\Users\\Admin\\.codex\\skills\\gse --skip-release-bundle --execute --json',
+    },
+    {
+      id: 'release-bundle',
+      active: releaseSensitiveChanged && hasGseScripts,
+      when: 'release, packaging, public acceptance, marketplace, or final-readiness files changed',
+      command: 'node scripts/generate-release-bundle.mjs --root . --label gse-release-bundle-audit --out .gse\\release-bundles\\gse-release-bundle-audit --force --json',
+    },
+    {
+      id: 'session-sync',
+      active: capabilityChanged && hasGseScripts && fs.existsSync(path.join(target, '.gse', 'session-sync.jsonl')),
+      when: 'installed GSE capability changed and active GSE-using session sync records are maintained',
+      command: 'node scripts/audit-session-sync.mjs --root . --json',
+    },
+  ]
+
+  return {
+    status: gitChanges.status,
+    profile: validationProfile,
+    changedPathCount: changedPaths.length,
+    changedPaths: changedPaths.slice(0, 20),
+    ignoredGeneratedPathCount: ignoredGeneratedPaths.length,
+    ignoredGeneratedPaths: ignoredGeneratedPaths.slice(0, 20),
+    requiredSteps: [
+      'Record outcome, scope, acceptance, evidence, risk, and next action for the current slice.',
+      'Append evidence to .gse/evidence/YYYY-MM-DD.md and .gse/evidence/index.jsonl.',
+      'Update .gse/state.json, .gse/current-slice.md, and .gse/goal-map.md before close.',
+      'Commit only the current slice files after focused checks pass.',
+    ],
+    requiredCloseCommands,
+    conditionalCloseCommands,
+    activeCloseCommands: conditionalCloseCommands.filter((item) => item.active).map((item) => item.command),
+    staleSignals: {
+      installedSyncStale,
+      maintenanceSnapshotStatus: maintenanceSnapshot.status,
+      maintenanceSnapshotMode: maintenanceSnapshot.installedSyncMode,
+    },
+    limits: [
+      'These commands are a close checklist, not proof that the slice is complete until their outputs are recorded as evidence.',
+      'Host-native slash-command evidence stays optional per host adapter and is not part of the default close checklist.',
+    ],
+  }
+}
+
+function buildGateTaxonomy(blockedGates) {
+  return {
+    core: {
+      scope: 'default project continuation and slice close',
+      blocking: true,
+      examples: [
+        'invalid .gse/state.json',
+        'invalid .gse/evidence/index.jsonl',
+        'missing project profile, goal map, quality gates, or canonical plan',
+        'missing current-slice evidence for the claim being closed',
+      ],
+      source: 'continue preflight, quality gates, close gate, project guards',
+    },
+    release: {
+      scope: 'public release, package, registry, CI, repository, security, or marketplace claims',
+      blocking: blockedGates.some((gate) => gate.gateType === 'owner-external'),
+      pendingCount: blockedGates.filter((gate) => gate.gateType === 'owner-external').length,
+      examples: [
+        'public CI run',
+        'public repository settings',
+        'public security contact',
+        'registry or package publication',
+        'marketplace or catalog publication',
+      ],
+      source: 'final readiness matrix and accepted owner/external records',
+    },
+    hostAdapter: {
+      scope: 'native slash-command, host UI, MCP, LSP, browser, subagent, or other runtime adapter claims',
+      blocking: blockedGates.some((gate) => gate.blockingScope === 'public-or-host-claim'),
+      examples: [
+        'native /gse command in a specific host',
+        'host UI command-palette invocation',
+        'verified browser or Playwright runtime',
+        'verified subagent dispatch',
+      ],
+      source: 'host capability records and host runtime invocation records',
+    },
+    rule: 'Core gates block default continuation; release and host-adapter gates block only the specific public, release, or host claim unless the project owner explicitly promotes them to project policy.',
+  }
+}
+
+function buildShortPrompt({ projectName, resolvedTarget, preflightStatus, compactState, blockedGates, failedHardChecks }) {
+  const nextMode = compactState.nextSliceMode?.action === 'open-next-slice'
+    ? 'open-next-slice'
+    : 'continue-current-slice'
+  const lines = [
+    `GSE continue: ${projectName} | ${compactState.phase} | preflight=${preflightStatus}`,
+    `Root: ${resolvedTarget}`,
+    `Slice: ${compactState.currentSlice.outcome} (${compactState.currentSlice.status})`,
+    `Next: ${compactState.currentSlice.nextAction}`,
+    `Mode: ${nextMode} | close=${compactState.completionPlan.requiredCloseCommands.length} required/${compactState.completionPlan.activeCloseCommands.length} active | risks=${compactState.activeRiskCount} active/${compactState.archivedRiskCount} archived | gates core=${compactState.gateTaxonomy.core.blocking ? 'blocking' : 'open'}, release=${compactState.gateTaxonomy.release.pendingCount}, host=${compactState.gateTaxonomy.hostAdapter.blocking ? 'claim-gated' : 'optional'}`,
+  ]
+  if (blockedGates.length) lines.push(`Claim evidence: ${blockedGates.map((gate) => gate.area).join(', ')}`)
+  if (failedHardChecks.length) lines.push(`Fix first: ${failedHardChecks.map((item) => item.label).join('; ')}`)
+  lines.push('Do: one verifiable slice -> evidence -> state/goal-map/current-slice -> completionPlan checks -> commit.')
+  return lines.join('\n')
+}
+
+function buildNextSliceMode(state) {
+  const status = String(state?.currentSlice?.status ?? '').trim().toLowerCase()
+  const verifiedStatuses = new Set(['verified', 'accepted', 'archived', 'closed', 'complete', 'completed'])
+  const currentSliceVerified = verifiedStatuses.has(status)
+  return {
+    action: currentSliceVerified ? 'open-next-slice' : 'continue-current-slice',
+    currentSliceVerified,
+    reason: currentSliceVerified
+      ? 'Current slice is already verified; use nextAction and roadmap priority to open a new verifiable slice before implementation.'
+      : 'Current slice is not verified; continue or close the active slice before opening another one.',
+  }
+}
+
+function shortText(value, maxLength = 180) {
+  const normalized = String(value || '').replace(/`/g, '').replace(/\s+/g, ' ').trim()
+  if (normalized.length <= maxLength) return normalized
+  return normalized.slice(0, maxLength - 1).trimEnd() + '…'
+}
+
+function fullCandidateReason(value) {
+  return String(value || '').replace(/`/g, '').replace(/\s+/g, ' ').trim()
+}
+
+function extractBulletsFromSection(text, heading) {
+  const lines = String(text || '').split(/\r?\n/)
+  const start = lines.findIndex((line) => line.trim().toLowerCase() === heading.toLowerCase())
+  if (start === -1) return []
+  const bullets = []
+  for (const line of lines.slice(start + 1)) {
+    if (/^#{1,6}\s+/.test(line)) break
+    const match = line.match(/^\s*-\s+(.+)/)
+    if (match) bullets.push(match[1].trim())
+  }
+  return bullets
+}
+
+function isHostNativeOnlyCandidate(text) {
+  const value = String(text || '').toLowerCase()
+  return (
+    value.includes('native slash-command') ||
+    value.includes('host-native') ||
+    value.includes('host native') ||
+    value.includes('host ui') ||
+    value.includes('browser') ||
+    value.includes('mcp') ||
+    value.includes('lsp') ||
+    value.includes('subagent') ||
+    value.includes('record native slash') ||
+    value.includes('when a host exposes')
+  )
+}
+
+function isMetaNextSliceCandidate(text) {
+  const value = String(text || '').toLowerCase()
+  return (
+    value.includes('open the next') ||
+    value.includes('next verifiable slice') ||
+    value.includes('next-slice selector') ||
+    value.includes('next slice selector') ||
+    value.includes('use /gse continue candidates') ||
+    value.includes('roadmap priority') ||
+    value.includes('harden candidate ranking')
+  )
+}
+
+function uniqueCandidateReasons(items) {
+  const seen = new Set()
+  const output = []
+  for (const item of items) {
+    const fullReason = fullCandidateReason(item.fullReason || item.reason)
+    if (!fullReason) continue
+    const key = fullReason.toLowerCase()
+    if (seen.has(key)) continue
+    seen.add(key)
+    output.push({ ...item, fullReason })
+  }
+  return output
+}
+
+function buildCandidateActionPacket(candidate) {
+  const kind = candidate.kind || 'roadmap-gap'
+  const base = {
+    candidateType: kind,
+    outcomeHint: candidate.outcomeHint || 'Open a focused GSE slice that makes the selected gap measurably more true.',
+    scopeHint: candidate.scopeHint || 'Touch only the scripts, references, templates, and state files needed for this slice.',
+    acceptanceHint: candidate.acceptanceHint,
+    evidenceHint: candidate.evidenceHint || 'Add or update a focused audit, run /gse continue, record evidence, and keep the claim boundary explicit.',
+    riskHint: candidate.riskHint || 'Do not turn optional host, release, or project-specific evidence into a default core blocker.',
+    nextActionHint: candidate.nextActionHint || 'Update current-slice, state, goal-map, evidence, installed copy, and session sync records when the capability changes.',
+    focusedChecks: candidate.focusedChecks || [
+      'node scripts\\audit-continue-preflight.mjs --root . --json',
+      'node scripts\\run-validation-profile.mjs --target . --profile lite --json',
+    ],
+  }
+  return base
+}
+
+function buildNextSliceCandidates(target, state, nextSliceMode) {
+  if (nextSliceMode.action !== 'open-next-slice') return []
+
+  const roadmapText = readText(path.join(target, 'references', 'final-form-roadmap.md'))
+  const goalMapText = readText(path.join(target, '.gse', 'goal-map.md'))
+  const currentNextAction = fullCandidateReason(state?.currentSlice?.nextAction || 'Open the next verifiable slice from the current roadmap priority.')
+  const activeRisks = Array.isArray(state?.residualRisks) ? state.residualRisks.map((risk) => fullCandidateReason(risk)) : []
+  const roadmapBullets = [
+    ...extractBulletsFromSection(roadmapText, '## Current Final-Form Gap List'),
+    ...extractBulletsFromSection(roadmapText, '## Final Form Priorities'),
+  ].filter((item) => item && !/^Done:/i.test(item) && !isHostNativeOnlyCandidate(item))
+  const goalMapNext = firstMatch(goalMapText, /Next action:\s*([^\n]+)/i)
+
+  const candidates = []
+  const firstReason = goalMapNext ? fullCandidateReason(goalMapNext) : currentNextAction
+
+  const roadmapCandidate = roadmapBullets.find((item) =>
+    item.toLowerCase().includes('short entry') ||
+    item.toLowerCase().includes('continue') ||
+    item.toLowerCase().includes('state') ||
+    item.toLowerCase().includes('evidence') ||
+    item.toLowerCase().includes('learning') ||
+    item.toLowerCase().includes('maintenance')
+  ) || roadmapBullets[0]
+
+  if (roadmapCandidate) {
+    candidates.push({
+      kind: 'roadmap-gap',
+      title: 'Reduce the next short-entry handoff gap',
+      source: 'references/final-form-roadmap.md',
+      fullReason: fullCandidateReason(roadmapCandidate),
+      outcomeHint: 'Make the next /gse continue candidate directly openable as a slice without a long prompt rewrite.',
+      scopeHint: 'Add machine-readable action fields to next-slice candidates and audit their presence.',
+      acceptanceHint: 'Add executable support or a focused audit for the selected roadmap gap, then surface it through /gse continue or /gse close when relevant.',
+      evidenceHint: 'Focused continue-preflight audit proves candidates include action fields and real /gse continue output exposes them.',
+      riskHint: 'Candidate packets can still be hints, not autonomous roadmap decisions.',
+      nextActionHint: 'Use the structured candidate packet to create the next current-slice entry.',
+      suggestedProfile: 'lite',
+    })
+  }
+
+  const riskCandidate = activeRisks.find((risk) => !isHostNativeOnlyCandidate(risk))
+  if (riskCandidate) {
+    candidates.push({
+      kind: 'active-risk',
+      title: 'Turn an active risk into an executable guard',
+      source: '.gse/state.json residualRisks',
+      fullReason: riskCandidate,
+      outcomeHint: 'Reduce one active recurring risk by converting it into an auditable guard, repair action, or claim boundary.',
+      scopeHint: 'Change one guard/audit/continue-close surface and compact the active risk only after evidence passes.',
+      acceptanceHint: 'Move one recurring active risk into a guard, audit, repair action, or explicit claim boundary, then reduce the active-risk summary.',
+      evidenceHint: 'Focused audit shows the risk is enforced or surfaced before close; state shows the active risk no longer needs top-risk space.',
+      riskHint: 'Avoid deleting risk text unless the new guard actually prevents or surfaces the failure.',
+      nextActionHint: 'Pick the highest-value active risk and open a guard-hardening slice.',
+      suggestedProfile: 'lite',
+    })
+  }
+
+  if (firstReason && (!isMetaNextSliceCandidate(firstReason) || candidates.length === 0)) {
+    candidates.push({
+      kind: 'goal-map-next',
+      title: 'Open the next roadmap-backed slice',
+      source: goalMapNext ? '.gse/goal-map.md Current Focus' : '.gse/state.json currentSlice.nextAction',
+      fullReason: firstReason,
+      outcomeHint: 'Turn the recorded next action into a concrete current slice before implementation.',
+      scopeHint: 'Create or update only the slice planning fields needed to start work.',
+      acceptanceHint: 'Create a new current-slice entry with outcome, scope, acceptance, evidence, risk, and next action before implementation.',
+      evidenceHint: 'Continue packet shows the new slice as active and close checks know which evidence is required.',
+      riskHint: 'Do not start coding from a vague next action without a verifiable slice contract.',
+      nextActionHint: 'Write the current-slice contract, then implement the smallest evidence-backed change.',
+      suggestedProfile: 'lite',
+    })
+  }
+
+  return uniqueCandidateReasons(candidates)
+    .slice(0, 3)
+    .map((candidate, index) => ({
+      id: `NEXT-${String(index + 1).padStart(3, '0')}`,
+      title: candidate.title,
+      source: candidate.source,
+      reason: shortText(candidate.fullReason),
+      fullReason: candidate.fullReason,
+      acceptanceHint: candidate.acceptanceHint,
+      actionPacket: buildCandidateActionPacket(candidate),
+      suggestedProfile: candidate.suggestedProfile,
+    }))
+}
+
+function makeCheck(id, label, ok, evidence, severity = 'hard', recommendation = '') {
+  return {
+    id,
+    label,
+    status: ok ? 'passed' : severity === 'soft' ? 'warning' : 'failed',
+    severity,
+    evidence,
+    recommendation,
+  }
+}
+
+function createFixture(options = {}) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gse-continue-packet-'))
+  fs.mkdirSync(path.join(dir, '.gse', 'evidence'), { recursive: true })
+  fs.mkdirSync(path.join(dir, 'docs'), { recursive: true })
+  fs.writeFileSync(path.join(dir, 'AGENTS.md'), '# Rules\n', 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'README.md'), '# GSE\n\nCanonical plan: `docs/productization-architecture.md`.\n', 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'project-profile.md'), '# Project Profile\n\n- Product/system name: Fixture Product\n', 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'goal-map.md'), '# Goal Map\n\n## Current Focus\n\n- Active slice: Fixture continue.\n- Next action: Run fixture smoke.\n', 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'quality-gates.md'), '# Quality Gates\n\n- Evidence required.\n', 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'host-capabilities.md'), [
+    '# Host Capabilities',
+    '',
+    '| Capability | Host/Tool | Status | Evidence | Claim Boundary | Last Checked |',
+    '|---|---|---|---|---|---|',
+    '| native-slash-command | current host | external-required | - | Native slash-command support requires real host runtime invocation evidence, not portable `/gse` runner output. | - |',
+    '| browser | browser or Playwright | unknown | - | Browser proof requires a real browser/component/screenshot command for this project. | - |',
+    '| mcp | MCP servers | unknown | - | MCP status is host and project specific. | - |',
+    '| lsp | LSP or code index | unknown | - | LSP/index status is current-session specific unless project docs prove it. | - |',
+    '| subagent | host dispatch | unknown | - | Real subagent dispatch requires verified host/tool evidence; sequential role fallback is not real dispatch. | - |',
+    '| ci | project CI | unknown | - | CI is verified only after a workflow/config or run is checked for this project. | - |',
+    '',
+  ].join('\n'), 'utf8')
+  fs.writeFileSync(path.join(dir, '.gse', 'project-guards.md'), [
+    '# Project Guards',
+    '',
+    '| ID | Guard | Severity | Trigger | Check | Status |',
+    '|---|---|---|---|---|---|',
+    '| WIN-SHELL | Use shell syntax that matches the active host. | high | shell command | Confirm shell syntax. | active |',
+    '| SPARSE-GIT | Check sparse checkout before staging workflow folders. | high | git staging | Confirm sparse visibility. | active |',
+    '| UTF8-DOC | Use UTF-8-safe readers before judging mojibake. | high | docs | Use UTF-8 reader. | active |',
+    '| EVIDENCE-STALE | Treat stale evidence as preflight problem. | high | evidence | Validate latest evidence. | active |',
+    '| UI-EVIDENCE | Label UI/browser downgrades explicitly. | medium | UI proof | Record evidence level. | active |',
+    '| SUBAGENT-HONEST | Do not claim fake subagent dispatch. | high | subagent | Require real host evidence. | active |',
+    '| SYNC-NO-INTERRUPT | Do not interrupt running project sessions with cross-thread sync. | high | sync or delegation | Confirm the target session is idle or use owner action record. | active |',
+    '',
+  ].join('\n'), 'utf8')
+  fs.writeFileSync(path.join(dir, 'docs', 'productization-architecture.md'), '# Productization Architecture\n', 'utf8')
+  fs.writeFileSync(
+    path.join(dir, '.gse', 'state.json'),
+    JSON.stringify({
+      schemaVersion: 1,
+      projectName: 'fixture-product',
+      mode: 'standard',
+      canonicalPlan: 'docs/productization-architecture.md',
+      phase: 'execute',
+      currentSlice: {
+        id: 'fixture-continue',
+        outcome: 'Fixture continue packet.',
+        status: 'planned',
+        nextAction: 'Run fixture smoke.',
+      },
+      toolStatuses: {
+        browser: 'unknown',
+        lsp: 'unknown',
+        mcp: 'unknown',
+        subagents: 'unknown',
+        ci: 'unknown',
+      },
+      lastEvidence: '.gse/evidence/index.jsonl',
+      residualRisks: [
+        'Fixture top risk 1.',
+        'Fixture top risk 2.',
+        'Fixture top risk 3.',
+        'Fixture archived risk 4.',
+      ],
+    }, null, 2) + '\n',
+    'utf8',
+  )
+  fs.writeFileSync(
+    path.join(dir, '.gse', 'evidence', 'index.jsonl'),
+    options.invalidEvidence
+      ? '{"date":"2026-07-08"\n'
+      : JSON.stringify({
+        date: '2026-07-08',
+        recordType: 'slice',
+        status: 'verified',
+        evidenceLevel: 'verified-unit',
+        requiredEvidenceLevel: 'verified-unit',
+        summary: 'Fixture evidence.',
+        evidenceFile: '.gse/evidence/2026-07-08.md',
+        commands: ['fixture'],
+        nextAction: 'Run fixture smoke.',
+      }) + '\n',
+    'utf8',
+  )
+  return dir
+}
+
+function buildContinuePacket(target) {
+  const resolvedTarget = path.resolve(target)
+  const gseDir = path.join(resolvedTarget, '.gse')
+  const stateResult = readJson(path.join(gseDir, 'state.json'))
+  const state = stateResult.ok ? stateResult.data : null
+  const evidenceIndex = readJsonl(path.join(gseDir, 'evidence', 'index.jsonl'))
+  const goalMapText = readText(path.join(gseDir, 'goal-map.md'))
+  const profileText = readText(path.join(gseDir, 'project-profile.md'))
+  const canonicalPlan = findCanonicalPlan(resolvedTarget, state)
+  const projectGuards = readProjectGuards(resolvedTarget)
+  const roleFallback = readRoleDispatchFallback(resolvedTarget)
+  const stateRepair = auditStateRepair(resolvedTarget)
+  const learningPromotion = analyzeLearningPromotions(resolvedTarget)
+  const learningDrift = auditLearningDrift(resolvedTarget)
+  const hostCapabilities = readHostCapabilities(resolvedTarget)
+  const toolFallbackPolicy = auditToolFallbackPolicy(resolvedTarget)
+  const maintenanceSnapshot = readMaintenanceSnapshot(resolvedTarget)
+  const sessionSyncBoundary = readSessionSyncBoundary(resolvedTarget)
+  const evidenceLevelAnalysis = analyzeEvidenceLevels(evidenceIndex.records)
+  const evidenceReviewQueue = analyzeEvidenceReviewQueue(evidenceIndex.records, resolvedTarget)
+  const evidenceLevelIssueCount =
+    evidenceLevelAnalysis.invalidLevel.length +
+    evidenceLevelAnalysis.downgraded.length +
+    evidenceLevelAnalysis.missingLevel.length
+  const canonicalPlanExists = canonicalPlan ? exists(resolvedTarget, canonicalPlan) : false
+  const evidenceRecordsAreSchemaComplete = evidenceIndex.ok && evidenceIndex.records.length > 0 && evidenceIndex.records.every((record) =>
+    typeof record.date === 'string' &&
+    typeof record.recordType === 'string' &&
+    typeof record.status === 'string' &&
+    typeof record.summary === 'string' &&
+    typeof record.evidenceFile === 'string' &&
+    Array.isArray(record.commands) &&
+    typeof record.nextAction === 'string',
+  )
+
+  const checks = [
+    makeCheck('CP01', '.gse directory exists', exists(resolvedTarget, '.gse'), exists(resolvedTarget, '.gse') ? '.gse present' : '.gse missing'),
+    makeCheck('CP02', 'state.json exists and parses', stateResult.ok, stateResult.exists ? stateResult.ok ? 'valid JSON' : stateResult.error : 'missing'),
+    makeCheck('CP03', 'evidence index exists and parses as JSONL', evidenceIndex.ok, evidenceIndex.exists ? evidenceIndex.ok ? `${evidenceIndex.records.length} record(s)` : evidenceIndex.error : 'missing'),
+    makeCheck('CP04', 'evidence index records are schema-complete', evidenceRecordsAreSchemaComplete, evidenceRecordsAreSchemaComplete ? 'records include status, evidenceFile, commands, nextAction' : 'missing required fields or no records'),
+    makeCheck('CP05', 'project profile exists', exists(resolvedTarget, '.gse/project-profile.md'), '.gse/project-profile.md'),
+    makeCheck('CP06', 'goal map exists', exists(resolvedTarget, '.gse/goal-map.md'), '.gse/goal-map.md'),
+    makeCheck('CP07', 'quality gates exist', exists(resolvedTarget, '.gse/quality-gates.md'), '.gse/quality-gates.md'),
+    makeCheck('CP08', 'canonical plan is declared and present', Boolean(canonicalPlan && canonicalPlanExists), canonicalPlan ? `${canonicalPlan}:${canonicalPlanExists ? 'present' : 'missing'}` : 'not declared'),
+    makeCheck('CP09', 'current slice has next action', Boolean(state?.currentSlice?.nextAction || firstMatch(goalMapText, /Next action:\s*([^\n]+)/i)), state?.currentSlice?.nextAction || firstMatch(goalMapText, /Next action:\s*([^\n]+)/i) || 'missing'),
+    makeCheck('CP10', 'residual risks are bounded in compact output', Array.isArray(state?.residualRisks), Array.isArray(state?.residualRisks) ? `${state.residualRisks.length} active risk(s); top 3 surfaced` : 'missing residualRisks array', 'soft'),
+    makeCheck('CP11', 'project guards are loaded as soft preflight rules', projectGuards.status !== 'failed', projectGuards.exists ? `${projectGuards.active.length} active guard(s)` : 'missing .gse/project-guards.md', 'soft', projectGuards.exists ? '' : 'Add .gse/project-guards.md or run GSE scaffold update when recurring lessons need guard coverage.'),
+    makeCheck(
+      'CP12',
+      'evidence levels are valid and surfaced',
+      evidenceLevelIssueCount === 0,
+      evidenceLevelAnalysis.invalidLevel.length
+        ? `invalid evidence level(s): ${evidenceLevelAnalysis.invalidLevel.map((item) => `${item.summary}:${item.evidenceLevel}`).join('; ')}`
+        : `${evidenceLevelAnalysis.recordsWithLevel}/${evidenceLevelAnalysis.records} record(s) with evidenceLevel; ${evidenceLevelAnalysis.downgraded.length} downgrade(s); ${evidenceLevelAnalysis.missingLevel.length} historical missing`,
+      evidenceLevelAnalysis.invalidLevel.length ? 'hard' : 'soft',
+      evidenceLevelAnalysis.invalidLevel.length
+        ? 'Use one of the evidence levels from references/evidence-taxonomy.md.'
+        : 'Add evidenceLevel to new records and label UI/browser/API/CI downgrades explicitly.',
+    ),
+    makeCheck(
+      'CP13',
+      'historical evidence review queue is visible',
+      true,
+      `${evidenceReviewQueue.counts.needsReview} needs-review; ${evidenceReviewQueue.counts.eligibleForStrongerReview} eligible-for-stronger-review; ${evidenceReviewQueue.counts.externalRequired} external-required`,
+      'soft',
+      evidenceReviewQueue.counts.needsReview
+        ? 'Review conservative historical result records before using them as stronger proof.'
+        : 'No conservative historical result records currently need review.',
+    ),
+    makeCheck(
+      'CP14',
+      'role dispatch fallback packets are auditable',
+      roleFallback.status !== 'failed',
+      roleFallback.exists ? `${roleFallback.summary.total} role packet(s); ${roleFallback.summary.sequentialFallbackRoles.length} sequential fallback role(s)` : 'missing .gse/agents/role-fallback-packets.md',
+      'soft',
+      roleFallback.exists
+        ? ''
+        : 'Run a Standard/Enterprise GSE scaffold update or add role fallback packets before claiming role-separated execution.',
+    ),
+    makeCheck(
+      'CP15',
+      'state and evidence repair actions are available',
+      stateRepair.summary.status !== 'repair-required',
+      stateRepair.summary.actions
+        ? `${stateRepair.summary.status}; ${stateRepair.summary.actions} repair action(s)`
+        : 'clean',
+      stateRepair.summary.status === 'repair-required' ? 'hard' : 'soft',
+      stateRepair.summary.status === 'clean'
+        ? ''
+        : 'Run /gse repair or inspect compactState.stateRepair.repairActions before implementation.',
+    ),
+    makeCheck(
+      'CP16',
+      'learning promotion candidates are classified',
+      learningPromotion.summary.status !== 'failed',
+      learningPromotion.exists
+        ? `${learningPromotion.summary.promoted} promoted candidate(s); ${learningPromotion.summary.guardCandidates} guard candidate(s); ${learningPromotion.summary.scriptCandidates} script/skill candidate(s)`
+        : 'missing .gse/learnings.md',
+      'soft',
+      learningPromotion.exists
+        ? 'Run /gse learn --promote --execute after reviewing candidate-only output.'
+        : 'Record reusable lessons with /gse learn before expecting promotion candidates.',
+    ),
+    makeCheck(
+      'CP17',
+      'learning promotion drift is audited',
+      learningDrift.summary.status !== 'failed',
+      `${learningDrift.summary.enforced}/${learningDrift.summary.candidates} promoted candidate(s) enforced; ${learningDrift.summary.highUnenforced} high-severity drift(s)`,
+      'soft',
+      learningDrift.summary.highUnenforced
+        ? 'Promote unenforced learning candidates into guards, quality gates, continue/close checks, or focused audit scripts.'
+        : 'Keep learning candidates mapped to executable controls as they are promoted.',
+    ),
+    makeCheck(
+      'CP18',
+      'host capability records are audited',
+      hostCapabilities.status !== 'failed',
+      hostCapabilities.exists
+        ? `${hostCapabilities.summary.total} capability row(s); verified=${hostCapabilities.summary.verified.length}; unknown=${hostCapabilities.summary.unknown.length}; external-required=${hostCapabilities.summary.externalRequired.length}`
+        : 'missing .gse/host-capabilities.md',
+      'soft',
+      hostCapabilities.exists
+        ? 'Update .gse/host-capabilities.md when host/browser/MCP/LSP/subagent/CI evidence changes.'
+        : 'Add .gse/host-capabilities.md or update the GSE scaffold before making host/tool capability claims.',
+    ),
+    makeCheck(
+      'CP19',
+      'optional tool fallback policy is auditable',
+      toolFallbackPolicy.summary.status !== 'failed',
+      `${toolFallbackPolicy.summary.passed}/${toolFallbackPolicy.summary.total} fallback policy check(s)`,
+      'soft',
+      toolFallbackPolicy.summary.status === 'failed'
+        ? 'Restore markdown fallback and claim boundaries for optional tools before continuing.'
+        : 'Keep optional tools non-blocking and evidence-gated in host and router docs.',
+    ),
+    makeCheck(
+      'CP20',
+      'latest maintenance snapshot is available',
+      maintenanceSnapshot.exists && maintenanceSnapshot.status === 'passed',
+      maintenanceSnapshot.exists
+        ? `${maintenanceSnapshot.status}; installedSync=${maintenanceSnapshot.installedSync}; releaseBundle=${maintenanceSnapshot.releaseBundleFreshness}; mode=${maintenanceSnapshot.installedSyncMode}`
+        : 'missing .gse/maintenance/latest-maintenance-snapshot.json',
+      'soft',
+      maintenanceSnapshot.exists
+        ? 'Regenerate /gse maintenance after capability upgrades or before release-sensitive claims.'
+        : 'Run /gse maintenance --installed-root <installed-skill-dir> --execute when recurring final-form freshness must be proven.',
+    ),
+    makeCheck(
+      'CP21',
+      'session sync adoption boundary is explicit',
+      sessionSyncBoundary.valid,
+      sessionSyncBoundary.exists
+        ? `${sessionSyncBoundary.boundary}; installedSync=${sessionSyncBoundary.installedSyncRecorded}; adoptionProven=${sessionSyncBoundary.adoptionProven}`
+        : 'no session sync records claimed',
+      sessionSyncBoundary.valid ? 'soft' : 'hard',
+      sessionSyncBoundary.valid
+        ? 'Do not infer target-session adoption from installed-copy sync or notification records.'
+        : 'Repair .gse/session-sync.jsonl before relying on sync records.',
+    ),
+  ]
+
+  const projectName = cleanInlineValue(
+    state?.projectName ||
+    firstMatch(profileText, /Product\/system name:\s*([^\n]+)/i) ||
+    path.basename(resolvedTarget),
+  )
+  const residualRisks = Array.isArray(state?.residualRisks) ? state.residualRisks : []
+  const archivedRisks = Array.isArray(state?.riskArchive) ? state.riskArchive : []
+  const topRisks = residualRisks.slice(0, 3)
+  const hiddenActiveRiskCount = Math.max(0, residualRisks.length - topRisks.length)
+  const archivedRiskCount = archivedRisks.length
+  const totalRiskCount = residualRisks.length + archivedRisks.length
+  const blockedGates = []
+
+  const targetHasPublicAcceptanceDoctor =
+    fs.existsSync(path.join(resolvedTarget, 'scripts', 'audit-public-acceptance-readiness.mjs')) &&
+    fs.existsSync(path.join(resolvedTarget, 'references', 'final-readiness.md')) &&
+    fs.existsSync(path.join(root, 'scripts', 'audit-public-acceptance-readiness.mjs'))
+
+  let ownerExternalGateSummary = null
+  if (targetHasPublicAcceptanceDoctor) {
+    const doctor = runNode('audit-public-acceptance-readiness.mjs', ['--root', resolvedTarget, '--json'])
+    ownerExternalGateSummary = {
+      status: doctor.data?.summary?.status ?? 'unknown',
+      publicAccepted: doctor.data?.summary?.publicAccepted ?? 'unknown',
+      pendingGates: doctor.data?.summary?.pendingGates ?? 0,
+      command: doctor.command,
+    }
+    for (const gate of doctor.data?.pendingGates ?? []) {
+      blockedGates.push({
+        area: gate.area,
+        status: gate.status,
+        owner: gate.owner,
+        requiredEvidence: gate.requiredEvidence,
+        gateType: 'owner-external',
+        blockingScope: 'public-or-host-claim',
+      })
+    }
+  }
+
+  const failedHardChecks = checks.filter((item) => item.status === 'failed' && item.severity === 'hard')
+  const warningChecks = checks.filter((item) => item.status === 'warning')
+  const preflightStatus = failedHardChecks.length > 0 ? 'failed' : blockedGates.length > 0 || warningChecks.length > 0 ? 'warning' : 'passed'
+  const latestEvidence = evidenceIndex.records.at(-1) ?? null
+  const latestEvidenceLevel = latestEvidence?.evidenceLevel ?? null
+  const completionPlan = buildCompletionPlan(resolvedTarget, state, maintenanceSnapshot)
+  const gateTaxonomy = buildGateTaxonomy(blockedGates)
+  const nextSliceMode = buildNextSliceMode(state)
+  const nextSliceCandidates = buildNextSliceCandidates(resolvedTarget, state, nextSliceMode)
+  const nextChecks = [
+    'node scripts/run-gse-command.mjs --target <project-root> --command "/gse doctor" --json',
+    ...completionPlan.requiredCloseCommands,
+    ...completionPlan.activeCloseCommands,
+  ]
+
+  const compactState = {
+    projectName,
+    mode: state?.mode ?? 'unknown',
+    phase: state?.phase ?? 'unknown',
+    canonicalPlan,
+    currentSlice: {
+      id: state?.currentSlice?.id ?? null,
+      outcome: state?.currentSlice?.outcome || firstMatch(goalMapText, /Active slice:\s*([^\n]+)/i) || 'Read goal map and select the next verifiable slice.',
+      status: state?.currentSlice?.status ?? 'unknown',
+      nextAction: state?.currentSlice?.nextAction || firstMatch(goalMapText, /Next action:\s*([^\n]+)/i) || 'Continue with the smallest verifiable GSE slice.',
+    },
+    topRisks,
+    riskCount: residualRisks.length,
+    activeRiskCount: residualRisks.length,
+    hiddenActiveRiskCount,
+    archivedRiskCount,
+    totalRiskCount,
+    blockedGates,
+    gateTaxonomy,
+    nextSliceMode,
+    nextSliceCandidates,
+    nextChecks,
+    completionPlan,
+    toolStatuses: state?.toolStatuses ?? {},
+    latestEvidence,
+    latestEvidenceLevel,
+    evidenceLevels: {
+      allowed: evidenceLevelAnalysis.allowed,
+      recordsWithLevel: evidenceLevelAnalysis.recordsWithLevel,
+      missingLevel: evidenceLevelAnalysis.missingLevel.length,
+      invalidLevel: evidenceLevelAnalysis.invalidLevel,
+      downgraded: evidenceLevelAnalysis.downgraded,
+    },
+    evidenceReviewQueue: {
+      totalRecords: evidenceReviewQueue.counts.totalRecords,
+      queued: evidenceReviewQueue.counts.queued,
+      needsReview: evidenceReviewQueue.counts.needsReview,
+      safeResult: evidenceReviewQueue.counts.safeResult,
+      eligibleForStrongerReview: evidenceReviewQueue.counts.eligibleForStrongerReview,
+      externalRequired: evidenceReviewQueue.counts.externalRequired,
+      missingEvidenceFile: evidenceReviewQueue.counts.missingEvidenceFile,
+      items: evidenceReviewQueue.queue.slice(0, 5),
+    },
+    projectGuards: {
+      status: projectGuards.status,
+      activeCount: projectGuards.active.length,
+      guards: projectGuards.active.map((guard) => ({
+        id: guard.id,
+        severity: guard.severity,
+        trigger: guard.trigger,
+        check: guard.check,
+      })),
+      missingDefaultIds: projectGuards.summary.missingDefaultIds,
+    },
+    roleFallback: {
+      status: roleFallback.status,
+      exists: roleFallback.exists,
+      total: roleFallback.summary.total,
+      requiredRoles: roleFallback.summary.requiredRoles,
+      missingRoles: roleFallback.summary.missingRoles,
+      sequentialFallbackRoles: roleFallback.summary.sequentialFallbackRoles,
+      fakeDelegationRisk: roleFallback.summary.fakeDelegationRisk,
+    },
+    stateRepair: {
+      status: stateRepair.summary.status,
+      hard: stateRepair.summary.hard,
+      warnings: stateRepair.summary.warnings,
+      repairActions: stateRepair.repairActions,
+    },
+    learningPromotion: {
+      status: learningPromotion.summary.status,
+      entries: learningPromotion.summary.entries,
+      uniqueLessons: learningPromotion.summary.uniqueLessons,
+      promoted: learningPromotion.summary.promoted,
+      guardCandidates: learningPromotion.summary.guardCandidates,
+      scriptCandidates: learningPromotion.summary.scriptCandidates,
+      topCandidates: learningPromotion.promotions.slice(0, 5).map((item) => ({
+        id: item.id,
+        category: item.category,
+        severity: item.severity,
+        count: item.count,
+        promotionLevel: item.promotionLevel,
+        promotionTarget: item.promotionTarget,
+      })),
+    },
+    learningDrift: {
+      status: learningDrift.summary.status,
+      candidates: learningDrift.summary.candidates,
+      enforced: learningDrift.summary.enforced,
+      unenforced: learningDrift.summary.unenforced,
+      highUnenforced: learningDrift.summary.highUnenforced,
+      unenforcedCandidates: learningDrift.unenforced.slice(0, 5).map((item) => ({
+        id: item.candidateId,
+        category: item.category,
+        severity: item.severity,
+        promotionLevel: item.promotionLevel,
+        recommendation: item.recommendation,
+      })),
+    },
+    hostCapabilities: {
+      status: hostCapabilities.status,
+      exists: hostCapabilities.exists,
+      total: hostCapabilities.summary.total,
+      verified: hostCapabilities.summary.verified,
+      documented: hostCapabilities.summary.documented,
+      unknown: hostCapabilities.summary.unknown,
+      unavailable: hostCapabilities.summary.unavailable,
+      externalRequired: hostCapabilities.summary.externalRequired,
+      missingRequired: hostCapabilities.summary.missingRequired,
+      nativeSlashOverclaim: hostCapabilities.summary.nativeSlashOverclaim,
+    },
+    toolFallbackPolicy: {
+      status: toolFallbackPolicy.summary.status,
+      checks: toolFallbackPolicy.summary.passed + '/' + toolFallbackPolicy.summary.total,
+      optionalToolFallbackPolicy: toolFallbackPolicy.workflows.optionalToolFallbackPolicy,
+    },
+    maintenanceSnapshot: {
+      exists: maintenanceSnapshot.exists,
+      status: maintenanceSnapshot.status,
+      generatedAt: maintenanceSnapshot.generatedAt,
+      summary: maintenanceSnapshot.summary,
+      installedSync: maintenanceSnapshot.installedSync,
+      releaseBundleFreshness: maintenanceSnapshot.releaseBundleFreshness,
+      installedSyncMode: maintenanceSnapshot.installedSyncMode,
+    },
+    sessionSyncBoundary: {
+      exists: sessionSyncBoundary.exists,
+      valid: sessionSyncBoundary.valid,
+      boundary: sessionSyncBoundary.boundary,
+      totalRecords: sessionSyncBoundary.totalRecords,
+      statusCounts: sessionSyncBoundary.statusCounts,
+      installedSyncRecorded: sessionSyncBoundary.installedSyncRecorded,
+      adoptionProven: sessionSyncBoundary.adoptionProven,
+      latestInstalledSync: sessionSyncBoundary.latestInstalledSync,
+      latestThreadOutcomes: sessionSyncBoundary.latestThreadOutcomes,
+      latestRecords: sessionSyncBoundary.latestRecords,
+      limits: sessionSyncBoundary.limits,
+    },
+  }
+
+  const prompt = buildShortPrompt({ projectName, resolvedTarget, preflightStatus, compactState, blockedGates, failedHardChecks })
+
+  return {
+    target: resolvedTarget,
+    generatedAt: new Date().toISOString(),
+    summary: {
+      status: preflightStatus,
+      failedHardChecks: failedHardChecks.length,
+      warnings: warningChecks.length,
+      blockedGates: blockedGates.length,
+      riskCount: residualRisks.length,
+      activeRiskCount: residualRisks.length,
+      archivedRiskCount,
+      totalRiskCount,
+      topRiskCount: topRisks.length,
+    },
+    preflight: {
+      status: preflightStatus,
+      checks,
+      failures: failedHardChecks,
+      warnings: warningChecks,
+    },
+    compactState,
+    ownerExternalGateSummary,
+    prompt,
+    limits: [
+      'This packet is the portable /gse continue preflight, not host-native slash-command proof.',
+      'Owner/external records affect only public release, marketplace, registry, or host-specific claims; they are not GSE core workflow blockers unless project policy says so.',
+      'Bad state or evidence index is a hard preflight failure and must be repaired before implementation starts.',
+    ],
+  }
+}
+
+function renderMarkdown(report) {
+  const lines = []
+  lines.push('# GSE Continue Packet')
+  lines.push('')
+  lines.push('Generated: ' + report.generatedAt)
+  lines.push('Target: ' + report.target)
+  lines.push('')
+  lines.push('## Summary')
+  lines.push('')
+  lines.push('- Status: ' + report.summary.status)
+  lines.push('- Project: ' + report.compactState.projectName)
+  lines.push('- Phase: ' + report.compactState.phase)
+  lines.push('- Current slice: ' + report.compactState.currentSlice.outcome)
+  lines.push('- Next action: ' + report.compactState.currentSlice.nextAction)
+  lines.push('- Risks: ' + report.summary.topRiskCount + ' shown / ' + report.summary.activeRiskCount + ' active (' + report.summary.archivedRiskCount + ' archived)')
+  lines.push('- Pending public/host claim evidence: ' + report.summary.blockedGates)
+  lines.push('- Gate taxonomy: core gates block default continuation; release and host-adapter gates block only their specific claims unless project policy promotes them.')
+  lines.push('- Active project guards: ' + report.compactState.projectGuards.activeCount)
+  lines.push('- Latest evidence level: ' + (report.compactState.latestEvidenceLevel || 'missing'))
+  lines.push('- Evidence level downgrades: ' + report.compactState.evidenceLevels.downgraded.length)
+  lines.push('- UI/browser proof boundary: `verified-component` is not `verified-browser`; screenshot/browser-backed claims require `verified-browser` evidence.')
+  lines.push('- Role fallback packets: ' + report.compactState.roleFallback.total + ' (' + report.compactState.roleFallback.status + ')')
+  lines.push('- State repair: ' + report.compactState.stateRepair.status + ' (' + report.compactState.stateRepair.repairActions.length + ' action(s))')
+  lines.push('- Learning promotion: ' + report.compactState.learningPromotion.status + ' (' + report.compactState.learningPromotion.promoted + ' candidate(s))')
+  lines.push('- Learning drift: ' + report.compactState.learningDrift.status + ' (' + report.compactState.learningDrift.enforced + '/' + report.compactState.learningDrift.candidates + ' enforced)')
+  lines.push('- Host capabilities: ' + report.compactState.hostCapabilities.status + ' (' + report.compactState.hostCapabilities.total + ' row(s))')
+  lines.push('- Maintenance snapshot: ' + report.compactState.maintenanceSnapshot.status + ' (' + report.compactState.maintenanceSnapshot.installedSyncMode + ')')
+  lines.push('- Session sync boundary: ' + report.compactState.sessionSyncBoundary.boundary + ' (adoptionProven=' + report.compactState.sessionSyncBoundary.adoptionProven + ')')
+  lines.push('- Completion plan: ' + report.compactState.completionPlan.requiredCloseCommands.length + ' required command(s), ' + report.compactState.completionPlan.activeCloseCommands.length + ' active conditional command(s)')
+  if (report.compactState.completionPlan.ignoredGeneratedPathCount > 0) {
+    lines.push('- Ignored generated/noisy paths: ' + report.compactState.completionPlan.ignoredGeneratedPathCount)
+  }
+  lines.push('')
+  lines.push('## Preflight')
+  lines.push('')
+  for (const item of report.preflight.checks) {
+    const marker = item.status === 'passed' ? '[x]' : item.status === 'warning' ? '[!]' : '[ ]'
+    lines.push('- ' + marker + ' ' + item.id + ' ' + item.label + ': ' + item.evidence)
+  }
+  lines.push('')
+  lines.push('## Completion Plan')
+  lines.push('')
+  lines.push('Required steps:')
+  for (const step of report.compactState.completionPlan.requiredSteps) {
+    lines.push('- ' + step)
+  }
+  lines.push('')
+  lines.push('Required commands:')
+  for (const command of report.compactState.completionPlan.requiredCloseCommands) {
+    lines.push('- `' + command + '`')
+  }
+  const activeConditional = report.compactState.completionPlan.conditionalCloseCommands.filter((item) => item.active)
+  if (activeConditional.length) {
+    lines.push('')
+    lines.push('Active conditional commands:')
+    for (const item of activeConditional) {
+      lines.push('- `' + item.command + '` - ' + item.when)
+    }
+  }
+  if (report.compactState.completionPlan.ignoredGeneratedPathCount > 0) {
+    lines.push('')
+    lines.push('Ignored generated/noisy paths:')
+    for (const item of report.compactState.completionPlan.ignoredGeneratedPaths) {
+      lines.push('- `' + item + '`')
+    }
+  }
+  lines.push('')
+  lines.push('## Prompt')
+  lines.push('')
+  lines.push('```text')
+  lines.push(report.prompt)
+  lines.push('```')
+  return lines.join('\n') + '\n'
+}
+
+const target = selfTest ? createFixture({ invalidEvidence: args.includes('--invalid-evidence-fixture') }) : targetArg
+const report = buildContinuePacket(target)
+
+if (jsonOnly) console.log(JSON.stringify(report, null, 2))
+else console.log(renderMarkdown(report))
+
+if (report.preflight.status === 'failed') process.exit(1)