@t275005746/gse 0.1.1 → 0.1.2

package/references/commands.md

@@ -19,9 +19,10 @@ node <gse-skill>/scripts/run-gse-command.mjs --target <gse-skill> --command "/gs
 node <gse-skill>/scripts/run-gse-command.mjs --target <gse-skill> --command "/gse probe --public-repo-url __PUBLIC_REPO_URL__" --json
 node <gse-skill>/scripts/run-gse-command.mjs --target <gse-skill> --command "/gse package" --json
 node <gse-skill>/scripts/run-gse-command.mjs --target <gse-skill> --command "/gse install --source __PACKAGE_DIR__ --install-target __INSTALL_SKILL_DIR__" --json
-node <gse-skill>/scripts/run-gse-command.mjs --target <gse-skill> --command "/gse public-release" --json
-node <gse-skill>/scripts/run-gse-command.mjs --target <project-root> --command "/gse learn --summary __LESSON__" --execute --json
-```
+node <gse-skill>/scripts/run-gse-command.mjs --target <gse-skill> --command "/gse public-release" --json
+node <gse-skill>/scripts/run-gse-command.mjs --target <project-root> --command "/gse learn --summary __LESSON__" --execute --json
+node <gse-skill>/scripts/run-gse-command.mjs --target <project-root> --command "/gse repair" --json
+```
 
 Validation profile helper:
 
@@ -44,22 +45,24 @@ The Claude adapter writes `.claude/commands/gse.md`, matching Claude Code's docu
 | `/gse help` | Show available GSE commands and the current project entry files | Command help | `SKILL.md`, `references/commands.md` | none or file inspection |
 | `/gse init` | Initialize `.gse/` in a new project | Project bootstrap | project rules, `project-bootstrap.md` | scaffold file check |
 | `/gse adopt` | Adopt GSE in an existing project without overwriting local rules | Project adoption | project rules, `adoption-recipes.md`, `project-profile.md` | discovery or adoption smoke |
-| `/gse continue` | Continue the current project from its goal map or canonical plan | Execute workflow | project rules, `.gse/project-profile.md`, goal map or canonical plan | focused test/smoke for the slice |
-| `/gse status` | Show current project state; for the GSE skill, show final-form progress and remaining public/host blockers | Status workflow | `.gse/state.json`; for GSE skill, final readiness audits | state/report inspection |
-| `/gse doctor` | Diagnose public/host acceptance blockers for the GSE skill, or target-project GSE readiness for normal projects | Final acceptance or project doctor | final readiness matrix, `.gse/state.json`, project profile | public acceptance doctor or target project doctor |
-| `/gse acceptance` | Alias for `/gse doctor` when the user wants final acceptance boundaries | Final acceptance doctor | final readiness matrix and owner/external evidence records | public acceptance doctor |
+| `/gse continue` | Continue the current project through a hard preflight and compact state packet | Execute workflow | project rules, `.gse/state.json`, evidence index, `.gse/project-profile.md`, quality gates, goal map or canonical plan | continue preflight plus focused test/smoke for the slice |
+| `/gse status` | Show current project state; for the GSE skill, show final-form progress and pending public/host claim evidence | Status workflow | `.gse/state.json`; for GSE skill, final readiness audits | state/report inspection |
+| `/gse doctor` | Diagnose public/host claim evidence for the GSE skill, or target-project GSE readiness for normal projects | Final acceptance or project doctor | final readiness matrix, `.gse/state.json`, project profile | public acceptance doctor or target project doctor |
+| `/gse repair` | Diagnose or repair stale state, broken evidence JSONL, and overlong residual risks | State/evidence repair workflow | `.gse/state.json`, `.gse/evidence/index.jsonl`, latest evidence files | state repair audit; optional execute-gated residual risk compaction |
+| `/gse acceptance` | Alias for `/gse doctor` when the user wants final acceptance boundaries | Final acceptance doctor | final readiness matrix and owner/external evidence records | public acceptance doctor |
 | `/gse owner-actions` | Show the remaining owner/external actions required before the GSE skill can claim public acceptance | Owner/external action packet | final readiness matrix and public acceptance doctor | owner action command smoke |
 | `/gse probe` | Probe supplied owner/external evidence locations before accepted records are written | Public external gate probe | public repo/security/CI/registry/marketplace/host evidence inputs | public external gate probe audit |
 | `/gse release` | Dry-run or generate the GSE release bundle for open-source/package handoff | Release bundle workflow | release metadata, package snapshot, acceptance handoff, owner/external kit | release bundle audit |
 | `/gse package` | Dry-run or generate a local installable GSE package | Package workflow | package label and output directory | package manifest or distribution audit |
-| `/gse install` | Dry-run or install GSE from a local package path or URL-shaped package source | Install workflow | package source and install target | install dry-run or installed CLI smoke |
-| `/gse public-release` | Dry-run or generate the ordered public release checklist for owner execution | Public release checklist workflow | release status manifest and pending owner/external gates | public release checklist audit |
-| `/gse change` | Create or normalize a GSE change spec pack | Spec workflow | change id, task level, goal map | change folder structure check |
+| `/gse install` | Dry-run or install GSE from a local package path or URL-shaped package source | Install workflow | package source and install target | install dry-run or installed CLI smoke |
+| `/gse public-release` | Dry-run or generate the ordered public release checklist for owner execution | Public release checklist workflow | release status manifest and pending owner/external gates | public release checklist audit |
+| `/gse maintenance` | Audit recurring maintenance coverage for benchmark, drift, security, forward-test, target drills, public acceptance, and installed sync | Maintenance workflow | `maintenance-cadence.md`, validation profile, current final-form state | maintenance cadence audit |
+| `/gse change` | Create or normalize a GSE change spec pack | Spec workflow | change id, task level, goal map | change folder structure check |
 | `/gse slice` | Define or normalize outcome, scope, acceptance, evidence, risk, and next action | Spec workflow | `goal-map.md`, `spec-workflow.md`, `quality-gates.md` | structural check |
 | `/gse verify` | Run the smallest verification that proves the current slice | Verification gate | `quality-gates.md`, project profile, evidence taxonomy | focused test/API/browser smoke |
-| `/gse learn` | Record a reusable lesson in `.gse/learnings.md` | Learning workflow | summary, trigger, source, optional impact | learning command audit |
+| `/gse learn` | Record a reusable lesson in `.gse/learnings.md`; with `--promote`, classify repeated lessons into promotion candidates | Learning workflow | summary, trigger, source, optional impact, optional `--promote` | learning command and promotion audits |
 | `/gse audit` | Check workflow drift, stale claims, missing evidence, or too-heavy process | Audit workflow | `benchmark-audit.md`, `drift-audit.md`, project profile | audit script or checklist |
-| `/gse close` | Check whether the current slice is ready to close | Close readiness check | `.gse/state.json`, evidence index, quality gates | close gate audit |
+| `/gse close` | Check whether the current slice is ready to close | Close readiness check | `.gse/state.json`, evidence index, quality gates, role fallback packets, git status | close gate audit |
 
 ## Aliases
 
@@ -68,17 +71,19 @@ The Claude adapter writes `.claude/commands/gse.md`, matching Claude Code's docu
 - `gse adopt` -> `/gse adopt`
 - `gse continue` -> `/gse continue`
 - `gse next` -> `/gse continue`
-- `gse status` -> `/gse status`
-- `gse doctor` -> `/gse doctor`
-- `gse acceptance` -> `/gse acceptance`
+- `gse status` -> `/gse status`
+- `gse doctor` -> `/gse doctor`
+- `gse repair` -> `/gse repair`
+- `gse acceptance` -> `/gse acceptance`
 - `gse owner-actions` -> `/gse owner-actions`
 - `gse owner` -> `/gse owner-actions`
 - `gse probe` -> `/gse probe`
 - `gse release` -> `/gse release`
 - `gse package` -> `/gse package`
-- `gse install` -> `/gse install`
-- `gse public-release` -> `/gse public-release`
-- `gse change` -> `/gse change`
+- `gse install` -> `/gse install`
+- `gse public-release` -> `/gse public-release`
+- `gse maintenance` -> `/gse maintenance`
+- `gse change` -> `/gse change`
 - `gse spec` -> `/gse change`
 - `gse slice` -> `/gse slice`
 - `gse verify` -> `/gse verify`
@@ -92,19 +97,28 @@ The Claude adapter writes `.claude/commands/gse.md`, matching Claude Code's docu
 /gse continue AION
 ```
 
-Expected behavior:
-
-1. Enter the project root.
-2. Read project rules, `.gse/state.json`, and `.gse/project-profile.md`.
-3. Read the project's canonical plan when one is declared.
-4. Pick the next verifiable slice from the machine-readable state plus goal map.
-5. Execute, verify, record evidence, update `.gse/state.json` and `.gse/evidence/index.jsonl`, and close only when accepted by the applicable gate.
-
-Portable helper:
-
-```text
-node <gse-skill>/scripts/generate-session-prompt.mjs --target <project-root>
-```
+Expected behavior:
+
+1. Enter the project root.
+2. Run the hard preflight: `.gse/state.json`, `.gse/evidence/index.jsonl`, `.gse/project-profile.md`, `.gse/goal-map.md`, `.gse/quality-gates.md`, canonical plan, current slice, residual risks, and owner/external gates when the target exposes them.
+3. Return a compact state packet with project identity, phase, current slice, next action, top risks, blocked gates, gate taxonomy, tool statuses, latest evidence, active project guards, next checks, and `completionPlan`.
+4. Fail before implementation when local state or evidence index is broken.
+5. Keep owner/external evidence visible as public/release/host-specific claim requirements without converting it into GSE core workflow debt.
+6. Use `completionPlan.requiredSteps`, `completionPlan.requiredCloseCommands`, and active `completionPlan.conditionalCloseCommands` as the exact close checklist before claiming a slice is done.
+7. Use `gateTaxonomy` to distinguish default core blockers from release gates and host-adapter claim gates. Release and host-adapter gates block only the specific claim unless project policy promotes them.
+8. Execute, verify, record evidence, update `.gse/state.json` and `.gse/evidence/index.jsonl`, and close only when accepted by the applicable gate.
+
+Portable helper:
+
+```text
+node <gse-skill>/scripts/generate-continue-packet.mjs --target <project-root>
+```
+
+Project guard helper:
+
+```text
+node <gse-skill>/scripts/audit-project-guards.mjs --target <project-root> --json
+```
 
 For existing projects that have `.gse/` but do not yet have machine-readable continuation files:
 
@@ -163,7 +177,8 @@ Expected behavior:
 3. Do not fix unrelated project code unless explicitly asked.
 
 ```text
-/gse learn --summary "Prefer UTF-8 safe readers for Chinese docs before judging mojibake" --trigger "encoding review" --source "project slice"
+/gse learn --summary "Prefer UTF-8 safe readers for Chinese docs before judging mojibake" --trigger "encoding review" --source "project slice"
+/gse learn --promote
 ```
 
 Expected behavior:
@@ -172,7 +187,8 @@ Expected behavior:
 2. Require `--summary`; accept optional `--trigger`, `--source`, `--impact`, and `--promotion`.
 3. Append the entry only when `--execute` is supplied.
 4. Skip duplicate summaries instead of appending repeated lessons.
-5. Keep raw chain-of-thought, long logs, and temporary attempts out of learnings.
+5. Keep raw chain-of-thought, long logs, and temporary attempts out of learnings.
+6. With `--promote`, run learning promotion analysis. Add `--execute` only to write candidate-only `.gse/learning-promotions.md`; do not mutate guards, gates, templates, scripts, or skill files automatically.
 
 ```text
 /gse status
@@ -181,22 +197,34 @@ Expected behavior:
 Expected behavior:
 
 1. For normal projects, read `.gse/state.json` and show phase, current slice, next action, and declared project files.
-2. For the GSE skill package itself, run the final-form progress report in dry-run mode and show local engineering readiness, full final-form readiness, pending owner/external gates, and `publicAccepted`.
+2. For the GSE skill package itself, run the final-form progress report in dry-run mode and show local engineering readiness, full final-form readiness, pending owner/external release evidence, and `publicAccepted`.
 3. Do not treat status output as completion evidence unless the relevant gate audit is also recorded.
 
-```text
-/gse doctor
-```
+```text
+/gse doctor
+```
 
 Expected behavior:
 
-1. For the GSE skill package, run the public acceptance doctor and list remaining owner/external blockers with concrete record commands.
+1. For the GSE skill package, run the public acceptance doctor and list pending owner/external claim evidence with concrete record commands.
 2. For normal target projects, run the target project doctor and report `.gse/` readiness, canonical plan visibility, evidence state, and host adapter drift.
-3. Keep owner-required and external-required gates explicit. Do not convert local mechanics into public acceptance.
-
-```text
-/gse owner-actions
-```
+3. Keep owner-required and external-required gates explicit. Do not convert local mechanics into public acceptance.
+
+```text
+/gse repair
+```
+
+Expected behavior:
+
+1. Read `.gse/state.json` and `.gse/evidence/index.jsonl`.
+2. Return concrete repair actions for invalid state JSON, invalid evidence JSONL, missing latest evidence files, stale state/evidence next actions, and overlong residual risks.
+3. Stay read-only by default.
+4. Automatic writes are limited to reversible residual-risk compaction with a backup, and require `--execute`.
+5. Do not guess or overwrite broken JSON/JSONL; report the file and line/error so the owner or agent can repair deliberately.
+
+```text
+/gse owner-actions
+```
 
 Expected behavior:
 
@@ -278,7 +306,7 @@ Expected behavior:
 ## Completion Rules
 
 - `/gse continue`, `/gse verify`, and `/gse close` must preserve the result -> verified -> accepted distinction.
-- `/gse close` is read-only in the portable command runner. It cannot mark a slice complete, archive a change, or write evidence by itself.
+- `/gse close` is read-only in the portable command runner. It checks state, evidence, role dispatch honesty, worktree ownership, staged generated artifacts, and `.gse` git state. It cannot mark a slice complete, archive a change, or write evidence by itself.
 - Portable close check:
 
 ```text
@@ -291,5 +319,6 @@ node <gse-skill>/scripts/audit-close-gate.mjs --target <project-root>
 node <gse-skill>/scripts/close-change.mjs --target <project-root> --change-id <change-id> --status result|verified|accepted --json
 ```
 
-- `/gse audit` cannot certify arbitrary repositories unless project-specific checks ran.
+- `/gse maintenance` verifies recurring upkeep coverage and command wiring; it does not replace real external host, CI, marketplace, or owner evidence.
+- `/gse audit` cannot certify arbitrary repositories unless project-specific checks ran.
 - `/gse init` and `/gse adopt` cannot overwrite existing project workflow files without explicit owner approval or `--force` with a recorded reason.

package/references/drift-audit.md

@@ -67,7 +67,8 @@ Choose the smallest durable remediation:
 - Refresh host adapter notes when host-specific folders duplicate policy or claim unavailable capabilities.
 - Refresh tool/model routing notes when provider, model, MCP, LSP, browser, CI, or deployment assumptions changed.
 - Add a learning entry only when the drift pattern is reusable beyond the current slice.
-- Add or update a script/template/gate when the same drift appears repeatedly.
+- Add or update a script/template/gate when the same drift appears repeatedly.
+- Run `scripts/audit-learning-drift.mjs --root <gse-skill> --target <project-root> --json` when `.gse/learning-promotions.md` or `/gse continue` shows promoted learning candidates. The audit surfaces candidates that are documented but not yet covered by a guard, quality gate, continue/close check, or focused script.
 
 Never update stale docs by inventing support. Prefer `unknown` plus a focused verification action.
 

package/references/evidence-taxonomy.md

@@ -2,13 +2,48 @@
 
 Use this to decide whether work is only produced, actually verified, or accepted.
 
-GSE uses three evidence gates:
+GSE uses three evidence gates:
 
 ```text
 result -> verified -> accepted
 ```
 
-Do not skip gates. Do not claim a higher gate when the evidence only proves a lower gate.
+Do not skip gates. Do not claim a higher gate when the evidence only proves a lower gate.
+
+## Evidence Status vs Evidence Level
+
+Evidence status answers whether the work is result, verified, or accepted.
+
+Evidence level answers what kind of proof produced that status.
+
+Keep both dimensions visible for non-trivial work:
+
+```text
+status: result | verified | accepted | blocked | not ready
+evidenceLevel: result | verified-unit | verified-component | verified-api | verified-browser | verified-ci | accepted-owner | accepted-release | external-required
+requiredEvidenceLevel: optional expected level for the claim
+```
+
+Use the narrowest honest level:
+
+| Evidence level | Meaning | Typical proof |
+|---|---|---|
+| `result` | Artifact exists or command produced an output, but behavior is not verified. | file exists, generated report, dry-run output |
+| `verified-unit` | Unit or script-level behavior is verified. | focused unit test, parser test, structure audit |
+| `verified-component` | Component-level or local integration behavior is verified without a real browser/runtime path. | component test, fixture integration, store/API mock |
+| `verified-api` | API/state contract is verified through an API, route, database, or state-machine check. | API smoke, state contract test, persistence fixture |
+| `verified-browser` | User-visible browser behavior is verified in a real browser automation or equivalent rendered UI smoke. | Playwright/browser smoke, screenshot-backed UI check |
+| `verified-ci` | CI or release pipeline executed and passed in the target environment. | public CI run, release workflow run, build pipeline evidence |
+| `accepted-owner` | Owner/reviewer accepts a verified result. | explicit owner acceptance, review approval, accepted project record |
+| `accepted-release` | Release/publication gate accepts the verified result. | release record, package publication record, marketplace approval |
+| `external-required` | Required evidence depends on an external owner, host, marketplace, registry, or runtime not available in the current local run. | native slash-command host proof, marketplace approval, public release gate |
+
+Examples:
+
+- A UI component test can be `status: verified` with `evidenceLevel: verified-component`, but it must not be described as browser proof.
+- A Playwright smoke can be `status: verified` with `evidenceLevel: verified-browser`.
+- A public CI record can be `status: verified` or `accepted` with `evidenceLevel: verified-ci`, depending on the project acceptance policy.
+- A pending native slash-command claim should stay `evidenceLevel: external-required` until a real host invocation record exists.
 
 ## Gate 1: Result
 
@@ -78,18 +113,20 @@ Example:
 
 ## Required Evidence Record
 
-Every non-trivial GSE slice should record:
+Every non-trivial GSE slice should record:
 
 ```text
 Outcome:
 Scope:
 Acceptance:
-Result evidence:
-Verification evidence:
-Accepted by:
-Residual risk:
-Next action:
-```
+Result evidence:
+Verification evidence:
+Evidence level:
+Required evidence level:
+Accepted by:
+Residual risk:
+Next action:
+```
 
 Use `accepted by: policy` only when the applicable policy is named, such as `Lite focused smoke policy`.
 

package/references/file-ownership.md

@@ -53,8 +53,9 @@ Claims should be short and local to the task. Do not create permanent process ar
 
 When real subagent tools exist:
 
-- Give each subagent a role, objective, allowed files, forbidden files, and expected output.
-- Prefer read-only locator/reviewer/QA roles for broad exploration.
+- Give each subagent a role, objective, allowed files, forbidden files, and expected output.
+- Prefer read-only locator/reviewer/QA roles for broad exploration.
+- Keep release roles focused on release/public/owner/external claim boundaries unless they are explicitly assigned release-file edits.
 - Do not dispatch parallel builders to the same files or tightly coupled modules.
 - Require implementers to report files changed and verification run.
 - Run spec review before code-quality review when both exist.
@@ -62,10 +63,11 @@ When real subagent tools exist:
 
 When no real subagent tool exists:
 
-- Execute roles sequentially in the main session.
-- Say that no real subagent dispatch occurred if the distinction matters.
-- Keep the same ownership boundaries: locator is read-only, builder writes assigned files, reviewer is read-only, QA writes evidence only.
-- Do not fake parallelism, independent review, or subagent status.
+- Execute roles sequentially in the main session.
+- Say that no real subagent dispatch occurred if the distinction matters.
+- Keep the same ownership boundaries: locator is read-only, builder writes assigned files, reviewer is read-only, QA writes evidence only.
+- Verifier records commands and evidence level; release records claim boundaries and external gates.
+- Do not fake parallelism, independent review, or subagent status.
 
 ## Shared File Rules
 
@@ -91,13 +93,15 @@ If two tasks need the same file:
 
 ## Verification Checklist
 
-Before claiming completion:
-
-- Intended files are the only files changed, or every extra file is explained.
-- Pre-existing dirty files were not reverted or overwritten.
-- Generated/test/output artifacts are excluded unless the project requires them.
-- Subagent work, if any, has role, allowed files, and verification evidence.
-- The evidence record names focused validation and residual risk.
+Before claiming completion:
+
+- Intended files are the only files changed, or every extra file is explained.
+- Pre-existing dirty files were not reverted or overwritten.
+- Generated/test/output artifacts are excluded unless the project requires them.
+- Subagent work, if any, has role, allowed files, and verification evidence.
+- The evidence record names focused validation and residual risk.
+
+`scripts/audit-close-gate.mjs` reports staged, unstaged, untracked, mixed, conflict, and common generated/test artifact paths so close reviews do not have to infer ownership from prose.
 
 ## Project Integration
 

package/references/final-form-roadmap.md

@@ -0,0 +1,201 @@
+# GSE Final Form Roadmap
+
+This roadmap defines the final product shape for GSE itself. It is the canonical continuation plan for GSE development after local v1 capability has been proven.
+
+The goal is not another patch cycle. Final form means a capable agent can enter a new or existing project, run a short GSE entry command, understand the project, select the next slice, execute with the right level of rigor, prove the result, and carry lessons forward without a long hand-written prompt.
+
+## Completion Definition
+
+GSE reaches final form when a new agent can enter any supported project and use `/gse continue` to obtain:
+
+- the project identity, current goal, active slice, and next action,
+- the required spec, quality gates, and evidence level,
+- the available tools, missing tools, role boundaries, and fallback path,
+- pending owner/external release evidence, plus any optional adapter claims that are not being made,
+- the learning rules that should affect the current run,
+- the exact checks needed before completion can be claimed.
+
+Broken state, stale evidence, unsupported tool claims, noisy risk lists, and missing host/runtime evidence must be surfaced before implementation begins.
+
+## Final Form Priorities
+
+| Priority | Area | Outcome | Acceptance |
+|---|---|---|---|
+| P0 | Short entry takeover | `/gse continue` replaces long goal prompts for mature projects | A project with `.gse/` returns current slice, next action, claim-boundary evidence, and required checks through the portable runner; host-native command evidence is recorded only when a specific host adapter claims it |
+| P1 | State system | Project state is readable, compact, repairable, and not a risk dump | State separates current summary, active slice, top risks, blocked gates, next checks, and archived risk history |
+| P2 | Evidence gate | Claims cannot outrun evidence | Evidence index validity is a preflight gate; bad JSONL, stale records, and downgraded UI/browser proof are labeled before close |
+| P3 | Spec and change lifecycle | GSE provides OpenSpec-style change control without requiring OpenSpec | Change packs move through proposed, active, implemented, verified, accepted, and archived states with goal-map links |
+| P4 | Roles and subagents | GSE provides Superpowers-style execution discipline without requiring a specific subagent host | Planner, locator, implementer, verifier, reviewer, doc/evidence, and release roles have dispatch packets and fallback checklists; process skills do not prove real host dispatch |
+| P5 | Tool and quality gates | Tool use is fast, explicit, and project-aware | LSP/index, browser, Playwright, MCP, CI, package manager, Windows shell, sparse checkout, UTF-8, and project custom gates are preflighted when relevant |
+| P6 | Learning automation | Repeated failures become guards | Lessons dedupe, classify severity, and promote into project quality gates, templates, scripts, or skill updates |
+| P7 | Project init and adapters | New projects get the right scaffold without heavy prerequisites | Lite, Standard, and Enterprise scaffolds create `.gse/` plus optional host pointers for `.codex`, `.claude`, `.mcp`, and similar folders |
+| P8 | Release and distribution | GSE is installable, auditable, and maintainable as an open-source skill product | npm/package install, GitHub release, public CI, security contact, repository settings, registry/marketplace records, bilingual docs, checksums/signing, and update paths are verified or honestly gated |
+| P9 | Benchmark and drills | GSE remains competitive with mature engineering skills | Regular audits compare against OpenSpec, Superpowers/BMAD-style roles, Comet-style phase discipline, and real projects such as AION and MuseFlow |
+| P10 | Final acceptance | Final claims are backed by real evidence at the right claim level | AION doctor, MuseFlow doctor, new-project bootstrap, `/gse continue`, evidence repair, state compaction, role dispatch, learning promotion, package publication, public CI, and portable command execution pass; host-native invocation is optional per host adapter and must be recorded before that adapter claims it |
+
+## First Execution Wave
+
+1. Done: make `/gse continue` run a hard preflight: state JSON, evidence index, project profile, quality gates, canonical plan, stale risks, and pending owner/external release evidence when the target exposes it.
+2. Done: split `.gse/state.json` into a compact default view and an archived risk/decision history so active sessions do not inherit unreadable residual risk blocks.
+3. Done for continuation: promote evidence index validity from target-project doctor finding to blocking preflight for `/gse continue`; close-gate evidence index validation already remains in place.
+4. Done: add explicit evidence levels for UI/browser/API/CI/owner/release/external proof: `verified-unit`, `verified-component`, `verified-api`, `verified-browser`, `verified-ci`, `accepted-owner`, `accepted-release`, and `external-required`.
+5. Done: convert reusable lessons from AION and MuseFlow into guards: Windows shell syntax, sparse checkout staging, UTF-8-safe Chinese docs, stale evidence, browser-smoke downgrade labeling, no fake subagent dispatch, and non-interrupting cross-thread sync.
+
+## Final Form Execution Plan
+
+This plan turns the completion definition into ordered implementation waves. It is the working plan for GSE itself, not a project roadmap for projects that use GSE.
+
+### Wave 1 - Short Entry And State Control
+
+Outcome: mature projects can resume from a short `/gse continue` entry instead of a long hand-written prompt.
+
+Status: verified; the hard preflight, compact state packet, completion plan, project guards, explicit evidence levels, role fallback readiness, and state/evidence repair path are verified. Native host slash-command evidence is an optional adapter claim, not a GSE core completion gate.
+
+Completed slices:
+
+- Done: `completionPlan` gives future agents exact required close steps, required close commands, and active conditional commands for encoding, installed-sync, maintenance snapshot, release bundle, and session sync.
+- Done: completionPlan drill audit verifies clean worktrees have no false active conditionals and dirty docs/scripts/references/acceptance/evidence changes activate the expected close checks.
+- Done: state repair path provides `/gse repair`, `CP14`, and concrete repair actions for stale state, bad JSONL, missing evidence files, next-action drift, and overlong residual risks.
+- Done: `gateTaxonomy` separates core workflow blockers from release gates and host-adapter claim gates in `/gse continue` compact state.
+- Done: generated/noisy artifacts stay visible in `/gse continue` as ignored paths but no longer count as actionable changes or trigger conditional close commands by themselves.
+- Done: active residual risks and archived risk history are counted separately so `/gse continue` does not make historical risk archive entries look like current blockers.
+- Done: the human-facing `/gse continue` prompt is a short action packet with project, root, slice, next action, close summary, risk summary, gate boundary, and do-step instead of long explanatory prose.
+
+Acceptance:
+
+- `/gse continue` shows current slice, next action, top risks, claim-boundary evidence, required checks, relevant guard rules, evidence status, and completion plan.
+- Bad evidence and stale state fail before implementation or return a repair action.
+- Default output stays compact; historical risk detail stays archived.
+
+### Wave 2 - Spec, Role, And Execution Discipline
+
+Outcome: GSE provides OpenSpec-style change control and Superpowers-style execution discipline without requiring either tool.
+
+Status: locally verified for portable execution discipline; role fallback packet outputs, no-fake-dispatch close checks, file-ownership/staged-artifact close checks, and host capability record audits are verified. Real-host dispatch evidence remains host-specific future evidence.
+
+Boundary: OpenSpec-style and Superpowers-style workflows define requirements, change control, execution discipline, and review quality. They do not provide native slash commands, subagent dispatch, browser tooling, MCP, LSP, CI, or host UI integration by themselves. GSE follows the same boundary: those capabilities are optional host adapters and must be recorded as host evidence before they are claimed.
+
+Required slices:
+
+- Change lifecycle hardening: every active change can be opened, verified, closed, archived, and linked back to the goal map.
+- Done: role packet execution fallback: planner, locator, implementer, verifier, reviewer, doc/evidence, and release roles have auditable packet outputs for sequential fallback.
+- Done: no-fake-dispatch guard: close gate blocks real-subagent claims unless the current host/tool status is verified.
+- Done: file ownership and dirty-worktree guard: close gate reports staged, unstaged, untracked, mixed, conflict, and generated/test artifact paths before close.
+
+Acceptance:
+
+- A real target project can run a change pack from open to archive.
+- Role packets work both with real subagents and sequential fallback.
+- Close gate rejects missing evidence, missing review, fake dispatch, and unrelated staged files when the project can expose that data.
+
+### Wave 3 - Learning To Guard Promotion
+
+Outcome: repeated user corrections and project failures become reusable engineering controls.
+
+Status: locally verified; learning capture, duplicate occurrence counting, deterministic promotion analysis, candidate-only promotion reports, `/gse continue` CP15 visibility, and learning drift detection for promoted-but-unenforced candidates are verified.
+
+Completed slices:
+
+- Done: learning classifier categorizes lessons by shell, encoding, evidence, browser, git, host-tool, project-rule, and release.
+- Done: duplicate learning capture increments `Occurrences` without appending noisy duplicate entries.
+- Done: promotion paths follow note -> checklist/template -> guard/quality gate -> script/skill.
+- Done: `/gse learn --promote` is read-only by default, `/gse learn --promote --execute` writes candidate-only `.gse/learning-promotions.md`, and `/gse continue` surfaces CP15 learning promotion status.
+
+Completed slices:
+
+- Done: drift audit detects when promoted learning candidates are not covered by project guards, quality gates, `/gse continue`, `/gse close`, or focused audit scripts.
+
+Acceptance:
+
+- A lesson can be recorded once, deduped, and promoted into a project guard with evidence.
+- `/gse continue` and `/gse close` both surface promoted high-severity guards.
+- AION/MuseFlow lessons are used as examples but no AION/MuseFlow-specific behavior is hardcoded.
+
+### Wave 4 - Tool And Host Runtime Adapters
+
+Outcome: GSE stays portable while using available tools aggressively.
+
+Completed slices:
+
+- Done: host capability audit records track native slash-command, browser, MCP, LSP, subagent, and CI status as `verified`, `documented`, `unknown`, `unavailable`, or `external-required`, with `/gse continue` `CP16` visibility and overclaim checks.
+- Done: target-project hardening drills run GSE doctor, `/gse continue`, close gate, host capability, and learning drift checks against configured real projects without mutating target worktrees.
+- Done: optional tool fallback policy audit verifies markdown fallback and claim boundaries across tool adapters, router, model routing, host adapters, project profile, generated command adapters, continue packet wiring, and validation profiles.
+
+Required slices:
+
+- Native slash-command evidence: record real host-native `/gse continue` invocation only when a host adapter claims native support.
+- Done: Browser/UI evidence policy: `scripts/audit-ui-browser-evidence-policy.mjs` verifies that `verified-component`, `verified-api`, `verified-browser`, screenshot/visual inspection rules, continue/close downgrade surfacing, and validation wiring stay aligned.
+
+Acceptance:
+
+- GSE never claims native host support from portable command evidence alone.
+- Browser/UI verification downgrade is labeled before close.
+- Host adapter docs point back to `.gse/` and do not duplicate canonical rules.
+
+### Wave 5 - Distribution, Public Trust, And Maintenance
+
+Outcome: GSE can be installed, audited, updated, and maintained as an open-source skill product.
+
+Required slices:
+
+- Public release evidence: repository settings, CI, security contact, registry/package channel, marketplace/catalog, release bundle, checksum/signing, and update path records.
+- Done: Installed skill sync: `scripts/audit-installed-sync.mjs` verifies fresh package output, package metadata/version preservation, source-root privacy, installed-copy hash parity, and installed-copy `/gse maintenance` smoke when `--installed-root` is supplied.
+- Done: Session sync records: `scripts/record-session-sync.mjs` and `scripts/audit-session-sync.mjs` make installed-copy refresh and active-session sync attempts auditable without treating notification as adoption.
+- Public docs hardening: keep README and bilingual docs concise, search-friendly, and free of defensive caveat bloat.
+- Done: Maintenance cadence: `references/maintenance-cadence.md`, `/gse maintenance`, and `scripts/audit-maintenance-cadence.mjs` verify benchmark audit, drift audit, dependency/security review, forward-test, target drill, public acceptance, and installed-skill sync coverage.
+- Done: Maintenance snapshot failure isolation: failed canonical `latest-maintenance-snapshot.json` writes are redirected to `latest-maintenance-snapshot.failed.json` so release-bundle and maintenance freshness loops keep the last passing canonical snapshot.
+
+Acceptance:
+
+- `validate-gse` passes the appropriate profile for the release stage.
+- Public acceptance rows are accepted only with real owner/external evidence.
+- A clean consumer project can install GSE, run `gse status`, initialize `.gse/`, and execute `/gse continue` through the portable runner.
+
+## Current Final-Form Gap List
+
+These items should drive future slices only when the claim is being made:
+
+- Short entry takeover is verified through the portable runner; `/gse continue` now exposes a compact action prompt, `completionPlan`, `gateTaxonomy`, generated/noisy ignored paths, and active-versus-archived risk counts. Real host-native slash-command evidence is optional per host adapter.
+- Project guards, learning promotion candidates, learning drift status, no-fake-dispatch/file-ownership close checks, host capability records, and target-project hardening drills now surface or execute through portable audits; AION/MuseFlow drill warnings remain project-local readiness signals, not GSE hard failures.
+- Evidence index validity is a hard preflight; evidence level granularity, state/evidence repair actions, and conservative historical evidence-level backfill are implemented.
+- Role fallback packets and host capability records are auditable through scaffold, `/gse continue`, and focused audits; real subagent dispatch still needs current host evidence.
+- Process skills such as OpenSpec, Superpowers, Comet, and GSE provide workflow discipline and portable artifacts; they do not satisfy host-native slash-command, subagent, browser, MCP, LSP, CI, or host UI evidence rows.
+- Learning capture, occurrence counting, classification, candidate promotion, candidate drift detection, and read-only target-project hardening drills are locally verified; remaining gaps are project-specific product evidence and external host evidence.
+- Public/package release mechanics, browser/UI evidence policy, maintenance cadence, installed/package sync freshness checks, active-session sync records, and portable command execution are verified; optional host-native slash-command evidence is recorded only for hosts that actually expose native support.
+- Failed canonical maintenance snapshot writes are isolated from the last passing snapshot; `.failed.json` is the diagnostic surface for failed runs.
+
+## Goal Mode Operating Contract
+
+Use this when continuing GSE itself in a goal-mode session:
+
+```text
+Goal: implement GSE final form as a portable, installable, evidence-driven engineering skill for long-running agent-assisted software projects.
+
+Workspace:
+<path-to-gse-repo>
+
+Start:
+1. Read the installed GSE `SKILL.md`.
+2. Read .gse/gse-design-master-plan.md, .gse/goal-map.md, .gse/current-slice.md, .gse/state.json, and references/final-form-roadmap.md.
+3. Continue from the current slice and the highest-priority unfinished Final Form roadmap item.
+4. Keep GSE generic. Do not add AION-only or MuseFlow-only behavior; use them as drills and evidence targets.
+
+Loop:
+Goal -> Spec -> Execute -> Evidence -> Learn.
+
+Slice rule:
+Do one verifiable slice at a time. Each slice must state outcome, scope, acceptance, evidence, risk, and next action. Prefer executable scripts, templates, and gates over prose-only rules.
+
+Verification:
+Run the smallest focused audit that proves the slice. For docs-only final-form routing changes, run audit-final-form-roadmap, roadmap consistency, JSON/UTF-8 sanity, and a smoke validation profile. For release or package claims, run the matching release/package audit.
+
+Evidence:
+Append evidence to .gse/evidence/YYYY-MM-DD.md and .gse/evidence/index.jsonl. Do not claim public, native host, marketplace, registry, CI, or owner acceptance without matching accepted records.
+
+Completion:
+A slice is complete only after focused validation passes, evidence is recorded, state/current-slice/goal-map are updated, and the changes are committed.
+```
+
+## Claim Boundary
+
+This roadmap is a contract for final-form development, not proof for every optional adapter claim. The live claim boundary remains `references/final-readiness.md` plus `scripts/audit-final-readiness.mjs`.

package/references/final-readiness.md

@@ -39,7 +39,7 @@ The table below describes the baseline/status source for each row. The current t
 | Marketplace approval | real marketplace/catalog approval or publication evidence | record-driven external gate |
 | Portable command execution | `run-gse-command.mjs` command semantics audit | verified |
 | Host adapters | generated adapter files and compatibility matrix audit | verified |
-| Native slash command | verified host invocation record with native slash support | record-driven external gate |
+| Native slash command | optional per-host adapter claim; verified only if a host invocation record proves native slash support | not claimed by GSE core |
 | Other host runtime invocation | verified invocation records per host | record-driven external gate |
 
 Do not read the baseline column as live status. For example, once the owner-selected license record is accepted, the audit reports `License decision` as `verified` even though the row remains an owner-gated claim type.
@@ -52,7 +52,7 @@ node <gse-skill>/scripts/audit-final-readiness.mjs --root <gse-skill>
 
 The audit must report external and owner gates as incomplete unless corresponding records exist. It is valid for the audit to pass while still reporting `owner-required` or `external-required`; passing means the matrix is honest and complete, not that every external gate is satisfied.
 
-Accepted owner/external records promote final rows only when the record contains accepted evidence and the relevant boundary proof. For example, a public CI row requires an accepted public CI run record with a successful conclusion and required-check proof; a registry row requires accepted publication evidence with registry proof; native slash command support requires a host invocation record that proves native slash-command support.
+Accepted owner/external records promote final rows only when the record contains accepted evidence and the relevant boundary proof. For example, a public CI row requires an accepted public CI run record with a successful conclusion and required-check proof; a registry row requires accepted publication evidence with registry proof. Native slash command support is a per-host optional adapter claim, not a GSE core completion gate; claim it only after a host invocation record proves native slash-command support.
 
 Use the promotion audit to verify that this path still works:
 
@@ -81,4 +81,4 @@ GSE can be described as publicly accepted only after:
 - public repository settings evidence exists when a public source repository is claimed,
 - public CI run evidence exists when public CI is claimed,
 - registry or marketplace publication evidence exists when those channels are claimed,
-- native slash-command support is recorded per host before it is claimed.
+- native slash-command support is recorded per host before it is claimed by that host adapter.