scriveno 2.0.11 → 2.5.0

package/docs/contributing.md

@@ -2,7 +2,7 @@
 
 Scriveno is a pure skill system -- markdown files that AI agents read and execute. There is no compiled code, no build step, no runtime dependencies. Contributing means adding or editing markdown files and updating the central constraint registry.
 
-This guide walks you through extending Scriveno: adding commands, agents, work types, templates, and export formats. Each section is self-contained -- jump to what you need.
+This guide walks you through extending Scriveno: adding commands, agents, work types, templates, and export formats. Each section is self-contained -- jump to what you need. For release operations, use [Release Checklist](release-checklist.md).
 
 ## File Structure Overview
 
@@ -379,6 +379,9 @@ When a package release changes the public story, update the release docs alongsi
 - `CHANGELOG.md` -- package-level release history
 - `docs/release-notes.md` -- public-facing summary of what changed and why it matters
 - `README.md` -- current version/status blurb when the release changes the headline positioning
+- `docs/quick-proof.md` -- proof-first first-run route when install, demo, or proof expectations change
+- `docs/starter-sets.md` -- goal-based command paths when command positioning changes
+- `docs/release-checklist.md` -- publish workflow when release validation changes
 - `docs/shipped-assets.md` -- canonical inventory when bundled docs, templates, proof assets, or trust-critical files change
 - `docs/command-reference.md` -- command contract reference when command behavior or flags change
 - `docs/auto-invoke-policy.md` -- proactive routing, safe apply, local-helper, and agent-spawn policy
@@ -395,7 +398,9 @@ When a package release changes the public story, update the release docs alongsi
 4. Run `npm test`
 5. Run `npm run release:check`
 6. For runtime, installer, agent, sync, or route-intelligence changes, run `scriveno sync --check`, `scriveno smoke --json`, `scriveno agents --json`, and `scriveno routes --json`
-7. Publish only after the docs and package metadata tell the same story
+7. For docs, prompts, command markdown, release notes, and README changes, run `npm run policy:check`
+8. Follow [Release Checklist](release-checklist.md) before publishing
+9. Publish only after the docs and package metadata tell the same story
 
 ## Code Style
 

package/docs/development.md

@@ -106,6 +106,12 @@ Run the release gate before publishing:
 npm run release:check
 ```
 
+Run the writing-policy gate directly when changing docs, prompts, commands, release notes, or public copy:
+
+```bash
+npm run policy:check
+```
+
 Start the installer locally:
 
 ```bash
@@ -143,6 +149,9 @@ For release-oriented documentation surfaces, the main files are:
 
 - `README.md`
 - `CHANGELOG.md`
+- `docs/quick-proof.md`
+- `docs/starter-sets.md`
+- `docs/release-checklist.md`
 - `docs/release-notes.md`
 - `docs/shipped-assets.md`
 - `docs/command-reference.md`
@@ -158,9 +167,10 @@ A good pre-ship pass for Scriveno changes is:
 
 1. run the targeted tests for the touched surface
 2. run `npm test`
-3. run `npm run release:check` for package-facing changes
-4. run the proactive audit commands when routing, runtime, installer, or agent surfaces changed
-5. review trust-sensitive docs for runtime, asset, and support claims
+3. run `npm run policy:check` for docs, command, agent, prompt, and release-note changes
+4. run `npm run release:check` for package-facing changes
+5. run the proactive audit commands when routing, runtime, installer, or agent surfaces changed
+6. review trust-sensitive docs for runtime, asset, and support claims
 
 ## Related docs
 
@@ -168,6 +178,8 @@ A good pre-ship pass for Scriveno changes is:
 - [Configuration](configuration.md)
 - [Testing](testing.md)
 - [Contributing](contributing.md)
+- [Quick Proof](quick-proof.md)
+- [Release Checklist](release-checklist.md)
 - [Auto-Invoke Policy](auto-invoke-policy.md)
 - [Runtime Support](runtime-support.md)
 - [Route Graph Audit](route-graph.md)

package/docs/getting-started.md

@@ -2,7 +2,7 @@
 
 Go from zero to a drafted scene in under 10 minutes. This guide walks you through installation, project setup, and your first draft.
 
-Want evidence first? Start with [Proof Artifacts](proof-artifacts.md). The watchmaker sample flow and the Voice DNA before/after bundle give you the fastest way to inspect what Scriveno actually proves today.
+Want evidence first? Start with [Quick Proof](quick-proof.md), then continue to [Proof Artifacts](proof-artifacts.md). The watchmaker sample flow and the Voice DNA before/after bundle give you the fastest way to inspect what Scriveno actually proves today.
 
 ## Prerequisites
 
@@ -22,12 +22,13 @@ npx scriveno@latest
 
 This installs Scriveno into the runtime you choose. Command-directory and skills targets place files where the runtime expects them. Guided targets like Perplexity Desktop instead write setup assets and show the exact connector steps you need. Takes about 30 seconds.
 
-Once installed, Claude Code uses flat `/scr-*` commands such as `/scr-help` and `/scr-new-work`. Other command-directory runtimes currently keep `/scr:*`. Codex uses generated `$scr-*` skills such as `$scr-help` and `$scr-new-work`. Guided targets explain their supported setup path directly in the generated setup files.
+Once installed, Claude Code uses flat `/scr-*` commands such as `/scr-help`, `/scr-first-run`, and `/scr-new-work`. Other command-directory runtimes currently keep `/scr:*`. Codex uses generated `$scr-*` skills such as `$scr-help`, `$scr-first-run`, and `$scr-new-work`. Guided targets explain their supported setup path directly in the generated setup files.
 
 You can also ask Scriveno for a read-only project status from any terminal:
 
 ```
 scriveno status --project .
+scriveno first-run --project .
 scriveno status . --json
 scriveno status --project . --apply-safe
 scriveno sync --check
@@ -37,6 +38,8 @@ That status command is the same shared auto-invoke engine used by `/scr-next`, `
 
 Use `--apply-safe` when you want Scriveno to run the read-only checks and show which helpers are safe, skipped, or agent-ready. Use `sync --check` when you want the installed runtime surfaces checked too.
 
+If you want one guided proof path instead of separate checks, start with `scriveno first-run --project .`.
+
 ## Step 2: Explore the Demo (Optional)
 
 Not sure what Scriveno does? Try the demo before starting your own project:
@@ -63,7 +66,7 @@ This creates a pre-built short story project -- a retired watchmaker who receive
 
 Explore at your own pace. When you're ready to start your own work, run `/scr-demo --clear` to clean up.
 
-If you want a curated reading path instead of jumping straight into the demo files, open [Proof Artifacts](proof-artifacts.md) first. It maps the watchmaker sample to the exact files worth inspecting.
+If you want a curated reading path instead of jumping straight into the demo files, open [Quick Proof](quick-proof.md) first. It maps the install checks, runtime command shapes, watchmaker demo, and next draft into one 10-minute path.
 
 ## Step 3: Start Your Project
 
@@ -204,11 +207,13 @@ Beyond the core workflow, Scriveno offers:
 - **Versions** -- `/scr-save`, `/scr-history`, `/scr-versions`, `/scr-compare`
 - **Navigation** -- `/scr-help`, `/scr-next`, `/scr-pause-work`
 
-For the full command list, see [Command Reference](command-reference.md).
+For small goal-based paths, use [Starter Sets](starter-sets.md). For the full command list, see [Command Reference](command-reference.md).
 
 If you want the trust surfaces around installation and shipping details, continue with:
 
 - [Runtime Support](runtime-support.md) -- installer targets, support levels, and verification status
+- [Quick Proof](quick-proof.md) -- proof-first first-run path through install, demo, and next draft
+- [Starter Sets](starter-sets.md) -- small command sets by writing goal
 - [Auto-Invoke Policy](auto-invoke-policy.md) -- status engine, visible automation, and agent-spawn boundaries
 - [Route Graph Audit](route-graph.md) -- generated route graph, automation lanes, and priority fixtures
 - [Shipped Assets](shipped-assets.md) -- what the npm package actually includes on the trust-critical surface

package/docs/proof-artifacts.md

@@ -4,10 +4,14 @@ This document is the canonical index of Scriveno's proof layer. It points to con
 
 ## Start Here
 
+- Read **Quick Proof** if you want one 10-minute route through installation checks, demo inspection, runtime command shapes, and the next draft command.
+- Read **First-Run Proof** if you want the committed transcript artifact for `/scr:first-run`, `scriveno first-run --project .`, runtime smoke, and the demo flow.
 - Read the **Watchmaker Sample Flow** if you want one end-to-end writing workflow from setup through drafts, review, and next step.
 - Read **Voice DNA** if you want the shortest possible proof of how style guidance changes output on the same brief.
 - Read **Creative Context** if you want to see one craft choice travel through discuss, plan, draft, and review artifacts.
 
+**Fast path:** [Quick Proof](quick-proof.md)
+
 ## Watchmaker Sample Flow
 
 **What it proves:** Scriveno ships one credible writing workflow from setup context through drafted outcome, review evidence, and next-step continuity.
@@ -29,6 +33,14 @@ This document is the canonical index of Scriveno's proof layer. It points to con
 
 Start with the proof bundle if you want the curated version. Follow the underlying files if you want to inspect the raw sample directly.
 
+## First-Run Proof
+
+**What it proves:** Scriveno has an executable first-run guide and committed transcript artifacts for the first proof path.
+
+**Canonical artifact:** [data/proof/first-run/README.md](../data/proof/first-run/README.md)
+
+**Related parity artifact:** [data/proof/runtime-parity/README.md](../data/proof/runtime-parity/README.md)
+
 ## Voice DNA
 
 **What it proves:** Scriveno's style-guide layer changes draft behavior in visible ways when the same brief is written unguided versus guided.
@@ -52,6 +64,10 @@ Read the bundle in order if you want to inspect sentence rhythm, metaphor select
 ## Related Trust Docs
 
 - [Shipped Assets](shipped-assets.md) -- canonical inventory of the trust-critical files Scriveno actually bundles
+- [Quick Proof](quick-proof.md) -- 10-minute proof-first path through install checks, the demo, and the next draft
+- [Starter Sets](starter-sets.md) -- small command sets by writing goal
+- [data/proof/first-run/README.md](../data/proof/first-run/README.md) -- committed first-run transcript artifact
+- [data/proof/runtime-parity/README.md](../data/proof/runtime-parity/README.md) -- runtime surface evidence and host-parity boundary
 - [Runtime Support](runtime-support.md) -- canonical runtime matrix and installer-baseline framing
 - [Auto-Invoke Policy](auto-invoke-policy.md) -- proactive status, safe apply, local-helper, and agent-spawn boundaries
 - [Route Graph Audit](route-graph.md) -- generated route graph, automation lanes, and priority fixtures

package/docs/quick-proof.md

@@ -0,0 +1,195 @@
+# Quick Proof
+
+This is the shortest proof-first path through Scriveno. It is meant for a fresh user who wants to see real shipped artifacts, a demo manuscript, runtime expectations, and the first practical commands before reading the full manual. If your runtime supports Scriveno commands, the executable version of this page is `/scr:first-run`.
+
+## What This Proves
+
+- Scriveno ships inspectable proof bundles, not only feature claims.
+- Scriveno ships `/scr:first-run` and `scriveno first-run --project .` as guided first-run surfaces.
+- The watchmaker demo includes real manuscript state, drafts, review notes, and a planned next unit.
+- Voice DNA changes output on the same brief, with guided and unguided samples side by side.
+- Runtime behavior is explicit: Claude Code is the primary reference runtime, Codex uses generated `$scr-*` skills, standard slash-command targets use `/scr:*`, and guided targets document their local setup path.
+- The public CLI can audit installed surfaces with `scriveno smoke --json`.
+
+## 10-Minute Route
+
+### 1. Install
+
+```bash
+npx scriveno@latest
+```
+
+For a source checkout while developing Scriveno itself:
+
+```bash
+node bin/install.js --runtimes claude-code,cursor,gemini-cli,codex,opencode,copilot,windsurf,antigravity,manus,perplexity-desktop,generic --global --developer --silent
+```
+
+### 2. Check The Installed Surface
+
+```bash
+scriveno first-run --project .
+scriveno status --project .
+scriveno smoke --json
+scriveno agents --json
+scriveno routes --json
+```
+
+Expected result: the commands report the recommended first path, installed surfaces, agent prompt availability, route lanes, and any manual gates. They do not mutate manuscript files.
+
+### 3. Open The Demo
+
+Claude Code:
+
+```text
+/scr-first-run
+/scr-demo
+```
+
+Standard slash-command runtimes:
+
+```text
+/scr:first-run
+/scr:demo
+```
+
+Codex:
+
+```text
+$scr-first-run
+$scr-demo
+```
+
+Then inspect the shipped files:
+
+- [data/demo/.manuscript/WORK.md](../data/demo/.manuscript/WORK.md)
+- [data/demo/.manuscript/STYLE-GUIDE.md](../data/demo/.manuscript/STYLE-GUIDE.md)
+- [data/demo/.manuscript/STATE.md](../data/demo/.manuscript/STATE.md)
+- [data/demo/.manuscript/drafts/body/1-the-letter-DRAFT.md](../data/demo/.manuscript/drafts/body/1-the-letter-DRAFT.md)
+- [data/demo/.manuscript/drafts/body/2-the-workshop-DRAFT.md](../data/demo/.manuscript/drafts/body/2-the-workshop-DRAFT.md)
+- [data/demo/.manuscript/reviews/2-the-workshop-REVIEW.md](../data/demo/.manuscript/reviews/2-the-workshop-REVIEW.md)
+- [data/demo/.manuscript/plans/5-the-reunion-PLAN.md](../data/demo/.manuscript/plans/5-the-reunion-PLAN.md)
+
+### 4. Read The Proof Bundle
+
+Start here:
+
+- [data/proof/watchmaker-flow/README.md](../data/proof/watchmaker-flow/README.md)
+- [data/proof/voice-dna/README.md](../data/proof/voice-dna/README.md)
+- [data/proof/creative-context/README.md](../data/proof/creative-context/README.md)
+- [data/proof/first-run/README.md](../data/proof/first-run/README.md)
+- [data/proof/runtime-parity/README.md](../data/proof/runtime-parity/README.md)
+
+The fastest comparison is the Voice DNA pair:
+
+- [data/proof/voice-dna/UNGUIDED-SAMPLE.md](../data/proof/voice-dna/UNGUIDED-SAMPLE.md)
+- [data/proof/voice-dna/GUIDED-SAMPLE.md](../data/proof/voice-dna/GUIDED-SAMPLE.md)
+
+### 5. Ask For The Next Unit
+
+The demo includes a planned but undrafted fifth unit. Use the command shape for your host:
+
+Claude Code:
+
+```text
+/scr-draft 5
+/scr-editor-review 5
+```
+
+Standard slash-command runtimes:
+
+```text
+/scr:draft 5
+/scr:editor-review 5
+```
+
+Codex:
+
+```text
+$scr-draft 5
+$scr-editor-review 5
+```
+
+### 6. Ask Scriveno What To Do Next
+
+Claude Code:
+
+```text
+/scr-next
+```
+
+Standard slash-command runtimes:
+
+```text
+/scr:next
+```
+
+Codex:
+
+```text
+$scr-next
+```
+
+Terminal:
+
+```bash
+scriveno status --project .
+```
+
+## Example Transcript
+
+These transcript blocks show the expected shape, not a promise that every host prints identical phrasing.
+
+```text
+> /scr-demo
+Created the watchmaker demo project.
+Next: inspect STYLE-GUIDE.md, read the first draft, then run /scr-next.
+```
+
+```text
+> scriveno status --project .
+Recommended next command: /scr:next
+Candidate agents: drafter, voice-checker
+Candidate local helpers: scan, save
+Manual gates: writer approval before publishing or overwriting exports
+```
+
+```text
+> scriveno first-run --project .
+Scriveno first-run guide
+Current recommendation: /scr:new-work
+Recommended first path:
+1. /scr:demo
+2. cd scriveno-demo
+3. /scr:next
+4. /scr:draft 5
+5. /scr:editor-review 5
+```
+
+```text
+> /scr:draft 5
+Loaded STYLE-GUIDE.md and the plan for unit 5.
+Drafted the next atomic unit in fresh context.
+Next: /scr:editor-review 5
+```
+
+## Runtime Expectations
+
+Use [Runtime Support](runtime-support.md) as the canonical matrix. The short version:
+
+- Claude Code is the primary reference runtime.
+- Codex installs generated `$scr-*` skills, mirrored commands, agent prompts, and `.toml` agent metadata.
+- Cursor, Gemini CLI, OpenCode, GitHub Copilot, Windsurf, and Antigravity install command directories plus agent prompts.
+- Manus Desktop and the generic fallback install bundled skill manifests.
+- Perplexity Desktop is a guided local-MCP setup target, not a writable command runtime.
+
+No runtime claim here should be read as host-runtime parity proof. The repo proves install surfaces and package artifacts; host parity still needs per-host verification.
+
+## Where To Go Next
+
+- [Starter Sets](starter-sets.md) for small command paths by writing goal
+- [data/proof/first-run/README.md](../data/proof/first-run/README.md) for committed first-run transcripts
+- [data/proof/runtime-parity/README.md](../data/proof/runtime-parity/README.md) for runtime parity evidence
+- [Getting Started](getting-started.md) for the complete first-project walkthrough
+- [Proof Artifacts](proof-artifacts.md) for the proof hub
+- [Runtime Support](runtime-support.md) for installation and support levels

package/docs/release-checklist.md

@@ -0,0 +1,117 @@
+# Release Checklist
+
+This checklist is the package-release path for Scriveno maintainers. It is designed to verify the source checkout, the package tarball, the installed runtime surfaces, the published npm package, and the GitHub release.
+
+## 1. Confirm A Clean Baseline
+
+```bash
+git status --short --branch
+npm view scriveno version
+```
+
+Choose the next package version from npm, not from memory.
+
+## 2. Run Local Gates
+
+```bash
+npm run release:check
+npm audit --omit=dev --json
+node bin/install.js routes --json
+node bin/install.js agents --json
+node bin/install.js smoke --json
+node bin/install.js sync --check --json
+git diff --check
+```
+
+Also scan text files for the repo writing policy:
+
+```bash
+node scripts/check-writing-policy.js
+```
+
+If that script does not exist in a checkout yet, run the equivalent local policy scan used by the release operator.
+
+## 3. Clear Previous Local Installs
+
+Before validating a release candidate, clear Scriveno-owned install surfaces so stale files cannot hide installer defects.
+
+```bash
+rm -rf "$HOME/.scriveno"
+rm -rf "$HOME/.codex/commands/scr"
+rm -rf "$HOME/.cursor/commands/scr"
+rm -rf "$HOME/.gemini/commands/scr"
+rm -rf "$HOME/.gemini/antigravity/commands/scr"
+rm -rf "$HOME/.config/opencode/commands/scr"
+rm -rf "$HOME/.github/commands/scr"
+rm -rf "$HOME/.windsurf/commands/scr"
+rm -rf "$HOME/.manus/skills/scriveno"
+npm cache clean --force
+```
+
+Then reinstall from the checkout:
+
+```bash
+npm install -g .
+scriveno --runtimes claude-code,cursor,gemini-cli,codex,opencode,copilot,windsurf,antigravity,manus,perplexity-desktop,generic --global --developer --silent
+scriveno smoke --json
+```
+
+## 4. Pack The Candidate
+
+```bash
+mkdir -p dist
+npm pack --pack-destination dist
+```
+
+Inspect the tarball name and confirm the version matches `package.json`.
+
+## 5. Commit And Tag
+
+```bash
+git status --short
+git add README.md CHANGELOG.md docs package.json package-lock.json data templates commands .planning test
+git commit -m "Release scriveno X.Y.Z"
+git tag vX.Y.Z
+```
+
+Keep the commit message plain and version-specific.
+
+## 6. Publish To npm
+
+```bash
+npm publish --access public
+npm view scriveno version
+```
+
+The published version must match `package.json` and the tag.
+
+## 7. Push Git And Create GitHub Release
+
+```bash
+git push origin main
+git push origin vX.Y.Z
+gh release create vX.Y.Z dist/scriveno-X.Y.Z.tgz --title "Scriveno X.Y.Z" --notes-file /tmp/scriveno-release-notes.md
+```
+
+The release notes should summarize the user-facing change, docs updated, tests run, and npm verification.
+
+## 8. Verify From Published npm
+
+```bash
+npm install -g scriveno@latest
+scriveno --version
+scriveno --runtimes claude-code,cursor,gemini-cli,codex,opencode,copilot,windsurf,antigravity,manus,perplexity-desktop,generic --global --developer --silent
+scriveno smoke --json
+```
+
+This is the final proof that a fresh user can install the same package that was released.
+
+## 9. Final State
+
+```bash
+git status --short --branch
+gh release view vX.Y.Z
+npm view scriveno version
+```
+
+The final state should show a clean worktree, a visible GitHub release, and npm latest aligned to the new version.

package/docs/release-notes.md

@@ -2,6 +2,78 @@
 
 This document is the public-facing summary of what changed between package releases. For package history, see the root [CHANGELOG](../CHANGELOG.md).
 
+## 2.5.0 - 2026-05-16
+
+### What changed
+
+- Scriveno now ships `/scr:first-run`, an executable first-run path through install checks, demo proof, starter choices, and next commands.
+- The public CLI now supports `scriveno first-run --project .`, giving terminal users the same proof path without relying on host-specific slash-command behavior.
+- First-run guidance is connected to `/scr:help`, `/scr:demo`, Quick Proof, Starter Sets, Runtime Support, Shipped Assets, Command Reference, README launch copy, and architecture docs.
+- Scriveno now includes committed first-run and runtime-parity proof bundles under `data/proof/`.
+- Runtime smoke now validates the 113-command installed surface across Claude Code, Codex, Cursor, Gemini CLI, OpenCode, GitHub Copilot, Windsurf, Antigravity, Manus, Perplexity Desktop, and the generic fallback.
+- README badges, package metadata, constraints metadata, generated config metadata, changelog, release notes, configuration docs, route graph docs, architecture docs, proof docs, and release tests are aligned on `2.5.0`.
+
+### Why it matters
+
+The previous release documented a stronger proof path. This release makes that path executable. A new writer can install Scriveno, run one first-run command, inspect proof artifacts, create the demo, and move into drafting without having to assemble the path from documentation.
+
+### Affected areas
+
+- first-run command surface
+- public CLI installer and smoke checks
+- proof artifact bundles
+- README badges and launch copy
+- runtime support matrix
+- command reference and route graph docs
+- package metadata and generated project examples
+- release-alignment tests
+
+### Verification
+
+- `npm run policy:check`
+- `node --test test/first-run-proof-surface.test.js test/adaptive-concierge.test.js test/auto-invoke-engine.test.js test/command-surface-coherence.test.js test/collaboration-trust-surface.test.js test/package.test.js test/phase15-proof-artifacts-positioning.test.js`
+- `npm test`
+- `npm run release:check`
+- `git diff --check`
+- `scriveno first-run --project .`
+- `scriveno smoke --json`
+
+## 2.0.12 - 2026-05-16
+
+### What changed
+
+- Scriveno now ships [Quick Proof](quick-proof.md), a 10-minute route through install checks, the watchmaker demo, Voice DNA samples, runtime command shapes, and the next draft command.
+- Scriveno now ships [Starter Sets](starter-sets.md), goal-based command paths for drafting, polishing, publishing, translation, sacred commentary, and repair.
+- Scriveno now ships [Release Checklist](release-checklist.md), a maintainer path for local gates, stale install cleanup, packing, npm publishing, GitHub release creation, and fresh `scriveno@latest` verification.
+- `npm run release:check` now includes `npm run policy:check`, which scans tracked text files for the repository writing policy before packaging.
+- README badges, Getting Started, Proof Artifacts, Runtime Support, Development, Contributing, Testing, Shipped Assets, Route Graph, Configuration, changelog, package metadata, constraints metadata, generated config metadata, and release tests are aligned on `2.0.12`.
+
+### Why it matters
+
+The product already had proof artifacts, but the shortest path through them was too implicit. This release makes the first 10 minutes clearer for a new writer and makes the release process harder to drift by documenting and testing the local, npm, GitHub, and fresh-install verification path.
+
+### Affected areas
+
+- README badges and launch copy
+- proof-first documentation
+- starter command guidance
+- release checklist and testing docs
+- writing-policy release gate
+- package metadata and generated project examples
+- planning state and release-alignment tests
+
+### Verification
+
+- `node --test test/first-run-proof-surface.test.js test/package.test.js test/phase16-trust-regression.test.js test/phase14-runtime-credibility.test.js`
+- `npm run policy:check`
+- `npm run release:check`
+- `node bin/install.js routes --json`
+- `node bin/install.js agents --json`
+- `node bin/install.js sync --check --json`
+- `node bin/install.js smoke --json`
+- `npm audit --omit=dev --json`
+- `git diff --check`
+
 ## 2.0.11 - 2026-05-16
 
 ### What changed

package/docs/route-graph.md

@@ -13,9 +13,9 @@ The text report summarizes command count, graph edges, agent-capable routes, loc
 
 ## Current Shape
 
-As of `2.0.11`, the route graph contains:
+As of `2.5.0`, the route graph contains:
 
-- 112 commands
+- 113 commands
 - intent-order edges from `command_intents`
 - dependency-chain edges from `dependencies.core_chain`
 - automation lanes from `getCommandAutomationPolicy()`

package/docs/runtime-support.md

@@ -65,6 +65,18 @@ Node is not a runtime dependency for Scriveno's markdown command system itself.
 - Manus Desktop and the generic skills fallback install a manifest `SKILL.md`, mirrored command files, and agent prompts inside the skill bundle.
 - Perplexity Desktop receives setup assets for a local-MCP connector. It does not receive writable command or agent prompt directories from the installer.
 
+## First-Run Command Shapes
+
+Scriveno docs use `/scr:*` as the shared command id format unless a host-specific example is needed. Installed command surfaces differ by runtime:
+
+- Claude Code: `/scr-first-run`, `/scr-demo`, `/scr-new-work`, `/scr-next`
+- Standard command-directory runtimes: `/scr:first-run`, `/scr:demo`, `/scr:new-work`, `/scr:next`
+- Codex: `$scr-first-run`, `$scr-demo`, `$scr-new-work`, `$scr-next`
+- Guided targets: follow the generated setup instructions and connector recipe
+
+Use [Quick Proof](quick-proof.md) for the 10-minute proof route and [Starter Sets](starter-sets.md) for goal-based command paths.
+Use [Runtime Parity Evidence](../data/proof/runtime-parity/README.md) for the committed boundary between install-surface proof and host-runtime parity proof.
+
 ## Shared Auto-Invoke Engine
 
 Every install target receives the same read-only status engine through Scriveno's shared asset directory:
@@ -126,5 +138,7 @@ That distinction is intentional. Installer-path coverage and guided setup assets
 ## See Also
 
 - [Getting Started](getting-started.md) -- install flow and first-run expectations
+- [Quick Proof](quick-proof.md) -- first-run proof path and runtime command shapes
+- [Starter Sets](starter-sets.md) -- small command sets by writing goal
 - [Shipped Assets](shipped-assets.md) -- trust-critical files that ship with the package
 - [Release Notes](release-notes.md) -- latest package-level summary

package/docs/sacred-texts.md

@@ -292,5 +292,5 @@ Here is a quick walkthrough for starting a sacred writing project:
 ## See Also
 
 - [Getting Started](getting-started.md) -- Install Scriveno and create your first project
-- [Command Reference](command-reference.md) -- Full reference for all 112 commands, including the [Sacred Exclusive](command-reference.md#sacred-exclusive) section
+- [Command Reference](command-reference.md) -- Full reference for all 113 commands, including the [Sacred Exclusive](command-reference.md#sacred-exclusive) section
 - [README](../README.md) -- Project overview and feature list

package/docs/shipped-assets.md

@@ -115,11 +115,16 @@ Sacred commands read top-level sacred profile keys in new projects and preserve
 - `CHANGELOG.md` -- package-level release history
 - `docs/release-notes.md` -- public-facing release summary
 - `docs/proof-artifacts.md` -- canonical proof hub for sample-flow and voice-preservation evidence
+- `docs/quick-proof.md` -- proof-first first-run route through install checks, demo inspection, and next-draft commands
+- `docs/starter-sets.md` -- small command paths for common writing goals
+- `docs/release-checklist.md` -- release validation path for source, npm, GitHub, and fresh installs
 - `docs/runtime-support.md` -- canonical runtime matrix, Node baseline, and support-confidence framing
 - `docs/command-reference.md` -- canonical command surface reference
 - `docs/configuration.md` -- canonical project config and package metadata reference
 - `data/proof/watchmaker-flow/README.md` -- canonical sample-flow proof bundle rooted in shipped demo files
 - `data/proof/voice-dna/README.md` -- canonical Voice DNA proof bundle
+- `data/proof/first-run/README.md` -- committed transcript artifact for the executable first-run path
+- `data/proof/runtime-parity/README.md` -- runtime install-surface evidence and host-parity boundary
 - `commands/scr/export.md` -- source of truth for export command behavior
 - `docs/publishing.md` -- user-facing explanation of export formats and publishing packages
 - `docs/contributing.md` -- contributor-facing guidance for extending export support