@buildaharness/aielia 0.3.9 → 0.3.10

package/dist/writer/article-style-derive.d.ts

@@ -0,0 +1,26 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { ArticleMeta } from './article-model.js';
+/**
+ * A first style sheet drawn from the text of an article that was just loaded: who it seems written for, what it does, how it sounds, how long
+ * it is, how the author writes, and the terms it uses consistently. One model call describes what the text shows. The result only fills what the
+ * writer has not set: a brief field that already has text is kept, and a writing profile already on the article is kept. Everything it writes is
+ * the writer's to edit, and it is never given back to the model as if the writer had said it.
+ */
+/** The most of the article sent, in characters. */
+export declare const STYLE_DERIVE_MAX_CHARS = 12000;
+export interface DerivedStyle {
+    status: 'derived' | 'not_derived';
+    meta: ArticleMeta;
+    /** What was filled in, for a plain sentence to the writer: brief field names, and "writing profile". */
+    filled: string[];
+    /** Why nothing was derived, when the model call failed or its answer could not be read. */
+    reason?: string;
+}
+export declare function deriveStyle(input: {
+    meta: ArticleMeta;
+    markdown: string;
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<DerivedStyle>;
+/** About one page of text. */
+export declare const STYLE_DERIVE_MIN_WORDS = 300;
+/** Whether the style sheet should be drawn from the text now: there is a page of text and the writer has set nothing yet. */
+export declare function shouldDeriveStyle(meta: Pick<ArticleMeta, 'brief' | 'style'>, markdown: string): boolean;

package/dist/writer/article-style.d.ts

@@ -0,0 +1,31 @@
+import { ArticleMeta, StyleProfile } from './article-model.js';
+import { SettingsStore } from './write-permissions.js';
+declare const BRIEF_FIELDS: readonly ["audience", "purpose", "tone", "length", "notes"];
+/** Replaces the article's brief. Empty fields are dropped; an empty brief removes it. */
+export declare function setBrief(meta: ArticleMeta, input: Partial<Record<(typeof BRIEF_FIELDS)[number], string | undefined>>): ArticleMeta;
+/** Normalises a profile: trims text, drops empty terms and repeats, caps the list. */
+export declare function cleanProfile(p: {
+    id: string;
+    name: string;
+    voice?: string;
+    terms?: {
+        use: string;
+        instead?: string;
+    }[];
+}): StyleProfile | undefined;
+/** Gives the article a copy of a profile, or removes it with null. */
+export declare function applyProfile(meta: ArticleMeta, profile: StyleProfile | null): ArticleMeta;
+/** The plain text the assistant is given, or '' when the writer set neither a brief nor a profile. */
+export declare function renderStyleGuide(meta: Pick<ArticleMeta, 'brief' | 'style'>): string;
+export declare function loadProfiles(store: SettingsStore): Promise<StyleProfile[]>;
+export declare function saveProfile(store: SettingsStore, profile: {
+    id?: string;
+    name: string;
+    voice?: string;
+    terms?: {
+        use: string;
+        instead?: string;
+    }[];
+}, newId?: () => string): Promise<StyleProfile | undefined>;
+export declare function deleteProfile(store: SettingsStore, id: string): Promise<void>;
+export {};

package/dist/writer/article-suggestions.d.ts

@@ -0,0 +1,33 @@
+import { ArticleMeta } from './article-model.js';
+/**
+ * Suggested changes (T9). A suggestion never touches the Markdown until the writer accepts it. It stores the exact
+ * quoted text it replaces; if that text is no longer where it was (or at all), the suggestion is stale and cannot be
+ * accepted as it stands. All functions are pure.
+ */
+export type SuggestionResult = {
+    ok: true;
+    meta: ArticleMeta;
+    markdown: string;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function proposeSuggestion(meta: ArticleMeta, markdown: string, input: {
+    quote: string;
+    replacement: string;
+    reason: string;
+    by: 'assistant' | 'writer';
+    now: string;
+    model?: string;
+    ideaIds?: string[];
+    commentIds?: string[];
+    sectionIds?: string[]; /** Look for the quote from here on, so the first of several equal passages is not always the one meant. */
+    from?: number;
+}): SuggestionResult;
+/** Marks pending suggestions stale when their quoted text no longer exists; refreshes the span of those that moved. */
+export declare function refreshSuggestions(meta: ArticleMeta, markdown: string): ArticleMeta;
+/** Accepts a pending suggestion, optionally with the writer's own replacement text. Returns the new Markdown. */
+export declare function acceptSuggestion(meta: ArticleMeta, markdown: string, id: string, edited?: string): SuggestionResult;
+export declare function rejectSuggestion(meta: ArticleMeta, id: string): SuggestionResult & {
+    ok: boolean;
+};

package/dist/writer/article-support.d.ts

@@ -0,0 +1,33 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { ArticleMeta, Claim, Source, SourceStatus } from './article-model.js';
+/**
+ * Per-statement support check (T7), built on the pattern of grounding-check.ts: one bounded call that compares a claim
+ * with the stored passages attached to it. The model judges; this module stores the verdict together with what it ran
+ * on (the claim text and the source fingerprints), so effectiveSourceStatus can later refuse to show a verdict that no
+ * longer applies. A check that could not run is never a pass: the claim keeps its status and the result says not_checked.
+ */
+export type SupportVerdict = Extract<SourceStatus, 'supported' | 'partly_supported' | 'not_supported' | 'contradicted'>;
+export type SupportCheck = {
+    status: 'checked';
+    meta: ArticleMeta;
+    verdict: SupportVerdict;
+    reason: string;
+} | {
+    status: 'no_sources';
+    meta: ArticleMeta;
+} | {
+    status: 'not_checked';
+    meta: ArticleMeta;
+    reason: string;
+};
+/** The sources linked to a claim by a supported_by link, in link order. */
+export declare function sourcesForClaim(meta: ArticleMeta, claimId: string): Source[];
+/** Text the model wrote or co-wrote is checked automatically (T7); a claim the writer alone wrote is checked on request. */
+export declare function needsAutoCheck(claim: Claim): boolean;
+export declare function checkClaimSupport(input: {
+    meta: ArticleMeta;
+    markdown: string;
+    claimId: string;
+    modelName: string;
+    now: string;
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<SupportCheck>;

package/dist/writer/article-verify.d.ts

@@ -0,0 +1,42 @@
+import { ArticleMeta, Claim } from './article-model.js';
+/**
+ * Verifying claims (pure parts): which claims to take, and how a search that found nothing is said. The search, the reading and the model
+ * check themselves are run by ArticleService.verifyClaims; whether a page backs a claim is the support check's judgement, never decided here.
+ */
+export type VerifyOutcome = 'supported' | 'partly_supported' | 'contradicted' | 'not_supported' | 'no_source_found' | 'cannot_search' | 'search_failed' | 'could_not_check';
+export interface VerifyEntry {
+    claimId: string;
+    quote: string;
+    outcome: VerifyOutcome;
+    /** Addresses of pages found and kept as sources for the claim. */
+    found: string[];
+    reason?: string;
+}
+export interface VerifyReport {
+    entries: VerifyEntry[];
+    /** Factual claims left for another run because of the limit. */
+    leftOver: number;
+    /** The writer stopped the run: the entries are the claims checked before that. */
+    stopped?: boolean;
+}
+export declare const DEFAULT_VERIFY_LIMIT = 10;
+export declare const DEFAULT_VERIFY_PAGES = 3;
+/**
+ * The claims to verify, in text order: the factual ones that are not already supported by a check that still counts. Named claims are taken
+ * even when supported (the writer asked for them). At most `limit` are taken; the count of the rest is returned.
+ */
+export declare function verifyTargets(meta: ArticleMeta, claimIds: readonly string[] | undefined, limit: number): {
+    ids: string[];
+    leftOver: number;
+};
+/** The lookup that still applies to the claim (its text has not changed since), or undefined. */
+export declare function currentLookup(claim: Claim): NonNullable<Claim['lookup']> | undefined;
+/** What the page says about a claim that was looked for and not backed; undefined when there was no lookup or sources have since been attached. */
+export declare function lookupNote(claim: Claim, hasSources: boolean): string | undefined;
+/** One sentence for the chat or a notice about a finished run. */
+export declare function summarizeVerify(report: VerifyReport): string;
+/**
+ * Where the whole article stands, from its records: a run only looks at some claims (a limit, or the ones already backed are skipped), so a later
+ * run's summary alone would read as if it were the result for the whole article. Empty when the article has no factual claims.
+ */
+export declare function summarizeArticleSources(meta: ArticleMeta): string;

package/dist/writer/local-folder.d.ts

@@ -0,0 +1,49 @@
+/**
+ * A folder on the writer's own computer (a checkout of a repository, say) that the writer has allowed the page to read.
+ * The page reads from it only what the writer picks, and never writes to it. The reader is held for the session; nothing about it is stored
+ * in the article except the file's address, written as `<folder name>/<path>`, which is how a file is found again.
+ */
+export interface FolderReader {
+    /** The folder's own name, the first part of every file's address. */
+    name: string;
+    /** Paths of the readable files under the folder, relative and with `/` separators. */
+    files(): Promise<string[]>;
+    /** The file's text, or undefined when it is gone or cannot be read. */
+    read(path: string): Promise<string | undefined>;
+}
+/** The most files a listing keeps; a repository with more is listed level by level and the deepest are left out. */
+export declare const MAX_FILES = 20000;
+export declare function isSkippedFolder(name: string): boolean;
+/** The address a folder file is stored under. */
+export declare function folderFileAddress(folderName: string, path: string): string;
+/** The path inside the folder for an address stored by folderFileAddress, or undefined when the address belongs to another folder. */
+export declare function pathInFolder(folderName: string, address: string): string | undefined;
+/**
+ * Walks a folder through a lister that says, for a directory path, its entries and which are folders. Skipped folders are left out, only files the
+ * Write page can read as text or code are kept, and the walk stops at a fixed depth and file count.
+ */
+export declare function walkFolder(list: (dir: string) => Promise<{
+    name: string;
+    directory: boolean;
+}[]>): Promise<string[]>;
+/**
+ * A reader over a file system that can list a directory with each entry marked as a file or a folder (the desktop app's `workspace_list_dir`),
+ * so subfolders are walked into without guessing which names are folders. `root` is the folder's absolute path.
+ */
+export declare function folderFromListing(fs: {
+    readTextFile(path: string): Promise<string | undefined>;
+    listDir(path: string): Promise<{
+        name: string;
+        directory: boolean;
+    }[]>;
+}, root: string, name: string): FolderReader;
+/**
+ * A reader over a file-system backend that has only readTextFile and readDir (the desktop app's). It cannot tell a folder from a file by name, so a
+ * path that cannot be listed as a directory is taken to be a file.
+ */
+export declare function folderFromFsBackend(fs: {
+    readTextFile(path: string): Promise<string | undefined>;
+    readDir(path: string): Promise<string[]>;
+}, root: string, name: string): FolderReader;
+/** The files whose path contains every word typed (any case), shortest path first; at most `limit`. A plain filter, no meaning is read from the words. */
+export declare function matchFolderFiles(files: string[], query: string, limit?: number): string[];

package/dist/writer/model-failure-hint.d.ts

@@ -0,0 +1,7 @@
+/**
+ * What to try after a model call failed, chosen by the backend and not by the wording of the error. The Claude CLI backend has no key or model
+ * to check: its calls fail when the CLI is not signed in, so the hint says to sign in. Every other backend is told to check the key and model.
+ */
+export declare const DEFAULT_MODEL_HINT = "Check your key and the model in Settings, or pick another model next to the chat, then try again.";
+export declare const CLAUDE_SIGN_IN_HINT = "Sign in to Claude (run \"claude\" in a terminal and use /login), or pick another model next to the chat, then try again.";
+export declare function modelFailureHint(backend: string | undefined): string;

package/dist/writer/repo-reader.d.ts

@@ -0,0 +1,29 @@
+import { FolderReader } from './local-folder.js';
+/**
+ * A repository the writer hands to Write so claims about code can be found in it and verified: a folder on the writer's computer (the same
+ * reader as for folder files) or a GitHub repository. Both only list and read; neither writes. A GitHub repository is read through GitHub's
+ * own interfaces (the file list from the API, file text from raw.githubusercontent.com), which a browser may call directly. A private
+ * repository needs the writer's own token, kept in this browser.
+ */
+export interface RepoReader extends FolderReader {
+    /** The address a file of this repository is stored under as a source (a link for GitHub, `<folder>/<path>` for a folder). */
+    addressOf?(path: string): string;
+}
+export interface GithubRepoSpec {
+    owner: string;
+    repo: string;
+    /** A branch, tag or commit; the repository's default branch when absent. */
+    ref?: string;
+    /** Only the files under this folder (from an address like github.com/o/r/tree/main/packages/x). */
+    path?: string;
+}
+/** The repository named by a GitHub address (github.com/o/r, with an optional /tree/<ref>), or `o/r`. Anything else is undefined. */
+export declare function parseGithubRepoAddress(input: string): GithubRepoSpec | undefined;
+export interface GithubReaderOptions {
+    fetchImpl?: typeof fetch;
+    /** The writer's own GitHub token, for a private repository. Sent only to GitHub. */
+    token?: string;
+}
+export declare function githubRepoReader(spec: GithubRepoSpec, options?: GithubReaderOptions): RepoReader;
+/** Several repositories read as one: each file is listed as `<repository name>/<path>`, and reads and addresses are routed back to the repository it came from. */
+export declare function combineRepos(readers: readonly RepoReader[]): RepoReader;

package/dist/writer/repo-search.d.ts

@@ -0,0 +1,33 @@
+import { FolderReader } from './local-folder.js';
+/**
+ * A searchable copy of a repository held in memory for one session, so a model can look things up (search, read some lines, list a folder) instead of being
+ * shown a path list and asked to guess. Built from any reader (a local folder or a GitHub repository); nothing is written anywhere. Pure: no node or DOM imports.
+ */
+/** Files bigger than this are left out (generated or data files that would only drown the search). */
+export declare const MAX_INDEXED_FILE_CHARS = 300000;
+/** The most characters of text a single search or read answers with. */
+export declare const MAX_ANSWER_CHARS = 4000;
+export declare const MAX_MATCHES = 30;
+export interface RepoIndex {
+    /** Number of files held. */
+    readonly fileCount: number;
+    /** Lines matching a pattern (case-insensitive regular expression; an invalid one is searched as plain text), as `path:line: text`. `glob` narrows the paths (`*.ts`, a folder, or a part of a path). */
+    search(pattern: string, glob?: string): string;
+    /** The lines `from`..`to` (1-based, inclusive) of a file, numbered; at most MAX_ANSWER_CHARS characters. */
+    readLines(path: string, from?: number, to?: number): string;
+    /** The files and folders directly under a folder ('' for the top). */
+    list(folder?: string): string;
+    /** The whole text of a file, or undefined. */
+    text(path: string): string | undefined;
+    /** Whether the file exists in the index. */
+    has(path: string): boolean;
+    /** How many files the reader listed, and how many of them could not be read at all (a failed or rate-limited fetch, not an empty or oversized file). */
+    readonly listed: number;
+    readonly unreadable: number;
+}
+export declare function createRepoIndex(files: ReadonlyMap<string, string>, stats?: {
+    listed?: number;
+    unreadable?: number;
+}): RepoIndex;
+/** Reads every file the reader lists (skipping the oversized and the empty) into an index. */
+export declare function buildRepoIndex(reader: FolderReader): Promise<RepoIndex>;

package/dist/writer/repo-verify-loop.d.ts

@@ -0,0 +1,61 @@
+import { ILLMClient, TokenUsage, ToolDefinition } from '@buildaharness/runtime';
+import { RepoIndex } from './repo-search.js';
+/**
+ * Checking a batch of claims against a repository with a model that can look things up: it searches, reads some lines, and answers each claim with
+ * a verdict and the file lines and exact words that decide it. The loop owns everything mechanical: it runs the lookups, refuses answers whose quoted
+ * words are not in the named file, and sends the claims that came back unsettled or unsourced to the model once more in the same conversation
+ * (the earlier turns are the shared start of that call, so a provider's prompt cache serves them). The model judges; it is never trusted on a quote.
+ */
+export type LoopVerdict = 'supported' | 'partly_supported' | 'contradicted' | 'not_supported' | 'not_about_code';
+export interface LoopEvidence {
+    /** Repository path. */
+    file: string;
+    /** Line range of the excerpt in the file as found (1-based), recomputed from the file, not taken from the model. */
+    from: number;
+    to: number;
+    excerpt: string;
+}
+export interface LoopResult {
+    id: string;
+    verdict: LoopVerdict;
+    reason: string;
+    /** Only excerpts that were found word for word in their file. */
+    evidence: LoopEvidence[];
+    /** What was searched, when the claim stayed unsettled. */
+    searched: string[];
+    /** Why this result is not trustworthy, when it is not (no answer, no usable quote); absent for a settled claim. */
+    problem?: string;
+}
+export interface LoopStep {
+    tool: string;
+    input: Record<string, unknown>;
+    chars: number;
+}
+export interface LoopOptions {
+    model?: string;
+    onUsage?: (usage: TokenUsage) => void;
+    onStep?: (step: LoopStep) => void;
+    /** The most lookups for the first pass and again for the follow-up pass. Past it the model is told to answer. */
+    maxToolCalls?: number;
+    /** The most model turns for one pass (a safety net against a model that never answers). */
+    maxTurns?: number;
+    /** The most tokens one model turn may produce (default 12000: a 25-claim answer is about 6000). A turn that runs away costs a whole run otherwise. */
+    maxTokens?: number;
+    /** Send unsettled claims back once (default true). */
+    gapPass?: boolean;
+}
+export declare const REPO_TOOLS: ToolDefinition[];
+/** Where the excerpt sits in the file: its first and last line, or undefined when its words are not there. `...` inside an excerpt joins separate pieces. */
+export declare function locateExcerpt(text: string, excerpt: string): {
+    from: number;
+    to: number;
+} | undefined;
+/** Turns the model's answer into one result per claim; anything missing or unquotable is marked with its problem. */
+export declare function checkAnswers(claimIds: readonly string[], rows: unknown, index: RepoIndex): LoopResult[];
+export declare function verifyBatchWithTools(input: {
+    claims: readonly {
+        id: string;
+        quote: string;
+    }[];
+    articleText: string;
+}, index: RepoIndex, llm: ILLMClient, opts?: LoopOptions): Promise<LoopResult[]>;

package/dist/writer/text-tool-calls.d.ts

@@ -0,0 +1,11 @@
+import { ChatMessage, ChatOptions, ILLMClient, LLMStructuredResponse, ToolDefinition } from '@buildaharness/runtime';
+/**
+ * Tool use for a backend that cannot take tool definitions itself (the local `claude -p` client runs its own tool loop and hands back only text).
+ * The tools are described in the system text, the conversation so far is written out as one prompt, and the model asks for lookups with a JSON
+ * object, which is turned back into the same tool calls an API backend returns. The caller's loop then runs the lookups as for any backend.
+ * Pure: no node or DOM imports.
+ */
+/** Whether the client takes tool definitions and returns tool calls itself (every API backend does; `claude -p` does not). */
+export declare function hasNativeToolCalls(llm: ILLMClient): boolean;
+/** One model turn with tools, over plain text. Returns tool calls when the reply asks for lookups, else the reply as the content. */
+export declare function callWithTextTools(llm: ILLMClient, messages: ChatMessage[], tools: ToolDefinition[], options: ChatOptions): Promise<LLMStructuredResponse>;

package/dist/writer/work-progress.d.ts

@@ -0,0 +1,51 @@
+/**
+ * What Write tells the writer while a model call runs in the background: a short checklist for the kind of job, and the sentence for
+ * the stage it is at. Pure, so the browser and desktop builds render the same words. The stages are the real boundaries of the work;
+ * nothing here cycles on a timer.
+ */
+export type WorkKind = 'edit' | 'draft' | 'suggest' | 'answer' | 'verify' | 'check'
+/** Any change to the article that saves the text first and reloads it after; the middle step is the action's own label. */
+ | 'change' | 'resolve' | 'files' | 'publish' | 'prepare' | 'style' | 'import' | 'page' | 'other';
+export interface WorkPlan {
+    /** The stages of this kind of job, in order, each a phrase for a checklist ("Reading your request"). */
+    steps: readonly string[];
+}
+/** The checklist for a kind of job; empty when the job is too short to need one. A 'change' is named by the action's own `label`. */
+export declare function workPlan(kind: WorkKind, label?: string): WorkPlan;
+export type StepState = 'done' | 'current' | 'waiting';
+export interface ChecklistItem {
+    text: string;
+    state: StepState;
+}
+/** The checklist with `current` as the step in progress: earlier ones done, later ones waiting. An index past the end marks all done. */
+export declare function checklistAt(plan: WorkPlan, current: number): ChecklistItem[];
+/** The sentence under the checklist for the current stage, in the first person ("Reading your request…"). */
+export declare function stageSentence(plan: WorkPlan, current: number): string | undefined;
+/** A running time for a job that has been going a while; nothing for the first few seconds, when it would only be noise. */
+export declare function elapsedText(ms: number, after?: number): string | undefined;
+/**
+ * The stretch of `after` that differs from `before`, found from the text both start and end with; null when nothing was added or changed
+ * (a pure deletion leaves nothing to light). Used to light the passage a job has just written.
+ */
+export declare function changedRange(before: string, after: string): {
+    start: number;
+    end: number;
+} | null;
+/**
+ * The passage to light after a job changed the text: the changed range, unless it is most of the text (a first draft, a full rewrite),
+ * where lighting it would only tint the whole article and point at nothing.
+ */
+export declare function litRange(before: string, after: string, maxShare?: number): {
+    start: number;
+    end: number;
+} | null;
+export type ResultTone = 'good' | 'warn' | 'bad';
+/** One finished piece of a counted job, shown under the bar as it settles ("Backed: the p99 was 18 ms"). */
+export interface ResultLine {
+    text: string;
+    tone: ResultTone;
+}
+/** The line for one checked claim: what came of it, then the claim cut to `max` characters. */
+export declare function claimResultLine(outcome: string, quote: string, max?: number): ResultLine;
+/** The lines kept on show: the newest few, so a long run does not push the rest of the block away. */
+export declare function recentResults(lines: readonly ResultLine[], line: ResultLine, keep?: number): ResultLine[];

package/dist/writer/write-activity.d.ts

@@ -0,0 +1,61 @@
+/**
+ * What the writer has done with Write, kept in this browser (or app) only and never sent anywhere: one small record per background job, so
+ * how Write is used (which jobs, how often they finish, how long they take, what they cost) can be seen without asking anyone.
+ * A record holds the kind of job, how it ended, the time and the cost; it never holds the writer's words, an article's name or a label.
+ */
+export type JobOutcome = 'done' | 'stopped' | 'failed';
+export interface JobRecord {
+    /** ISO time the job started. */
+    at: string;
+    /** The kind of job (a WorkKind: edit, draft, verify, publish...). */
+    kind: string;
+    outcome: JobOutcome;
+    ms: number;
+    usd: number;
+    calls: number;
+}
+export declare const ACTIVITY_KEY = "writer:activity";
+/** The newest records kept; older ones fall away so the record cannot grow without end. */
+export declare const MAX_ACTIVITY_RECORDS = 1000;
+export declare const isJobRecord: (x: unknown) => x is JobRecord;
+export declare function addRecord(records: readonly JobRecord[], record: JobRecord): JobRecord[];
+export interface KindSummary {
+    kind: string;
+    runs: number;
+    done: number;
+    stopped: number;
+    failed: number;
+    medianMs: number;
+    usd: number;
+}
+export interface ActivitySummary {
+    jobs: number;
+    firstAt?: string;
+    lastAt?: string;
+    /** Distinct days with at least one job. */
+    days: number;
+    usd: number;
+    /** Share of jobs that ended in 'done' (0 to 1); undefined with no jobs. */
+    doneRate?: number;
+    kinds: KindSummary[];
+}
+/** Counts per kind of job, most used first. */
+export declare function summarizeActivity(records: readonly JobRecord[]): ActivitySummary;
+/** The summary as plain text the writer can read, or copy to tell someone how Write went. */
+export declare function activityReport(s: ActivitySummary): string;
+/** Finished runs of a kind needed before a typical time is worth saying. */
+export declare const MIN_RUNS_FOR_TYPICAL = 3;
+/** How long a kind of job usually takes: the median of its finished runs, or undefined until there are enough of them. */
+export declare function typicalMs(records: readonly JobRecord[], kind: string): number | undefined;
+/** "Usually about 20 s": rounded so it reads as an expectation, not a measurement (to 5 s under a minute, to 15 s above). Nothing for a job that is quick anyway. */
+export declare function usuallyText(ms: number | undefined): string | undefined;
+export interface ActivityStore {
+    getSetting(key: string): Promise<unknown>;
+    setSetting(key: string, value: unknown): Promise<void>;
+}
+export interface ActivityLog {
+    record(job: JobRecord): Promise<void>;
+    read(): Promise<JobRecord[]>;
+}
+/** The log over a settings store. A failure to save never reaches the job that was being recorded. */
+export declare function createActivityLog(store: ActivityStore): ActivityLog;

package/dist/writer/write-models.d.ts

@@ -0,0 +1,12 @@
+/** What to call a model id in the page. The Claude CLI backend has no default id of its own (the CLI picks the model), so its id is empty: say so rather than show nothing. */
+export declare const CLI_DEFAULT_LABEL = "Claude default";
+export declare const modelLabel: (model: string | undefined) => string;
+export declare function suggestedModels(backend: string): string[];
+export interface WriteModelDefaults {
+    /** For the chat, edit suggestions and checks the writer starts from the chat. */
+    chat: string;
+    /** For checks that run by themselves after typing. */
+    auto: string;
+}
+/** `configured` is the model from the visitor's settings, when they set one. */
+export declare function defaultWriteModels(backend: string, configured?: string): WriteModelDefaults;

package/dist/writer/write-parameters.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The adjustments a writer can ask for in the chat. The first menu holds a handful of categories; picking one opens a single field whose
+ * suggestions are "Aspect: option" pairs (type to filter, or type your own words). Whatever is sent becomes an ordinary chat message.
+ * Two kinds, which only change the wording of the instruction: "setting" (how the article should be written: tone, length, audience ...)
+ * and "revision" (a one-off action on the text: shorten the introduction, add examples ...).
+ * Settings that are not about the text itself live elsewhere (Style tab, Sources tab, the Do actions) and are deliberately not repeated here.
+ */
+export type ParameterGroup = 'tone' | 'audience' | 'length' | 'structure' | 'seo' | 'sources' | 'promotion' | 'brand' | 'revise';
+export type ParameterKind = 'setting' | 'revision';
+export interface WriteParameter {
+    id: string;
+    label: string;
+    options: string[];
+    group: ParameterGroup;
+    kind: ParameterKind;
+}
+export declare const WRITE_PARAMETERS: WriteParameter[];
+export declare function findParameter(id: string): WriteParameter | undefined;
+export declare const PARAMETER_GROUPS: {
+    id: ParameterGroup;
+    label: string;
+}[];
+/** The suggestions of a category, each one "Aspect: option". */
+export declare function adjustmentChoices(group: ParameterGroup): string[];
+/** The chat message an adjustment turns into. Any aspect and any value are accepted, listed or not. */
+export declare function adjustmentInstruction(aspect: string, value: string, kind: ParameterKind): string;
+/**
+ * What the writer typed in a category's field. A suggestion ("Tone of voice: Witty", or its aspect with a value of their own) keeps its
+ * aspect; any other words are taken as the request itself. `group` is absent for "Something else".
+ */
+export declare function adjustmentFromText(group: ParameterGroup | undefined, text: string): string;

package/dist/writer/write-permissions.d.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { ChatMessage, ILLMClient, TokenUsage } from '@buildaharness/runtime';
+/**
+ * The permission list (T11): what the assistant may do on its own in Aielia Write, with defaults the writer can change, and
+ * a spending cap that stops model calls once reached. Changes the text only ever as suggestions (T9), so there is no
+ * "edit directly" permission to grant. Pure data plus a client wrapper; storage goes through any `get`/`set` of settings.
+ */
+export declare const WritePermissionsSchema: z.ZodObject<{
+    /** Read each message for reviewer comments, decisions and corrections (T13). On by default; off means nothing is recorded from chat. */
+    captureChat: z.ZodBoolean;
+    /** Run the claim check and the effects check on its own after the writer stops typing. Off by default: it spends the writer's money without being asked. */
+    autoCheck: z.ZodBoolean;
+    /** Read the web sources again just before publishing, and say which changed or could not be reached. On by default: it costs a model call only for a page that changed. Publishing is never blocked by it. */
+    recheckBeforePublish: z.ZodDefault<z.ZodBoolean>;
+    /** Stop all model calls once this much has been spent in this browser, in US dollars. Unset means no cap. */
+    spendCapUsd: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    captureChat: boolean;
+    autoCheck: boolean;
+    recheckBeforePublish: boolean;
+    spendCapUsd?: number | undefined;
+}, {
+    captureChat: boolean;
+    autoCheck: boolean;
+    recheckBeforePublish?: boolean | undefined;
+    spendCapUsd?: number | undefined;
+}>;
+export type WritePermissions = z.infer<typeof WritePermissionsSchema>;
+export declare const DEFAULT_WRITE_PERMISSIONS: WritePermissions;
+export interface SettingsStore {
+    getSetting(key: string): Promise<unknown>;
+    setSetting(key: string, value: unknown): Promise<void>;
+}
+export declare function loadPermissions(store: SettingsStore): Promise<WritePermissions>;
+export declare function savePermissions(store: SettingsStore, permissions: WritePermissions): Promise<void>;
+export declare class SpendCapReachedError extends Error {
+    readonly capUsd: number;
+    readonly spentUsd: number;
+    constructor(capUsd: number, spentUsd: number);
+}
+/** Running total of what the model calls cost, persisted so a reload does not reset the cap. */
+export interface SpendMeter {
+    spentUsd(): number;
+    /** `model` is the model that made the call; it is priced by that model, falling back to the meter's default. */
+    record(usage: CountedUsage, callType?: string, model?: string): Promise<void>;
+    /** Dollars and number of calls so far for each kind of call (the chat, the claim check, ...). Calls made before this was kept are in the total only. */
+    byType(): Record<string, {
+        usd: number;
+        calls: number;
+    }>;
+    /** Throws SpendCapReachedError when the cap is set and reached. */
+    assertWithinCap(capUsd: number | undefined): void;
+    /** Back to nothing spent, after the stored totals were deleted. */
+    reset(): void;
+    /** Dollars, tokens and calls counted since the page was opened (the dollars include what earlier visits spent). A caller takes one before and one after a request to know what that request cost. */
+    snapshot(): SpendSnapshot;
+    /** Called after every counted call and after a reset, so what is shown follows the real total. Returns the way to stop listening. */
+    subscribe(listener: () => void): () => void;
+}
+/** `cachedTokens` is the part of the input that came from the provider's cache; absent until some call has reported it (a backend that does not report it is not the same as none cached). */
+/** `estimatedInputTokens` is the part of `inputTokens` that was worked out from the size of the requests because the backend reported far fewer than they held. */
+export interface SpendSnapshot {
+    usd: number;
+    inputTokens: number;
+    outputTokens: number;
+    calls: number;
+    cachedTokens?: number;
+    estimatedInputTokens?: number;
+}
+/** Token counts as the meter takes them: `estimated` marks an input count that was worked out from the request, not reported. */
+export type CountedUsage = TokenUsage & {
+    estimated?: boolean;
+};
+/** About four characters to a token: a rough size for a request, used only when the backend's own count cannot be believed. */
+export declare function estimateInputTokens(messages: readonly ChatMessage[]): number;
+/**
+ * A backend (a proxy that drops them, say) can report a handful of input tokens for a request that holds thousands. Then the input is counted by the size
+ * of the request, so the cost and the cap are not understated, and the count is marked as estimated. A count that is plausible is left as reported.
+ */
+export declare function withEstimatedInput(usage: TokenUsage, messages: readonly ChatMessage[]): CountedUsage;
+export declare function createSpendMeter(store: SettingsStore, pricing: {
+    backend?: string;
+    model?: string;
+}): Promise<SpendMeter>;
+/**
+ * Wraps a client so every call is counted, and no call starts once the cap is reached. Every model step in the article
+ * service fails closed on an error (nothing is marked checked), so hitting the cap degrades to "not checked", never to a wrong result.
+ */
+export declare function withSpendCap(inner: ILLMClient, meter: SpendMeter, getCap: () => number | undefined): ILLMClient;

package/dist/writer/write-spend.d.ts

@@ -0,0 +1,16 @@
+import { ChatMessage } from '@buildaharness/runtime';
+/**
+ * What a model call was for, so the page can show where the writer's money went. The call type is read from the opening words of the
+ * call's system prompt (each step of the article service has its own); a call with none of these is the chat answering the writer.
+ * A test runs every step and fails if one is not recognised here, so a reworded prompt cannot silently move its cost to "chat".
+ */
+export interface CallType {
+    id: string;
+    label: string;
+    /** The start of the step's system prompt. */
+    marker: string;
+}
+export declare const CALL_TYPES: readonly CallType[];
+export declare const CHAT_CALL: CallType;
+export declare function classifyCall(messages: readonly ChatMessage[]): CallType;
+export declare function callTypeLabel(id: string): string;