footprintjs 9.0.0 → 9.2.0

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

@@ -11,7 +11,7 @@ import { DiagnosticCollector } from './DiagnosticCollector.js';
 import { EventLog } from './EventLog.js';
 import { SharedMemory } from './SharedMemory.js';
 import { TransactionBuffer } from './TransactionBuffer.js';
-import type { FlowControlType, StageSnapshot } from './types.js';
+import type { FlowControlType, ReadTrackingMode, StageSnapshot } from './types.js';
 export declare class StageContext {
     private sharedMemory;
     /**
@@ -28,6 +28,13 @@ export declare class StageContext {
      */
     private redactedSharedMemory?;
     private buffer?;
+    /**
+     * Committed-state view captured at this stage's FIRST touch (first read OR
+     * first write) — held by REFERENCE, never cloned. See
+     * {@link firstTouchState} for the algorithm and the immutability invariant
+     * that makes a bare reference safe.
+     */
+    private stateView?;
     private eventLog?;
     stageName: string;
     /** Unique stage identifier from the builder (matches spec node id). */
@@ -50,6 +57,17 @@ export declare class StageContext {
     private _stageWrites;
     /** Tracks user-level reads (pre-namespace) for the memory view. */
     private _stageReads;
+    /**
+     * How tracked reads are recorded into `_stageReads` (#14). Default `'full'`
+     * preserves the historical per-read `structuredClone`. Inherited by every
+     * context created via {@link createNext} / {@link createChild} (same
+     * propagation pattern as the redacted mirror), and pushed into subflow
+     * root contexts by `SubflowExecutor`. Affects ONLY the snapshot's
+     * `stageReads` payload — `ScopeRecorder.onRead` (and therefore narrative)
+     * is dispatched at the scope tier and never cloned, so it is identical in
+     * every mode.
+     */
+    private readTracking;
     /** Observer called after commit() — used by ScopeFacade to fire ScopeRecorder.onCommit. */
     private _commitObserver?;
     constructor(runId: string, name: string, stageId: string, sharedMemory: SharedMemory, branchId?: string, eventLog?: EventLog, isDecider?: boolean);
@@ -66,9 +84,69 @@ export declare class StageContext {
     useRedactedMirror(mirror: SharedMemory): void;
     /** Returns the redacted mirror if installed, else undefined. */
     getRedactedSharedMemory(): SharedMemory | undefined;
-    /** Lazily creates the transaction buffer on the stage's FIRST state access —
-     *  reads included, so read-only stages currently pay the clone cost too.
-     *  (Truly lazy-on-write is backlog Phase-3 #13.) */
+    /**
+     * Set the read-tracking policy for this context (#14). Called at the root
+     * by `ExecutionRuntime.useReadTracking()` (plumbed from
+     * `FlowChartExecutor`); descendants inherit via `createNext`/`createChild`,
+     * and `SubflowExecutor` pushes the parent context's mode into each subflow
+     * root so nested charts inherit too.
+     */
+    useReadTracking(mode: ReadTrackingMode): void;
+    /** Returns the active read-tracking policy (used for subflow propagation). */
+    getReadTracking(): ReadTrackingMode;
+    /**
+     * ── The first-touch state view (#13) ────────────────────────────────────
+     *
+     * WHAT: returns the committed shared state as it was at this stage's FIRST
+     * touch (first read or first write), capturing the reference on first call.
+     * Serves two consumers: reads before the first write ({@link readState})
+     * and the transaction buffer's diff base ({@link getTransactionBuffer}).
+     *
+     * WHY A BARE REFERENCE IS SAFE — the invariant this rests on: committed
+     * state is immutable-after-swap. `SharedMemory.applyPatch` routes through
+     * `applySmartMerge`, which `structuredClone`s the current state, mutates
+     * only the clone, and swaps `SharedMemory.context` to it — the object a
+     * stage captured here is never edited afterwards. (`SharedMemory.setValue`/
+     * `updateValue` DO mutate in place, but have no callers during traversal;
+     * every runtime write reaches state through a stage commit's `applyPatch`.)
+     * Holding the reference therefore gives this stage a stable snapshot at
+     * zero cost — no clone, which is the entire point of #13.
+     *
+     * WHY FIRST TOUCH, not first write: the pre-#13 eager engine cloned the
+     * state into the buffer at the stage's first ACCESS, anchoring both its
+     * snapshot reads and its commit baseline (the net-change diff base) there.
+     * #13's first cut anchored the lazy buffer at first WRITE — observably
+     * different when something else commits in the gap between this stage's
+     * first read and its first write. That gap is REACHABLE: fork siblings are
+     * namespace-isolated for run-scoped keys (each child writes under
+     * `runs/<childId>/`), but ROOT-level keys are shared — written via
+     * `setGlobal` from consumer scope code and, critically, by
+     * `SubflowInputMapper`'s output mapping (`parentContext.setGlobal`), which
+     * is exactly what runs when a subflow is a fork branch. A sibling's
+     * root-key commit landing in the gap would shift this stage's diff base,
+     * making its CommitBundle record a phantom change (or swallow a real one)
+     * relative to the eager engine. Anchoring the view at first touch restores
+     * the EXACT eager semantics — sequential AND parallel — at zero clone cost.
+     *
+     * Read visibility is two-tier, matching eager byte-for-byte: keys present
+     * in the view at first touch read repeatably from it; keys ABSENT from it
+     * fall back to LIVE state (the eager engine's exact fallback — a
+     * mid-flight sibling root-key write was always visible to reads, and
+     * stays visible; only the DIFF BASE is pinned).
+     */
+    private firstTouchState;
+    /** Lazily creates the transaction buffer on the stage's FIRST WRITE (#13).
+     *
+     *  Reads NEVER construct it: read-your-writes only matters once a staged
+     *  write exists, so before that {@link getValue}/{@link getValueDirect}
+     *  serve from the first-touch state view and {@link commit} records an
+     *  empty bundle — all with ZERO `structuredClone`s of the shared state.
+     *
+     *  The buffer's base is the FIRST-TOUCH view, NOT the live state at write
+     *  time: under parallel forks a sibling may have committed between this
+     *  stage's first read and this write, and the net-change diff base must
+     *  stay anchored at first touch to match the eager engine — see
+     *  {@link firstTouchState}. */
     getTransactionBuffer(): TransactionBuffer;
     /** Builds an absolute path inside the shared memory (run namespace). */
     private withNamespace;
@@ -82,7 +160,27 @@ export declare class StageContext {
     updateGlobalContext(key: string, value: unknown): void;
     appendToArray(path: string[], key: string, items: unknown[], description?: string): void;
     mergeObject(path: string[], key: string, obj: Record<string, unknown>, description?: string): void;
-    getValue(path: string[], key?: string, description?: string): any;
+    /** Buffer-aware read, mirroring the eager engine's read order byte-for-byte:
+     *
+     *    1. staged writes + first-touch snapshot — `buffer.get` over its
+     *       workingCopy when the buffer exists, else `nativeGet` over the
+     *       zero-clone state view (the buffer's base IS that view, so the two
+     *       tiers agree on content);
+     *    2. LIVE state via `sharedMemory.getValue` for keys absent from the
+     *       snapshot — including its run→global namespace fallback. The eager
+     *       engine had this exact live fallback for snapshot-missing keys;
+     *       byte-identity over purity.
+     *
+     *  Reads never construct the buffer (#13): a stage that never writes
+     *  performs zero clones of the shared state. */
+    private readState;
+    /**
+     * Tracked read. The returned value is BORROWED — see the contract on
+     * `ScopeFacade.getValue`. Read-tracking cost is policy-gated (#14):
+     * `'full'` clones the value into `_stageReads` (historical default),
+     * `'summary'` records a cheap marker, `'off'` records nothing.
+     */
+    getValue(path: string[], key?: string, description?: string): unknown;
     /** Read state without tracking in _stageReads or paying structuredClone cost.
      *  Used by ScopeFacade.getValueSilent() for array proxy internal operations. */
     getValueDirect(path: string[], key?: string): unknown;
@@ -97,6 +195,16 @@ export declare class StageContext {
         operation: 'set' | 'update' | 'delete';
     }>) => void): void;
     commit(): void;
+    /**
+     * Create (or return) this context's linked successor.
+     *
+     * MEMOIZED: the first call creates `this.next`; every later call returns
+     * that SAME context and IGNORES its arguments. In normal traversal each
+     * context advances exactly once, so the memo never bites — but a caller
+     * expecting a fresh context for different `stageName`/`stageId` args gets
+     * the old one silently. Dev mode (`enableDevMode()`) warns on that
+     * mismatch (backlog B4).
+     */
     createNext(path: string, stageName: string, stageId: string, isDecider?: boolean): StageContext;
     createChild(runId: string, branchId: string, stageName: string, stageId: string, isDecider?: boolean): StageContext;
     createDecider(path: string, stageName: string, stageId: string): StageContext;

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

@@ -1,11 +1,21 @@
 /**
- * TransactionBuffer — Transactional write buffer for stage mutations
+ * TransactionBuffer — Per-stage STAGING buffer for state mutations
  *
- * Collects writes during execution and commits them atomically.
- * Like a database transaction buffer:
- * - Changes staged here before being committed to SharedMemory
- * - Enables read-after-write consistency within a stage
- * - Records operation trace for deterministic replay
+ * What it IS: a staging buffer with read-your-writes and net-change commits.
+ * - Changes are staged here during stage execution and flushed to
+ *   SharedMemory in ONE batch per stage (`commit()`) — other stages and
+ *   parallel siblings never observe a stage's half-finished writes.
+ * - Read-after-write consistency within a stage — a stage sees its own
+ *   staged writes immediately.
+ * - `commit()` records the stage's NET change (see {@link commit}), plus an
+ *   operation trace for deterministic replay.
+ *
+ * What it is NOT: a rollback mechanism. Despite the name, there is no
+ * abort/rollback path — when a stage THROWS, the engine still commits
+ * everything staged so far before re-throwing (commit-on-error in
+ * `FlowchartTraverser`). That is deliberate: the audit trail must record
+ * what the failing stage changed. Do not rely on "stage failed → its
+ * writes vanished".
  */
 import type { MemoryPatch } from './types.js';
 export declare class TransactionBuffer {

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

@@ -9,5 +9,6 @@ export { EventLog } from './EventLog.js';
 export { SharedMemory } from './SharedMemory.js';
 export { StageContext } from './StageContext.js';
 export { TransactionBuffer } from './TransactionBuffer.js';
-export type { CommitBundle, FlowControlType, FlowMessage, MemoryPatch, ScopeFactory, StageSnapshot, TraceEntry, } from './types.js';
+export type { CommitBundle, FlowControlType, FlowMessage, MemoryPatch, ReadSummaryMarker, ReadTrackingMode, ScopeFactory, StageSnapshot, TraceEntry, } from './types.js';
+export { READ_PREVIEW_LENGTH } from './types.js';
 export { applySmartMerge, deepSmartMerge, DELIM, getNestedValue, getRunAndGlobalPaths, normalisePath, redactPatch, setNestedValue, updateNestedValue, updateValue, } from './utils.js';

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

@@ -45,6 +45,47 @@ export interface FlowMessage {
     iteration?: number;
     timestamp?: number;
 }
+/**
+ * Policy for how tracked reads are recorded into `StageSnapshot.stageReads`.
+ *
+ * - `'full'` (default) — every tracked read `structuredClone`s the value into
+ *   the stage's read view. Byte-identical to the historical behavior; this is
+ *   what snapshot consumers (lens, agentfootprint) see today.
+ * - `'summary'` — reads record a cheap {@link ReadSummaryMarker} (type + size
+ *   proxy + short preview) instead of the cloned value. O(1)-ish per read —
+ *   no value clone, no serialization of large objects.
+ * - `'off'` — reads are not recorded at all; `stageReads` is absent from the
+ *   snapshot. Zero per-read cost. Values are still readable, and the
+ *   `ScopeRecorder.onRead` event still fires (it passes the live reference and
+ *   never cloned) — so narrative output is identical in every mode. The policy
+ *   scopes ONLY the snapshot's `stageReads` payload.
+ *
+ * Set via `new FlowChartExecutor(chart, { readTracking })` or
+ * `executor.setReadTracking(mode)` (before `run()`).
+ */
+export type ReadTrackingMode = 'full' | 'summary' | 'off';
+/**
+ * Marker recorded in `StageSnapshot.stageReads` under `readTracking: 'summary'`.
+ *
+ * Honest cost note: `size` is a cheap proxy (string length / array length /
+ * object key count), NOT a serialized byte count — computing real byte size
+ * would require an O(value) serialization, which is exactly the cost the
+ * summary mode removes. `preview` is only produced for primitives and strings
+ * (first {@link READ_PREVIEW_LENGTH} characters); objects and arrays carry no
+ * preview for the same reason.
+ */
+export interface ReadSummaryMarker {
+    /** Discriminant — lets snapshot consumers detect marker entries. */
+    __readSummary: true;
+    /** `typeof` result, refined to 'array' / 'null' for objects. */
+    type: 'string' | 'number' | 'boolean' | 'bigint' | 'symbol' | 'function' | 'object' | 'array' | 'null';
+    /** Size proxy: string length, array length, or object key count. */
+    size?: number;
+    /** First {@link READ_PREVIEW_LENGTH} chars — primitives and strings only. */
+    preview?: string;
+}
+/** Max characters captured in {@link ReadSummaryMarker.preview}. */
+export declare const READ_PREVIEW_LENGTH = 80;
 /** Serialisable representation of a stage's state (for debugging / visualisation). */
 export type StageSnapshot = {
     id: string;
@@ -59,7 +100,10 @@ export type StageSnapshot = {
     isFork?: boolean;
     /** User-level writes made by this stage (pre-namespace keys → values). */
     stageWrites?: Record<string, unknown>;
-    /** User-level reads made by this stage (pre-namespace keys → values at read time). */
+    /** User-level reads made by this stage (pre-namespace keys → values at read
+     *  time). Shape depends on {@link ReadTrackingMode}: cloned values under
+     *  `'full'` (default), {@link ReadSummaryMarker}s under `'summary'`, absent
+     *  under `'off'`. */
     stageReads?: Record<string, unknown>;
     logs: Record<string, unknown>;
     errors: Record<string, unknown>;

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

@@ -61,7 +61,8 @@ import type { EmitRecorder } from './EmitRecorder.js';
  * Method names that appear on BOTH `ScopeRecorder` and `FlowRecorder` but with
  * different event payload types. For these, a `CombinedRecorder` declares
  * ONE handler that receives the union of both payloads — consumers
- * discriminate on `traversalContext`, which only control-flow events carry.
+ * discriminate with the exported `isFlowEvent()` helper (explicit `channel`
+ * discriminant, with a legacy pipelineId-absence fallback).
  */
 type SharedLifecycleOverlap = 'onError' | 'onPause' | 'onResume';
 /** Lifecycle hooks (not event-specific) that both interfaces share identically. */
@@ -81,8 +82,8 @@ type SharedLifecycle = 'id' | 'clear' | 'toSnapshot';
  * Both `ScopeRecorder` and `FlowRecorder` declare these with DIFFERENT payload
  * shapes. In a combined recorder, each such handler is called by BOTH
  * channels with its own variant. The parameter type is a union — consumers
- * can either handle both variants uniformly, or discriminate (control-flow
- * variants carry a `traversalContext` field that data-flow variants lack).
+ * can either handle both variants uniformly, or discriminate with
+ * `isFlowEvent()` (explicit `channel` discriminant stamped by the engine).
  *
  * ## Forward compatibility
  *
@@ -110,12 +111,17 @@ export type CombinedRecorder = Partial<Omit<ScopeRecorder, SharedLifecycleOverla
  *
  * ## How it discriminates
  *
- * Scope-channel events extend `RecorderContext`, which carries `pipelineId`.
- * Flow-channel events do not carry `pipelineId` (they carry an optional
- * `traversalContext` instead, but that field is optional and cannot be
- * relied on as a positive signal). We detect the flow variant by the
- * ABSENCE of `pipelineId` — this is schema-stable as long as scope events
- * continue to extend `RecorderContext`.
+ * 1. **Explicit `channel` field first** (backlog B3): every engine-dispatched
+ *    shared-method event is stamped `channel: 'flow'` (control-flow) or
+ *    `channel: 'scope'` (data-flow) at construction. This is the positive,
+ *    schema-robust signal — it survives wrappers that add/strip fields.
+ * 2. **Legacy fallback** for unstamped events (consumer-fabricated tests,
+ *    persisted traces from <9.2): scope-channel events extend
+ *    `RecorderContext`, which carries `pipelineId`; flow-channel events do
+ *    not. The flow variant is detected by the ABSENCE of `pipelineId` —
+ *    schema-stable as long as scope events continue to extend
+ *    `RecorderContext`, but fragile against field-stripping wrappers, which
+ *    is why the explicit discriminant now exists.
  *
  * @example
  * ```ts

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

@@ -12,7 +12,7 @@
 import { EventLog } from '../memory/EventLog.js';
 import { SharedMemory } from '../memory/SharedMemory.js';
 import { StageContext } from '../memory/StageContext.js';
-import type { CommitBundle, StageSnapshot } from '../memory/types.js';
+import type { CommitBundle, ReadTrackingMode, StageSnapshot } from '../memory/types.js';
 /** Snapshot of a single recorder's collected data. */
 export interface RecorderSnapshot {
     id: string;
@@ -63,6 +63,15 @@ export declare class ExecutionRuntime {
      * allocation, no functional difference in the snapshot.
      */
     enableRedactedMirror(): void;
+    /**
+     * Set the read-tracking policy (#14) on the root stage context. Descendant
+     * contexts inherit via `createNext`/`createChild`; subflow root contexts
+     * inherit from their parent-mount context via `SubflowExecutor`. Called by
+     * `FlowChartExecutor.createTraverser()` when the executor's policy is not
+     * the default `'full'` — including the resume path, where it is applied to
+     * the freshly-created continuation root.
+     */
+    useReadTracking(mode: ReadTrackingMode): void;
     /** Preserve the current rootStageContext for snapshots before changing it for resume. */
     preserveSnapshotRoot(): void;
     getPipelines(): string[];

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

@@ -22,6 +22,7 @@ import type { CombinedNarrativeEntry } from '../engine/narrative/narrativeTypes.
 import type { ManifestEntry } from '../engine/narrative/recorders/ManifestFlowRecorder.js';
 import type { FlowRecorder } from '../engine/narrative/types.js';
 import { type ExecutorResult, type RunOptions, type ScopeFactory, type SerializedPipelineStructure, type StageNode, type StreamHandlers, type SubflowResult } from '../engine/types.js';
+import type { ReadTrackingMode } from '../memory/types.js';
 import type { FlowchartCheckpoint } from '../pause/types.js';
 import type { CombinedRecorder } from '../recorder/CombinedRecorder.js';
 import type { EmitRecorder } from '../recorder/EmitRecorder.js';
@@ -63,6 +64,19 @@ export interface FlowChartExecutorOptions<TScope = any> {
     initialContext?: unknown;
     /** Read-only input accessible via `scope.getArgs()` — never tracked or written. */
     readOnlyContext?: unknown;
+    /**
+     * Policy for `StageSnapshot.stageReads` (#14). Default `'full'` — every
+     * tracked read `structuredClone`s the value into the stage's read view
+     * (the historical behavior; what lens/agentfootprint snapshots show).
+     * `'summary'` records a cheap type/size/preview marker per read; `'off'`
+     * records nothing — zero per-read clone cost (reads of large values become
+     * ~free). Narrative and `ScopeRecorder.onRead` are identical in every mode.
+     * Caveat: under `'off'` a stage's snapshot is indistinguishable from one
+     * that read nothing — auditing consumers that need "did it read?" without
+     * the value cost should prefer `'summary'`.
+     * Equivalent to calling `executor.setReadTracking(mode)` before `run()`.
+     */
+    readTracking?: ReadTrackingMode;
     /**
      * Custom error classifier for throttling detection. Return `true` if the
      * error represents a rate-limit or backpressure condition (the executor will
@@ -142,6 +156,13 @@ export declare class FlowChartExecutor<TOut = any, TScope = any> {
      * Must be called before run().
      */
     setRedactionPolicy(policy: RedactionPolicy): void;
+    /**
+     * Set the read-tracking policy for `StageSnapshot.stageReads` (#14).
+     * Must be called before run(). Equivalent to the `readTracking`
+     * constructor option — see {@link FlowChartExecutorOptions.readTracking}
+     * for the mode semantics ('full' default / 'summary' / 'off').
+     */
+    setReadTracking(mode: ReadTrackingMode): void;
     /**
      * Returns a compliance-friendly report of all redaction activity from the
      * most recent run. Never includes actual values.
@@ -243,9 +264,10 @@ export declare class FlowChartExecutor<TOut = any, TScope = any> {
      * on clone failure we sanitize the diagnostic bags (non-cloneable values
      * become '[non-serializable: …]' markers — the live engine bags are never
      * touched) and retry. If the retry STILL fails, the violation is in
-     * consumer-owned data (realistically `pauseData` — a function in shared
-     * state already rejects at stage entry when TransactionBuffer clones the
-     * context) and we throw a DESCRIPTIVE contract error naming the offending
+     * consumer-owned data (realistically `pauseData` — a function can never
+     * reach shared state in the first place: TransactionBuffer clones every
+     * written value at write time, so the offending write already rejected)
+     * and we throw a DESCRIPTIVE contract error naming the offending
      * checkpoint field(s). A naked DataCloneError never escapes.
      *
      * Subflow scope capture (`subflowStates`) survives ONLY on the signal — the

package/dist/types/lib/scope/ScopeFacade.d.ts

@@ -134,7 +134,30 @@ export declare class ScopeFacade {
      *  the existing getValue() contract where user code always receives raw data. */
     getValueSilent(key?: string): unknown;
     getInitialValueFor(key: string): any;
-    getValue(key?: string): any;
+    /**
+     * Tracked read of shared state.
+     *
+     * **Read values are BORROWED — do not mutate them.** Since the lazy buffer
+     * (#13), reads before the stage's first write return references INTO
+     * COMMITTED SHARED STATE, and reads after a write return references into
+     * the stage's private transaction-buffer working copy (the eager engine
+     * returned references into that working copy for ALL reads). Mutating a
+     * returned value in place would corrupt state without a commit record —
+     * write changes back via `setValue`/`updateValue` instead. TypedScope
+     * consumers are safe automatically: the proxy routes every mutation
+     * through `setValue`/`updateValue`/copy-on-write array ops.
+     *
+     * There is deliberately NO dev-mode freeze guard here: deep-freezing a
+     * buffer-served read would freeze the stage's own working copy and make a
+     * legitimate read-then-deep-write throw, and freezing a committed-state
+     * read mutates an object shared with every other consumer of the live
+     * state. See `src/lib/memory/README.md` ("Read values are borrowed").
+     *
+     * Recorder note: the `onRead` event below passes the SAME live reference
+     * (no clone) unless field-level redaction scrubs a copy — recorders must
+     * treat event values as read-only too.
+     */
+    getValue(key?: string): unknown;
     setValue(key: string, value: unknown, shouldRedact?: boolean, description?: string): void;
     updateValue(key: string, value: unknown, description?: string): void;
     deleteValue(key: string, description?: string): void;

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

@@ -38,15 +38,26 @@ export interface ErrorEvent extends RecorderContext {
     error: Error;
     operation: 'read' | 'write' | 'commit';
     key?: string;
+    /**
+     * Explicit channel discriminant — `'scope'` on every engine-dispatched
+     * event. `isFlowEvent()` checks it first (backlog B3); optional so
+     * consumer-fabricated events (tests, replays) remain type-valid and fall
+     * back to the legacy pipelineId-presence heuristic.
+     */
+    channel?: 'scope';
 }
 export interface StageEvent extends RecorderContext {
     duration?: number;
 }
 export interface PauseEvent extends RecorderContext {
     pauseData?: unknown;
+    /** Explicit channel discriminant — see {@link ErrorEvent.channel}. */
+    channel?: 'scope';
 }
 export interface ResumeEvent extends RecorderContext {
     hasInput: boolean;
+    /** Explicit channel discriminant — see {@link ErrorEvent.channel}. */
+    channel?: 'scope';
 }
 /**
  * Declarative redaction configuration — define once, applied everywhere.

package/package.json

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