agentfootprint 9.128.1 → 9.131.0

package/dist/esm/core/time/rowsBuild.js

@@ -0,0 +1,185 @@
+/**
+ * core/time/rowsBuild — the builders of the time layer's rows (`rows.ts` owns
+ * the shapes, the readers and the checkpoint door's checks).
+ *
+ * Pattern: one builder per row kind, each returning the plain record the
+ *          ledger's one writer files.
+ * Role:    core/ leaf (the time layer). Split from `rows.ts` because
+ *          `timeReadingRows` runs the resolver (`resolve.ts`), which only an
+ *          armed agent loads — its callers (`agent/stages/timeLayer.ts`, the
+ *          inputs layer's `arguments/resolve.ts`) are reached through
+ *          `import()` — while `rows.ts` sits on the checkpoint door's
+ *          synchronous path (the optional-family law of docs-next's site
+ *          budget). Import a builder from HERE — `rows.ts` does not re-export
+ *          them, or a bundler would place them on its synchronous path.
+ * Emits:   N/A.
+ *
+ * @example
+ * ```ts
+ * clockRow(clock, { turn: 1, iteration: 1 }); // { kind: 'clock', turn: 1, … }
+ * ```
+ */
+import { clockChange } from './clock.js';
+import { chooseReading, resolveMention } from './resolve.js';
+// ─── Building ────────────────────────────────────────────────────────────
+/** The clock stamp for one turn. */
+export function clockRow(clock, at, window) {
+    return {
+        kind: 'clock',
+        turn: at.turn,
+        iteration: at.iteration,
+        now: clock.now,
+        nowSource: clock.nowSource,
+        zone: clock.zone,
+        zoneSource: clock.zoneSource,
+        ...(window !== undefined && {
+            window: { from: window.from, to: window.to, source: 'control' },
+        }),
+    };
+}
+/**
+ * The row for one dispatched call. `nowMs` is the wall clock — the second of
+ * the layer's two recorded wall-clock reads (the first is a default `now`).
+ */
+export function callRow(call, at, nowMs, drift) {
+    return {
+        kind: 'call',
+        turn: at.turn,
+        iteration: at.iteration,
+        toolCallId: call.toolCallId,
+        toolName: call.toolName,
+        dispatchedAt: new Date(nowMs).toISOString(),
+        ...(drift !== undefined && { drift }),
+    };
+}
+/**
+ * The row for a resume whose passed `time` differs from the turn's kept clock
+ * (`clock.ts` · `clockChange`), or `undefined` when nothing differs. The kept
+ * clock is the turn's `clock` row; it is never replaced.
+ */
+export function clockOnResumeRow(passed, kept, at) {
+    const change = clockChange(passed, {
+        now: kept.now,
+        zone: kept.zone,
+        ...(kept.window !== undefined && { window: { from: kept.window.from, to: kept.window.to } }),
+    });
+    if (change === undefined)
+        return undefined;
+    return {
+        kind: 'clock-on-resume',
+        turn: at.turn,
+        iteration: at.iteration,
+        passed: change.passed,
+        kept: change.kept,
+    };
+}
+/**
+ * The `time-reading` rows for one checked reading (`reader.ts` ·
+ * `checkReading`): one per mention, resolved against the turn's clock — or
+ * one `mentions: 0` row. The one owner of the law "a reading only PROPOSES"
+ * (the owner's decision "Always confirm", time design TQ29): whatever the
+ * reader's kind, no reading is settled by the library and none is the
+ * person's words — its candidates carry `said: []` and its choice stays
+ * `open` with `confirm` (the policy may still remove readings), so the time
+ * ask offers it, pre-filled with its window and zone, and only the person's
+ * answer settles it (`rows.ts` · `TimeAnswerRow`).
+ */
+export function timeReadingRows(input) {
+    const { mentions, clock, policy, reader, tzdata, at } = input;
+    const base = {
+        kind: 'time-reading',
+        turn: at.turn,
+        iteration: at.iteration,
+        reader: { id: reader.id, version: reader.version, kind: reader.kind, locale: reader.locale },
+        tzdata,
+        mentions: mentions.length,
+    };
+    if (mentions.length === 0)
+        return [base];
+    return mentions.map((m, mention) => {
+        if ('refused' in m)
+            return { ...base, mention, refused: m.refused };
+        const resolution = resolveMention(m.parses, clock, { id: reader.id, kind: reader.kind }, true);
+        return {
+            ...base,
+            mention,
+            quote: m.quote,
+            parses: m.parses,
+            ...(m.problem !== undefined && { problem: m.problem }),
+            candidates: resolution.candidates,
+            choice: chooseReading(resolution, policy, reader.kind, m.problem, true),
+        };
+    });
+}
+const personOf = (w) => ({
+    from: w.range.from,
+    to: w.range.to,
+    source: w.source,
+    ...(w.mention !== undefined && { mention: w.mention }),
+});
+/** The `call-window` row for one call's decision (`bind.ts` · `callWindowOf`). */
+export function callWindowRow(call, decision, at) {
+    const base = {
+        kind: 'call-window',
+        turn: at.turn,
+        iteration: at.iteration,
+        toolCallId: call.toolCallId,
+        toolName: call.toolName,
+        how: decision.how,
+    };
+    const partly = 'partlyBeyondRetention' in decision && decision.partlyBeyondRetention === true
+        ? { partlyBeyondRetention: true }
+        : {};
+    switch (decision.how) {
+        case 'filled': {
+            const c = decision.conversion;
+            const widened = 'sent' in c ? c : undefined;
+            return {
+                ...base,
+                form: c.form,
+                asked: { from: decision.window.range.from, to: decision.window.range.to },
+                person: personOf(decision.window),
+                ...(c.rounded === true && { rounded: true }),
+                ...(widened !== undefined && { sent: widened.sent }),
+                ...(widened !== undefined &&
+                    (decision.trimmedByTool === true
+                        ? { trimmedByTool: true }
+                        : { differs: { extra: widened.extra } })),
+                ...partly,
+            };
+        }
+        case 'bound':
+            return {
+                ...base,
+                form: decision.form,
+                asked: decision.asked,
+                person: personOf(decision.window),
+                by: decision.by,
+                ...partly,
+            };
+        case 'model-chosen':
+            return {
+                ...base,
+                form: decision.form,
+                asked: decision.asked,
+                ...(decision.person !== undefined && { person: personOf(decision.person) }),
+                ...partly,
+            };
+        case 'model':
+            return { ...base, form: decision.form, asked: decision.asked, ...partly };
+        case 'unread':
+            return base;
+        case 'not-filled':
+            return { ...base, why: decision.why };
+        case 'refused':
+            return {
+                ...base,
+                refused: decision.refused,
+                ...(decision.form !== undefined && { form: decision.form }),
+                ...(decision.asked !== undefined && { asked: decision.asked }),
+                ...(decision.person !== undefined && { person: personOf(decision.person) }),
+                ...(decision.argument !== undefined && { argument: decision.argument }),
+            };
+    }
+}
+//# sourceMappingURL=rowsBuild.js.map

package/dist/esm/core/time/rowsBuild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowsBuild.js","sourceRoot":"","sources":["../../../../src/core/time/rowsBuild.ts"],"names":[],"mappings":"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"}

package/dist/esm/core/time/textForms.d.ts

@@ -0,0 +1,53 @@
+/**
+ * core/time/textForms — the spellings of the times written in TEXT (time
+ * design § 9.5, step T7): the text rule of `forms.ts` · `timeFormsOf`, and
+ * the small spelling parts both halves share.
+ *
+ * Pattern: pure regular expressions over the text — no reading, no resolver.
+ * Role:    split from `forms.ts` BY FILE for the synchronous doors: the
+ *          evidence gate's exempt corpus (`evidence/evidenceIndex.ts` ·
+ *          `addExempt`) runs on every agent with a gate, and a bundler places
+ *          a whole file on the synchronous graph — so the window half, which
+ *          re-resolves a recorded reading (`resolve.ts`), stays behind
+ *          `import()` (the optional-family law,
+ *          `test/lib/trace-toolpack/browserGraph.test.ts`). Imports nothing.
+ * Emits:   N/A.
+ *
+ * @example
+ * ```ts
+ * timeFormsOfText('2026-10-09').said; // ['2026', '10', '9']
+ * timeFormsOfText('took 2h');         // { said: [], derived: [] }
+ * ```
+ */
+/** The two lineages of the spellings of one source — see the file header. */
+export interface TimeForms {
+    readonly said: readonly string[];
+    readonly derived: readonly string[];
+}
+/**
+ * The spellings of the times written in `text` — `said` only (the text rule of
+ * `forms.ts` · `timeFormsOf`, which delegates here): an ISO date → its year,
+ * month and day; a 12-hour or 24-hour clock reading → its spellings. Slash
+ * dates and durations are never read.
+ *
+ * @example
+ * ```ts
+ * timeFormsOfText('what connected 8 Am to 8:40 AM PST').said;
+ * // ['8:00', '08:00', '8:00am', '8:40', '08:40', '8:40am']
+ * ```
+ */
+export declare function timeFormsOfText(text: string): TimeForms;
+/**
+ * The spellings of ONE clock time: the 24-hour form bare and padded
+ * (`8:00`, `08:00`, `20:00`), the 12-hour colon form (`8:00`) and its glued
+ * suffix form (`8:00pm`). After tokenizing, `8:00 PM` and `8:00 AM` both read
+ * `8:00` — the same hour on a 12-hour dial.
+ */
+export declare function clockSpellings(h24: number, minutes: string): readonly string[];
+export declare const pad2: (n: number) => string;
+/** An insertion-ordered set of spellings. */
+export declare class Spellings {
+    private readonly seen;
+    push(...forms: readonly string[]): void;
+    list(): readonly string[];
+}

package/dist/esm/core/time/textForms.js

@@ -0,0 +1,126 @@
+/**
+ * core/time/textForms — the spellings of the times written in TEXT (time
+ * design § 9.5, step T7): the text rule of `forms.ts` · `timeFormsOf`, and
+ * the small spelling parts both halves share.
+ *
+ * Pattern: pure regular expressions over the text — no reading, no resolver.
+ * Role:    split from `forms.ts` BY FILE for the synchronous doors: the
+ *          evidence gate's exempt corpus (`evidence/evidenceIndex.ts` ·
+ *          `addExempt`) runs on every agent with a gate, and a bundler places
+ *          a whole file on the synchronous graph — so the window half, which
+ *          re-resolves a recorded reading (`resolve.ts`), stays behind
+ *          `import()` (the optional-family law,
+ *          `test/lib/trace-toolpack/browserGraph.test.ts`). Imports nothing.
+ * Emits:   N/A.
+ *
+ * @example
+ * ```ts
+ * timeFormsOfText('2026-10-09').said; // ['2026', '10', '9']
+ * timeFormsOfText('took 2h');         // { said: [], derived: [] }
+ * ```
+ */
+// ─── The person's text ─────────────────────────────────────────────────────
+/** An ISO calendar date in text — `2026-10-09`, also the date half of `2026-10-09T08:00`. */
+const ISO_DATE = /(?<![\d-])(\d{4})-(\d{2})-(\d{2})(?![\d])/g;
+/**
+ * A 12-hour clock reading in text — `8 Am`, `8:40 AM`, `8pm`, `8:40 p.m.`.
+ * Read off the TEXT, not tokens, because the suffix is its own token.
+ */
+const TWELVE_HOUR = /(?<![\d:.])(\d{1,2})(?::(\d{2}))?\s*([ap])\.?m(?![a-z])/gi;
+/**
+ * The evidence tokenizer's boundary (`evidence/normalize.ts` · `tokenize`),
+ * restated for this leaf so a 24-hour reading is recognised as the same
+ * whole token the gate compares — pinned equal by `test/core/time/forms.test.ts`.
+ */
+const NOT_IN_TOKEN = /[^A-Za-z0-9:_\-/.,%+@#$]+/;
+const LIST_COMMA = /,(?!\d)|(?<!\d),/;
+const LEADING = /^[$#@+'"`([{<]+/;
+const TRAILING = /[.,;:!?%'"`)\]}>]+$/;
+const TWENTY_FOUR_HOUR = /^(\d{1,2}):(\d{2})$/;
+/** The whole tokens of `text` that are a 24-hour clock reading, lower-cased as the gate reads them. */
+function clockTokens(text) {
+    const out = [];
+    for (const rough of text.split(NOT_IN_TOKEN)) {
+        for (const piece of rough.split(LIST_COMMA)) {
+            const token = piece.toLowerCase().trim().replace(LEADING, '').replace(TRAILING, '');
+            if (TWENTY_FOUR_HOUR.test(token))
+                out.push(token);
+        }
+    }
+    return out;
+}
+/**
+ * The spellings of the times written in `text` — `said` only (the text rule of
+ * `forms.ts` · `timeFormsOf`, which delegates here): an ISO date → its year,
+ * month and day; a 12-hour or 24-hour clock reading → its spellings. Slash
+ * dates and durations are never read.
+ *
+ * @example
+ * ```ts
+ * timeFormsOfText('what connected 8 Am to 8:40 AM PST').said;
+ * // ['8:00', '08:00', '8:00am', '8:40', '08:40', '8:40am']
+ * ```
+ */
+export function timeFormsOfText(text) {
+    return { said: textForms(text), derived: [] };
+}
+/** The said spellings of every date and clock time written in `text` (the file header's text rule). */
+function textForms(text) {
+    const out = new Spellings();
+    for (const [, year = '', mm, dd] of text.matchAll(ISO_DATE)) {
+        const month = Number(mm);
+        const day = Number(dd);
+        if (month < 1 || month > 12 || day < 1 || day > 31)
+            continue;
+        out.push(year, String(month), String(day));
+    }
+    for (const [, hh, mm, half = ''] of text.matchAll(TWELVE_HOUR)) {
+        const hour = Number(hh);
+        const minutes = mm ?? '00';
+        if (hour < 1 || hour > 12 || Number(minutes) > 59)
+            continue;
+        const h24 = (hour % 12) + (half.toLowerCase() === 'p' ? 12 : 0);
+        out.push(...clockSpellings(h24, minutes));
+    }
+    // A reading the 12-hour pass already took is not read again as 24-hour:
+    // `8:40 p.m.` is 20:40, never also 08:40.
+    for (const token of clockTokens(text.replace(TWELVE_HOUR, ' '))) {
+        const [, hh = '', minutes = ''] = TWENTY_FOUR_HOUR.exec(token) ?? [];
+        const h24 = Number(hh);
+        if (h24 > 23 || Number(minutes) > 59)
+            continue;
+        out.push(...clockSpellings(h24, minutes));
+    }
+    return out.list();
+}
+/**
+ * The spellings of ONE clock time: the 24-hour form bare and padded
+ * (`8:00`, `08:00`, `20:00`), the 12-hour colon form (`8:00`) and its glued
+ * suffix form (`8:00pm`). After tokenizing, `8:00 PM` and `8:00 AM` both read
+ * `8:00` — the same hour on a 12-hour dial.
+ */
+export function clockSpellings(h24, minutes) {
+    const h12 = h24 % 12 === 0 ? 12 : h24 % 12;
+    const suffix = h24 < 12 ? 'am' : 'pm';
+    return [
+        `${h24}:${minutes}`,
+        `${pad2(h24)}:${minutes}`,
+        `${h12}:${minutes}`,
+        `${h12}:${minutes}${suffix}`,
+    ];
+}
+// ─── Small parts ─────────────────────────────────────────────────────────────
+export const pad2 = (n) => String(n).padStart(2, '0');
+/** An insertion-ordered set of spellings. */
+export class Spellings {
+    seen = new Set();
+    push(...forms) {
+        for (const form of forms)
+            if (form !== '')
+                this.seen.add(form);
+    }
+    list() {
+        return [...this.seen];
+    }
+}
+//# sourceMappingURL=textForms.js.map

package/dist/esm/core/time/textForms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textForms.js","sourceRoot":"","sources":["../../../../src/core/time/textForms.ts"],"names":[],"mappings":"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"}

package/dist/esm/core/time/windows.d.ts

@@ -0,0 +1,113 @@
+/**
+ * core/time/windows — the turn's windows, read from the record (time design
+ * § 5.6): the window the person settled in the time ask (`answered`), a
+ * `model` reader's one reading waiting for confirmation
+ * (`derived-from-reading`) and the clock's `control` window; the quotes still
+ * waiting on the person; and what the served sentence names
+ * (`readerWindowsOf`).
+ *
+ * Pattern: Walker over recorded rows — never over words, never the resolver.
+ * Role:    the record half of `bind.ts`, split out BY FILE for the synchronous
+ *          doors: the Tools mount's `inputMapper` (`agent/buildAgentChart.ts` ·
+ *          `timeWindowsArg`) and the evidence gate's lineage read it before
+ *          any `import()` can run, and a bundler places a whole file on the
+ *          synchronous graph — so this file imports only the leaves and the
+ *          row readers, never `convert.ts` or `resolve.ts` (the optional-family
+ *          law, `test/lib/trace-toolpack/browserGraph.test.ts`). `bind.ts`
+ *          re-exports every public name.
+ * Emits:   N/A (pure).
+ *
+ * @example
+ * ```ts
+ * readerWindowsOf(ledger);
+ * // { now: '2026-10-09T15:40:00Z', windows: [{ source: 'answered', quote: 'yesterday', … }] }
+ * ```
+ */
+import type { DurationText } from './duration.js';
+import type { InstantText } from './instant.js';
+import { type TimeRange } from './range.js';
+import { type ClockRow, type TimeAnswerRow, type TimeReadingRow } from './rows.js';
+import type { ZoneName } from './zone.js';
+/**
+ * Who a window is: the window the person settled in the time ask
+ * (`answered`), a `model` reader's unconfirmed reading (`derived-from-reading`),
+ * or a UI control. `said` — a `rule` reading filed as the person's words — is
+ * no longer filed (the owner's decision "Always confirm", time design TQ29);
+ * it stays in the union so a record an earlier version filed still reads.
+ */
+export type WindowSource = 'said' | 'derived-from-reading' | 'answered' | 'control';
+/** One window of the turn — a mention that resolved to one window, or the `control` window. */
+export interface TurnWindow {
+    readonly source: WindowSource;
+    /** The `time-reading` row's mention index — absent on the `control` window. */
+    readonly mention?: number;
+    /** The person's words it was read from — absent on the `control` window. */
+    readonly quote?: string;
+    readonly range: TimeRange;
+    /** The look-back it was said as, when it was one. */
+    readonly lookback?: DurationText;
+    /** The zone the person meant, else the clock's. */
+    readonly zone: ZoneName;
+    /** On an `answered` window: whether the person picked the offered reading (`confirmed`) or wrote their own (`edited`). */
+    readonly answer?: TimeAnswerRow['how'];
+}
+/** The turn's windows, and how many mentions the turn holds in all (resolved or not). */
+export interface TurnWindows {
+    readonly windows: readonly TurnWindow[];
+    /** Every mention with a quote, plus the `control` window — the "exactly one" count. */
+    readonly mentions: number;
+    /**
+     * Per mention still OPEN (the person has not chosen), the ranges of the
+     * readings left — what a tool's facts can already rule out (§ 6.3: every
+     * reading outside a tool's `direction` → nothing is asked, the call is
+     * refused). Absent when no mention is open with candidates.
+     */
+    readonly open?: readonly (readonly TimeRange[])[];
+}
+/**
+ * This turn's windows, read from the record: per mention, the window the
+ * person settled in the time ask (`answered`, its latest `time-answer` row),
+ * else a `model` reader's one window waiting for confirmation
+ * (`derived-from-reading`); and the clock's `control` window. A `rule`
+ * reading the person has not answered is counted and is OPEN.
+ */
+export declare function turnWindowsOf(readings: readonly TimeReadingRow[], clock: ClockRow | undefined, answers?: readonly TimeAnswerRow[]): TurnWindows;
+/** The windows of the person's words this turn, with the turn's clock — what the served sentence names. */
+export interface ReaderWindows {
+    readonly now: InstantText;
+    /** Each settled mention's window (`answered`, or a `model` reading's), in mention order — never the `control` window. */
+    readonly windows: readonly TurnWindow[];
+    /**
+     * The quote of each mention the library holds only as a PROPOSAL — a `rule`
+     * reading the person has not answered yet (its choice still `open`: a zone
+     * to name, readings to confirm) — in mention order. The served sentence
+     * names them as not confirmed, so a model that would write its own window
+     * leaves the period out and the time ask confirms it (step T6b bench,
+     * `bench/time/`). Absent when none is pending.
+     */
+    readonly pending?: readonly string[];
+    /**
+     * A mention is pending AND a call of this turn already ran on a window the
+     * model wrote into it (a `call-window` row `how: 'model'` — § 7.3: it runs
+     * as sent, unconfirmed). The served line then names that limit for the
+     * answer instead of the move that would have asked the person. Absent
+     * otherwise.
+     */
+    readonly ranUnconfirmed?: true;
+}
+/**
+ * The quotes of this turn's mentions still waiting on the person: a reading
+ * with a quote whose choice is `open`, not answered in the time ask, and not a
+ * `model` reading's one window (that one is served as a reading). Unreadable
+ * and refused mentions offer nothing to confirm and are not named.
+ */
+export declare function pendingQuotesOf(readings: readonly TimeReadingRow[], answers?: readonly TimeAnswerRow[]): readonly string[];
+/**
+ * The latest turn's windows of the person's words, read off the ledger (its
+ * last `clock` row and that turn's `time-reading` and `time-answer` rows) —
+ * `undefined` when the turn has no clock, no settled mention and none
+ * pending. A `rule` reading is named as a window only once the person
+ * answered it in the time ask; before that its quote is `pending`. The
+ * `control` window is not a reading and is not named (TQ13).
+ */
+export declare function readerWindowsOf(ledger: readonly unknown[] | undefined): ReaderWindows | undefined;

package/dist/esm/core/time/windows.js

@@ -0,0 +1,166 @@
+/**
+ * core/time/windows — the turn's windows, read from the record (time design
+ * § 5.6): the window the person settled in the time ask (`answered`), a
+ * `model` reader's one reading waiting for confirmation
+ * (`derived-from-reading`) and the clock's `control` window; the quotes still
+ * waiting on the person; and what the served sentence names
+ * (`readerWindowsOf`).
+ *
+ * Pattern: Walker over recorded rows — never over words, never the resolver.
+ * Role:    the record half of `bind.ts`, split out BY FILE for the synchronous
+ *          doors: the Tools mount's `inputMapper` (`agent/buildAgentChart.ts` ·
+ *          `timeWindowsArg`) and the evidence gate's lineage read it before
+ *          any `import()` can run, and a bundler places a whole file on the
+ *          synchronous graph — so this file imports only the leaves and the
+ *          row readers, never `convert.ts` or `resolve.ts` (the optional-family
+ *          law, `test/lib/trace-toolpack/browserGraph.test.ts`). `bind.ts`
+ *          re-exports every public name.
+ * Emits:   N/A (pure).
+ *
+ * @example
+ * ```ts
+ * readerWindowsOf(ledger);
+ * // { now: '2026-10-09T15:40:00Z', windows: [{ source: 'answered', quote: 'yesterday', … }] }
+ * ```
+ */
+import { sameRange } from './range.js';
+import { answersOf, clockOf, readingsOf, } from './rows.js';
+/**
+ * The one window a `model` reading offers, when it waits only for the
+ * person's confirmation — a reading, filled as `derived-from-reading`. A
+ * `rule` reading settles on nothing: it is a PROPOSAL the time ask offers,
+ * and only the person's answer settles it (the owner's decision "Always
+ * confirm", time design TQ29).
+ */
+function readingCandidate(row) {
+    const choice = row.choice;
+    if (row.reader.kind !== 'model' || choice?.by !== 'open')
+        return undefined;
+    if (choice.open.length !== 1 || choice.open[0] !== 'confirm')
+        return undefined;
+    return row.candidates?.[choice.remaining[0]];
+}
+/**
+ * This turn's windows, read from the record: per mention, the window the
+ * person settled in the time ask (`answered`, its latest `time-answer` row),
+ * else a `model` reader's one window waiting for confirmation
+ * (`derived-from-reading`); and the clock's `control` window. A `rule`
+ * reading the person has not answered is counted and is OPEN.
+ */
+export function turnWindowsOf(readings, clock, answers = []) {
+    const windows = [];
+    const open = [];
+    let mentions = 0;
+    const answered = new Map(answers.map((a) => [a.mention, a]));
+    for (const row of readings) {
+        if (row.mentions === 0 || row.refused !== undefined || row.quote === undefined)
+            continue;
+        mentions++;
+        const answer = row.mention === undefined ? undefined : answered.get(row.mention);
+        if (answer !== undefined) {
+            const range = { from: answer.from, to: answer.to };
+            // The person picked a look-back the library offered: it stays a look-back from now.
+            const offered = row.candidates?.find((c) => c.window.kind === 'lookback' && sameRange(c.range, range))?.window;
+            windows.push({
+                source: 'answered',
+                mention: answer.mention,
+                quote: row.quote,
+                range,
+                ...(offered?.kind === 'lookback' && { lookback: offered.duration }),
+                zone: answer.zone,
+                answer: answer.how,
+            });
+            continue;
+        }
+        const candidate = readingCandidate(row);
+        if (candidate === undefined) {
+            const choice = row.choice;
+            const left = choice?.by === 'open'
+                ? choice.remaining.flatMap((i) => {
+                    const c = row.candidates?.[i];
+                    return c === undefined ? [] : [c.range];
+                })
+                : [];
+            if (left.length > 0)
+                open.push(left);
+            continue;
+        }
+        windows.push({
+            source: 'derived-from-reading',
+            ...(row.mention !== undefined && { mention: row.mention }),
+            quote: row.quote,
+            range: candidate.range,
+            ...(candidate.window.kind === 'lookback' && { lookback: candidate.window.duration }),
+            zone: candidate.zone,
+        });
+    }
+    if (clock?.window !== undefined) {
+        mentions++;
+        windows.push({
+            source: 'control',
+            range: { from: clock.window.from, to: clock.window.to },
+            zone: clock.zone,
+        });
+    }
+    return { windows, mentions, ...(open.length > 0 && { open }) };
+}
+/** Whether a call of `turn` ran on a window the model wrote (`call-window` `how: 'model'`). */
+function ranOnSentWindow(ledger, turn) {
+    return (ledger ?? []).some((row) => {
+        const r = row;
+        return (r !== null &&
+            typeof r === 'object' &&
+            r.kind === 'call-window' &&
+            r.turn === turn &&
+            r.how === 'model');
+    });
+}
+/**
+ * The quotes of this turn's mentions still waiting on the person: a reading
+ * with a quote whose choice is `open`, not answered in the time ask, and not a
+ * `model` reading's one window (that one is served as a reading). Unreadable
+ * and refused mentions offer nothing to confirm and are not named.
+ */
+export function pendingQuotesOf(readings, answers = []) {
+    const answered = new Set(answers.map((a) => a.mention));
+    const quotes = [];
+    for (const row of readings) {
+        if (row.mentions === 0 || row.refused !== undefined || row.quote === undefined)
+            continue;
+        if (row.choice?.by !== 'open')
+            continue;
+        if (row.mention !== undefined && answered.has(row.mention))
+            continue;
+        if (readingCandidate(row) !== undefined)
+            continue;
+        quotes.push(row.quote);
+    }
+    return quotes;
+}
+/**
+ * The latest turn's windows of the person's words, read off the ledger (its
+ * last `clock` row and that turn's `time-reading` and `time-answer` rows) —
+ * `undefined` when the turn has no clock, no settled mention and none
+ * pending. A `rule` reading is named as a window only once the person
+ * answered it in the time ask; before that its quote is `pending`. The
+ * `control` window is not a reading and is not named (TQ13).
+ */
+export function readerWindowsOf(ledger) {
+    const clock = clockOf(ledger);
+    if (clock === undefined)
+        return undefined;
+    const turn = clock.turn;
+    const readings = readingsOf(ledger, turn);
+    const answers = answersOf(ledger, turn);
+    const { windows } = turnWindowsOf(readings, undefined, answers);
+    const pending = pendingQuotesOf(readings, answers);
+    if (windows.length === 0 && pending.length === 0)
+        return undefined;
+    return {
+        now: clock.now,
+        windows,
+        ...(pending.length > 0 && { pending }),
+        ...(pending.length > 0 && ranOnSentWindow(ledger, turn) && { ranUnconfirmed: true }),
+    };
+}
+//# sourceMappingURL=windows.js.map