agentfootprint 2.7.2 → 2.8.0

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

@@ -19,15 +19,22 @@ import type { AgentfootprintEvent, AgentfootprintEventType } from '../events/reg
 import type { LoggingOptions } from '../recorders/observability/LoggingRecorder.js';
 import type { ThinkingOptions } from '../recorders/observability/ThinkingRecorder.js';
 import type { FlowchartHandle, FlowchartOptions } from '../recorders/observability/FlowchartRecorder.js';
+import type { ObservabilityEnableOptions, CostEnableOptions, LiveStatusEnableOptions } from '../strategies/attach.js';
 /**
  * High-level feature-enable methods. Each attaches a pre-built observability
  * recorder and returns an Unsubscribe function. Additional methods land in
  * Phase 5 (lens, tracing, cost, guardrails, ...).
  */
 export interface EnableNamespace {
-    /** Claude-Code-style live status line. */
+    /**
+     * @deprecated v2.8 — use `enable.liveStatus({ strategy: chatBubbleLiveStatus({onLine}) })`.
+     * Kept for back-compat; removed in v3.0.
+     */
     thinking(opts: ThinkingOptions): Unsubscribe;
-    /** Firehose-style structured logging of every event. */
+    /**
+     * @deprecated v2.8 — use `enable.observability({ strategy: pinoObservability({...}) })`
+     * or another vendor strategy. Kept for back-compat; removed in v3.0.
+     */
     logging(opts?: LoggingOptions): Unsubscribe;
     /**
      * Live composition graph — subflow / fork-branch / decision-branch
@@ -39,6 +46,26 @@ export interface EnableNamespace {
      * at any time (not just via onUpdate).
      */
     flowchart(opts?: FlowchartOptions): FlowchartHandle;
+    /**
+     * v2.8+ — grouped strategy enabler for observability. Pipes every
+     * typed event into a vendor strategy (Datadog, OTel, AgentCore,
+     * CloudWatch, …) or the default `consoleObservability()`. See
+     * `agentfootprint/strategies` + `docs/inspiration/strategy-everywhere.md`.
+     */
+    observability(opts?: ObservabilityEnableOptions): Unsubscribe;
+    /**
+     * v2.8+ — grouped strategy enabler for cost. Subscribes the strategy
+     * to `cost.tick` events; defaults to `inMemorySinkCost()` for
+     * read-back / test inspection.
+     */
+    cost(opts?: CostEnableOptions): Unsubscribe;
+    /**
+     * v2.8+ — grouped strategy enabler for chat-bubble live status.
+     * Maintains the thinking-state machine; calls strategy.renderStatus
+     * each time the rendered line changes (deduped — not on every token).
+     * Strategy is required (consumer must wire UI).
+     */
+    liveStatus(opts: LiveStatusEnableOptions): Unsubscribe;
 }
 /**
  * Every primitive (LLMCall, Agent), every composition (Sequence, Parallel,

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

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/core/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,UAAU,EACX,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAC1F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gDAAgD,CAAC;AACtF,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,iDAAiD,CAAC;AAEzD;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,WAAW,CAAC;IAC7C,wDAAwD;IACxD,OAAO,CAAC,IAAI,CAAC,EAAE,cAAc,GAAG,WAAW,CAAC;IAC5C;;;;;;;;OAQG;IACH,SAAS,CAAC,IAAI,CAAC,EAAE,gBAAgB,GAAG,eAAe,CAAC;CACrD;AAED;;;;;GAKG;AACH,MAAM,WAAW,MAAM,CAAC,GAAG,GAAG,OAAO,EAAE,IAAI,GAAG,OAAO,CACnD,SAAQ,IAAI,CAAC,gBAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC;IAChD;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,GAAG,kBAAkB,CAAC,CAAC;IAE1E;;;;;OAKG;IACH,MAAM,CACJ,UAAU,EAAE,mBAAmB,EAC/B,KAAK,CAAC,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,UAAU,GACnB,OAAO,CAAC,IAAI,GAAG,kBAAkB,CAAC,CAAC;IAEtC,uDAAuD;IACvD,EAAE,CAAC,CAAC,SAAS,uBAAuB,EAClC,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,OAAO,CAAC,EAAE,aAAa,GACtB,WAAW,CAAC;IACf,+EAA+E;IAC/E,EAAE,CAAC,IAAI,EAAE,oBAAoB,EAAE,QAAQ,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,WAAW,CAAC;IAEjG,oDAAoD;IACpD,GAAG,CAAC,CAAC,SAAS,uBAAuB,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAClF,GAAG,CAAC,IAAI,EAAE,oBAAoB,EAAE,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAElE,oEAAoE;IACpE,IAAI,CAAC,CAAC,SAAS,uBAAuB,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC;IAC1F,IAAI,CAAC,IAAI,EAAE,oBAAoB,EAAE,QAAQ,EAAE,gBAAgB,GAAG,WAAW,CAAC;IAE1E;;;;OAIG;IACH,MAAM,CAAC,QAAQ,EAAE,gBAAgB,GAAG,WAAW,CAAC;IAEhD;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IAEjC;;;;;;OAMG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC5D;AAED,6EAA6E;AAC7E,YAAY,EAAE,UAAU,EAAE,CAAC;AAE3B;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,mBAAmB,CAAC"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/core/runner.ts"],"names":[],"mappings":"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"}

package/dist/types/strategies/attach.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Wire each grouped strategy to its data source on the dispatcher /
+ * recorder substrate. These are the 4 `enable.*` facades' actual
+ * implementations; `RunnerBase.enable` calls them with the right
+ * dispatcher / attach handle.
+ *
+ * Pattern: every facade follows the same shape:
+ *
+ *   1. Resolve strategy (consumer-supplied OR default)
+ *   2. Run `strategy.validate?()` — early-fail on misconfig (New Relic
+ *      panel review)
+ *   3. Set up subscription / projection
+ *   4. Apply per-strategy event-type filter (`relevantEventTypes`)
+ *   5. Apply per-call sample rate
+ *   6. Wrap calls in try/catch — route errors to `_onError` (passive
+ *      recorder rule: never throw to caller)
+ *   7. Return Unsubscribe (or handle for lens)
+ */
+import type { EventDispatcher, Unsubscribe } from '../events/dispatcher.js';
+import type { ObservabilityStrategy, CostStrategy, LiveStatusStrategy, CommonStrategyOptions, ObservabilityTier } from './types.js';
+import { type ThinkingTemplates } from '../recorders/observability/thinking/thinkingTemplates.js';
+export interface ObservabilityEnableOptions extends CommonStrategyOptions {
+    /** Cost-of-on knob. `'minimal'` → only error + lifecycle events.
+     *  `'standard'` → most domains. `'firehose'` → every event including
+     *  per-token streams. Default `'standard'`. */
+    readonly tier?: ObservabilityTier;
+    readonly strategy?: ObservabilityStrategy;
+}
+export declare function attachObservabilityStrategy(dispatcher: EventDispatcher, opts?: ObservabilityEnableOptions): Unsubscribe;
+export interface CostEnableOptions extends CommonStrategyOptions {
+    readonly strategy?: CostStrategy;
+}
+/**
+ * Subscribe to `agentfootprint.cost.tick` events, project payload into
+ * the canonical `CostTick` shape, hand to strategy.
+ */
+export declare function attachCostStrategy(dispatcher: EventDispatcher, opts?: CostEnableOptions): Unsubscribe;
+export interface LiveStatusEnableOptions extends CommonStrategyOptions {
+    readonly strategy: LiveStatusStrategy;
+    /** Override the bundled English thinking templates with locale /
+     *  per-tool / per-skill overrides. Same shape as
+     *  `agent.thinkingTemplates(...)`. */
+    readonly templates?: ThinkingTemplates;
+    /** App name woven into `{{appName}}` template var. */
+    readonly appName?: string;
+}
+export declare function attachLiveStatusStrategy(dispatcher: EventDispatcher, opts: LiveStatusEnableOptions): Unsubscribe;
+//# sourceMappingURL=attach.d.ts.map

package/dist/types/strategies/attach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attach.d.ts","sourceRoot":"","sources":["../../../src/strategies/attach.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE5E,OAAO,KAAK,EACV,qBAAqB,EACrB,YAAY,EAEZ,kBAAkB,EAElB,qBAAqB,EACrB,iBAAiB,EAElB,MAAM,YAAY,CAAC;AACpB,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,0DAA0D,CAAC;AA0IlE,MAAM,WAAW,0BAA2B,SAAQ,qBAAqB;IACvE;;mDAE+C;IAC/C,QAAQ,CAAC,IAAI,CAAC,EAAE,iBAAiB,CAAC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,qBAAqB,CAAC;CAC3C;AAQD,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,eAAe,EAC3B,IAAI,GAAE,0BAA+B,GACpC,WAAW,CA2Bb;AAID,MAAM,WAAW,iBAAkB,SAAQ,qBAAqB;IAC9D,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;CAClC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,eAAe,EAC3B,IAAI,GAAE,iBAAsB,GAC3B,WAAW,CAiCb;AAID,MAAM,WAAW,uBAAwB,SAAQ,qBAAqB;IACpE,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC;;0CAEsC;IACtC,QAAQ,CAAC,SAAS,CAAC,EAAE,iBAAiB,CAAC;IACvC,sDAAsD;IACtD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAgBD,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,eAAe,EAC3B,IAAI,EAAE,uBAAuB,GAC5B,WAAW,CA0Bb"}

package/dist/types/strategies/compose.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `compose([...])` — fan-out combinator.
+ *
+ * Pattern: Composite. Same shape as React's children array, RxJS's
+ *          `merge`, OTel's `MultiSpanProcessor`. Pass an array of
+ *          strategies; get back a single strategy that fan-outs each
+ *          call to every child.
+ *
+ * Use when:
+ *   - Multi-vendor pipelines (`compose([datadog(), otel(), console()])`)
+ *   - Test instrumentation alongside production sink
+ *     (`compose([inMemorySink(), stripeBilling()])`) so test assertions
+ *     can read ticks while production also ships
+ *   - Tier-staging — local dev mirrors what production sees
+ *
+ * Per-child error isolation: if one child's `exportEvent` throws, the
+ * other children still receive the event. The throwing child's
+ * `_onError` is called (if present); otherwise the error is logged
+ * via `console.warn` once. One bad sink never breaks the chain.
+ *
+ * Capabilities are OR-ed across children — if any child supports a
+ * capability, the composite reports it as supported. The dispatcher
+ * uses this to decide whether to bother building event objects at all.
+ *
+ * Idempotent operations:
+ *   - `flush()` — calls every child's `flush()` (sync or async)
+ *     concurrently, awaits all
+ *   - `stop()` — calls every child's `stop()` once, in order; failures
+ *     in one child don't block the others
+ */
+import type { ObservabilityStrategy, CostStrategy, LiveStatusStrategy, LensStrategy } from './types.js';
+/**
+ * Compose multiple ObservabilityStrategies into a single fan-out.
+ *
+ * @example
+ *   const all = composeObservability([
+ *     consoleObservability(),
+ *     datadogObservability({ apiKey }),
+ *     otelObservability(tracer),
+ *   ]);
+ */
+export declare function composeObservability(children: readonly ObservabilityStrategy[]): ObservabilityStrategy;
+/** Compose CostStrategies. */
+export declare function composeCost(children: readonly CostStrategy[]): CostStrategy;
+/** Compose LiveStatusStrategies. */
+export declare function composeLiveStatus(children: readonly LiveStatusStrategy[]): LiveStatusStrategy;
+/** Compose LensStrategies. */
+export declare function composeLens(children: readonly LensStrategy[]): LensStrategy;
+//# sourceMappingURL=compose.d.ts.map

package/dist/types/strategies/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../../src/strategies/compose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EACV,qBAAqB,EACrB,YAAY,EAEZ,kBAAkB,EAElB,YAAY,EAEb,MAAM,YAAY,CAAC;AAuEpB;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,SAAS,qBAAqB,EAAE,GACzC,qBAAqB,CAUvB;AAED,8BAA8B;AAC9B,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,CAU3E;AAED,oCAAoC;AACpC,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,GAAG,kBAAkB,CAU7F;AAED,8BAA8B;AAC9B,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,CAU3E"}

package/dist/types/strategies/defaults/chatBubbleLiveStatus.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `chatBubbleLiveStatus()` — default LiveStatusStrategy.
+ *
+ * Pattern: Strategy. Adapter for a consumer-supplied callback.
+ * Role:    The "every chat UI" sink. Wraps a `(line: string) => void`
+ *          callback so the consumer just hands us the function their
+ *          chat-bubble component needs and we drive it on every
+ *          rendered status update.
+ *
+ * Use when:
+ *   - Building a chat UI (Neo, Lens, embedded widget) where the
+ *     consumer owns rendering but not state derivation
+ *   - Tier-1 of compose chains (`compose([chatBubble(setLine), stdout()])`
+ *     so dev console mirrors what the user sees)
+ *
+ * The callback runs on EVERY status transition. Consumer can debounce
+ * / coalesce per their needs (we don't impose UI policy).
+ */
+import type { LiveStatusStrategy } from '../types.js';
+export interface ChatBubbleLiveStatusOptions {
+    /**
+     * Required — called per status update with the rendered line.
+     * Pass `setStatus` from your React component, or any function
+     * whose job is "show this line in the chat bubble."
+     *
+     * NOTE: this is INTENTIONALLY the only callback. If you need access
+     * to the underlying `ThinkingState` (for color-per-state, animation
+     * triggers, etc.), build your own `LiveStatusStrategy` directly OR
+     * use `compose([chatBubbleLiveStatus({onLine}), customStrategy])`.
+     * We don't surface `ThinkingState` here because it's an INTERNAL
+     * shape — exposing it would couple consumer UIs to changes in the
+     * state machine.
+     */
+    readonly onLine: (line: string) => void;
+}
+export declare function chatBubbleLiveStatus(opts: ChatBubbleLiveStatusOptions): LiveStatusStrategy;
+//# sourceMappingURL=chatBubbleLiveStatus.d.ts.map

package/dist/types/strategies/defaults/chatBubbleLiveStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatBubbleLiveStatus.d.ts","sourceRoot":"","sources":["../../../../src/strategies/defaults/chatBubbleLiveStatus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAgB,MAAM,aAAa,CAAC;AAEpE,MAAM,WAAW,2BAA2B;IAC1C;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,2BAA2B,GAAG,kBAAkB,CAgB1F"}

package/dist/types/strategies/defaults/consoleObservability.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `consoleObservability()` — default ObservabilityStrategy.
+ *
+ * Pattern: Strategy. Adapter for `globalThis.console`. Used when no
+ *          vendor-specific strategy is configured (zero-config dev
+ *          experience). Same role as `NoOpCacheStrategy` is for the
+ *          cache layer.
+ * Role:    Tier-1 fallback — print every event to the console with a
+ *          one-line type+payload summary. Vendor-neutral, dependency-
+ *          free, works in browser + Node + Deno + Bun.
+ *
+ * Use when:
+ *   - Local development (`agent.enable.observability()` with no opts)
+ *   - CI logs ("what events fired during this test?")
+ *   - Tier-1 of compose chains (`compose([console(), datadog()])`)
+ *
+ * Don't use when: production. Console output is unstructured + can't
+ * be queried; switch to a vendor strategy (Datadog, OTel, CloudWatch).
+ */
+import type { AgentfootprintEvent } from '../../events/registry.js';
+import type { ObservabilityStrategy } from '../types.js';
+export interface ConsoleObservabilityOptions {
+    /**
+     * Where to write. Defaults to `globalThis.console`. Override for
+     * tests or to wrap with a custom sink (browser DevTools' grouped
+     * console, a Node.js stream, etc.).
+     */
+    readonly logger?: {
+        log(...args: unknown[]): void;
+    };
+    /**
+     * Custom line formatter. Receives the typed event; returns the line.
+     * Defaults to `[type] payload-as-JSON`. Override to colorize, filter
+     * fields, or pretty-print.
+     */
+    readonly format?: (event: AgentfootprintEvent) => string;
+}
+/**
+ * Factory. Returns a fresh ObservabilityStrategy each call so multiple
+ * agents in the same process get independent instances.
+ */
+export declare function consoleObservability(opts?: ConsoleObservabilityOptions): ObservabilityStrategy;
+//# sourceMappingURL=consoleObservability.d.ts.map

package/dist/types/strategies/defaults/consoleObservability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consoleObservability.d.ts","sourceRoot":"","sources":["../../../../src/strategies/defaults/consoleObservability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;KAAE,CAAC;IACpD;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,MAAM,CAAC;CAC1D;AAmBD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,GAAE,2BAAgC,GACrC,qBAAqB,CAUvB"}

package/dist/types/strategies/defaults/inMemorySinkCost.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `inMemorySinkCost()` — default CostStrategy.
+ *
+ * Pattern: Strategy. In-process accumulator. Same role as InMemoryStore
+ *          for memory-providers.
+ * Role:    Tier-1 fallback — accumulate cost ticks in a process-local
+ *          array. Consumer reads via `getTicks()` or hooks `onRecord`
+ *          for streaming. Vendor-free.
+ *
+ * Use when:
+ *   - Tests / CI ("what cost did this run accrue?")
+ *   - Local dev before billing integration
+ *   - Tier-1 of compose chains (`compose([inMemorySink(), stripeBilling()])`
+ *     so test assertions can read ticks while production also ships)
+ *
+ * Don't use when: process is long-running with high cost-tick volume —
+ * the buffer grows unbounded. Add a `maxTicks` cap (drops oldest) or
+ * pair with a streaming strategy (`stripeBilling`, `webhook`).
+ */
+import type { CostStrategy, CostTick } from '../types.js';
+export interface InMemorySinkCostOptions {
+    /**
+     * Optional streaming hook called per tick. Useful for piping the
+     * accumulator into a custom sink without writing a full strategy.
+     */
+    readonly onRecord?: (tick: CostTick) => void;
+    /**
+     * Maximum ticks to retain in the buffer. When exceeded, the OLDEST
+     * tick is dropped (FIFO). Default `Infinity` — no cap.
+     */
+    readonly maxTicks?: number;
+}
+/**
+ * Extended interface — the in-memory sink also exposes the buffer
+ * for read-back. Strategies aren't required to do this; this one
+ * does because that IS its purpose (accumulate for inspection).
+ */
+export interface InMemorySinkCostStrategy extends CostStrategy {
+    /** Snapshot of the buffered ticks. O(n) per call — for cheap
+     *  polling use `getTicksCount()` + `getTicksSince(idx)`. */
+    readonly getTicks: () => readonly CostTick[];
+    /** Cheap O(1) read for "did anything new arrive?" polling. */
+    readonly getTicksCount: () => number;
+    /** Incremental read — returns ticks WITH index >= `idx`. Lets a
+     *  dashboard poll cheaply by tracking its last-seen index. */
+    readonly getTicksSince: (idx: number) => readonly CostTick[];
+    /** Drop all buffered ticks. */
+    readonly clear: () => void;
+}
+export declare function inMemorySinkCost(opts?: InMemorySinkCostOptions): InMemorySinkCostStrategy;
+//# sourceMappingURL=inMemorySinkCost.d.ts.map

package/dist/types/strategies/defaults/inMemorySinkCost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemorySinkCost.d.ts","sourceRoot":"","sources":["../../../../src/strategies/defaults/inMemorySinkCost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE1D,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC7C;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAyB,SAAQ,YAAY;IAC5D;gEAC4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,QAAQ,EAAE,CAAC;IAC7C,8DAA8D;IAC9D,QAAQ,CAAC,aAAa,EAAE,MAAM,MAAM,CAAC;IACrC;kEAC8D;IAC9D,QAAQ,CAAC,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,SAAS,QAAQ,EAAE,CAAC;IAC7D,+BAA+B;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED,wBAAgB,gBAAgB,CAAC,IAAI,GAAE,uBAA4B,GAAG,wBAAwB,CA0B7F"}

package/dist/types/strategies/defaults/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Default strategies — the four "shipped in core" sinks.
+ *
+ *   `consoleObservability`   — print events to console
+ *   `inMemorySinkCost`       — accumulate cost ticks in a process-local buffer
+ *   `chatBubbleLiveStatus`   — call a consumer-supplied line callback
+ *   `noopLens`               — drop graph updates (zero-arg fallback)
+ *
+ * Vendor strategies (datadog, otel, agentcore, cloudwatch, …) ship as
+ * separate subpaths with peer-dep on the vendor SDK. See
+ * `docs/inspiration/strategy-everywhere.md` for the AWS-first roadmap.
+ *
+ * ─────────────────────────────────────────────────────────────────
+ * Why defaults skip `validate()`:
+ *
+ * The optional `BaseStrategy.validate()` hook is the right place for
+ * runtime config checks (API keys, endpoint reachability, peer-dep
+ * presence). Defaults skip it by design — their inputs are TypeScript-
+ * checked at construction, and they don't talk to a remote vendor that
+ * might be misconfigured.
+ *
+ * Vendor strategies that DO talk to a remote (datadog, agentcore,
+ * cloudwatch) MUST implement `validate()` per the New Relic panel
+ * review — early-fail-with-useful-message beats silent zero-emission.
+ * ─────────────────────────────────────────────────────────────────
+ */
+export { consoleObservability, type ConsoleObservabilityOptions } from './consoleObservability.js';
+export { inMemorySinkCost, type InMemorySinkCostOptions, type InMemorySinkCostStrategy, } from './inMemorySinkCost.js';
+export { chatBubbleLiveStatus, type ChatBubbleLiveStatusOptions } from './chatBubbleLiveStatus.js';
+export { noopLens, type NoopLensOptions } from './noopLens.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/strategies/defaults/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/strategies/defaults/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,KAAK,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AACnG,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,GAC9B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,oBAAoB,EAAE,KAAK,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AACnG,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/dist/types/strategies/defaults/noopLens.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `noopLens()` — default LensStrategy.
+ *
+ * Pattern: Strategy. Wildcard fallback. Same role as `NoOpCacheStrategy`.
+ * Role:    Drops every update. Used when no Lens vendor strategy is
+ *          configured AND the consumer hasn't supplied a callback.
+ *          Keeps `enable.lens()` callable without args without
+ *          throwing — important for the zero-arg HelloWorld pattern.
+ *
+ * Use when:
+ *   - You want the agent to run without a Lens UI (production
+ *     server-side, headless eval, batch jobs)
+ *   - Tier-1 of compose chains where you want the chain to compile
+ *     even if the real Lens strategy is conditional
+ *
+ * Don't use when: you actually want to see the StepGraph. Use
+ * `lens-browser`, `lens-cli`, or `lens-jsonExport` from the
+ * vendor-strategy subpaths once they ship in v2.12+.
+ */
+import type { LensStrategy, LensUpdate } from '../types.js';
+export interface NoopLensOptions {
+    /**
+     * Optional callback called per update — useful for tests that want
+     * to verify the strategy was wired without actually rendering.
+     */
+    readonly onUpdate?: (update: LensUpdate) => void;
+}
+export declare function noopLens(opts?: NoopLensOptions): LensStrategy;
+//# sourceMappingURL=noopLens.d.ts.map

package/dist/types/strategies/defaults/noopLens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noopLens.d.ts","sourceRoot":"","sources":["../../../../src/strategies/defaults/noopLens.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE5D,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;CAClD;AAED,wBAAgB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,YAAY,CAQjE"}

package/dist/types/strategies/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `agentfootprint/strategies` — typed strategy interfaces + default
+ * sinks for the v2.8 grouped-enabler architecture.
+ *
+ * See:
+ *   - `docs/inspiration/strategy-everywhere.md` — design memo + AWS-first roadmap
+ *   - `types.ts` — typed interfaces (Observability, Cost, LiveStatus, Lens)
+ *   - `defaults/` — the 4 in-core default strategies
+ *
+ * Vendor strategies ship as separate subpaths:
+ *   - `agentfootprint/observability-agentcore` (v2.8.1)
+ *   - `agentfootprint/observability-cloudwatch` (v2.8.2)
+ *   - `agentfootprint/observability-xray` (v2.8.3)
+ *   - `agentfootprint/observability-otel` (v2.9.x)
+ *   - `agentfootprint/observability-datadog` (v2.9.x)
+ *   - `agentfootprint/cost-stripe` (v2.10.x)
+ *   - `agentfootprint/lens-browser` / `lens-cli` (v2.12.x)
+ */
+export * from './types.js';
+export * from './defaults/index.js';
+export { composeObservability, composeCost, composeLiveStatus, composeLens } from './compose.js';
+export { attachObservabilityStrategy, attachCostStrategy, attachLiveStatusStrategy, type ObservabilityEnableOptions, type CostEnableOptions, type LiveStatusEnableOptions, } from './attach.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/strategies/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/strategies/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACjG,OAAO,EACL,2BAA2B,EAC3B,kBAAkB,EAClB,wBAAwB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,GAC7B,MAAM,aAAa,CAAC"}

package/dist/types/strategies/registry.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Strategy registry — name → factory for each of the 4 groups.
+ *
+ * Mirrors `src/cache/strategyRegistry.ts` exactly: maps a string name
+ * to a factory function that takes vendor-specific config and returns
+ * a typed strategy instance. Vendor adapter subpaths self-register on
+ * import via side-effect.
+ *
+ * Two ways consumers wire a strategy:
+ *
+ *   1. By NAME (registry lookup) — the recommended path for vendor
+ *      adapters:
+ *        ```ts
+ *        import 'agentfootprint/observability-datadog';  // self-registers 'datadog'
+ *        agent.enable.observability({ vendor: 'datadog', config: { apiKey } });
+ *        ```
+ *
+ *   2. By INSTANCE (explicit pass) — for custom in-house strategies
+ *      or test mocks:
+ *        ```ts
+ *        agent.enable.observability({ strategy: myCustomStrategy });
+ *        ```
+ *
+ * The two paths are mutually exclusive in `EnableOptions` — the type
+ * union enforces that consumers pick one.
+ *
+ * Lookup is exact-match by name (case-insensitive fallback). Unknown
+ * names return `undefined`; the consumer's `enable.X` then no-ops
+ * (per "do nothing if not configured" rule).
+ */
+import type { ObservabilityStrategy, CostStrategy, LiveStatusStrategy, LensStrategy } from './types.js';
+/** Vendor adapter subpaths register a factory keyed by their vendor
+ *  name. Config shape is vendor-specific — type-erased at the registry
+ *  boundary; consumer's responsibility to pass the right shape. */
+export type ObservabilityFactory = (config?: unknown) => ObservabilityStrategy;
+export type CostFactory = (config?: unknown) => CostStrategy;
+export type LiveStatusFactory = (config?: unknown) => LiveStatusStrategy;
+export type LensFactory = (config?: unknown) => LensStrategy;
+/**
+ * Register a vendor observability strategy by name. Called from the
+ * vendor's subpath at module load (side-effect import):
+ *
+ *   ```ts
+ *   // agentfootprint/observability-datadog/index.ts
+ *   import { registerObservabilityStrategy } from 'agentfootprint/strategies';
+ *   registerObservabilityStrategy('datadog', (config) => datadogObservability(config));
+ *   ```
+ *
+ * Replacing an existing registration is allowed — most-recent wins.
+ * Useful for test mocks.
+ */
+export declare function registerObservabilityStrategy(name: string, factory: ObservabilityFactory): void;
+/** Look up an observability factory by vendor name. Case-insensitive
+ *  fallback. Returns `undefined` when the name is unknown — caller
+ *  decides to noop or throw. */
+export declare function getObservabilityStrategy(name: string): ObservabilityFactory | undefined;
+/** Diagnostic — list all registered vendor names. */
+export declare function listObservabilityStrategies(): readonly string[];
+export declare function registerCostStrategy(name: string, factory: CostFactory): void;
+export declare function getCostStrategy(name: string): CostFactory | undefined;
+export declare function listCostStrategies(): readonly string[];
+export declare function registerLiveStatusStrategy(name: string, factory: LiveStatusFactory): void;
+export declare function getLiveStatusStrategy(name: string): LiveStatusFactory | undefined;
+export declare function listLiveStatusStrategies(): readonly string[];
+export declare function registerLensStrategy(name: string, factory: LensFactory): void;
+export declare function getLensStrategy(name: string): LensFactory | undefined;
+export declare function listLensStrategies(): readonly string[];
+/** Reset every registry to empty. Tests only — not in the public
+ *  barrel. */
+export declare function _resetRegistriesForTests(): void;
+//# sourceMappingURL=registry.d.ts.map

package/dist/types/strategies/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/strategies/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EACV,qBAAqB,EACrB,YAAY,EACZ,kBAAkB,EAClB,YAAY,EACb,MAAM,YAAY,CAAC;AAIpB;;mEAEmE;AACnE,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,qBAAqB,CAAC;AAC/E,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,YAAY,CAAC;AAC7D,MAAM,MAAM,iBAAiB,GAAG,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,kBAAkB,CAAC;AACzE,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,YAAY,CAAC;AAW7D;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAE/F;AAED;;gCAEgC;AAChC,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAEvF;AAED,qDAAqD;AACrD,wBAAgB,2BAA2B,IAAI,SAAS,MAAM,EAAE,CAE/D;AAID,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,CAE7E;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAErE;AAED,wBAAgB,kBAAkB,IAAI,SAAS,MAAM,EAAE,CAEtD;AAID,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAEzF;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAEjF;AAED,wBAAgB,wBAAwB,IAAI,SAAS,MAAM,EAAE,CAE5D;AAID,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,CAE7E;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAErE;AAED,wBAAgB,kBAAkB,IAAI,SAAS,MAAM,EAAE,CAEtD;AAID;cACc;AACd,wBAAgB,wBAAwB,IAAI,IAAI,CAK/C"}