footprintjs 6.1.2 → 7.1.0

package/dist/types/advanced.d.ts

@@ -51,5 +51,3 @@ export { applyOutputMapping, ChildrenExecutor, computeNodeType, ContinuationReso
 export type { ExecutionCounter } from './lib/engine/runtimeStageId.js';
 export { buildRuntimeStageId, createExecutionCounter, parseRuntimeStageId } from './lib/engine/runtimeStageId.js';
 export { findCommit, findCommits, findLastWriter } from './lib/memory/commitLogUtils.js';
-export { BoundaryStateTracker } from './lib/recorder/BoundaryStateTracker.js';
-export { KeyedRecorder } from './lib/recorder/KeyedRecorder.js';

package/dist/types/lib/builder/structure/StructureRecorder.d.ts

@@ -14,7 +14,7 @@
  *
  *     - Runtime events carry `runtimeStageId` (`[subflowPath/]stageId#N`),
  *       `iteration`, `traversalContext` — load-bearing for time-travel
- *       UIs, commit-log indices, and `SequenceRecorder<T>` consumers.
+ *       UIs, commit-log indices, and `SequenceStore<T>` consumers.
  *       NONE of these exist at build time.
  *
  *     - Build events carry only `stageId` + structural fields. No

package/dist/types/lib/engine/narrative/CombinedNarrativeRecorder.d.ts

@@ -1,9 +1,10 @@
 /**
  * CombinedNarrativeRecorder — Inline narrative builder that merges flow + data during traversal.
  *
- * Extends SequenceRecorder<CombinedNarrativeEntry> for dual-indexed storage (ordered sequence
- * + O(1) per-step lookup by runtimeStageId). Implements `CombinedRecorder` — the library's
- * first-class abstraction for observers that span both data-flow and control-flow streams.
+ * Composes a SequenceStore<CombinedNarrativeEntry> for dual-indexed storage (ordered sequence
+ * + O(1) per-step lookup by runtimeStageId) — Convention 1, one purpose per recorder.
+ * Implements `CombinedRecorder` — the library's first-class abstraction for observers that span
+ * both data-flow and control-flow streams.
  *
  * Event ordering guarantees this works:
  *   1. Scope events (onRead, onWrite) fire DURING stage execution
@@ -15,7 +16,6 @@
  */
 import type { CombinedRecorder } from '../../recorder/CombinedRecorder.js';
 import type { EmitEvent } from '../../recorder/EmitRecorder.js';
-import { SequenceRecorder } from '../../recorder/SequenceRecorder.js';
 import type { ErrorEvent, PauseEvent, ReadEvent, ResumeEvent, WriteEvent } from '../../scope/types.js';
 import type { CombinedNarrativeEntry, NarrativeRenderer } from './narrativeTypes.js';
 import type { FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowPauseEvent, FlowResumeEvent, FlowSelectedEvent, FlowStageEvent, FlowSubflowEvent } from './types.js';
@@ -42,8 +42,10 @@ export interface CombinedNarrativeRecorderOptions {
  * Scope variants of these events are deliberately ignored here — the
  * narrative only surfaces control-flow lifecycle events.
  */
-export declare class CombinedNarrativeRecorder extends SequenceRecorder<CombinedNarrativeEntry> implements CombinedRecorder {
+export declare class CombinedNarrativeRecorder implements CombinedRecorder {
     readonly id: string;
+    /** Dual-indexed ordered storage (Convention 1 — composed, not inherited). */
+    private readonly store;
     /**
      * Pending scope ops keyed by runtimeStageId. Flushed in onStageExecuted/onDecision.
      *
@@ -100,6 +102,25 @@ export declare class CombinedNarrativeRecorder extends SequenceRecorder<Combined
      * Root-level entries have subflowId = undefined.
      */
     getEntriesBySubflow(): Record<string, CombinedNarrativeEntry[]>;
+    /** All narrative entries in execution order. */
+    getEntries(): CombinedNarrativeEntry[];
+    /** Total number of narrative entries. */
+    get entryCount(): number;
+    /** O(1) lookup: all narrative entries for one execution step. */
+    getEntriesForStep(runtimeStageId: string): CombinedNarrativeEntry[];
+    /** Number of distinct execution steps that produced entries. */
+    get stepCount(): number;
+    /** Pre-built per-step range index — O(1) lookups for time-travel scrubbing. */
+    getEntryRanges(): ReadonlyMap<string, {
+        readonly firstIdx: number;
+        readonly endIdx: number;
+    }>;
+    /** Reduce ALL entries to a single value. */
+    aggregate<R>(fn: (acc: R, entry: CombinedNarrativeEntry) => R, initial: R): R;
+    /** Reduce entries, optionally filtered to a set of visible runtimeStageIds. */
+    accumulate<R>(fn: (acc: R, entry: CombinedNarrativeEntry) => R, initial: R, keys?: ReadonlySet<string>): R;
+    /** Progressive reveal: entries whose runtimeStageId is in the visible set. */
+    getEntriesUpTo(visibleIds: ReadonlySet<string>): CombinedNarrativeEntry[];
     /** Clears all state. Called automatically before each run. */
     clear(): void;
     private incrementStageCounter;

package/dist/types/lib/memory/TransactionBuffer.d.ts

@@ -23,7 +23,60 @@ export declare class TransactionBuffer {
     /** Read current value at path (includes uncommitted changes). */
     get(path: (string | number)[], defaultValue?: any): any;
     /**
-     * Flush all staged mutations and return the commit bundle.
+     * Flush all staged mutations and return the commit bundle — recording the
+     * stage's NET CHANGE, not its raw write log.
+     *
+     * ── WHY (the defect this fixes) ─────────────────────────────────────────
+     * Previously every `set`/`merge` was recorded verbatim, so the commit bundle
+     * was a log of *operations* rather than *changes*. Two operations produce no
+     * net change yet were still committed as "mutations":
+     *
+     *   1. No-op write   — writing a key the value it already holds (e.g. an
+     *                      agent context slot re-emitting identical content every
+     *                      turn). base K=1, stage writes K=1.
+     *   2. Write-revert  — changing then restoring a key within one stage.
+     *                      base K=1, stage writes K=2 then K=1.
+     *
+     * Recording these as mutations (a) bloated causal slicing / backtracking with
+     * spurious dependencies on intermediate values that never reach final state,
+     * and (b) made downstream "what changed here?" consumers light up stages that
+     * changed nothing — most visibly the lens highlight flagging every slot.
+     *
+     * ── HOW ─────────────────────────────────────────────────────────────────
+     * At commit we hold BOTH `baseSnapshot` (state when the stage began) and
+     * `workingCopy` (state after all its writes). For each path the stage touched
+     * we keep it in the bundle ONLY if its final value differs from the base
+     * value ({@link deepEqual}). No-op AND write-revert paths drop out, because
+     * both compare equal to base. This is a single net-delta diff at commit time
+     * — one deep compare per touched path, O(changed state), paid once per stage
+     * (NOT per write). A naive per-write deep-equal skip would be more expensive
+     * and would still miss write-revert (the intermediate write differs from the
+     * value present at the moment of writing).
+     *
+     * ── TWO HONEST TIERS (by design — do not "unify" them) ──────────────────
+     *   • commit (here)   = CHANGE-level — truthful net delta. Feeds the commit
+     *                       log, causal chain, narrative, and the lens highlight.
+     *   • `onWrite` event = OP-level — fires on EVERY write attempt regardless of
+     *                       net change. Feeds metrics / behavioural observability
+     *                       (a debugger wants to see "wrote 2, then reverted").
+     * `onWrite` is unchanged by this method; only the COMMIT becomes change-only.
+     *
+     * ── EMPTY COMMITS ARE INTENTIONAL ───────────────────────────────────────
+     * A stage that nets no change commits an EMPTY patch — NOT nothing.
+     * {@link StageContext.commit} still records the bundle unconditionally, so
+     * every executed stage remains a time-travel cursor stop (its `runtimeStageId`
+     * marker is preserved); only its PATCH is empty. This is what keeps the
+     * commit-indexed slider stable while making the highlight truthful.
+     *
+     * ── KNOWN LIMITATIONS / FUTURE ──────────────────────────────────────────
+     *   • Explicit key DELETION is still unrepresentable in MemoryPatch (a removed
+     *     key cannot be expressed). Setting a key to `undefined` is treated as a
+     *     change (value differs from base), not a deletion. Tracked for a future
+     *     `delete` verb.
+     *   • Array-merge dedup in {@link deepSmartMerge} still uses reference equality
+     *     (`new Set`), so deep-equal *objects* in a merged array are not deduped.
+     *     Orthogonal to this change; tracked separately.
+     *
      * Resets the buffer to empty state after commit.
      */
     commit(): {
@@ -35,4 +88,17 @@ export declare class TransactionBuffer {
             verb: 'set' | 'merge';
         }[];
     };
+    /**
+     * Rebuild overwrite / updates / trace keeping ONLY paths whose final value
+     * differs from the base value — i.e. the stage's net change. See
+     * {@link TransactionBuffer.commit} for the rationale.
+     *
+     * Paths are compared at the exact granularity they were written (each trace
+     * entry's path), against `workingCopy` (final) vs `baseSnapshot` (start).
+     * Surviving `set` paths copy their final value from `overwritePatch`;
+     * surviving `merge` paths copy their accumulated delta from `updatePatch` —
+     * preserving the set-vs-merge verb so replay ({@link applySmartMerge}) is
+     * byte-for-byte identical to recording only the real changes.
+     */
+    private toChangeOnlyPayload;
 }

package/dist/types/lib/memory/utils.d.ts

@@ -57,6 +57,35 @@ export declare function redactPatch(patch: MemoryPatch, redactedSet: Set<string>
  * Normalises an array path into a stable string key using DELIM.
  */
 export declare function normalisePath(path: (string | number)[]): string;
+/**
+ * Structural deep equality for committed-state values.
+ *
+ * Used by {@link TransactionBuffer} to decide whether a stage actually CHANGED
+ * a path or merely re-wrote / reverted it to the value it already held (a
+ * "no-op write"). Committed state is JSON-shaped — it must survive
+ * `structuredClone` — so this only needs to handle the shapes that can reach a
+ * commit: primitives, arrays, and plain objects.
+ *
+ * Semantics:
+ *   - reference / identical-primitive short-circuits first (cheap fast path)
+ *   - `NaN` equals `NaN` (primitive compare falls back to `Object.is`)
+ *   - arrays: equal length AND deep-equal element-wise (order-sensitive)
+ *   - objects: identical own-key set AND deep-equal per key
+ *   - mismatched kinds (array vs object, object vs null) → not equal
+ *
+ * Cost & safety:
+ *   - Allocates NOTHING but transient `Object.keys` arrays — no clones. It is
+ *     strictly cheaper than the `structuredClone` the commit already performs.
+ *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /
+ *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded
+ *     by the value's own size.
+ *   - Assumes ACYCLIC, JSON-shaped values — the same contract the memory layer
+ *     already relies on (committed state is `structuredClone`d and must be
+ *     JSON-serialisable for checkpoints). A cyclic value is out of contract
+ *     here exactly as it is for checkpointing; dev mode flags cycles at write
+ *     time via `ScopeFacade.setValue`.
+ */
+export declare function deepEqual(a: any, b: any): boolean;
 /**
  * Deep union merge helper.
  * - Arrays (non-empty): union without duplicates (encounter order preserved)

package/dist/types/lib/recorder/InOutRecorder.d.ts

@@ -61,7 +61,6 @@
  * ```
  */
 import type { FlowRecorder, FlowRunEvent, FlowSubflowEvent } from '../engine/narrative/types.js';
-import { SequenceRecorder } from './SequenceRecorder.js';
 export type InOutPhase = 'entry' | 'exit';
 /** Synthetic id for the top-level run's boundary pair. */
 export declare const ROOT_SUBFLOW_ID = "__root__";
@@ -120,21 +119,22 @@ export interface InOutRecorderOptions {
 export declare function inOutRecorder(options?: InOutRecorderOptions): InOutRecorder;
 /**
  * Stateful accumulator that watches `FlowRecorder` chart-boundary events
- * (run start/end + subflow entry/exit) and emits `InOutEntry` records to
- * its underlying `SequenceRecorder` storage.
+ * (run start/end + subflow entry/exit) and pushes `InOutEntry` records to
+ * its composed `SequenceStore` (Convention 1 — one purpose per recorder).
  *
  * Attach via `executor.attachCombinedRecorder(recorder)` — footprintjs
  * detects the `FlowRecorder` method shape and routes events.
  */
-export declare class InOutRecorder extends SequenceRecorder<InOutEntry> implements FlowRecorder {
+export declare class InOutRecorder implements FlowRecorder {
     readonly id: string;
+    /** 1:N ordered storage with per-step index (Convention 1 — composed). */
+    private readonly store;
     constructor(options?: InOutRecorderOptions);
     onRunStart(event: FlowRunEvent): void;
     onRunEnd(event: FlowRunEvent): void;
     onSubflowEntry(event: FlowSubflowEvent): void;
     onSubflowExit(event: FlowSubflowEvent): void;
-    /** All entries in execution order (entry+exit interleaved).
-     *  Alias for `getEntries()` with domain-clearer naming. */
+    /** All entries in execution order (entry+exit interleaved). */
     getBoundaries(): InOutEntry[];
     /** Entry/exit pair for one chart execution.
      *  Returns `{ entry, exit }` — `exit` is `undefined` for in-progress / paused
@@ -148,6 +148,17 @@ export declare class InOutRecorder extends SequenceRecorder<InOutEntry> implemen
      *  for slider / scrubbing UIs. The top-level run's entry is the first
      *  step (depth 0). */
     getSteps(): InOutEntry[];
+    /** O(1) lookup: all boundary entries (both phases) for one runtimeStageId. */
+    getEntriesForStep(runtimeStageId: string): InOutEntry[];
+    /** Pre-built per-step range index — O(1) lookups for time-travel scrubbing. */
+    getEntryRanges(): ReadonlyMap<string, {
+        readonly firstIdx: number;
+        readonly endIdx: number;
+    }>;
+    /** Progressive reveal: boundaries whose runtimeStageId is in the visible set. */
+    getEntriesUpTo(visibleIds: ReadonlySet<string>): InOutEntry[];
+    /** Clear all stored boundaries — called by the executor before each run(). */
+    clear(): void;
     /** The root run's entry/exit pair, if the run has started.
      *  Convenience for consumers that want to bracket the timeline by the
      *  outermost in/out. */

package/dist/types/lib/recorder/QualityRecorder.d.ts

@@ -4,7 +4,8 @@
  * Collects quality scores during traversal (accumulate pattern).
  * After execution, use qualityTrace() to backtrack from any low-scoring step.
  *
- * Extends KeyedRecorder<QualityEntry> for O(1) lookup and standard operations:
+ * Composes a `KeyedStore<QualityEntry>` for O(1) lookup and standard operations
+ * (Convention 1 — one purpose per recorder):
  *   - **Translate**: `getByKey('call-llm#5')` — quality at this step
  *   - **Accumulate**: progressive quality up to slider position
  *   - **Aggregate**: overall pipeline quality score
@@ -30,7 +31,6 @@
  * ```
  */
 import type { ReadEvent, ScopeRecorder, StageEvent, WriteEvent } from '../scope/types.js';
-import { KeyedRecorder } from './KeyedRecorder.js';
 import type { RecorderOperation } from './RecorderOperation.js';
 /** Per-step quality data stored by QualityRecorder. */
 export interface QualityEntry {
@@ -69,10 +69,12 @@ export interface QualityRecorderOptions {
     /** Preferred UI operation. Defaults to 'accumulate' (progressive quality). */
     preferredOperation?: RecorderOperation;
 }
-export declare class QualityRecorder extends KeyedRecorder<QualityEntry> implements ScopeRecorder {
+export declare class QualityRecorder implements ScopeRecorder {
     private static _counter;
     readonly id: string;
     readonly preferredOperation: RecorderOperation;
+    /** 1:1 per-step storage (Convention 1 — composed, not inherited). */
+    private readonly store;
     private readonly scoringFn;
     private currentRuntimeStageId;
     private currentStageId;
@@ -84,6 +86,18 @@ export declare class QualityRecorder extends KeyedRecorder<QualityEntry> impleme
     onRead(event: ReadEvent): void;
     onWrite(event: WriteEvent): void;
     onStageEnd(event: StageEvent): void;
+    /** Translate: quality entry for a specific runtimeStageId. */
+    getByKey(runtimeStageId: string): QualityEntry | undefined;
+    /** All per-step quality entries as a read-only Map (insertion-ordered). */
+    getMap(): ReadonlyMap<string, QualityEntry>;
+    /** All per-step quality entries (insertion-ordered). */
+    values(): QualityEntry[];
+    /** Number of scored steps. */
+    get size(): number;
+    /** Aggregate: reduce ALL scored steps to a single value. */
+    aggregate<R>(fn: (acc: R, entry: QualityEntry, key: string) => R, initial: R): R;
+    /** Accumulate: reduce scored steps up to a slider position. */
+    accumulate<R>(fn: (acc: R, entry: QualityEntry, key: string) => R, initial: R, keys?: ReadonlySet<string>): R;
     /** Overall quality score — average of all step scores. */
     getOverallScore(): number;
     /** Find the lowest-scoring step. */

package/dist/types/lib/recorder/RecorderOperation.d.ts

@@ -4,9 +4,9 @@
  * Data is collected during the single DFS traversal. The consumer chooses the
  * operation at READ time:
  *
- * | Operation   | KeyedRecorder method     | SequenceRecorder method        | Use case                    |
+ * | Operation   | KeyedStore method        | SequenceStore method           | Use case                    |
  * |-------------|--------------------------|--------------------------------|-----------------------------|
- * | Translate   | `getByKey(id)`           | `getEntriesForStep(id)`        | Per-step detail             |
+ * | Translate   | `get(id)`                | `getByKey(id)`                 | Per-step detail             |
  * | Accumulate  | `accumulate(fn, init, k)` | `accumulate(fn, init, k)`     | Running total up to slider  |
  * | Aggregate   | `aggregate(fn, init)`    | `aggregate(fn, init)`          | Grand total for dashboards  |
  *

package/dist/types/lib/recorder/index.d.ts

@@ -1,9 +1,6 @@
 export { BoundaryStateStore } from './BoundaryStateStore.js';
 export { KeyedStore } from './KeyedStore.js';
 export { SequenceStore } from './SequenceStore.js';
-export { BoundaryStateTracker } from './BoundaryStateTracker.js';
-export { KeyedRecorder } from './KeyedRecorder.js';
-export { SequenceRecorder } from './SequenceRecorder.js';
 export type { CombinedRecorder } from './CombinedRecorder.js';
 export { hasEmitRecorderMethods, hasFlowRecorderMethods, hasRecorderMethods, isFlowEvent } from './CombinedRecorder.js';
 export type { CompositeSnapshot } from './CompositeRecorder.js';

package/dist/types/lib/recorder/qualityTrace.d.ts

@@ -14,8 +14,11 @@
  * ```
  */
 import type { CommitBundle } from '../memory/types.js';
-import type { KeyedRecorder } from './KeyedRecorder.js';
 import type { QualityEntry } from './QualityRecorder.js';
+/** Minimal per-step quality lookup — satisfied by `QualityRecorder` (structural, decoupled). */
+export interface QualityLookup {
+    getByKey(runtimeStageId: string): QualityEntry | undefined;
+}
 /** A single frame in the quality stack trace. */
 export interface QualityFrame {
     runtimeStageId: string;
@@ -44,7 +47,7 @@ export interface QualityStackTrace {
  * @param startId          runtimeStageId to start from
  * @param maxDepth         Maximum backtracking depth (default: 20)
  */
-export declare function qualityTrace(commitLog: CommitBundle[], qualityRecorder: KeyedRecorder<QualityEntry>, startId: string, maxDepth?: number): QualityStackTrace;
+export declare function qualityTrace(commitLog: CommitBundle[], qualityRecorder: QualityLookup, startId: string, maxDepth?: number): QualityStackTrace;
 /**
  * Format a QualityStackTrace as human-readable text.
  */

package/dist/types/lib/runner/ExecutionRuntime.d.ts

@@ -17,7 +17,7 @@ import type { CommitBundle, StageSnapshot } from '../memory/types.js';
 export interface RecorderSnapshot {
     id: string;
     name: string;
-    /** ScopeRecorder type and pattern description (e.g., "Translator (KeyedRecorder) — per-step token usage"). */
+    /** ScopeRecorder type and pattern description (e.g., "Translator (KeyedStore) — per-step token usage"). */
     description?: string;
     /** Preferred read-time operation — hints the UI about which view to show prominently. */
     preferredOperation?: 'translate' | 'accumulate' | 'aggregate';

package/dist/types/lib/scope/recorders/MetricRecorder.d.ts

@@ -2,7 +2,9 @@
  * MetricRecorder — per-step timing and execution counts, keyed by runtimeStageId.
  *
  * Stores per-invocation data during traversal. Aggregated views computed on read.
- * Extends KeyedRecorder<StepMetrics> for O(1) lookup and standard operations.
+ * Composes a `KeyedStore<StepMetrics>` for O(1) lookup and standard operations
+ * (Convention 1 — one purpose per recorder: this is the ScopeRecorder; the store
+ * is the storage).
  *
  * @example
  * ```typescript
@@ -20,7 +22,6 @@
  * metric.accumulate((sum, m) => sum + m.duration, 0, visibleKeys);
  * ```
  */
-import { KeyedRecorder } from '../../recorder/KeyedRecorder.js';
 import type { RecorderOperation } from '../../recorder/RecorderOperation.js';
 import type { CommitEvent, PauseEvent, ReadEvent, ScopeRecorder, StageEvent, WriteEvent } from '../types.js';
 /** Per-invocation metrics for a single execution step. */
@@ -67,10 +68,12 @@ export interface MetricRecorderOptions {
     /** Preferred UI operation. Defaults to 'aggregate' (dashboard totals). */
     preferredOperation?: RecorderOperation;
 }
-export declare class MetricRecorder extends KeyedRecorder<StepMetrics> implements ScopeRecorder {
+export declare class MetricRecorder implements ScopeRecorder {
     private static _counter;
     readonly id: string;
     readonly preferredOperation: RecorderOperation;
+    /** 1:1 per-step storage (Convention 1 — composed, not inherited). */
+    private readonly store;
     private stageStartTimes;
     private currentRuntimeStageId;
     private stageFilter?;
@@ -78,6 +81,18 @@ export declare class MetricRecorder extends KeyedRecorder<StepMetrics> implement
     private shouldRecord;
     /** Get or create the StepMetrics for the current stage. */
     private current;
+    /** Translate: per-step metrics by runtimeStageId. */
+    getByKey(runtimeStageId: string): StepMetrics | undefined;
+    /** All per-step metrics as a read-only Map (insertion-ordered). */
+    getMap(): ReadonlyMap<string, StepMetrics>;
+    /** All per-step metrics (insertion-ordered). */
+    values(): StepMetrics[];
+    /** Number of recorded steps. */
+    get size(): number;
+    /** Aggregate: reduce ALL steps to a single value (dashboards, totals). */
+    aggregate<R>(fn: (acc: R, entry: StepMetrics, key: string) => R, initial: R): R;
+    /** Accumulate: reduce steps up to a slider position (progressive view). */
+    accumulate<R>(fn: (acc: R, entry: StepMetrics, key: string) => R, initial: R, keys?: ReadonlySet<string>): R;
     onStageStart(event: StageEvent): void;
     onRead(event: ReadEvent): void;
     onWrite(event: WriteEvent): void;

package/dist/types/trace.d.ts

@@ -41,9 +41,6 @@ export { KeyedStore } from './lib/recorder/KeyedStore.js';
 export { SequenceStore } from './lib/recorder/SequenceStore.js';
 export type { RangeEntry, RangeToken } from './lib/recorder/CommitRangeIndex.js';
 export { CommitRangeIndex } from './lib/recorder/CommitRangeIndex.js';
-export { KeyedRecorder } from './lib/recorder/KeyedRecorder.js';
-export { SequenceRecorder } from './lib/recorder/SequenceRecorder.js';
-export { BoundaryStateTracker } from './lib/recorder/BoundaryStateTracker.js';
 export type { Topology, TopologyEdge, TopologyIncomingKind, TopologyNode, TopologyRecorderOptions, } from './lib/recorder/TopologyRecorder.js';
 export { TopologyRecorder, topologyRecorder } from './lib/recorder/TopologyRecorder.js';
 export type { InOutEntry, InOutPhase, InOutRecorderOptions } from './lib/recorder/InOutRecorder.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "footprintjs",
-  "version": "6.1.2",
+  "version": "7.1.0",
   "description": "Explainable backend flows — automatic causal traces, decision evidence, and MCP tool generation for AI agents",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",