@t275005746/gse 0.1.2 → 0.2.0

package/scripts/audit-target-hardening-drills.mjs

@@ -91,7 +91,232 @@ function evidenceFromRun(runResult) {
   return parts.join(', ') || `exit:${runResult.status}`
 }
 
-function createFixture(label) {
+function compactText(value, limit = 180) {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim()
+  if (text.length <= limit) return text
+  return text.slice(0, limit - 3) + '...'
+}
+
+function warningChecks(runResult) {
+  return (runResult.parsed?.checks ?? [])
+    .filter((item) => item.status === 'warning' || item.status === 'failed')
+    .map((item) => ({
+      id: item.id,
+      label: item.label,
+      status: item.status,
+      evidence: compactText(item.evidence),
+      recommendation: compactText(item.recommendation),
+    }))
+}
+
+function repairIssues(runResult) {
+  return (runResult.parsed?.repairActions ?? [])
+    .map((item) => ({
+      id: item.id,
+      label: item.problem,
+      status: item.severity === 'hard' ? 'failed' : 'warning',
+      evidence: item.targetPath,
+      recommendation: compactText(item.command),
+    }))
+}
+
+function uniqueIssues(items, limit = 8) {
+  const seen = new Set()
+  const result = []
+  for (const item of items) {
+    const key = `${item.id}:${item.label}:${item.evidence}`
+    if (seen.has(key)) continue
+    seen.add(key)
+    result.push(item)
+    if (result.length >= limit) break
+  }
+  return result
+}
+
+function classifyTargetAdoption({ hasHardFailure, hasWarnings, topLocalIssues }) {
+  if (hasHardFailure) return 'target-hard-failure'
+  if (topLocalIssues.length > 0) return 'target-local-adoption-hygiene'
+  if (hasWarnings) return 'gse-ready-with-soft-warnings'
+  return 'gse-ready'
+}
+
+function hasDirtyGseIssue(topLocalIssues) {
+  return topLocalIssues.some((item) => {
+    const id = String(item.id ?? '')
+    const evidence = String(item.evidence ?? '').toLowerCase()
+    if (id.startsWith('SR')) return false
+    return (
+      id === 'TPD09' ||
+      id === 'CG08' ||
+      evidence.includes('.gse/') ||
+      evidence.includes('.gse\\')
+    )
+  })
+}
+
+function hasDirtyTargetWorktreeIssue(topLocalIssues) {
+  return topLocalIssues.some((item) => {
+    const id = String(item.id ?? '')
+    const label = String(item.label ?? '').toLowerCase()
+    const evidence = String(item.evidence ?? '').toLowerCase()
+    return (
+      id === 'CG11' ||
+      label.includes('worktree') ||
+      evidence.includes('staged') ||
+      evidence.includes('unstaged') ||
+      evidence.includes('untracked') ||
+      evidence.includes('conflict')
+    )
+  })
+}
+
+function hasStateRepairIssue(topLocalIssues) {
+  return topLocalIssues.some((item) => String(item.id ?? '').startsWith('SR'))
+}
+
+function buildRepairPlan({ topLocalIssues, stateRepairSummary }) {
+  const dirtyGse = hasDirtyGseIssue(topLocalIssues)
+  const dirtyTargetWorktree = hasDirtyTargetWorktreeIssue(topLocalIssues)
+  const stateRepairAdvised = hasStateRepairIssue(topLocalIssues) || (stateRepairSummary.actions ?? 0) > 0
+  const repairBlockedByDirtyWorktree = dirtyGse || dirtyTargetWorktree
+  const steps = []
+  if (dirtyTargetWorktree) {
+    steps.push({
+      id: 'resolve-worktree-ownership',
+      status: 'required-first',
+      action: 'Review current target worktree ownership, finish or exclude unrelated target-session changes, and stage/commit only the active slice before repair.',
+    })
+  } else if (dirtyGse) {
+    steps.push({
+      id: 'resolve-gse-worktree-ownership',
+      status: 'required-first',
+      action: 'Review current .gse worktree ownership, finish or exclude unrelated target-session changes, and stage/commit only the active slice before repair.',
+    })
+  }
+  if (stateRepairAdvised) {
+    steps.push({
+      id: 'compact-state-risks',
+      status: repairBlockedByDirtyWorktree ? 'blocked-until-worktree-owned' : 'ready',
+      action: 'Run `/gse repair --execute` only after the target worktree and .gse state are owned and reversible backup output is acceptable.',
+    })
+  }
+  if (!steps.length) {
+    steps.push({
+      id: 'no-repair-required',
+      status: 'ready',
+      action: 'No target adoption repair step is required before normal continuation.',
+    })
+  }
+  return {
+    repairBlockedByDirtyGse: dirtyGse && stateRepairAdvised,
+    repairBlockedByDirtyWorktree: repairBlockedByDirtyWorktree && stateRepairAdvised,
+    stateRepairAdvised,
+    dirtyGseWorktree: dirtyGse,
+    dirtyTargetWorktree,
+    steps,
+  }
+}
+
+function buildRecommendedNextActions(topLocalIssues, repairPlan) {
+  const actions = []
+  for (const step of repairPlan.steps) {
+    if (step.id === 'no-repair-required') continue
+    actions.push(step.action)
+  }
+  for (const issue of uniqueIssues(topLocalIssues, 8)) {
+    if (!issue.recommendation) continue
+    if (repairPlan.repairBlockedByDirtyWorktree && String(issue.id ?? '').startsWith('SR')) continue
+    actions.push(issue.recommendation)
+  }
+  return [...new Set(actions)].slice(0, 6)
+}
+
+function buildTargetAdoptionSummary(commandRuns, checks) {
+  const failed = checks.filter((item) => item.status === 'failed')
+  const warnings = checks.filter((item) => item.status === 'warning')
+  const continueSummary = commandRuns.continue.parsed?.summary ?? {}
+  const stateRepairSummary = commandRuns.stateRepair.parsed?.summary ?? {}
+  const portableContinueUsable =
+    commandRuns.continue.status === 0 &&
+    (continueSummary.failedHardChecks ?? 0) === 0 &&
+    (continueSummary.blockedGates ?? 0) === 0
+  const activeRiskCount = continueSummary.activeRiskCount ?? continueSummary.riskCount ?? null
+  const topLocalIssues = uniqueIssues([
+    ...repairIssues(commandRuns.stateRepair),
+    ...warningChecks(commandRuns.doctor),
+    ...warningChecks(commandRuns.close),
+    ...warningChecks(commandRuns.hostCapabilities),
+    ...warningChecks(commandRuns.learningDrift),
+  ])
+  const repairPlan = buildRepairPlan({ topLocalIssues, stateRepairSummary })
+  const recommendedNextActions = buildRecommendedNextActions(topLocalIssues, repairPlan)
+  const hasHardFailure = failed.length > 0 || (stateRepairSummary.hard ?? 0) > 0
+  const hasWarnings = warnings.length > 0 || (stateRepairSummary.warnings ?? 0) > 0
+  return {
+    classification: classifyTargetAdoption({ hasHardFailure, hasWarnings, topLocalIssues }),
+    gseCoreGap: false,
+    coreGapAssessment: 'not-assessed-by-target-drill',
+    portableContinueUsable,
+    hostNativeSlashCommand: 'not-proven',
+    longPromptRisk: portableContinueUsable
+      ? Number.isFinite(activeRiskCount) && activeRiskCount > 20
+        ? 'risk-dump-needs-compaction'
+        : 'low'
+      : 'unknown',
+    activeRiskCount,
+    stateRepairStatus: stateRepairSummary.status ?? 'unknown',
+    topLocalIssues,
+    repairPlan,
+    recommendedNextActions,
+    limits: [
+      'This classifies target-project adoption hygiene, not product readiness.',
+      'gseCoreGap=false means this target drill did not find or claim a GSE core gap; full core-gap coverage belongs to GSE self audits.',
+      'Portable /gse continue success does not prove host-native slash-command support.',
+      'Warnings should be fixed before claiming a target project is fully GSE-ready, but they do not block normal continuation unless project policy says so.',
+    ],
+  }
+}
+
+function validateAdoptionSummary(target) {
+  const summary = target.adoptionSummary
+  const allowedClassifications = new Set([
+    'gse-ready',
+    'gse-ready-with-soft-warnings',
+    'target-local-adoption-hygiene',
+    'target-hard-failure',
+  ])
+  const failures = []
+  if (!summary || typeof summary !== 'object') failures.push('missing adoptionSummary')
+  if (summary && !allowedClassifications.has(summary.classification)) failures.push('invalid classification')
+  if (summary && typeof summary.gseCoreGap !== 'boolean') failures.push('gseCoreGap is not boolean')
+  if (summary && summary.coreGapAssessment !== 'not-assessed-by-target-drill') failures.push('coreGapAssessment boundary is missing')
+  if (summary && typeof summary.portableContinueUsable !== 'boolean') failures.push('portableContinueUsable is not boolean')
+  if (summary && !Array.isArray(summary.topLocalIssues)) failures.push('topLocalIssues is not an array')
+  if (summary && !summary.repairPlan) failures.push('missing repairPlan')
+  if (summary?.repairPlan && typeof summary.repairPlan.repairBlockedByDirtyGse !== 'boolean') failures.push('repairPlan.repairBlockedByDirtyGse is not boolean')
+  if (summary?.repairPlan && typeof summary.repairPlan.repairBlockedByDirtyWorktree !== 'boolean') failures.push('repairPlan.repairBlockedByDirtyWorktree is not boolean')
+  if (summary?.repairPlan && typeof summary.repairPlan.dirtyTargetWorktree !== 'boolean') failures.push('repairPlan.dirtyTargetWorktree is not boolean')
+  if (summary?.repairPlan && !Array.isArray(summary.repairPlan.steps)) failures.push('repairPlan.steps is not an array')
+  if (summary && !Array.isArray(summary.recommendedNextActions)) failures.push('recommendedNextActions is not an array')
+  if (summary?.repairPlan?.repairBlockedByDirtyWorktree) {
+    const firstAction = String(summary.recommendedNextActions?.[0] ?? '')
+    if (!firstAction.includes('worktree ownership')) failures.push('dirty repair plan does not prioritize worktree ownership')
+  }
+  if (summary?.classification === 'target-local-adoption-hygiene' && summary.topLocalIssues.length === 0) {
+    failures.push('local hygiene classification has no local issues')
+  }
+  return check(
+    `${target.id}-adoption-summary`,
+    'target adoption summary is structured and separates soft warnings from local hygiene',
+    failures.length === 0 ? 'passed' : 'failed',
+    failures.length === 0
+      ? `classification:${summary.classification}, portableContinueUsable:${summary.portableContinueUsable}, gseCoreGap:${summary.gseCoreGap}`
+      : failures.join('; '),
+    'Keep adoptionSummary machine-readable so project adoption reports do not overstate GSE core gaps.',
+  )
+}
+
+function createFixture(label, options = {}) {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), `gse-hardening-${label}-`))
   const init = run('init-project.mjs', ['--target', dir, '--mode', 'enterprise', '--json'])
   fs.mkdirSync(path.join(dir, 'docs'), { recursive: true })
@@ -108,7 +333,9 @@ function createFixture(label) {
     nextAction: 'Continue target hardening drill.',
   }
   state.lastEvidence = '.gse/evidence/2026-07-09.md'
-  state.residualRisks = []
+  state.residualRisks = options.committedRepair
+    ? Array.from({ length: 8 }, (_, index) => `Committed fixture residual risk ${index + 1} that should be compacted only after worktree ownership is resolved.`)
+    : []
   fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf8')
   fs.appendFileSync(path.join(dir, '.gse', 'README.md'), '\nCanonical plan: `docs/productization-architecture.md`.\n', 'utf8')
   fs.writeFileSync(path.join(dir, '.gse', 'evidence', '2026-07-09.md'), '# Evidence\n\nFixture hardening evidence.\n', 'utf8')
@@ -128,6 +355,14 @@ function createFixture(label) {
   spawnSync('git', ['config', 'user.name', 'GSE Fixture'], { cwd: dir, encoding: 'utf8', windowsHide: true })
   spawnSync('git', ['add', '.'], { cwd: dir, encoding: 'utf8', windowsHide: true })
   spawnSync('git', ['commit', '-m', 'fixture'], { cwd: dir, encoding: 'utf8', windowsHide: true })
+  if (options.dirtyRepair || options.dirtyProductRepair) {
+    state.residualRisks = Array.from({ length: 8 }, (_, index) => `Fixture residual risk ${index + 1} that should be compacted after worktree ownership is resolved.`)
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf8')
+  }
+  if (options.dirtyProductRepair) {
+    fs.mkdirSync(path.join(dir, 'src'), { recursive: true })
+    fs.writeFileSync(path.join(dir, 'src', 'active-slice.js'), 'export const activeSlice = true\n', 'utf8')
+  }
   return { dir, init }
 }
 
@@ -138,6 +373,7 @@ function auditTarget(target) {
     close: run('audit-close-gate.mjs', ['--target', target.root, '--json']),
     hostCapabilities: run('audit-host-capabilities.mjs', ['--root', root, '--target', target.root, '--json']),
     learningDrift: run('audit-learning-drift.mjs', ['--root', root, '--target', target.root, '--json']),
+    stateRepair: run('audit-state-repair.mjs', ['--root', root, '--target', target.root, '--json']),
   }
   const checks = [
     check(`${target.id}-doctor`, 'target project doctor has no hard failures', statusFromRun(commandRuns.doctor), evidenceFromRun(commandRuns.doctor), 'Repair target .gse adoption drift before claiming GSE-ready status.'),
@@ -146,12 +382,15 @@ function auditTarget(target) {
     check(`${target.id}-host`, 'host capability records are audited with claim boundaries', statusFromRun(commandRuns.hostCapabilities), evidenceFromRun(commandRuns.hostCapabilities), 'Record missing host capability facts or keep unknown/external-required boundaries explicit.'),
     check(`${target.id}-learning`, 'learning drift is audited for promoted guard candidates', statusFromRun(commandRuns.learningDrift), evidenceFromRun(commandRuns.learningDrift), 'Promote high-severity learning drift into guards, gates, or scripts before close.'),
   ]
+  const adoptionSummary = buildTargetAdoptionSummary(commandRuns, checks)
+  checks.push(validateAdoptionSummary({ id: target.id, adoptionSummary }))
   const failed = checks.filter((item) => item.status === 'failed')
   const warnings = checks.filter((item) => item.status === 'warning')
   return {
     id: target.id,
     root: target.root,
     status: failed.length > 0 ? 'failed' : warnings.length > 0 ? 'warning' : 'passed',
+    adoptionSummary,
     checks,
     commands: Object.values(commandRuns).map((item) => item.command),
     summaries: Object.fromEntries(Object.entries(commandRuns).map(([key, value]) => [key, value.parsed?.summary ?? { exit: value.status }])),
@@ -169,15 +408,23 @@ function runConfiguredTargets() {
 
 function runSelfTestTargets() {
   const primary = createFixture('primary')
-  const secondary = createFixture('secondary')
+  const secondary = createFixture('secondary', { dirtyRepair: true })
+  const dirtyProduct = createFixture('dirty-product', { dirtyProductRepair: true })
+  const committedRepairDirtyProduct = createFixture('committed-repair-dirty-product', { committedRepair: true })
+  fs.mkdirSync(path.join(committedRepairDirtyProduct.dir, 'src'), { recursive: true })
+  fs.writeFileSync(path.join(committedRepairDirtyProduct.dir, 'src', 'active-slice.js'), 'export const activeSlice = true\n', 'utf8')
   return {
     targets: [
       { id: 'fixture-primary', root: primary.dir },
       { id: 'fixture-secondary', root: secondary.dir },
+      { id: 'fixture-dirty-product', root: dirtyProduct.dir },
+      { id: 'fixture-committed-repair-dirty-product', root: committedRepairDirtyProduct.dir },
     ],
     cleanup: () => {
       fs.rmSync(primary.dir, { recursive: true, force: true })
       fs.rmSync(secondary.dir, { recursive: true, force: true })
+      fs.rmSync(dirtyProduct.dir, { recursive: true, force: true })
+      fs.rmSync(committedRepairDirtyProduct.dir, { recursive: true, force: true })
     },
   }
 }
@@ -212,6 +459,7 @@ function buildReport() {
         closeGateHardening: hardFailures.length === 0 ? 'verified' : 'failed',
         hostCapabilityBoundaries: hardFailures.length === 0 ? 'verified' : 'failed',
         learningDriftCoverage: hardFailures.length === 0 ? 'verified' : 'failed',
+        targetAdoptionHygieneSummary: hardFailures.length === 0 ? 'verified' : 'failed',
       },
       targets: reports,
       checks,
@@ -245,6 +493,9 @@ function renderMarkdown(report) {
   lines.push('')
   for (const target of report.targets) {
     lines.push('- ' + target.id + ': ' + target.status + ' at ' + target.root)
+    lines.push('  - Classification: ' + target.adoptionSummary.classification)
+    lines.push('  - Portable continue usable: ' + target.adoptionSummary.portableContinueUsable)
+    lines.push('  - Long prompt risk: ' + target.adoptionSummary.longPromptRisk)
   }
   lines.push('')
   lines.push('## Checks')

package/scripts/generate-continue-packet.mjs

@@ -342,7 +342,7 @@ function buildCompletionPlan(target, state, maintenanceSnapshot) {
       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',
+      command: 'cmd /c npm run check:encoding',
     },
     {
       id: 'installed-sync',
@@ -454,6 +454,8 @@ function buildShortPrompt({ projectName, resolvedTarget, preflightStatus, compac
   ]
   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('; ')}`)
+  if (compactState.productOutcomeGate?.status === 'warning') lines.push(`Product outcome: ${compactState.productOutcomeGate.recommendation}`)
+  if (compactState.productProgressDrift?.status === 'warning') lines.push(`Product drift: ${compactState.productProgressDrift.recommendation}`)
   lines.push('Do: one verifiable slice -> evidence -> state/goal-map/current-slice -> completionPlan checks -> commit.')
   return lines.join('\n')
 }
@@ -510,6 +512,216 @@ function isHostNativeOnlyCandidate(text) {
   )
 }
 
+const internalProgressTerms = [
+  'provenance',
+  'boundary',
+  'handoff',
+  'lineage',
+  'normalizer',
+  'normalize',
+  'source key',
+  'state repair',
+  'component',
+  'store',
+  'evidence',
+]
+
+const visibleProgressTerms = [
+  'browser',
+  'user interface',
+  'interface',
+  'user-visible',
+  'user visible',
+  'visible',
+  'canvas',
+  'workflow',
+  'execute',
+  'execution',
+  'provider',
+  'api',
+  'export',
+  'import',
+  'package',
+  'result',
+  'screenshot',
+]
+
+const productProjectTerms = [
+  'product',
+  'productization',
+  'user',
+  'customer',
+  'workflow',
+  'interface',
+  'canvas',
+  'provider',
+  'export',
+  'browser',
+]
+
+const skillProjectTerms = [
+  'skill',
+  'agentic engineering skill',
+  'operating model',
+  'open-source skill',
+  'portable command',
+  'host adapter',
+]
+
+function hasAnyTerm(text, terms) {
+  const value = String(text || '').toLowerCase()
+  return terms.some((term) => value.includes(term))
+}
+
+function isInternalEvidenceRecord(record) {
+  const evidenceLevel = String(record?.evidenceLevel || '').toLowerCase()
+  const requiredEvidenceLevel = String(record?.requiredEvidenceLevel || '').toLowerCase()
+  const text = [
+    record?.summary,
+    record?.nextAction,
+    Array.isArray(record?.commands) ? record.commands.join(' ') : '',
+  ].join(' ')
+  const lowLevel = evidenceLevel === 'verified-unit' || evidenceLevel === 'verified-component'
+  const notVisibleProof = requiredEvidenceLevel !== 'verified-browser' && !hasAnyTerm(text, ['browser smoke', 'screenshot', 'playwright'])
+  return lowLevel && notVisibleProof && hasAnyTerm(text, internalProgressTerms)
+}
+
+function analyzeProductProgressDrift(records, state) {
+  const recent = Array.isArray(records) ? records.slice(-6) : []
+  const internalRecent = recent.filter(isInternalEvidenceRecord)
+  const currentText = [
+    state?.currentSlice?.outcome,
+    state?.currentSlice?.nextAction,
+    state?.currentSummary?.currentPlan,
+  ].join(' ')
+  const currentInternal = hasAnyTerm(currentText, internalProgressTerms)
+  const currentVisible = hasAnyTerm(currentText, visibleProgressTerms)
+  const triggered = recent.length >= 3 && internalRecent.length >= 3 && currentInternal && !currentVisible
+  return {
+    status: triggered ? 'warning' : 'clear',
+    recentRecords: recent.length,
+    internalRecords: internalRecent.length,
+    trigger: triggered ? 'repeated-internal-component-slices' : 'not-detected',
+    recommendation: triggered
+      ? 'Open a product-visible recovery slice before another internal evidence/provenance slice.'
+      : 'Keep checking product-visible progress against the project north star.',
+    limits: [
+      'This is a soft steering guard, not a hard failure.',
+      'It detects repeated internal/component-level evidence patterns; project owners can still choose a risk-reduction slice deliberately.',
+    ],
+  }
+}
+
+function classifyProjectType(target, state, canonicalPlan, profileText, goalMapText) {
+  const packageJson = readJson(path.join(target, 'package.json'))
+  const packageName = String(packageJson.data?.name || '').toLowerCase()
+  const projectName = String(state?.projectName || '').toLowerCase()
+  const canonicalPlanText = canonicalPlan ? readText(path.join(target, canonicalPlan)) : ''
+  const text = [
+    projectName,
+    packageName,
+    canonicalPlan,
+    canonicalPlanText.slice(0, 4000),
+    profileText,
+    goalMapText,
+  ].join(' ').toLowerCase()
+
+  if (
+    projectName === 'gse' ||
+    packageName.includes('/gse') ||
+    packageName === 'gse' ||
+    String(canonicalPlan || '').includes('.gse/gse-design-master-plan.md')
+  ) {
+    return 'skill'
+  }
+  if (hasAnyTerm(text, productProjectTerms) && !hasAnyTerm(text, skillProjectTerms)) return 'product'
+  if (hasAnyTerm(text, ['library', 'package', 'sdk', 'cli'])) return 'library'
+  if (hasAnyTerm(text, productProjectTerms)) return 'product'
+  return 'unknown'
+}
+
+function classifySliceType(text) {
+  const value = String(text || '')
+  const visible = hasAnyTerm(value, visibleProgressTerms)
+  const support = hasAnyTerm(value, internalProgressTerms) || hasAnyTerm(value, [
+    'guard',
+    'audit',
+    'index',
+    'repair',
+    'validator',
+    'validation',
+    'preflight',
+    'sync',
+    'maintenance',
+  ])
+  if (visible) return 'product-visible'
+  if (support) return 'support'
+  return 'unknown'
+}
+
+function analyzeProductOutcomeGate(target, records, state, canonicalPlan, profileText, goalMapText) {
+  const projectType = classifyProjectType(target, state, canonicalPlan, profileText, goalMapText)
+  const recent = Array.isArray(records) ? records.slice(-6) : []
+  const currentText = [
+    state?.currentSlice?.id,
+    state?.currentSlice?.outcome,
+    state?.currentSlice?.nextAction,
+    state?.currentSummary?.currentPlan,
+    goalMapText,
+  ].join(' ')
+  const sliceType = classifySliceType(currentText)
+  const currentUserVisibleDelta = cleanInlineValue(
+    state?.currentSlice?.userVisibleDelta ||
+    state?.currentSummary?.userVisibleDelta ||
+    '',
+  )
+  const supportSliceBoundary = cleanInlineValue(state?.currentSlice?.supportSliceBoundary || '')
+  const recentSupportRecords = recent.filter((record) => {
+    const text = [
+      record?.summary,
+      record?.nextAction,
+      record?.userVisibleDelta,
+      Array.isArray(record?.commands) ? record.commands.join(' ') : '',
+    ].join(' ')
+    return classifySliceType(text) === 'support'
+  })
+  const recentVisibleRecords = recent.filter((record) => {
+    const text = [
+      record?.summary,
+      record?.nextAction,
+      record?.userVisibleDelta,
+      Array.isArray(record?.commands) ? record.commands.join(' ') : '',
+    ].join(' ')
+    return classifySliceType(text) === 'product-visible'
+  })
+  const latestVisibleDelta = currentUserVisibleDelta || cleanInlineValue([...recent].reverse().find((record) => record?.userVisibleDelta)?.userVisibleDelta || '')
+  const applicable = projectType === 'product'
+  const supportSliceStreak = recentSupportRecords.length
+  const warning = applicable && sliceType === 'support' && supportSliceStreak >= 3 && !latestVisibleDelta && !supportSliceBoundary
+  return {
+    status: !applicable ? 'not-applicable' : warning ? 'warning' : 'passed',
+    projectType,
+    sliceType,
+    userVisibleDelta: latestVisibleDelta || null,
+    supportSliceBoundary: supportSliceBoundary || null,
+    supportSliceStreak,
+    recentVisibleRecords: recentVisibleRecords.length,
+    recommendation: warning
+      ? 'For product work, open the next slice around a user-visible behavior, workflow, API/provider result, export, screenshot, or failure state.'
+      : applicable && sliceType === 'support' && supportSliceBoundary
+        ? `Keep this support slice within its declared boundary: ${supportSliceBoundary}`
+      : applicable
+        ? 'Keep naming the user-visible delta when product work is the mainline.'
+        : 'Product outcome gate is not applied to this project type.',
+    limits: [
+      'This is a soft steering gate, not a hard blocker.',
+      'Support slices remain valid when they are deliberate and bounded.',
+      'supportSliceBoundary is optional metadata for the current support slice; it must name a narrow scope or exit criterion.',
+      'API or workflow smoke can satisfy product-visible progress when browser evidence is not the right proof.',
+    ],
+  }
+}
+
 function isMetaNextSliceCandidate(text) {
   const value = String(text || '').toLowerCase()
   return (
@@ -555,7 +767,7 @@ function buildCandidateActionPacket(candidate) {
   return base
 }
 
-function buildNextSliceCandidates(target, state, nextSliceMode) {
+function buildNextSliceCandidates(target, state, nextSliceMode, productProgressDrift = null, productOutcomeGate = null) {
   if (nextSliceMode.action !== 'open-next-slice') return []
 
   const roadmapText = readText(path.join(target, 'references', 'final-form-roadmap.md'))
@@ -571,6 +783,46 @@ function buildNextSliceCandidates(target, state, nextSliceMode) {
   const candidates = []
   const firstReason = goalMapNext ? fullCandidateReason(goalMapNext) : currentNextAction
 
+  if (productOutcomeGate?.status === 'warning') {
+    candidates.push({
+      kind: 'product-visible-recovery',
+      title: 'Recover product outcome',
+      source: 'compactState.productOutcomeGate',
+      fullReason: productOutcomeGate.recommendation,
+      outcomeHint: 'Make the next product slice answer what the user can now do, see, run, export, or diagnose.',
+      scopeHint: 'Pick one visible UI, workflow, API/provider, export/import, or result path and keep internal evidence work as support only.',
+      acceptanceHint: 'Acceptance must name the user-visible behavior, result, failure state, or workflow step that changed.',
+      evidenceHint: 'Use the lightest proof that exercises the product path, such as API smoke, workflow smoke, browser smoke, screenshot, or exported result.',
+      riskHint: 'Do not let support work such as provenance, state, evidence, handoff, or audits replace the product mainline repeatedly.',
+      nextActionHint: 'Rewrite the current slice so its outcome is product-visible before changing implementation files.',
+      focusedChecks: [
+        'node scripts\\run-gse-command.mjs --target . --command "/gse continue" --json --compact',
+        'Run one focused product-visible smoke or workflow/API test for the selected path.',
+      ],
+      suggestedProfile: 'lite',
+    })
+  }
+
+  if (productProgressDrift?.status === 'warning') {
+    candidates.push({
+      kind: 'product-visible-recovery',
+      title: 'Recover product-visible progress',
+      source: 'compactState.productProgressDrift',
+      fullReason: productProgressDrift.recommendation,
+      outcomeHint: 'Make the next slice prove one user-visible workflow step or production capability instead of another internal state handoff.',
+      scopeHint: 'Choose a narrow UI/API/browser/provider/export path from the project north star and keep GSE as a light guardrail.',
+      acceptanceHint: 'Acceptance must name the user-visible behavior, result, failure state, or workflow step that changed.',
+      evidenceHint: 'Use the lightest focused proof that exercises the visible path, such as browser smoke, API smoke, screenshot, or product workflow test.',
+      riskHint: 'Do not let provenance, evidence index, state repair, or close-gate work become the product slice itself unless the owner explicitly asks for process work.',
+      nextActionHint: 'Rewrite current-slice around product-visible outcome before editing code.',
+      focusedChecks: [
+        'node scripts\\run-gse-command.mjs --target . --command "/gse continue" --json --compact',
+        'Run one focused product-visible smoke or workflow/API test for the selected path.',
+      ],
+      suggestedProfile: 'lite',
+    })
+  }
+
   const roadmapCandidate = roadmapBullets.find((item) =>
     item.toLowerCase().includes('short entry') ||
     item.toLowerCase().includes('continue') ||
@@ -762,6 +1014,8 @@ function buildContinuePacket(target) {
   const sessionSyncBoundary = readSessionSyncBoundary(resolvedTarget)
   const evidenceLevelAnalysis = analyzeEvidenceLevels(evidenceIndex.records)
   const evidenceReviewQueue = analyzeEvidenceReviewQueue(evidenceIndex.records, resolvedTarget)
+  const productProgressDrift = analyzeProductProgressDrift(evidenceIndex.records, state)
+  const productOutcomeGate = analyzeProductOutcomeGate(resolvedTarget, evidenceIndex.records, state, canonicalPlan, profileText, goalMapText)
   const evidenceLevelIssueCount =
     evidenceLevelAnalysis.invalidLevel.length +
     evidenceLevelAnalysis.downgraded.length +
@@ -901,6 +1155,22 @@ function buildContinuePacket(target) {
         ? 'Do not infer target-session adoption from installed-copy sync or notification records.'
         : 'Repair .gse/session-sync.jsonl before relying on sync records.',
     ),
+    makeCheck(
+      'CP22',
+      'product-visible progress drift is surfaced',
+      productProgressDrift.status !== 'warning',
+      `${productProgressDrift.trigger}; ${productProgressDrift.internalRecords}/${productProgressDrift.recentRecords} recent internal record(s)`,
+      'soft',
+      productProgressDrift.recommendation,
+    ),
+    makeCheck(
+      'CP23',
+      'product outcome gate is surfaced',
+      productOutcomeGate.status !== 'warning',
+      `${productOutcomeGate.projectType}/${productOutcomeGate.sliceType}; supportStreak=${productOutcomeGate.supportSliceStreak}; userVisibleDelta=${productOutcomeGate.userVisibleDelta ? 'present' : 'missing'}`,
+      'soft',
+      productOutcomeGate.recommendation,
+    ),
   ]
 
   const projectName = cleanInlineValue(
@@ -950,7 +1220,7 @@ function buildContinuePacket(target) {
   const completionPlan = buildCompletionPlan(resolvedTarget, state, maintenanceSnapshot)
   const gateTaxonomy = buildGateTaxonomy(blockedGates)
   const nextSliceMode = buildNextSliceMode(state)
-  const nextSliceCandidates = buildNextSliceCandidates(resolvedTarget, state, nextSliceMode)
+  const nextSliceCandidates = buildNextSliceCandidates(resolvedTarget, state, nextSliceMode, productProgressDrift, productOutcomeGate)
   const nextChecks = [
     'node scripts/run-gse-command.mjs --target <project-root> --command "/gse doctor" --json',
     ...completionPlan.requiredCloseCommands,
@@ -979,6 +1249,8 @@ function buildContinuePacket(target) {
     nextSliceMode,
     nextSliceCandidates,
     nextChecks,
+    productProgressDrift,
+    productOutcomeGate,
     completionPlan,
     toolStatuses: state?.toolStatuses ?? {},
     latestEvidence,
@@ -1158,6 +1430,7 @@ function renderMarkdown(report) {
   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('- Product outcome gate: ' + report.compactState.productOutcomeGate.status + ' (' + report.compactState.productOutcomeGate.projectType + '/' + report.compactState.productOutcomeGate.sliceType + ')')
   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)