scriveno 2.0.6 → 2.0.8

package/commands/scr/health.md

@@ -7,6 +7,8 @@ argument-hint: "[--repair]"
 
 You are a project health checker. Diagnose problems in the current Scriveno project and optionally fix what can be auto-fixed.
 
+Follow the auto-invoke policy. In the source repository it is documented at `docs/auto-invoke-policy.md`. `/scr:health` is local and diagnostic. It does not spawn agents.
+
 ## Diagnostic mode (default, no flags)
 
 Run these checks in order and report results with status indicators:
@@ -85,6 +87,23 @@ With `--repair`, fix what can be auto-fixed:
 
 After repair: re-run diagnostics and show the updated health report.
 
+## Automation Status
+
+Every response must include a compact status block:
+
+```text
+Automation status:
+Trigger: /scr:health {flags}
+Spawned agents:
+- none
+Local operations:
+- health checks run: {count}
+- repairs applied: {count}
+Auto-invoked:
+- none
+Why: health uses deterministic local checks; non-deterministic repairs stay manual
+```
+
 ## Response Contract
 
 Every writer-facing response must end with one to four next-command suggestions. Each suggestion must include a short explanation of what that path will do.

package/commands/scr/map-manuscript.md

@@ -98,6 +98,8 @@ Spawn 6 parallel analysis agents:
   </agent>
 </analysis_agents>
 
+If the host runtime cannot spawn these named analysis workers in parallel, run each selected analysis in an isolated fresh context sequentially. Report that fallback clearly. These analysis roles are command-local workers, not installed Scriveno agent prompt files.
+
 ### OUTPUT
 
 Save all analysis files to `.manuscript/analysis/`
@@ -110,6 +112,30 @@ Present a summary to the writer showing:
 
 This analysis is automatically loaded by `/scr:new-work` and `/scr:new-revision` when it exists.
 
+## Agent and Automation Status
+
+Every response must include a short status block that makes invocation visible:
+
+```text
+Agent status:
+Trigger: /scr:map-manuscript {area}
+Spawned agents:
+- voice-analyst: yes/no
+- structure-analyst: yes/no
+- character-analyst: yes/no
+- theme-analyst: yes/no
+- world-analyst: yes/no
+- pacing-analyst: yes/no
+Local operations:
+- manuscript files read: {count}
+- analysis files written: {count}
+Auto-invoked:
+- none
+Why: map-manuscript produces analysis artifacts that later commands load when present
+```
+
+If parallel worker spawning is unavailable, say `parallel unavailable; sequential isolated analysis used` in the status block.
+
 ## Response Contract
 
 Every writer-facing response must end with one to four next-command suggestions. Each suggestion must include a short explanation of what that path will do.

package/commands/scr/new-work.md

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

package/commands/scr/next.md

@@ -6,6 +6,19 @@ description: Auto-detect what to do next in your workflow and run it. The one co
 
 You are routing the writer to the right next step in their workflow. This command is the universal interface -- a writer who only ever types `/scr:next` should be able to complete an entire novel.
 
+Follow the auto-invoke policy. In the source repository it is documented at `docs/auto-invoke-policy.md`. `/scr:next` is Level 1 only by default: it may inspect disk state and suggest the safest next command, but it does not spawn agents or mutate files unless autopilot mode explicitly routes into another command.
+
+Use the shared executable engine before falling back to manual inspection. Try the first available path:
+
+```bash
+scriveno status --project "$PWD" --trigger /scr:next
+node lib/auto-invoke-engine.js --project "$PWD" --trigger /scr:next
+node "$HOME/.scriveno/lib/auto-invoke-engine.js" --project "$PWD" --trigger /scr:next
+node .scriveno/lib/auto-invoke-engine.js --project "$PWD" --trigger /scr:next
+```
+
+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 sweep below.
+
 ## What to do
 
 1. **Check for `.manuscript/` directory.** If none, the writer has no project. Run `/scr:new-work` to start one (or tell them to).
@@ -32,6 +45,25 @@ You are routing the writer to the right next step in their workflow. This comman
    - "Chapter 4 has a plan but no draft yet -- drafting it."
    - "You haven't discussed the next chapter -- shaping Chapter 5."
 
+8. **Run the proactive sweep before choosing the final route.** This is read-only unless autopilot mode has already taken over:
+   - Check whether `CONTEXT.md` is missing, stale, or older than STATE.md or the newest draft.
+   - Check whether `HISTORY.log` is missing or the last command failed.
+   - Check whether voice, continuity, editor-review, beta-reader, or translation reports contain unresolved items.
+   - Check whether translation folders, target language config, editor notes, track proposals, stale exports, or unsaved manuscript changes imply a better next command than the linear lifecycle.
+   - Check whether STATE.md and disk disagree enough that `/scr:scan` should be recommended first.
+
+Display a compact proactive block when any signal changes the recommendation:
+
+```text
+Proactive checks:
+  State: <fresh | stale, suggest /scr:scan>
+  Session: <fresh | context stale, suggest /scr:resume-work>
+  Reviews: <none | N pending, suggest review command>
+  Translation: <none | follow-up available>
+  Export: <fresh | stale, suggest /scr:export>
+  Save: <clean | unsaved manuscript changes, suggest /scr:save>
+```
+
 ## Routing logic
 
 Use the core writing lifecycle as the default map:
@@ -93,6 +125,25 @@ Use progressive surfacing rules:
 - **Non-blocking craft question or watchpoint** -- If only `QUESTION: Non-blocking`, `HUNCH`, or `WATCHPOINT` items remain, allow the next draft or review step and mention the watchpoint in one sentence.
 - **Autopilot mode** -- If config has `autopilot.enabled: true`, run multiple steps in sequence without asking, pausing only per the profile's rules (guided, supervised, full-auto).
 
+## Agent and Automation Status
+
+Every `/scr:next` response must include a short status block when it inspected proactive signals or handed off to another command:
+
+```text
+Automation status:
+Trigger: /scr:next
+Spawned agents:
+- none
+Local operations:
+- proactive sweep: read-only
+- state route computed: yes/no
+Auto-invoked:
+- <recommended command>: yes/no
+Why: /scr:next routes from disk state; it only runs follow-up commands under autopilot or explicit writer intent
+```
+
+If autopilot causes `/scr:next` to run another command, the follow-up command must provide its own agent or automation status block.
+
 ## Adaptive naming
 
 Use canonical runnable commands, and adapt the terminology in prompts/output for the current work type. If `command_unit` is `surah`, run `/scr:draft` and frame the work as drafting a surah; keep the command id stable and treat unit labels as presentation only.

package/commands/scr/plan.md

@@ -78,12 +78,34 @@ Require `{N}-CONTEXT.md` to exist (from discuss phase). If it doesn't, offer to
 
 7. **Update STATE.md** and suggest: "Ready to draft? Run `/scr:draft N`." (Suppress the draft suggestion if any plan came back NEEDS REVISION; suggest addressing the flagged items first.)
 
+   If `.manuscript/config.json` has `autopilot.enabled: true`, all plan checks are READY, and the active profile is `full-auto`, immediately proceed to `/scr:draft N` instead of stopping at a suggestion. In `supervised`, pause here and show the plan-check summary before drafting. In `guided`, ask for approval before drafting.
+
 8. **Append one line to `.manuscript/HISTORY.log`** per `docs/history-protocol.md`:
    ```
    {ISO timestamp} | scr:plan | unit={N} | atomic-units={count} | check={READY|N-flagged} | outcome=ok
    ```
    If the run failed, use `outcome=failed:<short-reason>` instead. Create HISTORY.log if it does not exist.
 
+## Agent and Automation Status
+
+Every response must include a short status block that makes invocation visible:
+
+```text
+Agent status:
+Trigger: /scr:plan N
+Spawned agents:
+- plan-checker: {count} fresh-context invocation(s)
+Local operations:
+- plan files written: {count}
+- STATE.md updated: yes/no
+- HISTORY.log updated: yes/no
+Auto-invoked:
+- /scr:draft N: yes/no
+Why: {all plans READY plus full-auto, supervised pause, guided approval needed, or plan check blocked}
+```
+
+If the host runtime cannot spawn a native `plan-checker` agent type, load the installed `agents/plan-checker.md` prompt from the active runtime and run it in an isolated fresh context. In the status block, write `Spawned agents: native unavailable; prompt-run fallback used`.
+
 ## Response Contract
 
 Every writer-facing response must end with one to four next-command suggestions. Each suggestion must include a short explanation of what that path will do.

package/commands/scr/progress.md

@@ -7,6 +7,19 @@ argument-hint: ""
 
 You are showing the writer their current project progress.
 
+Follow the auto-invoke policy. In the source repository it is documented at `docs/auto-invoke-policy.md`. `/scr:progress` is read-only: it can count, compare, and recommend, but it must not spawn agents or write files.
+
+Use the shared executable engine before falling back to manual counts. Try the first available path:
+
+```bash
+scriveno status --project "$PWD" --trigger /scr:progress
+node lib/auto-invoke-engine.js --project "$PWD" --trigger /scr:progress
+node "$HOME/.scriveno/lib/auto-invoke-engine.js" --project "$PWD" --trigger /scr:progress
+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.
+
 ## Prerequisites
 
 - `.manuscript/STATE.md` must exist
@@ -22,6 +35,29 @@ You are showing the writer their current project progress.
    - "{word_count} words so far."
    - "{open_threads} open record threads." (only when RECORD.md exists)
    - "Next: {next_action}"
+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.
+   - If exports are stale, suggest `/scr:export` or `/scr:publish`.
+   - If translation work exists and follow-up reports are missing, suggest the next translation check.
+   - If unsaved manuscript changes exist, suggest `/scr:save`.
+
+## Automation Status
+
+Every response must include a compact status block:
+
+```text
+Automation status:
+Trigger: /scr:progress
+Spawned agents:
+- none
+Local operations:
+- progress counts computed: yes/no
+- proactive sweep: read-only
+Auto-invoked:
+- none
+Why: progress is read-only; it recommends next commands without mutating files
+```
 
 ## Response Contract
 

package/commands/scr/quick-write.md

@@ -43,6 +43,8 @@ If `--discuss`: Ask 3-5 targeted questions about tone, pacing, and purpose for t
 
 If `--research`: Spawn a focused researcher for technique guidance.
 
+If the host runtime cannot spawn a focused researcher, run the research pass in an isolated fresh context and report `prompt-run fallback used` in the status block.
+
 ### STEP 3: DRAFT
 
 Write the passage following all established style guide constraints. Target whatever length feels natural unless the writer specified a target.
@@ -58,6 +60,27 @@ Save plan (if generated) to `.manuscript/quick/{NNN}-{slug}/PLAN.md`
 
 Commit: `quick: {slug}`
 
+## Agent and Automation Status
+
+Every response must include a short status block that makes invocation visible:
+
+```text
+Agent status:
+Trigger: /scr:quick-write {flags}
+Spawned agents:
+- researcher: yes/no
+Local operations:
+- context files loaded: {count}
+- draft file written: yes/no
+- plan file written: yes/no
+Auto-invoked:
+- /scr:continuity-check: yes/no
+- /scr:voice-check: yes/no
+Why: --full runs verification after drafting; --research spawns a focused technique pass
+```
+
+In default mode, report `researcher: none` and both auto-invoked checks as `no`.
+
 ## Response Contract
 
 Every writer-facing response must end with one to four next-command suggestions. Each suggestion must include a short explanation of what that path will do.

package/commands/scr/save.md

@@ -7,6 +7,8 @@ argument-hint: "[optional message]"
 
 You are saving the writer's current work. Your job is to create a git commit with a writer-friendly message, without exposing any git terminology.
 
+Follow the auto-invoke policy. In the source repository it is documented at `docs/auto-invoke-policy.md`. `/scr:save` does not spawn agents. It owns safe local helpers for `STATE.md`, `CONTEXT.md`, and `HISTORY.log`, then saves `.manuscript/`.
+
 ## What to do
 
 1. **Check for `.manuscript/` directory.** If missing: "No manuscript found. Start with `/scr:new-work`."
@@ -69,6 +71,25 @@ You are saving the writer's current work. Your job is to create a git commit wit
 
 10. **Tell the writer** the result (see output section below).
 
+## Automation Status
+
+Every response must include a compact status block:
+
+```text
+Automation status:
+Trigger: /scr:save
+Spawned agents:
+- none
+Local operations:
+- STATE.md updated: yes/no
+- CONTEXT.md regenerated: yes/no
+- HISTORY.log appended: yes/no
+- manuscript files saved: yes/no
+Auto-invoked:
+- /scr:next route computed for CONTEXT.md: yes/no
+Why: save uses deterministic local bookkeeping, not a spawned agent
+```
+
 ## Writer mode output
 
 - **Writer mode** (`developer_mode: false`): "Saved. You can see your save history with `/scr:history`."

package/commands/scr/scan.md

@@ -7,6 +7,8 @@ argument-hint: "[--fix] [--quiet]"
 
 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.
 
+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.
+
 This is the defense against context corruption. A fresh Claude session, a writer who hand-edited files between sessions, an interrupted command, or a partial revert can all leave the project in an internally inconsistent state. STATE.md says 12 units drafted; the disk has 14. OUTLINE.md lists "Chapter 8" but no draft file exists. RECORD.md says a promise is still open but the draft paid it off. STYLE-GUIDE.md was edited yesterday but no voice-check has run since. `/scr:scan` finds those.
 
 This complements `/scr:health` (which fixes structural issues like missing directories) and `/scr:resume-work` (which reads recorded state). `/scr:scan` interrogates whether the recorded state is true.
@@ -261,6 +263,24 @@ After any auto-fix, append a single line to HISTORY.log per `docs/history-protoc
 
 ---
 
+## Automation Status
+
+Every response must include a compact status block:
+
+```text
+Automation status:
+Trigger: /scr:scan {flags}
+Spawned agents:
+- none
+Local operations:
+- drift checks run: {count}
+- auto-fixes applied: {count}
+- HISTORY.log appended: yes/no
+Auto-invoked:
+- none
+Why: scan compares disk state locally; fixes require writer confirmation
+```
+
 ## Response Contract
 
 Every writer-facing response must end with one to four next-command suggestions. Each suggestion must include a short explanation of what that path will do.

package/commands/scr/session-report.md

@@ -7,6 +7,19 @@ argument-hint: ""
 
 You are summarizing the writer's current session. Your job is to compute actionable metrics from STATE.md and present them clearly.
 
+Follow the auto-invoke policy. In the source repository it is documented at `docs/auto-invoke-policy.md`. `/scr:session-report` is read-only and does not spawn agents.
+
+Use the shared executable engine for the read-only status portion before computing session-specific metrics. Try the first available path:
+
+```bash
+scriveno status --project "$PWD" --trigger /scr:session-report
+node lib/auto-invoke-engine.js --project "$PWD" --trigger /scr:session-report
+node "$HOME/.scriveno/lib/auto-invoke-engine.js" --project "$PWD" --trigger /scr:session-report
+node .scriveno/lib/auto-invoke-engine.js --project "$PWD" --trigger /scr:session-report
+```
+
+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, continue with the read-only report logic below.
+
 ## What to do
 
 1. **Read STATE.md "Last actions" table** to get the full history of actions.
@@ -44,6 +57,23 @@ Present the report in this format:
 | 3:15 PM | Editor review complete |
 ```
 
+## Automation Status
+
+Every response must include a compact status block:
+
+```text
+Automation status:
+Trigger: /scr:session-report
+Spawned agents:
+- none
+Local operations:
+- session metrics computed: yes/no
+- quality pass summary computed: yes/no
+Auto-invoked:
+- none
+Why: session-report summarizes disk state without mutating files
+```
+
 ## Edge cases
 
 - **No actions this session:** If the Last actions table is empty or has no entries after the last pause/resume marker, say: "Nothing to report yet. Start working with `/scr:next`."

package/commands/scr/sync.md

@@ -7,10 +7,21 @@ argument-hint: "[--check] [--apply] [--runtime <key>] [--detected] [--global|--p
 
 You are synchronizing Scriveno's installed agent surfaces with the current Scriveno source tree.
 
-This command is for local runtime drift: Codex skills, Codex command mirrors, Claude command files, Cursor command files, and agent prompts that no longer match the source files in the Scriveno package or repo.
+This command is for local runtime drift: Codex skills, Codex command mirrors, Claude Code command files, command-directory runtimes, skills runtimes, guided setup assets, and agent prompts that no longer match the source files in the Scriveno package or repo.
 
 This is not a package upgrade command. Do not fetch a newer Scriveno release, do not change npm dependencies, and do not modify manuscript content. If the writer wants a newer published package version, that belongs to a future `/scr:update` command.
 
+The auto-invoke status engine is a shared runtime asset. It is copied for every install target and can be checked with one of these paths:
+
+```bash
+scriveno status --project "$PWD" --trigger /scr:sync
+node lib/auto-invoke-engine.js --project "$PWD" --trigger /scr:sync
+node "$HOME/.scriveno/lib/auto-invoke-engine.js" --project "$PWD" --trigger /scr:sync
+node .scriveno/lib/auto-invoke-engine.js --project "$PWD" --trigger /scr:sync
+```
+
+Use it for read-only project status and next-command reasoning. Use `bin/install.js` for runtime file synchronization.
+
 ## Prerequisites
 
 - Node.js >=20.0.0
@@ -47,9 +58,15 @@ If you cannot find a Scriveno source root, stop and explain that `/scr:sync` nee
      - GitHub Copilot: `~/.github/commands/scr/`, `~/.github/agents/`
      - Windsurf: `~/.windsurf/commands/scr/`, `~/.windsurf/agents/`
      - Antigravity: `~/.gemini/antigravity/commands/scr/`, `~/.gemini/antigravity/agents/`
+     - Manus Desktop: `~/.manus/skills/scriveno/SKILL.md` plus mirrored `commands/scr/` and `agents/` inside that skill bundle
+     - Perplexity Desktop: `~/.scriveno/perplexity/SETUP.md` and `connector-command.txt`
+     - Generic skills fallback: `~/.scriveno/skills/SKILL.md` plus mirrored `commands/scr/` and `agents/`
 4. Compare source files against installed files:
    - Compare command counts.
    - Compare a representative hash set for `commands/scr/autopilot.md`, `commands/scr/next.md`, `commands/scr/scan.md`, `commands/scr/sync.md`, and all generated Codex `SKILL.md` wrappers when present.
+   - Check that Claude Code flat commands include `/scr-*` invocation rewrites and source-marker behavior after reinstall.
+   - Check that standard command-directory runtimes preserve nested command paths under their `commands/scr/` directory.
+   - Check that skills runtimes include `SKILL.md`, mirrored commands, and mirrored agent prompts inside their skill bundle.
    - Check that installed Codex commands include current response-contract and source-marker behavior after reinstall.
    - Report each runtime as `current`, `stale`, `missing`, or `unknown`.
 5. Decide mode:
@@ -70,15 +87,57 @@ Adjust flags from the command arguments:
 7. After applying, verify:
    - Re-read installed command counts.
    - Confirm `sync.md` is installed for each target runtime.
+   - For Claude Code, confirm `scr-sync.md` exists and installed agent prompts are present in the chosen `agents/` directory.
+   - For standard command-directory runtimes, confirm `commands/scr/sync.md` and installed agent prompts are present.
+   - For skills runtimes, confirm `SKILL.md`, `commands/scr/sync.md`, and bundled agent prompts are present.
+   - For Perplexity Desktop, confirm the setup guide and connector recipe are present.
    - For Codex, confirm both `~/.codex/commands/scr/sync.md` and `~/.codex/skills/scr-sync/SKILL.md` exist in the chosen scope.
+   - For Codex, confirm installed Scriveno agents have matching `.toml` metadata files in the chosen `agents/` directory when the Codex runtime supports agent metadata.
    - Confirm no stale runtime files remain in the checked target set.
-8. Report:
+8. Report a compact sync status trail:
    - Source version
    - Runtime targets checked
    - Runtime targets updated
    - Any skipped targets and why
+   - Trigger: `check`, `apply`, or `prompted apply`
+   - Agent: `none` for this command
+   - Engine: `bin/install.js` when applying, or `hash/count comparison` when checking only
+   - Local operations: command files compared, Claude flat commands checked, standard command directories checked, skills manifests checked, guided setup assets checked, agent prompts checked, Codex skills checked, Codex command mirrors checked, Codex agent metadata checked when applicable
+   - Result counts: commands, skills, agent prompts, metadata files, stale files removed, and skipped targets
    - Suggested project-level follow-up with `/scr:scan`
 
+Use this report shape:
+
+```text
+Sync status:
+Trigger: /scr:sync --apply --detected --global --developer
+Agent: none
+Why: runtime sync is installer-driven, not a writing or review agent task
+Engine: bin/install.js
+Checked:
+- commands: 112 source, 112 installed
+- Claude Code flat commands: 112 installed
+- standard command directories: current
+- skills manifests: current
+- guided setup assets: current
+- Codex skills: 112 installed
+- agent prompts: 6 installed
+- Codex agent metadata: 6 installed
+Updated:
+- Claude Code command files
+- standard command directories
+- skills manifests
+- guided setup assets
+- Codex command mirrors
+- Codex skills
+- Codex agent prompts
+- Codex agent metadata
+Skipped:
+- none
+```
+
+If no files were changed, keep the same shape and set `Updated: none`. If an agent was not spawned, always say `Agent: none` and explain why.
+
 ## Safety Rules
 
 - Only overwrite Scriveno-owned installed runtime files.

package/commands/scr/track.md

@@ -494,6 +494,26 @@ For standard revision tracks where only the track has changes (canon is unmodifi
 
 The `.manuscript/merge-log.json` file accumulates entries from every co-writing merge. Each entry preserves both versions of contradictory passages, the resolution chosen, and any reconciled text. This provides a history of how parallel work was integrated and supports future continuity auditing.
 
+### Automation Status
+
+Every `track merge` response must include a compact status block:
+
+```text
+Automation status:
+Trigger: /scr:track merge {track}
+Auto-invoked:
+- /scr:continuity-check equivalent: yes/no
+Spawned agents:
+- continuity-checker: yes/no
+Local operations:
+- track metadata checked: yes/no
+- canon and track changes compared: yes/no
+- merge log updated: yes/no
+Why: co-writing or parallel canon changes require continuity verification before accepting revisions
+```
+
+If continuity verification did not run, say why: standard revision track, canon unchanged, or writer cancelled before merge. If native `continuity-checker` spawning is unavailable, use the installed prompt in an isolated fresh context and report `prompt-run fallback used`.
+
 ---
 
 ## Writer-Friendly Language Guide

package/commands/scr/translate.md

@@ -171,6 +171,8 @@ Invoke the translator agent (`agents/translator.md`) with fresh context, providi
 
 **Fresh context per unit is mandatory.** Each translator invocation is independent -- this prevents translation drift, glossary inconsistency, and register collapse across a long manuscript.
 
+If the host runtime cannot spawn a native `translator` agent type, load the installed `agents/translator.md` prompt from the active runtime and run it in an isolated fresh context. Record that fallback in the status block.
+
 **5d. Post-unit processing:**
 
 After each unit translation:
@@ -214,6 +216,29 @@ After all units are translated, show a summary:
 > - Back-translate to verify: `/scr:back-translate [lang]`
 > - Export translation: `/scr:export --format [format] --language [lang]`
 
+## Agent and Automation Status
+
+Every response must include a short status block that makes invocation visible:
+
+```text
+Agent status:
+Trigger: /scr:translate {language}
+Spawned agents:
+- translator: {count} fresh-context invocation(s)
+Local operations:
+- glossary loaded: yes/no
+- translation memory loaded: yes/no
+- units written: {count}
+- new glossary terms flagged: {count}
+Auto-invoked:
+- /scr:translation-memory {language} --build: yes/no
+- /scr:cultural-adaptation {language}: yes/no
+- /scr:back-translate {language}: yes/no
+Why: {manual translation mode, autopilot-translate phase, or writer requested chained verification}
+```
+
+Plain `/scr:translate` does not auto-run translation memory, cultural adaptation, or back-translation unless the writer requested a chained verification or the command is being run inside `/scr:autopilot-translate`. Show `Auto-invoked: no` for those follow-up checks in manual mode.
+
 ## Response Contract
 
 Every writer-facing response must end with one to four next-command suggestions. Each suggestion must include a short explanation of what that path will do.

package/commands/scr/voice-check.md

@@ -45,6 +45,8 @@ Spawn the voice-checker agent (`agents/voice-checker.md`) with:
 - The scoped drafted prose (unit `N` or all units)
 - If available, previously approved units as reference anchors for comparison
 
+If the host runtime cannot spawn a native `voice-checker` agent type, load the installed `agents/voice-checker.md` prompt from the active runtime and run it in an isolated fresh context. Record that fallback in the status block.
+
 Because STYLE-GUIDE.md is present, this is voice-deviation framing: the agent measures deviation *from* the writer's voice, not against a generic ideal. An authentic writer habit is not a tell for that writer even when a generic catalog would flag it; STYLE-GUIDE.md wins.
 
 The voice-checker agent runs its diagnostic discipline: a scrutiny pre-check (match scrutiny to evidence density; low density biases hard toward a high score), a mandatory false-positive audit with veto power (lone weak signals dropped without lowering the score; strong false positives reclassified as human markers that raise it), and an internal-consistency check (sharp register or sophistication seams flagged against the document's own baseline). It performs deep analysis across four dimensions:
@@ -109,6 +111,24 @@ Save the full report to `.manuscript/{scope}-VOICE-CHECK-REPORT.md` where `{scop
 
 Present the score, status, and top issues to the writer. Offer to show the full report.
 
+## Agent Status
+
+Every response must include a short status block that makes invocation visible:
+
+```text
+Agent status:
+Trigger: /scr:voice-check {scope}
+Spawned agents:
+- voice-checker: 1 fresh-context diagnostic invocation
+Local operations:
+- STYLE-GUIDE.md loaded: yes/no
+- drafted files checked: {count}
+- report written: yes/no
+Auto-invoked:
+- none
+Why: voice-check is diagnostic only; fixes are writer-chosen handoffs
+```
+
 ## Response Contract
 
 Every writer-facing response must end with one to four next-command suggestions. Each suggestion must include a short explanation of what that path will do.

package/data/CONSTRAINTS.json

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

package/docs/architecture.md

@@ -349,6 +349,12 @@ Codex uses a skill-native variation of this strategy. The installer generates on
 
 **Guided local-MCP (type: `guided-mcp`).** Writes setup assets and connector recipes for runtimes that expose a documented local-MCP surface instead of a writable slash-command directory. Perplexity Desktop currently fits this model: Scriveno writes a setup guide and filesystem-server command recipe under `.scriveno/perplexity/`, and the user adds that command inside Perplexity Desktop's Connectors UI.
 
+### Shared status engine
+
+Scriveno also ships `lib/auto-invoke-engine.js`, exposed through `scriveno status --project .` and `scriveno status . --json`. The installer copies this library into the shared Scriveno asset directory for global and project installs, so command surfaces can call a single read-only status engine before falling back to embedded markdown logic.
+
+The engine checks disk evidence only: project presence, STATE.md, CONTEXT.md freshness, review files, translation work, 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.
+
 ### Installation modes
 
 The installer supports two scopes:
@@ -360,7 +366,7 @@ The user chooses during installation. Guided local-MCP targets still write their
 
 ### Runtime credibility
 
-Scriveno's installer compatibility floor is `Node.js >=20.0.0`. For new installs, prefer a currently supported LTS such as Node.js 24. The compatibility floor applies to `npx scriveno@latest`, `bin/install.js`, and the repo's JavaScript test suite, not to the markdown command system once files are installed.
+Scriveno's installer compatibility floor is `Node.js >=20.0.0`. For new installs, prefer a currently supported LTS such as Node.js 24. The compatibility floor applies to `npx scriveno@latest`, `bin/install.js`, `scriveno status --project .`, the shared status engine, and the repo's JavaScript test suite, not to the markdown command system once files are installed.
 
 This architecture doc is intentionally about mechanics: detection rules, install path shapes, `commands` versus `skills` versus `guided-mcp`, and global versus project scope. For the authoritative runtime matrix, support levels, and verification status, see [`docs/runtime-support.md`](runtime-support.md).