footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/recorder/AttemptRecorder.js

@@ -0,0 +1,412 @@
+/** P7: one bounded, payload-free metric projection collected from traversal hooks. */
+import { parseAttemptId } from 'foottrace';
+import { matchesQuery, metricRow, metricWindow, ownDataRecord } from './attemptMetricRows.js';
+import { aggregateAttempts, attemptRowKey, logicalKey, worst } from './attemptMetrics.js';
+import { attemptOTel } from './attemptOTel.js';
+import { KeyedStore } from './KeyedStore.js';
+function option(value, fallback, max, name, zero = false) {
+    const n = value ?? fallback;
+    if (!Number.isSafeInteger(n) || n < (zero ? 0 : 1) || n > max)
+        throw new TypeError(`attempts: invalid ${name}`);
+    return n;
+}
+let nextRecorder = 0;
+export class AttemptRecorder {
+    id = `attempts-${++nextRecorder}`;
+    rows = new KeyedStore();
+    logical = new Map();
+    starts = new Map();
+    reads = 0;
+    pending = new Set();
+    exemplars;
+    maxRows;
+    maxPending;
+    timeoutMs;
+    store;
+    failed = 0;
+    dropped = 0;
+    omittedRows = 0;
+    constructor(options = {}) {
+        this.exemplars = option(options.exemplars, 10, 100, 'exemplars');
+        this.maxRows = option(options.maxRows, 10000, 100000, 'maxRows');
+        this.maxPending = option(options.maxPending, 8, 64, 'maxPending');
+        this.timeoutMs = option(options.storeTimeoutMs, 1000, 60000, 'storeTimeoutMs');
+        this.store = options.store;
+    }
+    onRunStart(event) {
+        const runId = event.traversalContext?.runId;
+        if (runId) {
+            const startedAt = Date.now();
+            if (this.starts.size >= this.maxRows && !this.starts.has(runId)) {
+                const oldest = this.starts.keys().next().value;
+                if (oldest !== undefined) {
+                    if (this.starts.get(oldest)?.outcome === 'running')
+                        this.omittedRows++;
+                    this.starts.delete(oldest);
+                }
+            }
+            this.starts.set(runId, { startedAt, outcome: 'running' });
+            this.collect({ kind: 'run', runId, startedAt, outcome: 'running' });
+        }
+    }
+    onRunEnd(event) {
+        this.end(event, 'ok');
+    }
+    onPause(event) {
+        this.end(event, 'paused');
+    }
+    onRunFailed(event) {
+        this.end(event, 'failed');
+    }
+    end(event, outcome) {
+        const runId = event.traversalContext?.runId;
+        if (!runId)
+            return;
+        const prior = this.rows.get(attemptRowKey({ kind: 'run', runId, startedAt: 0, outcome: 'running' }));
+        const active = this.starts.get(runId) ?? (prior?.kind === 'run' ? prior : undefined);
+        if (active === undefined) {
+            this.omittedRows++;
+            return;
+        }
+        // Parallel children can each report a pause in one leg. It is one lifecycle fact, not a lost row.
+        // Keep the start until a real terminal event, so a later failure can supersede a child's pause.
+        if (outcome === 'paused' && active.outcome !== 'running')
+            return;
+        if (outcome !== 'paused' && (active.outcome === 'ok' || active.outcome === 'failed'))
+            return;
+        const startedAt = active.startedAt;
+        if (outcome === 'paused')
+            this.starts.set(runId, { startedAt, outcome });
+        else
+            this.starts.delete(runId);
+        this.collect({
+            kind: 'run',
+            runId,
+            startedAt,
+            endedAt: Date.now(),
+            outcome,
+        });
+        // Other parallel children may still finish after one child pauses. Keep their bounded identity links
+        // until a real terminal event, rather than dropping their later native decisions.
+        if (outcome !== 'paused')
+            for (const [key, row] of this.logical)
+                if (row.runId === runId)
+                    this.logical.delete(key);
+    }
+    onAttempt(event) {
+        const ctx = event.traversalContext;
+        const record = event.record;
+        if (!ctx?.runId) {
+            this.omittedRows++;
+            return;
+        }
+        const id = `${record.series}@${record.attempt}`;
+        if (id.length > 4096) {
+            this.omittedRows++;
+            return;
+        }
+        const parsed = parseAttemptId(id);
+        if (!parsed) {
+            this.omittedRows++;
+            return;
+        }
+        const row = metricRow({
+            kind: 'attempt',
+            id,
+            series: record.series,
+            runId: ctx.runId,
+            runtimeStageId: ctx.runtimeStageId,
+            target: record.target ?? event.stageId,
+            traceId: ctx.correlation?.traceId,
+            startedAt: record.startedAt,
+            durationMs: record.durationMs,
+            outcome: record.outcome,
+            category: record.category,
+            next: record.next,
+            reason: record.reason,
+            attemptKind: record.kind,
+            attempt: record.attempt,
+            of: record.of,
+            effect: record.effect,
+            retryLoop: record.retryLoop,
+        });
+        if (row?.kind !== 'attempt') {
+            this.omittedRows++;
+            return;
+        }
+        this.collect(row);
+        if (row.retryLoop?.phase === 'attempt') {
+            const key = logicalKey(row.runId, row.retryLoop.series, row.retryLoop.attempt);
+            if (!this.logical.has(key) && this.logical.size >= this.maxRows) {
+                const oldest = this.logical.keys().next().value;
+                if (oldest !== undefined)
+                    this.logical.delete(oldest);
+                this.omittedRows++;
+            }
+            this.logical.set(key, row);
+        }
+    }
+    onDecision(event) {
+        const logical = event.evidence?.retryLoop;
+        const runId = event.traversalContext?.runId;
+        if (!logical || !runId)
+            return;
+        const key = logicalKey(runId, logical.series, logical.attempt);
+        const physical = this.logical.get(key);
+        this.logical.delete(key);
+        if (!physical) {
+            this.omittedRows++;
+            return;
+        }
+        const row = metricRow({
+            ...logical,
+            kind: 'decision',
+            runId,
+            target: physical.target,
+            runtimeStageId: event.traversalContext?.runtimeStageId,
+            attemptId: physical.id,
+            startedAt: physical.startedAt,
+        });
+        if (row?.kind === 'decision')
+            this.collect(row);
+        else
+            this.omittedRows++;
+    }
+    collect(row) {
+        const key = attemptRowKey(row);
+        if (!this.rows.has(key) && this.rows.size >= this.maxRows) {
+            const oldest = this.rows.getMap().keys().next().value;
+            if (oldest !== undefined)
+                this.rows.delete(oldest);
+            this.omittedRows++;
+        }
+        this.rows.set(key, row);
+        if (!this.store)
+            return;
+        if (this.pending.size + this.reads >= this.maxPending) {
+            this.dropped++;
+            return;
+        }
+        // Hooks cannot await. Own every rejection immediately, with a bounded pool and no hidden retry queue.
+        try {
+            const result = this.store.append([structuredClone(row)]);
+            if (result !== undefined) {
+                const task = Promise.resolve(result)
+                    .then(() => undefined, () => {
+                    this.failed++;
+                })
+                    .then(() => {
+                    this.pending.delete(task);
+                });
+                this.pending.add(task);
+            }
+        }
+        catch {
+            this.failed++;
+        }
+    }
+    storage() {
+        return {
+            pending: this.pending.size + this.reads,
+            failed: this.failed,
+            dropped: this.dropped,
+            omittedRows: this.omittedRows,
+            incomplete: this.pending.size + this.reads + this.failed + this.dropped + this.omittedRows > 0,
+        };
+    }
+    async flush() {
+        if (this.pending.size === 0)
+            return this.storage();
+        let timer;
+        try {
+            await Promise.race([
+                Promise.all([...this.pending]),
+                new Promise((resolve) => {
+                    timer = setTimeout(resolve, this.timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        }
+        return this.storage();
+    }
+    byTarget() {
+        return aggregateAttempts(this.rows.values(), this.exemplars, this.storage()).byTarget;
+    }
+    byRun() {
+        return aggregateAttempts(this.rows.values(), this.exemplars, this.storage()).byRun;
+    }
+    slowest(target, limit = this.exemplars) {
+        const cap = option(limit, this.exemplars, 100, 'limit', true);
+        return worst(this.rows.values().filter((row) => row.kind === 'attempt' && row.target === target), cap);
+    }
+    series(series, runId) {
+        const held = this.rows.values().filter((row) => runId === undefined || row.runId === runId);
+        const linked = new Set();
+        for (const row of held)
+            if (row.kind === 'attempt' && row.series === series && row.retryLoop !== undefined)
+                linked.add(JSON.stringify([row.runId, row.retryLoop.series]));
+        const rows = held.filter((row) => row.kind !== 'run' &&
+            (row.series === series ||
+                (row.kind === 'attempt' && row.retryLoop?.series === series) ||
+                linked.has(JSON.stringify([row.runId, row.kind === 'attempt' ? row.retryLoop?.series : row.series]))));
+        return structuredClone({
+            attempts: rows.filter((row) => row.kind === 'attempt'),
+            decisions: rows.filter((row) => row.kind === 'decision'),
+        });
+    }
+    async aggregate(supplied = {}) {
+        const admitted = ownDataRecord(supplied);
+        if (admitted === undefined)
+            throw new TypeError('attempts: invalid query');
+        const { since, until, target, runId } = admitted;
+        if ((since !== undefined && (!Number.isFinite(since) || since < 0)) ||
+            (until !== undefined && (!Number.isFinite(until) || until < 0)) ||
+            (since !== undefined && until !== undefined && since > until) ||
+            (target !== undefined && (typeof target !== 'string' || target.length === 0)) ||
+            (runId !== undefined && (typeof runId !== 'string' || runId.length === 0)))
+            throw new TypeError('attempts: invalid query');
+        const query = Object.freeze({ since, until, target, runId });
+        await this.flush();
+        const raw = this.store === undefined ? this.rows.values() : await this.readStored(query);
+        const rows = [];
+        const window = metricWindow(raw, this.maxRows);
+        let invalid = window.omitted;
+        for (const value of window.values) {
+            const row = metricRow(value);
+            if (row && matchesQuery(row, query))
+                rows.push(row);
+            else if (row === undefined)
+                invalid++;
+        }
+        const storage = this.storage();
+        let storeOmitted = 0;
+        let accountingUnknown = false;
+        if (this.store?.stats !== undefined) {
+            try {
+                const stats = ownDataRecord(this.store.stats());
+                if (stats === undefined ||
+                    typeof stats.omittedRows !== 'number' ||
+                    !Number.isSafeInteger(stats.omittedRows) ||
+                    stats.omittedRows < 0)
+                    accountingUnknown = true;
+                else
+                    storeOmitted = stats.omittedRows;
+            }
+            catch {
+                accountingUnknown = true;
+            }
+        }
+        return aggregateAttempts(rows, this.exemplars, {
+            ...storage,
+            omittedRows: storage.omittedRows + invalid + storeOmitted,
+            incomplete: storage.incomplete || invalid + storeOmitted > 0 || accountingUnknown,
+        });
+    }
+    async readStored(query) {
+        if (this.reads + this.pending.size >= this.maxPending)
+            throw new Error('attempts: store read capacity reached');
+        const store = this.store;
+        if (store === undefined)
+            return this.rows.values();
+        this.reads++;
+        let timer;
+        let released = false;
+        const release = () => {
+            if (!released) {
+                released = true;
+                this.reads--;
+            }
+        };
+        // A timed-out I/O still owns its slot until it settles: a caller cannot create an unbounded pool of stuck reads.
+        const work = Promise.resolve()
+            .then(() => store.read(query))
+            .then((rows) => {
+            release();
+            if (!Array.isArray(rows))
+                throw new Error('attempts: invalid store rows');
+            return rows;
+        }, () => {
+            release();
+            throw new Error('attempts: store read failed');
+        });
+        try {
+            return await Promise.race([
+                work,
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(new Error('attempts: store read timed out')), this.timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        }
+    }
+    toSnapshot() {
+        const stats = aggregateAttempts(this.rows.values(), this.exemplars, this.storage());
+        return {
+            name: 'Attempts',
+            data: { byTarget: stats.byTarget, byRun: stats.byRun },
+            meta: {
+                projection: 'per-target',
+                exemplars: this.exemplars,
+                rows: this.rows.size,
+                maxRows: this.maxRows,
+                storage: stats.storage,
+                workTime: 'sum-of-attempt-durations',
+            },
+        };
+    }
+    toOTel() {
+        return attemptOTel(this.rows.values().filter((row) => row.kind === 'attempt'), this.byTarget(), this.exemplars);
+    }
+    /** Clear completed local projections; active/paused evidence and bounded ownership survive executor auto-clear. */
+    clear() {
+        const kept = this.rows.values().filter((row) => this.starts.has(row.runId));
+        this.rows.clear();
+        for (const row of kept)
+            this.rows.set(attemptRowKey(row), row);
+        for (const [key, row] of this.logical)
+            if (!this.starts.has(row.runId))
+                this.logical.delete(key);
+        if (this.starts.size === 0)
+            this.omittedRows = 0;
+    }
+}
+/** Bounded reference adapter for tests/local use; apps supply their own database adapter. */
+export function memoryStore(options = {}) {
+    const max = option(options.maxRows, 10000, 100000, 'maxRows');
+    const rows = new Map();
+    let omitted = 0;
+    let ordinal = 0;
+    return {
+        append(incoming) {
+            const window = metricWindow(incoming, max);
+            omitted += window.omitted;
+            for (const value of window.values) {
+                const row = metricRow(value);
+                if (!row) {
+                    omitted++;
+                    continue;
+                }
+                if (rows.size >= max) {
+                    const oldest = rows.keys().next().value;
+                    if (oldest !== undefined)
+                        rows.delete(oldest);
+                    omitted++;
+                }
+                rows.set(++ordinal, row);
+            }
+        },
+        async read(query) {
+            return [...rows.values()].filter((row) => matchesQuery(row, query)).map((row) => structuredClone(row));
+        },
+        stats() {
+            return { rows: rows.size, omittedRows: omitted };
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AttemptRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/AttemptRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/** P7: one bounded, payload-free metric projection collected from traversal hooks. */\nimport { parseAttemptId } from 'foottrace';\n\nimport type {\n  FlowAttemptEvent,\n  FlowDecisionEvent,\n  FlowPauseEvent,\n  FlowRecorder,\n  FlowRunEvent,\n  FlowRunFailedEvent,\n} from '../engine/narrative/types.js';\nimport { matchesQuery, metricRow, metricWindow, ownDataRecord } from './attemptMetricRows.js';\nimport { aggregateAttempts, attemptRowKey, logicalKey, worst } from './attemptMetrics.js';\nimport type {\n  AttemptAggregate,\n  AttemptDecisionRow,\n  AttemptQuery,\n  AttemptRecorderOptions,\n  AttemptRow,\n  AttemptStorageStats,\n  AttemptStore,\n  PhysicalAttemptRow,\n} from './attemptMetricsTypes.js';\nimport { attemptOTel } from './attemptOTel.js';\nimport { KeyedStore } from './KeyedStore.js';\n\nfunction option(value: number | undefined, fallback: number, max: number, name: string, zero = false): number {\n  const n = value ?? fallback;\n  if (!Number.isSafeInteger(n) || n < (zero ? 0 : 1) || n > max) throw new TypeError(`attempts: invalid ${name}`);\n  return n;\n}\nlet nextRecorder = 0;\nexport class AttemptRecorder implements FlowRecorder {\n  readonly id = `attempts-${++nextRecorder}`;\n  private readonly rows = new KeyedStore<AttemptRow>();\n  private readonly logical = new Map<string, PhysicalAttemptRow>();\n  private readonly starts = new Map<string, { readonly startedAt: number; readonly outcome: 'running' | 'paused' }>();\n  private reads = 0;\n  private readonly pending = new Set<Promise<void>>();\n  private readonly exemplars: number;\n  private readonly maxRows: number;\n  private readonly maxPending: number;\n  private readonly timeoutMs: number;\n  private readonly store?: AttemptStore;\n  private failed = 0;\n  private dropped = 0;\n  private omittedRows = 0;\n  constructor(options: AttemptRecorderOptions = {}) {\n    this.exemplars = option(options.exemplars, 10, 100, 'exemplars');\n    this.maxRows = option(options.maxRows, 10000, 100000, 'maxRows');\n    this.maxPending = option(options.maxPending, 8, 64, 'maxPending');\n    this.timeoutMs = option(options.storeTimeoutMs, 1000, 60000, 'storeTimeoutMs');\n    this.store = options.store;\n  }\n\n  onRunStart(event: FlowRunEvent): void {\n    const runId = event.traversalContext?.runId;\n    if (runId) {\n      const startedAt = Date.now();\n      if (this.starts.size >= this.maxRows && !this.starts.has(runId)) {\n        const oldest = this.starts.keys().next().value;\n        if (oldest !== undefined) {\n          if (this.starts.get(oldest)?.outcome === 'running') this.omittedRows++;\n          this.starts.delete(oldest);\n        }\n      }\n      this.starts.set(runId, { startedAt, outcome: 'running' });\n      this.collect({ kind: 'run', runId, startedAt, outcome: 'running' });\n    }\n  }\n\n  onRunEnd(event: FlowRunEvent): void {\n    this.end(event, 'ok');\n  }\n\n  onPause(event: FlowPauseEvent): void {\n    this.end(event, 'paused');\n  }\n\n  onRunFailed(event: FlowRunFailedEvent): void {\n    this.end(event, 'failed');\n  }\n\n  private end(event: FlowRunEvent | FlowRunFailedEvent | FlowPauseEvent, outcome: 'ok' | 'failed' | 'paused'): void {\n    const runId = event.traversalContext?.runId;\n    if (!runId) return;\n    const prior = this.rows.get(attemptRowKey({ kind: 'run', runId, startedAt: 0, outcome: 'running' }));\n    const active = this.starts.get(runId) ?? (prior?.kind === 'run' ? prior : undefined);\n    if (active === undefined) {\n      this.omittedRows++;\n      return;\n    }\n    // Parallel children can each report a pause in one leg. It is one lifecycle fact, not a lost row.\n    // Keep the start until a real terminal event, so a later failure can supersede a child's pause.\n    if (outcome === 'paused' && active.outcome !== 'running') return;\n    if (outcome !== 'paused' && (active.outcome === 'ok' || active.outcome === 'failed')) return;\n    const startedAt = active.startedAt;\n    if (outcome === 'paused') this.starts.set(runId, { startedAt, outcome });\n    else this.starts.delete(runId);\n    this.collect({\n      kind: 'run',\n      runId,\n      startedAt,\n      endedAt: Date.now(),\n      outcome,\n    });\n    // Other parallel children may still finish after one child pauses. Keep their bounded identity links\n    // until a real terminal event, rather than dropping their later native decisions.\n    if (outcome !== 'paused') for (const [key, row] of this.logical) if (row.runId === runId) this.logical.delete(key);\n  }\n\n  onAttempt(event: FlowAttemptEvent): void {\n    const ctx = event.traversalContext;\n    const record = event.record;\n    if (!ctx?.runId) {\n      this.omittedRows++;\n      return;\n    }\n    const id = `${record.series}@${record.attempt}`;\n    if (id.length > 4096) {\n      this.omittedRows++;\n      return;\n    }\n    const parsed = parseAttemptId(id);\n    if (!parsed) {\n      this.omittedRows++;\n      return;\n    }\n    const row = metricRow({\n      kind: 'attempt',\n      id,\n      series: record.series,\n      runId: ctx.runId,\n      runtimeStageId: ctx.runtimeStageId,\n      target: record.target ?? event.stageId,\n      traceId: ctx.correlation?.traceId,\n      startedAt: record.startedAt,\n      durationMs: record.durationMs,\n      outcome: record.outcome,\n      category: record.category,\n      next: record.next,\n      reason: record.reason,\n      attemptKind: record.kind,\n      attempt: record.attempt,\n      of: record.of,\n      effect: record.effect,\n      retryLoop: record.retryLoop,\n    });\n    if (row?.kind !== 'attempt') {\n      this.omittedRows++;\n      return;\n    }\n    this.collect(row);\n    if (row.retryLoop?.phase === 'attempt') {\n      const key = logicalKey(row.runId, row.retryLoop.series, row.retryLoop.attempt);\n      if (!this.logical.has(key) && this.logical.size >= this.maxRows) {\n        const oldest = this.logical.keys().next().value;\n        if (oldest !== undefined) this.logical.delete(oldest);\n        this.omittedRows++;\n      }\n      this.logical.set(key, row);\n    }\n  }\n\n  onDecision(event: FlowDecisionEvent): void {\n    const logical = event.evidence?.retryLoop;\n    const runId = event.traversalContext?.runId;\n    if (!logical || !runId) return;\n    const key = logicalKey(runId, logical.series, logical.attempt);\n    const physical = this.logical.get(key);\n    this.logical.delete(key);\n    if (!physical) {\n      this.omittedRows++;\n      return;\n    }\n    const row = metricRow({\n      ...logical,\n      kind: 'decision',\n      runId,\n      target: physical.target,\n      runtimeStageId: event.traversalContext?.runtimeStageId,\n      attemptId: physical.id,\n      startedAt: physical.startedAt,\n    });\n    if (row?.kind === 'decision') this.collect(row);\n    else this.omittedRows++;\n  }\n\n  private collect(row: AttemptRow): void {\n    const key = attemptRowKey(row);\n    if (!this.rows.has(key) && this.rows.size >= this.maxRows) {\n      const oldest = this.rows.getMap().keys().next().value;\n      if (oldest !== undefined) this.rows.delete(oldest);\n      this.omittedRows++;\n    }\n    this.rows.set(key, row);\n    if (!this.store) return;\n    if (this.pending.size + this.reads >= this.maxPending) {\n      this.dropped++;\n      return;\n    }\n    // Hooks cannot await. Own every rejection immediately, with a bounded pool and no hidden retry queue.\n    try {\n      const result = this.store.append([structuredClone(row)]);\n      if (result !== undefined) {\n        const task: Promise<void> = Promise.resolve(result)\n          .then(\n            () => undefined,\n            () => {\n              this.failed++;\n            },\n          )\n          .then(() => {\n            this.pending.delete(task);\n          });\n        this.pending.add(task);\n      }\n    } catch {\n      this.failed++;\n    }\n  }\n\n  storage(): AttemptStorageStats {\n    return {\n      pending: this.pending.size + this.reads,\n      failed: this.failed,\n      dropped: this.dropped,\n      omittedRows: this.omittedRows,\n      incomplete: this.pending.size + this.reads + this.failed + this.dropped + this.omittedRows > 0,\n    };\n  }\n\n  async flush(): Promise<AttemptStorageStats> {\n    if (this.pending.size === 0) return this.storage();\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    try {\n      await Promise.race([\n        Promise.all([...this.pending]),\n        new Promise<void>((resolve) => {\n          timer = setTimeout(resolve, this.timeoutMs);\n        }),\n      ]);\n    } finally {\n      if (timer !== undefined) clearTimeout(timer);\n    }\n    return this.storage();\n  }\n\n  byTarget(): AttemptAggregate['byTarget'] {\n    return aggregateAttempts(this.rows.values(), this.exemplars, this.storage()).byTarget;\n  }\n\n  byRun(): AttemptAggregate['byRun'] {\n    return aggregateAttempts(this.rows.values(), this.exemplars, this.storage()).byRun;\n  }\n\n  slowest(target: string, limit = this.exemplars) {\n    const cap = option(limit, this.exemplars, 100, 'limit', true);\n    return worst(\n      this.rows.values().filter((row): row is PhysicalAttemptRow => row.kind === 'attempt' && row.target === target),\n      cap,\n    );\n  }\n\n  series(series: string, runId?: string): { attempts: PhysicalAttemptRow[]; decisions: AttemptDecisionRow[] } {\n    const held = this.rows.values().filter((row) => runId === undefined || row.runId === runId);\n    const linked = new Set<string>();\n    for (const row of held)\n      if (row.kind === 'attempt' && row.series === series && row.retryLoop !== undefined)\n        linked.add(JSON.stringify([row.runId, row.retryLoop.series]));\n    const rows = held.filter(\n      (row) =>\n        row.kind !== 'run' &&\n        (row.series === series ||\n          (row.kind === 'attempt' && row.retryLoop?.series === series) ||\n          linked.has(JSON.stringify([row.runId, row.kind === 'attempt' ? row.retryLoop?.series : row.series]))),\n    );\n    return structuredClone({\n      attempts: rows.filter((row): row is PhysicalAttemptRow => row.kind === 'attempt'),\n      decisions: rows.filter((row): row is AttemptDecisionRow => row.kind === 'decision'),\n    });\n  }\n\n  async aggregate(supplied: AttemptQuery = {}): Promise<AttemptAggregate> {\n    const admitted = ownDataRecord(supplied);\n    if (admitted === undefined) throw new TypeError('attempts: invalid query');\n    const { since, until, target, runId } = admitted as AttemptQuery;\n    if (\n      (since !== undefined && (!Number.isFinite(since) || since < 0)) ||\n      (until !== undefined && (!Number.isFinite(until) || until < 0)) ||\n      (since !== undefined && until !== undefined && since > until) ||\n      (target !== undefined && (typeof target !== 'string' || target.length === 0)) ||\n      (runId !== undefined && (typeof runId !== 'string' || runId.length === 0))\n    )\n      throw new TypeError('attempts: invalid query');\n    const query = Object.freeze({ since, until, target, runId });\n    await this.flush();\n    const raw = this.store === undefined ? this.rows.values() : await this.readStored(query);\n    const rows: AttemptRow[] = [];\n    const window = metricWindow(raw, this.maxRows);\n    let invalid = window.omitted;\n    for (const value of window.values) {\n      const row = metricRow(value);\n      if (row && matchesQuery(row, query)) rows.push(row);\n      else if (row === undefined) invalid++;\n    }\n    const storage = this.storage();\n    let storeOmitted = 0;\n    let accountingUnknown = false;\n    if (this.store?.stats !== undefined) {\n      try {\n        const stats = ownDataRecord(this.store.stats());\n        if (\n          stats === undefined ||\n          typeof stats.omittedRows !== 'number' ||\n          !Number.isSafeInteger(stats.omittedRows) ||\n          stats.omittedRows < 0\n        )\n          accountingUnknown = true;\n        else storeOmitted = stats.omittedRows;\n      } catch {\n        accountingUnknown = true;\n      }\n    }\n    return aggregateAttempts(rows, this.exemplars, {\n      ...storage,\n      omittedRows: storage.omittedRows + invalid + storeOmitted,\n      incomplete: storage.incomplete || invalid + storeOmitted > 0 || accountingUnknown,\n    });\n  }\n\n  private async readStored(query: AttemptQuery): Promise<readonly AttemptRow[]> {\n    if (this.reads + this.pending.size >= this.maxPending) throw new Error('attempts: store read capacity reached');\n    const store = this.store;\n    if (store === undefined) return this.rows.values();\n    this.reads++;\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let released = false;\n    const release = () => {\n      if (!released) {\n        released = true;\n        this.reads--;\n      }\n    };\n    // A timed-out I/O still owns its slot until it settles: a caller cannot create an unbounded pool of stuck reads.\n    const work = Promise.resolve()\n      .then(() => store.read(query))\n      .then(\n        (rows) => {\n          release();\n          if (!Array.isArray(rows)) throw new Error('attempts: invalid store rows');\n          return rows;\n        },\n        () => {\n          release();\n          throw new Error('attempts: store read failed');\n        },\n      );\n    try {\n      return await Promise.race([\n        work,\n        new Promise<never>((_resolve, reject) => {\n          timer = setTimeout(() => reject(new Error('attempts: store read timed out')), this.timeoutMs);\n        }),\n      ]);\n    } finally {\n      if (timer !== undefined) clearTimeout(timer);\n    }\n  }\n\n  toSnapshot() {\n    const stats = aggregateAttempts(this.rows.values(), this.exemplars, this.storage());\n    return {\n      name: 'Attempts',\n      data: { byTarget: stats.byTarget, byRun: stats.byRun },\n      meta: {\n        projection: 'per-target',\n        exemplars: this.exemplars,\n        rows: this.rows.size,\n        maxRows: this.maxRows,\n        storage: stats.storage,\n        workTime: 'sum-of-attempt-durations',\n      },\n    };\n  }\n\n  toOTel() {\n    return attemptOTel(\n      this.rows.values().filter((row): row is PhysicalAttemptRow => row.kind === 'attempt'),\n      this.byTarget(),\n      this.exemplars,\n    );\n  }\n\n  /** Clear completed local projections; active/paused evidence and bounded ownership survive executor auto-clear. */\n  clear(): void {\n    const kept = this.rows.values().filter((row) => this.starts.has(row.runId));\n    this.rows.clear();\n    for (const row of kept) this.rows.set(attemptRowKey(row), row);\n    for (const [key, row] of this.logical) if (!this.starts.has(row.runId)) this.logical.delete(key);\n    if (this.starts.size === 0) this.omittedRows = 0;\n  }\n}\n\n/** Bounded reference adapter for tests/local use; apps supply their own database adapter. */\nexport function memoryStore(\n  options: { readonly maxRows?: number } = {},\n): AttemptStore & { stats(): { rows: number; omittedRows: number } } {\n  const max = option(options.maxRows, 10000, 100000, 'maxRows');\n  const rows = new Map<number, AttemptRow>();\n  let omitted = 0;\n  let ordinal = 0;\n  return {\n    append(incoming) {\n      const window = metricWindow(incoming, max);\n      omitted += window.omitted;\n      for (const value of window.values) {\n        const row = metricRow(value);\n        if (!row) {\n          omitted++;\n          continue;\n        }\n        if (rows.size >= max) {\n          const oldest = rows.keys().next().value;\n          if (oldest !== undefined) rows.delete(oldest);\n          omitted++;\n        }\n        rows.set(++ordinal, row);\n      }\n    },\n    async read(query) {\n      return [...rows.values()].filter((row) => matchesQuery(row, query)).map((row) => structuredClone(row));\n    },\n    stats() {\n      return { rows: rows.size, omittedRows: omitted };\n    },\n  };\n}\n"]}

package/dist/esm/lib/recorder/ControlDepRecorder.d.ts

@@ -27,6 +27,17 @@
  *      completing consumes its slot via `onError`, so the post-fan-out
  *      convergence stage is never misattributed as a branch entry.
  *
+ *   3. attempt stops (10.1) — `onAttempt`: a stage whose retry series STOPPED
+ *      (it gave up, or a later attempt paused or was aborted; the shared
+ *      predicate `recorder/attemptSeries.ts · isRetryEvidence`) made a decision of its
+ *      own — the retry-or-stop decision, in the shape `decide()` produces. It
+ *      is recorded beside the deciders as `kind: 'attempt-stop'`
+ *      (`getDecisions()`, `getAttemptStop(id)`), `chosen: 'stop'`, the stop
+ *      reason as its `ruleLabel`. It is NOT a branch entry: a control edge in
+ *      `causalChain` links a stage to ANOTHER execution that governed it, and
+ *      the stop governs the stage itself — so `lookup` is unchanged, and a
+ *      reader walking a failed stage reads the stop off its decision record.
+ *
  *   `lookup(runtimeStageId)` then walks the ancestor chain from the stage
  *   upward; the first ancestor (or the stage itself) registered as a
  *   branch entry yields its governing decider — the NEAREST decision.
@@ -55,9 +66,15 @@ import { causalChain } from 'foottrace';
  */
 import type { ControlDependency, ControlDepLookup } from 'foottrace';
 import type { DecisionEvidence, SelectionEvidence } from '../decide/types.js';
-import type { FlowDecisionEvent, FlowErrorEvent, FlowRecorder, FlowSelectedEvent, FlowStageEvent } from '../engine/narrative/types.js';
+import type { FlowAttemptEvent, FlowDecisionEvent, FlowErrorEvent, FlowRecorder, FlowSelectedEvent, FlowStageEvent } from '../engine/narrative/types.js';
 /** One recorded decision/selection event (RFC-003 D5). */
 export interface ControlDecisionRecord {
+    /**
+     * `'attempt-stop'` for a stage's own retry-or-stop decision that STOPPED its series (10.1) — then
+     * `deciderRuntimeStageId` is the stage's execution, `chosen` is `'stop'`, `evidence` the attempt's decision and
+     * `ruleLabel` the stop reason. Absent for a decider / selector.
+     */
+    kind?: 'attempt-stop';
     /** runtimeStageId of the decider/selector execution step. */
     deciderRuntimeStageId: string;
     /** Chosen branch display name (decider) or selected names (selector). */
@@ -100,6 +117,7 @@ export declare class ControlDepRecorder implements FlowRecorder {
     private lastRunId?;
     constructor(options?: ControlDepRecorderOptions);
     onDecision(event: FlowDecisionEvent): void;
+    onAttempt(event: FlowAttemptEvent): void;
     onSelected(event: FlowSelectedEvent): void;
     onStageExecuted(event: FlowStageEvent): void;
     /**
@@ -118,8 +136,24 @@ export declare class ControlDepRecorder implements FlowRecorder {
     lookup(runtimeStageId: string): ControlDependency | undefined;
     /** The lookup as a bare function — plug into `causalChain(..., { controlDeps })`. */
     asLookup(): ControlDepLookup;
-    /** All decisions recorded for the current run, in event order. */
+    /** The attempt-stop decision of a stage execution whose retry series stopped, if it did. */
+    getAttemptStop(runtimeStageId: string): ControlDecisionRecord | undefined;
+    /** All decisions recorded for the current run, in event order — deciders, selectors and attempt stops. */
     getDecisions(): ControlDecisionRecord[];
+    /**
+     * Current-run control evidence for the native snapshot. Project only the
+     * stage identities collected during traversal; never walk the execution tree.
+     * Parentless roots cannot have a governing control edge.
+     */
+    toSnapshot(): {
+        name: string;
+        data: {
+            decisions: ControlDecisionRecord[];
+            controlDeps: {
+                [k: string]: ControlDependency;
+            };
+        };
+    };
     /** Reset all state (also happens automatically on runId change). */
     clear(): void;
     /** Convention 4: a new runId means a new run — reset transient state. */