scriveno 2.5.0 → 2.7.1

package/docs/drafter-quality.md

@@ -104,7 +104,7 @@ Rough guidance for matching settings to model class. The writer's experience wit
 | Mid-tier (Sonnet 4.x, GPT-4 mini, Haiku 4.x) | Day-to-day drafting, most novels and screenplays | `standard` | `standard` |
 | Budget (Haiku, GPT-3.5, local 7-13B) | Bulk drafting of short scenes, repetitive structural work | `strict` | `minimal` |
 
-If voice fidelity drops below the writer's `voice.drift_threshold`, the first lever is `rigor: strict`. The second is to step up a model tier. The third is to recalibrate STYLE-GUIDE.md via `/scr:voice-test`.
+If voice fidelity drops below the writer's `voice.drift_threshold` (a voice-checker score below 70 at the default 0.3, where drift is `(100 - score) / 100`), the first lever is `rigor: strict`. The second is to step up a model tier. The third is to recalibrate STYLE-GUIDE.md via `/scr:voice-test`.
 
 ## Token economy
 

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,60 @@
 
 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
+
+- Fixed a Pandoc-variable mismatch so RTL, CJK, and non-Latin fonts now reach the print and PDF path; added RTL support to the picturebook and stageplay templates (all four interior templates verified with `dir=rtl`).
+- Made the voice-drift gate functional: `agents/voice-checker.md` now defines `drift = (100 - score) / 100`, so the default `voice.drift_threshold` of 0.3 means a re-draft is offered below a voice score of 70.
+- Kept `/scr:autopilot-publish` fully unattended and advisory; a severe voice failure is surfaced loudly rather than halting the run.
+- Corrected `/scr:quick-write` and `/scr:beta-reader` framing to match what they actually do.
+- Marked the translation and illustration API tables as future targets, not shipped behavior.
+- Audited and fixed documentation drift across the suite: command reference usage lines, the configuration baseline, the architecture file tree, voice-dna part numbering, the missing speech work type, and stale counts.
+- Added `lib/track-safety.js` with adversarial tests, and `argument-hint` to 17 commands.
+
+### Why it matters
+
+This release closes the gap between what Scriveno documented and what it shipped. The export fix makes RTL and non-Latin print output actually work, the voice gate is now a real computed check instead of a phantom threshold, and the documentation no longer claims integrations or behavior that the prompt system does not provide.
+
+### Affected areas
+
+- export and print templates (RTL, CJK, fonts)
+- voice-checker drift mapping and autopilot gates
+- translation and illustration honesty
+- documentation suite (command reference, configuration, architecture, voice-dna, README)
+- track-safety helper and command argument hints
+- package metadata and release-alignment tests
+
 ## 2.5.0 - 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.5.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/docs/translation.md

@@ -2,17 +2,13 @@
 
 Scriveno translates your manuscript into any language while preserving your voice. The translation pipeline handles glossary management, translation memory, cultural adaptation, quality verification, and multi-language publishing -- from setup to finished translated editions.
 
-This guide covers the full pipeline: choosing a translation engine, translating your manuscript, managing terminology, verifying quality, and publishing in multiple languages.
+This guide covers the full pipeline: how translation works, translating your manuscript, managing terminology, verifying quality, and publishing in multiple languages.
 
-## Translation Engines
+## Translation approach
 
-Scriveno uses three translation approaches, each suited to different languages and content types.
+Scriveno translates through the in-context translator agent (`agents/translator.md`), not an external translation API. The agent itself handles literary nuance, sacred-text registers, and cultural adaptation that machine-translation services miss. It applies your voice profile, maintains glossary compliance, and can do formal or dynamic equivalence translation. Every unit is translated by the translator agent in fresh context with your STYLE-GUIDE.md loaded.
 
-**DeepL** -- Primary engine for European languages. Higher quality than alternatives for English, French, German, Spanish, Italian, Portuguese, Dutch, Polish, Japanese, Chinese, and Korean. GDPR-compliant -- your content is not stored or used for training.
-
-**Google Cloud Translation** -- Broad language coverage with 130+ languages. Required for Arabic, Hebrew, Hindi, Swahili, and other languages DeepL does not cover. Best choice for RTL scripts and languages with limited DeepL support.
-
-**AI Agent (Claude/GPT)** -- The AI agent itself handles literary nuance, sacred text translation, and cultural adaptation that machine translation APIs miss. It applies your voice profile, maintains glossary compliance, and can do formal/dynamic equivalence translation. This is Scriveno's default for literary content -- every unit is translated by the translator agent with your STYLE-GUIDE.md loaded.
+DeepL and Google Cloud Translation are documented as possible future integration targets, not current behavior. Scriveno does not call either service today; if an automated machine-translation path is added later, this guide will describe how it plugs in.
 
 The translator agent works unit by unit in fresh context (just like the drafter), ensuring consistent quality and glossary compliance across the entire manuscript.
 
@@ -171,7 +167,7 @@ The TMX export produces industry-standard Translation Memory eXchange format com
 
 ## Cultural Adaptation
 
-Machine translation handles words. Cultural adaptation handles meaning. Scriveno flags culturally sensitive content that needs human attention beyond what translation APIs catch.
+Translation handles words. Cultural adaptation handles meaning. Scriveno flags culturally sensitive content that needs deliberate attention beyond a faithful unit-by-unit rendering.
 
 ```
 /scr:cultural-adaptation fr
@@ -247,8 +243,8 @@ Scriveno handles right-to-left and CJK (Chinese, Japanese, Korean) scripts throu
 
 RTL languages (Arabic, Hebrew, Persian, Urdu) receive special handling:
 
-- **Text direction** -- Export commands automatically set `--variable dir=rtl` for Pandoc and `text-dir` for Typst
-- **Template adjustments** -- The Typst book template reverses inside/outside margins for RTL binding
+- **Text direction** -- Export commands pass the Pandoc `dir` variable (`dir=rtl`); the Typst interior templates read that `dir` variable to orient text
+- **Template adjustments** -- The Typst interior templates honor RTL: the book template reverses inside/outside margins for RTL binding, and the stageplay template flips its binding margin and page-number alignment. The chapbook and picturebook templates set text direction from the `dir` variable.
 - **Font requirements** -- RTL exports need fonts with Arabic/Hebrew glyph support. Scriveno uses system-available fonts by default; specify custom fonts in `.manuscript/config.json`
 - **Punctuation** -- Quotation marks use the appropriate convention (e.g., French-style guillemets for Arabic)
 

package/docs/voice-dna.md

@@ -138,7 +138,7 @@ This section governs the speed and flow of narrative.
 - **Between chapters** -- Cliffhangers, echoes, or clean breaks
 - **Time jumps** -- How they're signaled, how frequent, how handled
 
-### Part 7: Reference Influences
+### Part 8: Reference Influences
 
 This section captures the authors, works, and passages that anchor your voice.
 
@@ -210,7 +210,7 @@ The 10 registers are:
 | **Parabolic** | Allegorical, story-within-story | "The kingdom of heaven is like..." concrete daily-life imagery |
 | **Didactic** | Instructional, systematic, expository | Topic-by-topic structure, teacher-student dynamic, Q&A format |
 
-Each unit's plan file specifies which register to use. Your STYLE-GUIDE.md Part 8 (Sacred Voice Registers) describes how YOU handle each register -- the drafter always defers to your personalized register style over the generic descriptions.
+Each unit's plan file specifies which register to use. Your STYLE-GUIDE.md "Sacred voice registers" part (Part 8 in the shipped template) describes how YOU handle each register -- the drafter always defers to your personalized register style over the generic descriptions.
 
 If no register is specified in a plan file, the drafter defaults to narrative-historical.
 
@@ -276,7 +276,7 @@ See [docs/drafter-quality.md](drafter-quality.md) for the full system, including
 ### Too many metaphors / not enough metaphors
 
 **Symptom:** Prose is either overwritten or too bare.
-**Fix:** Adjust metaphor density in STYLE-GUIDE.md Part 4 (Figurative Language). "Sparse" means one metaphor per page at most. "Dense" means multiple per paragraph. Find your natural density by looking at your existing writing.
+**Fix:** Adjust metaphor density in STYLE-GUIDE.md Part 3 (vocabulary and figurative language). "Sparse" means one metaphor per page at most. "Dense" means multiple per paragraph. Find your natural density by looking at your existing writing.
 
 ### AI-sounding hedging
 

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/lib/track-safety.js

@@ -0,0 +1,72 @@
+// lib/track-safety.js
+// Canonical, dependency-free slug + branch derivation for /scr:track (D-01).
+//
+// The track.md prompt instructs the agent to slugify a writer-provided track
+// label before it ever touches a git or shell command. This module is the
+// single source of truth for that algorithm. The installer copies lib/ into the
+// writer's data dir, so it ships as <data-dir>/lib/track-safety.js and a runtime
+// can derive a guaranteed-safe slug deterministically instead of relying on the
+// model to apply the rules by hand:
+//
+//   node <data-dir>/lib/track-safety.js "Editor's Suggestions"
+//   -> {"slug":"editors-suggestions","branch":"track/editors-suggestions"}
+//
+// Safety property: a sanitized slug contains only [a-z0-9-]. It can never carry
+// a shell metacharacter, quote, whitespace, path separator, or command
+// substitution, so interpolating `track/<slug>` into a git command line is safe.
+
+'use strict';
+
+// A slug is shell-safe iff it is a non-empty run of lowercase alphanumerics and
+// hyphens with no leading/trailing hyphen.
+const SLUG_SAFE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+const FALLBACK_SLUG = 'untitled';
+
+// Apply the D-01 rules: lowercase, whitespace/underscores to hyphen, strip
+// everything that is not [a-z0-9-], collapse hyphen runs, trim edge hyphens.
+// Returns FALLBACK_SLUG when the label has no usable characters (e.g. "***",
+// "日本", "") so the caller never produces an empty branch name.
+function sanitizeTrackSlug(label) {
+  const slug = String(label == null ? '' : label)
+    .toLowerCase()
+    .replace(/[\s_]+/g, '-')
+    .replace(/[^a-z0-9-]+/g, '')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return slug.length > 0 ? slug : FALLBACK_SLUG;
+}
+
+function isShellSafeSlug(slug) {
+  return typeof slug === 'string' && SLUG_SAFE.test(slug);
+}
+
+// Resolve a collision-free branch name. `existingBranches` is the set of branch
+// names already present in the repo (e.g. parsed from `git branch`). Mirrors
+// track.md create-step 6: append -2, -3, ... to the slug until the branch name
+// is free.
+function resolveTrackBranch(label, existingBranches = []) {
+  const taken = new Set(existingBranches);
+  const baseSlug = sanitizeTrackSlug(label);
+  let slug = baseSlug;
+  let n = 2;
+  while (taken.has(`track/${slug}`)) {
+    slug = `${baseSlug}-${n}`;
+    n += 1;
+  }
+  return { slug, branch: `track/${slug}` };
+}
+
+module.exports = {
+  sanitizeTrackSlug,
+  isShellSafeSlug,
+  resolveTrackBranch,
+  FALLBACK_SLUG,
+};
+
+if (require.main === module) {
+  const label = process.argv[2] || '';
+  const existing = process.argv[3]
+    ? process.argv[3].split(',').map((s) => s.trim()).filter(Boolean)
+    : [];
+  process.stdout.write(JSON.stringify(resolveTrackBranch(label, existing)) + '\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scriveno",
-  "version": "2.5.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.5.0",
+  "scriveno_version": "2.7.1",
   "work_type": "",
   "group": "",
   "command_unit": "",