scriveno 2.0.6 → 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.6-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.6
+**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, domain-grilling, and installer-marker cleanup work through `2.0.6`. 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.6` publishes Scriveno under the package name `scriveno`, so the current install command is `npx scriveno@latest`. The older `scriveno-cli` package name is historical and was unpublished during the rename, so npm cannot attach a deprecation notice to it while it has no active registry record. The older `scriven-cli` package remains on npm only as a deprecated legacy name that points users to `scriveno`. Do not treat either legacy package name as active unless a deliberate compatibility shim is republished. See [CHANGELOG](CHANGELOG.md) for the full list and [docs/release-notes.md](docs/release-notes.md) for the public-facing summary.
+ Version `2.0.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
@@ -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.6",
+  "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.

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,8 @@ 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.
+
 ## Prerequisites
 
 - `.manuscript/STATE.md` must exist
@@ -22,6 +24,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,8 @@ 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.
+
 ## What to do
 
 1. **Read STATE.md "Last actions" table** to get the full history of actions.
@@ -44,6 +46,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,7 +7,7 @@ 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.
 
@@ -47,9 +47,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 +76,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.7",
   "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/auto-invoke-policy.md

@@ -0,0 +1,100 @@
+# Auto-Invoke Policy
+
+Scriveno can be proactive, but it must be proactive from disk evidence. Commands should inspect `.manuscript/`, reports, timestamps, config, and installed runtime surfaces before choosing an automatic helper.
+
+## Cross-Platform Agent Rules
+
+Scriveno agent prompts live in `agents/*.md`. Each host runtime exposes them differently:
+
+- Claude Code installs command files in `~/.claude/commands/` and agent prompts in `~/.claude/agents/`.
+- Codex installs `$scr-*` skills, mirrored command files, agent prompts, and `.toml` metadata so Codex can expose agent types.
+- Cursor, Gemini CLI, OpenCode, Copilot, Windsurf, and Antigravity install nested command directories and agent prompts in their runtime-specific agent directories.
+- Manus and the generic skill runtime bundle `SKILL.md`, commands, and agents inside the skill directory.
+
+When a host supports native fresh-context spawning, use the native agent or subagent mechanism. When it does not, load the installed agent prompt from the active runtime and run it in an isolated fresh context. When the action is only a file operation, report `Agent: none`.
+
+Every automatic path must make the distinction visible.
+
+```text
+Agent status:
+Trigger: <command or state condition>
+Spawned agents:
+- <agent-name>: <count, none, or prompt-run fallback used>
+Local operations:
+- <operation>: <result>
+Auto-invoked:
+- <command or helper>: yes/no
+Why: <one sentence tied to disk state>
+```
+
+Use `Automation status:` for command chains and `Sync status:` for runtime install or sync checks.
+
+## Levels
+
+| Level | Behavior | Default | Examples |
+|-------|----------|---------|----------|
+| 1 | Read-only suggestion | Run by default | `/scr:next` route, progress sweep, review queue surfacing |
+| 2 | Safe local helper | Run when directly triggered | `CONTEXT.md` regeneration, `HISTORY.log` append, scan report, stats count |
+| 3 | Scoped agent | Spawn when the command implies it or evidence is bounded | drafter, plan-checker, voice-checker, continuity-checker, translator, beta-reader |
+| 4 | Writer-owned action | Require confirmation | publishing, destructive edits, merge decisions, accepting review findings |
+
+## Level 1: Auto-Suggest
+
+Run these read-only checks in `/scr:next`, `/scr:progress`, and closeouts for major commands:
+
+- If `STATE.md`, `CONTEXT.md`, `HISTORY.log`, or draft mtimes disagree, suggest `/scr:scan`.
+- If voice or continuity reports have unresolved issues, suggest `/scr:voice-check`, `/scr:continuity-check`, or `/scr:editor-review`.
+- If editor notes or track proposals exist, suggest `/scr:editor-review --notes`, `/scr:editor-review --respond`, or `/scr:track`.
+- If translation folders exist or config lists target languages, suggest translation follow-ups.
+- If export outputs are older than source files, suggest `/scr:export` or `/scr:publish`.
+- If no save exists after recent manuscript changes, suggest `/scr:save`.
+
+These checks must not mutate files.
+
+## Level 2: Auto-Run Local Helpers
+
+Run these only when the current command directly owns the file operation:
+
+- `/scr:save` regenerates `.manuscript/CONTEXT.md`, appends `HISTORY.log`, and commits `.manuscript/`.
+- `/scr:scan --fix` applies deterministic state repairs after confirmation and appends `HISTORY.log`.
+- `/scr:resume-work` may regenerate `CONTEXT.md` from disk state.
+- `/scr:progress` may count drafts, submitted units, open record threads, and stale reports, but does not write.
+- Runtime `/scr:sync --apply` runs the installer and verifies installed command, skill, and agent surfaces.
+
+Report these as local operations, not spawned agents.
+
+## Level 3: Auto-Spawn Scoped Agents
+
+Spawn or prompt-run fallback is appropriate when the command already implies a specialist role:
+
+- `/scr:plan` invokes `plan-checker` per plan.
+- `/scr:draft` invokes `drafter` per atomic unit and a voice diagnostic pass when a draft was produced.
+- `/scr:voice-check` invokes `voice-checker`.
+- `/scr:continuity-check` invokes `continuity-checker`.
+- `/scr:translate` invokes `translator` per unit.
+- `/scr:beta-reader` invokes a beta reader persona.
+- `/scr:map-manuscript` invokes analysis workers, or isolated sequential analysis if parallel workers are unavailable.
+- `/scr:editor-review` invokes revision diagnostics only for flagged issue groups.
+
+Do not pretend command-local analysis workers are installed agent files unless they actually are.
+
+## Level 4: Manual Only
+
+Never auto-run these without explicit writer confirmation:
+
+- deleting or removing units
+- accepting, rejecting, or applying editor decisions
+- merging revision tracks
+- clearing review findings
+- final publish or submission packaging
+- overwriting generated export packages
+- destructive repair, reset, revert, or cleanup
+- broad translation or cultural adaptation chains outside autopilot
+
+## Required Closeout
+
+Every proactive command should end with:
+
+- one recommended next command
+- a short reason tied to disk state
+- status showing whether agents spawned, local operations ran, or manual boundaries stopped automation

package/docs/configuration.md

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

package/docs/release-notes.md

@@ -2,6 +2,39 @@
 
 This document is the public-facing summary of what changed between package releases. For package history, see the root [CHANGELOG](../CHANGELOG.md).
 
+## 2.0.7 - 2026-05-16
+
+### What changed
+
+- Codex installs now generate agent metadata beside Scriveno agent prompts so native agent spawning can work when the host exposes those roles.
+- Non-Codex runtimes keep their own install surfaces: Claude Code flat commands and agents, command-directory runtimes, skill-file runtimes, Manus, guided Perplexity Desktop setup, and the generic fallback.
+- Scriveno now has a shared auto-invoke policy for read-only suggestions, deterministic local helpers, scoped agent spawns, and manual-only writer actions.
+- `/scr:next` and `/scr:progress` now do read-only proactive checks and explain what they found.
+- `/scr:save`, `/scr:scan`, `/scr:health`, `/scr:session-report`, `/scr:sync`, and multi-agent workflows now show visible status blocks that say what spawned, what ran locally, and why.
+- Package and shipped metadata are aligned on `2.0.7`.
+
+### Why it matters
+
+Writers and developers should not have to guess whether Scriveno used a native agent, a prompt fallback, or a local file operation. This release makes those paths visible and keeps runtime behavior honest across Codex, Claude Code, and the other supported install targets.
+
+The practical effect is calmer automation: Scriveno can be more proactive about the next safe move, while still keeping writer-owned actions like publishing, destructive edits, merges, and submissions behind explicit approval.
+
+### Affected areas
+
+- Codex agent metadata generation
+- Claude Code and other runtime install verification
+- proactive command guidance
+- local helper visibility
+- `/scr:sync` status reporting
+- README, changelog, release notes, and version metadata
+- regression tests for agent spawning, prompt fallback, and runtime install surfaces
+
+### Verification
+
+- `node --test`
+- `npm run release:check`
+- `git diff --check`
+
 ## 2.0.6 - 2026-05-15
 
 ### What changed

package/docs/runtime-support.md

@@ -34,23 +34,32 @@ Node is not a runtime dependency for Scriveno's markdown command system itself.
 
 - **Registry-tested**: installer registry shape is covered by automated tests.
 - **Repo-documented**: detection and install strategy are documented in the repo.
+- **Install-surface tested**: automated tests run the installer logic for representative targets and assert command files, agent prompts, and runtime-specific metadata or manifests are written in the expected place.
 - **No host-runtime parity verification yet**: Scriveno does not currently ship an end-to-end verification artifact for behavior inside the host runtime.
 
 ## Runtime Compatibility Matrix
 
 | Runtime | Install Type | Install Path Shape | Repo Evidence | Support Level | Verification Status |
 |---------|--------------|--------------------|---------------|---------------|---------------------|
-| Claude Code | commands | `~/.claude/commands/scr-*.md` + `~/.claude/agents` or `.claude/commands/scr-*.md` + `.claude/agents` | Installer registry, registry-tested, repo-documented | Primary reference runtime | Registry-tested; repo-documented; no host-runtime parity verification yet |
-| Cursor | commands | `~/.cursor/commands/scr` + `~/.cursor/agents` or `.cursor/commands/scr` + `.cursor/agents` | Installer registry, registry-tested, repo-documented | Standard installer target | Registry-tested; repo-documented; no host-runtime parity verification yet |
-| Gemini CLI | commands | `~/.gemini/commands/scr` + `~/.gemini/agents` or `.gemini/commands/scr` + `.gemini/agents` | Installer registry, registry-tested, repo-documented | Standard installer target | Registry-tested; repo-documented; no host-runtime parity verification yet |
-| Codex | skills | `~/.codex/skills/scr-*` or `.codex/skills/scr-*` (with mirrored command files in `~/.codex/commands/scr` or `.codex/commands/scr`) | Installer registry, registry-tested, repo-documented | Skills installer target | Registry-tested; repo-documented; no host-runtime parity verification yet |
-| OpenCode | commands | `~/.config/opencode/commands/scr` + `~/.config/opencode/agents` or `.config/opencode/commands/scr` + `.config/opencode/agents` | Installer registry, registry-tested, repo-documented | Standard installer target | Registry-tested; repo-documented; no host-runtime parity verification yet |
-| GitHub Copilot | commands | `~/.github/commands/scr` + `~/.github/agents` or `.github/commands/scr` + `.github/agents` | Installer registry, registry-tested, repo-documented | Standard installer target | Registry-tested; repo-documented; no host-runtime parity verification yet |
-| Windsurf | commands | `~/.windsurf/commands/scr` + `~/.windsurf/agents` or `.windsurf/commands/scr` + `.windsurf/agents` | Installer registry, registry-tested, repo-documented | Standard installer target | Registry-tested; repo-documented; no host-runtime parity verification yet |
-| Antigravity | commands | `~/.gemini/antigravity/commands/scr` + `~/.gemini/antigravity/agents` or `.gemini/antigravity/commands/scr` + `.gemini/antigravity/agents` | Installer registry, registry-tested, repo-documented | Standard installer target | Registry-tested; repo-documented; no host-runtime parity verification yet |
-| Manus Desktop | skills | `~/.manus/skills/scriveno/SKILL.md` or `.manus/skills/scriveno/SKILL.md` | Installer registry, registry-tested, repo-documented | Skills installer target | Registry-tested; repo-documented; no host-runtime parity verification yet |
+| Claude Code | commands | `~/.claude/commands/scr-*.md` + `~/.claude/agents` or `.claude/commands/scr-*.md` + `.claude/agents` | Installer registry, registry-tested, install-surface tested, repo-documented | Primary reference runtime | Registry-tested; install-surface tested; repo-documented; no host-runtime parity verification yet |
+| Cursor | commands | `~/.cursor/commands/scr` + `~/.cursor/agents` or `.cursor/commands/scr` + `.cursor/agents` | Installer registry, registry-tested, install-surface tested, repo-documented | Standard installer target | Registry-tested; install-surface tested; repo-documented; no host-runtime parity verification yet |
+| Gemini CLI | commands | `~/.gemini/commands/scr` + `~/.gemini/agents` or `.gemini/commands/scr` + `.gemini/agents` | Installer registry, registry-tested, install-surface tested, repo-documented | Standard installer target | Registry-tested; install-surface tested; repo-documented; no host-runtime parity verification yet |
+| Codex | skills | `~/.codex/skills/scr-*` or `.codex/skills/scr-*` (with mirrored command files in `~/.codex/commands/scr` or `.codex/commands/scr`, plus agent prompts and `.toml` metadata in `~/.codex/agents` or `.codex/agents`) | Installer registry, registry-tested, install-surface tested, repo-documented | Skills installer target | Registry-tested; install-surface tested; repo-documented; no host-runtime parity verification yet |
+| OpenCode | commands | `~/.config/opencode/commands/scr` + `~/.config/opencode/agents` or `.config/opencode/commands/scr` + `.config/opencode/agents` | Installer registry, registry-tested, install-surface tested, repo-documented | Standard installer target | Registry-tested; install-surface tested; repo-documented; no host-runtime parity verification yet |
+| GitHub Copilot | commands | `~/.github/commands/scr` + `~/.github/agents` or `.github/commands/scr` + `.github/agents` | Installer registry, registry-tested, install-surface tested, repo-documented | Standard installer target | Registry-tested; install-surface tested; repo-documented; no host-runtime parity verification yet |
+| Windsurf | commands | `~/.windsurf/commands/scr` + `~/.windsurf/agents` or `.windsurf/commands/scr` + `.windsurf/agents` | Installer registry, registry-tested, install-surface tested, repo-documented | Standard installer target | Registry-tested; install-surface tested; repo-documented; no host-runtime parity verification yet |
+| Antigravity | commands | `~/.gemini/antigravity/commands/scr` + `~/.gemini/antigravity/agents` or `.gemini/antigravity/commands/scr` + `.gemini/antigravity/agents` | Installer registry, registry-tested, install-surface tested, repo-documented | Standard installer target | Registry-tested; install-surface tested; repo-documented; no host-runtime parity verification yet |
+| Manus Desktop | skills | `~/.manus/skills/scriveno/SKILL.md` or `.manus/skills/scriveno/SKILL.md`, with mirrored `commands/scr/` and `agents/` inside the skill bundle | Installer registry, registry-tested, install-surface tested, repo-documented | Skills installer target | Registry-tested; install-surface tested; repo-documented; no host-runtime parity verification yet |
 | Perplexity Desktop | guided-mcp | `~/.scriveno/perplexity/SETUP.md` or `.scriveno/perplexity/SETUP.md` plus Perplexity Desktop Connectors setup | Installer registry, registry-tested, guided setup assets, repo-documented | Guided desktop MCP target | Registry-tested; repo-documented; no host-runtime parity verification yet |
-| Generic (SKILL.md) | skills | `~/.scriveno/skills/SKILL.md` or `.scriveno/skills/SKILL.md` | Installer registry, registry-tested | Generic skills fallback | Registry-tested; no host-runtime parity verification yet |
+| Generic (SKILL.md) | skills | `~/.scriveno/skills/SKILL.md` or `.scriveno/skills/SKILL.md`, with mirrored `commands/scr/` and `agents/` inside the skill bundle | Installer registry, registry-tested, install-surface tested | Generic skills fallback | Registry-tested; install-surface tested; no host-runtime parity verification yet |
+
+## Agent Surface By Runtime
+
+- Claude Code installs flat command files such as `scr-sync.md` plus agent prompts in its `agents` directory. It does not receive Codex `.toml` metadata.
+- Cursor, Gemini CLI, OpenCode, GitHub Copilot, Windsurf, and Antigravity install nested command directories plus agent prompts in their runtime-specific `agents` directory. They do not receive Codex `.toml` metadata.
+- Codex installs per-command skills, mirrored command files, agent prompts, and `.toml` metadata because Codex uses that metadata to expose agents.
+- Manus Desktop and the generic skills fallback install a manifest `SKILL.md`, mirrored command files, and agent prompts inside the skill bundle.
+- Perplexity Desktop receives setup assets for a local-MCP connector. It does not receive writable command or agent prompt directories from the installer.
 
 ## What Scriveno Proves Today
 
@@ -60,6 +69,7 @@ Scriveno currently proves all of the following in-repo:
 - each target has a declared install strategy (`commands`, `skills`, or `guided-mcp`)
 - each target has expected install-path properties in the installer registry
 - the runtime registry shape is covered by automated installer tests
+- representative install surfaces are covered for Claude Code, standard command-directory runtimes, Codex, Manus Desktop, and the generic skills fallback
 - the high-level install strategies and detection rules are documented in [Architecture](architecture.md)
 
 Scriveno does not currently prove:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scriveno",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "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/config.json

@@ -1,5 +1,5 @@
 {
-  "scriveno_version": "2.0.6",
+  "scriveno_version": "2.0.7",
   "work_type": "",
   "group": "",
   "command_unit": "",