agentfootprint 9.89.1 → 9.89.3

package/dist/types/core/servableSnapshot.d.ts

@@ -13,52 +13,44 @@
  *
  * THE DEFECT THIS CLOSES (9.89.1; entry 6 of
  * docs/design/2026-09-recorded-not-built.md). footprintjs scrubs at COMMIT
- * time: a policy-redacted key never
- * enters the commit log. But the live state view is not a commit — it is the
- * run's own heap — and its scrubbed twin, the *redacted mirror*, is served
- * only by `getSnapshot({ redact: true })`. Both tools called `getSnapshot()`
- * bare, so the string the model read and the kept record's `sharedState`
- * carried the plaintext while the log beside them said `REDACTED`. Two
- * mechanisms, each correct, never composed.
+ * time: a policy-redacted key never enters the commit log. But the live state
+ * view is not a commit — it is the run's own heap — and its scrubbed twin, the
+ * *redacted mirror*, is served only by `getSnapshot({ redact: true })`. Both
+ * tools called `getSnapshot()` bare, so the string the model read and the kept
+ * record's `sharedState` carried the plaintext while the log beside them said
+ * `REDACTED`. Two mechanisms, each correct, never composed.
  *
  * THE RULE. With a policy set, the served snapshot is footprintjs's redacted
- * view, plus one thing that view leaves raw: a subflow's final state.
- * `subflowResults[*].treeContext.globalContext` is the subflow's own isolated
- * heap (footprintjs `SubflowExecutor` builds the result from the nested
- * runtime's `sharedState`, and only the RUN-level runtime keeps a mirror). Its
- * `history`, though, is that subflow's commit log — scrubbed at write time
- * like the run's — so the served state is the FOLD of that history, through
- * footprintjs's own `stateAt`. That is the same construction the run-level
- * mirror is (apply the scrubbed patches in order), done at serve time for the
- * level footprintjs does not mirror. The subflow's fold base is dropped by the
- * same law footprintjs applies to the run's (`ExecutionRuntime.getSnapshot`:
- * the base never passed a policy, so it is omitted rather than served) — in
- * footprintjs 9.18 a subflow runtime is created bare, so that base is `{}`
- * and nothing is lost; the omission is there for the day it is not.
+ * view, exactly the object `getSnapshot({ redact: true })` returns — not a
+ * copy, not a second scrub. Without a policy it is `executor.getSnapshot()`,
+ * byte for byte: no mirror, the fold bases present, exactly the path both
+ * tools had.
  *
- * Without a policy this is `executor.getSnapshot()`, byte for byte: no
- * mirror, no fold, the fold bases present, exactly the path both tools had.
+ * WHAT IT NO LONGER HAS TO DO (9.89.3). Through footprintjs 9.19.x the
+ * redacted view left ONE surface raw: a subflow's final state
+ * (`subflowResults[*].treeContext.globalContext`, and its per-iteration `#n`
+ * twin) was the subflow's own isolated heap, because only the run-level
+ * runtime kept a mirror. So this function refolded each subflow's scrubbed
+ * `history` through footprintjs's `stateAt` before serving — the mirror's own
+ * construction, done at serve time, one level down. footprintjs 9.20.0 closed
+ * that limit at the root: a subflow keeps its own mirror whenever the run
+ * does, and the served state IS that mirror (equal to the fold over its
+ * scrubbed history; `engine/handlers/servedSubflowResults.ts` substitutes it
+ * once per mount, so the path key and the `#n` twin still name ONE object).
+ * A refold kept here would be a SECOND owner of the same rule — two owners
+ * drift — so it is gone. `test/core/flowchartAsTool.redact.test.ts` §7 pins
+ * both halves: the substrate's own redacted view holds the placeholder (red
+ * on 9.19.x), and this function serves that very object.
  *
- * WHAT IT CANNOT DO. A served view is as clean as the log it is built from,
- * and footprintjs 9.18.0 leaves the plaintext in the RECORD in these places —
- * each pinned in `test/core/flowchartAsTool.redact.test.ts` so this list
- * goes stale loudly:
- *   - `fields` (dot-path) redaction scrubs the value handed to RECORDERS only;
- *     the commit takes the key-level verdict (`ScopeFacade.setValue`).
- *   - A subflow's `outputMapper` writes back through `StageContext` directly,
- *     not the facade, so the PARENT log takes a policy-redacted key verbatim
- *     (`SubflowInputMapper.applyOutputMapping`).
- *   - An `inputMapper` seed is committed by the subflow's runtime, not a
- *     facade, so it is the subflow's `history[0]` unscrubbed
- *     (`SubflowInputMapper.seedSubflowGlobalStore`) — and the same seed is
- *     narrated as an `Input:` line with its `rawValue` before any policy sees
- *     it (`SubflowExecutor` · narrativeInput = mappedInput).
- *   - A stage that READS a redacted key clones the plaintext into its tracked
- *     reads (`StageContext.getValue`), served as `executionTree.*.stageReads`;
- *     read-tracking retention is not one of the substrate's redaction points.
- * The resume checkpoint (`err.checkpoint` on a paused run) is also not a
- * served view: resumption must replay against real values, and it is handed
- * to the agent loop, never to a model.
+ * WHAT IT CANNOT DO. The resume checkpoint (`err.checkpoint` on a paused run)
+ * is not a served view: resumption must replay against real values, and it is
+ * handed to the agent loop, never to a model. And the redacted view OMITS the
+ * run's `initialState` (footprintjs `ExecutionRuntime.getSnapshot`: the raw
+ * pre-run seed never passed a policy, so it is dropped rather than served), so
+ * a fold of a kept record reports `basis: 'log-only'`; a subflow's
+ * `treeContext.initialState` travels as footprintjs serves it (9.20.0 keeps
+ * it — the nested runtime's base BEFORE its seed, which is a commit of its
+ * own, `history[0]`).
  */
 import type { FlowChartExecutor, RedactionPolicy, RuntimeSnapshot } from 'footprintjs';
 /**

package/dist/types/core/servableSnapshot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"servableSnapshot.d.ts","sourceRoot":"","sources":["../../../src/core/servableSnapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAcvF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,eAAe,GAAG,SAAS,GAClC,eAAe,CAKjB"}
+{"version":3,"file":"servableSnapshot.d.ts","sourceRoot":"","sources":["../../../src/core/servableSnapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEvF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,eAAe,GAAG,SAAS,GAClC,eAAe,CAEjB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfootprint",
-  "version": "9.89.1",
+  "version": "9.89.3",
   "description": "The explainable agent framework — backtrack a wrong answer to the exact context that caused it (evidence, not guesses). Built on footprintjs.",
   "license": "MIT",
   "type": "commonjs",
@@ -326,7 +326,7 @@
     "@modelcontextprotocol/sdk": "*",
     "@opentelemetry/api": "*",
     "@yarflam/potion-base-8m": "*",
-    "footprintjs": "^9.18.0",
+    "footprintjs": "^9.20.0",
     "google-auth-library": "*",
     "ioredis": "*",
     "jose": "*",
@@ -423,7 +423,7 @@
     "esbuild": "^0.28.0",
     "eslint": "^8.44.0",
     "eslint-config-prettier": "^6.15.0",
-    "footprintjs": "^9.18.0",
+    "footprintjs": "^9.20.0",
     "google-auth-library": "^11.0.1",
     "jose": "^6.2.7",
     "openai": "^7.4.0",