scriveno 2.0.11 → 2.0.12

package/README.md

@@ -2,13 +2,15 @@
 
 [![CI](https://github.com/aihxp/scriveno/actions/workflows/ci.yml/badge.svg)](https://github.com/aihxp/scriveno/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-2.0.11-blue)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-2.0.12-blue)](CHANGELOG.md)
 [![npm](https://img.shields.io/npm/v/scriveno.svg)](https://www.npmjs.com/package/scriveno)
 [![Downloads](https://img.shields.io/npm/dm/scriveno.svg)](https://www.npmjs.com/package/scriveno)
 [![Status CLI](https://img.shields.io/badge/status%20CLI-scriveno%20status-blue)](docs/runtime-support.md#shared-auto-invoke-engine)
 [![Route Intelligence](https://img.shields.io/badge/route%20intelligence-agent%20lanes-blue)](docs/auto-invoke-policy.md)
 [![Runtime Smoke](https://img.shields.io/badge/runtime%20smoke-install%20checks-blue)](docs/runtime-support.md#runtime-smoke-and-agent-checks)
 [![Safe Apply](https://img.shields.io/badge/safe%20apply-visible%20gates-blue)](docs/auto-invoke-policy.md#safe-apply-and-audit-commands)
+[![Quick Proof](https://img.shields.io/badge/quick%20proof-10%20minute%20path-blue)](docs/quick-proof.md)
+[![Starter Sets](https://img.shields.io/badge/starter%20sets-goal%20paths-blue)](docs/starter-sets.md)
 
 **[scriveno on npm](https://www.npmjs.com/package/scriveno)**
 
@@ -18,7 +20,7 @@
 
 Scriveno brings spec-driven workflows to longform writing. It runs inside your AI coding agent (Claude Code, Cursor, Gemini CLI, and more) and also ships a guided Perplexity Desktop setup path for file-aware support without overstating parity.
 
-Scriveno is best understood as **AI-native longform writing software built around voice preservation**. Its core promise is narrow and high-stakes: drafted prose should sound like the writer, not like AI. If you want evidence before features, start with the [Proof Artifacts](docs/proof-artifacts.md).
+Scriveno is best understood as **AI-native longform writing software built around voice preservation**. Its core promise is narrow and high-stakes: drafted prose should sound like the writer, not like AI. If you want evidence before features, start with the [Quick Proof](docs/quick-proof.md), then inspect the [Proof Artifacts](docs/proof-artifacts.md).
 
 ```bash
 npx scriveno@latest
@@ -72,7 +74,7 @@ $scr-help
 
 If you only ever type `/scr-next` in Claude Code, you can complete an entire novel. It always knows what's next.
 
-If you want the shortest proof-first route, read [Proof Artifacts](docs/proof-artifacts.md) before exploring the rest of the docs.
+If you want the shortest proof-first route, read [Quick Proof](docs/quick-proof.md) before exploring the rest of the docs. If you want a small command path for your goal, use [Starter Sets](docs/starter-sets.md).
 
 ---
 
@@ -190,6 +192,8 @@ Scriveno is built on five principles:
 ## Documentation
 
 - [Proof Artifacts](docs/proof-artifacts.md) -- Canonical proof hub for the watchmaker sample flow and Voice DNA before/after bundle
+- [Quick Proof](docs/quick-proof.md) -- 10-minute proof-first route through install checks, the demo, and the next draft
+- [Starter Sets](docs/starter-sets.md) -- Small command paths for drafting, polishing, publishing, translation, sacred commentary, and repair
 - [Getting Started](docs/getting-started.md) -- Install to first draft in 10 minutes
 - [Command Reference](docs/command-reference.md) -- All 112 commands with usage, flags, and examples
 - [Work Types Guide](docs/work-types.md) -- How 50 work types adapt Scriveno's vocabulary
@@ -205,6 +209,7 @@ Scriveno is built on five principles:
 - [Route Graph Audit](docs/route-graph.md) -- Generated route graph, automation lanes, and priority fixtures
 - [Development](docs/development.md) -- Contributor workflow for changing commands, templates, installer logic, and docs
 - [Testing](docs/testing.md) -- What the test suite covers and which checks to run before shipping
+- [Release Checklist](docs/release-checklist.md) -- Local, npm, GitHub, and fresh-install release verification
 - [Release Notes](docs/release-notes.md) -- Public summary of what changed between package releases
 - [Shipped Assets](docs/shipped-assets.md) -- Canonical inventory of bundled export templates and launch-critical files
 - [Runtime Support](docs/runtime-support.md) -- Canonical runtime matrix, Node baseline, and verification-status framing
@@ -235,11 +240,11 @@ Scriveno currently ships installer targets for these AI tooling environments:
 
 ## Status
 
-**Version:** 2.0.11
+**Version:** 2.0.12
 
-Scriveno's core command surface is stable across 112 commands, 50 work types, and 11 installer targets. The current repo baseline includes shipped planning milestones through `v2.0 Publishing Cover Packaging`, plus the creative-context, record-store, branching-next, runtime-sync, adaptive concierge, human-first writing-safeguard, authenticity-diagnostic, domain-grilling, installer-marker cleanup, cross-runtime agent metadata, visible automation status, the shared `scriveno status --project .` auto-invoke engine, route-intelligence lanes, safe apply reporting, runtime smoke checks, agent availability checks, route graph audits, and the full audit repair pass through `2.0.11`. See [Shipped Assets](docs/shipped-assets.md) for the canonical asset inventory and [Runtime Support](docs/runtime-support.md) for the runtime compatibility matrix.
+Scriveno's core command surface is stable across 112 commands, 50 work types, and 11 installer targets. The current repo baseline includes shipped planning milestones through `v2.0 Publishing Cover Packaging`, plus the creative-context, record-store, branching-next, runtime-sync, adaptive concierge, human-first writing-safeguard, authenticity-diagnostic, domain-grilling, installer-marker cleanup, cross-runtime agent metadata, visible automation status, the shared `scriveno status --project .` auto-invoke engine, route-intelligence lanes, safe apply reporting, runtime smoke checks, agent availability checks, route graph audits, the full audit repair pass through `2.0.11`, and the first-run proof surface in `2.0.12`. See [Quick Proof](docs/quick-proof.md) for the fastest proof path, [Shipped Assets](docs/shipped-assets.md) for the canonical asset inventory, and [Runtime Support](docs/runtime-support.md) for the runtime compatibility matrix.
 
-Version `2.0.11` publishes Scriveno under the package name `scriveno`, so the current install command is `npx scriveno@latest`. The older `scriveno-cli` package name is historical and was unpublished during the rename, so npm cannot attach a deprecation notice to it while it has no active registry record. The older `scriven-cli` package remains on npm only as a deprecated legacy name that points users to `scriveno`. Do not treat either legacy package name as active unless a deliberate compatibility shim is republished. See [CHANGELOG](CHANGELOG.md) for the full list and [docs/release-notes.md](docs/release-notes.md) for the public-facing summary.
+Version `2.0.12` publishes Scriveno under the package name `scriveno`, so the current install command is `npx scriveno@latest`. The older `scriveno-cli` package name is historical and was unpublished during the rename, so npm cannot attach a deprecation notice to it while it has no active registry record. The older `scriven-cli` package remains on npm only as a deprecated legacy name that points users to `scriveno`. Do not treat either legacy package name as active unless a deliberate compatibility shim is republished. See [CHANGELOG](CHANGELOG.md) for the full list and [docs/release-notes.md](docs/release-notes.md) for the public-facing summary.
 
 Package history is tracked in [CHANGELOG.md](CHANGELOG.md), and the public-facing summary for this release is in [docs/release-notes.md](docs/release-notes.md).
 

package/commands/scr/new-work.md

@@ -69,7 +69,7 @@ Always create `RECORD.md` from `templates/RECORD.md` without renaming it. It is
 Write `.manuscript/config.json` by starting from `templates/config.json` and filling the project-specific values. The generated config must include the shared settings blocks that later commands read:
 ```json
 {
-  "scriveno_version": "2.0.11",
+  "scriveno_version": "2.0.12",
   "work_type": "<chosen>",
   "group": "<group>",
   "command_unit": "<unit>",

package/data/CONSTRAINTS.json

@@ -1,6 +1,6 @@
 {
   "$schema": "./constraints.schema.json",
-  "version": "2.0.11",
+  "version": "2.0.12",
   "description": "Scriveno constraint system: work types, command availability, exports, and dependencies. Every command checks this file at runtime.",
   "_notes": {
     "sacred_keys": "Sacred subcommands live at commands/scr/sacred/<name>.md and run as /scr:sacred:<name>. Their CONSTRAINTS keys use the sacred:<name> form so /scr:help can render the runnable slash-command path directly. The sacred-numbering-format entry is a separate flat command (commands/scr/sacred-numbering-format.md) that surfaces the active tradition's numbering format. It used to be named sacred-verse-numbering, which collided with sacred:verse-numbering at install time -- both flattened to scr-sacred-verse-numbering. Renamed in v1.6.x; the installer now refuses to install when two sources share a flat skill name."

package/docs/configuration.md

@@ -57,7 +57,7 @@ When a writer runs `/scr:new-work`, Scriveno creates `.manuscript/config.json`.
 
 ```json
 {
-  "scriveno_version": "2.0.11",
+  "scriveno_version": "2.0.12",
   "work_type": "<chosen>",
   "group": "<group>",
   "command_unit": "<unit>",

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
 
@@ -63,7 +63,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 +204,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,13 @@ 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 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.
@@ -52,6 +55,8 @@ 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
 - [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,174 @@
+# 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.
+
+## What This Proves
+
+- Scriveno ships inspectable proof bundles, not only feature claims.
+- 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 status --project .
+scriveno smoke --json
+scriveno agents --json
+scriveno routes --json
+```
+
+Expected result: the commands report 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-demo
+```
+
+Standard slash-command runtimes:
+
+```text
+/scr:demo
+```
+
+Codex:
+
+```text
+$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)
+
+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
+> /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
+- [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,42 @@
 
 This document is the public-facing summary of what changed between package releases. For package history, see the root [CHANGELOG](../CHANGELOG.md).
 
+## 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,7 +13,7 @@ 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.0.12`, the route graph contains:
 
 - 112 commands
 - intent-order edges from `command_intents`

package/docs/runtime-support.md

@@ -65,6 +65,17 @@ 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-demo`, `/scr-new-work`, `/scr-next`
+- Standard command-directory runtimes: `/scr:demo`, `/scr:new-work`, `/scr:next`
+- Codex: `$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.
+
 ## Shared Auto-Invoke Engine
 
 Every install target receives the same read-only status engine through Scriveno's shared asset directory:
@@ -126,5 +137,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/shipped-assets.md

@@ -115,6 +115,9 @@ 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

package/docs/starter-sets.md

@@ -0,0 +1,74 @@
+# Starter Sets
+
+Scriveno has a large command surface because it covers many kinds of writing. Starter sets give each writer a short path instead of asking them to learn every command up front.
+
+Each set is intentionally small. Use `/scr-next`, `/scr:next`, or `$scr-next` whenever you are unsure which command should come next.
+
+## Draft A Book
+
+- `/scr:new-work` creates the project and work-type context.
+- `/scr:profile-writer` turns the style guide into a real Voice DNA profile.
+- `/scr:discuss` shapes the next unit with a few targeted questions.
+- `/scr:plan` writes the next unit plan.
+- `/scr:draft` drafts the planned unit in fresh context.
+- `/scr:editor-review` reviews the draft for revision.
+- `/scr:next` chooses the safest next move from project state.
+
+## Polish A Manuscript
+
+- `/scr:import` brings existing material into a Scriveno project.
+- `/scr:profile-writer` calibrates the voice profile against your actual prose.
+- `/scr:continuity-check` finds contradictions and timeline drift.
+- `/scr:voice-check` compares drafts against Voice DNA.
+- `/scr:line-edit` improves sentence-level flow.
+- `/scr:copy-edit` catches grammar, clarity, and consistency issues.
+- `/scr:polish` chains the revision passes when the manuscript is ready.
+
+## Publish An Ebook
+
+- `/scr:publish` starts the publication workflow.
+- `/scr:front-matter` prepares title-page, copyright, and dedication pages.
+- `/scr:back-matter` prepares author notes, acknowledgments, and reader materials.
+- `/scr:blurb` drafts store-facing description copy.
+- `/scr:cover-art` prepares cover direction or cover assets.
+- `/scr:build-ebook` builds the ebook package.
+- `/scr:export` writes the selected export format.
+
+## Translate A Work
+
+- `/scr:translation-glossary` defines recurring terms, names, and voice rules.
+- `/scr:translation-memory` records approved translation decisions.
+- `/scr:translate` translates the selected unit or manuscript segment.
+- `/scr:cultural-adaptation` flags idioms and culture-specific phrasing.
+- `/scr:back-translate` checks whether meaning survived translation.
+- `/scr:multi-publish` prepares parallel translated editions.
+
+## Build Sacred Commentary
+
+- `/scr:new-work` creates a commentary, devotional, homiletic, or scripture project.
+- `/scr:sacred:source-tracking` records primary and secondary source anchors.
+- `/scr:sacred:concordance` builds searchable term and passage links.
+- `/scr:sacred:cross-reference` maps related passages and interpretive connections.
+- `/scr:sacred:doctrinal-check` verifies internal consistency and tradition constraints.
+- `/scr:draft` writes the next commentary or sacred text unit.
+- `/scr:editor-review` reviews the unit without flattening the tradition-native vocabulary.
+
+## Repair And Resume
+
+- `/scr:health` diagnoses missing files, stale state, and broken project assumptions.
+- `/scr:sync` checks installed command, agent, and helper surfaces.
+- `/scr:scan` refreshes project inventory.
+- `/scr:check-notes` surfaces open notes and unresolved reminders.
+- `/scr:resume-work` restores the paused thread or project state.
+- `/scr:next` chooses the next safe command.
+
+## Command Shape By Runtime
+
+The starter sets use `/scr:*` because that is the shared command id format in Scriveno docs. Host surfaces differ:
+
+- Claude Code uses flat commands such as `/scr-draft`.
+- Standard command-directory runtimes currently keep `/scr:draft`.
+- Codex uses generated skills such as `$scr-draft`.
+- Guided targets such as Perplexity Desktop follow their generated setup instructions.
+
+See [Runtime Support](runtime-support.md) for the canonical runtime matrix.

package/docs/testing.md

@@ -10,7 +10,8 @@ The root `package.json` defines:
 "scripts": {
   "test": "node --test test/*.test.js",
   "pack:check": "npm pack --dry-run",
-  "release:check": "npm test && npm run pack:check",
+  "policy:check": "node scripts/check-writing-policy.js",
+  "release:check": "npm test && npm run policy:check && npm run pack:check",
   "prepublishOnly": "npm run release:check"
 }
 ```
@@ -19,7 +20,8 @@ That means:
 
 - `npm test` runs the whole test suite
 - `npm run pack:check` verifies the package contents that would ship
-- `npm run release:check` runs both test and package checks
+- `npm run policy:check` scans tracked text files for the repo writing policy
+- `npm run release:check` runs tests, policy checks, and package checks
 - publishing is guarded by `release:check` through `prepublishOnly`
 
 ## Run the suite
@@ -95,8 +97,10 @@ Use these when changing README, docs, shipped-assets claims, or milestone trust
 
 - `test/phase13-launch-surface-integrity.test.js`
 - `test/phase15-proof-artifacts-positioning.test.js`
+- `test/first-run-proof-surface.test.js`
 - `test/phase19-verification-trust-surface-updates.test.js`
 - `test/repository-policy.test.js`
+- `npm run policy:check`
 
 ### Feature-family regression tests
 
@@ -136,6 +140,12 @@ For the standard release gate, prefer:
 npm run release:check
 ```
 
+For docs, prompt, command markdown, and release-note changes, run:
+
+```bash
+npm run policy:check
+```
+
 When changing proactive routing, runtime install paths, or agent surfaces, also run:
 
 ```bash
@@ -148,6 +158,8 @@ scriveno routes --json
 
 Use those for release prep so you can inspect what would ship without mutating the registry.
 
+For the full publish path, including clearing local installs, packing, publishing, pushing, creating the GitHub release, and verifying `scriveno@latest`, use [Release Checklist](release-checklist.md).
+
 ## Practical workflow
 
 For most changes:
@@ -156,11 +168,14 @@ For most changes:
 2. make the fix
 3. rerun the targeted files
 4. run `npm test`
-5. if packaging or release docs changed, run `npm run release:check`
+5. if docs, prompts, commands, or release notes changed, run `npm run policy:check`
+6. if packaging or release docs changed, run `npm run release:check`
 
 ## Related docs
 
 - [Development](development.md)
 - [Configuration](configuration.md)
 - [Contributing](contributing.md)
+- [Quick Proof](quick-proof.md)
+- [Release Checklist](release-checklist.md)
 - [Release Notes](release-notes.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scriveno",
-  "version": "2.0.11",
+  "version": "2.0.12",
   "description": "Spec-driven creative writing, publishing, and translation pipeline for AI coding agents. From blank page to published book.",
   "bin": {
     "scriveno": "bin/install.js"
@@ -9,7 +9,8 @@
     "start": "node bin/install.js",
     "test": "node --test test/*.test.js",
     "pack:check": "npm pack --dry-run",
-    "release:check": "npm test && npm run pack:check",
+    "policy:check": "node scripts/check-writing-policy.js",
+    "release:check": "npm test && npm run policy:check && npm run pack:check",
     "prepublishOnly": "npm run release:check"
   },
   "publishConfig": {
@@ -47,6 +48,7 @@
     "commands/",
     "agents/",
     "templates/",
+    "scripts/",
     "docs/",
     "README.md",
     "LICENSE"

package/scripts/check-writing-policy.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execSync } = require('node:child_process');
+
+const ROOT = path.join(__dirname, '..');
+const BINARY_EXTENSIONS = new Set([
+  '.docx',
+  '.gif',
+  '.ico',
+  '.jpeg',
+  '.jpg',
+  '.pdf',
+  '.png',
+  '.tgz',
+  '.zip',
+]);
+
+function trackedFiles() {
+  const output = execSync('git ls-files', { cwd: ROOT, encoding: 'utf8' }).trim();
+  return output ? output.split(/\n/) : [];
+}
+
+function isBinaryPath(relativePath) {
+  return BINARY_EXTENSIONS.has(path.extname(relativePath).toLowerCase());
+}
+
+function lineNumberFor(source, index) {
+  return source.slice(0, index).split('\n').length;
+}
+
+function shouldFlag(codePoint, char) {
+  return codePoint === 0x2013
+    || codePoint === 0x2014
+    || /\p{Extended_Pictographic}/u.test(char);
+}
+
+function scan() {
+  const findings = [];
+
+  for (const relativePath of trackedFiles()) {
+    if (isBinaryPath(relativePath)) {
+      continue;
+    }
+
+    const absolutePath = path.join(ROOT, relativePath);
+    const buffer = fs.readFileSync(absolutePath);
+    if (buffer.includes(0)) {
+      continue;
+    }
+
+    const source = buffer.toString('utf8');
+    for (let index = 0; index < source.length; index += 1) {
+      const codePoint = source.codePointAt(index);
+      const char = String.fromCodePoint(codePoint);
+      if (shouldFlag(codePoint, char)) {
+        findings.push({
+          codePoint,
+          line: lineNumberFor(source, index),
+          relativePath,
+        });
+      }
+
+      if (codePoint > 0xffff) {
+        index += 1;
+      }
+    }
+  }
+
+  return findings;
+}
+
+const findings = scan();
+
+for (const finding of findings) {
+  const hex = finding.codePoint.toString(16).toUpperCase().padStart(4, '0');
+  console.error(`${finding.relativePath}:${finding.line}: forbidden U+${hex}`);
+}
+
+if (findings.length > 0) {
+  console.error(`Writing policy scan failed: ${findings.length} forbidden marker(s).`);
+  process.exit(1);
+}
+
+console.log('Writing policy scan passed.');

package/templates/config.json

@@ -1,5 +1,5 @@
 {
-  "scriveno_version": "2.0.11",
+  "scriveno_version": "2.0.12",
   "work_type": "",
   "group": "",
   "command_unit": "",