agentfootprint 10.3.0 → 10.4.0

package/dist/types/lib/trace-toolpack/innerRunRecords.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"innerRunRecords.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/innerRunRecords.ts"],"names":[],"mappings":"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"}

package/dist/types/lib/trace-toolpack/lazyToolpack.d.ts

@@ -1,55 +0,0 @@
-/**
- * lazyTraceToolpack — the toolpack with LATE-BOUND artifacts.
- *
- * `traceToolpack(artifacts)` is a factory over FROZEN artifacts: it
- * precomputes an index and even bakes step-id enums into tool schemas.
- * That is right for the dedicated debugger (the run is already complete
- * when you build it) — and wrong for `.selfExplain()`, where the tools
- * are defined at Agent BUILD time but must read the agent's own *previous
- * completed run*, which changes every turn.
- *
- * This wrapper splits the two lifetimes:
- *
- *   - SCHEMAS are built once from an empty template (artifact-independent —
- *     no id enums, generic descriptions; the same shape `traceToolpack`
- *     itself produces past the enum cap), so the tools can be mounted on
- *     a skill before any run exists.
- *   - EXECUTION resolves `resolve()` per call, builds the REAL toolpack
- *     over the resolved artifacts (memoized by snapshot identity — one
- *     index per completed run, not per call), and delegates through
- *     `callTraceTool` so arg validation matches the eager path.
- *
- * When `resolve()` returns undefined (no completed run yet), every tool
- * answers with an honest, model-visible message instead of throwing —
- * the same #9 philosophy as the toolpack's unknown-id corrections.
- */
-import type { Tool } from '../../core/tools.js';
-import { NO_COMPLETED_RUN_MESSAGE } from './traceToolNames.js';
-import type { TraceToolpackArtifacts, TraceToolpackOptions } from './types.js';
-export { NO_COMPLETED_RUN_MESSAGE };
-/**
- * Model-visible answer when a tool MOUNTED on the catalog has no evidence
- * to serve for this particular run.
- *
- * The lazy pack's shape is fixed at Agent BUILD time — the tool catalog and
- * the builder's name reservation both need to know the list before any run
- * exists — while an artifact bag's OPTIONAL parts (the narrative, the event
- * tail) are decided per run. So a tool can be on the catalog with nothing
- * behind it, and the honest move is to say which switch turns it back on
- * rather than to answer emptily.
- */
-export declare function missingArtifactMessage(toolName: string): string;
-/**
- * Build the toolpack with late-bound artifacts.
- *
- * The template is built over an artifact bag that declares EVERY optional
- * part (an empty narrative, an empty event tail), so the lazy pack mounts
- * the same tool list every time. That fixed list is what the Agent
- * builder's name reservation and the tool catalog are both keyed on — a
- * pack whose shape depended on a run that has not happened yet could not
- * be reserved at build time. When a resolved run turns out not to carry
- * one of those parts, the tool answers with
- * {@link missingArtifactMessage} instead of quietly disappearing.
- */
-export declare function lazyTraceToolpack(resolve: () => TraceToolpackArtifacts | undefined, options?: TraceToolpackOptions): Tool[];
-//# sourceMappingURL=lazyToolpack.d.ts.map

package/dist/types/lib/trace-toolpack/lazyToolpack.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lazyToolpack.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/lazyToolpack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAK/E,OAAO,EAAE,wBAAwB,EAAE,CAAC;AAEpC;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAO/D;AAgBD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,sBAAsB,GAAG,SAAS,EACjD,OAAO,CAAC,EAAE,oBAAoB,GAC7B,IAAI,EAAE,CA4BR"}

package/dist/types/lib/trace-toolpack/openRecording.d.ts

@@ -1,94 +0,0 @@
-/**
- * openRecording — a saved run, reopened as evidence a model can navigate.
- *
- * Pattern: pure adapter. One shape in (`Recording`), one shape out
- *          (`TraceToolpackArtifacts`). No engine, no agent, no I/O.
- * Role:    the door between the two halves of this library that already
- *          knew about each other's data and had no way to say so.
- *
- * `recordRun(agent)` freezes a run into `{ snapshot, events, structure }` —
- * the shape a viewer reads. The trace toolpack reads a different shape.
- * Until now, a team with a recording on disk from last Tuesday and a
- * question about it had to reassemble the bag by hand, which meant
- * reassembling it differently in every integration and losing the
- * narrative and the events on the way.
- *
- *   const recording = JSON.parse(fs.readFileSync('run.json', 'utf8'));
- *   const tools = traceToolpack(openRecording(recording));
- *   await callTraceTool(tools, 'run_overview');
- *
- * WHAT SURVIVES THE ROUND TRIP, AND WHAT DOES NOT
- * ───────────────────────────────────────────────
- * A recording is JSON. Everything the toolpack needs from the snapshot
- * survives that (the commit log, the execution tree, shared state, the
- * mode discriminants) and so do the events. Two things do not:
- *
- *   - `controlDeps` is a LOOKUP FUNCTION built by a recorder that watched
- *     the run happen. A function does not serialize, and nothing in a
- *     finished recording can rebuild one. So slices opened over a
- *     recording carry the toolpack's existing "⚠ control edges
- *     unavailable" marker — the honest answer, already written.
- *   - The narrative survives only if it was ATTACHED. `recordRun`
- *     deliberately attaches no narrative recorder (see its header), so a
- *     recording made without `narrative()` has none, and `read_narrative`
- *     is simply not mounted. This function lifts it from the snapshot's
- *     recorder rows when it IS there.
- *
- * `structure` — the build-time chart — has no reader in the toolpack: the
- * toolpack navigates what a run DID, and the chart says what it COULD do.
- * It is left on the recording for the viewers that draw it.
- */
-import type { TraceToolpackArtifacts } from './types.js';
-import { type PackedRecording } from '../../recorders/observability/recordingPack.js';
-/**
- * The recording shape — structurally the `Recording` that `recordRun`
- * produces, restated here so this module stays a leaf (it must not pull
- * the recorder layer into a pure adapter's import graph). A `Recording`
- * satisfies it by construction.
- */
-export interface OpenableRecording {
-    readonly snapshot: unknown;
-    readonly events?: readonly unknown[];
-    readonly structure?: unknown;
-}
-/** A recorder row as it rides `snapshot.recorders`. */
-interface RecorderRow {
-    readonly id?: string;
-    readonly name?: string;
-    readonly data?: unknown;
-}
-/**
- * The narrative recorder's row: `data` is an array of `{ text, depth }`.
- *
- * @internal Exported for the bug-report bundler, which writes the same lines to
- * `narrative.txt`. One shape-detector, one answer to "is there a narrative in
- * this snapshot?" — two copies would disagree the first time the row changes.
- */
-export declare function narrativeFrom(snapshot: {
-    recorders?: readonly RecorderRow[];
-}): string[] | undefined;
-/**
- * Reopen a saved recording as toolpack artifacts.
- *
- * @param recording the `{ snapshot, events, structure }` bundle from
- *                  `recordRun(...).toRecording()` — live, or parsed back
- *                  from JSON — or the same recording packed
- *                  (`packRecording`), which is expanded first.
- *
- * A packed recording is expanded only when its plain form is within
- * `unpackRecording`'s default bound (`DEFAULT_UNPACK_MAX_BYTES`, 512 MiB): the
- * toolpack previews a value by serializing it, so it walks what it reads as a
- * tree, and a few KB packed can stand for far more than any plain recording
- * could hold. A larger recording you trust is opened by expanding it first,
- * with the bound you choose:
- * `openRecording(unpackRecording(packed, { maxBytes }))`.
- *
- * @throws PackedRecordingTooLargeError for a packed recording over that bound.
- * @throws when the recording carries no usable snapshot. A toolpack over
- *         an empty bag would answer every question with "nothing
- *         happened", which is the one answer a debugging session must
- *         never be given by mistake.
- */
-export declare function openRecording(input: OpenableRecording | PackedRecording): TraceToolpackArtifacts;
-export {};
-//# sourceMappingURL=openRecording.d.ts.map

package/dist/types/lib/trace-toolpack/openRecording.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"openRecording.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/openRecording.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAKH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,gDAAgD,CAAC;AAExD;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,uDAAuD;AACvD,UAAU,WAAW;IACnB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE;IACtC,SAAS,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;CACpC,GAAG,MAAM,EAAE,GAAG,SAAS,CAgBvB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,iBAAiB,GAAG,eAAe,GAAG,sBAAsB,CAyChG"}

package/dist/types/lib/trace-toolpack/selfExplain.d.ts

@@ -1,251 +0,0 @@
-/**
- * selfExplain — the IN-CONVERSATION door over the agent's own trace.
- *
- * `.selfExplain()` on the builder mounts ONE skill plus ONE scoped tool
- * provider. Day to day the tool catalog carries only the skill's
- * activation row — the trace tools are NOT in the skill (skill `tools`
- * land in the static registry, exposed every iteration); they ride a
- * `skillScopedTools` provider gated on the skill's activation, composed
- * with whatever provider the consumer already set. When the user asks a
- * why-question the LLM activates the skill, and the NEXT iteration's
- * catalog gains the trace tools, bound to the agent's own PREVIOUS
- * COMPLETED run.
- *
- * The two pieces here:
- *
- * 1. `SelfExplainBinding` — the late-binding seam, a plain CombinedRecorder
- *    attached like any consumer recorder (zero engine changes):
- *
- *      - capture at `onRunEnd`/`onRunFailed`: the just-finished run's
- *        snapshot becomes the explainable evidence (a FAILED run is
- *        still a completed trace — "why did you fail?" works);
- *      - rotate at `onRunStart`: a FRESH ControlDepRecorder per run. The
- *        retired instance never sees the new run's events, so its live
- *        `asLookup()` survives Convention-4's runId reset — the captured
- *        control edges stay valid for the whole next turn.
- *
- *    B13 safety lives here: `Agent.run()` reassigns its executor at run
- *    START, so resolving artifacts mid-run through `getLastSnapshot()`
- *    would expose the IN-FLIGHT run. Capturing only at terminal flush
- *    means the binding can never serve anything but a completed run.
- *
- *    Keyed PER CONVERSATION (R2-11): one agent instance can serve
- *    many people (`standingAgent({ agent })`), so "the previous completed
- *    run" is asked of the ASKING run's session — the evidence of the last
- *    run that session completed, never whichever run the instance finished
- *    last. A run with no session reads the last run that had none. A tool's
- *    retained inner runs are served through the same key
- *    (`innerRunRecords.ts · innerRunsOfConversation`).
- *
- * 2. `buildSelfExplainSkill` — the skill in two modes:
- *
- *      - INLINE (default): the skill unlocks the trace tools — every name
- *        in `TRACE_TOOL_NAMES` (11 today) — in the main agent's own loop
- *        (same model). The count is deliberately not restated anywhere
- *        that could fall behind the pack.
- *      - DELEGATE: the skill unlocks ONE tool — `explain_run(question)` —
- *        whose execute runs a nested `traceDebugAgent` on the consumer's
- *        chosen (cheaper) provider/model and returns its evidence-cited
- *        answer. The main conversation pays for one tool call; the
- *        trace-walking loop happens at the delegate's price. Loaded via
- *        dynamic import so the builder never statically pulls Agent
- *        through this module (no core ↔ lib cycle).
- */
-import { type CombinedRecorder, type RuntimeSnapshot } from 'footprintjs';
-import type { Injection } from '../injection-engine/types.js';
-import type { AgentOptions } from '../../core/agent/types.js';
-import type { Unsubscribe } from '../../events/dispatcher.js';
-import type { AgentfootprintEvent } from '../../events/registry.js';
-import type { ToolProvider } from '../../tool-providers/types.js';
-import { type InnerRunLookup } from './innerRunRecords.js';
-import type { TraceToolpackArtifacts, TraceToolpackOptions } from './types.js';
-/**
- * How much of a turn's evidence the binding keeps.
- *
- * Both default to TRUE, which is the point: the tools that read them
- * (`read_narrative`, `inspect_tool_call`) are on the catalog either way,
- * and a tool that answers "⚠ no evidence" by default is a tool that
- * teaches the model not to call it. Turn one off when the cost matters
- * more than the answer — a very long-running turn, or a run whose
- * narrative would repeat what the structured tools already say.
- */
-export interface SelfExplainInclude {
-    /** The run's plain-English story → the `read_narrative` tool. Default true. */
-    readonly narrative?: boolean;
-    /**
-     * A bounded tail of the run's typed events → tool-call timings and
-     * outcomes in `inspect_tool_call`, and the Context Integrity findings
-     * `find_context_errors` reads. Default true. Off means no wildcard event
-     * subscription is made at all, not a subscription that is ignored — and
-     * `find_context_errors` then reports the evidence channel as ABSENT
-     * rather than reporting a run with no context errors.
-     */
-    readonly events?: boolean;
-}
-/** Consumer surface for `.selfExplain()` on the Agent builder. */
-export interface SelfExplainOptions {
-    /** Appended to the recommended skill body (ours stays; yours adds). */
-    readonly instruction?: string;
-    /**
-     * Answer why-questions on a SEPARATE (typically cheaper) model: the
-     * skill unlocks one `explain_run` tool that runs a nested
-     * `traceDebugAgent` and returns its evidence-cited answer.
-     */
-    readonly delegate?: {
-        readonly provider: AgentOptions['provider'];
-        readonly model: string;
-        readonly maxIterations?: number;
-    };
-    /** Skill id (activation key for `read_skill`). Default 'self-explain'. */
-    readonly id?: string;
-    /** Bounding dials forwarded to the toolpack. */
-    readonly toolpack?: TraceToolpackOptions;
-    /** Which optional parts of a turn's evidence to capture. Both default true. */
-    readonly include?: SelfExplainInclude;
-    /**
-     * Cap on retained events per turn (only with `include.events`). Default
-     * 2,000 — enough for a long tool-using turn, small enough that a server
-     * holding one binding per agent does not grow without limit. A tail that
-     * dropped events says so in `inspect_tool_call`.
-     */
-    readonly maxEvents?: number;
-}
-/** Default per-turn event cap for the self-explain binding. */
-export declare const SELF_EXPLAIN_MAX_EVENTS = 2000;
-/** Which conversation the agent is serving, and which run — see {@link SelfExplainSource.getServing}. */
-export interface SelfExplainServing {
-    /** The evidence key. `undefined` = a direct run with no session. */
-    readonly conversation: string | undefined;
-    /** The run in flight, or the one served last. */
-    readonly runId: string;
-    /** A conversation no later request can name (a hosted request with no
-     *  session) — kept on its own, smaller shelf. */
-    readonly oneShot?: boolean;
-}
-/**
- * What the binding reads a completed turn's evidence FROM.
- *
- * One object rather than three wiring calls, on purpose: the
- * `BoundaryRecorder` lesson in this codebase is that a seam needing three
- * separate connections gets two of them in some integrations, and the
- * missing third fails silently. Here the only caller is `AgentBuilder`,
- * and it hands over all of it at once.
- */
-export interface SelfExplainSource {
-    /** The just-finished run's snapshot — `agent.getLastSnapshot()`. */
-    getSnapshot(): RuntimeSnapshot | undefined;
-    /** The run's narrative entries — `agent.getLastNarrativeEntries()`. */
-    getNarrative?(): readonly {
-        readonly text: string;
-    }[];
-    /** The typed event stream — `agent.on('*', …)`. */
-    on?(type: '*', listener: (event: AgentfootprintEvent) => void): Unsubscribe;
-    /**
-     * The records TOOLS kept of their own runs — present when the agent
-     * mounts a `flowchartAsTool({ keepRecord: true })`. Unlike the other
-     * three, this is NOT captured at the terminal flush: the store is a live,
-     * bounded object owned by the tool, and the binding holds the lookup so
-     * `inspect_tool_run` reads whatever the tool has filed. Rotating it per
-     * turn would throw away the previous turn's inner runs at exactly the
-     * moment the follow-up question arrives.
-     */
-    getInnerRuns?(): InnerRunLookup | undefined;
-    /**
-     * The conversation the agent is serving — or, between runs, served last —
-     * and that run's id. The conversation is the KEY the evidence is kept and
-     * served under: read at the terminal flush it names the conversation the
-     * finished turn belongs to, read inside a turn it names the conversation
-     * asking. It is the run's session; a HOSTED run with no session gets the
-     * host's per-request key, which nobody can present again; only a direct run
-     * with no session shares `undefined`. Absent (a bare `getSnapshot` binding)
-     * every run shares one key — the single-conversation behaviour — and inner
-     * runs are served unfiltered.
-     */
-    getServing?(): SelfExplainServing;
-}
-/**
- * The late-binding seam. Create one per built Agent, attach
- * `binding.recorder()` via `agent.attach()`, and point `bindTo()` at the
- * agent's `getLastSnapshot`. `artifacts` then always answers with the
- * previous COMPLETED run of the asking conversation — never the in-flight
- * one, and never another conversation's.
- */
-export declare class SelfExplainBinding {
-    private readonly include;
-    private readonly maxEvents;
-    private source;
-    private ctrl;
-    private tail;
-    /** Evidence and run ids per conversation (see
-     *  {@link SelfExplainSource.getServing}), on two shelves: one for
-     *  conversations a caller can come back to ({@link MAX_CONVERSATIONS}), one
-     *  for one-shot ones ({@link MAX_ONE_SHOT_CONVERSATIONS}). Insertion order is
-     *  recency order. Run ids are recorded at run START, so a run that PAUSED or
-     *  FAILED (neither reaches the terminal capture) still owns the records its
-     *  tools filed (recheck RS4). */
-    private readonly lasting;
-    private readonly oneShot;
-    constructor(include?: SelfExplainInclude, maxEvents?: number);
-    private get wantsNarrative();
-    private get wantsEvents();
-    /**
-     * Point the binding at the agent it explains.
-     *
-     * Accepts the bare `getSnapshot` function it has always accepted (the
-     * evidence a completed run leaves behind on its own), or the full
-     * source, which adds the two parts a snapshot does NOT carry: the
-     * narrative, and the typed event stream.
-     */
-    bindTo(source: SelfExplainSource | (() => RuntimeSnapshot | undefined)): void;
-    /**
-     * Evidence of the previous completed run OF THE ASKING CONVERSATION, or
-     * undefined when that conversation has completed none (or its evidence was
-     * dropped past the bound). Never another conversation's.
-     */
-    get artifacts(): TraceToolpackArtifacts | undefined;
-    /** The conversation (and run) in flight, or served last. */
-    private serving;
-    /** Which shelf a conversation lives on. */
-    private shelfOf;
-    /** Remember that the serving run belongs to its conversation (bounded both ways). */
-    private recordRun;
-    /** File the serving conversation's evidence as its most recent, within the bound. */
-    private file;
-    /** The recorder to attach — forwards flow events to the per-run ctrl. */
-    recorder(): CombinedRecorder;
-}
-/** The default skill id — the activation key the LLM passes to read_skill. */
-export declare const SELF_EXPLAIN_SKILL_ID = "self-explain";
-/**
- * The skill `.selfExplain()` mounts — methodology body ONLY. The trace
- * tools deliberately do NOT ride the skill: skill `tools` land in the
- * static registry (exposed every iteration); catalog gating is the
- * ToolProvider's job — see {@link buildSelfExplainToolProvider}.
- */
-export declare function buildSelfExplainSkill(options: SelfExplainOptions): Injection;
-/**
- * The gated tool delivery — `skillScopedTools` (the shipped primitive)
- * scoped to the skill's id, composed with the consumer's own provider
- * when they set one. The iteration after activation, `ctx.activeSkillId`
- * matches and the catalog gains the trace tools (inline) or the single
- * `explain_run` tool (delegate).
- *
- * INLINE MODE LOADS THE PACK LAZILY (9.94.0). The toolpack module is the
- * largest single module on the library's default graph, and until this
- * release every consumer who imported `Agent` carried it — `.selfExplain()`
- * or not — because this function reached it statically. Now the pack is
- * `import()`ed the first time the self-explain skill is ACTIVE on an
- * iteration, and never before: not at `build()`, not on a turn where the
- * model never opened the skill, not at all for an agent that did not enable
- * `.selfExplain()`. A bundler splits it into its own chunk; Node loads it
- * through the same `require` it always did, one microtask later.
- *
- * What the consumer sees: `list(ctx)` still answers `[]` synchronously when
- * the skill is not active (the sync fast path the tools slot skips the await
- * for), and a Promise of the same eleven tools when it is — the shape
- * `ToolProvider.list` has always allowed, and the one the composed provider
- * below already used. The provider id is unchanged, so `.watch()` output and
- * the `skill-scoped:` refusal in the builder read exactly as before.
- */
-export declare function buildSelfExplainToolProvider(binding: SelfExplainBinding, options: SelfExplainOptions, existing?: ToolProvider): ToolProvider;
-//# sourceMappingURL=selfExplain.d.ts.map

package/dist/types/lib/trace-toolpack/selfExplain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"selfExplain.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/selfExplain.ts"],"names":[],"mappings":"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"}

package/dist/types/lib/trace-toolpack/subflowRecords.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"subflowRecords.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/subflowRecords.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAK/F;AAUD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAM5F;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,GACnC,MAAM,EAAE,GAAG,SAAS,CAWtB;AAED,gEAAgE;AAChE,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMlE;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC5C,KAAK,EAAE,MAAM,GACZ,OAAO,CAET;AAED,qFAAqF;AACrF,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC5C,KAAK,EAAE,MAAM,GACZ,MAAM,CAER;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,MAAM,CAmC9F"}

package/dist/types/lib/trace-toolpack/traceDebugAgent.d.ts

@@ -1,43 +0,0 @@
-/**
- * traceDebugAgent — the DEDICATED conversational door over a completed
- * run's trace. One call returns a ready Agent whose entire catalog is
- * the trace toolpack and whose system prompt is the proven debugging
- * methodology (overview → drill by id → cite evidence → respect ⚠).
- *
- * The counterpart doors over the same evidence:
- *   - the UI (BacktrackView / Lens) for humans who LOOK,
- *   - `.selfExplain()` for why-questions INSIDE the main conversation
- *     (which, in delegate mode, runs one of these under the hood).
- *
- * Why dedicated (B13 posture): trace views can replay adversarial text
- * from the original run — a SEPARATE session over a COMPLETED run keeps
- * that out of the production conversation. It is also the cheap-model
- * story made real: debug a Sonnet/Opus run with a Haiku-priced session
- * that reads only what it opens, by id (~9% of the trace in the
- * example-01 fixture; the gap widens with run size).
- */
-import { Agent } from '../../core/Agent.js';
-import type { AgentOptions } from '../../core/agent/types.js';
-import type { TraceToolpackArtifacts, TraceToolpackOptions } from './types.js';
-export interface TraceDebugAgentOptions {
-    /** The completed run's evidence — `{ snapshot, controlDeps?, narrative? }`. */
-    readonly artifacts: TraceToolpackArtifacts;
-    /** Any provider — `mock()` in tests, a cheap model in production. */
-    readonly provider: AgentOptions['provider'];
-    readonly model: string;
-    /** ReAct budget for one debugging question. Default 8. */
-    readonly maxIterations?: number;
-    /** Appended to the methodology system prompt (domain hints, tone). */
-    readonly instruction?: string;
-    /** Bounding dials forwarded to the toolpack. */
-    readonly toolpack?: TraceToolpackOptions;
-    /** Display name in events/metrics. Default 'TraceDebugAgent'. */
-    readonly name?: string;
-}
-/**
- * Build the dedicated trace debugger. The returned Agent is a normal
- * Agent — `await debuggerAi.run({ message: 'Why was the refund approved?' })`
- * answers from the recorded evidence, citing runtimeStageIds.
- */
-export declare function traceDebugAgent(options: TraceDebugAgentOptions): Agent;
-//# sourceMappingURL=traceDebugAgent.d.ts.map

package/dist/types/lib/trace-toolpack/traceDebugAgent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"traceDebugAgent.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/traceDebugAgent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG9D,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE/E,MAAM,WAAW,sBAAsB;IACrC,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,sBAAsB,CAAC;IAC3C,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0DAA0D;IAC1D,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,sEAAsE;IACtE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IACzC,iEAAiE;IACjE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,KAAK,CAatE"}

package/dist/types/lib/trace-toolpack/traceToolNames.d.ts

@@ -1,38 +0,0 @@
-/**
- * traceToolNames — the two facts about the trace toolpack that are needed
- * BEFORE the pack is loaded.
- *
- * `.selfExplain()` mounts the pack lazily (9.94.0): the toolpack module —
- * eleven tools over a finished trace, the largest single module on the
- * library's default graph — is reached through `import()` the first time
- * the self-explain skill is active on an iteration, never at build time and
- * never for an agent that did not enable it (see `selfExplain.ts` ·
- * `buildSelfExplainToolProvider`). Two things the builder needs cannot wait
- * for that load, and they live here so that reading them costs nothing:
- *
- *   - `TRACE_TOOL_NAMES` — the names the pack can mount, which `build()`
- *     reserves synchronously (a consumer tool sharing a name would silently
- *     shadow the trace tool);
- *   - `NO_COMPLETED_RUN_MESSAGE` — the model-visible answer every trace tool
- *     gives before a turn has finished, which the delegate-mode `explain_run`
- *     tool returns without loading the pack at all.
- *
- * `traceToolpack.ts` re-exports `TRACE_TOOL_NAMES` and `lazyToolpack.ts`
- * re-exports `NO_COMPLETED_RUN_MESSAGE`, so every existing import path still
- * resolves — this module only changes what a static import of them COSTS.
- */
-/**
- * The tool names this pack can mount. The Agent builder reserves these at
- * `.selfExplain()` build time — the tools slot dedupes by name with
- * first-occurrence-wins, so a consumer tool sharing a name would silently
- * shadow the trace tool AND the skill body would instruct the model into
- * the wrong one. Exported so the reservation list is DERIVED from the pack
- * rather than typed out beside it (a second list is a list that drifts).
- *
- * The pack itself asserts, at test time, that what it mounts is exactly
- * this list (test/lib/trace-toolpack/selfExplainAgent.test.ts).
- */
-export declare const TRACE_TOOL_NAMES: readonly ["run_overview", "find_context_errors", "find_in_trace", "trace_node", "trace_slice", "backtrack", "who_wrote", "get_value", "inspect_tool_call", "inspect_tool_run", "inspect_subflow", "read_narrative"];
-/** Model-visible answer when no completed run is available yet. */
-export declare const NO_COMPLETED_RUN_MESSAGE: string;
-//# sourceMappingURL=traceToolNames.d.ts.map

package/dist/types/lib/trace-toolpack/traceToolNames.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"traceToolNames.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/traceToolNames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,qNAanB,CAAC;AAEX,mEAAmE;AACnE,eAAO,MAAM,wBAAwB,QAEa,CAAC"}

package/dist/types/lib/trace-toolpack/traceToolpack.d.ts

@@ -1,83 +0,0 @@
-/**
- * traceToolpack — footprintjs trace evidence exposed as TOOLS an LLM calls
- * (RFC-003 Part C: the introspection toolpack).
- *
- * "The framework's internal tool for itself": after a run completes, a
- * debugging LLM (a cheap model in a SEPARATE session) navigates the run's
- * evidence by ids instead of reading dumps — the same just-in-time,
- * token-efficient loading pattern as `read_skill`. Feed the slice, not the
- * trace; the LLM ranks by navigating, so no embedder is needed.
- *
- * Pattern: Factory over frozen artifacts. `traceToolpack(artifacts)` returns
- *          plain `Tool[]` — mount them on any Agent, or drive them scripted
- *          via `callTraceTool` (the offline auditor pattern, like
- *          examples/features/20). Nothing re-runs; every tool is a bounded
- *          read-only VIEW over a COMPLETED run's snapshot + commit log.
- *
- * The toolpack's three contracts (B13 posture):
- *
- *   1. BOUNDED BY DEFAULT — every output is capped (previews, slice
- *      depth/nodes, value chars, narrative lines). Per-call params raise
- *      the budget only up to hard caps the LLM cannot exceed.
- *   2. HONEST — truncation and incompleteness are ALWAYS marked (⚠), never
- *      silent: truncated slices, untracked sources (args/env/silent reads),
- *      missing read tracking, missing control-dependence lookup, values the
- *      commit log cannot see (pre-run state, closures).
- *   3. REDACTION-RESPECTING — the commit log already carries redacted
- *      payloads (footprintjs scrubs at commit time); the toolpack passes
- *      placeholders through verbatim and flags redacted keys. It never
- *      reconstructs around a redaction.
- *
- * Why ids: every view names steps by `runtimeStageId`
- * (`stageId#executionIndex`) — the universal key linking the commit log,
- * the execution tree, and recorder events. The LLM drills like a debugger:
- * overview → slice → node → value, paying only for what it opens.
- */
-import { type Tool } from '../../core/tools.js';
-import { type TraceToolpackArtifacts, type TraceToolpackOptions } from './types.js';
-/**
- * Build the introspection toolpack over a COMPLETED run's artifacts.
- *
- * Returns plain `Tool[]`:
- *
- * | Tool                | Question it answers                                    |
- * |---------------------|--------------------------------------------------------|
- * | `run_overview`      | What happened, broadly? (the entry point)              |
- * | `find_context_errors` | What did this run contradict itself about, and why?  |
- * | `find_in_trace`     | WHERE in this run does "…" appear? (free text → ids)   |
- * | `trace_node`        | What did step X read/write, and where did its inputs come from? |
- * | `trace_slice`       | Which chain of steps produced the data at X? (causal slice) |
- * | `backtrack`         | Why is VARIABLE K what it is? (+ `element`: who made K[i]?) — variable-first |
- * | `who_wrote`         | Which step last wrote key K?                           |
- * | `get_value`         | The full value of K as of step X (capped, truncation-marked) |
- * | `inspect_tool_call` | One tool call end to end: proposed args → ran-with args → result → outcome |
- * | `inspect_tool_run`  | INSIDE one tool call — the chart it ran, when that tool kept its record |
- * | `inspect_subflow`   | INSIDE one subflow mount — the subflow's own log, one level at a time |
- * | `read_narrative`    | The human-readable story, paginated (only when narrative provided) |
- *
- * Mount on an Agent (`Agent.create({...}).tool(...tools)`) or drive scripted
- * via {@link callTraceTool}. The tools NEVER throw on bad ids/keys — they
- * return corrective, model-visible messages (the #9 philosophy), and their
- * strict input schemas give Agent-dispatched calls free arg validation.
- *
- * Security note (B13 posture): trace content can carry adversarial text from
- * the original run (tool results, user input). Serve these tools to a
- * SEPARATE debugging session over completed runs — not to the production
- * agent mid-run — and treat tool outputs as data, not instructions.
- */
-export declare function traceToolpack(artifacts: TraceToolpackArtifacts, options?: TraceToolpackOptions): Tool[];
-/**
- * The tool names this pack can mount — declared in `traceToolNames.ts` so the
- * Agent builder can reserve them WITHOUT loading this module (the pack is
- * mounted lazily since 9.94.0); re-exported here so the list still reads as
- * the pack's own.
- */
-export { TRACE_TOOL_NAMES } from './traceToolNames.js';
-/**
- * Invoke a toolpack tool OUTSIDE an Agent (scripted debug sessions, tests,
- * offline auditors). Mirrors the Agent's #9 boundary: args are validated
- * against the tool's inputSchema first, and an invalid call returns the same
- * model-visible correction string instead of executing.
- */
-export declare function callTraceTool(tools: readonly Tool[], name: string, args?: Record<string, unknown>): Promise<string>;
-//# sourceMappingURL=traceToolpack.d.ts.map

package/dist/types/lib/trace-toolpack/traceToolpack.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"traceToolpack.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/traceToolpack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAmBH,OAAO,EAAc,KAAK,IAAI,EAA6B,MAAM,qBAAqB,CAAC;AAwBvF,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AA4VpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,sBAAsB,EACjC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,IAAI,EAAE,CA2BR;AAED;;;;;GAKG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAwiFvD;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACjC,OAAO,CAAC,MAAM,CAAC,CASjB"}