dsh-novel-write-engine 0.1.2 → 0.2.0

package/lib/index.d.ts

@@ -22,8 +22,8 @@ declare const SCENE_TYPES: readonly ["战斗/动作章", "日常过渡章", "情
 type SceneType = (typeof SCENE_TYPES)[number];
 /** A violation is blocking unless the rule pack declares it advisory. */
 type Severity = 'blocker' | 'advisory';
-/** All twenty-two service operations. */
-declare const OPERATIONS: readonly ["initProject", "archiveChapter", "amend", "rollback", "submitWorldPlan", "submitChapterPlan", "submitDraft", "submitReview", "submitRevision", "runCheck", "getStatus", "getBrief", "countWords", "queryState", "diff", "auditHistory", "advise", "export", "panelSummary", "panelChapters", "panelGates", "stats"];
+/** All thirty-one service operations (22 inherited from 0.1.x, 9 book-level). */
+declare const OPERATIONS: readonly ["initProject", "archiveChapter", "amend", "rollback", "reopenChapter", "submitWorldPlan", "submitChapterPlan", "submitDraft", "submitReview", "submitRevision", "runCheck", "submitBookPlan", "submitOutline", "importOutline", "submitWorldbook", "getStatus", "getBrief", "countWords", "queryState", "diff", "auditHistory", "advise", "search", "doctor", "report", "guide", "export", "panelSummary", "panelChapters", "panelGates", "stats"];
 type Operation = (typeof OPERATIONS)[number];
 /** Structured, non-fatal note attached to a successful result. */
 interface Warning {
@@ -72,6 +72,8 @@ declare const ERROR_CODES: {
   readonly PATH_ESCAPE: "ENGINE_PATH_ESCAPE";
   readonly LOCK_TIMEOUT: "ENGINE_LOCK_TIMEOUT";
   readonly TXN_ABORTED: "ENGINE_TXN_ABORTED";
+  readonly JOURNAL_MISSING: "ENGINE_JOURNAL_MISSING";
+  readonly TXN_IN_PROGRESS: "ENGINE_TXN_IN_PROGRESS";
   readonly RULEPACK_INVALID: "ENGINE_RULEPACK_INVALID";
   readonly ID_EXHAUSTED: "ENGINE_ID_EXHAUSTED";
   readonly CONFIG_INVALID: "ENGINE_CONFIG_INVALID";
@@ -171,10 +173,12 @@ interface CheckDocument {
   };
   verdict: 'pass' | 'fail';
 }
+/** Every persisted document whose damage status/panel can report. */
+type StateErrorCode = 'PROJECT_UNREADABLE' | 'PLAN_UNREADABLE' | 'WORLD_PLAN_UNREADABLE' | 'REVIEW_UNREADABLE' | 'CHECK_UNREADABLE' | 'CHAPTERS_UNREADABLE' | 'CHARACTERS_UNREADABLE' | 'WORLD_UNREADABLE' | 'LOCKS_UNREADABLE' | 'TIMELINE_UNREADABLE' | 'FORESHADOWS_UNREADABLE' | 'RELATIONSHIPS_UNREADABLE' | 'HANDOFF_UNREADABLE' | 'OUTLINE_UNREADABLE' | 'WORLDBOOK_UNREADABLE';
 /** A state document that exists but cannot be read safely. */
 interface StateError {
   path: string;
-  code: 'PLAN_UNREADABLE' | 'REVIEW_UNREADABLE' | 'CHECK_UNREADABLE';
+  code: StateErrorCode;
   message: string;
 }
 /** Word statistics with the single engine-wide counting rule. */
@@ -503,6 +507,14 @@ interface WorldPlanInput {
   }>;
   continuity_notes: string[];
 }
+/** A character the chapter plan puts on stage; no new persisted schema. */
+interface ChapterCastMember {
+  name: string;
+  entry_state?: string;
+  goal?: string;
+  knowledge?: string[];
+  exit_change?: string;
+}
 /** Chapter plan (`plans/chNNN.chapter.yaml`). */
 interface ChapterPlanInput {
   chapter: number;
@@ -513,6 +525,267 @@ interface ChapterPlanInput {
   opening: string;
   ending: string;
   target_words: [number, number];
+  /** Optional in 0.1.3: older plans remain readable; new plans may name 1–8 actors. */
+  cast?: ChapterCastMember[];
+}
+/** Book-level pitch and structure, persisted in `outline/outline.yaml`. */
+interface BookPlan {
+  premise: string;
+  logline: string;
+  themes: string[];
+  tone: string;
+  pov: string;
+  audience: string;
+  selling_points: string[];
+  ending: string;
+  /** Strict mode requires a chapter card before P2/P3 for every chapter. */
+  strict: boolean;
+  /** True once the author explicitly chose strict on/off; used for the first-outline default. */
+  strict_explicit?: boolean;
+}
+/** One volume of the planned book. `end_chapter` is inclusive. */
+interface OutlineVolume {
+  id: string;
+  title: string;
+  start_chapter: number;
+  end_chapter: number;
+  goal: string;
+  arc: string;
+  climax: string;
+  status: 'planned' | 'writing' | 'done';
+}
+/** One planned chapter card. Only the archive transaction may write the archived fields. */
+interface OutlineChapter {
+  num: number;
+  volume: number | null;
+  title: string;
+  scene_type: SceneType;
+  goal: string;
+  conflict: string;
+  hook: string;
+  cast: string[];
+  target_words: [number, number];
+  notes: string;
+  status: 'planned' | 'archived';
+  archived_at: string | null;
+  word_count: number | null;
+  score: number | null;
+}
+/** The planning SSOT read by P1–P8, PG-13, report, doctor and export. */
+interface OutlineDocument {
+  schema_version: 1;
+  updated_at: string;
+  book: BookPlan;
+  volumes: OutlineVolume[];
+  chapters: OutlineChapter[];
+}
+/** One worldbuilding rule/constraint. */
+interface WorldbookRule {
+  name: string;
+  description: string;
+}
+/** One faction in the world bible. */
+interface WorldbookFaction {
+  name: string;
+  description: string;
+  goal: string;
+}
+/** One location in the world bible. */
+interface WorldbookLocation {
+  name: string;
+  description: string;
+  layout: string;
+  capacity: number;
+}
+/** One planned character (not the post-prose ledger entry). */
+interface WorldbookCharacter {
+  name: string;
+  role: string;
+  description: string;
+  arc: string;
+}
+/** One glossary entry. */
+interface WorldbookGlossary {
+  term: string;
+  definition: string;
+}
+/** One backstory event. */
+interface WorldbookBackstory {
+  time: string;
+  event: string;
+}
+/** Worldbuilding plan, persisted in `outline/worldbook.yaml`. */
+interface WorldbookDocument {
+  schema_version: 1;
+  updated_at: string;
+  premise: string;
+  setting: string;
+  rules: WorldbookRule[];
+  factions: WorldbookFaction[];
+  locations: WorldbookLocation[];
+  characters: WorldbookCharacter[];
+  glossary: WorldbookGlossary[];
+  backstory: WorldbookBackstory[];
+  themes: string[];
+}
+/** One hit from `novel_search`; the scope names the source family. */
+interface SearchResultItem {
+  kind: 'chapters' | 'summaries' | 'outline' | 'worldbook' | 'ledgers';
+  chapter?: number;
+  title?: string;
+  paragraph?: number;
+  snippet: string;
+}
+/** Search response; `total` counts every matching segment, `results` is capped by `limit`. */
+interface SearchReport {
+  query: string;
+  scope: 'all' | 'chapters' | 'summaries' | 'outline' | 'worldbook' | 'ledgers';
+  total: number;
+  truncated: boolean;
+  results: SearchResultItem[];
+}
+/** One structured health check. */
+interface DoctorCheck {
+  id: string;
+  severity: 'ok' | 'info' | 'warning' | 'error';
+  title: string;
+  detail: string;
+  hint?: string;
+}
+/** `novel_doctor` payload; a missing project is reported, never thrown. */
+interface DoctorReport {
+  ok: boolean;
+  root: string;
+  checks: DoctorCheck[];
+  summary: {
+    errors: number;
+    warnings: number;
+    infos: number;
+  };
+}
+/** Book-wide quality, outline, cast and pacing aggregates. */
+interface BookReport {
+  progress: {
+    archived: number;
+    target: number | null;
+    words: number;
+    average_words: number;
+    percent: number;
+    remaining_words: number | null;
+  };
+  outline: {
+    present: boolean;
+    strict: boolean;
+    planned: number;
+    archived: number;
+    coverage: number;
+    volumes: Array<{
+      title: string;
+      start: number;
+      end: number;
+      planned: number;
+      archived: number;
+    }>;
+    drift: Array<{
+      chapter: number;
+      field: string;
+      planned: string;
+      actual: string;
+    }>;
+  };
+  worldbook: {
+    present: boolean;
+    characters: number;
+    locations: number;
+    factions: number;
+    rules: number;
+    glossary: number;
+    backstory: number;
+  };
+  quality: {
+    average: number;
+    median: number;
+    min: number;
+    max: number;
+    last_five: number[];
+    trend: number;
+    dimensions: Array<{
+      id: string;
+      average: number;
+      samples: number;
+    }>;
+  };
+  pacing: {
+    scene_types: Record<string, number>;
+    hook_strength: Record<string, number>;
+    plot_advancement: Record<string, number>;
+    longest: {
+      chapter: number;
+      words: number;
+    } | null;
+    shortest: {
+      chapter: number;
+      words: number;
+    } | null;
+  };
+  cast: {
+    total: number;
+    top: Array<{
+      name: string;
+      appearances: number;
+      last_seen: number;
+      role: string;
+    }>;
+  };
+  foreshadows: {
+    open: number;
+    dormant: number;
+    overdue: number;
+    resolved: number;
+    oldest: Array<{
+      id: string;
+      title: string;
+      last_touched: number;
+      age: number;
+    }>;
+  };
+  timeline: {
+    events: number;
+    first_chapter: number | null;
+    last_chapter: number | null;
+  };
+  relationships: {
+    total: number;
+    types: Record<string, number>;
+  };
+  activity: Array<{
+    at: string;
+    op: string;
+    chapter: number;
+    status: string;
+  }>;
+  warnings: string[];
+}
+/** One onboarding step. */
+interface GuideStep {
+  id: string;
+  title: string;
+  detail: string;
+  done: boolean;
+  tool?: string;
+}
+/** `novel_guide` payload. */
+interface GuideReport {
+  state: 'no-project' | 'new' | 'planning' | 'writing' | 'blocked' | 'finished';
+  title: string;
+  steps: GuideStep[];
+  next: {
+    tool: string;
+    args: Record<string, unknown>;
+    reason: string;
+  };
+  commands: string[];
+  tips: string[];
 }
 /** Draft submission payload. */
 interface DraftInput {
@@ -586,6 +859,12 @@ interface GateInput {
   /** The three preceding chapters, newest first, for the duplicate rule. */
   previousTexts: string[];
   priorSceneTypes: SceneType[];
+  /** 0.2.0 planning input; undefined means "no outline" for older fixtures. */
+  outline?: OutlineDocument | null;
+  /** The chapter plan's target range, used by PG-13. */
+  planTargetWords?: [number, number] | null;
+  /** The chapter plan's declared cast names, used by PG-13. */
+  planCast?: string[] | null;
 }
 /** Gate evaluation outcome. */
 interface GateResult {
@@ -616,9 +895,38 @@ interface StatusReport {
   stage: Stage;
   rounds: RoundCounters;
   blocking: BlockingItem[];
-  /** plan/review/check files that exist but cannot be read safely. */
+  /** plan/review/check/ledger files that exist but cannot be read safely. */
   state_errors: StateError[];
   metrics: WordMetrics | null;
+  /** Inherited handoff labels; absent before the first archive. */
+  volume?: number;
+  volume_name?: string;
+  act?: string;
+  act_progress?: string;
+  /** 0.2.0 book-level visibility; absent on older synthetic payloads. */
+  book?: {
+    premise: string;
+    logline: string;
+    strict: boolean;
+    outline: {
+      present: boolean;
+      total: number;
+      planned: number;
+      archived: number;
+      coverage: number;
+      volumes: number;
+      current: OutlineChapter | null;
+    };
+    worldbook: {
+      present: boolean;
+      characters: number;
+      locations: number;
+      factions: number;
+      rules: number;
+      glossary: number;
+      backstory: number;
+    };
+  };
   next: {
     tool: string;
     args: Record<string, unknown>;
@@ -657,8 +965,8 @@ interface DiffReport {
     line: string;
   }>;
 }
-/** Export capabilities. */
-type ExportKind = 'md' | 'txt' | 'epub';
+/** Export capabilities; the last three are book-planning deliverables. */
+type ExportKind = 'md' | 'txt' | 'epub' | 'outline' | 'worldbook' | 'proposal';
 /** One blacklisted word. */
 interface TermEntry {
   term: string;
@@ -786,13 +1094,65 @@ interface Rulepack {
   exemptions: string[];
 }
 /** Every persisted document the engine knows how to load. */
-type DocKind = 'project' | 'pipeline' | 'chapters' | 'characters' | 'world' | 'locks' | 'foreshadows' | 'timeline' | 'relationships' | 'handoff' | 'review' | 'check' | 'worldPlan' | 'chapterPlan';
+type DocKind = 'project' | 'pipeline' | 'chapters' | 'characters' | 'world' | 'locks' | 'foreshadows' | 'timeline' | 'relationships' | 'handoff' | 'review' | 'check' | 'worldPlan' | 'chapterPlan' | 'outline' | 'worldbook';
 /** One project row in the cross-project registry. */
 interface RegistryEntry {
   root: string;
   title: string;
   updated_at: string;
 }
+interface BookPatch {
+  premise?: string;
+  logline?: string;
+  themes?: string[];
+  tone?: string;
+  pov?: string;
+  audience?: string;
+  selling_points?: string[];
+  ending?: string;
+  strict?: boolean;
+  /** Internal provenance for an explicit strict choice. */
+  strict_explicit?: boolean;
+}
+interface VolumeInput {
+  id?: string;
+  title: string;
+  start_chapter: number;
+  end_chapter: number;
+  goal?: string;
+  arc?: string;
+  climax?: string;
+  status?: OutlineVolume['status'];
+}
+interface OutlineChapterInput {
+  num: number;
+  volume?: number | null;
+  title: string;
+  scene_type: SceneType;
+  goal: string;
+  conflict: string;
+  hook: string;
+  cast?: string[];
+  target_words: [number, number];
+  notes?: string;
+}
+interface OutlineInput {
+  book?: BookPatch;
+  volumes?: VolumeInput[];
+  chapters: OutlineChapterInput[];
+  strict?: boolean;
+}
+interface WorldbookPatch {
+  premise?: string;
+  setting?: string;
+  rules?: WorldbookRule[];
+  factions?: WorldbookFaction[];
+  locations?: WorldbookLocation[];
+  characters?: WorldbookCharacter[];
+  glossary?: WorldbookGlossary[];
+  backstory?: WorldbookBackstory[];
+  themes?: string[];
+}
 /** One rendered task book. */
 interface BriefDocument {
   stage: BriefStage;
@@ -829,6 +1189,7 @@ declare const GATES: {
   readonly 'PG-10': "CONSISTENCY";
   readonly 'PG-11': "ROUNDS";
   readonly 'PG-12': "ARCHIVE_ATOMIC";
+  readonly 'PG-13': "OUTLINE_ALIGNMENT";
 };
 type GateId = keyof typeof GATES;
 /** Everything gate evaluation needs beyond the input: taste comes from the pack. */
@@ -840,7 +1201,7 @@ interface GateOptions {
 declare function parseParagraphLocation(location: string): number | null;
 /** Verify one reading-proof reference against the manuscript. */
 declare function verifyReference(text: string, reference: ReadingProofReference): string | null;
-/** Evaluate all twelve gates and return every blocking item, in canonical order. */
+/** Evaluate all thirteen gates and return every blocking item, in canonical order. */
 declare function evaluateGates(input: GateInput, options: GateOptions): GateResult;
 /**
  * Which gates apply to an operation. A gate that does not apply must not run:
@@ -874,6 +1235,10 @@ interface PanelSnapshot {
     check: number;
   };
   blocking: BlockingItem[];
+  volume?: number;
+  volume_name?: string;
+  act?: string;
+  act_progress?: string;
   /** Recommended next action; lets the panel explain a stage with no blockers. */
   next?: StatusReport['next'];
   /** True only when the configured total chapter target has been reached. */
@@ -883,12 +1248,61 @@ interface PanelSnapshot {
   draft?: PanelDraft | null;
   /** Total words across the index, for the header. */
   totalWords: number;
+  /** Book-wide archived average, not just the panel's capped rows. */
+  averageScore?: number;
   /** The nine-phase strip state, derived from the pipeline stage. */
   phases: Array<{
     id: string;
     done: boolean;
     active: boolean;
   }>;
+  /** 0.2.0 book-level planning and health blocks. */
+  book?: PanelBook;
+  quality?: {
+    averageScore: number;
+    scores: number[];
+    trend: number;
+  };
+  health?: {
+    ok: boolean;
+    blocking: number;
+    stateErrors: number;
+  };
+  activity?: Array<{
+    at: string;
+    op: string;
+    chapter: number;
+    status: string;
+  }>;
+}
+interface PanelBook {
+  premise: string;
+  logline: string;
+  strict: boolean;
+  target: number | null;
+  outline: {
+    present: boolean;
+    total: number;
+    planned: number;
+    archived: number;
+    coverage: number;
+    volumes: Array<{
+      title: string;
+      start: number;
+      end: number;
+      planned: number;
+      archived: number;
+    }>;
+  };
+  worldbook: {
+    present: boolean;
+    characters: number;
+    locations: number;
+    factions: number;
+    rules: number;
+    glossary: number;
+    backstory: number;
+  };
 }
 interface PanelSummaryDto {
   schemaVersion: number;
@@ -901,6 +1315,12 @@ interface PanelSummaryDto {
   revision: number;
   totalWords: number;
   totalChapters: number;
+  /** Book-wide archived average; absent on older payloads. */
+  averageScore?: number;
+  volume?: number;
+  volume_name?: string;
+  act?: string;
+  act_progress?: string;
   phases: Array<{
     id: string;
     done: boolean;
@@ -913,6 +1333,24 @@ interface PanelSummaryDto {
   };
   /** Absent for older payloads; false means the current chapter cycle is done. */
   finished?: boolean;
+  /** 0.2.0 planning, quality, health and activity blocks. */
+  book?: PanelBook;
+  quality?: {
+    averageScore: number;
+    scores: number[];
+    trend: number;
+  };
+  health?: {
+    ok: boolean;
+    blocking: number;
+    stateErrors: number;
+  };
+  activity?: Array<{
+    at: string;
+    op: string;
+    chapter: number;
+    status: string;
+  }>;
 }
 interface PanelChapterRow {
   num: number;
@@ -992,6 +1430,31 @@ type EngineEvent = {
     path: string;
     reason: string;
   };
+} | {
+  name: 'novel/planned';
+  payload: {
+    schemaVersion: 1;
+    projectRoot: string;
+    kind: 'blueprint' | 'outline' | 'worldbook';
+    chapters: number;
+    volumes: number;
+  };
+} | {
+  name: 'novel/reopened';
+  payload: {
+    schemaVersion: 1;
+    projectRoot: string;
+    chapter: number;
+    restore_txid: string;
+  };
+} | {
+  name: 'novel/exported';
+  payload: {
+    schemaVersion: 1;
+    projectRoot: string;
+    kind: string;
+    files: number;
+  };
 };
 interface InitProjectInput {
   title: string;
@@ -1002,6 +1465,17 @@ interface InitProjectInput {
   words_per_chapter?: [number, number];
   total_chapters?: number | null;
   dialogue_ratio?: [number, number];
+  /** 0.2.0 book-planning seed; every field is optional. */
+  premise?: string;
+  logline?: string;
+  themes?: string[];
+  tone?: string;
+  pov?: string;
+  audience?: string;
+  selling_points?: string[];
+  ending?: string;
+  /** Strict outline is opt-in; a new project defaults to false. */
+  strict_outline?: boolean;
   root?: string;
 }
 interface StatusInput {
@@ -1041,7 +1515,7 @@ interface RevisionSubmission extends Omit<RevisionInput, 'summary'> {
 }
 interface CheckSubmission {
   chapter: number;
-  /** The four P6 semantic items; omission is a failed check, never a pass. */
+  /** The five P6 semantic items; omission is a failed check, never a pass. */
   semantic: SemanticItem[];
   scope?: string[];
   root?: string;
@@ -1067,7 +1541,7 @@ interface RollbackSubmission {
   root?: string;
 }
 interface DiffInput {
-  chapter: number;
+  chapter?: number;
   before?: string;
   after?: string;
   root?: string;
@@ -1084,6 +1558,10 @@ interface ExportInput {
 interface StateQueryInput {
   kind: DocKind | 'novel' | 'planWorld' | 'planChapter';
   chapter?: number;
+  /** Chapter index defaults to a compact read; opt in to the full summaries. */
+  include_summary?: boolean;
+  /** Inclusive chapter range for the `chapters` index. */
+  chapter_range?: [number, number];
   root?: string;
 }
 interface WordCountInput {
@@ -1091,6 +1569,43 @@ interface WordCountInput {
   chapter?: number;
   root?: string;
 }
+interface BookPlanSubmission extends BookPatch {
+  volumes?: VolumeInput[];
+  root?: string;
+}
+interface OutlineSubmission extends OutlineInput {
+  root?: string;
+}
+interface OutlineImportSubmission {
+  format: 'markdown' | 'yaml' | 'json';
+  content: string;
+  dry_run?: boolean;
+  root?: string;
+}
+interface WorldbookSubmission extends WorldbookPatch {
+  root?: string;
+}
+interface ReopenSubmission {
+  chapter: number;
+  /** A reopen is a history-changing maintenance action; the reason is mandatory. */
+  reason: string;
+  root?: string;
+}
+interface SearchInput {
+  query: string;
+  scope?: 'all' | 'chapters' | 'summaries' | 'outline' | 'worldbook' | 'ledgers';
+  limit?: number;
+  root?: string;
+}
+interface DoctorInput {
+  root?: string;
+}
+interface ReportSubmission {
+  root?: string;
+}
+interface GuideInput {
+  root?: string;
+}
 /**
  * The single write authority. Tools, commands, the panel and task books never
  * touch a file; every mutation is one of these operations.
@@ -1100,6 +1615,8 @@ declare class EngineService {
   private readonly stores;
   private readonly mutex;
   private readonly replay;
+  /** Status, panel and gates ask for the same stage context repeatedly. */
+  private readonly briefContextCache;
   private readonly briefs;
   private readonly now;
   /** The project this process last touched; the panel follows it without a workspace hint. */
@@ -1139,6 +1656,45 @@ declare class EngineService {
     chapter: number;
     stage: Stage;
   }>>;
+  submitBookPlan(input: BookPlanSubmission): Promise<OpResult<{
+    premise: string;
+    logline: string;
+    strict: boolean;
+    volumes: number;
+    chapters: number;
+  }>>;
+  submitOutline(input: OutlineSubmission): Promise<OpResult<{
+    planned: number;
+    archived: number;
+    total: number;
+    strict: boolean;
+    volumes: number;
+  }>>;
+  importOutline(input: OutlineImportSubmission): Promise<OpResult<{
+    format: string;
+    planned: number;
+    archived: number;
+    total: number;
+    warnings: string[];
+    preview: string;
+    applied: boolean;
+  }>>;
+  submitWorldbook(input: WorldbookSubmission): Promise<OpResult<{
+    sections: string[];
+    entries: number;
+    counts: Record<string, number>;
+  }>>;
+  reopenChapter(input: ReopenSubmission): Promise<OpResult<{
+    chapter: number;
+    stage: Stage;
+    restore_txid: string;
+  }>>;
+  /**
+   * Read-only paths must surface a committed-journal mismatch. The write path
+   * already fails closed; without this, status recommends the next write and
+   * the model only learns about the mismatch when that write aborts.
+   */
+  private journalBlocking;
   getStatus(input?: StatusInput): Promise<OpResult<StatusReport>>;
   countWords(input?: WordCountInput): Promise<OpResult<WordMetrics>>;
   queryState(input: StateQueryInput): Promise<OpResult<unknown>>;
@@ -1153,6 +1709,11 @@ declare class EngineService {
     blocking: BlockingItem[];
     state_errors: StateError[];
   }>>;
+  search(input: SearchInput): Promise<OpResult<SearchReport>>;
+  doctor(input?: DoctorInput): Promise<OpResult<DoctorReport>>;
+  private recoveryForSafe;
+  report(input?: ReportSubmission): Promise<OpResult<BookReport>>;
+  guide(input?: GuideInput): Promise<OpResult<GuideReport>>;
   getBrief(input: BriefInput): Promise<OpResult<{
     stage: string;
     chapter: number;
@@ -1245,6 +1806,12 @@ declare class EngineService {
     averageScore: number;
     lastScore: number;
     openForeshadows: number;
+    plannedChapters: number;
+    outlineCoverage: number;
+    blueprintReady: boolean;
+    worldbookEntries: number;
+    strictOutline: boolean;
+    targetChapters: number | null;
   }>;
   private registry;
   /** List known projects (convenience only; a project opens without a row). */
@@ -1286,12 +1853,62 @@ declare class EngineService {
     preview: string;
     applied: boolean;
   }>>;
+  /**
+   * Planning writes use project targets as invariants. The fallback project is
+   * only for reads; writing against its null target (or default word range)
+   * would create a document the real novel.yaml rejects after repair.
+   */
+  private assertProjectReadable;
+  /**
+   * Planning documents are read-only inputs to the write tools. A corrupt file
+   * must be repaired explicitly with novel_amend; allowing a normal write to
+   * proceed would silently replace every planned card or worldbook section it
+   * could not read.
+   */
+  private assertPlanningDocumentReadable;
+  /**
+   * A strict outline cannot silently lose the active chapter's card while the
+   * chapter is still being written. Otherwise a late replacement turns a
+   * strict project non-strict in effect and archive would auto-create the card
+   * the author was required to provide.
+   */
+  private assertActiveCardPreserved;
+  /**
+   * The outline is a derived progress view and the PG-13 input. Every write
+   * path must stage a document the loader will accept; otherwise a successful
+   * archive/planning call can leave the project with an unreadable outline and
+   * an unreachable repair path. Auto-created cards are normalized by book.ts;
+   * this is the final fail-closed boundary for all callers.
+   */
+  private assertOutlineWritable;
+  /**
+   * total_chapters is a hard ceiling everywhere: outline cards already enforce
+   * it, and writing/archiving a chapter past it would make the auto-created
+   * archived card invalid. Fail at the first stage instead of after the draft.
+   */
+  private assertChapterWithinTarget;
+  /**
+   * Without the chapter index, normalizeOutlineChapters cannot re-add archived
+   * cards and cannot prove that a replacement did not delete them. Planning
+   * writes must wait for a chapters repair; only novel_amend may repair it.
+   */
+  private assertArchiveIndexReadable;
+  private bookStatus;
   private panelSnapshot;
+  /**
+   * The archive stage has only one legal operation, so a status/panel that
+   * recommends it without checking the same gates as the archive creates a
+   * loop. Evaluate the real archive gates through `gateInput`, then add the
+   * machine pass and semantic evidence that archive re-checks separately.
+   */
+  private archivePreflight;
   private nextStep;
   /** A computed blocker for the retry budget the next operation would consume. */
   private roundsLimitBlock;
   /** Pipeline blockers plus budget exhaustion, so status/panel cannot say "all clear". */
   private effectiveBlocking;
+  /** The PG-13 block that status must show before P2/P3 even tries to write. */
+  private outlineGateBlock;
   /**
    * A review that exists but cannot be tied to the pipeline digest would let a
    * hand-edited review pass archive. Archive already fails closed; status and
@@ -1312,16 +1929,40 @@ declare class EngineService {
   private nextArgs;
   private metricsFor;
   private readChapter;
+  /**
+   * archive-digests.json is a derived mirror, not a source of truth. A damaged
+   * mirror must never make every write unreachable; rebuild the missing rows
+   * from the chapter index and let the next archive rewrite a valid file.
+   */
+  private readArchiveDigests;
   private latestBackup;
+  /**
+   * A manuscript export with an unreadable chapter index cannot prove which
+   * chapters exist. Refusing is preferable to writing a short book that looks
+   * complete; the repair path is novel_amend, not a silent partial export.
+   */
+  private assertExportIndexReadable;
   private chaptersForExport;
   private machine;
   private briefContextFor;
   private briefDigest;
   private briefVariables;
+  /**
+   * The one place a gate input is assembled. Archive preflight evaluates the
+   * same object as the real archive, so a gate cannot pass preflight and then
+   * fail the write (the old PG-06/scope holes did exactly that).
+   */
+  private gateInput;
   private assertGates;
   private assertChapterParameter;
   private assertChapter;
+  /** True when anything survives in the project directory besides novel.yaml. */
+  private projectStateExists;
+  /** A live writer lock makes a read-only snapshot potentially torn. */
+  private lockIsLive;
   private load;
+  /** A repair may bypass the journal hash only when the document is unreadable. */
+  private stateDocIsUnreadable;
   /** Read a review/check without letting one corrupt file wedge every read. */
   private recoverableDoc;
   private mutate;
@@ -1346,6 +1987,8 @@ declare function renderPlainText(project: NovelProject, chapters: readonly Expor
 declare function renderBlurb(project: NovelProject): string;
 /** Cover as a standalone SVG string; text is escaped, palette is theme-neutral. */
 declare function renderCover(project: NovelProject): string;
+/** A book-level proposal for editors, platforms and the author's own pitch. */
+declare function renderProposal(project: NovelProject, outline: OutlineDocument, worldbook: WorldbookDocument, chapters: readonly ChapterRecord[]): string;
 /** XHTML chapter document for the EPUB package. */
 declare function renderEpubChapter(chapter: ExportChapter): string;
 declare const name = "dsh-novel-write-engine";
@@ -1370,4 +2013,4 @@ declare const Config: Schema<Config>;
  * created lazily per project root.
  */
 declare function apply(ctx: Context, config: Config): void;
-export { AdviceReport, ArchiveHandoff, AuditRow, BlockingItem, BriefDocument, BriefLibrary, BriefStage, ChapterPlanInput, ChapterRecord, ChapterStatusRow, ChapterSummary, ChaptersDocument, CharacterDelta, CharactersDocument, CheckDocument, Config, Deduction, DeltaAction, DiffReport, DraftInput, ERROR_CODES, EngineBlockedError, EngineError, EngineFaultError, EngineInputError, EngineService, ErrorCode, ExportChapter, ExportKind, ForeshadowDelta, ForeshadowsDocument, GENRES, GateInput, GateOptions, GateResult, Genre, HandoffDocument, LocksDocument, MachineMetrics, NovelProject, OPERATIONS, OpResult, Operation, PLATFORMS, PanelChapterRow, PanelChaptersDto, PanelDraft, PanelGatesDto, PanelSnapshot, PanelSummaryDto, PipelineState, Platform, ReadingProof, ReadingProofReference, RelationshipDelta, RelationshipsDocument, ReviewDocument, ReviewInput, ReviewIssue, RevisionInput, RoundCounters, SCENE_TYPES, SCHEMA_VERSION, SceneType, ScoreDimension, SemanticItem, Severity, Stage, StateDelta, StateError, StatusReport, TimelineDelta, TimelineDocument, Violation, Warning, WordMetrics, WorldDelta, WorldDocument, WorldPlanInput, applicableGates, apply, blockedError, briefStageFor, chapterHeading, evaluateGates, faultError, gateName, inject, inputError, loadRulepack, name, parseParagraphLocation, phaseStrip, projectChapter, projectChapters, projectGates, projectSummary, renderBlurb, renderCover, renderEpubChapter, renderMarkdown, renderPlainText, verifyReference };
+export { AdviceReport, ArchiveHandoff, AuditRow, BlockingItem, BookPlan, BookReport, BriefDocument, BriefLibrary, BriefStage, ChapterCastMember, ChapterPlanInput, ChapterRecord, ChapterStatusRow, ChapterSummary, ChaptersDocument, CharacterDelta, CharactersDocument, CheckDocument, Config, Deduction, DeltaAction, DiffReport, DoctorCheck, DoctorReport, DraftInput, ERROR_CODES, EngineBlockedError, EngineError, EngineFaultError, EngineInputError, EngineService, ErrorCode, ExportChapter, ExportKind, ForeshadowDelta, ForeshadowsDocument, GENRES, GateInput, GateOptions, GateResult, Genre, GuideReport, GuideStep, HandoffDocument, LocksDocument, MachineMetrics, NovelProject, OPERATIONS, OpResult, Operation, OutlineChapter, OutlineDocument, OutlineVolume, PLATFORMS, PanelBook, PanelChapterRow, PanelChaptersDto, PanelDraft, PanelGatesDto, PanelSnapshot, PanelSummaryDto, PipelineState, Platform, ReadingProof, ReadingProofReference, RelationshipDelta, RelationshipsDocument, ReviewDocument, ReviewInput, ReviewIssue, RevisionInput, RoundCounters, SCENE_TYPES, SCHEMA_VERSION, SceneType, ScoreDimension, SearchReport, SearchResultItem, SemanticItem, Severity, Stage, StateDelta, StateError, StateErrorCode, StatusReport, TimelineDelta, TimelineDocument, Violation, Warning, WordMetrics, WorldDelta, WorldDocument, WorldPlanInput, WorldbookBackstory, WorldbookCharacter, WorldbookDocument, WorldbookFaction, WorldbookGlossary, WorldbookLocation, WorldbookRule, applicableGates, apply, blockedError, briefStageFor, chapterHeading, evaluateGates, faultError, gateName, inject, inputError, loadRulepack, name, parseParagraphLocation, phaseStrip, projectChapter, projectChapters, projectGates, projectSummary, renderBlurb, renderCover, renderEpubChapter, renderMarkdown, renderPlainText, renderProposal, verifyReference };