agentfootprint 9.128.1 → 9.131.0

package/dist/types/core/time/rows.d.ts

@@ -0,0 +1,298 @@
+/**
+ * core/time/rows — the time layer's rows on the one honesty ledger
+ * (`AgentState.findingsLedger`), and the checkpoint door's test for each.
+ *
+ * Pattern: one owner of each row's shape (the `coverage/period.ts` ·
+ *          `periodRowIsWellFormed` precedent): the module that defines a row
+ *          also answers "is this a row I would have filed?", so the
+ *          checkpoint door (`core/runCheckpoint.ts` · `ledgerRowIsWellFormed`)
+ *          refuses exactly what the library never files.
+ * Role:    core/ leaf (the time layer). Imports `instant.ts`, `zone.ts`,
+ *          `range.ts`, `reader.ts` (the parts check), `resolveRecord.ts` (the
+ *          candidate and choice checks), `convert.ts` (the refusal codes) and
+ *          `clock.ts`' and `bind.ts`' types only — the rows are plain records
+ *          the agent loop files (`agent/stages/timeLayer.ts`, the inputs
+ *          layer). Their BUILDERS live in `rowsBuild.ts` — never re-exported
+ *          here: they reach the resolver, which only an armed agent loads,
+ *          while this module is on the checkpoint door's synchronous path.
+ * Emits:   N/A — the rows fire no event of their own (the `conflict` row's
+ *          precedent: no event field ships without a reader in the same
+ *          release). The lens reads the rows.
+ *
+ * Eight kinds, each filed only while `.time()` is armed:
+ *
+ * | Kind | Filed | Carries |
+ * |------|-------|---------|
+ * | `clock` | once per turn, by seed | the turn's {@link TimeClock} and, when the run passed one, the `control` window |
+ * | `clock-on-resume` | first thing in the resumed leg's ToolCalls stage — either pause shape: the pausable resume door, or the stage re-run an `interrupt()` pause makes — when a resume passed a `time` that differs from the kept clock | what was passed and what was kept — the kept clock still rules |
+ * | `call` | once per dispatched call, just before the tool runs | `dispatchedAt`: the wall clock at dispatch (a look-back is evaluated by the TOOL at dispatch, which after a pause is later than `now`); `drift` when a look-back was sent more than the tool's step after `now` — `redrawn` into an absolute form, or `shifted` (§ 7.4, `drift.ts`) |
+ * | `call-window` | by the inputs layer, once per call to a tool that declares period forms, before it dispatches | which window the call carries: filled from the turn's one window (exactly, or wider — with what the read adds), bound to one (by quote or value), the model's own (beside the person's when it differs), unread, not filled and why, or refused before dispatch and why |
+ * | `time-reading` | by seed, once per MENTION the armed reader (`.time({ reader })`) found in the person's message — or ONE row with `mentions: 0` when it found none, so a retry knows the message was read | the quote, the parts, every candidate `resolve.ts` made of them, how the reading settled (`choice` — never settled by the library: every reading is a PROPOSAL, `open` with `confirm`, its candidates `said: []`), the reader's id, version, kind and locale, and the tz database version; a refused mention keeps only why |
+ * | `time-answer` | by the batch ask, once per mention the person settled in the time ask — the only door by which a window of words becomes the person's | the mention, the window and its zone, and `how`: `confirmed` (they picked a reading the library offered — the click) or `edited` (they wrote their own) |
+ * | `time-derived` | by the Route decider, once per judged answer that stands, when the evidence gate found values no tool result carried that the library itself spelled from this turn's time readings (§ 9.5, step T7 — `forms.ts` · `timeFormsOf`'s `derived` list) | the values, normalized and clipped as the gate reports them — the lineage `derived-from-reading`: never invented, never the person's |
+ * | `source-clock` | by ToolCalls, once per call and zone, when the call minted a dataset whose declared time axis names a `zone` (§ 9.6, step T8) | the tool, the call and the zone its rows' wall times are in — read by the limits block's `Clocks` lines and `check.ts` · `clocksDiffer` |
+ *
+ * Readers that switch over every row kind must skip one they do not know.
+ */
+import { type InstantText } from './instant.js';
+import { type TimeRange } from './range.js';
+import { type ZoneName } from './zone.js';
+import type { ClockChange, TimeClock } from './clock.js';
+import { type MentionRefusal, type TimeParts } from './reader.js';
+import type { CallWindow, WindowSource } from './bind.js';
+import { type TimeRefusal } from './periodForm.js';
+import { type ReadingChoice, type TimeCandidate } from './resolveRecord.js';
+/** A window set in a UI, as the clock row records it. */
+export interface ControlWindow extends TimeRange {
+    readonly source: 'control';
+}
+/** The turn's clock stamp — one per turn (time design § 4). */
+export interface ClockRow extends TimeClock {
+    readonly kind: 'clock';
+    /** `AgentState.turnNumber` when the row was filed — the conversation turn. */
+    readonly turn: number;
+    /** The iteration seed filed it at (1). */
+    readonly iteration: number;
+    /** The run's `time.window`, when it passed one. */
+    readonly window?: ControlWindow;
+}
+/** A resume passed a `time` that differs from the frozen clock: recorded, not applied (TQ21). */
+export interface ClockOnResumeRow {
+    readonly kind: 'clock-on-resume';
+    readonly turn: number;
+    /** The iteration the paused batch ran in. */
+    readonly iteration: number;
+    /** What the resume passed, as read (values as written, a `Date` spelled in UTC). */
+    readonly passed: ClockChange['passed'];
+    /** The frozen clock's values the passed ones would have replaced. */
+    readonly kept: ClockChange['kept'];
+}
+/** One dispatched call's wall-clock moment (time design § 4, § 7.4). */
+export interface CallRow {
+    readonly kind: 'call';
+    readonly turn: number;
+    readonly iteration: number;
+    readonly toolCallId: string;
+    readonly toolName: string;
+    /** The wall clock when the library handed the call to the tool — UTC, millisecond precision. */
+    readonly dispatchedAt: InstantText;
+    /**
+     * The clock at dispatch (§ 7.4, step T5b) — present only when the call sent
+     * a LOOK-BACK and `dispatchedAt − now` (`byMs`, signed) is more than the
+     * tool's step. `redrawn`: the library's own look-back fill was re-sent as
+     * the asked range in absolute form `form`; `shifted`: the look-back ran as
+     * sent (the model's value, or no absolute form), so the tool read a window
+     * shifted by `byMs` — `period-shifted`.
+     */
+    readonly drift?: CallDrift;
+}
+/** A look-back call's dispatch drift (§ 7.4) — see {@link CallRow.drift}. */
+export type CallDrift = {
+    readonly byMs: number;
+    readonly outcome: 'redrawn';
+    readonly form: number;
+} | {
+    readonly byMs: number;
+    readonly outcome: 'shifted';
+};
+/** The reader a reading came from, as recorded. */
+export interface TimeReaderStamp {
+    readonly id: string;
+    readonly version: string;
+    readonly kind: 'rule' | 'model';
+    readonly locale: string;
+}
+/**
+ * One mention the armed reader found in the person's message (time design
+ * § 5.2) — or, with `mentions: 0` and no mention fields, the record that the
+ * message was read and held none. Read back, never re-read: a resume and a
+ * retry of the same turn find these rows and do not call the reader.
+ */
+export interface TimeReadingRow {
+    readonly kind: 'time-reading';
+    readonly turn: number;
+    readonly iteration: number;
+    readonly reader: TimeReaderStamp;
+    /** The tz database the candidates were resolved with (`process.versions.tz`), else `'unknown'`. */
+    readonly tzdata: string;
+    /** How many mentions the reading held. */
+    readonly mentions: number;
+    /** This row's mention, 0-based — absent on the `mentions: 0` row. */
+    readonly mention?: number;
+    /** A verbatim substring of the person's message. */
+    readonly quote?: string;
+    readonly parses?: readonly TimeParts[];
+    readonly problem?: 'unreadable';
+    /** Why the mention was refused — its quote was not in the message, or its parts were malformed. It keeps no text. */
+    readonly refused?: MentionRefusal;
+    /** Every window `resolve.ts` made of the parts. */
+    readonly candidates?: readonly TimeCandidate[];
+    /** How the reading settled under the policy — `open` waits for the person. */
+    readonly choice?: ReadingChoice;
+}
+/**
+ * The window the person settled for one mention in the time ask — the ONLY
+ * door by which a window of words becomes the person's (the owner's decision
+ * "Always confirm", time design TQ29). Filed by the batch ask when a window
+ * answer binds (`arguments/ask.ts` · `bindAnswer`); read back by
+ * `bind.ts` · `turnWindowsOf`, so the rest of the turn uses it as an
+ * `answered` window and the served sentence names it with its source.
+ */
+export interface TimeAnswerRow extends TimeRange {
+    readonly kind: 'time-answer';
+    readonly turn: number;
+    readonly iteration: number;
+    /** The `time-reading` row's mention the answer settles. */
+    readonly mention: number;
+    /** The zone the window was answered in — the reading's, or the turn's clock for free entry. */
+    readonly zone: ZoneName;
+    /**
+     * `confirmed`: the person picked a reading the library offered (the
+     * pre-filled choice — their click); `edited`: they wrote a window of their
+     * own. Both are the person's answer.
+     */
+    readonly how: 'confirmed' | 'edited';
+}
+/** The person's window a `call-window` row names — its range, who gave it, and its mention. */
+export interface PersonWindow extends TimeRange {
+    readonly source: WindowSource;
+    /** The `time-reading` row's mention index — absent on a `control` window. */
+    readonly mention?: number;
+}
+/**
+ * Which window one call to a tool that declares period forms carries (time
+ * design § 7.3) — one row per such call, filed by the inputs layer beside the
+ * call's `argument` rows, before the call dispatches.
+ *
+ * | `how` | Means |
+ * |-------|-------|
+ * | `filled` | the model left the period out; the turn's one window (`person`) went into form `form` exactly (`rounded`: an epoch-seconds bound or a look-back's length moved outward) |
+ * | `bound` | the sent window IS the person's window `person` — named by the model's quote (`by: 'quote'`) or equal in value (`by: 'value'`) |
+ * | `model-chosen` | the sent window (`asked`) differs from the person's (`person`, when one window is theirs): it ran as sent (the v1 law) |
+ * | `model` | the sent window, and no window of the person's this turn |
+ * | `unread` | a period argument was sent and no form reads the call back as a range |
+ * | `not-filled` | the period was left out and nothing was filled (`why`) — the tool's own rule applied |
+ * | `refused` | refused before dispatch (`refused`: a fact the window breaks, `multi-day`, `dst-gap` with its `argument`) — the call did not run |
+ *
+ * `asked` is the half-open range the call asks for: the person's on a fill,
+ * the sent value read back otherwise — what `ctx.time.asked` hands the tool.
+ * A WIDENED fill (no form holds the window exactly — § 7.2) carries `sent`,
+ * the range the tool reads, and either `differs.extra` (the parts read but
+ * not asked — `period-differs-from-asked`) or `trimmedByTool` (the tool
+ * declares `filtersToAsked`). `partlyBeyondRetention` marks a window that
+ * starts before the source's oldest data and ends after it: it dispatched.
+ */
+export interface CallWindowRow {
+    readonly kind: 'call-window';
+    readonly turn: number;
+    readonly iteration: number;
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly how: CallWindow['how'];
+    /** The index of the tool's form the call used (filled into, or read back from). */
+    readonly form?: number;
+    readonly asked?: TimeRange;
+    readonly person?: PersonWindow;
+    readonly by?: 'quote' | 'value';
+    readonly rounded?: true;
+    readonly why?: 'no-window' | 'several-mentions' | 'open-reading' | 'no-exact-form';
+    /** A widened fill: the range the tool reads with the sent values. */
+    readonly sent?: TimeRange;
+    /** A widened fill the tool does not trim: the parts read but not asked. */
+    readonly differs?: {
+        readonly extra: readonly TimeRange[];
+    };
+    /** A widened fill to a tool that declares `filtersToAsked`. */
+    readonly trimmedByTool?: true;
+    readonly partlyBeyondRetention?: true;
+    /** Why the call was refused before dispatch. */
+    readonly refused?: TimeRefusal;
+    /** On a `dst-gap` refusal: the argument whose wall time the zone skips. */
+    readonly argument?: string;
+}
+/**
+ * The answer's values the library itself spelled from a time reading of this
+ * turn (§ 9.5, step T7) — an implied year, an offset, the end-of-grain
+ * minute, a value of the served time line. The lineage `derived-from-reading`:
+ * the answer's standing reads it as "not sure" at most, never "known", and the
+ * gate never calls these invented.
+ */
+export interface TimeDerivedRow {
+    readonly kind: 'time-derived';
+    readonly turn: number;
+    readonly iteration: number;
+    /** The values as the gate reports them — normalized, clipped, at most `MAX_DERIVED_VALUES`. */
+    readonly values: readonly string[];
+}
+/** The most values one `time-derived` row carries (the gate's report bound). */
+export declare const MAX_DERIVED_VALUES = 12;
+/** The longest value a `time-derived` row carries (the gate's clip). */
+export declare const MAX_DERIVED_VALUE_CHARS = 64;
+/**
+ * A wall-clock source (§ 9.6, step T8): the call minted a dataset whose
+ * declared time axis (`axis.ts` · `DatasetTimeAxis`, its `zone`) says its rows are
+ * wall times in `zone`. One row per call and zone. A period's offset is never
+ * read as a clock — only a declared axis zone files this row.
+ */
+export interface SourceClockRow {
+    readonly kind: 'source-clock';
+    readonly turn: number;
+    readonly iteration: number;
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly zone: ZoneName;
+}
+/** Every time-layer row kind. */
+export type TimeRow = ClockRow | ClockOnResumeRow | CallRow | TimeReadingRow | CallWindowRow | TimeAnswerRow | TimeDerivedRow | SourceClockRow;
+/** This turn's `call-window` row for one call, if the inputs layer filed one — `ctx.time` reads it. */
+export declare function callWindowOfCall(ledger: readonly unknown[] | undefined, toolCallId: string, turn: number): CallWindowRow | undefined;
+/** The `time-reading` rows filed for `turn` — read back on a resume or a retry, never re-read. */
+export declare function readingsOf(ledger: readonly unknown[] | undefined, turn: number): readonly TimeReadingRow[];
+/** The `time-answer` row for one window the person settled in the time ask. */
+export declare function timeAnswerRow(answer: {
+    readonly mention: number;
+    readonly range: TimeRange;
+    readonly zone: ZoneName;
+    readonly how: 'confirmed' | 'edited';
+}, at: {
+    readonly turn: number;
+    readonly iteration: number;
+}): TimeAnswerRow;
+/** The `time-derived` row for one judged answer — `values` cut to {@link MAX_DERIVED_VALUES}. */
+export declare function timeDerivedRow(values: readonly string[], at: {
+    readonly turn: number;
+    readonly iteration: number;
+}): TimeDerivedRow;
+/** The `source-clock` row for one call's dataset whose declared axis names `zone`. */
+export declare function sourceClockRow(call: {
+    readonly toolCallId: string;
+    readonly toolName: string;
+}, at: {
+    readonly turn: number;
+    readonly iteration: number;
+}, zone: ZoneName): SourceClockRow;
+/** This turn's `call` row for one call — the last filed (a resumed leg files its own). */
+export declare function callRowOfCall(ledger: readonly unknown[] | undefined, toolCallId: string, turn: number): CallRow | undefined;
+/** The `source-clock` rows filed for `turn`, in the order filed. */
+export declare function sourceClocksOf(ledger: readonly unknown[] | undefined, turn: number | undefined): readonly SourceClockRow[];
+/** The `time-answer` rows filed for `turn`, in the order filed. */
+export declare function answersOf(ledger: readonly unknown[] | undefined, turn: number): readonly TimeAnswerRow[];
+/**
+ * The clock of the LATEST turn on the ledger — the last `clock` row — or
+ * `undefined` when none was filed (an agent without `.time()`, or a turn
+ * paused by a runtime that had none). A continued conversation carries one
+ * row per turn; the last one is this turn's, because each turn's seed files
+ * exactly one (last in seed, before any stage of the turn can read it).
+ */
+export declare function clockOf(ledger: readonly unknown[] | undefined): ClockRow | undefined;
+/**
+ * The checkpoint door's test for a time-layer row — `true` only for a row of
+ * one of the eight kinds with every field this module files, well formed.
+ * Any other kind answers `false` (the caller routes by kind first).
+ */
+export declare function timeRowIsWellFormed(row: Readonly<Record<string, unknown>>): boolean;
+/** Whether a ledger row is one of the time layer's kinds (the router's question). */
+export declare function isTimeRowKind(kind: unknown): kind is TimeRow['kind'];
+/** The zone the answer's lines are rendered in — the clock's (no reader is armed yet, so the run's). */
+export declare function presentationZoneOf(ledger: readonly unknown[] | undefined): ZoneName | undefined;
+//# sourceMappingURL=rows.d.ts.map

package/dist/types/core/time/rows.d.ts.map

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

package/dist/types/core/time/rowsBuild.d.ts

@@ -0,0 +1,83 @@
+/**
+ * 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 type { TimeRange } from './range.js';
+import { type ReadRunTime, type TimeClock } from './clock.js';
+import type { CheckedMention } from './reader.js';
+import type { CallWindow } from './bind.js';
+import { type TimePolicy } from './resolve.js';
+import type { CallDrift, CallRow, CallWindowRow, ClockOnResumeRow, ClockRow, TimeReaderStamp, TimeReadingRow } from './rows.js';
+/** The clock stamp for one turn. */
+export declare function clockRow(clock: TimeClock, at: {
+    readonly turn: number;
+    readonly iteration: number;
+}, window?: TimeRange): ClockRow;
+/**
+ * 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 declare function callRow(call: {
+    readonly toolCallId: string;
+    readonly toolName: string;
+}, at: {
+    readonly turn: number;
+    readonly iteration: number;
+}, nowMs: number, drift?: CallDrift): CallRow;
+/**
+ * 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 declare function clockOnResumeRow(passed: ReadRunTime, kept: ClockRow, at: {
+    readonly turn: number;
+    readonly iteration: number;
+}): ClockOnResumeRow | undefined;
+/**
+ * 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 declare function timeReadingRows(input: {
+    readonly mentions: readonly CheckedMention[];
+    readonly clock: TimeClock;
+    readonly policy: TimePolicy;
+    readonly reader: TimeReaderStamp;
+    readonly tzdata: string;
+    readonly at: {
+        readonly turn: number;
+        readonly iteration: number;
+    };
+}): TimeReadingRow[];
+/** The `call-window` row for one call's decision (`bind.ts` · `callWindowOf`). */
+export declare function callWindowRow(call: {
+    readonly toolCallId: string;
+    readonly toolName: string;
+}, decision: CallWindow, at: {
+    readonly turn: number;
+    readonly iteration: number;
+}): CallWindowRow;
+//# sourceMappingURL=rowsBuild.d.ts.map

package/dist/types/core/time/rowsBuild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowsBuild.d.ts","sourceRoot":"","sources":["../../../../src/core/time/rowsBuild.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAe,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,WAAW,CAAC;AACxD,OAAO,EAAiC,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EACV,SAAS,EACT,OAAO,EACP,aAAa,EACb,gBAAgB,EAChB,QAAQ,EAER,eAAe,EACf,cAAc,EACf,MAAM,WAAW,CAAC;AAInB,oCAAoC;AACpC,wBAAgB,QAAQ,CACtB,KAAK,EAAE,SAAS,EAChB,EAAE,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EACzD,MAAM,CAAC,EAAE,SAAS,GACjB,QAAQ,CAaV;AAED;;;GAGG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE;IAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAChE,EAAE,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EACzD,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,SAAS,GAChB,OAAO,CAUT;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,QAAQ,EACd,EAAE,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACxD,gBAAgB,GAAG,SAAS,CAc9B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE;IACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CACpE,GAAG,cAAc,EAAE,CAwBnB;AASD,kFAAkF;AAClF,wBAAgB,aAAa,CAC3B,IAAI,EAAE;IAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAChE,QAAQ,EAAE,UAAU,EACpB,EAAE,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACxD,aAAa,CAgEf"}

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

@@ -0,0 +1,54 @@
+/**
+ * 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[];
+}
+//# sourceMappingURL=textForms.d.ts.map

package/dist/types/core/time/textForms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textForms.d.ts","sourceRoot":"","sources":["../../../../src/core/time/textForms.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,6EAA6E;AAC7E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAoCD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAEvD;AA6BD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAS9E;AAID,eAAO,MAAM,IAAI,MAAO,MAAM,KAAG,MAAoC,CAAC;AAEtE,6CAA6C;AAC7C,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;IAC1C,IAAI,CAAC,GAAG,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAGvC,IAAI,IAAI,SAAS,MAAM,EAAE;CAG1B"}

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

@@ -0,0 +1,114 @@
+/**
+ * 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;
+//# sourceMappingURL=windows.d.ts.map

package/dist/types/core/time/windows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"windows.d.ts","sourceRoot":"","sources":["../../../../src/core/time/windows.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvD,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAI1C;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,sBAAsB,GAAG,UAAU,GAAG,SAAS,CAAC;AAEpF,+FAA+F;AAC/F,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,qDAAqD;IACrD,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACjC,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,0HAA0H;IAC1H,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;CACxC;AAED,yFAAyF;AACzF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,uFAAuF;IACvF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,SAAS,SAAS,EAAE,CAAC,EAAE,CAAC;CACnD;AAgBD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,KAAK,EAAE,QAAQ,GAAG,SAAS,EAC3B,OAAO,GAAE,SAAS,aAAa,EAAO,GACrC,WAAW,CAyDb;AAED,2GAA2G;AAC3G,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAC1B,yHAAyH;IACzH,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,IAAI,CAAC;CAChC;AAgBD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,OAAO,GAAE,SAAS,aAAa,EAAO,GACrC,SAAS,MAAM,EAAE,CAWnB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAejG"}

package/dist/types/core/time/wire.d.ts

@@ -0,0 +1,64 @@
+/**
+ * core/time/wire — the time layer's JSON that crosses a transport (time
+ * design § 7.5): `ctx.time`, the window a call asks for, handed to the tool.
+ *
+ * Pattern: one versioned shape, the same object in process and on the wire.
+ *          In process it is `ToolExecutionContext.time`; over MCP it travels
+ *          in the `tools/call` request's `_meta.agentfootprint.time`
+ *          (`lib/mcp/mcpClient.ts` sends it, `lib/mcp/mcpServe.ts` hands it
+ *          to the served tool); a transport with no metadata slot sends
+ *          nothing, and the tool declares its period from its own arguments.
+ *          A tool's `period` declaration itself travels in the listing's
+ *          `_meta.agentfootprint.period`, judged by `arguments/declare.ts`.
+ * Role:    core/ leaf (the time layer). Imports `instant.ts`, `range.ts` and
+ *          `zone.ts` only.
+ * Emits:   N/A.
+ *
+ * @example
+ * ```ts
+ * timeContextOf({ asked: { from: '2026-10-09T08:00:00-07:00', to: '2026-10-09T08:41:00-07:00' } },
+ *   { now: '2026-10-09T15:40:00Z', zone: 'America/Los_Angeles' }, '2026-10-09T15:40:02.114Z');
+ * // { version: 1, asked: { from: …, to: …, edge: 'exclusive' }, zone: 'America/Los_Angeles',
+ * //   now: '2026-10-09T15:40:00Z', dispatchedAt: '2026-10-09T15:40:02.114Z' }
+ * ```
+ */
+import { type InstantText } from './instant.js';
+import { type TimeRange } from './range.js';
+import { type ZoneName } from './zone.js';
+/** The shape's version — a reader refuses one it does not know. */
+export declare const TIME_CONTEXT_VERSION = 1;
+/** The `_meta.agentfootprint` key the call's time travels under over MCP. */
+export declare const TIME_CONTEXT_META_KEY = "time";
+/**
+ * What a tool that declares a period is handed about the call's time
+ * (`ctx.time`). `asked` is the half-open range the call asks for — the
+ * person's window when the library filled or bound it, the sent value read
+ * back otherwise — so a tool can declare the `period.queried` its read covered
+ * without parsing its own argument. Absent when no form read the call back.
+ */
+export interface TimeContext {
+    readonly version: typeof TIME_CONTEXT_VERSION;
+    readonly asked?: TimeRange & {
+        readonly edge: 'exclusive';
+    };
+    /** The person's zone for this run (the clock's). */
+    readonly zone: ZoneName;
+    /** The turn's frozen clock (§ 4). */
+    readonly now: InstantText;
+    /** The wall clock when the library handed the call to the tool — the `call` row's. */
+    readonly dispatchedAt: InstantText;
+}
+/** The context for one call, from its `call-window` row's `asked`, the turn's clock and the dispatch moment. */
+export declare function timeContextOf(window: {
+    readonly asked?: TimeRange;
+} | undefined, clock: {
+    readonly now: InstantText;
+    readonly zone: ZoneName;
+}, dispatchedAt: InstantText): TimeContext;
+/**
+ * A received context read — the version this runtime knows, every field well
+ * formed — or `undefined`. What a served tool is handed from the wire; never
+ * repaired.
+ */
+export declare function readTimeContext(value: unknown): TimeContext | undefined;
+//# sourceMappingURL=wire.d.ts.map

package/dist/types/core/time/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../../../../src/core/time/wire.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAc,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAEtD,mEAAmE;AACnE,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,6EAA6E;AAC7E,eAAO,MAAM,qBAAqB,SAAS,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,oBAAoB,CAAC;IAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG;QAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;KAAE,CAAC;IAC5D,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,qCAAqC;IACrC,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAC1B,sFAAsF;IACtF,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC;CACpC;AAED,gHAAgH;AAChH,wBAAgB,aAAa,CAC3B,MAAM,EAAE;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG,SAAS,EAClD,KAAK,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,EAC7D,YAAY,EAAE,WAAW,GACxB,WAAW,CAWb;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,SAAS,CA4BvE"}