agentfootprint 2.14.5 → 3.1.0

package/dist/types/recorders/observability/internal/ActorArrowClassifier.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @internal — not part of the public agentfootprint API. Imported only
+ * by RunStepRecorder. Subject to change without notice.
+ *
+ * ActorArrowClassifier — classifies the next `llm.start` as
+ * `'user→llm'` (no pending tool result) vs `'tool→llm'` (after a
+ * tool result), and the next `llm.end` as `'llm→tool'` vs `'llm→user'`
+ * based on the call's `toolCallCount`.
+ *
+ * Extracted from RunStepRecorder per Convention 1. Keeps a single
+ * boolean of state — `prevLLMEndHadTools` — and consumes-then-resets
+ * it on each `llm.start`.
+ */
+export type StartArrow = 'user→llm' | 'tool→llm';
+export type EndArrow = 'llm→tool' | 'llm→user';
+export declare class ActorArrowClassifier {
+    private prevLLMEndHadTools;
+    /** Classify the next `llm.start`. Consumes + resets the pending
+     *  flag after returning. */
+    classifyStart(): StartArrow;
+    /** Classify an `llm.end` based on its tool-call count, and update
+     *  the pending flag for the NEXT llm.start. */
+    classifyEnd(toolCallCount: number): EndArrow;
+    clear(): void;
+}
+//# sourceMappingURL=ActorArrowClassifier.d.ts.map

package/dist/types/recorders/observability/internal/ActorArrowClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActorArrowClassifier.d.ts","sourceRoot":"","sources":["../../../../../src/recorders/observability/internal/ActorArrowClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;AACjD,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAC;AAE/C,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,kBAAkB,CAAS;IAEnC;gCAC4B;IAC5B,aAAa,IAAI,UAAU;IAM3B;mDAC+C;IAC/C,WAAW,CAAC,aAAa,EAAE,MAAM,GAAG,QAAQ;IAM5C,KAAK,IAAI,IAAI;CAGd"}

package/dist/types/recorders/observability/internal/CandidateAnswerBuffer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @internal — not part of the public agentfootprint API. Imported only
+ * by RunStepRecorder. Subject to change without notice.
+ *
+ * CandidateAnswerBuffer — buffers a "this leaf MIGHT be the run's
+ * answer" candidate that's only confirmed on `onRunEnd`. Replaced
+ * by every later leaf exit at run scope; the last one wins.
+ *
+ * Extracted from RunStepRecorder per Convention 1.
+ *
+ * Use:
+ *   - On leaf EXIT at run scope: `set(frame, ts, runtimeStageId)`.
+ *   - On `onRunEnd`: `flush()` returns the buffered candidate (or
+ *     undefined if none), and clears the buffer.
+ */
+export interface CandidateAnswer<TFrame> {
+    readonly frame: TFrame;
+    readonly tsMs: number;
+    readonly runtimeStageId: string;
+}
+export declare class CandidateAnswerBuffer<TFrame> {
+    private candidate;
+    /** Buffer a new candidate, replacing any prior one. */
+    set(frame: TFrame, tsMs: number, runtimeStageId: string): void;
+    /** Return + clear the buffered candidate (or undefined if empty). */
+    flush(): CandidateAnswer<TFrame> | undefined;
+    clear(): void;
+}
+//# sourceMappingURL=CandidateAnswerBuffer.d.ts.map

package/dist/types/recorders/observability/internal/CandidateAnswerBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CandidateAnswerBuffer.d.ts","sourceRoot":"","sources":["../../../../../src/recorders/observability/internal/CandidateAnswerBuffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,eAAe,CAAC,MAAM;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,qBAAa,qBAAqB,CAAC,MAAM;IACvC,OAAO,CAAC,SAAS,CAAsC;IAEvD,uDAAuD;IACvD,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI;IAI9D,qEAAqE;IACrE,KAAK,IAAI,eAAe,CAAC,MAAM,CAAC,GAAG,SAAS;IAM5C,KAAK,IAAI,IAAI;CAGd"}

package/dist/types/recorders/observability/internal/ForkTracker.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @internal — not part of the public agentfootprint API. Imported only
+ * by RunStepRecorder. Subject to change without notice; do not import
+ * via deep paths.
+ *
+ * ForkTracker — owns the bookkeeping for parallel-fork emission and
+ * merge-step detection. Extracted from RunStepRecorder per Convention 1
+ * (one purpose per recorder/state machine).
+ *
+ * Responsibilities (and ONLY these):
+ *   1. Coalesce repeated `onFork` events for the same parent (race-safe
+ *      via parent+runtimeStageId key).
+ *   2. Track which child branches belong to which parent fork.
+ *   3. Track which branches have exited; signal "merge ready" when ALL
+ *      branches of a fork have exited.
+ *
+ * What it does NOT own:
+ *   - Storage (the recorder writes RunSteps to its SequenceStore).
+ *   - Run-boundary detection (the recorder's runIdGuard wipes this
+ *     tracker via `clear()`).
+ *   - Any other state machine.
+ */
+export interface ForkRegistration {
+    /** True if this is a NEW fork; false if the same fork was already seen
+     *  (caller should suppress duplicate emission). */
+    readonly fresh: boolean;
+}
+export interface MergeReady {
+    /** All branch IDs of the now-fully-exited fork, in the order they
+     *  were originally registered. */
+    readonly branches: readonly string[];
+}
+export declare class ForkTracker {
+    /** Per-parent: the ordered list of child branch IDs registered. */
+    private readonly branches;
+    /** Per-parent: the set of child branch IDs that have exited so far. */
+    private readonly exited;
+    /** Reverse index: child branch ID → its parent fork. */
+    private readonly childToParent;
+    /** Set of `${parent}@${runtimeStageId}` keys already registered, to
+     *  coalesce repeated onFork events. */
+    private readonly emittedKeys;
+    /**
+     * Register a new fork. If the same fork (by parent+runtimeStageId)
+     * was already registered, returns `{ fresh: false }` and the caller
+     * should suppress emission. Otherwise registers all child branches
+     * and returns `{ fresh: true }`.
+     */
+    registerFork(parent: string, runtimeStageId: string, children: readonly string[]): ForkRegistration;
+    /** True if this child belongs to a tracked fork (used to suppress
+     *  sequential-emission for fork-branch entry events). */
+    isForkChild(childSubflowId: string): boolean;
+    /**
+     * Record a fork-branch exit. If this completes the fork (all branches
+     * have exited), returns `{ branches }` so the caller can emit a merge
+     * step. Returns `undefined` if not yet complete or not a fork branch.
+     */
+    recordChildExit(childSubflowId: string): MergeReady | undefined;
+    clear(): void;
+}
+//# sourceMappingURL=ForkTracker.d.ts.map

package/dist/types/recorders/observability/internal/ForkTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForkTracker.d.ts","sourceRoot":"","sources":["../../../../../src/recorders/observability/internal/ForkTracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,WAAW,gBAAgB;IAC/B;uDACmD;IACnD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB;sCACkC;IAClC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED,qBAAa,WAAW;IACtB,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwC;IACjE,uEAAuE;IACvE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,wDAAwD;IACxD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D;2CACuC;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IAEjD;;;;;OAKG;IACH,YAAY,CACV,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,gBAAgB;IAYnB;6DACyD;IACzD,WAAW,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAI5C;;;;OAIG;IACH,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAgB/D,KAAK,IAAI,IAAI;CAMd"}

package/dist/types/recorders/observability/internal/RootInferrer.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @internal — not part of the public agentfootprint API. Imported only
+ * by RunStepRecorder. Subject to change without notice.
+ *
+ * RootInferrer — small state machine deciding whether a run's root is
+ * a single leaf primitive (Agent / LLMCall) or a composition (Sequence
+ * / Parallel / Conditional / Loop).
+ *
+ * Extracted from RunStepRecorder per Convention 1.
+ *
+ * Inputs: subflow entries (with their depth + parsed primitiveKind),
+ * fork events (depth 0 → Parallel root), decision events (depth 0 →
+ * Conditional root), loop events (depth 0 → Loop root).
+ *
+ * Output: query `kind()` for the inferred root. Returns `undefined`
+ * until a signal arrives.
+ *
+ * Inference rules:
+ *   - Decisive composition signals (fork / decide / loop AT DEPTH 0)
+ *     lock the root and are never overridden.
+ *   - Shallowest primitive boundary IS a composition kind → root is
+ *     that composition.
+ *   - Two+ leaf siblings at the shallowest depth → implicit Sequence
+ *     root (Sequence-as-runner case where the Sequence itself doesn't
+ *     fire its own subflow.entry).
+ *   - Single leaf at the shallowest depth → root is "leaf".
+ */
+export type InferredRoot = 'leaf' | 'sequence' | 'parallel' | 'conditional' | 'loop' | undefined;
+export declare class RootInferrer {
+    private inferred;
+    private shallowestDepth;
+    private shallowestSiblings;
+    /** Currently-inferred root kind, or undefined if no signal yet. */
+    kind(): InferredRoot;
+    /** True when the root is a single leaf primitive (or unknown,
+     *  which should be treated as leaf for kind-filter purposes). */
+    isLeafRoot(): boolean;
+    /** Observe a subflow entry. */
+    observeSubflowEntry(depth: number, primitiveKind: string | undefined): void;
+    /** Observe a fork event. Locks root to Parallel if at depth 0 and
+     *  no decisive root has been inferred yet. */
+    observeFork(depth: number): void;
+    /** Observe a decision event. Locks root to Conditional if at depth 0
+     *  and no decisive root has been inferred yet. */
+    observeDecision(depth: number): void;
+    /** Observe a loop event. Locks root to Loop if at depth 0 and no
+     *  decisive root has been inferred yet. */
+    observeLoop(depth: number): void;
+    clear(): void;
+    private tryInfer;
+}
+//# sourceMappingURL=RootInferrer.d.ts.map

package/dist/types/recorders/observability/internal/RootInferrer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RootInferrer.d.ts","sourceRoot":"","sources":["../../../../../src/recorders/observability/internal/RootInferrer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAaH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,aAAa,GAAG,MAAM,GAAG,SAAS,CAAC;AAEjG,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,eAAe,CAA4B;IACnD,OAAO,CAAC,kBAAkB,CAAK;IAE/B,mEAAmE;IACnE,IAAI,IAAI,YAAY;IAIpB;qEACiE;IACjE,UAAU,IAAI,OAAO;IAIrB,+BAA+B;IAC/B,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAY3E;kDAC8C;IAC9C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAMhC;sDACkD;IAClD,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAMpC;+CAC2C;IAC3C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAMhC,KAAK,IAAI,IAAI;IAMb,OAAO,CAAC,QAAQ;CA0BjB"}

package/dist/types/recorders/observability/internal/SequenceSiblingTracker.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @internal — not part of the public agentfootprint API. Imported only
+ * by RunStepRecorder. Subject to change without notice.
+ *
+ * SequenceSiblingTracker — tracks the most-recent leaf exit at each
+ * depth so the recorder knows when a new leaf entry at the same depth
+ * should emit a "sequential handoff" step ("forwards" semantics).
+ *
+ * Extracted from RunStepRecorder per Convention 1.
+ *
+ * Use:
+ *   - On leaf EXIT: `recordExit(depth, subflowId)`.
+ *   - On leaf ENTRY: `peekPrevSibling(depth)` returns the previous
+ *     leaf's subflowId at this depth, or undefined for the first leaf.
+ */
+export declare class SequenceSiblingTracker {
+    private readonly prevExitedAtDepth;
+    /** Returns the subflow id of the most-recently-exited leaf at this
+     *  depth, or undefined if this is the first leaf entry at the depth. */
+    peekPrevSibling(depth: number): string | undefined;
+    /** Record that a leaf at this depth just exited. */
+    recordExit(depth: number, subflowId: string): void;
+    clear(): void;
+}
+//# sourceMappingURL=SequenceSiblingTracker.d.ts.map

package/dist/types/recorders/observability/internal/SequenceSiblingTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SequenceSiblingTracker.d.ts","sourceRoot":"","sources":["../../../../../src/recorders/observability/internal/SequenceSiblingTracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6B;IAE/D;4EACwE;IACxE,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIlD,oDAAoD;IACpD,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAIlD,KAAK,IAAI,IAAI;CAGd"}

package/dist/types/recorders/observability/observeRunId.d.ts

@@ -0,0 +1,37 @@
+/**
+ * observeRunId — shared run-boundary detection helper for recorders.
+ *
+ * Why this exists: 5 places in observability/* duplicated the same
+ * 10-line pattern (lastRunId field + 3-line check + reset). Extract
+ * once so the contract stays consistent under maintenance.
+ *
+ * The pattern: hold a `lastRunId | undefined`. On every observed event:
+ *   - If runId is missing/undefined → no-op (defensive, allows callers
+ *     to pass `event.meta?.runId` without checking).
+ *   - First observation (lastRunId === undefined) → record, no reset.
+ *   - Same runId → no-op (steady state).
+ *   - Different runId → call onNewRun() then record the new id.
+ *
+ * Returned helper is mutable closure state — callers store it as a
+ * private field and call `.observe(runId)` from event hooks.
+ *
+ * @example
+ * ```typescript
+ * class MyRecorder implements ScopeRecorder {
+ *   private readonly runIdGuard = createRunIdObserver(() => this.reset());
+ *   onWrite(e) {
+ *     this.runIdGuard.observe(e.runId);
+ *     // ... handle event
+ *   }
+ *   private reset() { this.store.clear(); }
+ * }
+ * ```
+ */
+export interface RunIdObserver {
+    /** Process an event's runId; fires onNewRun callback when it changes. */
+    observe(runId: string | undefined): void;
+    /** Clear state so the next observation initializes fresh. */
+    reset(): void;
+}
+export declare function createRunIdObserver(onNewRun: () => void): RunIdObserver;
+//# sourceMappingURL=observeRunId.d.ts.map

package/dist/types/recorders/observability/observeRunId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observeRunId.d.ts","sourceRoot":"","sources":["../../../../src/recorders/observability/observeRunId.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACzC,6DAA6D;IAC7D,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,aAAa,CAkBvE"}

package/dist/types/reliability/buildReliabilityGateChart.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildReliabilityGateChart.d.ts","sourceRoot":"","sources":["../../../src/reliability/buildReliabilityGateChart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAWzD,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,YAAY,CAAC;AAkFvF;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAkT9E"}
+{"version":3,"file":"buildReliabilityGateChart.d.ts","sourceRoot":"","sources":["../../../src/reliability/buildReliabilityGateChart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAWzD,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,YAAY,CAAC;AAmFvF;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAsT9E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfootprint",
-  "version": "2.14.5",
+  "version": "3.1.0",
   "description": "The explainable agent framework — build AI agents you can explain, audit, and trust. Built on footprintjs.",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",
@@ -52,7 +52,7 @@
     "build": "tsc && tsc -p tsconfig.esm.json",
     "watch": "tsc -w",
     "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
+    "test:coverage": "vitest run --coverage --coverage.reporter=json-summary --coverage.reporter=text-summary --coverage.reportsDirectory=coverage",
     "test:examples": "tsc -p examples/tsconfig.json && bash scripts/run-all-examples.sh",
     "test:examples:typecheck": "tsc -p examples/tsconfig.json",
     "examples:readme": "node scripts/generate-examples-readme.mjs",
@@ -66,7 +66,8 @@
     "format:fix": "prettier --config .prettierrc.js --write 'src/**/*.ts' 'test/**/*.ts'",
     "release:patch": "bash scripts/release.sh patch",
     "release:minor": "bash scripts/release.sh minor",
-    "release:major": "bash scripts/release.sh major"
+    "release:major": "bash scripts/release.sh major",
+    "coverage:badge": "npm run test:coverage; node scripts/coverage-badge.mjs"
   },
   "files": [
     "dist/**/*",
@@ -184,7 +185,7 @@
     "@aws-sdk/client-xray": "*",
     "@modelcontextprotocol/sdk": "*",
     "@opentelemetry/api": "*",
-    "footprintjs": ">=4.17.2",
+    "footprintjs": "^6.0.0",
     "ioredis": "*",
     "openai": "*",
     "zod": "*"
@@ -228,7 +229,7 @@
     "@vitest/coverage-v8": "^4.1.5",
     "eslint": "^8.44.0",
     "eslint-config-prettier": "^6.15.0",
-    "footprintjs": "^4.17.2",
+    "footprintjs": "^6.0.0",
     "prettier": "^2.8.1",
     "typedoc": "^0.28.19",
     "typedoc-plugin-markdown": "^4.11.0",

package/dist/core/agent/stages/iterationStart.js

@@ -1,24 +0,0 @@
-"use strict";
-/**
- * iterationStart — per-iteration marker stage.
- *
- * Emits `agentfootprint.agent.iteration_start` so observability adapters
- * + recorders can bracket each ReAct iteration. Fires AFTER the slot
- * subflows (SystemPrompt, Messages, Tools, CacheDecision, CacheGate)
- * have produced this iteration's prompt assembly and BEFORE CallLLM.
- *
- * `turnIndex: 0` is intentional — the agent currently runs ONE turn per
- * `agent.run()`. The turn index is reserved for future multi-turn
- * orchestration; iteration index is the per-iteration counter.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.iterationStartStage = void 0;
-const typedEmit_js_1 = require("../../../recorders/core/typedEmit.js");
-const iterationStartStage = (scope) => {
-    (0, typedEmit_js_1.typedEmit)(scope, 'agentfootprint.agent.iteration_start', {
-        turnIndex: 0,
-        iterIndex: scope.iteration,
-    });
-};
-exports.iterationStartStage = iterationStartStage;
-//# sourceMappingURL=iterationStart.js.map

package/dist/core/agent/stages/iterationStart.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"iterationStart.js","sourceRoot":"","sources":["../../../../src/core/agent/stages/iterationStart.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAGH,uEAAiE;AAG1D,MAAM,mBAAmB,GAAG,CAAC,KAA6B,EAAQ,EAAE;IACzE,IAAA,wBAAS,EAAC,KAAK,EAAE,sCAAsC,EAAE;QACvD,SAAS,EAAE,CAAC;QACZ,SAAS,EAAE,KAAK,CAAC,SAAS;KAC3B,CAAC,CAAC;AACL,CAAC,CAAC;AALW,QAAA,mBAAmB,uBAK9B"}

package/dist/esm/core/agent/stages/iterationStart.js

@@ -1,20 +0,0 @@
-/**
- * iterationStart — per-iteration marker stage.
- *
- * Emits `agentfootprint.agent.iteration_start` so observability adapters
- * + recorders can bracket each ReAct iteration. Fires AFTER the slot
- * subflows (SystemPrompt, Messages, Tools, CacheDecision, CacheGate)
- * have produced this iteration's prompt assembly and BEFORE CallLLM.
- *
- * `turnIndex: 0` is intentional — the agent currently runs ONE turn per
- * `agent.run()`. The turn index is reserved for future multi-turn
- * orchestration; iteration index is the per-iteration counter.
- */
-import { typedEmit } from '../../../recorders/core/typedEmit.js';
-export const iterationStartStage = (scope) => {
-    typedEmit(scope, 'agentfootprint.agent.iteration_start', {
-        turnIndex: 0,
-        iterIndex: scope.iteration,
-    });
-};
-//# sourceMappingURL=iterationStart.js.map

package/dist/esm/core/agent/stages/iterationStart.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"iterationStart.js","sourceRoot":"","sources":["../../../../../src/core/agent/stages/iterationStart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,KAA6B,EAAQ,EAAE;IACzE,SAAS,CAAC,KAAK,EAAE,sCAAsC,EAAE;QACvD,SAAS,EAAE,CAAC;QACZ,SAAS,EAAE,KAAK,CAAC,SAAS;KAC3B,CAAC,CAAC;AACL,CAAC,CAAC"}

package/dist/types/core/agent/stages/iterationStart.d.ts

@@ -1,16 +0,0 @@
-/**
- * iterationStart — per-iteration marker stage.
- *
- * Emits `agentfootprint.agent.iteration_start` so observability adapters
- * + recorders can bracket each ReAct iteration. Fires AFTER the slot
- * subflows (SystemPrompt, Messages, Tools, CacheDecision, CacheGate)
- * have produced this iteration's prompt assembly and BEFORE CallLLM.
- *
- * `turnIndex: 0` is intentional — the agent currently runs ONE turn per
- * `agent.run()`. The turn index is reserved for future multi-turn
- * orchestration; iteration index is the per-iteration counter.
- */
-import type { TypedScope } from 'footprintjs';
-import type { AgentState } from '../types.js';
-export declare const iterationStartStage: (scope: TypedScope<AgentState>) => void;
-//# sourceMappingURL=iterationStart.d.ts.map

package/dist/types/core/agent/stages/iterationStart.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"iterationStart.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/stages/iterationStart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,mBAAmB,UAAW,WAAW,UAAU,CAAC,KAAG,IAKnE,CAAC"}