footprintjs 10.0.1 → 10.2.0

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

@@ -10,6 +10,17 @@
  *   - **Accumulate**: progressive quality up to slider position
  *   - **Aggregate**: overall pipeline quality score
  *
+ * Attempts (10.1): a stage whose retry series GAVE UP (exhausted, declined,
+ * no time left) or TIMED OUT is a quality drop at that stage — `drop:
+ * 'attempts'`, with the series' `attempts` summary and a factor naming why.
+ * A series that gave up never reached `onStageEnd` (the stage failed), so the
+ * recorder scores it itself: `0`, the floor, with the keys its last attempt
+ * read — which is what `qualityTrace()` walks to pair the drop with its
+ * causal parents. A series that timed out and recovered keeps the scoring
+ * function's score and gains the flag. Attempts reach a recorder on the FLOW
+ * channel (`onAttempt`): attach with `attachCombinedRecorder` to see them —
+ * `attachScopeRecorder` scores exactly as before.
+ *
  * @example
  * ```typescript
  * const quality = new QualityRecorder((runtimeStageId, context) => {
@@ -30,6 +41,8 @@
  * quality.getLowest();  // { runtimeStageId: 'call-llm#5', entry: { score: 0.7, ... } }
  * ```
  */
+import type { AttemptSummary } from '../attempt/types.js';
+import type { FlowAttemptEvent } from '../engine/narrative/types.js';
 import type { ReadEvent, ScopeRecorder, StageEvent, WriteEvent } from '../scope/types.js';
 import type { RecorderOperation } from './RecorderOperation.js';
 /** Per-step quality data stored by QualityRecorder. */
@@ -46,6 +59,10 @@ export interface QualityEntry {
     keysRead: string[];
     /** Keys written during this step (for backtracking). */
     keysWritten: string[];
+    /** Present when the step's retry series gave up or timed out — a quality drop by attempts (10.1). */
+    drop?: 'attempts';
+    /** With `drop`: the series at a glance. */
+    attempts?: AttemptSummary;
 }
 /**
  * Scoring function called at the end of each stage.
@@ -76,16 +93,26 @@ export declare class QualityRecorder implements ScopeRecorder {
     /** 1:1 per-step storage (Convention 1 — composed, not inherited). */
     private readonly store;
     private readonly scoringFn;
-    private currentRuntimeStageId;
-    private currentStageId;
-    private currentStageName;
-    private currentKeysRead;
-    private currentKeysWritten;
+    /**
+     * Each execution in flight, by its OWN runtimeStageId (10.1) — every event owns its attribution, so parallel
+     * siblings never score under each other's id or with each other's keys (until 10.0 one shared "current stage"
+     * buffer did). A retried execution's entry restarts with each attempt: a series that gave up is scored with the
+     * keys its last attempt touched. Released at the stage's end, or when a drop consumes it.
+     */
+    private readonly inFlight;
+    /** Per-series tallies of the series that retried, gave up or timed out. */
+    private readonly attemptBook;
     constructor(scoringFn: QualityScoringFn, options?: QualityRecorderOptions);
     onStageStart(event: StageEvent): void;
     onRead(event: ReadEvent): void;
     onWrite(event: WriteEvent): void;
     onStageEnd(event: StageEvent): void;
+    /**
+     * A series that ended after giving up or timing out is a drop at its stage. `onAttempt` for the last attempt
+     * fires after that attempt's `onStageEnd` (when it returned), so a recovered series amends the scored entry; a
+     * series that gave up has none, and is scored here.
+     */
+    onAttempt(event: FlowAttemptEvent): void;
     /** Translate: quality entry for a specific runtimeStageId. */
     getByKey(runtimeStageId: string): QualityEntry | undefined;
     /** All per-step quality entries as a read-only Map (insertion-ordered). */

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

@@ -10,6 +10,17 @@
  *   - **Accumulate**: progressive quality up to slider position
  *   - **Aggregate**: overall pipeline quality score
  *
+ * Attempts (10.1): a stage whose retry series GAVE UP (exhausted, declined,
+ * no time left) or TIMED OUT is a quality drop at that stage — `drop:
+ * 'attempts'`, with the series' `attempts` summary and a factor naming why.
+ * A series that gave up never reached `onStageEnd` (the stage failed), so the
+ * recorder scores it itself: `0`, the floor, with the keys its last attempt
+ * read — which is what `qualityTrace()` walks to pair the drop with its
+ * causal parents. A series that timed out and recovered keeps the scoring
+ * function's score and gains the flag. Attempts reach a recorder on the FLOW
+ * channel (`onAttempt`): attach with `attachCombinedRecorder` to see them —
+ * `attachScopeRecorder` scores exactly as before.
+ *
  * @example
  * ```typescript
  * const quality = new QualityRecorder((runtimeStageId, context) => {
@@ -30,6 +41,7 @@
  * quality.getLowest();  // { runtimeStageId: 'call-llm#5', entry: { score: 0.7, ... } }
  * ```
  */
+import { AttemptSeriesBook, gaveUp } from './attemptSeries.js';
 import { KeyedStore } from './KeyedStore.js';
 export class QualityRecorder {
     static _counter = 0;
@@ -38,46 +50,95 @@ export class QualityRecorder {
     /** 1:1 per-step storage (Convention 1 — composed, not inherited). */
     store = new KeyedStore();
     scoringFn;
-    // Per-stage buffers (reset on each stageStart)
-    currentRuntimeStageId = '';
-    currentStageId = '';
-    currentStageName = '';
-    currentKeysRead = [];
-    currentKeysWritten = [];
+    /**
+     * Each execution in flight, by its OWN runtimeStageId (10.1) — every event owns its attribution, so parallel
+     * siblings never score under each other's id or with each other's keys (until 10.0 one shared "current stage"
+     * buffer did). A retried execution's entry restarts with each attempt: a series that gave up is scored with the
+     * keys its last attempt touched. Released at the stage's end, or when a drop consumes it.
+     */
+    inFlight = new Map();
+    /** Per-series tallies of the series that retried, gave up or timed out. */
+    attemptBook = new AttemptSeriesBook();
     constructor(scoringFn, options) {
         this.scoringFn = scoringFn;
         this.id = options?.id ?? `quality-${++QualityRecorder._counter}`;
         this.preferredOperation = options?.preferredOperation ?? 'accumulate';
     }
     onStageStart(event) {
-        this.currentRuntimeStageId = event.runtimeStageId;
-        this.currentStageId = event.stageId;
-        this.currentStageName = event.stageName;
-        this.currentKeysRead = [];
-        this.currentKeysWritten = [];
+        this.inFlight.set(event.runtimeStageId, {
+            stageId: event.stageId,
+            stageName: event.stageName,
+            keysRead: [],
+            keysWritten: [],
+        });
     }
     onRead(event) {
         if (event.key)
-            this.currentKeysRead.push(event.key);
+            this.inFlight.get(event.runtimeStageId)?.keysRead.push(event.key);
     }
     onWrite(event) {
-        this.currentKeysWritten.push(event.key);
+        this.inFlight.get(event.runtimeStageId)?.keysWritten.push(event.key);
     }
     onStageEnd(event) {
-        const { score, factors } = this.scoringFn(this.currentRuntimeStageId, {
-            stageName: this.currentStageName,
-            stageId: this.currentStageId,
-            keysRead: this.currentKeysRead,
-            keysWritten: this.currentKeysWritten,
+        const id = event.runtimeStageId;
+        const step = this.inFlight.get(id) ?? {
+            stageId: event.stageId,
+            stageName: event.stageName,
+            keysRead: [],
+            keysWritten: [],
+        };
+        this.inFlight.delete(id);
+        const { score, factors } = this.scoringFn(id, {
+            stageName: step.stageName,
+            stageId: step.stageId,
+            keysRead: step.keysRead,
+            keysWritten: step.keysWritten,
             duration: event.duration,
         });
-        this.store.set(this.currentRuntimeStageId, {
-            stageName: this.currentStageName,
-            stageId: this.currentStageId,
+        this.store.set(id, {
+            stageName: step.stageName,
+            stageId: step.stageId,
             score: Math.max(0, Math.min(1, score)),
             factors: factors ?? [],
-            keysRead: [...this.currentKeysRead],
-            keysWritten: [...this.currentKeysWritten],
+            keysRead: [...step.keysRead],
+            keysWritten: [...step.keysWritten],
+        });
+    }
+    /**
+     * A series that ended after giving up or timing out is a drop at its stage. `onAttempt` for the last attempt
+     * fires after that attempt's `onStageEnd` (when it returned), so a recovered series amends the scored entry; a
+     * series that gave up has none, and is scored here.
+     */
+    onAttempt(event) {
+        const { record } = event;
+        const state = this.attemptBook.add(record);
+        const summary = state?.summary;
+        if (!summary || (summary.timeout === 0 && !gaveUp(record)))
+            return;
+        const factor = gaveUp(record)
+            ? `attempts: gave up (${[record.reason, record.category].filter(Boolean).join(', ')}) after ${record.attempt} of ${record.of ?? record.attempt}`
+            : `attempts: ${summary.timeout} of ${summary.count} timed out`;
+        const scored = this.store.get(record.series);
+        if (scored) {
+            this.store.set(record.series, {
+                ...scored,
+                factors: [...scored.factors, factor],
+                drop: 'attempts',
+                attempts: summary,
+            });
+            return;
+        }
+        const step = this.inFlight.get(record.series);
+        this.inFlight.delete(record.series);
+        this.store.set(record.series, {
+            stageName: event.stageName,
+            stageId: event.stageId,
+            score: 0,
+            factors: [factor],
+            keysRead: step ? [...step.keysRead] : [],
+            keysWritten: step ? [...step.keysWritten] : [],
+            drop: 'attempts',
+            attempts: summary,
         });
     }
     // ── Per-step query API (delegates to the composed store) ───────────────
@@ -150,11 +211,8 @@ export class QualityRecorder {
     }
     clear() {
         this.store.clear();
-        this.currentRuntimeStageId = '';
-        this.currentStageId = '';
-        this.currentStageName = '';
-        this.currentKeysRead = [];
-        this.currentKeysWritten = [];
+        this.inFlight.clear();
+        this.attemptBook.clear();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"QualityRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/QualityRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * QualityRecorder — per-step quality scoring keyed by runtimeStageId.\n *\n * Collects quality scores during traversal (accumulate pattern).\n * After execution, use qualityTrace() to backtrack from any low-scoring step.\n *\n * Composes a `KeyedStore<QualityEntry>` for O(1) lookup and standard operations\n * (Convention 1 — one purpose per recorder):\n *   - **Translate**: `getByKey('call-llm#5')` — quality at this step\n *   - **Accumulate**: progressive quality up to slider position\n *   - **Aggregate**: overall pipeline quality score\n *\n * @example\n * ```typescript\n * const quality = new QualityRecorder((runtimeStageId, context) => {\n *   // Custom scoring function — return { score: 0.0–1.0, factors? }\n *   if (context.stageName.includes('llm')) return { score: 0.7, factors: ['llm stage'] };\n *   return { score: 1.0 };\n * });\n * executor.attachScopeRecorder(quality);\n * await executor.run();\n *\n * // Per-step score\n * quality.getByKey('call-llm#5');  // { score: 0.7, stageName: 'CallLLM', factors: [...] }\n *\n * // Overall quality\n * quality.getOverallScore();  // 0.85\n *\n * // Lowest-scoring step\n * quality.getLowest();  // { runtimeStageId: 'call-llm#5', entry: { score: 0.7, ... } }\n * ```\n */\n\nimport type { ReadEvent, ScopeRecorder, StageEvent, WriteEvent } from '../scope/types.js';\nimport { KeyedStore } from './KeyedStore.js';\nimport type { RecorderOperation } from './RecorderOperation.js';\n\n/** Per-step quality data stored by QualityRecorder. */\nexport interface QualityEntry {\n  /** Human-readable stage name. */\n  stageName: string;\n  /** Stable stage identifier. */\n  stageId: string;\n  /** Quality score for this step (0.0 = worst, 1.0 = best). */\n  score: number;\n  /** What contributed to this score. */\n  factors: string[];\n  /** Keys read during this step (for backtracking). */\n  keysRead: string[];\n  /** Keys written during this step (for backtracking). */\n  keysWritten: string[];\n}\n\n/**\n * Scoring function called at the end of each stage.\n * Receives the runtimeStageId, stage event, and a summary of reads/writes.\n * Return a score (0.0–1.0) and optional factors explaining the score.\n */\nexport type QualityScoringFn = (\n  runtimeStageId: string,\n  context: {\n    stageName: string;\n    stageId: string;\n    keysRead: string[];\n    keysWritten: string[];\n    duration?: number;\n  },\n) => { score: number; factors?: string[] };\n\n/** Options for QualityRecorder. */\nexport interface QualityRecorderOptions {\n  /** ScopeRecorder ID. Defaults to auto-increment. */\n  id?: string;\n  /** Preferred UI operation. Defaults to 'accumulate' (progressive quality). */\n  preferredOperation?: RecorderOperation;\n}\n\nexport class QualityRecorder implements ScopeRecorder {\n  private static _counter = 0;\n\n  readonly id: string;\n  readonly preferredOperation: RecorderOperation;\n  /** 1:1 per-step storage (Convention 1 — composed, not inherited). */\n  private readonly store = new KeyedStore<QualityEntry>();\n  private readonly scoringFn: QualityScoringFn;\n\n  // Per-stage buffers (reset on each stageStart)\n  private currentRuntimeStageId = '';\n  private currentStageId = '';\n  private currentStageName = '';\n  private currentKeysRead: string[] = [];\n  private currentKeysWritten: string[] = [];\n\n  constructor(scoringFn: QualityScoringFn, options?: QualityRecorderOptions) {\n    this.scoringFn = scoringFn;\n    this.id = options?.id ?? `quality-${++QualityRecorder._counter}`;\n    this.preferredOperation = options?.preferredOperation ?? 'accumulate';\n  }\n\n  onStageStart(event: StageEvent): void {\n    this.currentRuntimeStageId = event.runtimeStageId;\n    this.currentStageId = event.stageId;\n    this.currentStageName = event.stageName;\n    this.currentKeysRead = [];\n    this.currentKeysWritten = [];\n  }\n\n  onRead(event: ReadEvent): void {\n    if (event.key) this.currentKeysRead.push(event.key);\n  }\n\n  onWrite(event: WriteEvent): void {\n    this.currentKeysWritten.push(event.key);\n  }\n\n  onStageEnd(event: StageEvent): void {\n    const { score, factors } = this.scoringFn(this.currentRuntimeStageId, {\n      stageName: this.currentStageName,\n      stageId: this.currentStageId,\n      keysRead: this.currentKeysRead,\n      keysWritten: this.currentKeysWritten,\n      duration: event.duration,\n    });\n\n    this.store.set(this.currentRuntimeStageId, {\n      stageName: this.currentStageName,\n      stageId: this.currentStageId,\n      score: Math.max(0, Math.min(1, score)),\n      factors: factors ?? [],\n      keysRead: [...this.currentKeysRead],\n      keysWritten: [...this.currentKeysWritten],\n    });\n  }\n\n  // ── Per-step query API (delegates to the composed store) ───────────────\n\n  /** Translate: quality entry for a specific runtimeStageId. */\n  getByKey(runtimeStageId: string): QualityEntry | undefined {\n    return this.store.get(runtimeStageId);\n  }\n\n  /** All per-step quality entries as a read-only Map (insertion-ordered). */\n  getMap(): ReadonlyMap<string, QualityEntry> {\n    return this.store.getMap();\n  }\n\n  /** All per-step quality entries (insertion-ordered). */\n  values(): QualityEntry[] {\n    return this.store.values();\n  }\n\n  /** Number of scored steps. */\n  get size(): number {\n    return this.store.size;\n  }\n\n  /** Aggregate: reduce ALL scored steps to a single value. */\n  aggregate<R>(fn: (acc: R, entry: QualityEntry, key: string) => R, initial: R): R {\n    return this.store.aggregate(fn, initial);\n  }\n\n  /** Accumulate: reduce scored steps up to a slider position. */\n  accumulate<R>(fn: (acc: R, entry: QualityEntry, key: string) => R, initial: R, keys?: ReadonlySet<string>): R {\n    return this.store.accumulate(fn, initial, keys);\n  }\n\n  /** Overall quality score — average of all step scores. */\n  getOverallScore(): number {\n    if (this.store.size === 0) return 1.0;\n    const total = this.store.aggregate((sum, e) => sum + e.score, 0);\n    return total / this.store.size;\n  }\n\n  /** Find the lowest-scoring step. */\n  getLowest(): { runtimeStageId: string; entry: QualityEntry } | undefined {\n    let lowest: { runtimeStageId: string; entry: QualityEntry } | undefined;\n    for (const [key, entry] of this.store.getMap()) {\n      if (!lowest || entry.score < lowest.entry.score) {\n        lowest = { runtimeStageId: key, entry };\n      }\n    }\n    return lowest;\n  }\n\n  /** Progressive quality score up to a slider position. */\n  getScoreUpTo(visibleKeys: ReadonlySet<string>): number {\n    let count = 0;\n    const total = this.store.accumulate(\n      (sum, e) => {\n        count++;\n        return sum + e.score;\n      },\n      0,\n      visibleKeys,\n    );\n    return count === 0 ? 1.0 : total / count;\n  }\n\n  toSnapshot() {\n    const steps: Record<string, unknown> = {};\n    for (const [key, value] of this.store.getMap()) {\n      steps[key] = value;\n    }\n    return {\n      name: 'Quality',\n      description: 'Quality scores per execution step with backtracking support',\n      preferredOperation: this.preferredOperation,\n      data: {\n        numericField: 'score',\n        overallScore: this.getOverallScore(),\n        lowestStep: this.getLowest()?.runtimeStageId,\n        steps,\n      },\n    };\n  }\n\n  clear(): void {\n    this.store.clear();\n    this.currentRuntimeStageId = '';\n    this.currentStageId = '';\n    this.currentStageName = '';\n    this.currentKeysRead = [];\n    this.currentKeysWritten = [];\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"QualityRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/QualityRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * QualityRecorder — per-step quality scoring keyed by runtimeStageId.\n *\n * Collects quality scores during traversal (accumulate pattern).\n * After execution, use qualityTrace() to backtrack from any low-scoring step.\n *\n * Composes a `KeyedStore<QualityEntry>` for O(1) lookup and standard operations\n * (Convention 1 — one purpose per recorder):\n *   - **Translate**: `getByKey('call-llm#5')` — quality at this step\n *   - **Accumulate**: progressive quality up to slider position\n *   - **Aggregate**: overall pipeline quality score\n *\n * Attempts (10.1): a stage whose retry series GAVE UP (exhausted, declined,\n * no time left) or TIMED OUT is a quality drop at that stage — `drop:\n * 'attempts'`, with the series' `attempts` summary and a factor naming why.\n * A series that gave up never reached `onStageEnd` (the stage failed), so the\n * recorder scores it itself: `0`, the floor, with the keys its last attempt\n * read — which is what `qualityTrace()` walks to pair the drop with its\n * causal parents. A series that timed out and recovered keeps the scoring\n * function's score and gains the flag. Attempts reach a recorder on the FLOW\n * channel (`onAttempt`): attach with `attachCombinedRecorder` to see them —\n * `attachScopeRecorder` scores exactly as before.\n *\n * @example\n * ```typescript\n * const quality = new QualityRecorder((runtimeStageId, context) => {\n *   // Custom scoring function — return { score: 0.0–1.0, factors? }\n *   if (context.stageName.includes('llm')) return { score: 0.7, factors: ['llm stage'] };\n *   return { score: 1.0 };\n * });\n * executor.attachScopeRecorder(quality);\n * await executor.run();\n *\n * // Per-step score\n * quality.getByKey('call-llm#5');  // { score: 0.7, stageName: 'CallLLM', factors: [...] }\n *\n * // Overall quality\n * quality.getOverallScore();  // 0.85\n *\n * // Lowest-scoring step\n * quality.getLowest();  // { runtimeStageId: 'call-llm#5', entry: { score: 0.7, ... } }\n * ```\n */\n\nimport type { AttemptSummary } from '../attempt/types.js';\nimport type { FlowAttemptEvent } from '../engine/narrative/types.js';\nimport type { ReadEvent, ScopeRecorder, StageEvent, WriteEvent } from '../scope/types.js';\nimport { AttemptSeriesBook, gaveUp } from './attemptSeries.js';\nimport { KeyedStore } from './KeyedStore.js';\nimport type { RecorderOperation } from './RecorderOperation.js';\n\n/** Per-step quality data stored by QualityRecorder. */\nexport interface QualityEntry {\n  /** Human-readable stage name. */\n  stageName: string;\n  /** Stable stage identifier. */\n  stageId: string;\n  /** Quality score for this step (0.0 = worst, 1.0 = best). */\n  score: number;\n  /** What contributed to this score. */\n  factors: string[];\n  /** Keys read during this step (for backtracking). */\n  keysRead: string[];\n  /** Keys written during this step (for backtracking). */\n  keysWritten: string[];\n  /** Present when the step's retry series gave up or timed out — a quality drop by attempts (10.1). */\n  drop?: 'attempts';\n  /** With `drop`: the series at a glance. */\n  attempts?: AttemptSummary;\n}\n\n/**\n * Scoring function called at the end of each stage.\n * Receives the runtimeStageId, stage event, and a summary of reads/writes.\n * Return a score (0.0–1.0) and optional factors explaining the score.\n */\nexport type QualityScoringFn = (\n  runtimeStageId: string,\n  context: {\n    stageName: string;\n    stageId: string;\n    keysRead: string[];\n    keysWritten: string[];\n    duration?: number;\n  },\n) => { score: number; factors?: string[] };\n\n/** One execution between its `onStageStart` and its `onStageEnd` (or the drop that scores it). */\ninterface InFlight {\n  readonly stageId: string;\n  readonly stageName: string;\n  readonly keysRead: string[];\n  readonly keysWritten: string[];\n}\n\n/** Options for QualityRecorder. */\nexport interface QualityRecorderOptions {\n  /** ScopeRecorder ID. Defaults to auto-increment. */\n  id?: string;\n  /** Preferred UI operation. Defaults to 'accumulate' (progressive quality). */\n  preferredOperation?: RecorderOperation;\n}\n\nexport class QualityRecorder implements ScopeRecorder {\n  private static _counter = 0;\n\n  readonly id: string;\n  readonly preferredOperation: RecorderOperation;\n  /** 1:1 per-step storage (Convention 1 — composed, not inherited). */\n  private readonly store = new KeyedStore<QualityEntry>();\n  private readonly scoringFn: QualityScoringFn;\n\n  /**\n   * Each execution in flight, by its OWN runtimeStageId (10.1) — every event owns its attribution, so parallel\n   * siblings never score under each other's id or with each other's keys (until 10.0 one shared \"current stage\"\n   * buffer did). A retried execution's entry restarts with each attempt: a series that gave up is scored with the\n   * keys its last attempt touched. Released at the stage's end, or when a drop consumes it.\n   */\n  private readonly inFlight = new Map<string, InFlight>();\n  /** Per-series tallies of the series that retried, gave up or timed out. */\n  private readonly attemptBook = new AttemptSeriesBook();\n\n  constructor(scoringFn: QualityScoringFn, options?: QualityRecorderOptions) {\n    this.scoringFn = scoringFn;\n    this.id = options?.id ?? `quality-${++QualityRecorder._counter}`;\n    this.preferredOperation = options?.preferredOperation ?? 'accumulate';\n  }\n\n  onStageStart(event: StageEvent): void {\n    this.inFlight.set(event.runtimeStageId, {\n      stageId: event.stageId,\n      stageName: event.stageName,\n      keysRead: [],\n      keysWritten: [],\n    });\n  }\n\n  onRead(event: ReadEvent): void {\n    if (event.key) this.inFlight.get(event.runtimeStageId)?.keysRead.push(event.key);\n  }\n\n  onWrite(event: WriteEvent): void {\n    this.inFlight.get(event.runtimeStageId)?.keysWritten.push(event.key);\n  }\n\n  onStageEnd(event: StageEvent): void {\n    const id = event.runtimeStageId;\n    const step = this.inFlight.get(id) ?? {\n      stageId: event.stageId,\n      stageName: event.stageName,\n      keysRead: [],\n      keysWritten: [],\n    };\n    this.inFlight.delete(id);\n    const { score, factors } = this.scoringFn(id, {\n      stageName: step.stageName,\n      stageId: step.stageId,\n      keysRead: step.keysRead,\n      keysWritten: step.keysWritten,\n      duration: event.duration,\n    });\n\n    this.store.set(id, {\n      stageName: step.stageName,\n      stageId: step.stageId,\n      score: Math.max(0, Math.min(1, score)),\n      factors: factors ?? [],\n      keysRead: [...step.keysRead],\n      keysWritten: [...step.keysWritten],\n    });\n  }\n\n  /**\n   * A series that ended after giving up or timing out is a drop at its stage. `onAttempt` for the last attempt\n   * fires after that attempt's `onStageEnd` (when it returned), so a recovered series amends the scored entry; a\n   * series that gave up has none, and is scored here.\n   */\n  onAttempt(event: FlowAttemptEvent): void {\n    const { record } = event;\n    const state = this.attemptBook.add(record);\n    const summary = state?.summary;\n    if (!summary || (summary.timeout === 0 && !gaveUp(record))) return;\n    const factor = gaveUp(record)\n      ? `attempts: gave up (${[record.reason, record.category].filter(Boolean).join(', ')}) after ${\n          record.attempt\n        } of ${record.of ?? record.attempt}`\n      : `attempts: ${summary.timeout} of ${summary.count} timed out`;\n    const scored = this.store.get(record.series);\n    if (scored) {\n      this.store.set(record.series, {\n        ...scored,\n        factors: [...scored.factors, factor],\n        drop: 'attempts',\n        attempts: summary,\n      });\n      return;\n    }\n    const step = this.inFlight.get(record.series);\n    this.inFlight.delete(record.series);\n    this.store.set(record.series, {\n      stageName: event.stageName,\n      stageId: event.stageId,\n      score: 0,\n      factors: [factor],\n      keysRead: step ? [...step.keysRead] : [],\n      keysWritten: step ? [...step.keysWritten] : [],\n      drop: 'attempts',\n      attempts: summary,\n    });\n  }\n\n  // ── Per-step query API (delegates to the composed store) ───────────────\n\n  /** Translate: quality entry for a specific runtimeStageId. */\n  getByKey(runtimeStageId: string): QualityEntry | undefined {\n    return this.store.get(runtimeStageId);\n  }\n\n  /** All per-step quality entries as a read-only Map (insertion-ordered). */\n  getMap(): ReadonlyMap<string, QualityEntry> {\n    return this.store.getMap();\n  }\n\n  /** All per-step quality entries (insertion-ordered). */\n  values(): QualityEntry[] {\n    return this.store.values();\n  }\n\n  /** Number of scored steps. */\n  get size(): number {\n    return this.store.size;\n  }\n\n  /** Aggregate: reduce ALL scored steps to a single value. */\n  aggregate<R>(fn: (acc: R, entry: QualityEntry, key: string) => R, initial: R): R {\n    return this.store.aggregate(fn, initial);\n  }\n\n  /** Accumulate: reduce scored steps up to a slider position. */\n  accumulate<R>(fn: (acc: R, entry: QualityEntry, key: string) => R, initial: R, keys?: ReadonlySet<string>): R {\n    return this.store.accumulate(fn, initial, keys);\n  }\n\n  /** Overall quality score — average of all step scores. */\n  getOverallScore(): number {\n    if (this.store.size === 0) return 1.0;\n    const total = this.store.aggregate((sum, e) => sum + e.score, 0);\n    return total / this.store.size;\n  }\n\n  /** Find the lowest-scoring step. */\n  getLowest(): { runtimeStageId: string; entry: QualityEntry } | undefined {\n    let lowest: { runtimeStageId: string; entry: QualityEntry } | undefined;\n    for (const [key, entry] of this.store.getMap()) {\n      if (!lowest || entry.score < lowest.entry.score) {\n        lowest = { runtimeStageId: key, entry };\n      }\n    }\n    return lowest;\n  }\n\n  /** Progressive quality score up to a slider position. */\n  getScoreUpTo(visibleKeys: ReadonlySet<string>): number {\n    let count = 0;\n    const total = this.store.accumulate(\n      (sum, e) => {\n        count++;\n        return sum + e.score;\n      },\n      0,\n      visibleKeys,\n    );\n    return count === 0 ? 1.0 : total / count;\n  }\n\n  toSnapshot() {\n    const steps: Record<string, unknown> = {};\n    for (const [key, value] of this.store.getMap()) {\n      steps[key] = value;\n    }\n    return {\n      name: 'Quality',\n      description: 'Quality scores per execution step with backtracking support',\n      preferredOperation: this.preferredOperation,\n      data: {\n        numericField: 'score',\n        overallScore: this.getOverallScore(),\n        lowestStep: this.getLowest()?.runtimeStageId,\n        steps,\n      },\n    };\n  }\n\n  clear(): void {\n    this.store.clear();\n    this.inFlight.clear();\n    this.attemptBook.clear();\n  }\n}\n"]}

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

@@ -15,10 +15,16 @@
  *   three primitive channels, one live graph, queryable at any moment during
  *   or after a run.
  *
- * What it records — THREE node kinds for complete composition coverage:
+ * What it records — FOUR node kinds for complete composition coverage:
  *   1. 'subflow'          — via onSubflowEntry (a mounted subflow boundary)
  *   2. 'fork-branch'      — via onFork (one node per child, synthesized)
  *   3. 'decision-branch'  — via onDecision (the chosen branch, synthesized)
+ *   4. 'attempt-series'   — via onAttempt (10.1): a stage execution that
+ *      RETRIED, GAVE UP or TIMED OUT (`recorder/attemptSeries.ts · isRetryEvidence`), with its
+ *      `attemptSummary` and its ordered `attempts`. A retry is a loop, so each
+ *      retry decision is a self-edge of kind 'retry' on the node — the way
+ *      onLoop draws 'loop-iteration'. A stage that ran once (with or without a
+ *      policy) is no node, as before.
  *
  *   When a fork-branch or decision-branch target IS ALSO a subflow, the
  *   subsequent onSubflowEntry creates a subflow CHILD of the synthetic node.
@@ -48,11 +54,13 @@
  * topo.getSubflowNodes();                     // only mounted subflows
  * ```
  */
-import type { FlowDecisionEvent, FlowForkEvent, FlowLoopEvent, FlowRecorder, FlowSubflowEvent } from '../engine/narrative/types.js';
+import type { AttemptSummary } from '../attempt/types.js';
+import type { FlowAttemptEvent, FlowDecisionEvent, FlowForkEvent, FlowLoopEvent, FlowRecorder, FlowSubflowEvent } from '../engine/narrative/types.js';
+import type { AttemptRef } from './attemptSeries.js';
 /** The kind of composition unit a node represents. */
-export type TopologyNodeKind = 'subflow' | 'fork-branch' | 'decision-branch';
+export type TopologyNodeKind = 'subflow' | 'fork-branch' | 'decision-branch' | 'attempt-series';
 /** How the traversal reached this node — drives consumer layout decisions. */
-export type TopologyIncomingKind = 'root' | 'next' | 'fork-branch' | 'decision-branch' | 'loop-iteration';
+export type TopologyIncomingKind = 'root' | 'next' | 'fork-branch' | 'decision-branch' | 'loop-iteration' | 'retry';
 /** A composition-significant point in the graph. */
 export interface TopologyNode {
     /** Unique id. Subflows use their subflowId (with `#n` suffix on re-entry).
@@ -76,8 +84,16 @@ export interface TopologyNode {
     /** runtimeStageId when the corresponding subflow exited. Only meaningful
      *  for kind='subflow'; fork/decision-branch nodes are instantaneous. */
     exitedAt?: string;
-    /** Kind-specific extras: forkParent, decider, rationale, description. */
+    /** Kind-specific extras: forkParent, decider, rationale, description; stageId for an attempt series. */
     readonly metadata?: Readonly<Record<string, unknown>>;
+    /**
+     * kind='attempt-series' only: the series at a glance — equal to the stage's
+     * `StageSnapshot.attemptSummary`. Absent while the series is in flight (or
+     * when the run's signal cut its wait: no record says how it ended).
+     */
+    readonly attemptSummary?: AttemptSummary;
+    /** kind='attempt-series' only: the series' attempts, in order. */
+    readonly attempts?: readonly AttemptRef[];
 }
 /** A traversal transition between two nodes. */
 export interface TopologyEdge {
@@ -135,12 +151,26 @@ export declare class TopologyRecorder implements FlowRecorder {
      * TopologyRecorder is supposed to expose.
      */
     private readonly previousSubflowInScope;
+    /** Open subflow node id by its path-prefixed subflowId — where a stage's attempt series hangs. */
+    private readonly openSubflowByPath;
+    /** Per-series tallies of the series that are evidence (retried, gave up or timed out). */
+    private readonly attemptBook;
     constructor(options?: TopologyRecorderOptions);
     onSubflowEntry(event: FlowSubflowEvent): void;
     onSubflowExit(event: FlowSubflowEvent): void;
     onFork(event: FlowForkEvent): void;
     onDecision(event: FlowDecisionEvent): void;
     onLoop(event: FlowLoopEvent): void;
+    onAttempt(event: FlowAttemptEvent): void;
+    /**
+     * A new series node, under its parent: the pending fork-branch / decision-
+     * branch of the same name (a fork child or a chosen branch that is a plain
+     * stage), else the open subflow the stage runs in (read off its
+     * runtimeStageId — the stack top can be a parallel sibling), else the top
+     * level. One edge from
+     * the parent, as for every composition child.
+     */
+    private placeSeries;
     /** Called by the executor before each `run()` — resets all state. */
     clear(): void;
     /** Live snapshot of the composition graph. Safe during or after a run. */