bareloop 0.43.0 → 0.45.0

package/types/authorjob.d.ts

@@ -87,19 +87,20 @@ export function refuseLockedKind(kind: string): Refusal;
  *   rates?: {in: number, out: number}|null, draftThinking?: 'on'|'off',
  *   onPhase?: (phase: string, data?: any) => void,
  *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string}) => void,
- *   seedFn?: Function, scoutFn?: Function, listingFn?: Function, lookFn?: Function|null,
+ *   seedFn?: Function, scoutFn?: Function, listingFn?: Function, lookFn?: Function|null, fitFn?: Function|null,
+ *   fitAsk?: ((question: string) => Promise<string|null>)|null, onFit?: (fit: {state: string, asks: any[], notFound: any[]}) => void,
  *   authorFn?: Function, authorOpts?: object, writeScope?: string[]|null,
  *   signerFix?: Function|any, proposeFn?: Function, compileOpts?: object,
  *   ask?: ((step: {kind: string, [k: string]: any}) => Promise<string|null>)|null,
- *   answerQuestions?: ((o: {questions: {line: number, question: string}[], dropped: {reason: string, raw: any}[], confirmed: any}) =>
- *     Promise<{jobLines: {n: number, text: string, rule?: string}[], answers: Record<string|number, any>}|null>)|null,
+ *   answerQuestions?: ((o: {questions: {line: number, question: string, rule?: number, source?: string, ask?: string, reading?: string}[], dropped: {reason: string, raw: any}[], confirmed: any}) =>
+ *     Promise<{jobLines: {n: number, text: string, rule?: string}[], answers: Record<string|number, any>, left?: {line: number, rule: number}[]}|null>)|null,
  *   confirmGenerate?: Function|null, isRepo?: boolean,
  *   langResult?: {kind: string, candidates?: string[], [k: string]: any}|null}} o
  * @returns {Promise<{ok: boolean, refusal: Refusal|null, verdictType: string|null,
  *   closeDecl: any, seedRef: string|null, authoring: any, judged: any, reds: Red[],
  *   stop: string|null, cost: any, interview: any, confirmed: any}>}
  */
-export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, jobLines, inputs, generate, provider, seedRef, scout, listing, ceilingUsd, rates, draftThinking, writeScope, judgeModel, onPhase, onCall, seedFn, scoutFn, listingFn, lookFn, authorFn, authorOpts, signerFix, proposeFn, compileOpts, ask, confirmGenerate, isRepo, langResult, answerQuestions, }: {
+export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, jobLines, inputs, generate, provider, seedRef, scout, listing, ceilingUsd, rates, draftThinking, writeScope, judgeModel, onPhase, onCall, seedFn, scoutFn, listingFn, lookFn, fitFn, fitAsk, onFit, authorFn, authorOpts, signerFix, proposeFn, compileOpts, ask, confirmGenerate, isRepo, langResult, answerQuestions, }: {
     answers: Record<string | number, any>;
     repoPath?: string | null;
     lang: string;
@@ -137,6 +138,13 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
     scoutFn?: Function;
     listingFn?: Function;
     lookFn?: Function | null;
+    fitFn?: Function | null;
+    fitAsk?: ((question: string) => Promise<string | null>) | null;
+    onFit?: (fit: {
+        state: string;
+        asks: any[];
+        notFound: any[];
+    }) => void;
     authorFn?: Function;
     authorOpts?: object;
     writeScope?: string[] | null;
@@ -151,6 +159,10 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
         questions: {
             line: number;
             question: string;
+            rule?: number;
+            source?: string;
+            ask?: string;
+            reading?: string;
         }[];
         dropped: {
             reason: string;
@@ -164,6 +176,10 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
             rule?: string;
         }[];
         answers: Record<string | number, any>;
+        left?: {
+            line: number;
+            rule: number;
+        }[];
     } | null>) | null;
     confirmGenerate?: Function | null;
     isRepo?: boolean;

package/types/declaredclose.d.ts

@@ -118,6 +118,7 @@ export function guardNames(closeDecl: any, verdictType: string): string[];
  *   judgeLoop?: ((o: {system: string}) => any)|null,
  *   judgeModel?: string|null,
  *   onJudgeCost?: ((c: any) => void)|null,
+ *   onRubricEvidence?: ((e: any) => void)|null,
  *   callBounds?: (() => {timeoutMs?: number, deadlineMs?: number})|null}} [opts]
  * @returns {Promise<any>}
  */
@@ -138,6 +139,7 @@ export function runDeclaredStages(stages: any[], redact?: (s: string) => string,
     }) => any) | null;
     judgeModel?: string | null;
     onJudgeCost?: ((c: any) => void) | null;
+    onRubricEvidence?: ((e: any) => void) | null;
     callBounds?: (() => {
         timeoutMs?: number;
         deadlineMs?: number;

package/types/draftspend.d.ts

@@ -3,6 +3,8 @@
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
  *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway" / "can't change it" / "not confirmed")
+ *  - `human`       {no, source: 'confirm'|'try-3'|'look', question, answer, line?, at}: one question the person was asked and what they answered (the answer is secret-masked
+ *    before it is written; the row is written only when BOTH exist, so a question nobody answered leaves no row)
  *  - `call`        {no, step, label, model, thinking, thinkingSupport, thinkingStatus?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
  *    (`thinking` = the tick's mode: off | on; `thinkingSupport` = bare-agent's lookup for the model: true | false | 'unverified';
  *    `thinkingStatus` = bare-agent's own verdict for the call's run: applied | unsupported | ignored | unknown, present only when thinkingMode was sent)
@@ -58,12 +60,33 @@ export function sessionDirForRow(row: {
     home?: string;
     sessionsRoot?: string;
 }): string | null;
+/**
+ * PRD v1.106 Part 5 Q1: one answered question as the two lines the Audit's drafting table shows under its step. ONE place owns the words.
+ * @param {{question: string, answer: string, source?: string, line?: number, at?: string}} h
+ * @returns {{question: string, answer: string, source: string, line?: number, at?: string, askedText: string, saidText: string}}
+ */
+export function humanRowWords(h: {
+    question: string;
+    answer: string;
+    source?: string;
+    line?: number;
+    at?: string;
+}): {
+    question: string;
+    answer: string;
+    source: string;
+    line?: number;
+    at?: string;
+    askedText: string;
+    saidText: string;
+};
 /**
  * Fold `<dir>/draft-log.jsonl` into one record per drafting step, each with its calls. A line that cannot be parsed is
  * skipped (a torn last line must not hide the rest).
  * @param {string} dir
  * @returns {{no: number, id: string, label: string, status: 'running'|'done'|'failed', startedAt: string, endedAt: string|null, wallMs: number|null,
- *   calls: {label: string, model: string|null, costUsd: number|null, unpricedRounds: number, at: string}[]}[]}
+ *   calls: {label: string, model: string|null, costUsd: number|null, unpricedRounds: number, at: string}[],
+ *   humans: ReturnType<typeof humanRowWords>[]}[]}
  */
 export function readDraftSteps(dir: string): {
     no: number;
@@ -80,6 +103,7 @@ export function readDraftSteps(dir: string): {
         unpricedRounds: number;
         at: string;
     }[];
+    humans: ReturnType<typeof humanRowWords>[];
 }[];
 /**
  * The DRAFTING PART of a run (hamr 2026-10-06, option A): the first part of the run's views, built from the session's
@@ -109,6 +133,8 @@ export const DRAFT_LOG_FILE: "draft-log.jsonl";
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
  *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway" / "can't change it" / "not confirmed")
+ *  - `human`       {no, source: 'confirm'|'try-3'|'look', question, answer, line?, at}: one question the person was asked and what they answered (the answer is secret-masked
+ *    before it is written; the row is written only when BOTH exist, so a question nobody answered leaves no row)
  *  - `call`        {no, step, label, model, thinking, thinkingSupport, thinkingStatus?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
  *    (`thinking` = the tick's mode: off | on; `thinkingSupport` = bare-agent's lookup for the model: true | false | 'unverified';
  *    `thinkingStatus` = bare-agent's own verdict for the call's run: applied | unsupported | ignored | unknown, present only when thinkingMode was sent)

package/types/facts.d.ts

@@ -23,6 +23,14 @@ export function factClaims(part: any, results: unknown): {
     quote: string;
     values?: Record<string, string>;
 }[];
+/**
+ * One amount of a money fact in the fact's OWN signed forms, never a hardcoded sign: `symbolFirst` puts the currency sign before the amount
+ * ("$144") when the fact has one, else the unit after it ("144 US dollars"); not `symbolFirst` (a rule's bound) prefers the unit.
+ * @param {any} f a money fact @param {string|number} n @param {boolean} symbolFirst @returns {string}
+ */
+export function moneyAs(f: any, n: string | number, symbolFirst: boolean): string;
+/** @param {any} f a fact with a rule @returns {string} the rule in words, e.g. "at most 450 US dollars" */
+export function ruleWords(f: any): string;
 /**
  * One fact as a plain row, written by code from the signed fields:
  * `fact · price — money, at most 450 US dollars, after "Price", quoted from "Flights"`.
@@ -69,3 +77,10 @@ export const FACT_OPS: readonly string[];
 export const MAX_FACTS: 10;
 /** every field a part of class `fact` may carry (the shared ones are checked by rubricStepShapeReds) */
 export const FACT_PART_FIELDS: readonly string[];
+/** the limits bareguard 0.24 puts on a money fact's lists (ruling #65), enforced here first so the red is ours and plain */
+export const MAX_CURRENCIES: 3;
+export const MAX_UNITS: 10;
+export const MAX_UNIT_CHARS: 100;
+export function asList(v: unknown): string[];
+export function moneyForms(f: any): string[];
+export function boundOk(shape: string, v: unknown): boolean;

package/types/factwords.d.ts

@@ -9,16 +9,35 @@ export function countExact(source: string, words: string): number;
  * @param {string} source @param {string} words @returns {number}
  */
 export function countPhrase(source: string, words: string): number;
+/**
+ * What the page-word map (src/pagemap.js) KEPT and DROPPED for one input: the sets the second proof reads. A look from the old search-and-read
+ * path has no `dropped` list, so it gives null and the label is proved against the code-made list as before.
+ * @param {{facts?: any[], dropped?: (import('./pagerules.js').Dropped & {source?: string})[]}|null|undefined} look @param {string} source
+ * @returns {{labels: Set<string>, units: Set<string>, currencies: Set<string>, words: Set<string>, dropped: Map<string, import('./pagerules.js').Dropped>}|null}
+ */
+export function keptSetOf(look: {
+    facts?: any[];
+    dropped?: (import("./pagerules.js").Dropped & {
+        source?: string;
+    })[];
+} | null | undefined, source: string): {
+    labels: Set<string>;
+    units: Set<string>;
+    currencies: Set<string>;
+    words: Set<string>;
+    dropped: Map<string, import("./pagerules.js").Dropped>;
+} | null;
 /**
  * The reds for ONE fact part against its frozen source text.
- * @param {{part: any, text: string, line: number|string, scan?: import('./labelscan.js').LabelScan}} o
+ * @param {{part: any, text: string, line: number|string, scan?: import('./labelscan.js').LabelScan, kept?: ReturnType<typeof keptSetOf>}} o
  * @returns {{code: string, detail: string}[]}
  */
-export function checkFactWords({ part, text, line, scan }: {
+export function checkFactWords({ part, text, line, scan, kept }: {
     part: any;
     text: string;
     line: number | string;
     scan?: import("./labelscan.js").LabelScan;
+    kept?: ReturnType<typeof keptSetOf>;
 }): {
     code: string;
     detail: string;
@@ -27,9 +46,13 @@ export function checkFactWords({ part, text, line, scan }: {
  * The reds for every fact part of a declaration. A fact part whose input text is not at hand is a red: a check whose words were never
  * proved against the source is never signed.
  * @param {any} declaration @param {Record<string, string>|null} texts label -> frozen text
+ * @param {{facts?: any[], dropped?: any[]}|null} [look] the page-word map's report: what it kept and dropped (null = no map, the code-made list is the proof)
  * @returns {{code: string, path: string, detail: string}[]}
  */
-export function checkDeclarationWords(declaration: any, texts: Record<string, string> | null): {
+export function checkDeclarationWords(declaration: any, texts: Record<string, string> | null, look?: {
+    facts?: any[];
+    dropped?: any[];
+} | null): {
     code: string;
     path: string;
     detail: string;

package/types/fitcheck.d.ts

@@ -0,0 +1,113 @@
+/**
+ * What the AI is told: the job lines (the numbered text only, no `~` rules) and the WHOLE text of every input under its label. Adapted from the POC
+ * call (.claude/scratch/fit-poc6/run.mjs): the asks are copied from each job line instead of hand-written.
+ * @param {{jobLines: {n: number, text: string}[], texts: Record<string, string>}} o
+ * @returns {string}
+ */
+export function fitPrompt({ jobLines, texts }: {
+    jobLines: {
+        n: number;
+        text: string;
+    }[];
+    texts: Record<string, string>;
+}): string;
+/**
+ * Read the AI's reply and decide, all in code. Malformed (no repair): not JSON, another form, a line that is not a job line, an ask not copied from its own
+ * line, found not a boolean, a quote neither text nor null, or a job line with no ask. An ask is found only if `found` is true AND its quote is on a page;
+ * `found` with a quote that is not on any page (or no quote) is made up and counts as not found.
+ * @param {unknown} text the reply
+ * @param {{n: number, text: string}[]} jobLines
+ * @param {Record<string, string>} texts the frozen input texts by label
+ * @returns {{status: 'malformed'}|{status: 'ok', state: 'fits'|'ask', asks: FitAsk[], notFound: {line: number, ask: string}[]}}
+ */
+export function decideFit(text: unknown, jobLines: {
+    n: number;
+    text: string;
+}[], texts: Record<string, string>): {
+    status: "malformed";
+} | {
+    status: "ok";
+    state: "fits" | "ask";
+    asks: FitAsk[];
+    notFound: {
+        line: number;
+        ask: string;
+    }[];
+};
+/**
+ * Run the fit check: one call (one retry on a malformed reply or a transport failure or a 429). Never throws on a call casualty; every failure is `absent`.
+ * @param {{jobLines: {n: number, text: string}[], texts: Record<string, string>, provider?: any, maxTokens?: number, ceilingUsd?: number|null,
+ *   callTimeoutMs?: number, onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string, raw?: string}) => void,
+ *   createLoop?: Function, rates?: {in: number, out: number}|null, callOptions?: Record<string, any>, sleep?: (ms: number) => Promise<void>}} o
+ * @returns {Promise<{state: 'fits'|'ask'|'absent', asks: FitAsk[], notFound: {line: number, ask: string}[], reason: string|null, cause: string|null,
+ *   calls: {label: string, costUsd: number|null, unpricedRounds: number}[], budgetStop: 'cap-halt'|'pricing-red'|null}>}
+ */
+export function runFitCheck({ jobLines, texts, provider, maxTokens, ceilingUsd, callTimeoutMs, onCall, createLoop, rates, callOptions, sleep, }: {
+    jobLines: {
+        n: number;
+        text: string;
+    }[];
+    texts: Record<string, string>;
+    provider?: any;
+    maxTokens?: number;
+    ceilingUsd?: number | null;
+    callTimeoutMs?: number;
+    onCall?: (call: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+        thinkingStatus?: string;
+        raw?: string;
+    }) => void;
+    createLoop?: Function;
+    rates?: {
+        in: number;
+        out: number;
+    } | null;
+    callOptions?: Record<string, any>;
+    sleep?: (ms: number) => Promise<void>;
+}): Promise<{
+    state: "fits" | "ask" | "absent";
+    asks: FitAsk[];
+    notFound: {
+        line: number;
+        ask: string;
+    }[];
+    reason: string | null;
+    cause: string | null;
+    calls: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    }[];
+    budgetStop: "cap-halt" | "pricing-red" | null;
+}>;
+/** the label of the one paid call, as the drafting book and the progress line see it */
+export const FIT_CALL_LABEL: "fit-check";
+/** what the chat says when the check did not finish (drafting goes on) */
+export const FIT_ABSENT_NOTE: "The fit check did not finish; drafting goes on.";
+/** the answer that keeps drafting after the fit question (any case, a closing full stop allowed) */
+export const FIT_GO_ON: "go on";
+export function isGoOn(text: unknown): boolean;
+export const FIT_SYSTEM: "You check whether saved web pages show what a job asks for. You never invent words: every ask must be copied from its job line and every quote must be copied from the page, character for character.";
+export function norm(s: unknown): string;
+export function notFoundList(notFound: {
+    line: number;
+    ask: string;
+}[]): string;
+export function fitQuestionText({ found, total, notFound }: {
+    found: number;
+    total: number;
+    notFound: {
+        line: number;
+        ask: string;
+    }[];
+}): string;
+export type FitAsk = {
+    line: number;
+    ask: string;
+    found: boolean;
+    quote: string | null;
+    madeUp: boolean;
+    ignored?: "number";
+};

package/types/inputlook.d.ts

@@ -148,6 +148,12 @@ export function lookPrompt({ jobLines, labels, lists }: {
     labels: string[];
     lists: Record<string, string>;
 }): string;
+/**
+ * A fact the page-word map kept (src/pagerules.js `KeptFact`), as the look report carries it: a phrase fact holds its alternative
+ * phrases; any other holds its labels (the first is the primary), and a money fact its units and currencies.
+ * @param {import('./pagerules.js').KeptFact} k @param {string} source @returns {LookFact}
+ */
+export function lookFactOf(k: import("./pagerules.js").KeptFact, source: string): LookFact;
 /**
  * Turn the AI's raw report into a VERIFIED one, by code, at $0. A fact is carried only when: its shape is a real shape, its source is
  * a real input, and its label is ON THE LIST for that input and shape (an id is resolved to its exact words). Anything else is moved
@@ -207,6 +213,9 @@ export const LOOK_REPORT_TOOL: "report_look";
 /** how many hits one search returns at most, and how long a snippet or a read line is */
 export const LOOK_MAX_HITS: 40;
 export { LABEL_SHAPES };
+/**
+ * `words` / `labels` / `unit` / `currency`: what the page-word map kept (idea A core)
+ */
 export type LookFact = {
     line: number;
     name: string;
@@ -220,6 +229,11 @@ export type LookFact = {
     rule?: any;
     aiProposal?: boolean;
     forRule?: number;
+    reading?: import("./pagerules.js").Reading;
+    words?: string[];
+    labels?: string[];
+    unit?: string[];
+    currency?: string[];
 };
 export type LookNotFound = {
     line: number;
@@ -234,5 +248,6 @@ export type LookReport = {
         text?: string;
     }[];
     notFound: LookNotFound[];
+    dropped?: import("./pagerules.js").Dropped[];
 };
 import { LABEL_SHAPES } from './labelscan.js';

package/types/kinds.d.ts

@@ -645,6 +645,11 @@ export type Ctx = {
         timeoutMs?: number;
         deadlineMs?: number;
     };
+    onRubricEvidence?: (e: {
+        step: number;
+        evidence: any[];
+        evidenceTotal?: number;
+    }) => void;
     onStage?: (row: {
         stage: string | null;
         kind: string | null;

package/types/pagedropwords.d.ts

@@ -0,0 +1,39 @@
+/** @param {Dropped} d @returns {string} the plain sentence for one drop */
+export function dropSentence(d: Dropped): string;
+/**
+ * One row per fact that lost something: the sentences (one per dropped word, then the fact's own), and whether the whole fact went.
+ * @param {Dropped[]|undefined|null} dropped
+ * @returns {{line: number, rule?: number, fact: string, full: boolean, sentences: string[]}[]}
+ */
+export function dropRows(dropped: Dropped[] | undefined | null): {
+    line: number;
+    rule?: number;
+    fact: string;
+    full: boolean;
+    sentences: string[];
+}[];
+/**
+ * A row as one Not-checked line, in the person's own words: `line N: "<the ~ rule as written, or the fact's name>" — <sentences>`.
+ * @param {{line: number, rule?: number, fact: string, sentences: string[]}} row @param {any[]|null|undefined} jobLines @param {(l: any) => string[]} rulesOf
+ * @returns {string}
+ */
+export function dropLine(row: {
+    line: number;
+    rule?: number;
+    fact: string;
+    sentences: string[];
+}, jobLines: any[] | null | undefined, rulesOf: (l: any) => string[]): string;
+/**
+ * An `s1` drop (a second fact that would read the same value as one already kept) is a NOTE when that OTHER fact is still signed: the guardrail
+ * is checked by it. With the other fact not signed, or no signed list given, the sentence stays Not checked. Every sentence of a row must qualify.
+ * @param {string} text one Not-checked line @param {string[]|null|undefined} [signed] the names of the facts the plan signs
+ * @returns {boolean} true when the line only says which written forms of a still-checked fact were not used
+ */
+export function isReadNote(text: string, signed?: string[] | null | undefined): boolean;
+/** @param {string[]|null|undefined} items @param {string[]|null|undefined} [signed] names of the signed facts (see isReadNote)
+ * @returns {{notChecked: string[], readNotes: string[]}} the lines split: what is left unchecked, and how the page was read */
+export function splitReadNotes(items: string[] | null | undefined, signed?: string[] | null | undefined): {
+    notChecked: string[];
+    readNotes: string[];
+};
+export type Dropped = import("./pagerules.js").Dropped;

package/types/pagedry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The result lines of a kept money fact: with a label, every page line where a kept label is followed by a number (one sign between allowed);
+ * with no label (U1 moved it to a unit, e.g. "€533 total"), every line where a number is followed by a kept unit.
+ * @param {string} text @param {KeptFact} k @returns {{quote: string, value: string}[]}
+ */
+export function moneyResultLines(text: string, k: KeptFact): {
+    quote: string;
+    value: string;
+}[];
+/**
+ * Dry-read every kept money fact; drop (as `reads-no-result`) the ones whose forms read no result line. Other facts pass through untouched.
+ * @param {string} text the frozen page text @param {KeptFact[]} facts what applyPageRules kept
+ * @returns {Promise<{facts: KeptFact[], dropped: Dropped[], reads: Record<string, number>, results: Record<string, number>}>}
+ *   `reads` / `results` = result lines the checker read / lines found, per fact name (for tests and reports; no verdict derives from the numbers)
+ */
+export function dryReadMoney(text: string, facts: KeptFact[]): Promise<{
+    facts: KeptFact[];
+    dropped: Dropped[];
+    reads: Record<string, number>;
+    results: Record<string, number>;
+}>;
+/**
+ * The same "can it read" for PHRASE facts (hamr ruled 3a, run m10-walk-flights-3: "Rome" was on the page only in "Track prices from Madrid to
+ * Rome" switches, in none of the 18 result lines, so no result could ever say it). A kept phrase fact is read against the page's RESULT LINES =
+ * the lines the job's kept money facts read (`moneyResultLines`), each graded as an honest claim by the real `gradeStep` (quote = that line;
+ * a phrase has no value to write). A phrase that reads no result line is dropped whole as `phrase-no-result` and shows under Not checked.
+ * With no kept money fact the result lines are unknown, so phrase facts pass through untouched (nothing is guessed about what a result is).
+ * @param {string} text the frozen page text @param {KeptFact[]} facts what the money dry read kept
+ * @returns {Promise<{facts: KeptFact[], dropped: Dropped[], reads: Record<string, number>}>} `reads` = result lines that said the phrase, per fact name
+ */
+export function dryReadPhrases(text: string, facts: KeptFact[]): Promise<{
+    facts: KeptFact[];
+    dropped: Dropped[];
+    reads: Record<string, number>;
+}>;
+export type KeptFact = import("./pagerules.js").KeptFact;
+export type Dropped = import("./pagerules.js").Dropped;

package/types/pagemap.d.ts

@@ -0,0 +1,154 @@
+/**
+ * What the AI is told, for ONE page input. Ported from the POC prompt: the job, the `~` rules, "a result is one item", the answer form
+ * and the shape meanings.
+ * @param {{jobLines: {n: number, text: string, rule?: string, rules?: string[]}[], label: string, text: string}} o
+ * @returns {string}
+ */
+export function mapPrompt({ jobLines, label, text }: {
+    jobLines: {
+        n: number;
+        text: string;
+        rule?: string;
+        rules?: string[];
+    }[];
+    label: string;
+    text: string;
+}): string;
+/**
+ * Read the AI's answer: ONE JSON object of the answer form, and nothing else. No repair (hamr's ruling): text that is not JSON, JSON of
+ * another form, or a fact whose shape or lists are not of the form is a malformed answer.
+ * @param {unknown} text @returns {{ok: true, mapping: import('./pagerules.js').PageMap}|{ok: false}}
+ */
+export function parseMapAnswer(text: unknown): {
+    ok: true;
+    mapping: import("./pagerules.js").PageMap;
+} | {
+    ok: false;
+};
+/**
+ * Run the map: one call per page input.
+ * @param {{texts: Record<string, string>, inputs: {n: number, label: string}[], jobLines: {n: number, text: string, rule?: string, rules?: string[]}[],
+ *   provider?: any, maxTokens?: number, ceilingUsd?: number|null, callTimeoutMs?: number,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string, raw?: string}) => void,
+ *   createLoop?: (o: {system: string, onLlmResult: any, provider: any, rates?: {in: number, out: number}}) => any,
+ *   rates?: {in: number, out: number}|null, callOptions?: Record<string, any>, sleep?: (ms: number) => Promise<void>, prove?: Function}} o
+ * @returns {Promise<{state: 'PRESENT'|'ABSENT', facts: any, reason: string|null, cause: string|null, meta: any, raw: string,
+ *   raws: ReturnType<typeof scrubRaw>[], calls: {label: string, costUsd: number|null, unpricedRounds: number}[],
+ *   budgetStop: 'cap-halt'|'pricing-red'|null}>}
+ */
+export function runPageMap({ texts, inputs, jobLines, provider, maxTokens, ceilingUsd, callTimeoutMs, onCall, createLoop, rates, callOptions, sleep, }: {
+    texts: Record<string, string>;
+    inputs: {
+        n: number;
+        label: string;
+    }[];
+    jobLines: {
+        n: number;
+        text: string;
+        rule?: string;
+        rules?: string[];
+    }[];
+    provider?: any;
+    maxTokens?: number;
+    ceilingUsd?: number | null;
+    callTimeoutMs?: number;
+    onCall?: (call: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+        thinkingStatus?: string;
+        raw?: string;
+    }) => void;
+    createLoop?: (o: {
+        system: string;
+        onLlmResult: any;
+        provider: any;
+        rates?: {
+            in: number;
+            out: number;
+        };
+    }) => any;
+    rates?: {
+        in: number;
+        out: number;
+    } | null;
+    callOptions?: Record<string, any>;
+    sleep?: (ms: number) => Promise<void>;
+    prove?: Function;
+}): Promise<{
+    state: "PRESENT" | "ABSENT";
+    facts: any;
+    reason: string | null;
+    cause: string | null;
+    meta: any;
+    raw: string;
+    raws: ReturnType<typeof scrubRaw>[];
+    calls: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    }[];
+    budgetStop: "cap-halt" | "pricing-red" | null;
+}>;
+/** @param {unknown} q a recorded question @returns {string|null} the reading a reading ask proposed, or null when it was another kind of question */
+export function readingOfQuestion(q: unknown): string | null;
+/**
+ * PRD v1.107 Part 5b ("the look reads, code asks"): the early asks CODE forces before any paid drafting, from the look's own result. Every `~` rule is
+ * one of three kinds:
+ *   - PAGE: a kept page word carries it (a kept fact with `forRule` and no `reading`): no ask.
+ *   - READING: a kept fact carries it with a `reading` (a limit the page cannot hold, e.g. "not a red-eye" -> departure time between 06:00 and 21:00).
+ *     Asked only when a bound of the reading is NOT in the words the person wrote (the same test as `rubric-fact-unmarked`, `boundInWords`); a
+ *     bound they wrote themselves is theirs and nothing is asked. `agree` writes the reading as a `~` rule in plain words (the answer text is
+ *     `reading`), so the drafter is told it and the fact signs plain.
+ *   - CAN'T CHECK: no kept fact carries it (PRD v1.106 Part 5 Q3 T2). `drop it` leaves it Not checked.
+ * One ask per rule text on a line; readings first, then can't-check asks, each in line order. The caller applies the machine's cap and the answer gate.
+ * @param {{facts?: {line: number, forRule?: number, name?: string, shape?: string, unit?: string[], currency?: string[], reading?: import('./pagerules.js').Reading}[]}|null|undefined} look
+ * @param {{n: number, text?: string, rule?: string, rules?: string[]}[]|null|undefined} jobLines
+ * @returns {LookAsk[]}
+ */
+export function askableFromLook(look: {
+    facts?: {
+        line: number;
+        forRule?: number;
+        name?: string;
+        shape?: string;
+        unit?: string[];
+        currency?: string[];
+        reading?: import("./pagerules.js").Reading;
+    }[];
+} | null | undefined, jobLines: {
+    n: number;
+    text?: string;
+    rule?: string;
+    rules?: string[];
+}[] | null | undefined): LookAsk[];
+/**
+ * PRD v1.107 Part 5b: more asks than the machine's cap means the job needs a rewrite, not a questionnaire. The code-owned stop words list EVERY ask and
+ * its reading as the suggestion (no extra paid call). A secret in a rule is masked.
+ * @param {LookAsk[]} asks @returns {string}
+ */
+export function tooManyAsksText(asks: LookAsk[]): string;
+/** the label of the one paid call, as the drafting book and the progress line see it */
+export const MAP_CALL_LABEL: "page-map";
+/** the shapes the map may name; a `place` is read by code as a phrase */
+export const MAP_SHAPES: readonly string[];
+export const MAP_SYSTEM: "You map a person's job to the exact words of ONE saved web page. You never grade and never invent words: every string you return must be copied from the page text, character for character.";
+/** the plain-word stop when the answer was not readable twice (no Resume: a draft is not a run) */
+export const MAP_UNREADABLE: "The AI's answer about the page was not readable twice. Nothing was signed.";
+/** the answer that drops a `~` rule the page cannot check: the person types it (any case, a closing full stop allowed) */
+export const DROP_IT: "drop it";
+export function isDropIt(text: unknown): boolean;
+export function isAgree(text: unknown): boolean;
+/**
+ * `reading` = the plain words an `agree` writes as a `~` rule (a reading ask only)
+ */
+export type LookAsk = {
+    line: number;
+    rule: number;
+    source: "look";
+    question: string;
+    ask: "reading" | "cant-check";
+    ruleText: string;
+    reading?: string;
+};
+import { scrubRaw } from './text.js';