agentfootprint 9.77.0 → 9.79.0

package/CHANGELOG.md

@@ -7,6 +7,195 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [9.79.0] - 2026-08-30
+
+### Added
+
+- **`walk: { recording }` — file the runbook's inner chart as a recording, so
+  the walk can actually be DRAWN.** A consumer wired the flow components of
+  the lens family to a runbook's answer and could not mount anything, and they
+  were right not to try. `runbookAsTool` files its walk as
+  `recording/chart-walk`, whose payload is a **row projection** — 129 rows of
+  `{step, type, depth, stage, stage_id, runtime_stage_id, subflow, text}`. A
+  step graph cannot be inferred from sentences about steps; a consumer handed
+  those rows can only correctly REFUSE to guess at the edges. The one piece
+  that makes a walk drawable is `structure`, the chart's build-time graph —
+  which a finished run does not leave behind and no snapshot carries.
+
+  Everything needed was already in the file, a few lines apart: the bridge
+  builds a fresh inner executor and ATTACHES RECORDERS (the run was recorded,
+  it simply was not filed), `recordingPutInput` was already the mint for the
+  agent's own run, `mintWalk` was already the guarded side effect that files
+  and never fails the answer, and `WalkDescriptor` was already where the spine
+  states what it filed. This connects them.
+
+  Declare `walk: { recording: true }` (or `{ label, maxBytes }`) and the inner
+  chart's own **`{ snapshot, events, structure }`** — the `recordRun` contract
+  exactly, the shape `observeRecording()` mounts — is filed under the existing
+  kind `recording/run`, and its ref rides the SAME spine descriptor as
+  `result.walk.recording_ref` beside `recording_kind`, `recording_bytes` and
+  `recording_note`. The wire ops that already redeem the walk redeem this with
+  **zero new operations**.
+
+  **OPT-IN, and that is the honest default.** A walk carries *sentences about*
+  what happened and no payload from it — values are off by construction
+  (`narrative({ includeValues: false })`). A recording is the run: shared
+  state, the whole commit log, every attached recorder's data — **whatever the
+  chart wrote**. Filing one is a materially bigger promise, so it is declared,
+  never begun on an operator's behalf. Unset, nothing extra runs — no second
+  snapshot, no bytes measured, no store call — and the envelope is
+  byte-identical to 9.78.0, pinned by a test that asserts no `recording_*` key
+  exists at all. A reader who never asked for a recording does not even get a
+  sentence explaining its absence.
+
+  **Redaction means the same for both artifacts.** The recording's snapshot is
+  read from the REDACTED MIRROR (`getSnapshot({ redact: true })`), never the
+  raw working memory — so the `redact` policy that scrubs the walk scrubs the
+  recording by the same rule at the same moment, and a redacted key travels as
+  `REDACTED` rather than vanishing (a reader sees that a value existed and was
+  scrubbed). With no policy configured the flag is a documented no-op.
+
+  **Size has a declared failure mode, and it is a refusal.** Over
+  `walk.recording.maxBytes` (default `DEFAULT_RECORDING_MAX_BYTES` =
+  5,000,000 — a walk is tens of KB, this package's own measured `recordRun`
+  bundle was 2.76 MB, a fleet sweep is unbounded) the recording is **not filed
+  and not truncated**, and `recording_note` names what it measured, the
+  ceiling it broke, and the option that raises it. The asymmetry with the
+  walk's row cap is the point: walk rows are independently meaningful so a
+  projection of them is still true, but `{ snapshot, events, structure }` is
+  one bundle — half a commit log under a whole chart draws a picture nobody
+  can check.
+
+  **The absence is always SPOKEN.** No store, an over-size refusal, an
+  unserializable snapshot, a store that threw — each costs the REF and lands a
+  named reason in `recording_note`, following `mintWalk`'s own law. A missing
+  ref with no sentence would leave a reader guessing, which is the one thing
+  the spine exists to prevent.
+
+  **`events` is empty by construction, and says so.** It is the typed
+  *agentfootprint* stream, fired by an agent turn; what ran here is a
+  footprintjs chart on its own executor, which fires none. All three keys are
+  present (that is what a viewer reads), the empty array is the honest count,
+  and the note states it so nobody reads it as a dropped stream — the walk's
+  own story rides `snapshot`, where the narrative recorder's data already
+  lives.
+
+- **`recordingPutInput` accepts `toolCallId`** — stamped on `origin.toolCallId`
+  the way `chartWalkPutInput` already did. A walk and the recording it projects
+  are two views of ONE tool call, so they carry the same join key, and either
+  joins back to the call the model made. Absent for an agent's own run
+  recording, which is a whole turn and belongs to no single call.
+
+## [9.78.0] - 2026-08-30
+
+### Added
+
+- **`Tool.resultColumns` + `checkColumnTypes` — the column-type contract: a
+  tool declares what its rows contain, and the library checks the rows against
+  it at the boundary.** Three recorded failures, and they are one shape — *a
+  number became something else, and nothing noticed at the seam*:
+
+  1. A mapping report wrote `str(m.get("logical_unit_number") or "")`. **LUN 0
+     is falsy**, so LUN 0 was stored as an EMPTY STRING on 2,094 mappings, and
+     a host group missing the LUN an initiator probes first became
+     indistinguishable from one that had it.
+  2. A capacity view rendered `round(mib / 1024, 1)`, so an 8 MiB disk came out
+     as `0.0 GB` — which reads as NO DISK, a provisioning failure, during a
+     live incident.
+  3. A whole family of tools returned their numbers as quoted strings
+     (`"1240"`), which silently blanked every chart, because nothing downstream
+     could tell a measure from a label.
+
+  Every rail passed, honestly, in all three: nothing errored, nothing was
+  ungrounded. The library already lets a tool declare what its result IS
+  (`resultKind`, 9.70.0); it did not let a tool declare what its result
+  CONTAINS, so a rowset had nothing to be wrong against — and every consumer
+  downstream was left SNIFFING types out of the data, where one stray `''`
+  demotes a numeric column to text in silence.
+
+  `resultColumns` is the sibling declaration: a column-name → type map, on
+  `Tool` beside `resultKind`. Types are `number` / `string` / `boolean` /
+  `date` — **the vocabulary this ecosystem's rowset consumers already sniff
+  their way to**, not a new one. The one word deliberately left behind is
+  `'unknown'`: a sniffer needs it ("I could not tell"), a declaration has no
+  use for it. A column maps to a bare word or to `{ type, nullable }` (the
+  `CostBudget` two-spellings pattern, normalized once).
+
+  **THE CEILING**, exported as `COLUMN_TYPE_CEILING` and quoted verbatim into
+  every finding, the `EMPTY_LOOKUP_CEILING` law: *"This judges TYPE, never
+  MEANING — it can see that a column declared `number` holds a string, and it
+  can never see that the string should have been 0, or that a 0.0 should have
+  been an 8; a column whose every value has its declared type passes here and
+  can still be wrong."* Failures 1 and 3 are caught. **Failure 2 is not, and
+  never will be** — `0.0` is a perfectly good number — and the check says so
+  out loud rather than letting a green row imply otherwise.
+
+  **TWO finding kinds, because the field bug turned on the difference.** New
+  `ContextErrorKind`s at the **write seam**: **`column-type-mismatch`** (the
+  column is THERE and holds the wrong thing) and **`missing-column`** (the
+  declared column is in NONE of the rows). *"The value is not what it should
+  be"* sends a person to the mapping code; *"the column was never delivered"*
+  sends them to the query. A checker that said only "something is off with
+  logical_unit_number" would have helped with neither. Each finding names the
+  column, the offending value quoted, the rows affected of the rows read, and
+  the tool.
+
+  **OPEN, never closed.** A declaration is a promise about what it NAMES — an
+  unlisted column is allowed and never judged. A closed schema would punish the
+  wrong party the day a backend adds a column, and it is the rule the
+  neighbouring boundary (`toolArgsValidation`) already keeps.
+
+  **`nullable`, and what "no value" means.** `null`, `undefined` and a key not
+  set on a row are one idea with three spellings, and by default all three are
+  violations; `nullable: true` legitimizes them and every finding about an
+  absence names that one-word fix in its own message. `nullable` is a promise
+  about VALUES, not about the column's existence: a declared column in no row
+  at all is `missing-column` regardless.
+
+  **The dial: `AgentOptions.checkColumnTypes`, default `'off'`** —
+  `'off'` | `'warn'` | `'enforce'`. **The three words are borrowed, not
+  minted:** this boundary is the MIRROR of `toolArgsValidation` (arguments in,
+  against `inputSchema`; rows out, against `resultColumns`), and two validators
+  at one seam grading themselves in different vocabularies would be a worse
+  defect than either could catch — so there is no new `assist`/`guard`/`rails`
+  trio here and no new `observe`/`warn`/`refuse` one either. `'warn'` files
+  findings and the model reads the rows **exactly** as the tool returned them.
+  `'enforce'` REFUSES in the library's own refusal idiom — the `resultCeiling`
+  teaching sentence ("…Fix the tool so the column holds what it declares, or
+  change the declaration. No data was returned."), the whole payload on every
+  channel, delivered status `'invalid'`, never a thrown stack trace.
+
+  **What it refuses to judge** (`readRowset`): a result is read only when it is
+  an ARRAY OF PLAIN OBJECTS with at least one row. Prose, a `null`, a bespoke
+  `{ rows: [...] }` wrapper, a claim ticket — and the **zero-row** result,
+  which has no columns to be wrong about and is `empty-lookup`'s subject next
+  door — all file an explicit `not-applicable` ROW and no finding. Filing
+  `missing-column` for every declared column of an empty answer would turn one
+  honest emptiness into a pile of false accusations.
+
+  **Armed by two halves**: the dial off `'off'` **and** at least one tool
+  declaring `resultColumns`. Absent either, the run is byte-identical — no
+  finding, no event, nothing on the wire, and a declaring tool with the dial
+  off runs byte-for-byte the run it ran before the declaration existed. The one
+  visible difference is the two registered rows in the disposition report,
+  filed `not-applicable`: registered-but-unarmed is a ROW, never silence.
+
+  **Travels MCP `_meta`** like the library's other tool declarations, both
+  directions — a remote catalogue is exactly where a numeric column arriving as
+  text goes unnoticed, and leaving the declaration behind would arm the check
+  for local tools while leaving every MCP tool a second-class citizen of it. A
+  malformed declaration from a foreign server is warned about once and dropped;
+  the tool still registers.
+
+  Exports: `COLUMN_TYPE_CEILING`, `COLUMN_TYPES`, `readRowset`,
+  `assertResultColumns`, and the types `ColumnType`, `ColumnDeclaration`,
+  `ToolResultColumns`, `ColumnCheckMode`, `ColumnViolation`, `RowsetReading`.
+  Docs: `docs-next` → Monitor → Column Types, which also names the three
+  existing consumers this declaration feeds (chart axis pickers that sniff, the
+  panel deciding table-vs-chart by inference, and `compute` staging rows blind)
+  — none of those integrations are built here, they are named so the next
+  person does not add an eighth sniffer.
+
 ## [9.77.0] - 2026-08-29
 
 ### Added

package/CLAUDE.md

@@ -17,7 +17,7 @@ not in this table, search `src/index.ts` for the nearest noun before writing cod
 
 | If you are about to build… | It is | Where | Since |
 |---|---|---|---|
-| turning a written operational procedure (a runbook, a triage playbook) into ONE agent tool whose every answer is EVIDENCE — coverage folded up from the inner tools it calls, rule name+version, verdict rows with GENERATED meanings, and the recorded walk as an artifact ticket, never bytes | `runbookAsTool` — dials: `procedure` (factory, invoked per call with `ctx.tools`) + `resultKind` (`'verdict/*'` arms the rowset projection; anything else ships spine + the chart's `report`) + `rules {name, version}` (default absent ⇒ `rule_version: 'undeclared'`) + `verdicts {decider, maxRows}` (default 50) + `walk {cap}` (default 500; over-cap ⇒ control-flow projection, declared) + `composedOf` (drift-checked at agent BUILD) + kept `recorders`/`keepRecord`/`keepRecordLimit`/`redact`; reserved state keys `verdicts`/`coverage`/`report` (the `report` bag lands BESIDE the spine, never over it — a report field spelling `af_coverage`/`af_provenance`/`rule_version`/`walk`/`report_note` or a live projection key is discarded and NAMED in `result.report_note`; precedence is explicit in `report.ts`, never spread order); inner `absent()` passes through VERBATIM unless the call said `allowAbsent`; walk kind `recording/chart-walk` + `walk_segment` discriminant | `src/core/runbook/` | 9.76.0 |
+| turning a written operational procedure (a runbook, a triage playbook) into ONE agent tool whose every answer is EVIDENCE — coverage folded up from the inner tools it calls, rule name+version, verdict rows with GENERATED meanings, and the recorded walk as an artifact ticket, never bytes | `runbookAsTool` — dials: `procedure` (factory, invoked per call with `ctx.tools`) + `resultKind` (`'verdict/*'` arms the rowset projection; anything else ships spine + the chart's `report`) + `rules {name, version}` (default absent ⇒ `rule_version: 'undeclared'`) + `verdicts {decider, maxRows}` (default 50) + `walk {cap, recording}` (cap default 500; over-cap ⇒ control-flow projection, declared · `recording: true` or `{label, maxBytes}`, default OFF — ALSO files the inner chart's own `{snapshot, events, structure}` under `recording/run` and puts its ref on the spine as `walk.recording_ref`, because the ROW projection cannot be drawn; snapshot read from the REDACTED mirror so one `redact` means the same for both; over `maxBytes` (`DEFAULT_RECORDING_MAX_BYTES` = 5,000,000) it is REFUSED not truncated; every absence — no store / over size / unserializable / store threw — is STATED in `walk.recording_note`, and the four `recording_*` fields are absent entirely when the dial is off) + `composedOf` (drift-checked at agent BUILD) + kept `recorders`/`keepRecord`/`keepRecordLimit`/`redact`; reserved state keys `verdicts`/`coverage`/`report` (the `report` bag lands BESIDE the spine, never over it — a report field spelling `af_coverage`/`af_provenance`/`rule_version`/`walk`/`report_note` or a live projection key is discarded and NAMED in `result.report_note`; precedence is explicit in `report.ts`, never spread order); inner `absent()` passes through VERBATIM unless the call said `allowAbsent`; walk kind `recording/chart-walk` + `walk_segment` discriminant | `src/core/runbook/` | 9.76.0, recording 9.79.0 |
 | calling ANOTHER registered tool from inside a tool's `execute` — composition over the agent's own dispatch map instead of importing the module and building a second query stack | `agentToolDispatch` + `ctx.tools` (ToolDispatch has/call) — sees static and skill-carried tools, NEVER ToolProvider-delivered ones (no build-time list, the 9.72.0 caveat); inner calls get the outer facts with hasArtifacts false and a derived toolCallId, `needs` resolved fail-closed non-interactively, `checkIn` and `wants` tools refused by name, no nested dispatch; declare ingredients via `composedOf` (and `gates` for a pausing procedure) — both travel MCP `_meta` | `src/core/agent/toolDispatch.ts` | 9.76.0 |
 | a tool returning numbers WITH the caveats that make them honest — interval/aggregation grain, is-it-a-counter, when the world was measured, which ground was NOT covered — as typed data the model reads compactly and the record keeps whole | `semantic()` + `tools.semantics_declared` (model sees `semanticsForModel` projection; `coverage` field absorbed by the coverage()/absent() channel) | `src/lib/semantics/` | 9.53.0 |
 | a build gate that refuses a triage/inventory tool that forgot its caveats, by tool name and field name | `checkSemantics` + `defineTool({ resultClass })` (`'triage'`/`'inventory'`, the closed set) + bin `agentfootprint-check-semantics` | `src/lib/semantics/check.ts` | 9.53.0 |
@@ -52,6 +52,7 @@ not in this table, search `src/index.ts` for the nearest noun before writing cod
 | the model inventing an id or a reading that no tool ever returned — a deterministic fabrication detector on the final answer, with a posture for how hard it pushes back | `.namesAndNumbersFromEvidence()` + `posture` (`'assist'` record+flag, the default / `'guard'` one revision then ship flagged / `'rails'` refuse instead) + `shapes` + `exempt` + `minDigits` (default 4) + `nudge` (default off) | `src/core/agent/evidence/` | 9.35.0 |
 | counting a HUMAN-VERIFIED value as ground for the choice-seam check — the person clicked a row, the app verified the cells against the artifact, and the id the model takes from that selection is not fabricated; the source label travels onto the record | `externalGrounds` + `ExternalGround` + `external_ground_used` | `src/integrity/unsupported-argument/check.ts` | 9.72.0 |
 | a lookup tool that answers "nothing found" for EVERY id because a filter broke, and an agent reporting that absence as fact — the run itself produced the id, the lookup came back empty, and that PAIR is worth a look | `noticeEmptyLookups` + `readLookupResult` + `EMPTY_LOOKUP_CEILING` (dial default OFF and needs a tool declaring `argumentsFrom` too — two halves; kind `empty-lookup` at seam `write`, always `advisory: true`; empty = a zero-length ARRAY or an `absent()` envelope, every other shape files `not-applicable` and no finding; the ceiling is quoted verbatim into every message) | `src/integrity/empty-lookup/` | 9.77.0 |
+| a tool's ROWS quietly disagreeing with what the tool promised — a LUN 0 stored as `""` because it is falsy, a numeric column arriving as quoted strings, a declared column present in no row at all | `Tool.resultColumns` + `checkColumnTypes` + `COLUMN_TYPE_CEILING` + `readRowset` (dial `'off'` (default) / `'warn'` (file findings, model reads the rows unchanged) / `'enforce'` (refuse the rows, `resultCeiling`'s teaching-sentence idiom, delivered status `'invalid'`) — the `toolArgsValidation` trio, this seam's mirror; needs a tool declaring `resultColumns` too — two halves; types `number`/`string`/`boolean`/`date`, bare word or `{type, nullable}`, deliberately NO `'unknown'`; OPEN — unlisted columns allowed and unjudged; TWO kinds at seam `write` — `column-type-mismatch` (there, wrong type) vs `missing-column` (declared, in no row); rowset = an ARRAY OF PLAIN OBJECTS with ≥1 row, everything else incl. the ZERO-ROW result files `not-applicable` (empty is `empty-lookup`'s subject); travels MCP `_meta`; the ceiling is quoted verbatim into every message) | `src/integrity/column-types/` | 9.78.0 |
 | a model head-mathing a total from tool-result numbers while a compute tool sits unused on the wire — a LATE line each iteration naming the staged refs and the `wants` tool that spends them (recency working FOR the instruction), plus the revise correction naming the same route | `nudge: true` (default off) + `stagedRefsNudgeLine` + `findStagedRefs` + `grounding_nudged` | `src/core/agent/stagedRefs.ts` | 9.75.0 |
 | a tool answering "I looked and found nothing", routably | `absent` + `looked_for` + `checked`/`not_checked`/`cannot_cover` + `tryInstead` (delivered status `'absent'`, routable by `onToolStatus`) | `src/core/agent/coverage/absent.ts` | 9.43.0 |
 | stating what a clean answer does NOT rule out | `coverage` + the declaration `{ checked, not_checked?, cannot_cover? }` | `src/core/agent/coverage/ledger.ts` | 9.43.0 |

package/dist/artifacts/recordingArtifact.js

@@ -84,12 +84,16 @@ function recordingPutInput(recording, facts = {}) {
     if (text === '') {
         throw new UnserializableRecordingError('it serializes to nothing');
     }
+    const origin = {
+        ...(facts.runId !== undefined && { runId: facts.runId }),
+        ...(facts.toolCallId !== undefined && { toolCallId: facts.toolCallId }),
+    };
     return {
         kind: exports.RECORDING_ARTIFACT_KIND,
         mediaType: exports.RECORDING_MEDIA_TYPE,
         data: text,
         label: facts.label ?? (facts.runId !== undefined ? `run ${facts.runId}` : 'run recording'),
-        ...(facts.runId !== undefined && { origin: { runId: facts.runId } }),
+        ...(Object.keys(origin).length > 0 && { origin }),
     };
 }
 exports.recordingPutInput = recordingPutInput;

package/dist/artifacts/recordingArtifact.js.map

@@ -1 +1 @@
-{"version":3,"file":"recordingArtifact.js","sourceRoot":"","sources":["../../src/artifacts/recordingArtifact.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;;;AAIH;oEACoE;AACvD,QAAA,uBAAuB,GAAG,eAAe,CAAC;AAEvD;;;;;;GAMG;AACU,QAAA,wBAAwB,GAAG,sBAAsB,CAAC;AAE/D,iDAAiD;AACpC,QAAA,oBAAoB,GAAG,kBAAkB,CAAC;AAoBvD;;;;;GAKG;AACH,MAAa,4BAA6B,SAAQ,KAAK;IAC5C,IAAI,GAAG,8BAAuC,CAAC;IAExD,YAAY,MAAc;QACxB,KAAK,CACH,0DAA0D,MAAM,mBAAmB;YACjF,kFAAkF;YAClF,oFAAoF;YACpF,kFAAkF,CACrF,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,8BAA8B,CAAC;IAC7C,CAAC;CACF;AAZD,oEAYC;AAED;;;;;;;;GAQG;AACH,SAAgB,iBAAiB,CAC/B,SAAkB,EAClB,QAA4B,EAAE;IAE9B,IAAI,IAAY,CAAC;IACjB,IAAI,CAAC;QACH,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IACzC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,4BAA4B,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3F,CAAC;IACD,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,MAAM,IAAI,4BAA4B,CAAC,0BAA0B,CAAC,CAAC;IACrE,CAAC;IACD,OAAO;QACL,IAAI,EAAE,+BAAuB;QAC7B,SAAS,EAAE,4BAAoB;QAC/B,IAAI,EAAE,IAAI;QACV,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC;QAC1F,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;KACrE,CAAC;AACJ,CAAC;AApBD,8CAoBC;AAgBD;;;;;;;;;;;;;GAaG;AACH,SAAgB,iBAAiB,CAC/B,IAAwB,EACxB,QAA4B,EAAE;IAE9B,IAAI,IAAY,CAAC;IACjB,IAAI,CAAC;QACH,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IACpC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,4BAA4B,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3F,CAAC;IACD,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,MAAM,IAAI,4BAA4B,CAAC,0BAA0B,CAAC,CAAC;IACrE,CAAC;IACD,MAAM,MAAM,GAAG;QACb,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;QACxD,GAAG,CAAC,KAAK,CAAC,UAAU,KAAK,SAAS,IAAI,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC;KACxE,CAAC;IACF,OAAO;QACL,IAAI,EAAE,gCAAwB;QAC9B,SAAS,EAAE,4BAAoB;QAC/B,IAAI,EAAE,IAAI;QACV,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,QAAQ,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC;QAC9F,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;KAClD,CAAC;AACJ,CAAC;AAxBD,8CAwBC"}
+{"version":3,"file":"recordingArtifact.js","sourceRoot":"","sources":["../../src/artifacts/recordingArtifact.ts"],"names":[],"mappings":"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"}

package/dist/core/Agent.js

@@ -315,6 +315,13 @@ class Agent extends RunnerBase_js_1.RunnerBase {
     /** See AgentOptions.noticeEmptyLookups (9.77.0). Default false — absent is
      *  byte-identical, save for the registered not-applicable ledger row. */
     noticeEmptyLookups = false;
+    /** Set at chart build: whether any tool in the FULL declared catalog
+     *  declared `resultColumns` (9.78.0) — the other half of the column-type
+     *  contract's arming. */
+    integrityColumnsPresent = false;
+    /** See AgentOptions.checkColumnTypes (9.78.0). Default 'off' — absent is
+     *  byte-identical, save for the registered not-applicable ledger rows. */
+    checkColumnTypes = 'off';
     /** See AgentOptions.externalGrounds (9.72.0). Absent = door closed,
      *  byte-identical behavior. */
     externalGrounds;
@@ -675,6 +682,22 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             }
             this.noticeEmptyLookups = opts.noticeEmptyLookups;
         }
+        // The column-type contract's dial (9.78.0) — refused at construction for
+        // the same reason as the postures above, and with one more: `'enforce'`
+        // REFUSES tool results, so a misspelling silently downgraded to off would
+        // leave an operator believing a boundary is held that nothing is holding.
+        if (opts.checkColumnTypes !== undefined) {
+            if (opts.checkColumnTypes !== 'off' &&
+                opts.checkColumnTypes !== 'warn' &&
+                opts.checkColumnTypes !== 'enforce') {
+                throw new Error(`Agent: checkColumnTypes must be 'off', 'warn' or 'enforce', got ` +
+                    `${JSON.stringify(opts.checkColumnTypes)}. It reads each tool's declared ` +
+                    `\`resultColumns\` and judges the rows it returns: 'warn' files findings and ` +
+                    `changes nothing the model reads; 'enforce' refuses the rows and hands the model a ` +
+                    `teaching sentence instead. Omit it (or pass 'off') and nothing is ever measured.`);
+            }
+            this.checkColumnTypes = opts.checkColumnTypes;
+        }
         // The claim-check seam (9.21.0). One store per agent, attached at
         // construction — idempotent by shape: there is no second door to attach a
         // competing one through, so "one per agent" is a fact of the type rather
@@ -2362,6 +2385,10 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             // TWO HALVES (9.77.0): the operator's dial AND a declaration to arm
             // on. Either alone leaves a registered `not-applicable` row.
             emptyLookup: this.noticeEmptyLookups && this.integrityDanglingPresent,
+            // TWO HALVES (9.78.0), the same law: the operator's dial off `'off'`
+            // AND a tool declaring `resultColumns`. Either alone leaves two
+            // registered `not-applicable` rows.
+            columnTypes: this.checkColumnTypes !== 'off' && this.integrityColumnsPresent,
         }, this.integrityPosture);
     }
     /**
@@ -3092,6 +3119,14 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             .filter(([, tool]) => tool.argumentsFrom !== undefined)
             .map(([name, tool]) => [name, tool.argumentsFrom]));
         this.integrityDanglingPresent = toolGrounding.size > 0;
+        // The column-type contract's declared half (9.78.0) — harvested from the
+        // SAME catalog and with the same ToolProvider caveat, so an MCP-carried
+        // `resultColumns` (which rides `_meta`) arms the check exactly as a
+        // locally-defined one does.
+        // `flatMap` rather than filter-then-assert: the narrowing is real here,
+        // so the twin harvest above's non-null assertion is not inherited.
+        const toolColumns = new Map([...registryByName.entries()].flatMap(([name, tool]) => tool.resultColumns === undefined ? [] : [[name, tool.resultColumns]]));
+        this.integrityColumnsPresent = toolColumns.size > 0;
         // The staged-refs join's other half (grounded numbers): `Tool.wants` by
         // tool name, harvested the same way and with the same ToolProvider caveat.
         // Consumed only by the evidence gate (the callLLM nudge and the recheck
@@ -3142,6 +3177,11 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             // runs where the result is. Value-conditional on BOTH halves, so an
             // agent that never asked for it reads no new key.
             ...(this.noticeEmptyLookups && toolGrounding.size > 0 && { noticeEmptyLookups: true }),
+            // The column-type contract's arming (9.78.0), same job and same
+            // value-conditional law: this stage owns only the "no declaring tool
+            // was called this response" not-applicable notes.
+            ...(this.checkColumnTypes !== 'off' &&
+                toolColumns.size > 0 && { columnDeclaringTools: new Set(toolColumns.keys()) }),
             integrityLedger: this.integrityLedgerHolder,
             ...(this.reliabilityConfig !== undefined && { reliability: this.reliabilityConfig }),
             ...(this.outputSchemaParser !== undefined && {
@@ -3246,6 +3286,16 @@ class Agent extends RunnerBase_js_1.RunnerBase {
                 emptyLookupGrounding: toolGrounding,
                 integrityLedger: this.integrityLedgerHolder,
             }),
+            // THE WRITE SEAM'S other check (9.78.0) — the column-type contract.
+            // Value-conditional on both halves for the same reason, so an agent
+            // that asked for neither hands the handler exactly the deps object it
+            // always did.
+            ...(this.checkColumnTypes !== 'off' &&
+                toolColumns.size > 0 && {
+                columnDeclarations: toolColumns,
+                columnCheckMode: this.checkColumnTypes,
+                integrityLedger: this.integrityLedgerHolder,
+            }),
             ...(this.externalToolProvider && { externalToolProvider: this.externalToolProvider }),
             ...(this.externalToolProvider && { providerToolCache }),
             ...(permissionChecker && { permissionChecker }),