scriveno 2.0.8 → 2.0.9

package/lib/auto-invoke-engine.js

@@ -91,6 +91,116 @@ const REVIEW_KEYWORDS = [
   'CONTINUITY',
 ];
 
+const CORE_PROJECT_FILES = [
+  'WORK.md',
+  'OUTLINE.md',
+  'STYLE-GUIDE.md',
+  'RECORD.md',
+  'config.json',
+];
+
+const AGENT_ROUTE_POLICIES = {
+  '/scr:plan': {
+    agents: ['plan-checker'],
+    reason: 'planning can validate unit plans before drafting',
+  },
+  '/scr:draft': {
+    agents: ['drafter', 'voice-checker'],
+    reason: 'drafting uses fresh-context prose generation and voice checks',
+  },
+  '/scr:editor-review': {
+    agents: ['diagnostic worker'],
+    reason: 'editor review can isolate flagged issue groups',
+  },
+  '/scr:voice-check': {
+    agents: ['voice-checker'],
+    reason: 'voice review compares drafts against STYLE-GUIDE.md',
+  },
+  '/scr:continuity-check': {
+    agents: ['continuity-checker'],
+    reason: 'continuity review checks contradictions and timeline drift',
+  },
+  '/scr:translate': {
+    agents: ['translator'],
+    reason: 'translation runs one fresh-context translation pass per unit',
+  },
+  '/scr:back-translate': {
+    agents: ['translator'],
+    reason: 'back-translation verifies target-language drift',
+  },
+  '/scr:beta-reader': {
+    agents: ['beta-reader worker'],
+    reason: 'beta review benefits from isolated reader perspectives',
+  },
+  '/scr:quick-write': {
+    agents: ['drafter', 'voice-checker'],
+    reason: 'quick writing still benefits from voice-aware isolation',
+  },
+  '/scr:map-manuscript': {
+    agents: ['voice analyst', 'structure analyst', 'character analyst', 'theme analyst', 'world analyst', 'pacing analyst'],
+    reason: 'manuscript import uses parallel analysis workers when available',
+  },
+};
+
+const LOCAL_ROUTE_POLICIES = {
+  '/scr:save': 'refresh CONTEXT.md, HISTORY.log, and project checkpoint state',
+  '/scr:scan': 'reconcile STATE.md and disk evidence',
+  '/scr:health': 'diagnose project and runtime health',
+  '/scr:sync': 'compare and refresh installed runtime surfaces',
+  '/scr:validate': 'run project validation checks',
+  '/scr:check-notes': 'surface unresolved writer notes',
+  '/scr:progress': 'compute read-only project progress',
+  '/scr:session-report': 'compute read-only session metrics',
+};
+
+const MANUAL_ROUTE_POLICIES = {
+  '/scr:publish': 'publication packaging can overwrite deliverables and needs writer choices',
+  '/scr:export': 'export writes output artifacts and may overwrite packages',
+  '/scr:track merge': 'merging revision tracks is a writer-owned decision',
+  '/scr:undo': 'undo changes state and should stay explicit',
+};
+
+const CATEGORY_ROUTE_POLICIES = {
+  core: { lane: 'mixed', level: 3, reason: 'core lifecycle routes may read, write, or spawn depending on the current stage' },
+  navigation: { lane: 'read-only', level: 1, reason: 'navigation routes should inspect and recommend by default' },
+  quality: { lane: 'agent-or-local', level: 3, reason: 'quality routes may run bounded diagnostics or text transforms' },
+  character_world: { lane: 'local-helper', level: 2, reason: 'character and world routes update project knowledge files' },
+  structure: { lane: 'local-helper', level: 2, reason: 'structure routes update maps, outlines, and state evidence' },
+  structure_management: { lane: 'manual-gated', level: 4, reason: 'structure management can rename, remove, or reorder manuscript units' },
+  review: { lane: 'agent-or-local', level: 3, reason: 'review routes may invoke bounded diagnostic workers' },
+  illustration: { lane: 'local-helper', level: 2, reason: 'illustration routes generate prompts and asset briefs' },
+  publishing: { lane: 'manual-gated', level: 4, reason: 'publishing routes write deliverables and package outputs' },
+  translation: { lane: 'agent-or-local', level: 3, reason: 'translation routes use translator agents or verification helpers' },
+  sacred_exclusive: { lane: 'agent-or-local', level: 3, reason: 'sacred routes perform specialized consistency and reference work' },
+  utility: { lane: 'local-helper', level: 2, reason: 'utility routes perform deterministic diagnostics or project updates' },
+  session: { lane: 'local-helper', level: 2, reason: 'session routes save, compare, resume, or report project state' },
+  collaboration: { lane: 'manual-gated', level: 4, reason: 'collaboration routes change revision tracks and require writer control' },
+};
+
+function normalizeCommandRef(commandName) {
+  if (commandName.startsWith('/scr:')) return commandName;
+  return `/scr:${commandName}`;
+}
+
+function getCommandAutomationPolicy(commandName, command = {}) {
+  const ref = normalizeCommandRef(commandName);
+  if (AGENT_ROUTE_POLICIES[ref]) {
+    return { ref, lane: 'agent-ready', level: 3, reason: AGENT_ROUTE_POLICIES[ref].reason };
+  }
+  if (LOCAL_ROUTE_POLICIES[ref]) {
+    return { ref, lane: 'local-helper', level: 2, reason: LOCAL_ROUTE_POLICIES[ref] };
+  }
+  if (MANUAL_ROUTE_POLICIES[ref]) {
+    return { ref, lane: 'manual-gated', level: 4, reason: MANUAL_ROUTE_POLICIES[ref] };
+  }
+  const categoryPolicy = CATEGORY_ROUTE_POLICIES[command.category] || {
+    lane: 'read-only',
+    level: 1,
+    reason: 'unclassified routes should only suggest until a category policy is added',
+  };
+  return { ref, ...categoryPolicy };
+}
+
 function pathExists(filePath) {
   try {
     fs.accessSync(filePath);
@@ -156,11 +266,124 @@ function countMarkdownFiles(dir) {
   return listFiles(dir, { extensions: ['.md'], recursive: true }).length;
 }
 
+function countFiles(dir, extensions = null) {
+  return listFiles(dir, { extensions, recursive: true }).length;
+}
+
+function anyPathExists(paths) {
+  return paths.some(pathExists);
+}
+
 function containsAny(text, keywords) {
   const haystack = text.toUpperCase();
   return keywords.some((keyword) => haystack.includes(keyword.toUpperCase()));
 }
 
+function detectProjectReadiness(manuscriptDir) {
+  const missing = CORE_PROJECT_FILES.filter((file) => !pathExists(path.join(manuscriptDir, file)));
+  return {
+    state: missing.length ? 'incomplete' : 'ready',
+    missing,
+    suggest: missing.length ? '/scr:scan' : null,
+  };
+}
+
+function detectPlanSignal(manuscriptDir, draftFiles) {
+  const files = listFiles(path.join(manuscriptDir, 'plans'), { extensions: ['.md'], recursive: true });
+  if (files.length === 0) {
+    return { state: 'missing', count: 0, suggest: '/scr:plan' };
+  }
+  if (draftFiles.length === 0) {
+    return { state: 'ready-to-draft', count: files.length, suggest: '/scr:draft' };
+  }
+  if (files.length > draftFiles.length) {
+    return { state: 'partially-drafted', count: files.length, suggest: '/scr:draft' };
+  }
+  return { state: 'covered', count: files.length, suggest: null };
+}
+
+function detectReviewCoverage(draftFiles, reviewFiles) {
+  if (draftFiles.length === 0) {
+    return { state: 'none', suggest: null };
+  }
+  if (reviewFiles.length === 0) {
+    return { state: 'missing', suggest: '/scr:editor-review' };
+  }
+  if (reviewFiles.length < draftFiles.length) {
+    return { state: 'partial', suggest: '/scr:editor-review' };
+  }
+  return { state: 'covered', suggest: null };
+}
+
+function detectNotesSignal(manuscriptDir) {
+  const noteFiles = [
+    ...listFiles(path.join(manuscriptDir, 'notes'), { extensions: ['.md', '.txt'], recursive: true }),
+    path.join(manuscriptDir, 'NOTES.md'),
+    path.join(manuscriptDir, 'TODO.md'),
+  ].filter(pathExists);
+  const pending = noteFiles.filter((file) => containsAny(readText(file), ['TODO', 'FIXME', 'UNRESOLVED', 'QUESTION:', 'NOTE:']));
+  return {
+    state: pending.length ? 'pending' : 'none',
+    count: pending.length,
+    files: pending.map((file) => path.relative(manuscriptDir, file)),
+    suggest: pending.length ? '/scr:check-notes' : null,
+  };
+}
+
+function detectTrackSignal(manuscriptDir) {
+  const tracks = readJson(path.join(manuscriptDir, 'tracks.json'));
+  const proposals = listFiles(path.join(manuscriptDir, 'proposals'), { extensions: ['.md'], recursive: true });
+  const activeTracks = Array.isArray(tracks?.tracks)
+    ? tracks.tracks.filter((track) => track && track.status !== 'merged')
+    : [];
+  let state = 'none';
+  let suggest = null;
+  if (proposals.length > 0) {
+    state = 'proposal-ready';
+    suggest = '/scr:editor-review --proposal';
+  } else if (activeTracks.length > 0) {
+    state = 'active';
+    suggest = '/scr:track';
+  }
+  return {
+    state,
+    activeCount: activeTracks.length,
+    proposalCount: proposals.length,
+    suggest,
+  };
+}
+
+function detectPublishingSignal(manuscriptDir, draftFiles) {
+  const frontMatter = countMarkdownFiles(path.join(manuscriptDir, 'front-matter'));
+  const backMatter = countMarkdownFiles(path.join(manuscriptDir, 'back-matter'));
+  const blurb = pathExists(path.join(manuscriptDir, 'output', 'blurb.md'));
+  const ebookCover = anyPathExists([
+    path.join(manuscriptDir, 'build', 'ebook-cover.jpg'),
+    path.join(manuscriptDir, 'build', 'ebook-cover.png'),
+  ]);
+  const printCover = anyPathExists([
+    path.join(manuscriptDir, 'build', 'paperback-cover.pdf'),
+    path.join(manuscriptDir, 'build', 'hardcover-cover.pdf'),
+  ]);
+  const promptFiles = countFiles(path.join(manuscriptDir, 'illustrations', 'cover'), ['.md']);
+  const gaps = [];
+  if (draftFiles.length > 0 && frontMatter === 0) gaps.push('front-matter');
+  if (draftFiles.length > 0 && backMatter === 0) gaps.push('back-matter');
+  if (draftFiles.length > 0 && !blurb) gaps.push('blurb');
+  if (draftFiles.length > 0 && !ebookCover && promptFiles === 0) gaps.push('cover-art');
+  return {
+    state: gaps.length ? 'gaps' : draftFiles.length ? 'ready' : 'not-started',
+    frontMatter,
+    backMatter,
+    blurb,
+    ebookCover,
+    printCover,
+    coverPrompts: promptFiles,
+    gaps,
+    suggest: gaps.length ? `/scr:${gaps[0]}` : null,
+  };
+}
+
 function scanReviewSignals(manuscriptDir) {
   const reviewDirs = [
     'reviews',
@@ -290,6 +513,13 @@ function chooseRecommendation(signals, counts) {
       alternatives: ['/scr:progress', '/scr:resume-work'],
     };
   }
+  if (signals.tracks?.state === 'proposal-ready') {
+    return {
+      command: signals.tracks.suggest,
+      reason: `${signals.tracks.proposalCount} revision proposal(s) are waiting for review.`,
+      alternatives: ['/scr:track', '/scr:compare', '/scr:progress'],
+    };
+  }
   if (signals.reviews.count > 0) {
     return {
       command: '/scr:editor-review',
@@ -297,6 +527,20 @@ function chooseRecommendation(signals, counts) {
       alternatives: ['/scr:voice-check', '/scr:continuity-check', '/scr:progress'],
     };
   }
+  if (signals.notes?.count > 0) {
+    return {
+      command: signals.notes.suggest,
+      reason: `${signals.notes.count} note file(s) contain unresolved items.`,
+      alternatives: ['/scr:progress', '/scr:scan', '/scr:next'],
+    };
+  }
+  if (signals.plan?.state === 'ready-to-draft' || signals.plan?.state === 'partially-drafted') {
+    return {
+      command: signals.plan.suggest,
+      reason: `${signals.plan.count} plan file(s) exist and drafting is the next connected step.`,
+      alternatives: ['/scr:plan', '/scr:voice-test', '/scr:progress'],
+    };
+  }
   if (counts.drafts === 0) {
     return {
       command: '/scr:plan',
@@ -304,6 +548,13 @@ function chooseRecommendation(signals, counts) {
       alternatives: ['/scr:discuss', '/scr:draft', '/scr:voice-test'],
     };
   }
+  if (signals.reviewCoverage?.state === 'missing' || signals.reviewCoverage?.state === 'partial') {
+    return {
+      command: signals.reviewCoverage.suggest,
+      reason: `Drafts exist but review coverage is ${signals.reviewCoverage.state}.`,
+      alternatives: ['/scr:voice-check', '/scr:continuity-check', '/scr:progress'],
+    };
+  }
   if (signals.translation.state !== 'none') {
     return {
       command: '/scr:back-translate',
@@ -311,6 +562,13 @@ function chooseRecommendation(signals, counts) {
       alternatives: ['/scr:cultural-adaptation', '/scr:multi-publish', '/scr:progress'],
     };
   }
+  if (signals.publishing?.state === 'gaps' && signals.export.state === 'missing') {
+    return {
+      command: signals.publishing.suggest || '/scr:publish',
+      reason: `Publishing prerequisites have gaps: ${signals.publishing.gaps.join(', ')}.`,
+      alternatives: ['/scr:publish', '/scr:export', '/scr:progress'],
+    };
+  }
   if (signals.export.state === 'stale' || signals.export.state === 'missing') {
     return {
       command: signals.export.suggest || '/scr:export',
@@ -332,6 +590,90 @@ function chooseRecommendation(signals, counts) {
   };
 }
 
+function dedupeByCommand(items) {
+  const seen = new Set();
+  return items.filter((item) => {
+    if (seen.has(item.command)) return false;
+    seen.add(item.command);
+    return true;
+  });
+}
+
+function buildAutomationPlan(signals, recommendation) {
+  const spawnPolicy = AGENT_ROUTE_POLICIES[recommendation.command];
+  const localPolicy = LOCAL_ROUTE_POLICIES[recommendation.command];
+  const manualPolicy = MANUAL_ROUTE_POLICIES[recommendation.command];
+  const spawnCandidates = [];
+  const localCandidates = [];
+  const manualGates = [];
+
+  if (spawnPolicy) {
+    spawnCandidates.push({
+      command: recommendation.command,
+      agents: spawnPolicy.agents,
+      reason: spawnPolicy.reason,
+    });
+  }
+  if (signals.plan?.state === 'ready-to-draft' || signals.plan?.state === 'partially-drafted') {
+    spawnCandidates.push({
+      command: '/scr:draft',
+      agents: AGENT_ROUTE_POLICIES['/scr:draft'].agents,
+      reason: 'planned units can be drafted by the drafter route',
+    });
+  }
+  if (signals.reviewCoverage?.state === 'missing' || signals.reviewCoverage?.state === 'partial') {
+    spawnCandidates.push({
+      command: '/scr:editor-review',
+      agents: AGENT_ROUTE_POLICIES['/scr:editor-review'].agents,
+      reason: 'drafts without review coverage should enter the review route',
+    });
+  }
+  if (signals.translation?.state !== 'none') {
+    spawnCandidates.push({
+      command: '/scr:back-translate',
+      agents: AGENT_ROUTE_POLICIES['/scr:back-translate'].agents,
+      reason: 'translation work needs a verification pass',
+    });
+  }
+
+  if (localPolicy) {
+    localCandidates.push({ command: recommendation.command, reason: localPolicy });
+  }
+  if (signals.context?.state === 'stale') {
+    localCandidates.push({ command: signals.context.suggest || '/scr:scan', reason: 'refresh stale context before chaining work' });
+  }
+  if (signals.notes?.count > 0) {
+    localCandidates.push({ command: '/scr:check-notes', reason: 'surface unresolved notes before the next writing route' });
+  }
+  if (signals.save?.state !== 'clean') {
+    localCandidates.push({ command: signals.save.suggest || '/scr:save', reason: 'save manuscript changes before branching or packaging' });
+  }
+
+  if (manualPolicy) {
+    manualGates.push({ command: recommendation.command, reason: manualPolicy });
+  }
+  if (signals.publishing?.state === 'gaps') {
+    manualGates.push({
+      command: '/scr:publish',
+      reason: `publishing still needs ${signals.publishing.gaps.join(', ')}`,
+    });
+  }
+  if (signals.tracks?.state === 'active' || signals.tracks?.state === 'proposal-ready') {
+    manualGates.push({
+      command: signals.tracks.suggest || '/scr:track',
+      reason: 'revision-track decisions belong to the writer',
+    });
+  }
+
+  const recommendationIsManual = manualGates.some((gate) => gate.command === recommendation.command);
+  return {
+    mode: recommendationIsManual ? 'manual-gated' : spawnCandidates.length ? 'agent-ready' : localCandidates.length ? 'local-helper' : 'read-only',
+    spawnCandidates: dedupeByCommand(spawnCandidates),
+    localCandidates: dedupeByCommand(localCandidates),
+    manualGates: dedupeByCommand(manualGates),
+  };
+}
+
 function analyzeProject(projectRoot = process.cwd(), options = {}) {
   const root = path.resolve(projectRoot);
   const manuscriptDir = options.manuscriptDir || path.join(root, '.manuscript');
@@ -346,11 +688,18 @@ function analyzeProject(projectRoot = process.cwd(), options = {}) {
       context: { state: 'none', suggest: null },
       history: { state: 'none', lastFailed: false },
       reviews: { state: 'none', count: 0, files: [] },
+      reviewCoverage: { state: 'none', suggest: null },
+      readiness: { state: 'none', missing: [], suggest: null },
+      plan: { state: 'none', count: 0, suggest: null },
+      notes: { state: 'none', count: 0, files: [], suggest: null },
+      tracks: { state: 'none', activeCount: 0, proposalCount: 0, suggest: null },
       translation: { state: 'none', count: 0, configuredTargets: [] },
       export: { state: 'none', suggest: null },
+      publishing: { state: 'not-started', gaps: [], suggest: null },
       save: { state: 'clean', suggest: null },
     };
     const recommendation = chooseRecommendation(signals, { drafts: 0 });
+    const automation = buildAutomationPlan(signals, recommendation);
     return {
       projectRoot: root,
       manuscriptDir,
@@ -359,12 +708,13 @@ function analyzeProject(projectRoot = process.cwd(), options = {}) {
       counts: { drafts: 0, plans: 0, reviews: 0 },
       signals,
       recommendation,
+      automation,
     };
   }
 
   const draftFiles = listFiles(path.join(manuscriptDir, 'drafts'), { extensions: ['.md'], recursive: true });
-  const planCount = countMarkdownFiles(path.join(manuscriptDir, 'plans'));
   const reviewFiles = scanReviewSignals(manuscriptDir);
+  const allReviewFiles = listFiles(path.join(manuscriptDir, 'reviews'), { extensions: ['.md', '.txt'], recursive: true });
   const historySignal = detectHistorySignal(manuscriptDir);
   const sourceFiles = [
     statePath,
@@ -379,21 +729,28 @@ function analyzeProject(projectRoot = process.cwd(), options = {}) {
     hasState: pathExists(statePath),
     context: detectContextSignal(manuscriptDir, draftFiles),
     history: historySignal,
+    readiness: detectProjectReadiness(manuscriptDir),
+    plan: detectPlanSignal(manuscriptDir, draftFiles),
     reviews: {
       state: reviewFiles.length ? 'pending' : 'none',
       count: reviewFiles.length,
       files: reviewFiles,
     },
+    reviewCoverage: detectReviewCoverage(draftFiles, allReviewFiles),
+    notes: detectNotesSignal(manuscriptDir),
+    tracks: detectTrackSignal(manuscriptDir),
     translation: detectTranslationSignal(manuscriptDir, config),
     export: detectExportSignal(manuscriptDir, sourceFiles),
+    publishing: detectPublishingSignal(manuscriptDir, draftFiles),
     save: detectSaveSignal(historySignal, draftFiles),
   };
   const counts = {
     drafts: draftFiles.length,
-    plans: planCount,
+    plans: signals.plan.count,
     reviews: reviewFiles.length,
   };
   const recommendation = chooseRecommendation(signals, counts);
+  const automation = buildAutomationPlan(signals, recommendation);
   return {
     projectRoot: root,
     manuscriptDir,
@@ -402,6 +759,7 @@ function analyzeProject(projectRoot = process.cwd(), options = {}) {
     counts,
     signals,
     recommendation,
+    automation,
   };
 }
 
@@ -413,9 +771,15 @@ function formatProactiveChecks(analysis) {
   return [
     'Proactive checks:',
     stateLine,
+    `  Readiness: ${signals.readiness?.state || 'none'}${signals.readiness?.missing?.length ? `, missing ${signals.readiness.missing.join(', ')}` : ''}`,
     `  Session: ${signals.context.state}${signals.context.suggest ? `, suggest ${signals.context.suggest}` : ''}`,
+    `  Plans: ${signals.plan?.state || 'none'}${signals.plan?.suggest ? `, suggest ${signals.plan.suggest}` : ''}`,
     `  Reviews: ${signals.reviews.count ? `${signals.reviews.count} pending, suggest /scr:editor-review` : 'none'}`,
+    `  Review coverage: ${signals.reviewCoverage?.state || 'none'}${signals.reviewCoverage?.suggest ? `, suggest ${signals.reviewCoverage.suggest}` : ''}`,
+    `  Notes: ${signals.notes?.count ? `${signals.notes.count} pending, suggest ${signals.notes.suggest}` : 'none'}`,
+    `  Tracks: ${signals.tracks?.state || 'none'}${signals.tracks?.suggest ? `, suggest ${signals.tracks.suggest}` : ''}`,
     `  Translation: ${signals.translation.state}`,
+    `  Publishing: ${signals.publishing?.state || 'none'}${signals.publishing?.gaps?.length ? `, gaps ${signals.publishing.gaps.join(', ')}` : ''}`,
     `  Export: ${signals.export.state}${signals.export.suggest ? `, suggest ${signals.export.suggest}` : ''}`,
     `  Save: ${signals.save.state}${signals.save.suggest ? `, suggest ${signals.save.suggest}` : ''}`,
   ].join('\n');
@@ -425,14 +789,31 @@ function formatAutomationStatus(analysis, options = {}) {
   const trigger = options.trigger || '/scr:next';
   const localOperation = options.localOperation || 'auto-invoke engine: read-only';
   const autoInvoked = options.autoInvoked || `${analysis.recommendation.command}: no`;
+  const automation = analysis.automation || { mode: 'read-only', spawnCandidates: [], localCandidates: [], manualGates: [] };
+  const candidateAgentLines = automation.spawnCandidates.length
+    ? automation.spawnCandidates.map((candidate) => `- ${candidate.command}: ${candidate.agents.join(', ')} (${candidate.reason})`)
+    : ['- none'];
+  const localCandidateLines = automation.localCandidates.length
+    ? automation.localCandidates.map((candidate) => `- ${candidate.command}: ${candidate.reason}`)
+    : ['- none'];
+  const manualGateLines = automation.manualGates.length
+    ? automation.manualGates.map((gate) => `- ${gate.command}: ${gate.reason}`)
+    : ['- none'];
   return [
     'Automation status:',
     `Trigger: ${trigger}`,
+    `Mode: ${automation.mode}`,
     'Spawned agents:',
     '- none',
+    'Candidate agents:',
+    ...candidateAgentLines,
     'Local operations:',
     `- ${localOperation}`,
     `- state route computed: ${analysis.signals.hasProject ? 'yes' : 'no project'}`,
+    'Candidate local helpers:',
+    ...localCandidateLines,
+    'Manual gates:',
+    ...manualGateLines,
     'Auto-invoked:',
     `- ${autoInvoked}`,
     `Why: ${analysis.recommendation.reason}`,
@@ -508,12 +889,17 @@ if (require.main === module) {
 }
 
 module.exports = {
+  AGENT_ROUTE_POLICIES,
+  CATEGORY_ROUTE_POLICIES,
   DEFAULT_RUNTIME_SUPPORT,
+  LOCAL_ROUTE_POLICIES,
+  MANUAL_ROUTE_POLICIES,
   analyzeProject,
   formatProactiveChecks,
   formatAutomationStatus,
   formatRecommendation,
   formatReport,
+  getCommandAutomationPolicy,
   getRuntimeAgentSupport,
   listRuntimeAgentSupport,
   parseCliArgs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scriveno",
-  "version": "2.0.8",
+  "version": "2.0.9",
   "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,30 +1,26 @@
 {
-  "scriveno_version": "2.0.8",
+  "scriveno_version": "2.0.9",
   "work_type": "",
   "group": "",
   "command_unit": "",
   "developer_mode": false,
   "created_at": "",
   "updated_at": "",
-
   "autopilot": {
     "enabled": false,
     "profile": "guided",
     "custom_checkpoints": []
   },
-
   "voice": {
     "calibrated": false,
     "last_calibration": null,
     "drift_threshold": 0.3
   },
-
   "draft": {
     "rigor": "standard",
     "context_profile": "standard",
     "pitfalls_enabled": true
   },
-
   "export": {
     "default_format": "docx_manuscript",
     "include_front_matter": true,
@@ -36,14 +32,12 @@
       "margins": "1in"
     }
   },
-
   "translation": {
     "source_language": "en",
     "target_languages": [],
     "name_handling": "keep_original",
     "measurement_system": "source"
   },
-
   "technical": {
     "audience_level": "mixed",
     "prerequisite_knowledge": [],
@@ -52,18 +46,15 @@
     "source_of_truth": [],
     "review_mode": "accuracy_first"
   },
-
   "collaboration": {
     "tracks_enabled": false,
     "default_track": "canon"
   },
-
   "illustration": {
     "style": null,
     "cover_enabled": false,
     "interior_enabled": false
   },
-
   "git": {
     "auto_commit": true,
     "commit_message_style": "descriptive",