dsh-novel-write-engine 0.1.3 → 0.2.1

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", "restoreBackup"];
 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";
@@ -159,6 +161,7 @@ interface CheckDocument {
   content_hash: string;
   machine: {
     violations: Violation[];
+    advisories?: Violation[];
     metrics: WordMetrics;
   };
   semantic: {
@@ -169,10 +172,12 @@ interface CheckDocument {
       note: string;
     }>;
   };
+  /** Advisory codes the author has explicitly acknowledged for this content. */
+  acknowledged?: string[];
   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';
+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;
@@ -187,6 +192,8 @@ interface WordMetrics {
   numbers: number;
   chinese_punct: number;
   english_punct: number;
+  /** All punctuation counted by the engine; total = cjk + words + numbers + punctuation. */
+  punctuation_chars: number;
   non_ws_chars: number;
   total_lines: number;
   non_empty_lines: number;
@@ -209,6 +216,10 @@ interface ChapterRecord {
   status: 'draft' | 'reviewed';
   content_hash: string;
   summary: ChapterSummary;
+  /** How hard this chapter was before it was archived. */
+  rounds?: RoundCounters;
+  final_check?: 'pass' | 'fail';
+  archived_at?: string;
   /** Keys allocated by the archive transaction; lets a cross-process retry replay. */
   assigned_ids?: Record<string, string>;
   /** Digest of the archive request that produced this row. */
@@ -223,6 +234,7 @@ interface ChapterSummary {
       key: string;
       title: string;
       description: string;
+      anchor?: string;
     }>;
     advanced: Array<{
       key: string;
@@ -256,6 +268,8 @@ interface RoundCounters {
   review: number;
   revise: number;
   check: number;
+  /** Lifetime rollback count on a chapter record; never stored in the live pipeline. */
+  rollbacks?: number;
 }
 /** How one ledger entity changed in this chapter. */
 type DeltaAction = 'created' | 'updated' | 'no_change';
@@ -287,6 +301,8 @@ interface ForeshadowDelta {
   action: DeltaAction;
   reason?: string;
   title?: string;
+  /** Verbatim manuscript quote used for verification; title stays a readable label. */
+  anchor?: string;
   description?: string;
   note?: string;
   new_info?: boolean;
@@ -329,6 +345,28 @@ interface ArchiveHandoff {
   act?: string;
   act_progress?: string;
 }
+/** One issued task-book receipt; the brief itself is rendered on demand. */
+interface BriefReceipt {
+  chapter: number;
+  stage: BriefStage;
+  digest: string;
+  issued_at: string;
+}
+/** `state/briefs.yaml`: append-only task-book evidence outside content transactions. */
+interface BriefReceiptsDocument {
+  schema_version: 1;
+  receipts: BriefReceipt[];
+}
+/** The active draft's own metadata; P2 plan stays immutable after submission. */
+interface DraftState {
+  chapter: number;
+  title: string;
+  scene_type: SceneType;
+  narrator: string;
+  summary: ChapterSummary;
+  content_hash: string;
+  updated_at: string;
+}
 /** Pipeline document (`state/pipeline.yaml`). */
 interface PipelineState {
   schema_version: 1;
@@ -341,6 +379,8 @@ interface PipelineState {
     digest: string;
   }>;
   blocking: BlockingItem[];
+  /** Current draft summary/title; never written into the P2 plan file. */
+  draft?: DraftState;
   /** Hash of the review document last written by submitReview/submitRevision. */
   review_digest?: string;
   last_action: {
@@ -420,6 +460,7 @@ interface ForeshadowsDocument {
     status: 'planted' | 'dormant' | 'advanced' | 'resolved';
     resolved_at: number | null;
     description: string;
+    anchor?: string;
     advance_log: Array<{
       chapter: number;
       note: string;
@@ -526,6 +567,317 @@ interface ChapterPlanInput {
   /** 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;
+}
+/** One declared numeric canon, checked against the manuscript on request. */
+interface WorldbookFact {
+  alias: string;
+  value: number;
+  unit: string;
+  tolerance?: number;
+  note?: 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[];
+  /** Optional numeric canon; old documents omit it. */
+  facts?: WorldbookFact[];
+  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;
+  };
+}
+/** One canonical outline-progress calculation shared by every adapter. */
+interface OutlineProgress {
+  present: boolean;
+  target: number | null;
+  total: number;
+  planned: number;
+  archived: number;
+  missingCards: number;
+  plannedCoverage: number | null;
+  archivedCoverage: number | null;
+  /** Compatibility alias: planned coverage when a target exists, otherwise card coverage. */
+  coverage: number;
+  /** Fraction of archived chapters that have a matching archived card. */
+  cardCoverage: number;
+  volumes: 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;
+    remaining_words_min: number | null;
+    remaining_words_average: number | null;
+    remaining_words_basis: 'actual_average' | 'minimum_target' | 'none';
+  };
+  outline: {
+    present: boolean;
+    strict: boolean;
+    target: number | null;
+    total: number;
+    planned: number;
+    archived: number;
+    missing_cards: number;
+    planned_coverage: number | null;
+    archived_coverage: number | null;
+    coverage: number;
+    card_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;
+    facts?: number;
+  };
+  quality: {
+    average: number;
+    median: number;
+    min: number;
+    max: number;
+    last_five: number[];
+    trend: number;
+    dimensions: Array<{
+      id: string;
+      average: number;
+      samples: number;
+    }>;
+  };
+  /** Per-chapter effort survives archive (pipeline rounds are reset). */
+  effort: {
+    reviews: number;
+    revisions: number;
+    checks: number;
+    rollbacks: number;
+    chapters: Array<{
+      num: number;
+      reviews: number;
+      revisions: number;
+      checks: number;
+      rollbacks: number;
+      final_check: 'pass' | 'fail' | null;
+      archived_at: string | null;
+    }>;
+  };
+  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 {
   chapter: number;
@@ -544,10 +896,23 @@ interface ReviewInput {
   total: number;
   proof: ReadingProof;
 }
+/** One exact, unique replacement used by patch-mode revisions. */
+interface RevisionEdit {
+  old_text: string;
+  new_text: string;
+  /** 1-based occurrence; defaults to requiring exactly one match. */
+  occurrence?: number;
+}
+/** Patch-mode revision; content and patch are mutually exclusive. */
+interface RevisionPatch {
+  expected_hash: string;
+  edits: RevisionEdit[];
+}
 /** Revision submission payload. */
 interface RevisionInput {
   chapter: number;
-  content: string;
+  content?: string;
+  patch?: RevisionPatch;
   summary: ChapterSummary;
 }
 /** Semantic check items supplied by the model. */
@@ -598,6 +963,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 {
@@ -636,6 +1007,36 @@ interface StatusReport {
   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;
+      target: number | null;
+      total: number;
+      planned: number;
+      archived: number;
+      missing_cards: number;
+      planned_coverage: number | null;
+      archived_coverage: number | null;
+      coverage: number;
+      card_coverage: number;
+      volumes: number;
+      current: OutlineChapter | null;
+    };
+    worldbook: {
+      present: boolean;
+      characters: number;
+      locations: number;
+      factions: number;
+      rules: number;
+      glossary: number;
+      backstory: number;
+      facts?: number;
+    };
+  };
   next: {
     tool: string;
     args: Record<string, unknown>;
@@ -654,6 +1055,8 @@ interface AdviceReport {
 }
 /** One history row derived from the journal. */
 interface AuditRow {
+  /** Stable chronological cursor; absent only on hand-built test rows. */
+  seq?: number;
   at: string;
   op: string;
   chapter: number;
@@ -661,6 +1064,14 @@ interface AuditRow {
   txid: string;
   status: 'committed' | 'aborted';
   files: string[];
+  /** Machine code and human reason for a refused attempt. */
+  code?: string;
+  reason?: string;
+  hint?: string;
+  stage?: string;
+  /** True when no transaction started: the gate/input refused the call. */
+  attempt?: boolean;
+  blocking?: BlockingItem[];
 }
 /** One diff hunk between two revisions of a chapter. */
 interface DiffReport {
@@ -674,8 +1085,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;
@@ -803,13 +1214,66 @@ 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[];
+  facts?: WorldbookFact[];
+  themes?: string[];
+}
 /** One rendered task book. */
 interface BriefDocument {
   stage: BriefStage;
@@ -846,6 +1310,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. */
@@ -857,7 +1322,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:
@@ -912,6 +1377,59 @@ interface PanelSnapshot {
     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;
+    target: number | null;
+    total: number;
+    planned: number;
+    archived: number;
+    missing_cards: number;
+    planned_coverage: number | null;
+    archived_coverage: number | null;
+    coverage: number;
+    card_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;
+    facts?: number;
+  };
 }
 interface PanelSummaryDto {
   schemaVersion: number;
@@ -942,6 +1460,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;
@@ -1021,6 +1557,40 @@ 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/restored';
+  payload: {
+    schemaVersion: 1;
+    projectRoot: string;
+    txid: string;
+    chapter: number;
+    paths: string[];
+  };
+} | {
+  name: 'novel/exported';
+  payload: {
+    schemaVersion: 1;
+    projectRoot: string;
+    kind: string;
+    files: number;
+  };
 };
 interface InitProjectInput {
   title: string;
@@ -1031,6 +1601,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 {
@@ -1070,9 +1651,11 @@ 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[];
+  /** Advisory codes the author has read and accepts; blockers cannot be acknowledged. */
+  acknowledge?: string[];
   root?: string;
 }
 interface ArchiveSubmission {
@@ -1089,6 +1672,13 @@ interface AmendSubmission {
   reason: string;
   root?: string;
 }
+interface RestoreSubmission {
+  txid: string;
+  chapter?: number;
+  /** Restrict to these project-relative files; omitted restores every chapter file in the snapshot. */
+  paths?: string[];
+  root?: string;
+}
 interface RollbackSubmission {
   chapter: number;
   toStage: 'P1' | 'P2' | 'P3' | 'P4' | 'P5' | 'P6';
@@ -1096,13 +1686,19 @@ interface RollbackSubmission {
   root?: string;
 }
 interface DiffInput {
-  chapter: number;
+  chapter?: number;
   before?: string;
   after?: string;
   root?: string;
 }
 interface AuditInput {
   limit?: number;
+  cursor?: number;
+  chapter?: number;
+  op?: string;
+  status?: 'committed' | 'aborted';
+  since?: string;
+  until?: string;
   root?: string;
 }
 interface ExportInput {
@@ -1111,8 +1707,10 @@ interface ExportInput {
   root?: string;
 }
 interface StateQueryInput {
-  kind: DocKind | 'novel' | 'planWorld' | 'planChapter';
+  kind: DocKind | 'novel' | 'planWorld' | 'planChapter' | 'history' | 'backups' | 'briefs';
   chapter?: number;
+  /** Select one historical revision instead of listing history. */
+  revision?: number;
   /** Chapter index defaults to a compact read; opt in to the full summaries. */
   include_summary?: boolean;
   /** Inclusive chapter range for the `chapters` index. */
@@ -1124,6 +1722,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.
@@ -1174,12 +1809,61 @@ 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;
+  }>>;
+  /**
+   * Restore one active chapter from a backup transaction. Archived chapters
+   * are refused: their manuscript hash is bound by the index, so restoring
+   * behind the index would corrupt the project. Reopen first, then restore.
+   */
+  restoreBackup(input: RestoreSubmission): Promise<OpResult<{
+    txid: string;
+    chapter: number;
+    restored: 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;
+  /**
+   * Count every committed attempt for one chapter, not just the loop since the
+   * last rollback. `pipeline.rounds` is deliberately reset by rollback to keep
+   * the retry budget fair; it is not the chapter's lifetime effort.
+   */
+  private lifetimeRounds;
   getStatus(input?: StatusInput): Promise<OpResult<StatusReport>>;
   countWords(input?: WordCountInput): Promise<OpResult<WordMetrics>>;
   queryState(input: StateQueryInput): Promise<OpResult<unknown>>;
@@ -1194,6 +1878,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;
@@ -1236,6 +1925,9 @@ declare class EngineService {
     chapter: number;
     verdict: 'pass' | 'fail';
     violations: number;
+    advisories: number;
+    advisory_codes: string[];
+    acknowledged: string[];
     metrics: WordMetrics;
     stage: Stage;
   }>>;
@@ -1286,6 +1978,15 @@ declare class EngineService {
     averageScore: number;
     lastScore: number;
     openForeshadows: number;
+    plannedChapters: number;
+    totalCards: number;
+    outlineCoverage: number | null;
+    archivedCoverage: number | null;
+    missingCards: number;
+    blueprintReady: boolean;
+    worldbookEntries: number;
+    strictOutline: boolean;
+    targetChapters: number | null;
   }>;
   private registry;
   /** List known projects (convenience only; a project opens without a row). */
@@ -1327,6 +2028,47 @@ 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
@@ -1340,6 +2082,8 @@ declare class EngineService {
   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
@@ -1355,12 +2099,25 @@ declare class EngineService {
   /** State damage that makes this operation unsafe to start. */
   private stateGateBlock;
   /** Whether the stored brief still signs the current snapshot. */
+  private readBriefReceipts;
   private briefIsCurrent;
   /** Arguments valid for the tool `STAGE_NEXT` recommends at this stage. */
   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;
@@ -1375,6 +2132,10 @@ declare class EngineService {
   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;
@@ -1402,6 +2163,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";
@@ -1426,4 +2189,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, ChapterCastMember, 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, StateErrorCode, 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, BriefReceipt, BriefReceiptsDocument, BriefStage, ChapterCastMember, ChapterPlanInput, ChapterRecord, ChapterStatusRow, ChapterSummary, ChaptersDocument, CharacterDelta, CharactersDocument, CheckDocument, Config, Deduction, DeltaAction, DiffReport, DoctorCheck, DoctorReport, DraftInput, DraftState, 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, OutlineProgress, OutlineVolume, PLATFORMS, PanelBook, PanelChapterRow, PanelChaptersDto, PanelDraft, PanelGatesDto, PanelSnapshot, PanelSummaryDto, PipelineState, Platform, ReadingProof, ReadingProofReference, RelationshipDelta, RelationshipsDocument, ReviewDocument, ReviewInput, ReviewIssue, RevisionEdit, RevisionInput, RevisionPatch, 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, WorldbookFact, 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 };