dsh-novel-write-engine 0.2.1 → 0.2.3

package/lib/index.d.ts

@@ -22,7 +22,7 @@ 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 thirty-one service operations (22 inherited from 0.1.x, 9 book-level). */
+/** All thirty-two service operations (22 inherited + 9 book-level + restoreBackup). */
 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. */
@@ -60,11 +60,18 @@ interface ReadingProof {
 /** Error families map one-to-one to the three repair actions a caller can take. */
 declare const ERROR_CODES: {
   readonly PROJECT_NOT_FOUND: "ENGINE_PROJECT_NOT_FOUND";
+  readonly PROJECT_AMBIGUOUS: "ENGINE_PROJECT_AMBIGUOUS";
+  readonly PROJECT_MISSING: "ENGINE_PROJECT_MISSING";
+  readonly PROJECT_IDENTITY_MISMATCH: "ENGINE_PROJECT_IDENTITY_MISMATCH";
   readonly PROJECT_EXISTS: "ENGINE_PROJECT_EXISTS";
   readonly STAGE_ORDER: "ENGINE_STAGE_ORDER";
+  /** The exact same keyed submission already failed in the same context. */
+  readonly RETRY_UNCHANGED: "ENGINE_RETRY_UNCHANGED";
   readonly GATE_BLOCKED: "ENGINE_GATE_BLOCKED";
   readonly READING_PROOF_INVALID: "ENGINE_READING_PROOF_INVALID";
   readonly SCORE_MISMATCH: "ENGINE_SCORE_MISMATCH";
+  /** A revision tried to rewrite reviewer-owned issue fields. */
+  readonly ISSUE_IMMUTABLE: "ENGINE_ISSUE_IMMUTABLE";
   readonly DELTA_UNVERIFIED: "ENGINE_DELTA_UNVERIFIED";
   readonly RESOURCE_NEGATIVE_BALANCE: "ENGINE_RESOURCE_NEGATIVE_BALANCE";
   readonly SCHEMA_TOO_NEW: "ENGINE_SCHEMA_TOO_NEW";
@@ -461,6 +468,8 @@ interface ForeshadowsDocument {
     resolved_at: number | null;
     description: string;
     anchor?: string;
+    /** New 0.2.3 writes are distinguishable from pre-0.2.3 rows by this marker. */
+    format_version?: 1;
     advance_log: Array<{
       chapter: number;
       note: string;
@@ -783,7 +792,13 @@ interface BookReport {
     min: number;
     max: number;
     last_five: number[];
-    trend: number;
+    /** Null when there are not enough distinct chapter reviews to compare. */
+    trend: number | null;
+    trend_basis: 'last_five_vs_previous_five' | 'insufficient_samples' | 'insufficient_history';
+    /** Number of chapters represented by a final review. */
+    samples: number;
+    /** Committed review rounds for this report, including history. */
+    attempts: number;
     dimensions: Array<{
       id: string;
       average: number;
@@ -984,6 +999,15 @@ interface ChapterStatusRow {
   stage: Stage;
   passed: boolean;
 }
+/** Where an omitted project root came from. */
+type SelectionSource = 'explicit' | 'session' | 'workspace' | 'active' | 'config' | 'single';
+/** One resolved project choice, before the project is loaded. */
+interface Selection {
+  root: string;
+  source: SelectionSource;
+  title?: string;
+  created_at?: string;
+}
 /** The `getStatus` payload. */
 interface StatusReport {
   project: {
@@ -992,10 +1016,17 @@ interface StatusReport {
     platform: Platform;
     root: string;
   };
+  /** Why this project was chosen; lets the model notice a wrong book. */
+  selection?: {
+    source: SelectionSource;
+    root: string;
+  };
   /** The chapter requested for metrics; may be historical. */
   chapter: number;
   /** The chapter the pipeline is currently working on. */
   active_chapter: number;
+  /** SHA-256 of the active manuscript, or null when the stage has no draft. */
+  manuscript_hash: string | null;
   stage: Stage;
   rounds: RoundCounters;
   blocking: BlockingItem[];
@@ -1072,6 +1103,10 @@ interface AuditRow {
   /** True when no transaction started: the gate/input refused the call. */
   attempt?: boolean;
   blocking?: BlockingItem[];
+  /** Keyed operation fingerprint; lets an identical failed retry be refused. */
+  retry_key?: string;
+  /** Brief/stage/revision context for `retry_key`. */
+  retry_context?: string;
 }
 /** One diff hunk between two revisions of a chapter. */
 interface DiffReport {
@@ -1219,6 +1254,8 @@ type DocKind = 'project' | 'pipeline' | 'chapters' | 'characters' | 'world' | 'l
 interface RegistryEntry {
   root: string;
   title: string;
+  /** Project identity; absent on registries written by 0.2.1 and earlier. */
+  created_at?: string;
   updated_at: string;
 }
 interface BookPatch {
@@ -1382,7 +1419,10 @@ interface PanelSnapshot {
   quality?: {
     averageScore: number;
     scores: number[];
-    trend: number;
+    trend: number | null;
+    trend_basis?: 'last_five_vs_previous_five' | 'insufficient_samples' | 'insufficient_history';
+    samples?: number;
+    attempts?: number;
   };
   health?: {
     ok: boolean;
@@ -1395,6 +1435,19 @@ interface PanelSnapshot {
     chapter: number;
     status: string;
   }>;
+  /** Unacknowledged machine advisories; never mixed into `blocking`. */
+  advisories?: Array<{
+    code: string;
+    detail: string;
+    hint?: string;
+  }>;
+  /** Number of advisory codes already acknowledged for the current check. */
+  acknowledgedAdvisories?: number;
+  /** Read-only upgrade findings; null when the project needs no explanation. */
+  legacy?: Array<{
+    code: string;
+    detail: string;
+  }>;
 }
 interface PanelBook {
   premise: string;
@@ -1434,6 +1487,8 @@ interface PanelBook {
 interface PanelSummaryDto {
   schemaVersion: number;
   panelId: string;
+  /** Absolute project root, so a stale title cannot hide a wrong book. */
+  root: string;
   title: string;
   genre: string;
   platform: string;
@@ -1465,7 +1520,10 @@ interface PanelSummaryDto {
   quality?: {
     averageScore: number;
     scores: number[];
-    trend: number;
+    trend: number | null;
+    trend_basis?: 'last_five_vs_previous_five' | 'insufficient_samples' | 'insufficient_history';
+    samples?: number;
+    attempts?: number;
   };
   health?: {
     ok: boolean;
@@ -1478,6 +1536,19 @@ interface PanelSummaryDto {
     chapter: number;
     status: string;
   }>;
+  /** Unacknowledged machine advisories; never mixed into `blocking`. */
+  advisories?: Array<{
+    code: string;
+    detail: string;
+    hint?: string;
+  }>;
+  /** Number of advisory codes already acknowledged for the current check. */
+  acknowledgedAdvisories?: number;
+  /** Read-only upgrade findings; null when the project needs no explanation. */
+  legacy?: Array<{
+    code: string;
+    detail: string;
+  }>;
 }
 interface PanelChapterRow {
   num: number;
@@ -1502,6 +1573,49 @@ interface PanelGatesDto {
   /** Human-facing one-liner per blocking item. */
   explanations: string[];
 }
+/** One selectable project in the panel; state is cheap, not a full load. */
+interface PanelProjectOption {
+  root: string;
+  title: string;
+  active: boolean;
+  registered: boolean;
+  state: 'ok' | 'damaged' | 'missing' | 'not-project' | 'unreadable';
+  /** The path now holds a different project identity; writes will fail closed. */
+  identity_changed?: boolean;
+}
+interface PanelSelection {
+  root: string | null;
+  source: 'query' | 'active' | 'single' | 'config' | 'none';
+}
+interface PanelMissing {
+  root: string;
+  title: string;
+  code: 'ENGINE_PROJECT_MISSING' | 'ENGINE_PROJECT_NOT_FOUND' | 'ENGINE_TXN_IN_PROGRESS';
+  reason: 'missing' | 'not-project' | 'damaged' | 'not_registered' | 'unreadable' | 'busy';
+  hint: string;
+}
+interface PanelBundle {
+  projects: PanelProjectOption[];
+  selection: PanelSelection;
+  summary?: PanelSummaryDto;
+  chapters?: PanelChaptersDto;
+  gates?: PanelGatesDto;
+  resume?: {
+    text: string;
+  };
+  missing?: PanelMissing;
+  empty?: true;
+  error?: string;
+}
+interface ResumePromptInput {
+  title: string;
+  root: string;
+  chapter: number | string;
+  stage: string;
+  nextTool: string;
+}
+/** One shared prompt template for `/novel resume` and the panel copy button. */
+declare function formatResumePrompt(input: ResumePromptInput): string;
 /** The nine-phase progress strip: phases before the active one are done. */
 declare function phaseStrip(stage: Stage, finished?: boolean): Array<{
   id: string;
@@ -1513,6 +1627,15 @@ declare function projectChapter(record: ChapterRecord): PanelChapterRow;
 declare function projectSummary(snapshot: PanelSnapshot): PanelSummaryDto;
 declare function projectChapters(snapshot: PanelSnapshot): PanelChaptersDto;
 declare function projectGates(snapshot: PanelSnapshot): PanelGatesDto;
+/** How much of a candidate project can be inspected without loading a snapshot. */
+type ProjectState = 'ok' | 'damaged' | 'not-project' | 'missing' | 'unreadable';
+interface ProjectInspection {
+  root: string;
+  state: ProjectState;
+  title: string;
+  created_at?: string;
+  error?: string;
+}
 /** Plugin configuration, mapped from `Config` in `src/index.ts`. */
 interface EngineConfig {
   projectRoot: string;
@@ -1623,6 +1746,16 @@ interface BriefInput {
   chapter?: number;
   root?: string;
 }
+type BriefPayload = {
+  stage: BriefStage;
+  chapter: number;
+  digest: string;
+  title: string;
+  content: string;
+  content_hash: string;
+  fields: Record<string, unknown>;
+  context: Record<string, unknown>;
+};
 interface WorldPlanSubmission extends WorldPlanInput {
   root?: string;
 }
@@ -1759,6 +1892,11 @@ interface ReportSubmission {
 interface GuideInput {
   root?: string;
 }
+/** Session/workspace context of one tool or command call. */
+interface EngineCaller {
+  sessionId?: string;
+  cwd?: string;
+}
 /**
  * The single write authority. Tools, commands, the panel and task books never
  * touch a file; every mutation is one of these operations.
@@ -1772,8 +1910,8 @@ declare class EngineService {
   private readonly briefContextCache;
   private readonly briefs;
   private readonly now;
-  /** The project this process last touched; the panel follows it without a workspace hint. */
-  private lastRoot;
+  private readonly metadataMutex;
+  private readonly callerContext;
   constructor(config: EngineConfig, rulepack: Rulepack | (() => Rulepack), options?: {
     briefs?: BriefLibrary;
     now?: () => Date;
@@ -1794,15 +1932,52 @@ declare class EngineService {
   private readonly signalContext;
   /** Bind the host cancellation signal to the engine work of one tool call. */
   withSignal<T>(signal: AbortSignal | undefined, task: () => Promise<T>): Promise<T>;
+  /** Bind the calling Agent session and cwd to every engine operation in `task`. */
+  withCaller<T>(caller: EngineCaller | undefined, task: () => Promise<T>): Promise<T>;
+  private caller;
   /** The configured default project root. */
   defaultRoot(): string;
+  /** Resolve a caller-supplied root against the session cwd, like /novel use. */
+  private resolveProjectPath;
+  /** The resolved metadata directory; resolves relative config once per call. */
+  private stateRoot;
+  private stateStore;
+  private bindings;
   /**
-   * Resolve an omitted root through the cross-project registry. The registry is
-   * convenience state, so a corrupt or unreadable registry falls back to the
-   * configured root instead of making every call fail.
+   * Serialize metadata read-modify-write across sessions and processes. The
+   * project manuscript lock is a different lock; a slow write never blocks a
+   * registry update.
    */
+  withMetadataLock<T>(task: () => Promise<T>): Promise<T>;
+  private inspectConfigRoot;
+  /**
+   * Resolve the four-layer choice: explicit, session binding, bounded workspace
+   * discovery, then registry/config defaults. There is deliberately no
+   * process-global "last project" layer.
+   */
+  /** Doctor/guide may run before any project exists; that is not a failure. */
+  private resolveRootForInspection;
   private resolveRoot;
   private storeFor;
+  /** Persist one explicit choice for this DSH session. */
+  private bindSelection;
+  /**
+   * Best-effort discovery bookkeeping. A metadata failure must never turn a
+   * successful project read/write into a failure; the registry is convenience.
+   */
+  private autoRegister;
+  /** Record the session binding/registration implied by a successful selection. */
+  private recordSelection;
+  /**
+   * Read paths may record convenience metadata, but a corrupt or read-only
+   * state directory must not turn a successful explicit-root read into a
+   * failure. Resolution without an explicit root still reads the binding
+   * fail-closed; writes use recordSelection directly and report a committed
+   * mutation with a warning if its metadata update fails.
+   */
+  private recordSelectionBestEffort;
+  /** Registration/activation/use need a readable project identity. */
+  private assertProjectHealthy;
   initProject(input: InitProjectInput): Promise<OpResult<{
     root: string;
     title: string;
@@ -1858,6 +2033,13 @@ declare class EngineService {
    * the model only learns about the mismatch when that write aborts.
    */
   private journalBlocking;
+  /**
+   * Count review attempts per archived chapter. The journal is authoritative;
+   * history fills any per-chapter gap where it has more distinct historical
+   * reviews than committed journal rows (legacy or a truncated upgrade). A
+   * chapter can never report fewer attempts than readable current reviews.
+   */
+  private reviewAttemptsByChapter;
   /**
    * Count every committed attempt for one chapter, not just the loop since the
    * last rollback. `pipeline.rounds` is deliberately reset by rollback to keep
@@ -1865,6 +2047,12 @@ declare class EngineService {
    */
   private lifetimeRounds;
   getStatus(input?: StatusInput): Promise<OpResult<StatusReport>>;
+  /**
+   * Build a status report from an already-loaded snapshot. This deliberately
+   * has no selection side effect: read-only callers such as /novel resume must
+   * not register or bind the project just by reading it.
+   */
+  private statusFor;
   countWords(input?: WordCountInput): Promise<OpResult<WordMetrics>>;
   queryState(input: StateQueryInput): Promise<OpResult<unknown>>;
   advise(input?: {
@@ -1879,20 +2067,18 @@ declare class EngineService {
     state_errors: StateError[];
   }>>;
   search(input: SearchInput): Promise<OpResult<SearchReport>>;
+  /**
+   * Read-only upgrade audit. It never edits a legacy document: the point is to
+   * explain why an old project's numbers look different, not to rewrite history.
+   */
+  private legacyIssues;
   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;
-    digest: string;
-    title: string;
-    content: string;
-    content_hash: string;
-    fields: Record<string, unknown>;
-    context: Record<string, unknown>;
-  }>>;
+  getBrief(input: BriefInput): Promise<OpResult<BriefPayload>>;
+  private assertBriefChapter;
+  private briefPayload;
   submitWorldPlan(input: WorldPlanSubmission): Promise<OpResult<{
     chapter: number;
     stage: Stage;
@@ -1960,14 +2146,21 @@ declare class EngineService {
   panelGates(input?: {
     root?: string;
   }): Promise<PanelGatesDto>;
-  /** One snapshot, three projections: the panel never mixes revisions. */
+  /**
+   * Build the read-only panel payload. The query root is accepted only when it
+   * is registered, active or the configured root; arbitrary paths never reach
+   * the filesystem from the panel route.
+   */
   panelBundle(input?: {
     root?: string;
-  }): Promise<{
-    summary: PanelSummaryDto;
-    chapters: PanelChaptersDto;
-    gates: PanelGatesDto;
-  }>;
+  }): Promise<PanelBundle>;
+  /** Read-only resume text shared with the panel copy button. */
+  resumePrompt(input?: {
+    root?: string;
+  }): Promise<OpResult<{
+    text: string | null;
+    selection: StatusReport['selection'];
+  }>>;
   stats(input?: {
     root?: string;
   }): Promise<{
@@ -1989,31 +2182,97 @@ declare class EngineService {
     targetChapters: number | null;
   }>;
   private registry;
-  /** List known projects (convenience only; a project opens without a row). */
+  /** List known projects with a cheap directory state for the panel/command. */
   listProjects(): Promise<{
     active: string | null;
-    projects: RegistryEntry[];
+    projects: Array<RegistryEntry & {
+      state: ProjectState;
+      identity_changed?: boolean;
+    }>;
   }>;
-  /** Record the current project in the registry. */
+  /**
+   * Record an explicit project row. An unchanged duplicate is a no-op; a path
+   * reused by another project updates the row and reports `replaced`.
+   */
   registerProject(input?: {
     root?: string;
   }): Promise<{
     active: string | null;
     projects: RegistryEntry[];
+    replaced: boolean;
   }>;
-  /** Choose the default project for future convenience calls. */
+  /** Choose the panel/default project. This never binds the current session. */
   setActiveProject(input: {
     root: string;
   }): Promise<{
     active: string | null;
+    replaced: boolean;
   }>;
-  /** Forget a registry row; the project directory is never touched. */
+  /** Forget a registry row; the project directory and bindings are never touched. */
   forgetProject(input: {
     root: string;
   }): Promise<{
     active: string | null;
     projects: RegistryEntry[];
   }>;
+  /**
+   * Remove only registry rows whose directories are missing, not a project, or
+   * unreadable. The default is a dry run; project files and session bindings are
+   * never touched, and `--yes` is required at the command layer.
+   */
+  pruneProjects(input?: {
+    apply?: boolean;
+  }): Promise<{
+    candidates: Array<{
+      root: string;
+      title: string;
+      state: ProjectState;
+    }>;
+    removed: string[];
+    active: string | null;
+  }>;
+  /**
+   * Bounded workspace scan. Normal mode is read-only; `register` updates only
+   * healthy, newly discovered rows, never active or session bindings.
+   */
+  scanProjects(input: {
+    cwd: string;
+    register?: boolean;
+  }): Promise<{
+    cwd: string;
+    candidates: Array<ProjectInspection & {
+      registered: boolean;
+      identity_changed?: boolean;
+      reason?: string;
+    }>;
+    truncated: boolean;
+    added: string[];
+    already: string[];
+    skipped: Array<{
+      root: string;
+      reason: string;
+    }>;
+    identity_changed: string[];
+  }>;
+  /** Current session binding, or the inferred fallback when none is set. */
+  currentProject(): Promise<{
+    selection: Selection | null;
+    bound: boolean;
+    state?: ProjectState;
+    error?: string;
+  }>;
+  /** Explicitly switch this session; failure leaves the old binding untouched. */
+  useProject(input: {
+    target: string;
+  }): Promise<{
+    selection: Selection;
+    title: string;
+    created_at: string;
+  }>;
+  /** Clear only this session's choice; never touches a project or registry row. */
+  unbindProject(): Promise<{
+    cleared: boolean;
+  }>;
   /**
    * Import one ledger from a settings pack. Always previews with a diff; a
    * dry run never writes, and an apply is a normal transaction.
@@ -2071,10 +2330,10 @@ declare class EngineService {
   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.
+   * The archive stage can be left by a direct revision (the 0.2.3 workflow) or
+   * by rollback. Evaluate the same gates as archive so status/panel do not
+   * recommend an operation that will immediately fail; when the failure is
+   * prose-level, `nextStep` recommends the direct P5 revision instead.
    */
   private archivePreflight;
   private nextStep;
@@ -2100,6 +2359,7 @@ declare class EngineService {
   private stateGateBlock;
   /** Whether the stored brief still signs the current snapshot. */
   private readBriefReceipts;
+  private assertBriefReceiptsWritable;
   private briefIsCurrent;
   /** Arguments valid for the tool `STAGE_NEXT` recommends at this stage. */
   private nextArgs;
@@ -2132,11 +2392,13 @@ 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;
+  /** Resolve a selection, load it, then persist the explicit choice (best effort). */
   private load;
+  /** Load exactly one already-resolved selection; never writes a binding. */
+  private movedProjectHint;
+  private loadAt;
   /** 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. */
@@ -2147,6 +2409,100 @@ declare class EngineService {
 }
 /** Read, compile and freeze a pack. Runtime callers always use the bundled default. */
 declare function loadRulepack(path?: string): Rulepack;
+/** Panel and session identifiers. */
+declare const PLUGIN_NAME = "dsh-novel-write-engine";
+declare const PANEL_ID = "novel-workshop";
+declare const PANEL_ROUTE = "/api/novel-write-engine/panel";
+declare const SKILL_NAME = "novel-write-engine";
+declare const REMOTE_VERSION = 5;
+/** The panel is a recent-history view; the wire payload and UI use one cap. */
+declare const PANEL_CHAPTER_LIMIT = 30;
+/** Project-relative locations. Every write goes through these constants. */
+declare const PROJECT_FILE = "novel.yaml";
+declare const OUTLINE_FILE = "outline/outline.yaml";
+declare const WORLDBOOK_FILE = "outline/worldbook.yaml";
+declare const STATE_DIR = "state";
+declare const CHAPTERS_DIR = "chapters";
+declare const PLAN_DIR = "plans";
+declare const REVIEW_DIR = "reviews";
+declare const CHECK_DIR = "checks";
+declare const EXPORT_DIR = "exports";
+declare const BACKUP_DIR = "backups";
+declare const HISTORY_DIR = "history";
+/** Brief receipts are append-only evidence, separate from content transactions. */
+declare const BRIEF_RECEIPTS_FILE = "state/briefs.yaml";
+declare const OUTLINE_DIR = "outline";
+declare const LOCK_FILE = ".engine.lock";
+declare const STAGING_DIR = ".staging";
+declare const REGISTRY_FILE = "projects.yaml";
+declare const SESSION_BINDINGS_FILE = "session-bindings.yaml";
+declare const METADATA_LOCK_FILE = ".metadata.lock";
+declare const ARCHIVE_DIGESTS_FILE = "state/archive-digests.json";
+/** Files owned by the engine under `state/`. */
+declare const STATE_FILES: {
+  readonly pipeline: "pipeline.yaml";
+  readonly chapters: "chapters.yaml";
+  readonly characters: "characters.yaml";
+  readonly world: "world.yaml";
+  readonly locks: "locks.yaml";
+  readonly timeline: "timeline.yaml";
+  readonly foreshadows: "foreshadows.yaml";
+  readonly relationships: "relationships.yaml";
+  readonly handoff: "handoff.yaml";
+  readonly journal: "journal.jsonl";
+};
+/** Chapter file name, zero padded to three digits. */
+declare const chapterFile: (chapter: number) => string;
+/** Kept for reference when a rollback discards the current draft. */
+declare const deprecatedChapterFile: (chapter: number) => string;
+declare const planWorldFile: (chapter: number) => string;
+declare const planChapterFile: (chapter: number) => string;
+declare const reviewFile: (chapter: number) => string;
+declare const checkFile: (chapter: number) => string;
+declare const reviewHistoryFile: (chapter: number, revision: number) => string;
+declare const checkHistoryFile: (chapter: number, revision: number) => string;
+declare const chapterHistoryFile: (chapter: number, revision: number) => string;
+declare const deprecatedHistoryFile: (chapter: number, revision: number) => string;
+declare const planHistoryFile: (chapter: number, revision: number) => string;
+declare const HISTORY_KINDS: readonly ["reviews", "checks", "chapters", "deprecated", "plans"];
+type HistoryKind = (typeof HISTORY_KINDS)[number];
+/** Limits that are structural, not taste. */
+declare const LIMITS: {
+  /** P4 <-> P5/P6 retries before a forced rollback. */
+  maxRounds: number;
+  /** Lock staleness in milliseconds. */
+  lockStaleMs: number;
+  /** How long a writer waits for the keyed mutex before failing. */
+  lockWaitMs: number;
+  /** Reading proofs shorter than this cannot be verified. */
+  minQuoteChars: number;
+  /** World-plan text fields are protected context, so they need a hard bound. */
+  maxWorldPlanItems: number;
+  maxWorldPlanTextChars: number;
+  maxWorldPlanObjectiveChars: number;
+  /** Cast plus summary may exceed eight, but not without a bound. */
+  maxActiveCast: number;
+  /** Outline and worldbook are protected context, so they need hard bounds. */
+  maxOutlineChapters: number;
+  maxOutlineVolumes: number;
+  maxOutlineTextFieldChars: number;
+  maxOutlineNotesChars: number;
+  maxWorldbookEntries: number;
+  maxWorldbookTextChars: number;
+  maxSearchQueryChars: number;
+};
+/** Re-exported enums make adapter code readable without importing types twice. */
+declare const SCENE_TYPE_DEFAULT: SceneType;
+declare const DEFAULT_GENRE: Genre;
+declare const DEFAULT_PLATFORM: Platform;
+declare const INITIAL_STAGE: Stage;
+/** The order used to render the nine-phase progress strip. */
+declare const PHASE_STRIP: readonly ["P1", "P2", "P3", "P4", "P5", "P6", "P7", "P8", "P9"];
+/** Tool names, kept here so the arch test can assert one namespace. */
+declare const TOOL_NAMES: readonly ["novel_init", "novel_status", "novel_brief", "novel_plan_world", "novel_plan_chapter", "novel_write_draft", "novel_review", "novel_revise", "novel_check", "novel_archive", "novel_word_count", "novel_state", "novel_amend", "novel_rollback", "novel_diff", "novel_export", "novel_audit", "novel_pipeline", "novel_blueprint", "novel_outline", "novel_outline_import", "novel_worldbook", "novel_search", "novel_doctor", "novel_report", "novel_guide", "novel_reopen", "novel_restore"];
+type ToolName = (typeof TOOL_NAMES)[number];
+/** The ten high-frequency tools kept when `tools.mode = core`. */
+declare const CORE_TOOLS: readonly ToolName[];
 /** One rendered chapter, assembled by the engine before rendering. */
 interface ExportChapter {
   num: number;
@@ -2189,4 +2545,4 @@ declare const Config: Schema<Config>;
  * created lazily per project root.
  */
 declare function apply(ctx: Context, config: Config): void;
-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 };
+export { ARCHIVE_DIGESTS_FILE, AdviceReport, ArchiveHandoff, AuditRow, BACKUP_DIR, BRIEF_RECEIPTS_FILE, BlockingItem, BookPlan, BookReport, BriefDocument, BriefLibrary, BriefReceipt, BriefReceiptsDocument, BriefStage, CHAPTERS_DIR, CHECK_DIR, CORE_TOOLS, ChapterCastMember, ChapterPlanInput, ChapterRecord, ChapterStatusRow, ChapterSummary, ChaptersDocument, CharacterDelta, CharactersDocument, CheckDocument, Config, DEFAULT_GENRE, DEFAULT_PLATFORM, Deduction, DeltaAction, DiffReport, DoctorCheck, DoctorReport, DraftInput, DraftState, ERROR_CODES, EXPORT_DIR, EngineBlockedError, EngineError, EngineFaultError, EngineInputError, EngineService, ErrorCode, ExportChapter, ExportKind, ForeshadowDelta, ForeshadowsDocument, GENRES, GateInput, GateOptions, GateResult, Genre, GuideReport, GuideStep, HISTORY_DIR, HISTORY_KINDS, HandoffDocument, HistoryKind, INITIAL_STAGE, LIMITS, LOCK_FILE, LocksDocument, METADATA_LOCK_FILE, MachineMetrics, NovelProject, OPERATIONS, OUTLINE_DIR, OUTLINE_FILE, OpResult, Operation, OutlineChapter, OutlineDocument, OutlineProgress, OutlineVolume, PANEL_CHAPTER_LIMIT, PANEL_ID, PANEL_ROUTE, PHASE_STRIP, PLAN_DIR, PLATFORMS, PLUGIN_NAME, PROJECT_FILE, PanelBook, PanelBundle, PanelChapterRow, PanelChaptersDto, PanelDraft, PanelGatesDto, PanelMissing, PanelProjectOption, PanelSelection, PanelSnapshot, PanelSummaryDto, PipelineState, Platform, REGISTRY_FILE, REMOTE_VERSION, REVIEW_DIR, ReadingProof, ReadingProofReference, RelationshipDelta, RelationshipsDocument, ResumePromptInput, ReviewDocument, ReviewInput, ReviewIssue, RevisionEdit, RevisionInput, RevisionPatch, RoundCounters, SCENE_TYPES, SCENE_TYPE_DEFAULT, SCHEMA_VERSION, SESSION_BINDINGS_FILE, SKILL_NAME, STAGING_DIR, STATE_DIR, STATE_FILES, SceneType, ScoreDimension, SearchReport, SearchResultItem, Selection, SelectionSource, SemanticItem, Severity, Stage, StateDelta, StateError, StateErrorCode, StatusReport, TOOL_NAMES, TimelineDelta, TimelineDocument, ToolName, Violation, WORLDBOOK_FILE, Warning, WordMetrics, WorldDelta, WorldDocument, WorldPlanInput, WorldbookBackstory, WorldbookCharacter, WorldbookDocument, WorldbookFact, WorldbookFaction, WorldbookGlossary, WorldbookLocation, WorldbookRule, applicableGates, apply, blockedError, briefStageFor, chapterFile, chapterHeading, chapterHistoryFile, checkFile, checkHistoryFile, deprecatedChapterFile, deprecatedHistoryFile, evaluateGates, faultError, formatResumePrompt, gateName, inject, inputError, loadRulepack, name, parseParagraphLocation, phaseStrip, planChapterFile, planHistoryFile, planWorldFile, projectChapter, projectChapters, projectGates, projectSummary, renderBlurb, renderCover, renderEpubChapter, renderMarkdown, renderPlainText, renderProposal, reviewFile, reviewHistoryFile, verifyReference };