scriveno 2.0.9 → 2.0.11

package/docs/route-graph.md

@@ -0,0 +1,51 @@
+# Route Graph Audit
+
+Scriveno's route graph is generated from `data/CONSTRAINTS.json` and `lib/auto-invoke-engine.js`. It is not a separate hand-maintained registry.
+
+Run the audit with:
+
+```bash
+scriveno routes
+scriveno routes --json
+```
+
+The text report summarizes command count, graph edges, agent-capable routes, local-helper routes, manual-gated routes, read-only routes, and lane counts. The JSON report includes nodes and edges for host adapters, CI checks, and future visualizations.
+
+## Current Shape
+
+As of `2.0.11`, the route graph contains:
+
+- 112 commands
+- intent-order edges from `command_intents`
+- dependency-chain edges from `dependencies.core_chain`
+- automation lanes from `getCommandAutomationPolicy()`
+- route priority fixtures for high-value state transitions
+
+## Automation Lanes
+
+Each command receives one lane:
+
+- `read-only`: inspect and recommend
+- `local-helper`: deterministic local helper, visible in status
+- `agent-ready`: bounded specialist route with known agent prompts
+- `agent-or-local`: route may use a specialist or local diagnostic pass
+- `mixed`: lifecycle route whose behavior depends on project state
+- `manual-gated`: writer-owned action that must stay explicit
+
+## Priority Fixtures
+
+The engine exports priority fixtures for the flows most likely to regress:
+
+- empty workspace routes to `/scr:new-work`
+- scanned project without drafts routes to `/scr:plan`
+- planned work without drafts routes to `/scr:draft`
+- drafts without review coverage route to `/scr:editor-review`
+- revision proposals route to `/scr:editor-review --proposal`
+- translation work routes to `/scr:back-translate`
+- publishing prerequisite gaps route to the first missing packaging prerequisite
+
+These fixtures are covered by `test/auto-invoke-engine.test.js`.
+
+## Cross-Runtime Use
+
+All runtimes use the same route graph audit. Claude Code, Cursor, Gemini CLI, OpenCode, GitHub Copilot, Windsurf, and Antigravity read command files and prompt agents. Codex reads generated `$scr-*` skills plus `.toml` agent metadata. Manus and the generic fallback read bundled skill files. Perplexity Desktop receives guided local-MCP setup. The graph stays shared even when the host's native spawning behavior differs.

package/docs/runtime-support.md

@@ -11,6 +11,8 @@ Node is required for:
 - running `npx scriveno@latest`
 - executing `bin/install.js`
 - running `scriveno status --project .`
+- running `scriveno status --project . --apply-safe`
+- running `scriveno sync --check`, `scriveno smoke`, `scriveno agents`, and `scriveno routes`
 - executing the shared auto-invoke status engine at `lib/auto-invoke-engine.js`
 - running the repo's JavaScript test suite
 
@@ -78,12 +80,30 @@ The public CLI entrypoint is:
 ```bash
 scriveno status --project .
 scriveno status . --json
+scriveno status --project . --apply-safe
 ```
 
 The JSON form is intended for CI, host adapters, and future runtime smoke tests.
 
 Status output uses the same route-intelligence shape across runtimes: `Candidate agents`, `Candidate local helpers`, and `Manual gates`. That keeps Claude Code, Codex, Cursor, Gemini CLI, OpenCode, GitHub Copilot, Windsurf, Antigravity, Manus, Perplexity Desktop, and generic skill installs aligned even when their native spawning mechanisms differ.
 
+## Runtime Smoke and Agent Checks
+
+The package now exposes cross-runtime checks through the public CLI:
+
+```bash
+scriveno sync --check
+scriveno smoke --json
+scriveno agents --json
+scriveno routes --json
+```
+
+`scriveno smoke` checks installed command surfaces, Codex skill directories, bundled skill manifests, agent prompt counts, Codex `.toml` metadata, guided Perplexity setup assets, and the shared engine under `~/.scriveno/lib/auto-invoke-engine.js`.
+
+`scriveno agents` checks whether each runtime has the expected Scriveno agent prompts and reports the correct fallback: prompt-run fallback for Claude Code and standard command runtimes, metadata-ready for Codex when `.toml` files are present, guided setup for Perplexity Desktop, and bundled skill prompts for Manus or generic skill installs.
+
+`scriveno routes` audits the command graph and automation lanes from `data/CONSTRAINTS.json`. It is useful when adding commands because it surfaces whether a route is read-only, local-helper, agent-ready, agent-or-local, mixed, or manual-gated.
+
 ## What Scriveno Proves Today
 
 Scriveno currently proves all of the following in-repo:

package/docs/sacred-texts.md

@@ -182,7 +182,7 @@ Apply or adjust verse numbering systems to your drafted text. Supports tradition
 
 **Requires:** At least one drafted unit.
 
-The top-level `/scr:sacred-verse-numbering` compatibility command is read-only: it shows the active tradition's numbering format and can render example citations. The nested `/scr:sacred:verse-numbering` command changes or verifies the project's numbering system.
+The top-level `/scr:sacred-numbering-format` compatibility command is read-only: it shows the active tradition's numbering format and can render example citations. The nested `/scr:sacred:verse-numbering` command changes or verifies the project's numbering system.
 
 ### `/scr:sacred:source-tracking`
 

package/docs/shipped-assets.md

@@ -39,6 +39,7 @@ These files ship in `templates/` and `docs/` and provide the trust trio for sess
 ## Runtime Sync Asset Shipped Today
 
 - `commands/scr/sync.md` -- local runtime-surface synchronization command. It compares and refreshes installed Scriveno commands, Codex skills, command mirrors, and agent prompts from the current source tree by delegating to `bin/install.js`.
+- `lib/auto-invoke-engine.js` -- shared project status, safe apply, runtime smoke, agent availability, and route graph audit engine used by `scriveno status`, `scriveno sync --check`, `scriveno smoke`, `scriveno agents`, and `scriveno routes`.
 
 ## Export Templates Shipped Today
 

package/docs/testing.md

@@ -136,6 +136,16 @@ For the standard release gate, prefer:
 npm run release:check
 ```
 
+When changing proactive routing, runtime install paths, or agent surfaces, also run:
+
+```bash
+scriveno status --project . --apply-safe
+scriveno sync --check
+scriveno smoke --json
+scriveno agents --json
+scriveno routes --json
+```
+
 Use those for release prep so you can inspect what would ship without mutating the registry.
 
 ## Practical workflow

package/lib/auto-invoke-engine.js

@@ -1,4 +1,5 @@
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 
 const DEFAULT_RUNTIME_SUPPORT = {
@@ -99,6 +100,119 @@ const CORE_PROJECT_FILES = [
   'config.json',
 ];
 
+const DEFAULT_AGENT_NAMES = [
+  'continuity-checker',
+  'drafter',
+  'plan-checker',
+  'researcher',
+  'translator',
+  'voice-checker',
+];
+
+const ROUTE_PRIORITY_FIXTURES = [
+  {
+    name: 'empty workspace',
+    setup: 'no .manuscript directory',
+    expectedCommand: '/scr:new-work',
+    reason: 'start or import before lifecycle routing',
+  },
+  {
+    name: 'scanned project without drafts',
+    setup: 'STATE.md and CONTEXT.md exist, drafts are absent',
+    expectedCommand: '/scr:plan',
+    reason: 'planning comes before drafting when no plan is ready',
+  },
+  {
+    name: 'planned work without draft',
+    setup: 'plan files exist and drafts are absent',
+    expectedCommand: '/scr:draft',
+    reason: 'connected plan evidence should route to drafting',
+  },
+  {
+    name: 'draft without review coverage',
+    setup: 'draft files exist and reviews are absent',
+    expectedCommand: '/scr:editor-review',
+    reason: 'review should precede export and packaging',
+  },
+  {
+    name: 'revision proposal waiting',
+    setup: 'proposal files exist in .manuscript/proposals',
+    expectedCommand: '/scr:editor-review --proposal',
+    reason: 'proposal review is more urgent than general notes',
+  },
+  {
+    name: 'translation follow-up',
+    setup: 'translation folders or target languages exist after review coverage',
+    expectedCommand: '/scr:back-translate',
+    reason: 'translation needs verification before multi-publish',
+  },
+  {
+    name: 'publishing prerequisite gap',
+    setup: 'reviewed drafts exist without front matter, back matter, blurb, or cover handoff',
+    expectedCommand: '/scr:front-matter',
+    reason: 'specific packaging prerequisites come before final publish',
+  },
+];
+
+const RUNTIME_INSTALL_SURFACES = {
+  'claude-code': {
+    commands: (homeDir) => path.join(homeDir, '.claude', 'commands'),
+    agents: (homeDir) => path.join(homeDir, '.claude', 'agents'),
+    commandLayout: 'flat',
+  },
+  cursor: {
+    commands: (homeDir) => path.join(homeDir, '.cursor', 'commands', 'scr'),
+    agents: (homeDir) => path.join(homeDir, '.cursor', 'agents'),
+    commandLayout: 'nested',
+  },
+  'gemini-cli': {
+    commands: (homeDir) => path.join(homeDir, '.gemini', 'commands', 'scr'),
+    agents: (homeDir) => path.join(homeDir, '.gemini', 'agents'),
+    commandLayout: 'nested',
+  },
+  codex: {
+    commands: (homeDir) => path.join(homeDir, '.codex', 'commands', 'scr'),
+    skills: (homeDir) => path.join(homeDir, '.codex', 'skills'),
+    agents: (homeDir) => path.join(homeDir, '.codex', 'agents'),
+    commandLayout: 'nested',
+    metadata: 'toml',
+  },
+  opencode: {
+    commands: (homeDir) => path.join(homeDir, '.config', 'opencode', 'commands', 'scr'),
+    agents: (homeDir) => path.join(homeDir, '.config', 'opencode', 'agents'),
+    commandLayout: 'nested',
+  },
+  copilot: {
+    commands: (homeDir) => path.join(homeDir, '.github', 'commands', 'scr'),
+    agents: (homeDir) => path.join(homeDir, '.github', 'agents'),
+    commandLayout: 'nested',
+  },
+  windsurf: {
+    commands: (homeDir) => path.join(homeDir, '.windsurf', 'commands', 'scr'),
+    agents: (homeDir) => path.join(homeDir, '.windsurf', 'agents'),
+    commandLayout: 'nested',
+  },
+  antigravity: {
+    commands: (homeDir) => path.join(homeDir, '.gemini', 'antigravity', 'commands', 'scr'),
+    agents: (homeDir) => path.join(homeDir, '.gemini', 'antigravity', 'agents'),
+    commandLayout: 'nested',
+  },
+  manus: {
+    skills: (homeDir) => path.join(homeDir, '.manus', 'skills', 'scriveno'),
+    agents: (homeDir) => path.join(homeDir, '.manus', 'skills', 'scriveno', 'agents'),
+    commandLayout: 'skill-bundle',
+  },
+  'perplexity-desktop': {
+    guide: (homeDir) => path.join(homeDir, '.scriveno', 'perplexity'),
+    commandLayout: 'guided-mcp',
+  },
+  generic: {
+    skills: (homeDir) => path.join(homeDir, '.scriveno', 'skills'),
+    agents: (homeDir) => path.join(homeDir, '.scriveno', 'skills', 'agents'),
+    commandLayout: 'skill-bundle',
+  },
+};
+
 const AGENT_ROUTE_POLICIES = {
   '/scr:plan': {
     agents: ['plan-checker'],
@@ -855,6 +969,381 @@ function listRuntimeAgentSupport() {
   }));
 }
 
+function getPackageRoot() {
+  return path.resolve(__dirname, '..');
+}
+
+function loadConstraints(options = {}) {
+  const constraintsPath = options.constraintsPath || path.join(getPackageRoot(), 'data', 'CONSTRAINTS.json');
+  const constraints = readJson(constraintsPath);
+  return constraints && constraints.commands ? constraints : { commands: {}, command_intents: {}, dependencies: {} };
+}
+
+function expectedCommandCount(options = {}) {
+  return Object.keys(loadConstraints(options).commands || {}).length;
+}
+
+function getExpectedAgentNames(options = {}) {
+  if (Array.isArray(options.agentNames) && options.agentNames.length > 0) {
+    return options.agentNames.slice().sort();
+  }
+  const agentsRoot = options.agentsRoot || path.join(getPackageRoot(), 'agents');
+  const files = listFiles(agentsRoot, { extensions: ['.md'], recursive: false })
+    .map((file) => path.basename(file, '.md'))
+    .sort();
+  return files.length ? files : DEFAULT_AGENT_NAMES.slice().sort();
+}
+
+function collectSafeApplyActions(projectRoot = process.cwd(), options = {}) {
+  const analysis = options.analysis || analyzeProject(projectRoot);
+  const actions = [
+    {
+      name: 'status sweep',
+      command: 'scriveno status',
+      status: 'ran',
+      mutation: false,
+      reason: 'computed the current route, local-helper, agent, and manual-gate state',
+    },
+  ];
+
+  const readOnlyHelpers = new Set(['/scr:progress', '/scr:session-report', '/scr:check-notes', '/scr:health', '/scr:validate']);
+  const writeOrInstallHelpers = new Set(['/scr:save', '/scr:scan', '/scr:sync']);
+
+  for (const candidate of analysis.automation.localCandidates || []) {
+    const command = candidate.command;
+    if (readOnlyHelpers.has(command)) {
+      actions.push({
+        name: command.replace('/scr:', ''),
+        command,
+        status: 'ready',
+        mutation: false,
+        reason: candidate.reason,
+      });
+    } else if (writeOrInstallHelpers.has(command)) {
+      actions.push({
+        name: command.replace('/scr:', ''),
+        command,
+        status: 'skipped',
+        mutation: true,
+        reason: `${candidate.reason}; safe apply reports this instead of writing files`,
+      });
+    } else {
+      actions.push({
+        name: command.replace('/scr:', ''),
+        command,
+        status: 'suggested',
+        mutation: null,
+        reason: candidate.reason,
+      });
+    }
+  }
+
+  for (const candidate of analysis.automation.spawnCandidates || []) {
+    actions.push({
+      name: candidate.command.replace('/scr:', ''),
+      command: candidate.command,
+      status: 'agent-candidate',
+      mutation: null,
+      reason: `${candidate.agents.join(', ')}: ${candidate.reason}`,
+    });
+  }
+
+  for (const gate of analysis.automation.manualGates || []) {
+    actions.push({
+      name: gate.command.replace('/scr:', ''),
+      command: gate.command,
+      status: 'manual-gate',
+      mutation: true,
+      reason: gate.reason,
+    });
+  }
+
+  return {
+    projectRoot: analysis.projectRoot,
+    trigger: options.trigger || 'scriveno status --apply-safe',
+    appliedCount: actions.filter((action) => action.status === 'ran').length,
+    skippedCount: actions.filter((action) => action.status === 'skipped' || action.status === 'manual-gate').length,
+    safeToRunCount: actions.filter((action) => action.status === 'ready').length,
+    agentCandidateCount: actions.filter((action) => action.status === 'agent-candidate').length,
+    actions,
+  };
+}
+
+function formatSafeApplyReport(result) {
+  const actionLines = result.actions.length
+    ? result.actions.map((action) => {
+      const mutation = action.mutation === false ? 'read-only' : action.mutation === true ? 'writes or external action' : 'host-dependent';
+      return `- ${action.command}: ${action.status} (${mutation}) - ${action.reason}`;
+    })
+    : ['- none'];
+  return [
+    'Safe apply status:',
+    `Trigger: ${result.trigger}`,
+    `Project: ${result.projectRoot}`,
+    `Read-only checks run: ${result.appliedCount}`,
+    `Safe helpers ready: ${result.safeToRunCount}`,
+    `Agent candidates: ${result.agentCandidateCount}`,
+    `Manual or write-gated actions: ${result.skippedCount}`,
+    'Actions:',
+    ...actionLines,
+  ].join('\n');
+}
+
+function runtimeSurfacePaths(runtimeKey, options = {}) {
+  const homeDir = options.homeDir || os.homedir();
+  const surface = RUNTIME_INSTALL_SURFACES[runtimeKey];
+  if (!surface) return null;
+  const out = { runtimeKey };
+  for (const [key, value] of Object.entries(surface)) {
+    if (typeof value === 'function') out[key] = value(homeDir);
+  }
+  out.commandLayout = surface.commandLayout;
+  out.metadata = surface.metadata || 'none';
+  return out;
+}
+
+function inspectAgentAvailability(options = {}) {
+  const runtimeKeys = options.runtimeKeys || Object.keys(DEFAULT_RUNTIME_SUPPORT);
+  const agentNames = getExpectedAgentNames(options);
+  const runtimes = [];
+
+  for (const runtimeKey of runtimeKeys) {
+    const support = getRuntimeAgentSupport(runtimeKey);
+    const paths = runtimeSurfacePaths(runtimeKey, options);
+    if (!support || !paths) continue;
+
+    if (runtimeKey === 'perplexity-desktop') {
+      const guideReady = pathExists(path.join(paths.guide || '', 'SETUP.md'));
+      runtimes.push({
+        runtime: runtimeKey,
+        label: support.label,
+        status: guideReady ? 'guided-ready' : 'guided-missing',
+        nativeSpawn: support.nativeSpawn,
+        fallback: support.fallback,
+        agentsDir: null,
+        promptCount: 0,
+        missingPrompts: agentNames,
+        metadataCount: 0,
+        missingMetadata: [],
+      });
+      continue;
+    }
+
+    const agentsDir = paths.agents || path.join(paths.skills || '', 'agents');
+    const promptFiles = agentNames.map((name) => `${name}.md`);
+    const missingPrompts = promptFiles
+      .filter((fileName) => !pathExists(path.join(agentsDir, fileName)))
+      .map((fileName) => path.basename(fileName, '.md'));
+    const metadataFiles = support.metadata === 'toml'
+      ? agentNames.map((name) => `${name}.toml`)
+      : [];
+    const missingMetadata = metadataFiles
+      .filter((fileName) => !pathExists(path.join(agentsDir, fileName)))
+      .map((fileName) => path.basename(fileName, '.toml'));
+    const promptCount = promptFiles.length - missingPrompts.length;
+    const metadataCount = metadataFiles.length - missingMetadata.length;
+    let status = 'missing';
+    if (missingPrompts.length === 0 && missingMetadata.length === 0 && support.metadata === 'toml') {
+      status = 'metadata-ready';
+    } else if (missingPrompts.length === 0) {
+      status = 'prompt-fallback-ready';
+    }
+
+    runtimes.push({
+      runtime: runtimeKey,
+      label: support.label,
+      status,
+      nativeSpawn: support.nativeSpawn,
+      fallback: support.fallback,
+      agentsDir,
+      promptCount,
+      missingPrompts,
+      metadataCount,
+      missingMetadata,
+    });
+  }
+
+  return {
+    checkedAt: new Date().toISOString(),
+    expectedAgents: agentNames,
+    runtimes,
+  };
+}
+
+function formatAgentAvailabilityReport(report) {
+  const lines = [
+    'Agent availability:',
+    `Expected agents: ${report.expectedAgents.join(', ')}`,
+  ];
+  for (const runtime of report.runtimes) {
+    lines.push(`- ${runtime.label}: ${runtime.status}`);
+    if (runtime.agentsDir) lines.push(`  Agents: ${runtime.agentsDir}`);
+    lines.push(`  Prompts: ${runtime.promptCount}/${report.expectedAgents.length}`);
+    if (runtime.missingPrompts.length) lines.push(`  Missing prompts: ${runtime.missingPrompts.join(', ')}`);
+    if (runtime.missingMetadata.length) lines.push(`  Missing metadata: ${runtime.missingMetadata.join(', ')}`);
+    lines.push(`  Fallback: ${runtime.fallback}`);
+  }
+  return lines.join('\n');
+}
+
+function countInstalledCommands(paths) {
+  if (!paths) return 0;
+  if (paths.commandLayout === 'flat') {
+    return listFiles(paths.commands, { extensions: ['.md'], recursive: false })
+      .filter((file) => /^scr-/.test(path.basename(file)))
+      .length;
+  }
+  if (paths.commandLayout === 'skill-bundle') {
+    return countMarkdownFiles(path.join(paths.skills || '', 'commands', 'scr'));
+  }
+  if (paths.commandLayout === 'guided-mcp') {
+    return pathExists(path.join(paths.guide || '', 'SETUP.md')) ? 1 : 0;
+  }
+  return countMarkdownFiles(paths.commands || '');
+}
+
+function inspectRuntimeSmoke(options = {}) {
+  const runtimeKeys = options.runtimeKeys || Object.keys(DEFAULT_RUNTIME_SUPPORT);
+  const expectedCommands = options.expectedCommands || expectedCommandCount(options);
+  const expectedAgents = getExpectedAgentNames(options);
+  const dataDir = options.dataDir || path.join(options.homeDir || os.homedir(), '.scriveno');
+  const enginePath = path.join(dataDir, 'lib', 'auto-invoke-engine.js');
+  const results = [];
+
+  for (const runtimeKey of runtimeKeys) {
+    const support = getRuntimeAgentSupport(runtimeKey);
+    const paths = runtimeSurfacePaths(runtimeKey, options);
+    if (!support || !paths) continue;
+    const commandCount = countInstalledCommands(paths);
+    const skillCount = runtimeKey === 'codex' && pathExists(paths.skills || '')
+      ? fs.readdirSync(paths.skills, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith('scr-')).length
+      : paths.skills && pathExists(path.join(paths.skills, 'SKILL.md')) ? 1 : 0;
+    const agentsDir = paths.agents || (paths.skills ? path.join(paths.skills, 'agents') : null);
+    const promptCount = countFiles(agentsDir, ['.md']);
+    const metadataCount = runtimeKey === 'codex' ? countFiles(agentsDir, ['.toml']) : 0;
+    const commandReady = runtimeKey === 'perplexity-desktop' ? commandCount === 1 : commandCount >= expectedCommands;
+    const skillReady = runtimeKey === 'codex' ? skillCount >= expectedCommands : !paths.skills || skillCount >= 1;
+    const agentReady = runtimeKey === 'perplexity-desktop' ? true : promptCount >= expectedAgents.length;
+    const metadataReady = runtimeKey === 'codex' ? metadataCount >= expectedAgents.length : true;
+    const engineReady = pathExists(enginePath);
+    const ok = commandReady && skillReady && agentReady && metadataReady && engineReady;
+
+    results.push({
+      runtime: runtimeKey,
+      label: support.label,
+      ok,
+      commands: commandCount,
+      expectedCommands: runtimeKey === 'perplexity-desktop' ? 1 : expectedCommands,
+      skills: skillCount,
+      agents: promptCount,
+      expectedAgents: runtimeKey === 'perplexity-desktop' ? 0 : expectedAgents.length,
+      metadata: metadataCount,
+      expectedMetadata: runtimeKey === 'codex' ? expectedAgents.length : 0,
+      engineReady,
+      paths,
+    });
+  }
+
+  return {
+    checkedAt: new Date().toISOString(),
+    dataDir,
+    enginePath,
+    expectedCommands,
+    expectedAgents,
+    ok: results.every((result) => result.ok),
+    runtimes: results,
+  };
+}
+
+function formatRuntimeSmokeReport(report) {
+  const lines = [
+    'Runtime smoke status:',
+    `Shared engine: ${report.enginePath} (${report.runtimes.some((runtime) => runtime.engineReady) ? 'present' : 'missing'})`,
+    `Overall: ${report.ok ? 'pass' : 'needs attention'}`,
+  ];
+  for (const runtime of report.runtimes) {
+    lines.push(`- ${runtime.label}: ${runtime.ok ? 'pass' : 'needs attention'}`);
+    lines.push(`  Commands: ${runtime.commands}/${runtime.expectedCommands}`);
+    if (runtime.skills) lines.push(`  Skills: ${runtime.skills}`);
+    if (runtime.expectedAgents) lines.push(`  Agent prompts: ${runtime.agents}/${runtime.expectedAgents}`);
+    if (runtime.expectedMetadata) lines.push(`  Agent metadata: ${runtime.metadata}/${runtime.expectedMetadata}`);
+    lines.push(`  Shared engine: ${runtime.engineReady ? 'present' : 'missing'}`);
+  }
+  return lines.join('\n');
+}
+
+function buildRouteGraph(options = {}) {
+  const constraints = options.commands ? options : loadConstraints(options);
+  const commands = constraints.commands || {};
+  const categories = {};
+  const lanes = {};
+  const nodes = Object.entries(commands).map(([name, command]) => {
+    const policy = getCommandAutomationPolicy(name, command);
+    categories[command.category || 'uncategorized'] = (categories[command.category || 'uncategorized'] || 0) + 1;
+    lanes[policy.lane] = (lanes[policy.lane] || 0) + 1;
+    return {
+      id: `/scr:${name}`,
+      name,
+      category: command.category || 'uncategorized',
+      lane: policy.lane,
+      level: policy.level,
+      available: command.available || [],
+      reason: policy.reason,
+    };
+  });
+
+  const edges = [];
+  for (const [intent, names] of Object.entries(constraints.command_intents || {})) {
+    for (let i = 0; i < names.length - 1; i++) {
+      if (commands[names[i]] && commands[names[i + 1]]) {
+        edges.push({ from: `/scr:${names[i]}`, to: `/scr:${names[i + 1]}`, type: 'intent-order', label: intent });
+      }
+    }
+  }
+  for (const [chainName, entries] of Object.entries(constraints.dependencies || {})) {
+    if (!Array.isArray(entries)) continue;
+    const commandEntries = entries.filter((entry) => entry && typeof entry === 'object' && entry.command);
+    for (let i = 0; i < commandEntries.length - 1; i++) {
+      const from = commandEntries[i].command;
+      const to = commandEntries[i + 1].command;
+      if (commands[from] && commands[to]) {
+        edges.push({ from: `/scr:${from}`, to: `/scr:${to}`, type: 'dependency-chain', label: chainName });
+      }
+    }
+  }
+
+  return {
+    generatedAt: new Date().toISOString(),
+    commandCount: nodes.length,
+    edgeCount: edges.length,
+    categories,
+    lanes,
+    agentRoutes: nodes.filter((node) => node.lane === 'agent-ready' || node.lane === 'agent-or-local').length,
+    localRoutes: nodes.filter((node) => node.lane === 'local-helper').length,
+    manualRoutes: nodes.filter((node) => node.lane === 'manual-gated').length,
+    readOnlyRoutes: nodes.filter((node) => node.lane === 'read-only').length,
+    nodes,
+    edges,
+  };
+}
+
+function formatRouteGraphReport(graph) {
+  const laneLines = Object.entries(graph.lanes)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([lane, count]) => `- ${lane}: ${count}`);
+  return [
+    'Route graph audit:',
+    `Commands: ${graph.commandCount}`,
+    `Edges: ${graph.edgeCount}`,
+    `Agent-capable routes: ${graph.agentRoutes}`,
+    `Local-helper routes: ${graph.localRoutes}`,
+    `Manual-gated routes: ${graph.manualRoutes}`,
+    `Read-only routes: ${graph.readOnlyRoutes}`,
+    'Automation lanes:',
+    ...laneLines,
+  ].join('\n');
+}
+
 function parseCliArgs(argv) {
   const out = {
     projectRoot: process.cwd(),
@@ -892,15 +1381,27 @@ module.exports = {
   AGENT_ROUTE_POLICIES,
   CATEGORY_ROUTE_POLICIES,
   DEFAULT_RUNTIME_SUPPORT,
+  DEFAULT_AGENT_NAMES,
   LOCAL_ROUTE_POLICIES,
   MANUAL_ROUTE_POLICIES,
+  ROUTE_PRIORITY_FIXTURES,
   analyzeProject,
+  buildRouteGraph,
+  collectSafeApplyActions,
+  expectedCommandCount,
+  formatAgentAvailabilityReport,
+  formatRouteGraphReport,
   formatProactiveChecks,
   formatAutomationStatus,
   formatRecommendation,
   formatReport,
+  formatRuntimeSmokeReport,
+  formatSafeApplyReport,
   getCommandAutomationPolicy,
+  getExpectedAgentNames,
   getRuntimeAgentSupport,
+  inspectAgentAvailability,
+  inspectRuntimeSmoke,
   listRuntimeAgentSupport,
   parseCliArgs,
 };

package/package.json

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

package/templates/sacred/DOCTRINES.md

@@ -42,4 +42,4 @@
 
 ---
 
-*Drafter agents check this file to avoid contradicting established doctrines when drafting passages. `/scr:doctrinal-check` flags any unit that contradicts or undermines an affirmed doctrine without explicit intent.*
+*Drafter agents check this file to avoid contradicting established doctrines when drafting passages. `/scr:sacred:doctrinal-check` flags any unit that contradicts or undermines an affirmed doctrine without explicit intent.*