scriveno 2.0.6 → 2.0.8

package/README.md

@@ -2,9 +2,10 @@
 
 [![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.8-blue)](CHANGELOG.md)
 [![npm](https://img.shields.io/npm/v/scriveno.svg)](https://www.npmjs.com/package/scriveno)
 [![Downloads](https://img.shields.io/npm/dm/scriveno.svg)](https://www.npmjs.com/package/scriveno)
+[![Status CLI](https://img.shields.io/badge/status%20CLI-scriveno%20status-blue)](docs/runtime-support.md#shared-auto-invoke-engine)
 
 **[scriveno on npm](https://www.npmjs.com/package/scriveno)**
 
@@ -18,6 +19,9 @@ Scriveno is best understood as **AI-native longform writing software built aroun
 
 ```bash
 npx scriveno@latest
+
+# Optional project status check
+scriveno status --project .
 ```
 
 ---
@@ -68,6 +72,19 @@ If you want the shortest proof-first route, read [Proof Artifacts](docs/proof-ar
 
 ---
 
+## Proactive status
+
+Scriveno ships a shared read-only status engine for every installer target. The public CLI is:
+
+```bash
+scriveno status --project .
+scriveno status . --json
+```
+
+It inspects disk evidence such as `.manuscript/`, `STATE.md`, `CONTEXT.md`, review files, translation work, exports, and history, then recommends the safest next command. The engine does not mutate files and does not spawn agents by itself. Command surfaces such as `/scr-next`, `/scr:next`, `/scr:progress`, `/scr:session-report`, and `/scr:sync` call it when local command execution is available, then fall back to embedded markdown logic when a host cannot run Node. See [Auto-Invoke Policy](docs/auto-invoke-policy.md) and [Runtime Support](docs/runtime-support.md#shared-auto-invoke-engine).
+
+---
+
 ## The Voice DNA system
 
 Scriveno's core insight: drafted prose should sound like *you*, not like an AI. Before drafting begins, `/scr:profile-writer` builds a detailed voice profile across 15+ dimensions:
@@ -171,6 +188,7 @@ Scriveno is built on five principles:
 - [Contributing](docs/contributing.md) -- How to add commands, agents, work types, and templates
 - [Architecture](docs/architecture.md) -- How Scriveno works under the hood
 - [Configuration](docs/configuration.md) -- Package, installer, constraints, and `.manuscript/config.json` surfaces
+- [Auto-Invoke Policy](docs/auto-invoke-policy.md) -- Shared status engine, visible automation status, and agent-spawn boundaries
 - [Development](docs/development.md) -- Contributor workflow for changing commands, templates, installer logic, and docs
 - [Testing](docs/testing.md) -- What the test suite covers and which checks to run before shipping
 - [Release Notes](docs/release-notes.md) -- Public summary of what changed between package releases
@@ -195,7 +213,7 @@ Scriveno currently ships installer targets for these AI tooling environments:
 - **Perplexity Desktop** (guided local-MCP setup)
 - **Generic (SKILL.md)** fallback
 
-**Installer baseline:** `Node.js >=20.0.0` for `npx scriveno@latest` and `bin/install.js`. For new installs, use a currently supported LTS such as Node.js 24; Node.js 20 is now a compatibility floor, not the recommended fresh-install target.
+**Installer baseline:** `Node.js >=20.0.0` for `npx scriveno@latest`, `bin/install.js`, and `scriveno status --project .`. For new installs, use a currently supported LTS such as Node.js 24; Node.js 20 is now a compatibility floor, not the recommended fresh-install target.
 
 **Support note:** Claude Code is the primary reference runtime and now installs a flat `/scr-*` command surface. The environments listed above are installer targets, not a claim that every host runtime has verified parity today. Codex currently installs a skill-native `$scr-*` surface, while Perplexity Desktop is a guided local-MCP target rather than a writable command runtime. See the [runtime compatibility matrix](docs/runtime-support.md) for install type, support level, and verification status.
 
@@ -203,11 +221,11 @@ Scriveno currently ships installer targets for these AI tooling environments:
 
 ## Status
 
-**Version:** 2.0.6
+**Version:** 2.0.8
 
- 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, visible automation status, and the shared `scriveno status --project .` auto-invoke engine through `2.0.8`. 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.8` 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

@@ -6,6 +6,7 @@ const os = require('os');
 const readline = require('readline');
 const crypto = require('crypto');
 const architecturalProfiles = require('../lib/architectural-profiles.js');
+const autoInvokeEngine = require('../lib/auto-invoke-engine.js');
 
 const PKG_ROOT = path.join(__dirname, '..');
 const PKG = require('../package.json');
@@ -155,6 +156,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 +416,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
@@ -767,6 +821,8 @@ function printHelp() {
   console.log(BANNER);
   console.log(`Usage:
   scriveno
+  scriveno status --project .
+  scriveno status . --json
   scriveno --runtimes codex,claude-code --global --writer --silent
 
 Options:
@@ -781,6 +837,12 @@ Options:
   --help              Show this help text
   --version           Show the Scriveno package version
 
+Status options:
+  status              Inspect a project and recommend the next command
+  --project <path>    Project root to inspect (default: current directory)
+  --trigger <name>    Status trigger label (default: scriveno status)
+  --json              Print machine-readable status JSON
+
 Runtime keys:
   ${Object.keys(RUNTIMES).join(', ')}
 `);
@@ -788,6 +850,7 @@ Runtime keys:
 
 function parseArgs(argv) {
   const options = {
+    command: 'install',
     runtimeKeys: [],
     installDetected: false,
     isGlobal: null,
@@ -795,8 +858,44 @@ function parseArgs(argv) {
     silent: false,
     showHelp: false,
     showVersion: false,
+    statusProjectRoot: process.cwd(),
+    statusTrigger: 'scriveno status',
+    statusJson: false,
   };
 
+  if (argv[0] === 'status') {
+    options.command = 'status';
+    for (let i = 1; i < argv.length; i++) {
+      const arg = argv[i];
+      if (arg === '--help' || arg === '-h') {
+        options.showHelp = true;
+      } else if (arg === '--version' || arg === '-v') {
+        options.showVersion = true;
+      } else if (arg === '--json') {
+        options.statusJson = true;
+      } else if (arg === '--project') {
+        const value = argv[i + 1];
+        if (!value) throw new Error('--project requires a value for status');
+        options.statusProjectRoot = value;
+        i++;
+      } else if (arg.startsWith('--project=')) {
+        options.statusProjectRoot = arg.slice('--project='.length);
+      } else if (arg === '--trigger') {
+        const value = argv[i + 1];
+        if (!value) throw new Error('--trigger requires a value');
+        options.statusTrigger = value;
+        i++;
+      } else if (arg.startsWith('--trigger=')) {
+        options.statusTrigger = arg.slice('--trigger='.length);
+      } else if (arg.startsWith('-')) {
+        throw new Error(`Unknown status argument "${arg}"`);
+      } else {
+        options.statusProjectRoot = arg;
+      }
+    }
+    return options;
+  }
+
   function addRuntimeList(value) {
     for (const key of String(value).split(',').map((item) => item.trim()).filter(Boolean)) {
       if (!Object.prototype.hasOwnProperty.call(RUNTIMES, key)) {
@@ -848,6 +947,16 @@ function parseArgs(argv) {
   return options;
 }
 
+function runStatus({ projectRoot, trigger, json }) {
+  const analysis = autoInvokeEngine.analyzeProject(projectRoot);
+  if (json) {
+    console.log(JSON.stringify(analysis, null, 2));
+  } else {
+    console.log(autoInvokeEngine.formatReport(analysis, { trigger }));
+  }
+  return analysis;
+}
+
 function resolveInstallRequest(parsed, detectedRuntimeKeys, { isTTY }) {
   const hasRuntimeDirective = parsed.runtimeKeys.length > 0 || parsed.installDetected;
   const hasModifierOverrides = parsed.isGlobal !== null || parsed.developerMode !== null;
@@ -1202,6 +1311,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) {
@@ -1213,6 +1380,15 @@ async function main() {
     return;
   }
 
+  if (parsed.command === 'status') {
+    runStatus({
+      projectRoot: parsed.statusProjectRoot,
+      trigger: parsed.statusTrigger,
+      json: parsed.statusJson,
+    });
+    return;
+  }
+
   const detectedRuntimeKeys = Object.entries(RUNTIMES).filter(([, runtime]) => runtime.detect()).map(([key]) => key);
   const installRequest = resolveInstallRequest(parsed, detectedRuntimeKeys, { isTTY: Boolean(process.stdin.isTTY) });
 
@@ -1342,6 +1518,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 +1551,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 +1568,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 +1580,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) {
@@ -1415,11 +1610,13 @@ function installGuidedRuntime(runtime, isGlobal, dataDir, log) {
 function writeSharedAssets(dataDir, runtimeKeys, isGlobal, developerMode, installMode, log) {
   fs.mkdirSync(path.join(dataDir, 'templates'), { recursive: true });
   fs.mkdirSync(path.join(dataDir, 'data'), { recursive: true });
+  fs.mkdirSync(path.join(dataDir, 'lib'), { recursive: true });
   const templateResult = copyDirWithPreservation(path.join(PKG_ROOT, 'templates'), path.join(dataDir, 'templates'));
   const dataResult = copyDirWithPreservation(path.join(PKG_ROOT, 'data'), path.join(dataDir, 'data'));
+  const libResult = copyDirWithPreservation(path.join(PKG_ROOT, 'lib'), path.join(dataDir, 'lib'));
   const sum = (r) => r.fresh + r.replaced + r.backedUp;
-  log(`  ${c('green', 'OK')} ${sum(templateResult)} templates + ${sum(dataResult)} data files -> ${c('dim', dataDir)}`);
-  const totalBackedUp = templateResult.backedUp + dataResult.backedUp;
+  log(`  ${c('green', 'OK')} ${sum(templateResult)} templates + ${sum(dataResult)} data files + ${sum(libResult)} lib files -> ${c('dim', dataDir)}`);
+  const totalBackedUp = templateResult.backedUp + dataResult.backedUp + libResult.backedUp;
   if (totalBackedUp > 0) {
     log(`  ${c('yellow', 'i')} Preserved ${totalBackedUp} user-modified file(s) as .backup.<timestamp>`);
   }
@@ -1576,17 +1773,25 @@ module.exports = {
   RUNTIMES,
   parseArgs,
   resolveInstallRequest,
+  runStatus,
   collectCommandEntries,
+  collectAgentEntries,
   assertNoSkillNameCollisions,
   cleanCodexSkillDirs,
+  cleanCodexAgentFiles,
   commandRefToCodexSkillName,
   commandRefToClaudeInvocation,
   commandRefToCodexInvocation,
   commandEntryToFlatCommandFileName,
   generateClaudeCommandContent,
   generateCodexCommandContent,
+  generateCodexAgentMetadata,
   rewriteInstalledCommandRefs,
+  installCommandRuntime,
+  installClaudeCommandRuntime,
+  installManifestSkillRuntime,
   installCodexRuntime,
+  installCodexAgentsWithMetadata,
   cleanFlatCommandFiles,
   generateCodexSkill,
   generateSkillManifest,
@@ -1617,4 +1822,10 @@ module.exports = {
   // Per-work-type pitfall packs
   listPitfallPacks: architecturalProfiles.listPitfallPacks,
   getPitfallPackPath: architecturalProfiles.getPitfallPackPath,
+  // Shared proactive status engine
+  autoInvokeEngine,
+  analyzeProject: autoInvokeEngine.analyzeProject,
+  formatAutoInvokeReport: autoInvokeEngine.formatReport,
+  getRuntimeAgentSupport: autoInvokeEngine.getRuntimeAgentSupport,
+  listRuntimeAgentSupport: autoInvokeEngine.listRuntimeAgentSupport,
 };

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: