agentfootprint-lens 0.68.0 → 0.69.0

package/README.md

@@ -951,7 +951,8 @@ if (recording.snapshot) {
 }
 ```
 
-(Under footprintjs 9.17 — still the peer floor — the same call needs
+(Under footprintjs 9.17 — the floor when this narrowing landed, now below
+the peer floor of `^9.26.0` — the same call needs
 `recording.snapshot as unknown as TimeTravelSource`, and a bad row throws
 inside the fold; a types-only difference the lens's `foldFactsAt` reports as
 `foldError`.) **Movement never needs a snapshot at all**: `openLensCursor`
@@ -1083,6 +1084,58 @@ summary card, the transport and the commentary under a native **More detail**
 Needs agentfootprint ≥ 9.116.0 (the release that ships `AnswerAccount` and the
 op) — the lens's peer floor since 0.68.0.
 
+## Time — what the run took "now" to be, and which window each call read
+
+**Every time decision an armed agent makes, as the record holds it.** With
+agentfootprint's time layer armed (`.time()`, 9.129.0), the run files rows on
+its honesty ledger: the clock it froze for the turn, what it read from the
+person's words, which window each call carries and how, whether a call reads
+MORE than was asked, and how far the wall clock had moved by the time the
+tool ran. `<TimeBand>` draws them; `<ContextView>` mounts it under the
+Findings band, so it moves with the one cursor.
+
+### Why
+
+A time bug is quiet. "Yesterday" sent to a tool that only takes a look-back
+reads from yesterday's midnight to NOW — a day and a half, not a day — and
+the answer looks fine. After a 30-minute pause, a "last hour" look-back reads
+a different hour than the person asked about. The library records each of
+these; this band is where a person sees them: a widened fill says **wider
+than asked** with the extra ranges, a drift says `redrawn` or `shifted` and by
+how much, a result whose held range is unknown says **clock unknown**.
+
+### Mount it
+
+```tsx
+import { ContextView, TimeBand } from 'agentfootprint-lens/context';
+
+<ContextView runner={recording} />            // the band appears once the ledger holds a time row
+
+// or on its own, over rows you already hold:
+<TimeBand rows={state.findingsLedger} coverage={state.coverageDeclared} />
+```
+
+A paused ask with a time field (`requestInput` with `format`) shows its time
+half inside `<AwaitingPane>` — the choices with the library's labels and, on
+a re-ask, the refused value with the library's reason. A `dataset/rows`
+artifact that declares a time axis shows it above the table
+(`<TimeAxisLine meta rows>`), judged by the library: column, unit, zone,
+grain, and how many values have no known clock.
+
+### The laws it keeps
+
+- **Omit, never deny.** No time row at the stop, no band — an unarmed run has
+  no band, never an empty one. A row prints no field it does not carry.
+- **Never infer.** Nothing here compares two instants. `wider than asked`
+  renders only on a row that carries `differs`; a drift only on a call row
+  that carries `drift`; `clock unknown` only where the record says `unknown`.
+- **No sentence of its own.** Every printed string is a value off the record
+  or a `TIME_LABELS` entry; the one sentence it shows — an ask's refusal
+  reason — is the library's, printed as data.
+
+Headless: `foldTimeRows(ledger, coverage?)`, `timeAskOf(pause)`,
+`datasetTimeAxisOf(meta, rows?)`.
+
 ## The Served tab
 
 **At every LLM call, exactly what the model was served — provable from the log.**

package/dist/chunk-5S5JD7BV.js

@@ -0,0 +1,361 @@
+import {
+  servedRowAt,
+  servedRowForEpoch,
+  sincePrevious,
+  verify
+} from "./chunk-XEAZRBOH.js";
+
+// src/core/context/contextAt.ts
+import * as trace from "footprintjs/trace";
+import { stateAt } from "footprintjs/trace";
+function firstSegment(path) {
+  const helper = trace.pathSegments;
+  if (typeof helper === "function") return helper(path)[0];
+  const unit = path.indexOf("");
+  if (unit >= 0) return path.slice(0, unit);
+  const dot = path.indexOf(".");
+  return dot >= 0 ? path.slice(0, dot) : path;
+}
+function logOf(snapshot) {
+  const s = snapshot;
+  return Array.isArray(s?.commitLog) ? s.commitLog : [];
+}
+function writersUpTo(log, commitIdx) {
+  const out = /* @__PURE__ */ new Map();
+  const last = Math.min(commitIdx, log.length - 1);
+  for (let i = 0; i <= last; i++) {
+    const bundle = log[i];
+    if (bundle === void 0 || typeof bundle.runtimeStageId !== "string" || !Array.isArray(bundle.trace))
+      continue;
+    for (const row of bundle.trace) {
+      const key = firstSegment(row.path);
+      if (key === void 0) continue;
+      const prior = out.get(key);
+      out.set(key, {
+        wroteBy: bundle.runtimeStageId,
+        wroteAt: i,
+        enteredAt: prior?.enteredAt ?? i,
+        verb: row.verb
+      });
+    }
+  }
+  return out;
+}
+function foldAt(snapshot, commitIdx) {
+  const source = typeof snapshot === "object" && snapshot !== null ? snapshot : void 0;
+  try {
+    return stateAt(source, commitIdx);
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : String(e) };
+  }
+}
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function servedFor(snapshot, cursor) {
+  try {
+    const row = servedRowAt(snapshot, cursor);
+    if (row === void 0) return {};
+    const checks = verify(row.view, row.receipt, row.receipt?.basis.runId ?? "", row.receiptCause);
+    const previous = row.previousEpoch !== void 0 ? servedRowForEpoch(snapshot, row.previousEpoch) : void 0;
+    const since = previous !== void 0 ? sincePrevious(row, previous) : void 0;
+    return {
+      served: Object.freeze({
+        row,
+        checks,
+        ...since !== void 0 ? { since } : {}
+      })
+    };
+  } catch (e) {
+    return { servedError: e instanceof Error ? e.message : String(e) };
+  }
+}
+function whyFor(events, stages) {
+  if (events === void 0 || stages.size === 0) return Object.freeze([]);
+  const out = [];
+  for (const entry of events) {
+    const id = entry.runtimeStageId;
+    if (id === void 0 || !stages.has(id)) continue;
+    out.push({ seq: entry.seq, name: entry.event.type, runtimeStageId: id });
+  }
+  return Object.freeze(out);
+}
+function contextAt(recording, cursor, options = {}) {
+  const log = logOf(recording);
+  const folded = foldAt(recording, cursor.commitIdx);
+  if ("error" in folded) {
+    return Object.freeze({
+      cursor,
+      keys: Object.freeze([]),
+      left: Object.freeze([]),
+      rows: Object.freeze([]),
+      redacted: false,
+      foldError: folded.error,
+      why: Object.freeze([])
+    });
+  }
+  const writers = writersUpTo(log, cursor.commitIdx);
+  const previous = options.previous !== void 0 ? foldAt(recording, options.previous.commitIdx) : void 0;
+  const previousState = previous !== void 0 && !("error" in previous) ? previous.state : void 0;
+  const keys = [];
+  for (const [path, value] of Object.entries(folded.state)) {
+    const w = writers.get(path);
+    const since = previousState === void 0 ? void 0 : !(path in previousState) ? "entered" : same(previousState[path], value) ? "unchanged" : "changed";
+    keys.push(
+      Object.freeze({
+        path,
+        value,
+        ...w !== void 0 ? {
+          wroteBy: w.wroteBy,
+          wroteAt: w.wroteAt,
+          enteredAt: w.enteredAt,
+          verb: w.verb
+        } : {},
+        ...since !== void 0 ? { since } : {}
+      })
+    );
+  }
+  const left = previousState === void 0 ? [] : Object.keys(previousState).filter((k) => !(k in folded.state));
+  const bundle = log[cursor.commitIdx];
+  const rows = Array.isArray(bundle?.trace) ? bundle.trace.map((r) => Object.freeze({ path: r.path, verb: r.verb })) : [];
+  const stages = /* @__PURE__ */ new Set();
+  if (bundle !== void 0 && typeof bundle.runtimeStageId === "string") stages.add(bundle.runtimeStageId);
+  for (const k of keys)
+    if (k.since !== void 0 && k.since !== "unchanged" && k.wroteBy !== void 0) stages.add(k.wroteBy);
+  const skipped = folded.skipped !== void 0 && folded.skipped.length > 0 ? folded.skipped.map((g) => g.index) : void 0;
+  const { served, servedError } = servedFor(recording, cursor);
+  return Object.freeze({
+    cursor,
+    keys: Object.freeze(keys),
+    left: Object.freeze(left),
+    rows: Object.freeze(rows),
+    basis: folded.basis,
+    redacted: folded.redacted,
+    ...skipped !== void 0 ? { skipped: Object.freeze(skipped) } : {},
+    ...served !== void 0 ? { served } : {},
+    ...servedError !== void 0 ? { servedError } : {},
+    why: whyFor(options.events, stages)
+  });
+}
+
+// src/core/time/labels.ts
+var LABELS = Object.freeze({
+  band: "time",
+  rows: "rows",
+  turn: "turn",
+  clock: "clock",
+  now: "now",
+  zone: "zone",
+  source: "source",
+  window: "window",
+  clockOnResume: "clock on resume",
+  passed: "passed",
+  kept: "kept",
+  readings: "readings",
+  reader: "reader",
+  tzdata: "tz database",
+  noMentions: "no mentions",
+  quote: "quote",
+  candidates: "candidates",
+  choice: "choice",
+  remaining: "remaining",
+  open: "open",
+  policy: "policy",
+  refused: "refused",
+  problem: "problem",
+  said: "said",
+  implied: "implied",
+  notes: "notes",
+  grain: "grain",
+  calls: "calls",
+  how: "how",
+  form: "form",
+  asked: "asked",
+  person: "person",
+  mention: "mention",
+  by: "by",
+  rounded: "rounded",
+  why: "why",
+  sent: "sent",
+  widened: "wider than asked",
+  extra: "extra",
+  trimmedByTool: "trimmed by tool",
+  partlyBeyondRetention: "partly beyond retention",
+  argument: "argument",
+  dispatchedAt: "dispatched at",
+  drift: "drift at dispatch",
+  period: "period",
+  verdict: "verdict",
+  queried: "queried",
+  held: "held",
+  readAt: "read at",
+  clockUnknown: "clock unknown",
+  ask: "time ask",
+  request: "request",
+  repeat: "asked again",
+  answer: "answer",
+  reason: "reason",
+  field: "field",
+  format: "format",
+  choices: "choices",
+  strict: "strict",
+  missing: "missing",
+  axis: "time axis",
+  column: "column",
+  unit: "unit",
+  interval: "interval",
+  aggregate: "aggregate",
+  summary: "summary",
+  malformed: "malformed",
+  unjudged: "not checked",
+  values: "values",
+  placed: "placed",
+  dstGap: "dst gap",
+  unreadable: "unreadable"
+});
+
+// src/core/time/timeRows.ts
+var isRec = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var isStr = (v) => typeof v === "string" && v.length > 0;
+var isCount = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
+function isRangeShape(v) {
+  return isRec(v) && isStr(v.from) && isStr(v.to);
+}
+var hasTurn = (r) => isCount(r.turn) && isCount(r.iteration);
+function clockOf(r) {
+  return isStr(r.now) && isStr(r.zone) && isStr(r.nowSource) && isStr(r.zoneSource) ? r : void 0;
+}
+function resumeOf(r) {
+  return isRec(r.passed) && isRec(r.kept) ? r : void 0;
+}
+function readingOf(r) {
+  const reader = r.reader;
+  if (!isRec(reader) || !isStr(reader.id) || !isStr(reader.version) || !isCount(r.mentions)) {
+    return void 0;
+  }
+  if (r.candidates !== void 0 && !Array.isArray(r.candidates)) return void 0;
+  return r;
+}
+var callIdentity = (r) => isStr(r.toolCallId) && typeof r.toolName === "string";
+function windowOf(r) {
+  return callIdentity(r) && isStr(r.how) ? r : void 0;
+}
+function dispatchOf(r) {
+  return callIdentity(r) && isStr(r.dispatchedAt) ? r : void 0;
+}
+function periodOf(r) {
+  return callIdentity(r) && isStr(r.verdict) ? r : void 0;
+}
+function declaredPeriods(coverage) {
+  const out = /* @__PURE__ */ new Map();
+  for (const row of coverage ?? []) {
+    if (!isRec(row) || !isStr(row.toolCallId) || !isRec(row.period)) continue;
+    const p = row.period;
+    if (!isRangeShape(p.queried) || !(p.held === "unknown" || isRangeShape(p.held))) continue;
+    out.set(row.toolCallId, p);
+  }
+  return out;
+}
+function foldTimeRows(ledger, coverage) {
+  if (!Array.isArray(ledger)) return void 0;
+  const turns = /* @__PURE__ */ new Map();
+  const declared = declaredPeriods(coverage);
+  let rows = 0;
+  const turnOf = (n) => {
+    let t = turns.get(n);
+    if (t === void 0) {
+      t = { turn: n, resumes: [], readings: [], calls: /* @__PURE__ */ new Map() };
+      turns.set(n, t);
+    }
+    return t;
+  };
+  const callOf = (t, r) => {
+    const id = r.toolCallId;
+    let c = t.calls.get(id);
+    if (c === void 0) {
+      c = { toolCallId: id, toolName: r.toolName, iteration: r.iteration };
+      const d = declared.get(id);
+      if (d !== void 0) c.declared = d;
+      t.calls.set(id, c);
+    }
+    return c;
+  };
+  for (const row of ledger) {
+    if (!isRec(row) || !hasTurn(row)) continue;
+    const t = () => turnOf(row.turn);
+    switch (row.kind) {
+      case "clock": {
+        const clock = clockOf(row);
+        if (clock === void 0) continue;
+        t().clock = clock;
+        break;
+      }
+      case "clock-on-resume": {
+        const resume = resumeOf(row);
+        if (resume === void 0) continue;
+        t().resumes.push(resume);
+        break;
+      }
+      case "time-reading": {
+        const reading = readingOf(row);
+        if (reading === void 0) continue;
+        t().readings.push(reading);
+        break;
+      }
+      case "call-window": {
+        const w = windowOf(row);
+        if (w === void 0) continue;
+        callOf(t(), row).window = w;
+        break;
+      }
+      case "call": {
+        const d = dispatchOf(row);
+        if (d === void 0) continue;
+        callOf(t(), row).dispatch = d;
+        break;
+      }
+      case "period": {
+        const p = periodOf(row);
+        if (p === void 0) continue;
+        callOf(t(), row).period = p;
+        break;
+      }
+      default:
+        continue;
+    }
+    rows += 1;
+  }
+  if (rows === 0) return void 0;
+  return {
+    rows,
+    turns: [...turns.values()].map((t) => ({
+      turn: t.turn,
+      ...t.clock !== void 0 ? { clock: t.clock } : {},
+      resumes: t.resumes,
+      readings: t.readings,
+      calls: [...t.calls.values()]
+    }))
+  };
+}
+function spellMs(ms) {
+  const sign = ms < 0 ? "-" : "+";
+  let rest = Math.abs(ms);
+  const parts = [];
+  for (const [unit, size] of [
+    ["h", 36e5],
+    ["m", 6e4],
+    ["s", 1e3]
+  ]) {
+    const n = Math.floor(rest / size);
+    if (n > 0) parts.push(`${n}${unit}`);
+    rest -= n * size;
+  }
+  if (rest > 0 || parts.length === 0) parts.push(`${rest}ms`);
+  return sign + parts.join(" ");
+}
+
+export {
+  contextAt,
+  LABELS,
+  foldTimeRows,
+  spellMs
+};
+//# sourceMappingURL=chunk-5S5JD7BV.js.map

package/dist/chunk-5S5JD7BV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/context/contextAt.ts","../src/core/time/labels.ts","../src/core/time/timeRows.ts"],"sourcesContent":["/**\n * core/context/contextAt — the context object at a stop, with who wrote each\n * key, what moved since the previous stop, and what was served beside it.\n *\n * THE JOIN, nothing more. Three records already exist and this file writes\n * none of its own:\n *\n *   1. the COMMIT LOG — `stateAt(snapshot, commitIdx)` is the object at the\n *      stop; the trace rows of the bundles up to it name, per top-level key,\n *      the stage that last wrote it (`runtimeStageId`) and the first that\n *      did; the bundle's own rows are the DELTA of the stop;\n *   2. the RECEIPT at the stop's epoch — `servedRowAt` (the Served tab's own\n *      core) says what crossed into the model call and what the catalogue\n *      withheld; it is handed through untouched, never re-derived;\n *   3. the EVENT STREAM — entries stamped with the stages that wrote this\n *      stop's delta, or with the stop's own stage, are the \"why\" beside the\n *      keys; names only, no sentence.\n *\n * Join keys: `runtimeStageId` (commit log ⟂ events), `epoch` (commit log ⟂\n * receipt, through `servedRowAt`). A key the fold holds with no writer row —\n * the run's initial state, or a row the log lost — is `wroteBy: undefined`:\n * UNATTRIBUTED, never guessed (the reads law: omit, never deny). Owners are\n * stage ids, because that is what the record says; a word like \"host\" or\n * \"model\" is a reader's mapping, not this file's.\n *\n * Pure; frozen returns; no React. Consumers with their own UI read this.\n */\nimport * as trace from 'footprintjs/trace';\nimport { stateAt } from 'footprintjs/trace';\nimport type { FoldSource, FoldedState } from 'footprintjs/trace';\n\nimport type { EventLogEntry } from '../types.js';\nimport { servedRowAt, servedRowForEpoch } from '../served/servedRowAt.js';\nimport { sincePrevious, type SincePrevious } from '../served/sincePrevious.js';\nimport { verify, type ServedVerification } from '../served/verify.js';\nimport type { ServedCursor, ServedRow } from '../served/types.js';\n\n/** The slice of a footprintjs commit bundle this file reads — narrowed per row, never trusted whole. */\ninterface TraceRow {\n  readonly path: string;\n  readonly verb: string;\n}\ninterface CommitBundle {\n  readonly idx?: number;\n  readonly runtimeStageId: string;\n  readonly trace?: readonly TraceRow[];\n}\n\n/** One top-level key of the context object at the stop. */\nexport interface ContextKey {\n  readonly path: string;\n  readonly value: unknown;\n  /** The stage that LAST wrote the key, from its trace row; absent = unattributed. */\n  readonly wroteBy?: string;\n  /** The commit index of that last write. */\n  readonly wroteAt?: number;\n  /** The first commit that wrote the key — when it ENTERED the context. */\n  readonly enteredAt?: number;\n  /** The verb of the last write, from the trace row. */\n  readonly verb?: string;\n  /** How the key moved since the previous stop (absent when no previous stop was given). */\n  readonly since?: 'entered' | 'changed' | 'unchanged';\n}\n\n/** What is served beside the object at this stop — the Served tab's own row, handed through. */\nexport interface ContextServed {\n  readonly row: ServedRow;\n  readonly checks: ServedVerification;\n  readonly since?: SincePrevious;\n}\n\nexport interface ContextAt {\n  readonly cursor: ServedCursor;\n  /** Every top-level key of the fold at the stop, in the fold's key order. */\n  readonly keys: readonly ContextKey[];\n  /** Keys the previous stop held that this one does not (only with a previous stop). */\n  readonly left: readonly string[];\n  /** The trace rows the stop's own bundle wrote — its delta as the log spells it. */\n  readonly rows: readonly { readonly path: string; readonly verb: string }[];\n  /** The fold's honesty facts, as `stateAt` reports them. */\n  readonly basis?: FoldedState['basis'];\n  readonly redacted: boolean;\n  readonly skipped?: readonly number[];\n  readonly foldError?: string;\n  /** The served side at this stop's epoch, when the stop is at or after a model call. */\n  readonly served?: ContextServed;\n  /** The Served core refused this snapshot — its message, verbatim; `served` is then absent. */\n  readonly servedError?: string;\n  /** Event names raised by the stages that wrote this stop's delta, or by its own stage. */\n  readonly why: readonly {\n    readonly seq: number;\n    readonly name: string;\n    readonly runtimeStageId: string;\n  }[];\n}\n\nexport interface ContextAtOptions {\n  /** The previous stop on the reader's axis — enables `since` and `left`. */\n  readonly previous?: ServedCursor;\n  /** The recording's event stream, when the reader has one (a replay's `getEntries()`). */\n  readonly events?: readonly EventLogEntry[];\n}\n\n/**\n * The top-level key a trace-row path names. footprintjs 9.22.0 exports\n * `pathSegments` (its paths are joined with U+001F since then); the lens's\n * peer floor is 9.17.0, whose paths are dotted and which has no such export —\n * so the helper is read at call time, the way `tagStops` is, and a floor\n * substrate gets the split it used (0.53.4: a consumer on 9.21.1 could not\n * even bundle the lens while this was a static import).\n */\nexport function firstSegment(path: string): string | undefined {\n  const helper = (trace as { pathSegments?: (p: string) => string[] }).pathSegments;\n  if (typeof helper === 'function') return helper(path)[0];\n  const unit = path.indexOf('\\u001F');\n  if (unit >= 0) return path.slice(0, unit);\n  const dot = path.indexOf('.');\n  return dot >= 0 ? path.slice(0, dot) : path;\n}\n\ninterface WriterFacts {\n  readonly wroteBy: string;\n  readonly wroteAt: number;\n  readonly enteredAt: number;\n  readonly verb: string;\n}\n\nfunction logOf(snapshot: unknown): readonly CommitBundle[] {\n  const s = snapshot as { commitLog?: unknown } | null | undefined;\n  return Array.isArray(s?.commitLog) ? (s.commitLog as CommitBundle[]) : [];\n}\n\n/** Per top-level key, the first and last trace rows up to `commitIdx` (inclusive). */\nfunction writersUpTo(log: readonly CommitBundle[], commitIdx: number): ReadonlyMap<string, WriterFacts> {\n  const out = new Map<string, WriterFacts>();\n  const last = Math.min(commitIdx, log.length - 1);\n  for (let i = 0; i <= last; i++) {\n    const bundle = log[i];\n    if (bundle === undefined || typeof bundle.runtimeStageId !== 'string' || !Array.isArray(bundle.trace))\n      continue;\n    for (const row of bundle.trace) {\n      const key = firstSegment(row.path);\n      if (key === undefined) continue;\n      const prior = out.get(key);\n      out.set(key, {\n        wroteBy: bundle.runtimeStageId,\n        wroteAt: i,\n        enteredAt: prior?.enteredAt ?? i,\n        verb: row.verb,\n      });\n    }\n  }\n  return out;\n}\n\nfunction foldAt(snapshot: unknown, commitIdx: number): FoldedState | { readonly error: string } {\n  const source: FoldSource | undefined =\n    typeof snapshot === 'object' && snapshot !== null ? (snapshot as FoldSource) : undefined;\n  try {\n    return stateAt(source, commitIdx);\n  } catch (e) {\n    return { error: e instanceof Error ? e.message : String(e) };\n  }\n}\n\nconst same = (a: unknown, b: unknown): boolean => JSON.stringify(a) === JSON.stringify(b);\n\nfunction servedFor(\n  snapshot: unknown,\n  cursor: ServedCursor,\n): { readonly served?: ContextServed; readonly servedError?: string } {\n  try {\n    const row = servedRowAt(snapshot, cursor);\n    if (row === undefined) return {};\n    const checks = verify(row.view, row.receipt, row.receipt?.basis.runId ?? '', row.receiptCause);\n    const previous =\n      row.previousEpoch !== undefined ? servedRowForEpoch(snapshot, row.previousEpoch) : undefined;\n    const since = previous !== undefined ? sincePrevious(row, previous) : undefined;\n    return {\n      served: Object.freeze({\n        row,\n        checks,\n        ...(since !== undefined ? { since } : {}),\n      }),\n    };\n  } catch (e) {\n    return { servedError: e instanceof Error ? e.message : String(e) };\n  }\n}\n\nfunction whyFor(events: readonly EventLogEntry[] | undefined, stages: ReadonlySet<string>): ContextAt['why'] {\n  if (events === undefined || stages.size === 0) return Object.freeze([]);\n  const out: { seq: number; name: string; runtimeStageId: string }[] = [];\n  for (const entry of events) {\n    const id = entry.runtimeStageId;\n    if (id === undefined || !stages.has(id)) continue;\n    out.push({ seq: entry.seq, name: entry.event.type, runtimeStageId: id });\n  }\n  return Object.freeze(out);\n}\n\n/**\n * The context at `cursor`: the fold's keys with their writers, the delta\n * since `options.previous`, the served side at this epoch, and the events\n * beside the delta. Returns a frozen object; a fold that cannot be replayed\n * reports `foldError` with no keys rather than an empty object pretending to\n * be one.\n */\nexport function contextAt(\n  recording: unknown,\n  cursor: ServedCursor,\n  options: ContextAtOptions = {},\n): ContextAt {\n  const log = logOf(recording);\n  const folded = foldAt(recording, cursor.commitIdx);\n  if ('error' in folded) {\n    return Object.freeze({\n      cursor,\n      keys: Object.freeze([]),\n      left: Object.freeze([]),\n      rows: Object.freeze([]),\n      redacted: false,\n      foldError: folded.error,\n      why: Object.freeze([]),\n    });\n  }\n  const writers = writersUpTo(log, cursor.commitIdx);\n  const previous = options.previous !== undefined ? foldAt(recording, options.previous.commitIdx) : undefined;\n  const previousState = previous !== undefined && !('error' in previous) ? previous.state : undefined;\n\n  const keys: ContextKey[] = [];\n  for (const [path, value] of Object.entries(folded.state)) {\n    const w = writers.get(path);\n    const since: ContextKey['since'] | undefined =\n      previousState === undefined\n        ? undefined\n        : !(path in previousState)\n          ? 'entered'\n          : same(previousState[path], value)\n            ? 'unchanged'\n            : 'changed';\n    keys.push(\n      Object.freeze({\n        path,\n        value,\n        ...(w !== undefined\n          ? {\n              wroteBy: w.wroteBy,\n              wroteAt: w.wroteAt,\n              enteredAt: w.enteredAt,\n              verb: w.verb,\n            }\n          : {}),\n        ...(since !== undefined ? { since } : {}),\n      }),\n    );\n  }\n  const left =\n    previousState === undefined ? [] : Object.keys(previousState).filter((k) => !(k in folded.state));\n\n  const bundle = log[cursor.commitIdx];\n  const rows = Array.isArray(bundle?.trace)\n    ? bundle.trace.map((r: TraceRow) => Object.freeze({ path: r.path, verb: r.verb }))\n    : [];\n\n  const stages = new Set<string>();\n  if (bundle !== undefined && typeof bundle.runtimeStageId === 'string') stages.add(bundle.runtimeStageId);\n  for (const k of keys)\n    if (k.since !== undefined && k.since !== 'unchanged' && k.wroteBy !== undefined) stages.add(k.wroteBy);\n\n  const skipped =\n    folded.skipped !== undefined && folded.skipped.length > 0\n      ? folded.skipped.map((g) => g.index)\n      : undefined;\n  const { served, servedError } = servedFor(recording, cursor);\n\n  return Object.freeze({\n    cursor,\n    keys: Object.freeze(keys),\n    left: Object.freeze(left),\n    rows: Object.freeze(rows),\n    basis: folded.basis,\n    redacted: folded.redacted,\n    ...(skipped !== undefined ? { skipped: Object.freeze(skipped) } : {}),\n    ...(served !== undefined ? { served } : {}),\n    ...(servedError !== undefined ? { servedError } : {}),\n    why: whyFor(options.events, stages),\n  });\n}\n","/**\n * The time views' own words — names for rows and fields, never a claim.\n *\n * Every other string the time views print is a value off the record (an\n * instant, a zone, a tool name, the record's own word for `how`, `choice.by`,\n * `outcome`, `verdict`, a refusal code) or a library sentence handed through\n * (an ask's `refused.reason`). `test/served/no-own-claims.test.ts` walks\n * `src/core/time/` and the three time components against this set.\n *\n * Two labels carry a MEANING the reader must not miss, and are chosen from\n * the design page's own words (agentfootprint docs/design/time § 8, § 10.2):\n * `widened` (\"wider than asked\") on a fill that reads more than was asked,\n * and `clockUnknown` (\"clock unknown\") on a value, a tz database or a held\n * range whose clock the record does not know.\n */\nexport const LABELS = Object.freeze({\n  band: 'time',\n  rows: 'rows',\n  turn: 'turn',\n  clock: 'clock',\n  now: 'now',\n  zone: 'zone',\n  source: 'source',\n  window: 'window',\n  clockOnResume: 'clock on resume',\n  passed: 'passed',\n  kept: 'kept',\n  readings: 'readings',\n  reader: 'reader',\n  tzdata: 'tz database',\n  noMentions: 'no mentions',\n  quote: 'quote',\n  candidates: 'candidates',\n  choice: 'choice',\n  remaining: 'remaining',\n  open: 'open',\n  policy: 'policy',\n  refused: 'refused',\n  problem: 'problem',\n  said: 'said',\n  implied: 'implied',\n  notes: 'notes',\n  grain: 'grain',\n  calls: 'calls',\n  how: 'how',\n  form: 'form',\n  asked: 'asked',\n  person: 'person',\n  mention: 'mention',\n  by: 'by',\n  rounded: 'rounded',\n  why: 'why',\n  sent: 'sent',\n  widened: 'wider than asked',\n  extra: 'extra',\n  trimmedByTool: 'trimmed by tool',\n  partlyBeyondRetention: 'partly beyond retention',\n  argument: 'argument',\n  dispatchedAt: 'dispatched at',\n  drift: 'drift at dispatch',\n  period: 'period',\n  verdict: 'verdict',\n  queried: 'queried',\n  held: 'held',\n  readAt: 'read at',\n  clockUnknown: 'clock unknown',\n  ask: 'time ask',\n  request: 'request',\n  repeat: 'asked again',\n  answer: 'answer',\n  reason: 'reason',\n  field: 'field',\n  format: 'format',\n  choices: 'choices',\n  strict: 'strict',\n  missing: 'missing',\n  axis: 'time axis',\n  column: 'column',\n  unit: 'unit',\n  interval: 'interval',\n  aggregate: 'aggregate',\n  summary: 'summary',\n  malformed: 'malformed',\n  unjudged: 'not checked',\n  values: 'values',\n  placed: 'placed',\n  dstGap: 'dst gap',\n  unreadable: 'unreadable',\n});\n","/**\n * foldTimeRows — the time layer's rows on the honesty ledger, grouped for\n * reading (agentfootprint 9.129.0, time design § 10.6; the row shapes are\n * `core/time/rows.ts` · `TimeRow` and `coverage/period.ts` · `PeriodRow`).\n *\n * WHY. An armed agent (`.time()`) files five row kinds on\n * `AgentState.findingsLedger` beside the findings rows: one `clock` per turn,\n * a `clock-on-resume` when a resume passed a different `time`, a\n * `time-reading` per mention the reader found, a `call-window` per call to a\n * tool that declares period forms, and a `call` per dispatched call. The\n * results layer files a `period` verdict per call whose tool declares a\n * period. Read raw, one call's story is spread over three rows; this fold\n * joins them by `toolCallId` under their turn, and joins the call's own\n * declared period (`coverageDeclared` · `period`) beside the verdict, so the\n * reader sees asked → sent → covered in one place.\n *\n * THE LAWS THIS FILE KEEPS:\n *\n *   1. A SHAPE THE LENS DOES NOT OWN. The rows came off a recording as JSON,\n *      so each is narrowed by its shape here and a row that does not fit is\n *      passed over (the `FindingsBand.tsx` · `standingOf` precedent). Types\n *      mirror the library's (`shapes.ts`, pinned to them by a type test).\n *   2. NEVER INFER. Nothing here compares instants, computes a verdict or\n *      decides that a window differs: `wider than asked` is printed only\n *      where the row carries `differs`, a drift only where it carries\n *      `drift`. A row kind the lens does not know is skipped.\n *   3. OMIT, NEVER DENY. `undefined` when the ledger holds no time row and no\n *      period row — an unarmed run has no band, never an empty one.\n *\n * Pure: no React, no clock, no I/O.\n */\n\nimport type {\n  CallRowShape as CallRow,\n  CallWindowRowShape as CallWindowRow,\n  ClockOnResumeRowShape as ClockOnResumeRow,\n  ClockRowShape as ClockRow,\n  TimeReadingRowShape as TimeReadingRow,\n  TimeRangeShape as TimeRange,\n} from './shapes.js';\n\n/** A period verdict row, as read (the library does not export the type from its root). */\nexport interface PeriodRowShape {\n  readonly kind: 'period';\n  readonly turn: number;\n  readonly toolCallId: string;\n  readonly toolName: string;\n  readonly iteration: number;\n  readonly verdict: string;\n  readonly argument?: string;\n}\n\n/** What a result declared its read covered (`DeclaredPeriod`), as read. */\nexport interface DeclaredPeriodShape {\n  readonly queried: TimeRange;\n  readonly held: TimeRange | 'unknown';\n  readonly readAt?: string;\n}\n\n/** One call's time story: its window decision, its dispatch moment, its period verdict. */\nexport interface TimeCall {\n  readonly toolCallId: string;\n  readonly toolName: string;\n  readonly iteration: number;\n  readonly window?: CallWindowRow;\n  readonly dispatch?: CallRow;\n  readonly period?: PeriodRowShape;\n  /** The period the call's result declared (`coverageDeclared` · `period`), joined by `toolCallId`. */\n  readonly declared?: DeclaredPeriodShape;\n}\n\n/** One turn's time rows, in the order the ledger holds them. */\nexport interface TimeTurn {\n  readonly turn: number;\n  readonly clock?: ClockRow;\n  readonly resumes: readonly ClockOnResumeRow[];\n  readonly readings: readonly TimeReadingRow[];\n  readonly calls: readonly TimeCall[];\n}\n\nexport interface TimeFold {\n  /** How many ledger rows the fold read (time kinds and `period`). */\n  readonly rows: number;\n  readonly turns: readonly TimeTurn[];\n}\n\n// ─── Narrowing ────────────────────────────────────────────────────────────\n\ntype Rec = Readonly<Record<string, unknown>>;\n\nconst isRec = (v: unknown): v is Rec => v !== null && typeof v === 'object' && !Array.isArray(v);\nconst isStr = (v: unknown): v is string => typeof v === 'string' && v.length > 0;\nconst isCount = (v: unknown): v is number => typeof v === 'number' && Number.isInteger(v) && v >= 0;\n\n/** `{ from, to }` of two strings — the one range shape every time row carries. */\nexport function isRangeShape(v: unknown): v is TimeRange {\n  return isRec(v) && isStr(v.from) && isStr(v.to);\n}\n\nconst hasTurn = (r: Rec): boolean => isCount(r.turn) && isCount(r.iteration);\n\nfunction clockOf(r: Rec): ClockRow | undefined {\n  return isStr(r.now) && isStr(r.zone) && isStr(r.nowSource) && isStr(r.zoneSource)\n    ? (r as unknown as ClockRow)\n    : undefined;\n}\n\nfunction resumeOf(r: Rec): ClockOnResumeRow | undefined {\n  return isRec(r.passed) && isRec(r.kept) ? (r as unknown as ClockOnResumeRow) : undefined;\n}\n\nfunction readingOf(r: Rec): TimeReadingRow | undefined {\n  const reader = r.reader;\n  if (!isRec(reader) || !isStr(reader.id) || !isStr(reader.version) || !isCount(r.mentions)) {\n    return undefined;\n  }\n  if (r.candidates !== undefined && !Array.isArray(r.candidates)) return undefined;\n  return r as unknown as TimeReadingRow;\n}\n\nconst callIdentity = (r: Rec): boolean => isStr(r.toolCallId) && typeof r.toolName === 'string';\n\nfunction windowOf(r: Rec): CallWindowRow | undefined {\n  return callIdentity(r) && isStr(r.how) ? (r as unknown as CallWindowRow) : undefined;\n}\n\nfunction dispatchOf(r: Rec): CallRow | undefined {\n  return callIdentity(r) && isStr(r.dispatchedAt) ? (r as unknown as CallRow) : undefined;\n}\n\nfunction periodOf(r: Rec): PeriodRowShape | undefined {\n  return callIdentity(r) && isStr(r.verdict) ? (r as unknown as PeriodRowShape) : undefined;\n}\n\n/** The `period` a `coverageDeclared` row carries, by its `toolCallId`. */\nfunction declaredPeriods(coverage: readonly unknown[] | undefined): Map<string, DeclaredPeriodShape> {\n  const out = new Map<string, DeclaredPeriodShape>();\n  for (const row of coverage ?? []) {\n    if (!isRec(row) || !isStr(row.toolCallId) || !isRec(row.period)) continue;\n    const p = row.period;\n    if (!isRangeShape(p.queried) || !(p.held === 'unknown' || isRangeShape(p.held))) continue;\n    out.set(row.toolCallId, p as unknown as DeclaredPeriodShape);\n  }\n  return out;\n}\n\n// ─── The fold ─────────────────────────────────────────────────────────────\n\ninterface TurnDraft {\n  turn: number;\n  clock?: ClockRow;\n  resumes: ClockOnResumeRow[];\n  readings: TimeReadingRow[];\n  calls: Map<string, { -readonly [K in keyof TimeCall]: TimeCall[K] }>;\n}\n\n/**\n * The time rows of `ledger`, grouped by turn and, within a turn, by call —\n * or `undefined` when the ledger holds none (law 3). `coverage` is the\n * state's `coverageDeclared` at the same stop, read only for each call's\n * declared `period`.\n */\nexport function foldTimeRows(\n  ledger: readonly unknown[] | undefined,\n  coverage?: readonly unknown[],\n): TimeFold | undefined {\n  if (!Array.isArray(ledger)) return undefined;\n  const turns = new Map<number, TurnDraft>();\n  const declared = declaredPeriods(coverage);\n  let rows = 0;\n  const turnOf = (n: number): TurnDraft => {\n    let t = turns.get(n);\n    if (t === undefined) {\n      t = { turn: n, resumes: [], readings: [], calls: new Map() };\n      turns.set(n, t);\n    }\n    return t;\n  };\n  const callOf = (t: TurnDraft, r: Rec) => {\n    const id = r.toolCallId as string;\n    let c = t.calls.get(id);\n    if (c === undefined) {\n      c = { toolCallId: id, toolName: r.toolName as string, iteration: r.iteration as number };\n      const d = declared.get(id);\n      if (d !== undefined) c.declared = d;\n      t.calls.set(id, c);\n    }\n    return c;\n  };\n\n  for (const row of ledger) {\n    if (!isRec(row) || !hasTurn(row)) continue;\n    const t = (): TurnDraft => turnOf(row.turn as number);\n    switch (row.kind) {\n      case 'clock': {\n        const clock = clockOf(row);\n        if (clock === undefined) continue;\n        t().clock = clock;\n        break;\n      }\n      case 'clock-on-resume': {\n        const resume = resumeOf(row);\n        if (resume === undefined) continue;\n        t().resumes.push(resume);\n        break;\n      }\n      case 'time-reading': {\n        const reading = readingOf(row);\n        if (reading === undefined) continue;\n        t().readings.push(reading);\n        break;\n      }\n      case 'call-window': {\n        const w = windowOf(row);\n        if (w === undefined) continue;\n        callOf(t(), row).window = w;\n        break;\n      }\n      case 'call': {\n        const d = dispatchOf(row);\n        if (d === undefined) continue;\n        callOf(t(), row).dispatch = d;\n        break;\n      }\n      case 'period': {\n        const p = periodOf(row);\n        if (p === undefined) continue;\n        callOf(t(), row).period = p;\n        break;\n      }\n      default:\n        continue;\n    }\n    rows += 1;\n  }\n  if (rows === 0) return undefined;\n  return {\n    rows,\n    turns: [...turns.values()].map((t) => ({\n      turn: t.turn,\n      ...(t.clock !== undefined ? { clock: t.clock } : {}),\n      resumes: t.resumes,\n      readings: t.readings,\n      calls: [...t.calls.values()],\n    })),\n  };\n}\n\n// ─── Spelling ─────────────────────────────────────────────────────────────\n\n/**\n * A signed millisecond count as the shortest exact spelling: `+30m`,\n * `-1h 5m`, `+45s`, `+250ms`. A drift is printed as the record's number,\n * spelled — never rounded into a different number.\n */\nexport function spellMs(ms: number): string {\n  const sign = ms < 0 ? '-' : '+';\n  let rest = Math.abs(ms);\n  const parts: string[] = [];\n  for (const [unit, size] of [\n    ['h', 3_600_000],\n    ['m', 60_000],\n    ['s', 1_000],\n  ] as const) {\n    const n = Math.floor(rest / size);\n    if (n > 0) parts.push(`${n}${unit}`);\n    rest -= n * size;\n  }\n  if (rest > 0 || parts.length === 0) parts.push(`${rest}ms`);\n  return sign + parts.join(' ');\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-P63SOXBD.js → chunk-6RNHIZHE.js}

@@ -1141,10 +1141,10 @@ function approveDecision(input) {
 function declineDecision(input) {
   return buildConsent(false, input, "declineDecision");
 }
-function buildConsent(approved, input, door) {
+function buildConsent(approved, input, door2) {
   if (typeof input?.by !== "string" || input.by.trim().length === 0) {
     throw new Error(
-      `${door} needs \`by\` \u2014 who is deciding (an operator id, an email). The decision is an audit record, and a record with no actor names nobody; it cannot be defaulted.`
+      `${door2} needs \`by\` \u2014 who is deciding (an operator id, an email). The decision is an audit record, and a record with no actor names nobody; it cannot be defaulted.`
     );
   }
   return {
@@ -1194,6 +1194,97 @@ function isConsentDecision(value) {
   return typeof value === "object" && value !== null && typeof value.approved === "boolean" && typeof value.by === "string";
 }
 
+// src/core/time/timeAsk.ts
+var isRec = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var isValue = (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean";
+function awaitingOf(value) {
+  if (!isRec(value)) return void 0;
+  if (Array.isArray(value.fields)) return value;
+  if (isRec(value.awaitingInput)) return awaitingOf(value.awaitingInput);
+  if (isRec(value.pauseData)) return awaitingOf(value.pauseData);
+  return void 0;
+}
+function fieldOf(raw, missing) {
+  if (!isRec(raw) || typeof raw.id !== "string" || typeof raw.format !== "string") return void 0;
+  const values = Array.isArray(raw.enum) ? raw.enum.filter(isValue) : [];
+  const labels = Array.isArray(raw.labels) ? raw.labels : [];
+  return {
+    id: raw.id,
+    format: raw.format,
+    required: raw.required !== false,
+    missing: missing.has(raw.id),
+    ...typeof raw.description === "string" ? { description: raw.description } : {},
+    choices: values.map((value, i) => {
+      const label = labels[i];
+      return typeof label === "string" ? { value, label } : { value };
+    }),
+    strict: raw.strict === true
+  };
+}
+function answerOf(raw) {
+  if (!isRec(raw)) return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) if (isValue(v)) out[k] = v;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function timeAskOf(value) {
+  const awaiting = awaitingOf(value);
+  if (awaiting === void 0) return void 0;
+  const missing = new Set(
+    Array.isArray(awaiting.missing) ? awaiting.missing.filter((m) => typeof m === "string") : []
+  );
+  const fields = awaiting.fields.map((f) => fieldOf(f, missing)).filter((f) => f !== void 0);
+  if (fields.length === 0) return void 0;
+  const refused = awaiting.refused;
+  const repeat = awaiting.repeat;
+  const answer = isRec(refused) ? answerOf(refused.answer) : void 0;
+  return {
+    ...typeof awaiting.requestId === "string" ? { requestId: awaiting.requestId } : {},
+    ...typeof awaiting.question === "string" ? { question: awaiting.question } : {},
+    fields,
+    ...isRec(refused) && typeof refused.reason === "string" ? { refused: { reason: refused.reason, ...answer !== void 0 ? { answer } : {} } } : {},
+    ...isRec(repeat) && typeof repeat.count === "number" ? { repeat: repeat.count } : {}
+  };
+}
+
+// src/core/time/timeAxis.ts
+import * as agentfootprint from "agentfootprint";
+function door() {
+  return agentfootprint;
+}
+function valuesOf(rows, axis) {
+  const normalise = door().normaliseInstants;
+  if (typeof normalise !== "function") return void 0;
+  try {
+    const view = normalise(rows, axis);
+    return {
+      status: view.status,
+      placed: view.status === "refused" ? 0 : view.points.length,
+      clockUnknown: view.status === "instants" ? 0 : view.count,
+      counts: view.counts
+    };
+  } catch {
+    return void 0;
+  }
+}
+function datasetTimeAxisOf(meta, rows) {
+  const raw = meta !== null && typeof meta === "object" ? meta.timeAxis : void 0;
+  if (raw === void 0) return { status: "absent" };
+  const { readTimeAxis, describeTimeAxis } = door();
+  if (typeof readTimeAxis !== "function") return { status: "unjudged", raw };
+  const reading = readTimeAxis(meta);
+  if (reading.status === "absent") return { status: "absent" };
+  if (reading.status === "malformed") return { status: "malformed", issues: reading.issues };
+  const summary = typeof describeTimeAxis === "function" ? describeTimeAxis(reading.axis) : void 0;
+  const values = rows !== void 0 ? valuesOf(rows, reading.axis) : void 0;
+  return {
+    status: "declared",
+    axis: reading.axis,
+    ...summary !== void 0 ? { summary } : {},
+    ...values !== void 0 ? { values } : {}
+  };
+}
+
 export {
   buildStepGraphFromSnapshot,
   buildSpecTreeFromBoundary,
@@ -1234,6 +1325,8 @@ export {
   declineDecision,
   decisionRequestBody,
   decisionSentence,
-  isConsentDecision
+  isConsentDecision,
+  timeAskOf,
+  datasetTimeAxisOf
 };
-//# sourceMappingURL=chunk-P63SOXBD.js.map
+//# sourceMappingURL=chunk-6RNHIZHE.js.map