scriveno 2.6.0 → 2.7.1

package/README.md

@@ -2,7 +2,7 @@
 
 [![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.6.0-blue)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-2.7.1-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)
@@ -40,7 +40,7 @@ Scriveno is a command system that turns your AI coding agent into a voice-preser
 The wedge comes first: Scriveno profiles the writer, loads that voice into every drafting step, and keeps each unit on fresh context so the prose stays specific to the project. From there, it expands into 113 writing commands covering the rest of the pipeline:
 
 - **Create** -- Set up a project with tailored context files. Progressive onboarding, never overwhelming.
-- **Write** -- Discuss, plan, draft, and revise one unit at a time. The drafter agent loads your Voice DNA and writes in *your* voice, not generic AI prose.
+- **Write** -- Discuss, plan, draft, and revise one unit at a time. The drafter agent loads your Voice DNA and writes in *your* voice, not generic AI prose. Run `/scr:progress` any time to open a per-unit ledger (`.manuscript/PROGRESS.md`) showing what is done, in progress, and untouched.
 - **Polish** -- Editor review, line edit, copy edit, continuity check, voice check, beta reader simulation, sensitivity review.
 - **Publish** -- Front/back matter, cover art, blurbs, query letters, KDP packages, IngramSpark packages, EPUB, PDF, Fountain, Final Draft, LaTeX.
 - **Translate** -- Deep translation with glossary management, cultural adaptation, back-translation verification, multi-language simultaneous publishing.
@@ -246,11 +246,11 @@ Scriveno currently ships installer targets for these AI tooling environments:
 
 ## Status
 
-**Version:** 2.6.0
+**Version:** 2.7.1
 
 Scriveno's core command surface is stable across 113 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`, the first-run proof surface in `2.5.0`, and the executable `/scr:first-run` path. 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.6.0` 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.7.1` 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/autopilot.md

@@ -38,7 +38,7 @@ FOR each unit in OUTLINE.md (starting from current position):
     If writer says "skip": advance to next unit, update STATE.md
 ```
 
-When the loop completes (all units through all stages), show a completion summary: total units, total word count, voice consistency across the manuscript, open record threads or promises, and any flags or issues encountered.
+When the loop completes (all units through all stages), show a completion summary: total units, total word count, voice consistency across the manuscript, open record threads or promises, any flags or issues encountered, and a pointer to the per-unit ledger at `.manuscript/PROGRESS.md`.
 
 ## Profile rules
 
@@ -141,6 +141,7 @@ After each stage execution:
 2. Update progress counters: `units_discussed`, `units_planned`, `units_drafted`, `units_reviewed`, `units_submitted`
 3. Update `current_unit` and next step
 4. Update `total_words` running count
+5. Refresh `.manuscript/PROGRESS.md` so the openable ledger advances unit by unit during the run, per `docs/progress-protocol.md`
 
 On pause or stop:
 1. Write current position to "Session handoff" section so `--resume` can pick up exactly where you left off
@@ -168,6 +169,7 @@ Spawned agents:
 - continuity-checker: {count}
 Local operations:
 - STATE.md updated: yes/no
+- PROGRESS.md refreshed: yes/no
 - HISTORY.log updated: yes/no
 Pause:
 - status: none/guided/supervised/quality-gate/blocker
@@ -201,11 +203,13 @@ If the command stops because a prerequisite is missing, suggest the command that
 
 ## Tone
 
-**Progress updates:** Concise, one line per unit.
-- "Drafted chapter 3: 1,247 words. Voice check: passed."
+**Progress updates:** Concise, one line per unit, anchored to the whole manuscript so progress is visible during the run.
+- "Drafted chapter 3 (3 of 12, 25%): 1,247 words. Voice check: passed."
 - "Planned scenes 1-4 for chapter 5."
 - "Editor review complete for chapter 2: 3 notes."
 
+Every few units, show a one-line manuscript bar pulled from the deliverable progress in `docs/progress-protocol.md`, for example: `████░░░░░░ 5/12 chapters done (42%)`. The full per-unit ledger is `.manuscript/PROGRESS.md`.
+
 **At pause points:** Warm, non-technical.
 - "Chapter 3 is ready for your review."
 - "The first act is complete -- 4 chapters, 12,340 words."

package/commands/scr/draft.md

@@ -49,9 +49,9 @@ Require `.manuscript/plans/{N}-*-PLAN.md` files to exist. If none exist, also ch
 
 6. **Surface state nudges.** If the drafter emits `CHARACTER STATE NUDGE`, suggest `/scr:character-touch <name>` after drafting. If the drafter emits `SUBJECT DYNAMICS NUDGE`, suggest `/scr:subject-touch <subject>` after drafting. These nudges go to the writer, not into the draft file.
 
-7. **Update STATE.md:** mark unit as drafted, note word count, flag any voice-check issues.
+7. **Update STATE.md:** mark unit as drafted, note word count, flag any voice-check issues. Then refresh `.manuscript/PROGRESS.md` so the ledger advances (this unit moves to in progress or done) per `docs/progress-protocol.md`.
 
-8. **Tell the writer:** "Drafted {unit} {N}: X words across Y {atomic_units}. Voice consistency: Z% (the voice-checker Overall score for this unit; omit this figure if the voice-check could not run). Updated RECORD.md with what the draft established. Ready for editor review? Run `/scr:editor-review N` or `/scr:next`."
+8. **Tell the writer:** "Drafted {unit} {N} ({N} of {total}, {pct}% of the manuscript): X words across Y {atomic_units}. Voice consistency: Z% (the voice-checker Overall score for this unit; omit this figure if the voice-check could not run). Updated RECORD.md with what the draft established. Ready for editor review? Run `/scr:editor-review N` or `/scr:next`." The full per-unit ledger is in `.manuscript/PROGRESS.md`.
 
 ## Agent and Automation Status
 
@@ -67,6 +67,7 @@ Local operations:
 - draft files written: {count}
 - RECORD.md updated: yes/no
 - STATE.md updated: yes/no
+- PROGRESS.md refreshed: yes/no
 Auto-invoked:
 - /scr:editor-review N: yes/no
 Why: {autopilot.enabled true, full-auto profile, supervised pause, or writer-facing manual mode}
@@ -113,6 +114,6 @@ If the command stops because a prerequisite is missing, suggest the command that
 
 ## Tone
 
-Don't narrate each atomic unit being drafted. That's noise. Show progress concisely: "Drafted scene 1/4... 2/4... 3/4... 4/4. Voice check: passed."
+Don't narrate each atomic unit being drafted. That's noise. Show progress concisely, and anchor it to the whole manuscript so the writer sees momentum: "Drafted scene 1/4... 2/4... 3/4... 4/4. Voice check: passed. Chapter 5 of 12 done (42%)." Pull the unit-of-total figure and percent from the deliverable progress defined in `docs/progress-protocol.md`.
 
 Let the writer read the actual prose in the draft files. Your job is orchestration, not performance.

package/commands/scr/editor-review.md

@@ -168,6 +168,7 @@ Write the standard review report to `.manuscript/reviews/{N}-REVIEW.md`. If an o
 
 If all beats passed:
 - Mark act as "reviewed" in STATE.md
+- Refresh `.manuscript/PROGRESS.md` so the ledger reflects the new review status, per `docs/progress-protocol.md`
 - Apply confirmed compact updates to RECORD.md when the review established or corrected the work's durable content state
 - Suggest moving to `/scr:submit N` or `/scr:discuss {N+1}`
 

package/commands/scr/manuscript-stats.md

@@ -94,17 +94,17 @@ If the user passes `--detail`, append a per-unit breakdown table after the summa
 ```
 Unit Breakdown
 --------------
-Ch 1: The Beginning        3,200 words   ~13 pages
-Ch 2: The Middle           4,100 words   ~16 pages
-Ch 3: The Climax           2,800 words   ~11 pages
-  (not yet drafted)
-Ch 4: The Resolution         --- words    --- pages
+Ch 1: The Beginning    [x] done          3,200 words   ~13 pages
+Ch 2: The Middle       [x] done          4,100 words   ~16 pages
+Ch 3: The Climax       [~] in progress   2,800 words   ~11 pages
+Ch 4: The Resolution   [ ] untouched      --- words    --- pages
 --------------
-Total                     10,100 words   ~40 pages
+Total                                   10,100 words   ~40 pages
 ```
 
 - Use the hierarchy's mid-level label (e.g., "Ch" for chapter, "Sc" for scene, "Sec" for section) from CONSTRAINTS.json.
-- For units not yet drafted, show `(not yet drafted)` with dashes for counts.
+- Show each unit's status (`[x]` done, `[~]` in progress, `[ ]` untouched) derived from disk per `docs/progress-protocol.md`. The full per-unit ledger lives in `.manuscript/PROGRESS.md`.
+- For units not yet drafted, show dashes for counts.
 - Right-align word counts and page counts for visual clarity.
 - Include a total row at the bottom.
 

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.6.0",
+  "scriveno_version": "2.7.1",
   "work_type": "<chosen>",
   "group": "<group>",
   "command_unit": "<unit>",

package/commands/scr/next.md

@@ -62,6 +62,7 @@ Proactive checks:
   Translation: <none | follow-up available>
   Export: <fresh | stale, suggest /scr:export>
   Save: <clean | unsaved manuscript changes, suggest /scr:save>
+  Progress: <X/Y units done -- see .manuscript/PROGRESS.md or /scr:progress>
 ```
 
 ## Routing logic

package/commands/scr/outline.md

@@ -22,7 +22,7 @@ You are an outline manager. Load:
 - `.manuscript/config.json` (to get `work_type`)
 - Scriveno's installed/shared `CONSTRAINTS.json` (global `~/.scriveno/data/CONSTRAINTS.json` or project `.scriveno/data/CONSTRAINTS.json`) (to check `work_types[type].hierarchy` for unit labels, and `file_adaptations`)
 - `.manuscript/OUTLINE.md` (the outline data -- read it fully)
-- `.manuscript/STATE.md` (to get drafted/planned/pending status per unit)
+- `.manuscript/STATE.md` (aggregate counters) plus each unit's files on disk (plans, drafts, reviews) to derive per-unit status -- see `docs/progress-protocol.md`. The persisted per-unit ledger is `.manuscript/PROGRESS.md` when present.
 
 **Work-type adaptation:** Read the hierarchy from CONSTRAINTS.json for the current work type to determine the correct unit terminology:
 - Novel: part > chapter > scene
@@ -56,7 +56,7 @@ Present the hierarchical outline with:
 2. **For each unit, show:**
    - Unit number and title
    - 1-line summary (from OUTLINE.md)
-   - Status: drafted | planned | pending (from STATE.md)
+   - Status: drafted | planned | pending (derived from disk per `docs/progress-protocol.md`, not from STATE.md aggregates)
    - Word count (if drafted, from STATE.md or draft file)
    - Arc position (if mapped in PLOT-GRAPH.md)
 

package/commands/scr/pause-work.md

@@ -33,7 +33,7 @@ You are helping the writer pause their session gracefully. Your job is to captur
    - Outcome: `Paused session`
    Keep this pause marker in the Last actions table because `/scr:session-report` and future resume logic use it as a session boundary.
 
-6. **Regenerate `.manuscript/CONTEXT.md`** using the `templates/CONTEXT.md` scaffold and the field set described in `/scr:save` step 7, with `{{LAST_COMMAND}}` set to `/scr:pause-work`. This is the file the next session reads first; refreshing it on pause means the writer (or a fresh AI session) returns to a current view without having to call `/scr:resume-work` to bootstrap.
+6. **Regenerate `.manuscript/CONTEXT.md`** using the `templates/CONTEXT.md` scaffold and the field set described in `/scr:save` step 7, with `{{LAST_COMMAND}}` set to `/scr:pause-work`. This is the file the next session reads first; refreshing it on pause means the writer (or a fresh AI session) returns to a current view without having to call `/scr:resume-work` to bootstrap. Also regenerate `.manuscript/PROGRESS.md` (the per-unit progress ledger) per `/scr:save` step 8 and `docs/progress-protocol.md`, so the saved ledger matches where the writer is pausing.
 
 7. **Append one line to `.manuscript/HISTORY.log`** per `docs/history-protocol.md`:
    ```

package/commands/scr/progress.md

@@ -1,5 +1,5 @@
 ---
-description: Show current project state and next step. How far along, what is drafted, what is pending.
+description: Show project progress -- a unit progress bar, what is done / in progress / untouched, pipeline position, and a pointer to the per-unit ledger.
 argument-hint: ""
 ---
 
@@ -18,7 +18,7 @@ node "$HOME/.scriveno/lib/auto-invoke-engine.js" --project "$PWD" --trigger /scr
 node .scriveno/lib/auto-invoke-engine.js --project "$PWD" --trigger /scr:progress
 ```
 
-This engine is installed into Scriveno shared assets for every runtime, including Claude Code, Codex, Cursor, Gemini CLI, OpenCode, GitHub Copilot, Windsurf, Antigravity, Manus, Perplexity Desktop, and the generic skill fallback. If the engine is not present, perform the read-only progress logic below.
+This engine is installed into Scriveno shared assets for every runtime, including Claude Code, Codex, Cursor, Gemini CLI, OpenCode, GitHub Copilot, Windsurf, Antigravity, Manus, Perplexity Desktop, and the generic skill fallback. The engine exposes `computeProgressLedger(manuscriptDir)` (see `lib/auto-invoke-engine.js` and `docs/progress-protocol.md`), which returns the deliverable bar, percent, and the done / in progress / untouched bucket counts deterministically from disk; a runtime that loads the module should prefer it over re-deriving counts by hand. If the engine is not present, perform the read-only progress logic below.
 
 ## Prerequisites
 
@@ -26,15 +26,19 @@ This engine is installed into Scriveno shared assets for every runtime, includin
 
 ## What to do
 
-1. Load `.manuscript/STATE.md`, `.manuscript/OUTLINE.md`, `.manuscript/RECORD.md` when present, and `.manuscript/config.json`
-2. Count total units, drafted units, submitted units, and pending units
-3. Calculate word count from existing draft files
-4. Determine the next step (what unit to discuss, plan, or draft next)
-5. Display a progress summary:
-   - "{drafted}/{total} units drafted. {submitted}/{total} submitted."
+1. Load `.manuscript/STATE.md`, `.manuscript/OUTLINE.md`, `.manuscript/config.json`, and `.manuscript/RECORD.md` when present. Read `.manuscript/PROGRESS.md` if it exists -- it is the saved ledger snapshot.
+2. Derive per-unit status from disk per `docs/progress-protocol.md`: for each outline unit, resolve its stage (untouched / discussed / planned / drafted / reviewed / submitted) and its headline bucket (done / in progress / untouched). Count units in each bucket plus the total, and calculate word count from existing draft files.
+3. Determine the pipeline position: the first incomplete stage on the writing lifecycle `seed > voice > outline > discuss > plan > draft > review > revise > publish > translate`, expressed as `Stage {index} of {total}: {Name}`.
+4. Determine the next step (what unit to discuss, plan, or draft next), using the work type's unit label from CONSTRAINTS.json (chapter, act, surah, section, and so on).
+5. Display the progress report, leading with the deliverable view:
+   - A progress bar over units, for example `████████░░ 4/5 scenes done (80%)` (block characters `U+2588` filled and `U+2591` empty; use the work type's plural unit label).
+   - "Done: {done}   In progress: {in_progress}   Untouched: {untouched}."
    - "{word_count} words so far."
+   - "Pipeline: Stage {index} of {total} ({stage_name})."
    - "{open_threads} open record threads." (only when RECORD.md exists)
    - "Next: {next_action}"
+   - "Full per-unit ledger: `.manuscript/PROGRESS.md`" -- the file the writer can open any time to see every unit's status. If it is missing or older than the newest draft, add: "(run `/scr:save` to refresh the saved ledger)".
+   When the project is small (20 units or fewer) or the writer asks, render the per-unit ledger table inline per `docs/progress-protocol.md` instead of only pointing at the file.
 6. Run the Level 1 proactive sweep:
    - If STATE.md counts disagree with draft files, suggest `/scr:scan`.
    - If reports show unresolved review items, suggest the matching review command.
@@ -55,14 +59,15 @@ Candidate agents:
 - <recommended agent route or none>
 Local operations:
 - progress counts computed: yes/no
+- per-unit ledger rendered: yes/no
 - proactive sweep: read-only
 Candidate local helpers:
-- <recommended helper or none>
+- /scr:save to refresh the saved .manuscript/PROGRESS.md when it is stale
 Manual gates:
 - <writer-owned route or none>
 Auto-invoked:
 - none
-Why: progress is read-only; it recommends next commands without mutating files
+Why: progress is read-only; it renders the ledger live and points at .manuscript/PROGRESS.md without writing it
 ```
 
 ## Response Contract

package/commands/scr/resume-work.md

@@ -46,7 +46,7 @@ You are welcoming the writer back and orienting them. Your job is to read the se
    Example:
    > Last time you drafted chapter 3 (1,247 words across 4 scenes, voice check passed). You were working on chapter 4 -- you noted you wanted it shorter and more tense, with Marcus discovering the letter. I'd suggest starting with /scr:discuss 4 to shape the plan.
 
-6. **Regenerate `.manuscript/CONTEXT.md`** using the `templates/CONTEXT.md` scaffold and the same field set described in `/scr:save` step 7, with `{{LAST_COMMAND}}` set to `/scr:resume-work`. This refreshes the bootstrap file so the next session opens to a current view -- the act of resuming is itself a state event worth recording.
+6. **Regenerate `.manuscript/CONTEXT.md`** using the `templates/CONTEXT.md` scaffold and the same field set described in `/scr:save` step 7, with `{{LAST_COMMAND}}` set to `/scr:resume-work`. This refreshes the bootstrap file so the next session opens to a current view -- the act of resuming is itself a state event worth recording. Also regenerate `.manuscript/PROGRESS.md` (the per-unit progress ledger) per `/scr:save` step 8 and `docs/progress-protocol.md`.
 
 7. **Append one line to `.manuscript/HISTORY.log`** per `docs/history-protocol.md`:
    ```

package/commands/scr/save.md

@@ -56,20 +56,22 @@ Follow the auto-invoke policy. In the source repository it is documented at `doc
    - `{{LAST_SCAN}}`, `{{LAST_SCAN_VERDICT}}` -- from STATE.md if recorded; otherwise `never run` and `unknown`
    Save to `.manuscript/CONTEXT.md`. This file is committed alongside STATE.md.
 
-8. **Append one line to `.manuscript/HISTORY.log`** per `docs/history-protocol.md`:
+8. **Regenerate `.manuscript/PROGRESS.md`** before staging. This is the openable per-unit progress ledger. Use the `templates/PROGRESS.md` scaffold and derive per-unit status from disk per `docs/progress-protocol.md` (plan, draft, and review files reconciled with STATE.md). Fill the unit ledger, the deliverable progress bar, the pipeline position, and the bucket counts (done / in progress / untouched). Save to `.manuscript/PROGRESS.md`; it is committed alongside STATE.md and CONTEXT.md.
+
+9. **Append one line to `.manuscript/HISTORY.log`** per `docs/history-protocol.md`:
    ```
    {ISO timestamp} | scr:save | message="{generated message}" | files={changed file count} | outcome=committed
    ```
    If HISTORY.log does not exist, create it. Do not stage it as a separate operation -- step 9 picks it up.
 
-9. **Execute the save:**
+10. **Execute the save:**
    ```
    git add .manuscript/
    git commit -m "{generated message}"
    ```
-   This commit must include the `STATE.md`, `CONTEXT.md`, and `HISTORY.log` updates from steps 6 through 8 so the worktree is clean immediately after a successful save.
+   This commit must include the `STATE.md`, `CONTEXT.md`, `PROGRESS.md`, and `HISTORY.log` updates from steps 6 through 9 so the worktree is clean immediately after a successful save.
 
-10. **Tell the writer** the result (see output section below).
+11. **Tell the writer** the result (see output section below).
 
 ## Automation Status
 
@@ -85,6 +87,7 @@ Candidate agents:
 Local operations:
 - STATE.md updated: yes/no
 - CONTEXT.md regenerated: yes/no
+- PROGRESS.md regenerated: yes/no
 - HISTORY.log appended: yes/no
 - manuscript files saved: yes/no
 Candidate local helpers:

package/commands/scr/scan.md

@@ -5,7 +5,7 @@ argument-hint: "[--fix] [--quiet]"
 
 # /scr:scan -- Context Drift Scanner
 
-You are the project's drift detector. Trust nothing. Compare what `.manuscript/STATE.md`, `OUTLINE.md`, `RECORD.md`, `config.json`, and the various structural files **claim** against what the filesystem actually contains, and report every mismatch.
+You are the project's drift detector. Trust nothing. Compare what `.manuscript/STATE.md`, `OUTLINE.md`, `RECORD.md`, `PROGRESS.md`, `config.json`, and the various structural files **claim** against what the filesystem actually contains, and report every mismatch.
 
 Follow the auto-invoke policy. In the source repository it is documented at `docs/auto-invoke-policy.md`. `/scr:scan` does not spawn agents. It may run deterministic local checks and, under `--fix` after confirmation, deterministic local repairs.
 
@@ -23,7 +23,7 @@ This complements `/scr:health` (which fixes structural issues like missing direc
 
 ## Instruction
 
-Load `.manuscript/config.json`, `.manuscript/STATE.md`, `.manuscript/OUTLINE.md`, and `.manuscript/RECORD.md` when present. Each check below produces a finding with one of three severities:
+Load `.manuscript/config.json`, `.manuscript/STATE.md`, `.manuscript/OUTLINE.md`, `.manuscript/RECORD.md`, and `.manuscript/PROGRESS.md` when present. Each check below produces a finding with one of three severities:
 
 - **DRIFT** -- recorded state contradicts disk reality. Trust nothing downstream until resolved.
 - **WARNING** -- an artifact is stale or out of date. Downstream work may be silently using outdated input.
@@ -206,6 +206,20 @@ Do not over-claim. RECORD.md is an interpretive store, so uncertain findings sho
 
 ---
 
+### CHECK 12: PROGRESS.md ledger staleness
+
+If `.manuscript/PROGRESS.md` exists, compare its mtime against STATE.md and the newest draft. If PROGRESS.md is older than either, the saved per-unit ledger no longer reflects the work on disk. Emit:
+
+```
+WARNING .manuscript/PROGRESS.md is older than the recorded state.
+        The saved per-unit ledger may show stale unit status.
+        Fix: /scr:save to rebuild it (or /scr:scan --fix).
+```
+
+Recompute per-unit status from disk per `docs/progress-protocol.md`. If the bucket counts (done / in progress / untouched) disagree with what PROGRESS.md records, emit a DRIFT finding citing both. If PROGRESS.md does not exist, emit INFO with a one-line suggestion to run `/scr:save` once to generate the openable ledger.
+
+---
+
 ### REPORT
 
 Output a single structured report:
@@ -248,7 +262,7 @@ If `--quiet` was passed and there are zero findings, exit silently with no outpu
 
 When `--fix` is passed, after the report, group findings by auto-fixability:
 
-- **Auto-fixable now** -- finding has a deterministic fix Scriveno can apply (e.g. update STATE.md unit counts to match disk, initialize missing RECORD.md from the installed template, regenerate stale CONTEXT.md, sort orphan drafts into a `_unsorted/` review directory). For each, ask the writer once:
+- **Auto-fixable now** -- finding has a deterministic fix Scriveno can apply (e.g. update STATE.md unit counts to match disk, initialize missing RECORD.md from the installed template, regenerate stale CONTEXT.md, regenerate stale or missing PROGRESS.md from disk per `docs/progress-protocol.md`, sort orphan drafts into a `_unsorted/` review directory). For each, ask the writer once:
   > Apply [N] auto-fixes? (yes / no / show me what each does)
 - **Requires writer decision** -- finding needs a judgment call (e.g. character orphans, scaffold pending, voice drift). List with suggested next command.
 - **Manual** -- finding requires manual cleanup (e.g. malformed HISTORY.log lines).

package/commands/scr/submit.md

@@ -20,7 +20,8 @@ Load `.manuscript/config.json` for `command_unit`. The runnable command stays `/
 1. Load `.manuscript/config.json` for project context
 2. Check that the specified unit has been through editor review. Prefer `.manuscript/reviews/{N}-REVIEW.md`; if it is missing, accept legacy `{N}-EDITOR-NOTES.md`.
 3. Mark the unit as submitted in `STATE.md`
-4. Report: "Unit {N} submitted. {remaining} units remaining."
+4. Refresh `.manuscript/PROGRESS.md` so the ledger shows this unit as done, per `docs/progress-protocol.md`.
+5. Report: "Unit {N} submitted. {remaining} units remaining."
 
 ## Response Contract
 

package/data/CONSTRAINTS.json

@@ -1,6 +1,6 @@
 {
   "$schema": "./constraints.schema.json",
-  "version": "2.6.0",
+  "version": "2.7.1",
   "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."
@@ -3744,6 +3744,7 @@
     "default": {
       "BRIEF.md": "BRIEF.md",
       "RECORD.md": "RECORD.md",
+      "PROGRESS.md": "PROGRESS.md",
       "CHARACTERS.md": "CHARACTERS.md",
       "RELATIONSHIPS.md": "RELATIONSHIPS.md",
       "WORLD.md": "WORLD.md",
@@ -3753,6 +3754,7 @@
     "academic": {
       "BRIEF.md": "PROPOSAL.md",
       "RECORD.md": "RECORD.md",
+      "PROGRESS.md": "PROGRESS.md",
       "CHARACTERS.md": "CONCEPTS.md",
       "WORLD.md": "CONTEXT.md",
       "PLOT-GRAPH.md": "ARGUMENT-MAP.md",
@@ -3761,6 +3763,7 @@
     "technical": {
       "BRIEF.md": "DOC-BRIEF.md",
       "RECORD.md": "RECORD.md",
+      "PROGRESS.md": "PROGRESS.md",
       "CHARACTERS.md": "AUDIENCE.md",
       "RELATIONSHIPS.md": "DEPENDENCIES.md",
       "WORLD.md": "SYSTEM.md",
@@ -3770,6 +3773,7 @@
     "sacred": {
       "BRIEF.md": "FRAMEWORK.md",
       "RECORD.md": "RECORD.md",
+      "PROGRESS.md": "PROGRESS.md",
       "CHARACTERS.md": "FIGURES.md",
       "RELATIONSHIPS.md": "LINEAGES.md",
       "WORLD.md": "COSMOLOGY.md",

package/docs/architecture.md

@@ -175,6 +175,8 @@ scriveno/
     WRITING-RULES.md       Universal AI-tell rulebook (1.6.0+)
     THEMES.md              Thematic threads template
     STATE.md               Progress tracking template
+    CONTEXT.md             Session bootstrap scaffold (derived, auto-regenerated)
+    PROGRESS.md            Per-unit progress ledger scaffold (derived, 2.7.0+)
     BRIEF.md               Project brief template
     WORLD.md               World-building template
     pitfalls/              Per-work-type pitfall packs (1.6.0+)
@@ -355,7 +357,7 @@ Codex uses a skill-native variation of this strategy. The installer generates on
 
 Scriveno also ships `lib/auto-invoke-engine.js`, exposed through `scriveno status --project .`, `scriveno status . --json`, `scriveno status --project . --apply-safe`, `scriveno sync --check`, `scriveno smoke`, `scriveno agents`, and `scriveno routes`. The installer copies this library into the shared Scriveno asset directory for global and project installs, so command surfaces can call a single status and audit engine before falling back to embedded markdown logic.
 
-The engine checks disk evidence only: project presence, required project files, STATE.md, CONTEXT.md freshness, plan files, draft files, review coverage, unresolved notes, revision-track proposals, translation work, publishing prerequisites, exports, history, and save signals. It recommends the next command, but it does not mutate files and does not spawn agents by itself. That boundary keeps proactive behavior portable across Claude Code, Codex, Cursor, Gemini CLI, OpenCode, GitHub Copilot, Windsurf, Antigravity, Manus, Perplexity Desktop, and the generic fallback.
+The engine checks disk evidence only: project presence, required project files, STATE.md, CONTEXT.md freshness, plan files, draft files, review coverage, unresolved notes, revision-track proposals, translation work, publishing prerequisites, exports, history, and save signals. It also computes the per-unit progress ledger (done / in progress / untouched) through `computeProgressLedger`, which `/scr:progress` and `.manuscript/PROGRESS.md` build on. It recommends the next command, but it does not mutate files and does not spawn agents by itself. That boundary keeps proactive behavior portable across Claude Code, Codex, Cursor, Gemini CLI, OpenCode, GitHub Copilot, Windsurf, Antigravity, Manus, Perplexity Desktop, and the generic fallback.
 
 The engine now reports three automation lanes:
 

package/docs/auto-invoke-policy.md

@@ -63,7 +63,7 @@ Use `Automation status:` for command chains and `Sync status:` for runtime insta
 | Level | Behavior | Default | Examples |
 |-------|----------|---------|----------|
 | 1 | Read-only suggestion | Run by default | `/scr:next` route, progress sweep, review queue surfacing |
-| 2 | Safe local helper | Run when directly triggered | `CONTEXT.md` regeneration, `HISTORY.log` append, scan report, stats count |
+| 2 | Safe local helper | Run when directly triggered | `CONTEXT.md` regeneration, `PROGRESS.md` ledger regeneration, `HISTORY.log` append, scan report, stats count |
 | 3 | Scoped agent | Spawn when the command implies it or evidence is bounded | drafter, plan-checker, voice-checker, continuity-checker, translator, beta-reader |
 | 4 | Writer-owned action | Require confirmation | publishing, destructive edits, merge decisions, accepting review findings |
 
@@ -81,6 +81,7 @@ Run these read-only checks in `/scr:next`, `/scr:progress`, and closeouts for ma
 - If front matter, back matter, blurb, or cover handoff assets are missing, surface the specific publishing prerequisite before packaging.
 - If export outputs are older than source files, suggest `/scr:export` or `/scr:publish`.
 - If no save exists after recent manuscript changes, suggest `/scr:save`.
+- Surface deliverable progress (units done / in progress / untouched) and point at the per-unit ledger `.manuscript/PROGRESS.md`; if it is stale, suggest `/scr:save` to refresh it.
 
 These checks must not mutate files.
 
@@ -88,10 +89,10 @@ These checks must not mutate files.
 
 Run these only when the current command directly owns the file operation:
 
-- `/scr:save` regenerates `.manuscript/CONTEXT.md`, appends `HISTORY.log`, and commits `.manuscript/`.
+- `/scr:save` regenerates `.manuscript/CONTEXT.md` and `.manuscript/PROGRESS.md` (the per-unit ledger), appends `HISTORY.log`, and commits `.manuscript/`.
 - `/scr:scan --fix` applies deterministic state repairs after confirmation and appends `HISTORY.log`.
 - `/scr:resume-work` may regenerate `CONTEXT.md` from disk state.
-- `/scr:progress` may count drafts, submitted units, open record threads, and stale reports, but does not write.
+- `/scr:progress` may count drafts, submitted units, open record threads, and stale reports and render the per-unit ledger live, but does not write. The saved `.manuscript/PROGRESS.md` is refreshed by `/scr:save`, `/scr:draft`, `/scr:autopilot`, and `/scr:scan --fix`.
 - Runtime `/scr:sync --apply` runs the installer and verifies installed command, skill, and agent surfaces.
 
 Report these as local operations, not spawned agents.

package/docs/command-reference.md

@@ -293,17 +293,22 @@ Show publishing-related commands available for your work type. Without a categor
 
 ### `/scr:progress`
 
-**Description:** Show current state and next step. How far along are you, what's drafted, what's pending.
+**Description:** Show project progress: a unit progress bar, what's done / in progress / untouched, pipeline position, and a pointer to the per-unit ledger.
 
 **Usage:** `/scr:progress`
 
 **Prerequisites:** None
 
+**Output includes:**
+- A deliverable progress bar over units (done / in progress / untouched) with percent
+- Pipeline position on the writing lifecycle (e.g., "Stage 6 of 10: Drafting")
+- A pointer to `.manuscript/PROGRESS.md`, the openable per-unit ledger you can read any time
+
 **Example:**
 ```
 /scr:progress
 ```
-See "Chapter 4 of 12 drafted. 32,000 words. Next: discuss-chapter 5."
+See "████████░░ 4/12 chapters done (33%). Pipeline: Stage 6 of 10 (Drafting). Next: discuss chapter 5. Full ledger: .manuscript/PROGRESS.md."
 
 ---
 

package/docs/configuration.md

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

package/docs/context-protocol.md

@@ -6,6 +6,7 @@ It is part of the trust layer:
 - `STATE.md` -- structured snapshot (data)
 - `RECORD.md` -- compact established-content store
 - `.manuscript/CONTEXT.md` -- one-page narrative bootstrap (synthesis)
+- `.manuscript/PROGRESS.md` -- per-unit progress ledger (derived; see `docs/progress-protocol.md`)
 - `.manuscript/HISTORY.log` -- append-only audit trail
 
 ## The rule
@@ -71,7 +72,7 @@ Filesystem mtime is a cheap, durable signal that does not require parsing the fi
 - **Drafter agents** (drafter.md, voice-checker.md, etc.) -- they need the full source files for fidelity.
 - **Read-only data display commands** (`/scr:progress`, `/scr:session-report`) -- already cheap; no orientation files to skip.
 - **First-write commands** (`/scr:new-work`, `/scr:import`) -- no CONTEXT.md exists yet.
-- **The CONTEXT.md regenerators themselves** (`/scr:save`, `/scr:pause-work`, `/scr:resume-work`) -- they MUST load the raw files to rebuild CONTEXT.md correctly. They are the *writers* of CONTEXT.md, not consumers.
+- **The CONTEXT.md and PROGRESS.md regenerators themselves** (`/scr:save`, `/scr:pause-work`, `/scr:resume-work`) -- they MUST load the raw files to rebuild CONTEXT.md and the per-unit PROGRESS.md ledger correctly. They are the *writers* of those derived files, not consumers.
 - **`/scr:scan`** -- its job is to detect drift, so it must read the raw files to compare against CONTEXT.md.
 
 ## Expected savings

package/docs/creative-context.md

@@ -56,7 +56,7 @@ Do not turn `.manuscript/CONTEXT.md` into a glossary. It is an auto-regenerated
 | `cast` | `CHARACTERS.md`, `FIGURES.md` | Character state, voice anchors, relationships, figure continuity |
 | `world` | `WORLD.md`, `COSMOLOGY.md`, `SYSTEM.md` | Setting, constraints, environment, cosmology, operating rules |
 | `themes` | `THEMES.md`, `DOCTRINES.md`, `QUESTIONS.md` | Motifs, doctrine, argument, inquiry, recurring meaning |
-| `continuity` | `STATE.md`, `CONTEXT.md`, `HISTORY.log` | Current position, recent activity, open items, disk truth |
+| `continuity` | `STATE.md`, `CONTEXT.md`, `PROGRESS.md`, `HISTORY.log` | Current position, recent activity, per-unit progress ledger, open items, disk truth |
 | `publication` | front matter, back matter, build files | Export and publishing intent |
 | `translation` | glossary, translation memory, language config | Term consistency and cultural adaptation |
 | `art` | cover, illustration, storyboard assets | Visual continuity and image direction |

package/docs/history-protocol.md

@@ -1,6 +1,6 @@
 # HISTORY.log Protocol
 
-`.manuscript/HISTORY.log` is the project's append-only chronological record of Scriveno commands that mutate state. It is the third leg of the context-integrity stool, alongside `STATE.md` (structured snapshot) and `.manuscript/CONTEXT.md` (one-page bootstrap). Where STATE.md records *what is true now* and CONTEXT.md narrates *where you are*, HISTORY.log records *how you got here, in order*.
+`.manuscript/HISTORY.log` is the project's append-only chronological record of Scriveno commands that mutate state. It is part of the context-integrity layer alongside `STATE.md` (structured snapshot), `RECORD.md` (established content), `.manuscript/CONTEXT.md` (one-page bootstrap), and `.manuscript/PROGRESS.md` (per-unit progress ledger). Where STATE.md records *what is true now* and CONTEXT.md narrates *where you are*, HISTORY.log records *how you got here, in order*.
 
 This document is the single source of truth for the line format. Every command that appends to HISTORY.log must follow this contract.
 

package/docs/progress-protocol.md

@@ -0,0 +1,132 @@
+# Progress ledger protocol
+
+This is the canonical contract for `.manuscript/PROGRESS.md`, Scriveno's openable per-unit progress ledger, and for how every command derives and renders unit status. The goal is one consistent answer to the question a writer asks most often: *what is done, what is in progress, what is untouched, and where are we in the journey?*
+
+It is part of the trust layer, alongside the other derived and recorded surfaces:
+
+- `STATE.md` -- structured workflow snapshot (aggregate counters, current position)
+- `RECORD.md` -- compact established-content store
+- `.manuscript/CONTEXT.md` -- one-page narrative bootstrap (synthesis, read first by a fresh session)
+- `.manuscript/PROGRESS.md` -- per-unit progress ledger (the file you open to see every unit's status)
+- `.manuscript/HISTORY.log` -- append-only audit trail
+
+`STATE.md` answers "how many units are drafted." `PROGRESS.md` answers "which ones, and what state is each in." They never disagree because both are reconciled against disk, and `/scr:scan` is the trust check.
+
+## What PROGRESS.md is for
+
+`STATE.md` holds aggregate counts (`Units drafted: 4 of 5`). That tells the writer how far along they are but not *which* unit is where. `PROGRESS.md` is the deliverable-level view: a single human-readable file the writer can open to see every unit with its status (done / in progress / untouched), the macro pipeline position, recent activity, and the next step. It is the writing-domain analog of a requirements checklist.
+
+The template lives at `templates/PROGRESS.md`. The file is **derived**: never hand-edited, always rebuilt from disk. Like `CONTEXT.md`, it is not created at `/scr:new-work`; it is generated the first time a unit-status-changing command or a save/pause/resume runs.
+
+## The three status buckets
+
+Every unit resolves to exactly one headline status. Derive it from disk first, then reconcile with `STATE.md`:
+
+| Bucket | Marker | Disk condition |
+|--------|--------|----------------|
+| **Untouched** | `[ ]` | No plan file and no draft file for the unit. Not yet worked. |
+| **In progress** | `[~]` | Started but not finished: a plan exists without a draft, a draft exists without a clean review, a review has open editor notes, or revisions are pending. |
+| **Done** | `[x]` | The unit needs no more work this pass: it is submitted, or (for flows that stop at review) reviewed with no open notes. |
+
+The headline bucket sits next to a finer **stage** so the writer sees both the rollup and the precise position.
+
+## Per-unit stage derivation (disk-first)
+
+Match each outline unit to its files by unit number. Use the same evidence `/scr:scan` uses (see `commands/scr/scan.md`, checks 1-3):
+
+- **untouched** -- no `.manuscript/plans/{N}-*-PLAN.md` (or legacy `.manuscript/{N}-*-PLAN.md`) and no `.manuscript/drafts/body/{N}-*-DRAFT.md`
+- **discussed** -- a `{N}-CONTEXT.md` exists but no plan or draft yet
+- **planned** -- a plan file exists, no draft file
+- **drafted** -- a draft file exists, no review report
+- **reviewed** -- a `.manuscript/reviews/{N}-REVIEW.md` (or legacy `{N}-EDITOR-NOTES.md`) exists; treat as *reviewed with open notes* (in progress) when the review or `STATE.md` lists unresolved items, otherwise *reviewed clean*
+- **submitted** -- `STATE.md` marks the unit submitted
+
+Map stages to buckets: `untouched` -> untouched; `discussed`, `planned`, `drafted`, `reviewed-with-open-notes`, `revisions-pending` -> in progress; `reviewed-clean` (when the flow stops at review) and `submitted` -> done.
+
+Word count per unit comes from the unit's draft file(s); show `--` for units with no draft.
+
+## Pipeline position
+
+The macro writing lifecycle is the default map (same chain `/scr:next` walks):
+
+```
+seed > voice > outline > discuss > plan > draft > review > revise > publish > translate
+```
+
+Compute the current stage as the first incomplete step across the whole project, render it as `Stage {index} of {total}: {Name}`, and show the track with the current stage bracketed, for example:
+
+```
+seed > voice > outline > discuss > plan > [draft] > review > revise > publish > translate
+```
+
+Translate is only relevant when the project has target languages configured; keep it in the track for orientation but never treat its absence as incomplete for a single-language project.
+
+## The deliverable progress bar
+
+Render a 10-cell bar over the done fraction using block characters (`U+2588` filled, `U+2591` empty), followed by counts and percent:
+
+```
+████████░░ 4/5 scenes done (80%)
+```
+
+The denominator is the total unit count from `OUTLINE.md`. Percent is `round(done / total * 100)`. Use the work type's plural unit label (scenes, chapters, surahs, procedures, poems, and so on) from `CONSTRAINTS.json`; never hard-code "chapter."
+
+## Ledger table shape
+
+Group rows by the work type's mid level (act, part, sequence) when the outline has one, with a per-group rollup in the heading. Within a group, one row per atomic unit:
+
+```
+### Act I -- Disruption (2/2 done)
+
+| # | Title | Stage | Status | Words |
+|---|-------|-------|--------|-------|
+| 1 | The Letter   | submitted | [x] | 1,020 |
+| 2 | The Workshop | reviewed  | [x] | 1,010 |
+
+### Act II -- Decision (0/1 done, 1 in progress)
+
+| # | Title | Stage | Status | Words |
+|---|-------|-------|--------|-------|
+| 3 | The Pier | drafted | [~] | 890 |
+```
+
+For work types without a mid level (short story, poetry collection), use a single flat table.
+
+## Who regenerates PROGRESS.md
+
+The ledger is a Level 2 safe local helper (see `docs/auto-invoke-policy.md`). It is rebuilt by the commands that change unit status or refresh derived state, never by a read-only command:
+
+- `/scr:draft` -- after a unit is drafted and STATE.md is updated
+- `/scr:editor-review` -- after a unit is marked reviewed
+- `/scr:submit` -- after a unit is marked submitted
+- `/scr:autopilot` -- after every unit, as part of the mandatory state update (so the file advances visibly during a run)
+- `/scr:save`, `/scr:pause-work`, `/scr:resume-work` -- alongside `CONTEXT.md` regeneration, from the shared field set in `/scr:save` step 7
+- `/scr:scan --fix` -- when the ledger is missing or stale
+
+`/scr:progress` is read-only: it renders this picture live from disk and points the writer at `PROGRESS.md`, but it does not write the file. When the live view is ahead of the saved file (units changed since the last refresh), `/scr:progress` says so and suggests `/scr:save`.
+
+## Token reference
+
+A regenerator fills these tokens in `templates/PROGRESS.md`:
+
+| Token | Source |
+|-------|--------|
+| `{{LAST_UPDATED}}` | ISO 8601 timestamp of this regeneration |
+| `{{LAST_COMMAND}}` | the command that triggered the rebuild |
+| `{{TITLE}}`, `{{WORK_TYPE}}` | `config.json` |
+| `{{UNIT_LABEL}}`, `{{UNIT_LABEL_PLURAL}}` | `CONSTRAINTS.json` hierarchy for the work type |
+| `{{PROGRESS_BAR}}`, `{{DONE_PERCENT}}` | computed from the done fraction |
+| `{{DONE_COUNT}}`, `{{IN_PROGRESS_COUNT}}`, `{{UNTOUCHED_COUNT}}`, `{{TOTAL_COUNT}}` | per-unit derivation above |
+| `{{WORD_COUNT}}` | sum of draft word counts |
+| `{{STAGE_INDEX}}`, `{{STAGE_TOTAL}}`, `{{STAGE_NAME}}`, `{{LIFECYCLE_TRACK}}` | pipeline position above |
+| `{{LEDGER_TABLE}}` | grouped ledger rows above |
+| `{{RECENT_ACTIONS}}` | last 3-5 lines of `HISTORY.log` (or STATE.md Last actions) as rows |
+| `{{NEXT_STEP}}` | the suggestion `/scr:next` would emit |
+| `{{LAST_SCAN}}`, `{{LAST_SCAN_VERDICT}}` | `STATE.md` if recorded, else `never run` / `unknown` |
+
+## When this protocol does not apply
+
+- **Read-only views** (`/scr:progress`, `/scr:manuscript-stats`, `/scr:outline`) consume and render the derivation but do not write `PROGRESS.md`.
+- **First-write commands** (`/scr:new-work`, `/scr:import`) -- no units exist yet; the ledger is generated on the first status-changing command or save.
+
+The protocol is a hint, not a hard gate. A command that cannot parse the outline cleanly should fall back to the aggregate `STATE.md` counts and say so, rather than emit a wrong per-unit ledger.

package/docs/release-notes.md

@@ -2,6 +2,35 @@
 
 This document is the public-facing summary of what changed between package releases. For package history, see the root [CHANGELOG](../CHANGELOG.md).
 
+## 2.7.1 - 2026-05-30
+
+### What changed
+
+- `scriveno status` now prints the progress ledger directly (a `Progress:` line with bar, done / in progress / untouched, and pipeline position), so the deliverable view is visible from the bundled CLI, not only to runtimes that load the engine module.
+- Documentation-integrity pass: corrected the context-integrity layer description (now five files), added `PROGRESS.md` to the scan trust-file lists and the architecture template tree, and refreshed stale version and count references across the docs.
+
+### Why it matters
+
+It closes the loop on the 2.7.0 progress ledger: the numbers are surfaced everywhere a writer looks, and the documentation matches the shipped behavior.
+
+## 2.7.0 - 2026-05-30
+
+### What changed
+
+- Added a per-unit progress ledger: `.manuscript/PROGRESS.md` shows every unit as done / in progress / untouched, with a deliverable progress bar and pipeline position, and `/scr:progress` now leads with that view and points at the ledger file.
+- `/scr:draft` and `/scr:autopilot` now narrate progress against the whole manuscript (unit N of total, percent).
+- `lib/auto-invoke-engine.js` exposes `computeProgressLedger` so the ledger numbers are deterministic across runtimes; `docs/progress-protocol.md` documents the contract.
+
+### Why it matters
+
+Writers asked for one place to see what is done, in progress, and untouched without re-deriving it each time. The ledger is that file, and because it is derived from disk it cannot silently drift from the real state of the manuscript.
+
+### Affected areas
+
+- progress, draft, autopilot, outline, manuscript-stats, and scan commands
+- the shared auto-invoke engine (computeProgressLedger)
+- the trust-layer docs and templates
+
 ## 2.6.0 - 2026-05-29
 
 ### 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.6.0`, the route graph contains:
+As of `2.7.1`, the route graph contains:
 
 - 113 commands
 - intent-order edges from `command_intents`

package/docs/shipped-assets.md

@@ -27,14 +27,16 @@ A contributor adding `templates/pitfalls/<work_type>.md` is automatically picked
 
 ## Context Integrity Assets Shipped Since 2.0.0
 
-These files ship in `templates/` and `docs/` and provide the trust trio for session-aware AI work:
+These files ship in `templates/` and `docs/` and provide the context-integrity set for session-aware AI work:
 
 - `templates/CONTEXT.md` -- one-page session bootstrap scaffold copied into every project. Auto-regenerated on `/scr:save`, `/scr:pause-work`, `/scr:resume-work`. Read first by `/scr:next` and `/scr:resume-work` for orientation, with stale-detection + STATE.md fallback.
+- `templates/PROGRESS.md` -- per-unit progress ledger scaffold: the openable file showing every unit as done / in progress / untouched, plus a deliverable progress bar and pipeline position. Derived from disk; auto-regenerated on `/scr:draft`, `/scr:editor-review`, `/scr:submit`, `/scr:autopilot`, `/scr:save`, `/scr:pause-work`, `/scr:resume-work`, and `/scr:scan --fix`. Rendered live by `/scr:progress`.
 - `templates/RECORD.md` -- compact established-content store copied into every project. It tracks what the work has established, including open threads, promises, payoffs, continuity facts, movement, and next-unit obligations. It is deliberately neutral so sacred, academic, technical, poetry, script, visual, and prose projects can all use the same filename.
 - `docs/context-protocol.md` -- canonical contract for the CONTEXT.md preference rule. The 12 high-impact commands that opt into the protocol reference this doc.
+- `docs/progress-protocol.md` -- canonical contract for the `.manuscript/PROGRESS.md` per-unit ledger: status derivation from disk, the done / in progress / untouched buckets, pipeline position, the progress bar, and the regeneration points.
 - `docs/history-protocol.md` -- canonical line-format spec for `.manuscript/HISTORY.log`, the append-only audit trail. Pipe-delimited, UTC ISO timestamps, committed to git.
 
-`STATE.md` (workflow data) + `RECORD.md` (established content) + `CONTEXT.md` (narrative bootstrap) + `HISTORY.log` (audit trail) together form the integrity layer. `/scr:scan` is the trust check that interrogates whether the recorded state still matches disk.
+`STATE.md` (workflow data) + `RECORD.md` (established content) + `CONTEXT.md` (narrative bootstrap) + `PROGRESS.md` (per-unit ledger) + `HISTORY.log` (audit trail) together form the integrity layer. `/scr:scan` is the trust check that interrogates whether the recorded state still matches disk.
 
 ## Runtime Sync Asset Shipped Today
 

package/lib/auto-invoke-engine.js

@@ -820,6 +820,7 @@ function analyzeProject(projectRoot = process.cwd(), options = {}) {
       commandUnit: config.command_unit || 'unit',
       workType: config.work_type || '',
       counts: { drafts: 0, plans: 0, reviews: 0 },
+      progress: computeProgressLedger(manuscriptDir),
       signals,
       recommendation,
       automation,
@@ -871,6 +872,7 @@ function analyzeProject(projectRoot = process.cwd(), options = {}) {
     commandUnit: config.command_unit || 'unit',
     workType: config.work_type || '',
     counts,
+    progress: computeProgressLedger(manuscriptDir),
     signals,
     recommendation,
     automation,
@@ -879,12 +881,17 @@ function analyzeProject(projectRoot = process.cwd(), options = {}) {
 
 function formatProactiveChecks(analysis) {
   const { signals } = analysis;
+  const progress = analysis.progress || {};
   const stateLine = signals.hasProject
     ? `  State: ${signals.hasState ? 'fresh' : 'missing, suggest /scr:scan'}`
     : '  Project: missing, suggest /scr:new-work';
+  const progressLine = progress.total
+    ? `  Progress: ${progress.bar} ${progress.done}/${progress.total} done (${progress.percent}%), ${progress.inProgress} in progress, ${progress.untouched} untouched`
+    : '  Progress: no units yet';
   return [
     'Proactive checks:',
     stateLine,
+    progressLine,
     `  Readiness: ${signals.readiness?.state || 'none'}${signals.readiness?.missing?.length ? `, missing ${signals.readiness.missing.join(', ')}` : ''}`,
     `  Session: ${signals.context.state}${signals.context.suggest ? `, suggest ${signals.context.suggest}` : ''}`,
     `  Plans: ${signals.plan?.state || 'none'}${signals.plan?.suggest ? `, suggest ${signals.plan.suggest}` : ''}`,
@@ -1377,6 +1384,93 @@ if (require.main === module) {
   }
 }
 
+// Progress ledger: deterministic deliverable-progress computation from disk.
+// See docs/progress-protocol.md. Additive helper used by /scr:progress and any
+// runtime that loads this module, so the ledger is consistent across hosts.
+function ledgerUnitNumbers(dir, suffixRegex) {
+  const found = new Set();
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch (err) {
+    return found;
+  }
+  for (const name of entries) {
+    const match = name.match(suffixRegex);
+    if (match) {
+      found.add(parseInt(match[1], 10));
+    }
+  }
+  return found;
+}
+
+function ledgerOutlineUnitCount(manuscriptDir) {
+  let text;
+  try {
+    text = fs.readFileSync(path.join(manuscriptDir, 'OUTLINE.md'), 'utf8');
+  } catch (err) {
+    return 0;
+  }
+  const tableRows = text.match(/^\|\s*\d+\s*\|/gm);
+  if (tableRows && tableRows.length) {
+    return tableRows.length;
+  }
+  const numberedLines = text.match(/^\s*\d+[.)]\s+\S/gm);
+  return numberedLines ? numberedLines.length : 0;
+}
+
+function ledgerBar(done, total, width) {
+  const cells = width || 10;
+  const filled = total > 0 ? Math.round((done / total) * cells) : 0;
+  const clamped = Math.max(0, Math.min(cells, filled));
+  return '█'.repeat(clamped) + '░'.repeat(cells - clamped);
+}
+
+// Returns deliverable progress for a project's .manuscript directory: total
+// units, per-stage counts, the done / in-progress / untouched buckets, a
+// percent, a rendered bar, and the unit-number sets. Derived purely from disk
+// (plan/draft/review files reconciled with the OUTLINE unit count).
+function computeProgressLedger(manuscriptDir) {
+  const drafted = ledgerUnitNumbers(
+    path.join(manuscriptDir, 'drafts', 'body'),
+    /^(\d+)\D.*DRAFT\.md$/i
+  );
+  const planned = ledgerUnitNumbers(path.join(manuscriptDir, 'plans'), /^(\d+)\D.*PLAN\.md$/i);
+  for (const unit of ledgerUnitNumbers(manuscriptDir, /^(\d+)\D.*PLAN\.md$/i)) {
+    planned.add(unit);
+  }
+  const reviewed = ledgerUnitNumbers(path.join(manuscriptDir, 'reviews'), /^(\d+)\D.*REVIEW\.md$/i);
+  for (const unit of ledgerUnitNumbers(manuscriptDir, /^(\d+)\D.*EDITOR-NOTES\.md$/i)) {
+    reviewed.add(unit);
+  }
+
+  const worked = new Set([...planned, ...drafted, ...reviewed]);
+  const maxWorked = worked.size ? Math.max(...worked) : 0;
+  const total = Math.max(ledgerOutlineUnitCount(manuscriptDir), worked.size, maxWorked);
+
+  const done = reviewed.size;
+  const inProgress = [...worked].filter((unit) => !reviewed.has(unit)).length;
+  const untouched = Math.max(0, total - worked.size);
+  const percent = total > 0 ? Math.round((done / total) * 100) : 0;
+
+  return {
+    total,
+    drafted: drafted.size,
+    planned: planned.size,
+    reviewed: reviewed.size,
+    done,
+    inProgress,
+    untouched,
+    percent,
+    bar: ledgerBar(done, total, 10),
+    units: {
+      drafted: [...drafted].sort((a, b) => a - b),
+      planned: [...planned].sort((a, b) => a - b),
+      reviewed: [...reviewed].sort((a, b) => a - b),
+    },
+  };
+}
+
 module.exports = {
   AGENT_ROUTE_POLICIES,
   CATEGORY_ROUTE_POLICIES,
@@ -1404,4 +1498,5 @@ module.exports = {
   inspectRuntimeSmoke,
   listRuntimeAgentSupport,
   parseCliArgs,
+  computeProgressLedger,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scriveno",
-  "version": "2.6.0",
+  "version": "2.7.1",
   "description": "Spec-driven creative writing, publishing, and translation pipeline for AI coding agents. From blank page to published book.",
   "bin": {
     "scriveno": "bin/install.js"

package/templates/PROGRESS.md

@@ -0,0 +1,56 @@
+---
+creative_pillar: continuity
+always_load_for: [progress]
+authority: derived
+---
+
+# Progress ledger
+
+This file is auto-regenerated by Scriveno. It is the one place to open and see every {{UNIT_LABEL}} at a glance: what is done, what is in progress, and what is untouched. Do not hand-edit -- it is rebuilt from disk whenever the project's unit status changes (on `/scr:draft`, `/scr:editor-review`, `/scr:submit`, `/scr:autopilot`, `/scr:save`, `/scr:pause-work`, `/scr:resume-work`, and `/scr:scan --fix`).
+
+If this file is missing, stale, or disagrees with the live view from `/scr:progress`, run `/scr:save` (or `/scr:scan --fix`) to rebuild it. `/scr:progress` always renders the current picture from disk; this file is the saved snapshot you can open any time.
+
+**Updated:** {{LAST_UPDATED}}
+**Updated by:** {{LAST_COMMAND}}
+**Project:** {{TITLE}} ({{WORK_TYPE}})
+
+## Deliverable progress
+
+{{PROGRESS_BAR}} {{DONE_COUNT}}/{{TOTAL_COUNT}} {{UNIT_LABEL_PLURAL}} done ({{DONE_PERCENT}}%)
+
+- **Done:** {{DONE_COUNT}}
+- **In progress:** {{IN_PROGRESS_COUNT}}
+- **Untouched:** {{UNTOUCHED_COUNT}}
+- **Words:** {{WORD_COUNT}}
+
+## Pipeline position
+
+Stage {{STAGE_INDEX}} of {{STAGE_TOTAL}}: {{STAGE_NAME}}
+
+`{{LIFECYCLE_TRACK}}`
+
+## {{UNIT_LABEL}} ledger
+
+Status key: `[x]` done   `[~]` in progress   `[ ]` untouched
+
+{{LEDGER_TABLE}}
+
+## Recent activity
+
+The last few recorded actions, newest first. Full history lives in `.manuscript/HISTORY.log`.
+
+{{RECENT_ACTIONS}}
+
+## What's next
+
+{{NEXT_STEP}}
+
+## Trust check
+
+The status above is derived from disk: plan files in `.manuscript/plans/`, drafts in `.manuscript/drafts/body/`, and reviews in `.manuscript/reviews/`, reconciled with `.manuscript/STATE.md`. The numbers are claims, not facts -- run `/scr:scan` to confirm they still match disk.
+
+**Last `/scr:scan` run:** {{LAST_SCAN}}
+**Last drift verdict:** {{LAST_SCAN_VERDICT}}
+
+---
+*Derived ledger. See `docs/progress-protocol.md` for how status is computed. This file is the saved snapshot; `/scr:progress` renders the same picture live.*

package/templates/config.json

@@ -1,5 +1,5 @@
 {
-  "scriveno_version": "2.6.0",
+  "scriveno_version": "2.7.1",
   "work_type": "",
   "group": "",
   "command_unit": "",