* Returns the full entity list for a project.

* Describe every known provider's model config for the settings UI: * current active model, hardcoded default, tier, known-model list, and the *

* Get skills grouped by category for dashboard display.

* Returns true if the given path appears to live inside a cloud-sync folder * (OneDrive / Dropbox / Google Drive). Used to warn loudly when the key

Absolute path to the out-of-repo key file.

Run the LLM judge — one AI call, structured JSON output. * @param kind Which lens to apply: 'craft' (developmental editor) or * 'm

* Run the periodic LLM consolidation. Updates snapshot.narrative. * Returns null if consolidation didn't run (no AI wired, or budget cap).

* Record a cost directly from the router response. Prefer passing the * router-supplied `estimatedCost` so we don't disagree with the per-provider

* Called by the worker after executing an approved request. * Transitions the request to 'completed' or 'failed'.

Reject a draft → deletes the SKILL.md file + marks rejected.

* Run a multi-phase continuity check across the entire project.

Persist the discovered slug + timestamp so future process starts skip the probe call.

Seed a ContextEngine cache with two chapter summaries for `projectId`.

* Send a reminder via the broadcast channel (WebSocket + Telegram)

* Switch the active persona. All subsequent conversation turns will be * tagged with this personaId so memory search can filter by pen name. * P

* Inject the tiered-memory service (Chunk B1). Follows the setContextEngine * pattern. When never called, memoryTier stays undefined and every CORE

* Start (or continue) a project and run ONE step through the AI. * Returns a short summary for Telegram + accurate word count.

* Start executing a project — marks it active and returns the first step

* Add or update a memory entry. Returns the row id. * Idempotent on (source, sourceRef) — re-indexing the same conversation * line / step output

Persist the key to the out-of-repo key file with restrictive perms.

Add words to today's count (called by goal engine after each step)

* Auto-add a book to a site when a linked project completes. Idempotent * on (siteId, book.slug). Called from the project-completion hook. *

* The autonomous wake cycle with priority-based project selection. * Runs on schedule, scores projects by priority, and executes steps.

* Broadcast a message to all known allowed users. * Used by autonomous heartbeat to send status updates.

* Build a detailed book cover prompt from context. Optional rich fields * (subgenre, mood, era, setting, keyImagery, palette, avoidImagery) are

* Build the full 90-day launch plan. Pure function — doesn't create * confirmations yet, just shows the user what's coming.

* Pass 2: Build a pronunciation dictionary template from the entity list. * Only includes entities whose names look "uncommon" (not in a basic word

* Build the unified bible by pulling every project's ContextEngine data * and merging entities + timeline. Does NOT mutate the individual project

* Build the user message for project step execution. * Injects uploaded manuscript DIRECTLY into the user message so the AI can't * miss it. For

* Hard-gate check. Returns passed=false if: * - Any required disclosure is missing from acknowledgedScopes * - Any applicable rule is a 'banne

* Check an outline against a chosen structure. Returns SUGGESTIONS, not * hard failures. Author can override anything they call deliberate. *

* Classify what type of writing task this is for tiered routing.

* Pass 1: Normalize manuscript text for narration.

* Compute the deterministic metrics from raw observations. No AI needed. * Cheap — runs in O(n) where n is bounded at MAX_OBSERVATIONS.

Compute the per-persona breakdown. Same observations, grouped.

* Create a Book Production project with dynamic chapter steps.

* Create a new confirmation request. The calling service MUST await a * subsequent 'approved' status via polling / awaitDecision() before * exec

* Debounced write — coalesces rapid updates into a single disk write.

* Deploy a rendered site directory using the configured target. * Returns DeployResult; never throws — failures come back as * { success: false,

* Score a single chapter for character-voice drift. For each character * with a fingerprint, compare their dialogue in this chapter to their * h

* Probe each candidate model with a tiny "ping" generateContent call. * Returns the first slug that does NOT 404. Cached per ImageGenService * i

* User-triggered version (via /api or skill-acquisition skill). * Same drafter, different `source` label.

* Flag high-entropy paragraph spans that are the most likely to hide a * contradiction, so the expensive whole-chapter detect() call can be * pr

* Convert a markdown-ish blurb into KDP-compliant HTML plus variants.

* Main entry point: download → transcribe → extract notes. * @param url Video URL (yt-dlp handles YouTube/TikTok/Vimeo/etc.) * @param topic Auth

Pull a "Sources:" / "References:" list out of free text.

* Pull dialogue lines from a chapter and attribute speakers using the * standard quote conventions + optional dialogue tags. Same heuristic as *

Plain text of a paragraph (strips all tags).

Pull the first capitalized word (simple proper-noun heuristic).

Fake project port exposing our single seeded project.

* Fetch a URL and extract clean text content from the HTML. * Strips scripts, styles, nav, headers, footers, then HTML tags.

Find the nth change of a given type at a paragraph.

Locate a sibling project by name, returning its root dir or null.

* Convenience: return a single-string summary suitable for pasting into * a confirmation card's "disclosures" section.

* Generate an image from a text prompt. * Tries Together AI first (cheaper), falls back to OpenAI.

Generate TTS audio and send as voice message (used by voice mode + one-off requests)

* Generate a book cover image with smart prompting.

* Generate the full set of standard cover sizes an author needs: * ebook (vertical 2:3) — Amazon Kindle / KDP * print (vertical 2:3) — Print

* Generate an AI summary of a chapter and store it in the context.

* Check which image providers are available (have API keys). * Returned in PREFERENCE order so the dashboard can show the active fallback chain.