scriveno 2.0.5 → 2.0.7

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.0.5-blue)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-2.0.7-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)
 
@@ -203,11 +203,11 @@ Scriveno currently ships installer targets for these AI tooling environments:
 
 ## Status
 
-**Version:** 2.0.5
+**Version:** 2.0.7
 
- Scriveno's core command surface is stable across 112 commands, 50 work types, and 11 installer targets. The current repo baseline includes shipped planning milestones through `v2.0 Publishing Cover Packaging`, plus the creative-context, record-store, branching-next, runtime-sync, adaptive concierge, human-first writing-safeguard, authenticity-diagnostic, and domain-grilling work through `2.0.5`. See [Shipped Assets](docs/shipped-assets.md) for the canonical asset inventory and [Runtime Support](docs/runtime-support.md) for the runtime compatibility matrix.
+ Scriveno's core command surface is stable across 112 commands, 50 work types, and 11 installer targets. The current repo baseline includes shipped planning milestones through `v2.0 Publishing Cover Packaging`, plus the creative-context, record-store, branching-next, runtime-sync, adaptive concierge, human-first writing-safeguard, authenticity-diagnostic, domain-grilling, installer-marker cleanup, cross-runtime agent metadata, and proactive auto-invoke visibility work through `2.0.7`. See [Shipped Assets](docs/shipped-assets.md) for the canonical asset inventory and [Runtime Support](docs/runtime-support.md) for the runtime compatibility matrix.
 
- Version `2.0.5` publishes Scriveno under the package name `scriveno`, so the current install command is `npx scriveno@latest`. The older `scriveno-cli` package name remains historical; new docs and package metadata now point at `scriveno`. See [CHANGELOG](CHANGELOG.md) for the full list and [docs/release-notes.md](docs/release-notes.md) for the public-facing summary.
+ Version `2.0.7` 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/bin/install.js

@@ -155,6 +155,7 @@ const RUNTIMES = {
     agents_dir_global: path.join(os.homedir(), '.codex', 'agents'),
     agents_dir_project: '.codex/agents',
     skill_style: 'per-command',
+    agent_metadata: 'toml',
     detect: () => fs.existsSync(path.join(os.homedir(), '.codex')),
   },
   'opencode': {
@@ -414,6 +415,58 @@ function collectCommandEntries(commandsRoot) {
   return entries;
 }
 
+function stripMarkdownFrontmatter(content) {
+  if (typeof content !== 'string' || content.length === 0) return '';
+  const stripped = content.charCodeAt(0) === 0xFEFF ? content.slice(1) : content;
+  const lines = stripped.split(/\r?\n/);
+  if (lines[0] !== '---') return stripped;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i] === '---' || lines[i] === '...') {
+      return lines.slice(i + 1).join('\n').replace(/^\n/, '');
+    }
+  }
+  return stripped;
+}
+
+function collectAgentEntries(agentsRoot = path.join(PKG_ROOT, 'agents')) {
+  if (!fs.existsSync(agentsRoot)) return [];
+  const entries = [];
+  for (const entry of fs.readdirSync(agentsRoot, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+    const relativePath = entry.name;
+    const filePath = path.join(agentsRoot, relativePath);
+    const content = fs.readFileSync(filePath, 'utf8');
+    const stem = entry.name.replace(/\.md$/, '');
+    const frontmatter = readFrontmatterValues(content);
+    const name = frontmatter.name || stem;
+    const description = frontmatter.description || `${stem.replace(/-/g, ' ')} agent`;
+    entries.push({
+      name,
+      description,
+      relativePath,
+      metadataFileName: `${name}.toml`,
+      content,
+      body: stripMarkdownFrontmatter(content),
+    });
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  return entries;
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value));
+}
+
+function generateCodexAgentMetadata(entry) {
+  return [
+    `name = ${tomlString(entry.name)}`,
+    `description = ${tomlString(entry.description)}`,
+    'sandbox_mode = "workspace-write"',
+    `developer_instructions = ${tomlString(entry.body)}`,
+    '',
+  ].join('\n');
+}
+
 // Both Claude (flat scr-foo.md filename) and Codex (per-command skill dir
 // scr-foo/SKILL.md) install commands keyed by the same skill-name function:
 // /scr:foo and /scr:foo:bar both flatten under commandRefToCodexSkillName by
@@ -686,7 +739,7 @@ function rewriteInstalledCommandRefs(content, transform) {
 }
 
 function markInstalledCommand(content, runtimeKey, commandRef, sourcePath) {
-  const marker = `<!-- scriveno-cli-installed-command runtime:${runtimeKey} command:${commandRef} source:${sourcePath} -->`;
+  const marker = `<!-- scriveno-installed-command runtime:${runtimeKey} command:${commandRef} source:${sourcePath} -->`;
   return insertMarkerComment(content, marker);
 }
 
@@ -708,7 +761,7 @@ function generateCodexCommandContent(entry, sourceContent) {
 function isScrivenoInstalledCommandFile(filePath) {
   if (!fs.existsSync(filePath)) return false;
   const content = fs.readFileSync(filePath, 'utf8');
-  return content.includes('scriveno-cli-installed-command');
+  return content.includes('scriveno-installed-command') || content.includes('scriveno-cli-installed-command');
 }
 
 function cleanFlatCommandFiles(commandsDir, currentFileNames, legacyDirs = []) {
@@ -754,7 +807,7 @@ function cleanFlatCommandFiles(commandsDir, currentFileNames, legacyDirs = []) {
 function writeInstalledCommandManifest(commandsDir, runtimeKey, fileNames) {
   const manifestPath = path.join(commandsDir, '.scriveno-installed.json');
   const manifest = {
-    installer: 'scriveno-cli',
+    installer: 'scriveno',
     version: VERSION,
     runtime: runtimeKey,
     files: fileNames,
@@ -1194,7 +1247,7 @@ function cleanCodexSkillDirs(skillsDir, currentSkillNames) {
 function writeCodexSkillManifest(skillsDir, skillNames) {
   const manifestPath = path.join(skillsDir, '.scriveno-installed.json');
   const manifest = {
-    installer: 'scriveno-cli',
+    installer: 'scriveno',
     version: VERSION,
     skills: skillNames,
     generated_at: new Date().toISOString(),
@@ -1202,6 +1255,64 @@ function writeCodexSkillManifest(skillsDir, skillNames) {
   atomicWriteFileSync(manifestPath, JSON.stringify(manifest, null, 2));
 }
 
+function isScrivenoCodexAgentMetadataFile(filePath) {
+  if (!fs.existsSync(filePath)) return false;
+  const content = fs.readFileSync(filePath, 'utf8');
+  return content.includes('developer_instructions = ') && (
+    content.includes('# Drafter agent')
+    || content.includes('# Voice checker agent')
+    || content.includes('# Continuity checker agent')
+    || content.includes('# Plan checker agent')
+    || content.includes('# Researcher agent')
+    || content.includes('# Translator agent')
+  );
+}
+
+function cleanCodexAgentFiles(agentsDir, currentFileNames) {
+  if (!fs.existsSync(agentsDir)) return 0;
+
+  const manifestPath = path.join(agentsDir, '.scriveno-agents-installed.json');
+  const manifest = readJsonIfExists(manifestPath);
+  const currentFileSet = new Set(currentFileNames);
+  const knownFileNames = new Set(Array.isArray(manifest?.files) ? manifest.files : []);
+
+  for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith('.toml')) continue;
+    const filePath = path.join(agentsDir, entry.name);
+    if (isScrivenoCodexAgentMetadataFile(filePath)) {
+      knownFileNames.add(entry.name);
+    }
+  }
+
+  removePathIfExists(manifestPath);
+
+  let removed = 0;
+  for (const fileName of knownFileNames) {
+    if (!currentFileSet.has(fileName) && removePathIfExists(path.join(agentsDir, fileName))) {
+      removed++;
+    }
+  }
+
+  for (const fileName of currentFileNames) {
+    if (removePathIfExists(path.join(agentsDir, fileName))) {
+      removed++;
+    }
+  }
+
+  return removed;
+}
+
+function writeCodexAgentManifest(agentsDir, fileNames) {
+  const manifestPath = path.join(agentsDir, '.scriveno-agents-installed.json');
+  const manifest = {
+    installer: 'scriveno',
+    version: VERSION,
+    files: fileNames,
+    generated_at: new Date().toISOString(),
+  };
+  atomicWriteFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+}
+
 async function main() {
   const parsed = parseArgs(process.argv.slice(2));
   if (parsed.showHelp) {
@@ -1342,6 +1453,26 @@ function installManifestSkillRuntime(runtime, isGlobal, log) {
   log(`  ${c('green', 'OK')} ${runtime.label}: ${agentCount} agent prompts -> ${c('dim', path.join(skillsDir, 'agents'))}`);
 }
 
+function installCodexAgentsWithMetadata(agentsDir) {
+  const agentEntries = collectAgentEntries(path.join(PKG_ROOT, 'agents'));
+  const currentFileNames = agentEntries.flatMap((entry) => [entry.relativePath, entry.metadataFileName]);
+
+  fs.mkdirSync(agentsDir, { recursive: true });
+  const removed = cleanCodexAgentFiles(agentsDir, currentFileNames);
+
+  for (const entry of agentEntries) {
+    atomicWriteFileSync(path.join(agentsDir, entry.relativePath), entry.content);
+    atomicWriteFileSync(path.join(agentsDir, entry.metadataFileName), generateCodexAgentMetadata(entry));
+  }
+  writeCodexAgentManifest(agentsDir, currentFileNames);
+
+  return {
+    agentCount: agentEntries.length,
+    metadataCount: agentEntries.length,
+    removed,
+  };
+}
+
 function installCodexRuntime(runtime, isGlobal, log) {
   const skillsDir = isGlobal ? runtime.skills_dir_global : path.resolve(runtime.skills_dir_project);
   const commandsDir = isGlobal ? runtime.commands_dir_global : path.resolve(runtime.commands_dir_project);
@@ -1355,7 +1486,6 @@ function installCodexRuntime(runtime, isGlobal, log) {
   removePathIfExists(commandsDir);
   fs.mkdirSync(skillsDir, { recursive: true });
   const removedSkillDirs = cleanCodexSkillDirs(skillsDir, skillNames);
-  const removedAgentFiles = cleanMirroredFiles(path.join(PKG_ROOT, 'agents'), agentsDir);
 
   // NOTE: `collectCommandEntries` returns .md files only, and the authoritative
   // `commands/scr/**` tree is .md-only today. No non-.md assets need mirroring.
@@ -1373,7 +1503,7 @@ function installCodexRuntime(runtime, isGlobal, log) {
     commandCount++;
   }
 
-  const agentCount = copyDir(path.join(PKG_ROOT, 'agents'), agentsDir);
+  const agentInstall = installCodexAgentsWithMetadata(agentsDir);
 
   for (const entry of commandEntries) {
     const skillDir = path.join(skillsDir, entry.skillName);
@@ -1385,7 +1515,7 @@ function installCodexRuntime(runtime, isGlobal, log) {
 
   log(`  ${c('green', 'OK')} ${runtime.label}: ${commandEntries.length} \$scr-* skills -> ${c('dim', skillsDir)}${removedSkillDirs ? c('dim', ` (cleaned ${removedSkillDirs} stale dirs)`) : ''}`);
   log(`  ${c('green', 'OK')} ${runtime.label}: ${commandCount} command files -> ${c('dim', commandsDir)}`);
-  log(`  ${c('green', 'OK')} ${runtime.label}: ${agentCount} agent prompts -> ${c('dim', agentsDir)}${removedAgentFiles ? c('dim', ` (cleaned ${removedAgentFiles} stale files)`) : ''}`);
+  log(`  ${c('green', 'OK')} ${runtime.label}: ${agentInstall.agentCount} agent prompts + ${agentInstall.metadataCount} metadata files -> ${c('dim', agentsDir)}${agentInstall.removed ? c('dim', ` (cleaned ${agentInstall.removed} stale files)`) : ''}`);
 }
 
 function installGuidedRuntime(runtime, isGlobal, dataDir, log) {
@@ -1577,16 +1707,23 @@ module.exports = {
   parseArgs,
   resolveInstallRequest,
   collectCommandEntries,
+  collectAgentEntries,
   assertNoSkillNameCollisions,
   cleanCodexSkillDirs,
+  cleanCodexAgentFiles,
   commandRefToCodexSkillName,
   commandRefToClaudeInvocation,
   commandRefToCodexInvocation,
   commandEntryToFlatCommandFileName,
   generateClaudeCommandContent,
   generateCodexCommandContent,
+  generateCodexAgentMetadata,
   rewriteInstalledCommandRefs,
+  installCommandRuntime,
+  installClaudeCommandRuntime,
+  installManifestSkillRuntime,
   installCodexRuntime,
+  installCodexAgentsWithMetadata,
   cleanFlatCommandFiles,
   generateCodexSkill,
   generateSkillManifest,

package/commands/scr/autopilot-publish.md

@@ -182,6 +182,34 @@ If any steps failed, show them in the "Errors" section with actionable fix instr
 
 ---
 
+## Automation Status
+
+Every progress update and final response must include a compact status trail. This is how the writer can tell whether Scriveno auto-chained commands, spawned agents, or only updated local files.
+
+```text
+Automation status:
+Trigger: /scr:autopilot-publish --preset {preset}
+Auto-invoked commands:
+- /scr:voice-check: yes/no
+- /scr:continuity-check: yes/no
+- /scr:front-matter: yes/no
+- /scr:back-matter: yes/no
+- /scr:cover-art: yes/no
+- /scr:export: {count} run(s)
+Spawned agents:
+- voice-checker: {count}
+- continuity-checker: {count}
+Local operations:
+- prerequisite scan: yes/no
+- quality report files written: yes/no
+- export package files written: {count}
+Quality gate:
+- status: warn-only
+- reason: autopilot-publish reports quality findings but continues to export
+```
+
+If a quality command cannot spawn its native agent type, use the installed agent prompt in a fresh context and say `prompt-run fallback 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/autopilot-translate.md

@@ -213,6 +213,35 @@ Next Steps:
 - **NEVER** continue past a blocking error without logging it -- all errors must appear in the completion summary
 - **NEVER** modify the source manuscript -- translation works on copies in `.manuscript/translation/{lang}/`
 
+## Automation Status
+
+Every progress update and final response must include a compact status trail. This is how the writer can tell whether Scriveno auto-chained commands, spawned agents, or only updated local files.
+
+```text
+Automation status:
+Trigger: /scr:autopilot-translate {languages}
+Languages: {count}
+Auto-invoked commands per language:
+- /scr:translation-glossary: yes/no
+- /scr:translate: yes/no
+- /scr:translation-memory --build: yes/no
+- /scr:cultural-adaptation: yes/no
+- /scr:back-translate: yes/no
+- /scr:multi-publish: yes/no
+Spawned agents:
+- translator: {count} fresh-context invocation(s)
+Local operations:
+- glossary files written: {count}
+- translation memory files updated: {count}
+- adaptation reports written: {count}
+- export files written: {count}
+Pause:
+- status: none/blocking-error/writer-requested
+- reason: {one sentence}
+```
+
+If the translator native agent type is unavailable, use the installed `agents/translator.md` prompt in a fresh context per unit and say `prompt-run fallback 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/autopilot.md

@@ -147,6 +147,35 @@ On pause or stop:
 2. Include what was just completed and what the next action would be
 3. Record the writer's notes if they provide any
 
+## Automation Status
+
+Every progress update and final response must include a compact status trail. This is how the writer can tell whether Scriveno auto-chained commands, spawned agents, or only updated local files.
+
+```text
+Automation status:
+Trigger: /scr:autopilot --profile {profile}
+Profile: guided/supervised/full-auto
+Auto-invoked commands:
+- /scr:discuss N: yes/no
+- /scr:plan N: yes/no
+- /scr:draft N: yes/no
+- /scr:editor-review N: yes/no
+- /scr:submit N: yes/no
+Spawned agents:
+- plan-checker: {count}
+- drafter: {count}
+- voice-checker: {count}
+- continuity-checker: {count}
+Local operations:
+- STATE.md updated: yes/no
+- HISTORY.log updated: yes/no
+Pause:
+- status: none/guided/supervised/quality-gate/blocker
+- reason: {one sentence}
+```
+
+If a command in the chain runs local file operations only, say so under `Local operations` rather than listing it as a spawned agent. If a native agent type is unavailable and an installed prompt-run fallback is used, include that in `Spawned agents`.
+
 ## 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/beta-reader.md

@@ -67,12 +67,34 @@ Load `.manuscript/config.json` to get `work_type`. Load Scriveno's installed/sha
   </task>
 </beta_reader_agent>
 
+If the host runtime cannot spawn a beta reader worker, run the beta reader persona in an isolated fresh context. Report that fallback in the status block.
+
 ### OUTPUT
 
 Save to `.manuscript/{act_num}-BETA-READER-NOTES.md`
 
 Present findings conversationally to the writer -- this should feel like getting feedback from a trusted reader, not a technical report.
 
+## Agent Status
+
+Every response must include a short status block that makes invocation visible:
+
+```text
+Agent status:
+Trigger: /scr:beta-reader {scope}
+Spawned agents:
+- beta-reader: 1 fresh-context reader invocation
+Local operations:
+- drafted files checked: {count}
+- focus area applied: yes/no
+- report written: yes/no
+Auto-invoked:
+- none
+Why: beta-reader is experiential feedback only; revision remains a writer decision
+```
+
+If native worker spawning is unavailable, say `prompt-run fallback 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/continuity-check.md

@@ -27,6 +27,8 @@ Invoke the installed `continuity-checker.md` agent for the writer's active Scriv
 - DOCTRINES.md, LINEAGES.md, and CHRONOLOGY.md when present (sacred only)
 - The previous continuity report if one exists, so the agent can verify resolved issues stayed resolved instead of re-flagging them
 
+If the host runtime cannot spawn a native `continuity-checker` agent type, load the installed `agents/continuity-checker.md` prompt from the active runtime and run it in an isolated fresh context. Record that fallback in the status block.
+
 The agent reads all drafted scenes and checks:
 
 If RECORD.md contradicts the drafted text, flag the mismatch as a RECORD drift finding. If the drafted text reveals established facts or open threads that are missing from RECORD.md, list compact suggested updates under a "Record updates" section without rewriting the file unless the writer asked for fixes.
@@ -105,6 +107,25 @@ For each issue:
 
 Save to `.manuscript/{act_num}-CONTINUITY-REPORT.md` or `.manuscript/FULL-CONTINUITY-REPORT.md`. For technical work types, use `CONSISTENCY-REPORT` in the writer-facing title even if the file path stays the same.
 
+## Agent Status
+
+Every response must include a short status block that makes invocation visible:
+
+```text
+Agent status:
+Trigger: /scr:continuity-check {scope}
+Spawned agents:
+- continuity-checker: 1 fresh-context diagnostic invocation
+Local operations:
+- drafted files checked: {count}
+- RECORD.md checked: yes/no
+- prior report checked: yes/no
+- report written: yes/no
+Auto-invoked:
+- none
+Why: continuity-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/commands/scr/draft.md

@@ -53,6 +53,27 @@ Require `.manuscript/plans/{N}-*-PLAN.md` files to exist. If none exist, also ch
 
 8. **Tell the writer:** "Drafted {unit} {N}: X words across Y {atomic_units}. Voice consistency: Z%. Updated RECORD.md with what the draft established. Ready for editor review? Run `/scr:editor-review N` or `/scr:next`."
 
+## Agent and Automation Status
+
+Every response must include a short status block that makes invocation visible:
+
+```text
+Agent status:
+Trigger: /scr:draft N
+Spawned agents:
+- drafter: {count} fresh-context invocation(s)
+- voice-checker: 1 diagnostic pass, or none if no draft was produced
+Local operations:
+- draft files written: {count}
+- RECORD.md updated: yes/no
+- STATE.md updated: yes/no
+Auto-invoked:
+- /scr:editor-review N: yes/no
+Why: {autopilot.enabled true, full-auto profile, supervised pause, or writer-facing manual mode}
+```
+
+If the host runtime cannot spawn a native `drafter` or `voice-checker` agent type, load the installed agent prompt from the active runtime's `agents/` directory and run it in an isolated fresh context. In the status block, write `Spawned agents: native unavailable; prompt-run fallback used` so the writer can see what happened.
+
 ## History log
 
 After all atomic units in this invocation are drafted, append one line to `.manuscript/HISTORY.log` per `docs/history-protocol.md`:

package/commands/scr/editor-review.md

@@ -101,6 +101,8 @@ For any issues flagged, spawn a diagnostic agent:
   </task>
 </diagnostic_agent>
 
+If the host runtime cannot spawn a dedicated diagnostic worker, run the revision diagnosis in an isolated fresh context for each flagged issue group. Report that fallback in the status block.
+
 ---
 
 ### STEP 4: GENERATE EDITOR NOTES
@@ -408,6 +410,30 @@ Together these form a complete accountability trail. Neither party's work is los
 
 ---
 
+## Agent and Automation Status
+
+Every response must include a short status block that makes invocation visible:
+
+```text
+Agent status:
+Trigger: /scr:editor-review {mode}
+Spawned agents:
+- revision-diagnostic: {count} fresh-context invocation(s)
+Local operations:
+- reviewable units checked: {count}
+- review report written: yes/no
+- proposal decisions written: yes/no
+- editor notes written: yes/no
+- writer responses written: yes/no
+Auto-invoked:
+- none
+Why: editor-review surfaces decisions and recommended handoffs; it does not revise prose without writer choice
+```
+
+If there were no flagged issues in standard review mode, report `revision-diagnostic: none`. In collaboration modes, report `revision-diagnostic: none` unless diagnosis was explicitly requested.
+
+---
+
 ## Writer-Friendly Language Guide
 
 This command uses writer-friendly terminology throughout:

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

package/commands/scr/next.md

@@ -6,6 +6,8 @@ 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.
+
 ## 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 +34,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 +114,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.