agentwrangler 0.1.0

package/dist/detector/detectors/d6_tool_result_bloat.js

@@ -0,0 +1,301 @@
+/**
+ * src/detector/detectors/d6_tool_result_bloat.ts — D6 TOOL_RESULT_BLOAT.
+ *
+ * Fires PER-SESSION when a session carries a large volume of tool-result output
+ * (size only, never content — the privacy boundary holds). A tool_result rides
+ * in context and is re-processed at the cached rate on every later turn, so a
+ * bloated session pays a recurring carry cost.
+ *
+ * A session qualifies when (UNVALIDATED defaults, labeled in every rec):
+ *   - summed tool_result_bytes ≥ 30% of the session's cap-weighted total, AND
+ *   - summed tool_result_bytes ≥ 200 KB (absolute floor; skips tiny sessions).
+ * The detector only surfaces recs when ≥ 3 such sessions exist in the window
+ * (a recurrence gate, so one-off large dumps don't fire).
+ *
+ * When event metadata is available, D6 annotates the session with the largest
+ * recurring tool-name class and a directional carry estimate. This remains size-only:
+ * no tool input/output content is read or persisted.
+ *
+ * modeled_savings (R12 — opt-in calibration gate):
+ *   modeled_savings_u_per_wk is non-null ONLY when a calibrated bytes_per_token
+ *   is present in user_config (requires explicit opt-in). Without calibration it
+ *   stays null — an honest default: we make no $ claim on the raw heuristic.
+ *
+ * scopeKey: "D6|<session_id>".
+ */
+import { LIST_PRICES, modelTier } from "../../ingest/pricing.js";
+import { capWeightedTokens } from "../../query/cap-weighted.js";
+import { resolveBytesPerToken } from "../calibration.js";
+import { D6_ABS_FLOOR_BYTES, D6_AVOIDANCE_FRACTION, D6_BLOAT_SHARE, D6_MIN_SESSIONS, d6Savings, } from "../savings.js";
+/** Resolve cache-read price ($/MTok = µUSD/token) from a pricing snapshot or list price. */
+function cacheReadPrice(unitPricesJson, model) {
+    if (unitPricesJson) {
+        try {
+            const arr = JSON.parse(unitPricesJson);
+            if (typeof arr[2] === "number")
+                return arr[2];
+        }
+        catch {
+            // fall through to list price
+        }
+    }
+    const tier = modelTier(model);
+    const lp = tier ? LIST_PRICES[tier] : undefined;
+    return lp ? lp[2] : 0;
+}
+/**
+ * Compute the blended cache-read price ($/MTok) for a session, weighted by
+ * cache_read_tokens across all turns — mirrors D8's blended write-price approach.
+ */
+function blendedCacheReadPriceForSession(db, sessionId, fromIso, toIso) {
+    const rows = db
+        .prepare(`SELECT t.cache_read_tokens, t.model, ps.unit_prices_json
+         FROM turns t
+         LEFT JOIN pricing_snapshots ps ON ps.snapshot_id = t.pricing_snapshot_id
+        WHERE t.session_id = ? AND t.ts >= ? AND t.ts < ? AND t.provisional = 0`)
+        .all(sessionId, fromIso, toIso);
+    let totalCrTokens = 0;
+    let totalCrSpend = 0;
+    for (const r of rows) {
+        const price = cacheReadPrice(r.unit_prices_json, r.model);
+        totalCrTokens += r.cache_read_tokens;
+        totalCrSpend += r.cache_read_tokens * price;
+    }
+    return totalCrTokens > 0 ? totalCrSpend / totalCrTokens : 0;
+}
+function d6DirectionalFormula(toolResultBytes, bloatShare, sessionCapWeightedTokens, bytesPerToken) {
+    return {
+        model: "D6_TOOL_RESULT_BLOAT_V1",
+        kind: "DIRECTIONAL",
+        inputs: {
+            tool_result_bytes: toolResultBytes,
+            bytes_per_token: bytesPerToken,
+            bloat_share: Number(bloatShare.toFixed(4)),
+            session_cap_weighted_tokens: Math.round(sessionCapWeightedTokens),
+        },
+        expression: "tool_result_bytes / bytes_per_token compared with session_cap_weighted_tokens; heuristic directional exposure only (no avoidable-token or USD estimate)",
+    };
+}
+/** True only for SQLite "no such table/column" errors from an un-migrated DB. */
+function isMissingSchemaError(error) {
+    return (error instanceof Error &&
+        error.code === "SQLITE_ERROR" &&
+        /no such (table|column)/i.test(error.message));
+}
+/** Keep event-provided tool identity structural and bounded. */
+function boundedToolNameClass(toolName) {
+    const trimmed = toolName.trim();
+    return trimmed === "" ? null : trimmed.slice(0, 64);
+}
+function d6Attribution(db, sessionId, fromIso, toIso, bytesPerToken) {
+    const empty = {
+        attributed_tool: null,
+        attributed_result_bytes: null,
+        carry_turns: null,
+        carry_exposure_tokens_directional: null,
+    };
+    try {
+        const events = db
+            .prepare(`SELECT e.event_id, e.tool_name, e.result_bytes,
+                m.owner_message_id, m.block_index
+           FROM tool_events e
+           LEFT JOIN tool_event_metadata m ON m.event_id = e.event_id
+           LEFT JOIN turns owner
+             ON owner.message_id = m.owner_message_id
+            AND owner.session_id = e.session_id
+            AND owner.ts >= ? AND owner.ts < ?
+            AND owner.provisional = 0
+          WHERE e.session_id = ?
+            AND e.ts >= ? AND e.ts < ?
+            AND e.result_bytes IS NOT NULL
+            AND e.result_bytes > 0
+            AND m.owner_message_id IS NOT NULL
+            AND owner.message_id IS NOT NULL
+          ORDER BY e.ts ASC, m.block_index ASC, e.event_id ASC`)
+            .all(fromIso, toIso, sessionId, fromIso, toIso);
+        if (events.length === 0)
+            return empty;
+        const laterTurns = db
+            .prepare(`SELECT message_id, ts
+           FROM turns
+          WHERE session_id = ?
+            AND ts >= ? AND ts < ?
+            AND provisional = 0
+          ORDER BY ts ASC, message_id ASC`)
+            .all(sessionId, fromIso, toIso);
+        const turnIndexByMessage = new Map(laterTurns.map((turn, index) => [turn.message_id, index]));
+        const byTool = new Map();
+        for (const event of events) {
+            if (event.result_bytes === null || event.owner_message_id === null)
+                continue;
+            const ownerIndex = turnIndexByMessage.get(event.owner_message_id);
+            if (ownerIndex === undefined)
+                continue;
+            const tool = boundedToolNameClass(event.tool_name);
+            if (tool === null)
+                continue;
+            const existing = byTool.get(tool);
+            if (existing === undefined) {
+                byTool.set(tool, {
+                    bytes: event.result_bytes,
+                    eventCount: 1,
+                    firstOwnerIndex: ownerIndex,
+                });
+            }
+            else {
+                existing.bytes += event.result_bytes;
+                existing.eventCount += 1;
+                if (ownerIndex < existing.firstOwnerIndex)
+                    existing.firstOwnerIndex = ownerIndex;
+            }
+        }
+        const recurring = [...byTool.entries()]
+            .filter(([, value]) => value.eventCount >= 2)
+            .sort(([toolA, valueA], [toolB, valueB]) => {
+            return valueB.bytes - valueA.bytes || (toolA < toolB ? -1 : toolA > toolB ? 1 : 0);
+        });
+        const winner = recurring[0];
+        if (winner === undefined)
+            return empty;
+        const [attributedTool, value] = winner;
+        // Directional upper bound: assumes the result stays in context for every later
+        // turn. Real carry is shorter when context is trimmed, so this over-estimates
+        // (~20% observed); it is exposure, never an avoidable-token or savings claim.
+        const carryTurns = Math.max(0, laterTurns.length - value.firstOwnerIndex - 1);
+        return {
+            attributed_tool: attributedTool,
+            attributed_result_bytes: value.bytes,
+            carry_turns: carryTurns,
+            carry_exposure_tokens_directional: Number(((value.bytes * carryTurns) / bytesPerToken).toFixed(4)),
+        };
+    }
+    catch (error) {
+        // Older or partially migrated databases lack event metadata; keep the
+        // already-qualified session-level recommendation instead of failing D6.
+        // Only swallow the missing-schema case — a genuine query defect must surface.
+        if (isMissingSchemaError(error))
+            return empty;
+        throw error;
+    }
+}
+export const d6Detector = {
+    id: "D6",
+    name: "TOOL_RESULT_BLOAT",
+    evaluate(db, ctx) {
+        // Resolve bytes-per-token: calibrated value from user_config, fallback to 4.
+        const bptResolution = resolveBytesPerToken(db);
+        const bytesPerToken = bptResolution.ratio;
+        const capRows = capWeightedTokens(db, {
+            fromIso: ctx.fromIso,
+            toIso: ctx.toIso,
+            groupBy: "session_id",
+        });
+        const capBySession = new Map(capRows.map((r) => [r.group ?? "", r.cap_weighted_tokens]));
+        const sessions = db
+            .prepare(`SELECT t.session_id, t.workspace_id,
+                COALESCE(SUM(t.tool_result_bytes), 0) AS tool_result_bytes,
+                COUNT(*) AS turns
+           FROM turns t
+          WHERE t.ts >= ? AND t.ts < ? AND t.provisional = 0
+          GROUP BY t.session_id
+         HAVING SUM(t.tool_result_bytes) IS NOT NULL`)
+            .all(ctx.fromIso, ctx.toIso);
+        // Identify qualifying sessions (bloat share + absolute floor).
+        // Convert bytes → tokens before computing the share so the ratio is unitless.
+        const qualifying = [];
+        for (const s of sessions) {
+            const capTotal = capBySession.get(s.session_id) ?? 0;
+            if (capTotal <= 0)
+                continue;
+            const bloatTokens = s.tool_result_bytes / bytesPerToken;
+            const bloatShare = bloatTokens / capTotal;
+            if (bloatShare >= D6_BLOAT_SHARE && s.tool_result_bytes >= D6_ABS_FLOOR_BYTES) {
+                qualifying.push({ row: s, capTotal, bloatShare });
+            }
+        }
+        // Recurrence gate: only surface when the pattern repeats across ≥ N sessions.
+        if (qualifying.length < D6_MIN_SESSIONS) {
+            return {
+                fired: [],
+                status: "INACTIVE",
+                note: `${qualifying.length} bloated session(s) (< ${D6_MIN_SESSIONS} threshold)`,
+            };
+        }
+        const fired = [];
+        for (const { row, capTotal, bloatShare } of qualifying) {
+            const attribution = d6Attribution(db, row.session_id, ctx.fromIso, ctx.toIso, bytesPerToken);
+            // Compute modeled savings only when calibration is present AND attribution
+            // provided a carry estimate. Without calibration the heuristic ratio is
+            // unvalidated, so we make no $ claim (honest default: stays null).
+            let modeledSavingsU = null;
+            let savingsFormula = null;
+            let calibrationCaveat = null;
+            if (bptResolution.calibrated &&
+                attribution.carry_exposure_tokens_directional !== null &&
+                attribution.carry_exposure_tokens_directional > 0) {
+                const blendedReadPrice = blendedCacheReadPriceForSession(db, row.session_id, ctx.fromIso, ctx.toIso);
+                const { savingsU, formula } = d6Savings(attribution.carry_exposure_tokens_directional, D6_AVOIDANCE_FRACTION, blendedReadPrice);
+                if (savingsU > 0) {
+                    modeledSavingsU = savingsU;
+                    savingsFormula = formula;
+                    calibrationCaveat = {
+                        tokenizer: "anthropic count_tokens",
+                        model: bptResolution.model,
+                        measured_at: bptResolution.measuredAt,
+                        note: "conservative — proxy corpora undercount Claude tokens, so real savings are likely ≥ shown",
+                    };
+                }
+            }
+            // When calibrated with savings, use the savings formula; otherwise directional.
+            const formula = savingsFormula !== null
+                ? savingsFormula
+                : d6DirectionalFormula(row.tool_result_bytes, bloatShare, capTotal, bytesPerToken);
+            const bytesPerTokenNote = bptResolution.calibrated
+                ? `calibrated via count_tokens (${bptResolution.provenance ?? ""})`
+                : "heuristic estimate; actual tokenization is not observed";
+            fired.push({
+                scopeKey: `D6|${row.session_id}`,
+                category: "TOOLING",
+                scope_workspace_id: row.workspace_id,
+                lever: "Use scoped reads (line ranges) and head/filters over full dumps; truncate or summarize verbose tool output; move exploration to subagents to keep bloat off the premium main thread.",
+                target_metric: "tool_result_byte_share",
+                modeled_savings_u_per_wk: modeledSavingsU,
+                modeled_formula: formula,
+                evidence: {
+                    title: `Trim tool output: ${Math.round(bloatShare * 100)}% bloat share in session`,
+                    session_id: row.session_id,
+                    workspace_id: row.workspace_id,
+                    tool_result_bytes: row.tool_result_bytes,
+                    session_cap_weighted_tokens: capTotal,
+                    bloat_share: Number(bloatShare.toFixed(4)),
+                    turn_count: row.turns,
+                    bloat_share_threshold: D6_BLOAT_SHARE,
+                    abs_floor_bytes_threshold: D6_ABS_FLOOR_BYTES,
+                    min_sessions_threshold: D6_MIN_SESSIONS,
+                    bytes_per_token: bytesPerToken,
+                    bytes_per_token_note: bytesPerTokenNote,
+                    thresholds_unvalidated: true,
+                    attributed_tool: attribution.attributed_tool,
+                    attributed_result_bytes: attribution.attributed_result_bytes,
+                    carry_turns: attribution.carry_turns,
+                    carry_exposure_tokens_directional: attribution.carry_exposure_tokens_directional,
+                    ...(calibrationCaveat !== null ? { calibration: calibrationCaveat } : {}),
+                    steps: [
+                        "Open the session and find the turns carrying large tool-result output",
+                        "Replace full-file dumps with scoped reads (line ranges) and head/grep filters",
+                        "Truncate or summarize verbose command output before it enters context",
+                        "Move broad exploration to a subagent so the bloat stays off the main thread",
+                    ],
+                },
+            });
+        }
+        if (fired.length === 0) {
+            return { fired: [], status: "INACTIVE", note: "no qualifying bloated session" };
+        }
+        return {
+            fired,
+            status: "ACTIVE",
+            note: `${fired.length} session(s) with tool-result bloat`,
+        };
+    },
+};

package/dist/detector/detectors/d7_loop_retry_waste.js

@@ -0,0 +1,345 @@
+/**
+ * D7 LOOP_RETRY_WASTE.
+ *
+ * Detects three privacy-safe structural loop signals in reconciled sessions:
+ * repeated identical tool calls, repeated TEST_FAIL results, and repeated reads
+ * of one path/region identity without an intervening edit/write to that path.
+ * Raw tool inputs, outputs, commands, paths, and path hashes never leave the
+ * query/detection boundary.
+ */
+import { capWeightForTurn, resolveCapReadCoeff } from "../../query/cap-weighted.js";
+const MIN_RUN = 3;
+const MIN_TRIGRAM_REPEATS = 3;
+function identicalCallKey(row) {
+    return row === undefined || row.input_hash === null
+        ? null
+        : `${row.tool_name.length}:${row.tool_name}${row.input_hash}`;
+}
+function markRuns(rows, keyFor, target, excessTarget) {
+    let run = [];
+    let runKey = null;
+    const flush = () => {
+        if (run.length >= MIN_RUN) {
+            for (const row of run)
+                target.add(row.event_id);
+            // The first event is the necessary baseline attempt. Only later events
+            // contribute to the conservative repeat-excess exposure estimate.
+            for (const row of run.slice(1))
+                excessTarget.add(row.event_id);
+        }
+        run = [];
+        runKey = null;
+    };
+    for (const row of rows) {
+        const key = keyFor(row);
+        if (key !== null && key === runKey) {
+            run.push(row);
+        }
+        else {
+            flush();
+            if (key !== null) {
+                run = [row];
+                runKey = key;
+            }
+        }
+    }
+    flush();
+}
+function markRedundantReads(rows, target, excessTarget) {
+    const readsSinceWrite = new Map();
+    const markIfQualifying = (reads) => {
+        if (reads && reads.length >= MIN_RUN) {
+            for (const row of reads)
+                target.add(row.event_id);
+            // Preserve one baseline read; only repeated reads are excess exposure.
+            for (const row of reads.slice(1))
+                excessTarget.add(row.event_id);
+        }
+    };
+    const flushPath = (pathIdentity) => {
+        const regions = readsSinceWrite.get(pathIdentity);
+        if (regions !== undefined) {
+            for (const reads of regions.values())
+                markIfQualifying(reads);
+        }
+        readsSinceWrite.delete(pathIdentity);
+    };
+    for (const row of rows) {
+        const pathIdentity = row.file_path_hash;
+        if (pathIdentity === null)
+            continue;
+        const tool = row.tool_name.toLowerCase();
+        if (tool === "edit" || tool === "write") {
+            flushPath(pathIdentity);
+            continue;
+        }
+        if (tool !== "read" || row.input_hash === null)
+            continue;
+        // input_hash includes normalized file_path plus Read offset/limit, so
+        // different chunks of one file remain distinct and do not look redundant.
+        const regions = readsSinceWrite.get(pathIdentity) ?? new Map();
+        const reads = regions.get(row.input_hash) ?? [];
+        reads.push(row);
+        regions.set(row.input_hash, reads);
+        readsSinceWrite.set(pathIdentity, regions);
+    }
+    for (const regions of readsSinceWrite.values()) {
+        for (const reads of regions.values())
+            markIfQualifying(reads);
+    }
+}
+function markThreeGramLoops(rows, target, excessTarget) {
+    const tripleLength = 3;
+    const minimumRunLength = tripleLength * MIN_TRIGRAM_REPEATS;
+    for (let start = 0; start <= rows.length - minimumRunLength;) {
+        const first = identicalCallKey(rows[start]);
+        const second = identicalCallKey(rows[start + 1]);
+        const third = identicalCallKey(rows[start + 2]);
+        if (first === null ||
+            second === null ||
+            third === null ||
+            (first === second && second === third)) {
+            start += 1;
+            continue;
+        }
+        let end = start + tripleLength;
+        while (end + tripleLength <= rows.length &&
+            identicalCallKey(rows[end]) === first &&
+            identicalCallKey(rows[end + 1]) === second &&
+            identicalCallKey(rows[end + 2]) === third) {
+            end += tripleLength;
+        }
+        if (end - start < minimumRunLength) {
+            start += 1;
+            continue;
+        }
+        for (const row of rows.slice(start, end))
+            target.add(row.event_id);
+        for (const row of rows.slice(start + tripleLength, end))
+            excessTarget.add(row.event_id);
+        start = end;
+    }
+}
+export const d7Detector = {
+    id: "D7",
+    name: "LOOP_RETRY_WASTE",
+    evaluate(db, ctx) {
+        const candidateRows = db
+            .prepare(`WITH metadata AS (
+               SELECT event_id, COUNT(*) AS metadata_rows,
+                      MAX(file_path_hash) AS file_path_hash,
+                      MAX(owner_message_id) AS owner_message_id,
+                      MAX(block_index) AS block_index
+                 FROM tool_event_metadata
+                GROUP BY event_id
+             ),
+             owners AS (
+               SELECT message_id, COUNT(*) AS owner_rows,
+                      MAX(session_id) AS owner_session_id,
+                      MAX(workspace_id) AS owner_workspace_id,
+                      MAX(ts) AS owner_ts,
+                      MAX(provisional) AS owner_provisional,
+                      MAX(input_tokens) AS input_tokens,
+                      MAX(output_tokens) AS output_tokens,
+                      MAX(cache_read_tokens) AS cache_read_tokens,
+                      MAX(cache_write_5m) AS cache_write_5m,
+                      MAX(cache_write_1h) AS cache_write_1h,
+                      MAX(cache_write_other) AS cache_write_other
+                 FROM turns
+                GROUP BY message_id
+             ),
+             params(from_ts, as_of_ts) AS (VALUES (?, ?)),
+             candidates AS (
+               SELECT e.event_id, e.session_id, e.ts AS event_ts, e.tool_name,
+                      e.input_hash, e.exit_class,
+                      s.workspace_id AS session_workspace_id,
+                      m.file_path_hash, m.owner_message_id, m.block_index,
+                      COALESCE(m.metadata_rows, 0) AS metadata_rows,
+                      COALESCE(t.owner_rows, 0) AS owner_rows,
+                      t.owner_session_id, t.owner_workspace_id, t.owner_ts,
+                      t.owner_provisional,
+                      t.input_tokens, t.output_tokens, t.cache_read_tokens,
+                      t.cache_write_5m, t.cache_write_1h, t.cache_write_other,
+                      p.from_ts, p.as_of_ts
+                 FROM tool_events e INDEXED BY idx_tool_ts_session_event
+                 JOIN sessions s
+                   ON s.session_id = e.session_id
+                  AND s.state = 'RECONCILED'
+                 LEFT JOIN metadata m ON m.event_id = e.event_id
+                 LEFT JOIN owners t ON t.message_id = m.owner_message_id
+                 CROSS JOIN params p
+             ),
+             classified AS (
+               SELECT *,
+                      CASE WHEN strftime('%s', event_ts) IS NULL THEN 1 ELSE 0 END AS event_malformed,
+                      CASE WHEN strftime('%s', event_ts) IS NOT NULL
+                                AND julianday(event_ts) >= julianday(from_ts)
+                                AND julianday(event_ts) < julianday(as_of_ts)
+                           THEN 1 ELSE 0 END AS in_window,
+                      CASE WHEN metadata_rows = 1 AND owner_rows = 1
+                                AND owner_session_id = session_id
+                                AND owner_workspace_id = session_workspace_id
+                                AND owner_provisional = 0
+                                AND strftime('%s', owner_ts) IS NOT NULL
+                                AND julianday(owner_ts) >= julianday(from_ts)
+                                AND julianday(owner_ts) < julianday(as_of_ts)
+                           THEN 1 ELSE 0 END AS owner_eligible
+                 FROM candidates
+             ),
+             eligible AS (
+               SELECT *, in_window AS denominator_event,
+                      CASE WHEN in_window = 1 AND owner_eligible = 1
+                           THEN 1 ELSE 0 END AS covered_event
+                 FROM classified
+             )
+        SELECT event_id, session_id, session_workspace_id AS workspace_id, event_ts AS ts,
+               tool_name, input_hash, exit_class, file_path_hash, owner_message_id, block_index,
+               input_tokens, output_tokens, cache_read_tokens,
+               cache_write_5m, cache_write_1h, cache_write_other,
+               metadata_rows, owner_eligible, covered_event
+          FROM eligible
+         WHERE denominator_event = 1
+         ORDER BY session_id ASC, ts ASC, block_index ASC, event_id ASC`)
+            .all(ctx.fromIso, ctx.toIso);
+        const coverageBySession = new Map();
+        for (const row of candidateRows) {
+            const coverage = coverageBySession.get(row.session_id) ?? { denominator: 0, covered: 0 };
+            coverage.denominator += 1;
+            if (row.covered_event === 1)
+                coverage.covered += 1;
+            coverageBySession.set(row.session_id, coverage);
+        }
+        const rows = candidateRows.filter((row) => row.covered_event === 1);
+        if (rows.length === 0) {
+            return {
+                fired: [],
+                status: "NOT_EVALUATED",
+                note: "0 enriched tool events available in the trailing window; forward-only D7 coverage has not started",
+            };
+        }
+        const bySession = new Map();
+        for (const row of rows) {
+            const session = bySession.get(row.session_id) ?? {
+                workspaceId: row.workspace_id,
+                rows: [],
+            };
+            session.rows.push(row);
+            bySession.set(row.session_id, session);
+        }
+        const totalRows = db
+            .prepare(`SELECT t.session_id, COUNT(*) AS turn_count
+           FROM turns t INDEXED BY idx_turns_ts_provisional_session
+           JOIN sessions s ON s.session_id = t.session_id
+          WHERE t.ts >= ? AND t.ts < ?
+            AND t.provisional = 0
+            AND s.state = 'RECONCILED'
+          GROUP BY t.session_id`)
+            .all(ctx.fromIso, ctx.toIso);
+        const totalTurnsBySession = new Map(totalRows.map((row) => [row.session_id, row.turn_count]));
+        const capReadCoeff = resolveCapReadCoeff(db);
+        const fired = [];
+        for (const [sessionId, session] of bySession) {
+            const identicalCalls = new Set();
+            const testFails = new Set();
+            const redundantReads = new Set();
+            const threeGramLoops = new Set();
+            const repeatExcessEventIds = new Set();
+            markRuns(session.rows, identicalCallKey, identicalCalls, repeatExcessEventIds);
+            markRuns(session.rows, (row) => (row.exit_class === "TEST_FAIL" ? "TEST_FAIL" : null), testFails, repeatExcessEventIds);
+            markRedundantReads(session.rows, redundantReads, repeatExcessEventIds);
+            markThreeGramLoops(session.rows, threeGramLoops, repeatExcessEventIds);
+            const flaggedEventIds = new Set([
+                ...identicalCalls,
+                ...testFails,
+                ...redundantReads,
+                ...threeGramLoops,
+            ]);
+            if (flaggedEventIds.size === 0)
+                continue;
+            const flaggedTurns = new Map();
+            const repeatExcessTurns = new Map();
+            for (const row of session.rows) {
+                if (flaggedEventIds.has(row.event_id))
+                    flaggedTurns.set(row.owner_message_id, row);
+                if (repeatExcessEventIds.has(row.event_id)) {
+                    repeatExcessTurns.set(row.owner_message_id, row);
+                }
+            }
+            let repeatExcessTurnCapWeightedTokens = 0;
+            for (const row of repeatExcessTurns.values()) {
+                repeatExcessTurnCapWeightedTokens += capWeightForTurn(row, capReadCoeff);
+            }
+            const totalTurns = totalTurnsBySession.get(sessionId) ?? 0;
+            const loopTurnShare = totalTurns > 0 ? flaggedTurns.size / totalTurns : 0;
+            const coverage = coverageBySession.get(sessionId);
+            if (!coverage || coverage.denominator === 0) {
+                throw new Error("D7 coverage denominator missing for fired session");
+            }
+            const ownerTurnMetadataCoverage = Number((coverage.covered / coverage.denominator).toFixed(6));
+            fired.push({
+                scopeKey: `D7|${sessionId}`,
+                category: "SESSION_HYGIENE",
+                scope_workspace_id: session.workspaceId,
+                lever: "Interrupt repeated attempts, restate the goal and latest failure, split the task when the loop persists, and read a file before editing it while avoiding redundant re-reads.",
+                target_metric: "loop_flagged_turn_share",
+                modeled_savings_u_per_wk: null,
+                modeled_formula: {
+                    model: "D7_LOOP_RETRY_WASTE_EXPOSURE_V2",
+                    kind: "DIRECTIONAL_UNVALIDATED",
+                    inputs: {
+                        repeat_excess_turn_cap_weighted_tokens: repeatExcessTurnCapWeightedTokens,
+                        repeat_excess_event_count: repeatExcessEventIds.size,
+                        repeat_excess_turn_count: repeatExcessTurns.size,
+                        loop_flagged_turn_count: flaggedTurns.size,
+                        total_turn_count: totalTurns,
+                        loop_flagged_turn_share: Number(loopTurnShare.toFixed(6)),
+                        owner_turn_metadata_coverage: ownerTurnMetadataCoverage,
+                        cap_read_coefficient: capReadCoeff,
+                    },
+                    expression: "cap-weighted exposure of turns owning repeat-excess events; not an avoidable-token or USD savings estimate",
+                },
+                evidence: {
+                    title: `Break retry loops: ${flaggedTurns.size} flagged turn${flaggedTurns.size === 1 ? "" : "s"} in session`,
+                    session_id: sessionId,
+                    workspace_id: session.workspaceId,
+                    loop_flagged_event_count: flaggedEventIds.size,
+                    loop_flagged_turn_count: flaggedTurns.size,
+                    repeat_excess_event_count: repeatExcessEventIds.size,
+                    repeat_excess_turn_count: repeatExcessTurns.size,
+                    total_turn_count: totalTurns,
+                    loop_flagged_turn_share: Number(loopTurnShare.toFixed(6)),
+                    owner_turn_metadata_coverage: ownerTurnMetadataCoverage,
+                    owner_turn_metadata_covered_event_count: coverage.covered,
+                    owner_turn_metadata_denominator_event_count: coverage.denominator,
+                    identical_call_event_count: identicalCalls.size,
+                    test_fail_event_count: testFails.size,
+                    redundant_read_event_count: redundantReads.size,
+                    three_gram_loop_event_count: threeGramLoops.size,
+                    repeat_excess_turn_cap_weighted_tokens: repeatExcessTurnCapWeightedTokens,
+                    thresholds_unvalidated: true,
+                    savings_claim: "repeat-excess owning-turn exposure only; no avoidable-token or USD savings claim",
+                    privacy_caveat: "Evidence contains structural counts and identifiers only; raw paths, path hashes, tool input/output, commands, and transcript content are excluded.",
+                    coverage_caveat: "Forward-only enrichment: historical or malformed events without owner-turn metadata are ignored safely.",
+                    steps: [
+                        "Interrupt after the same attempt or failure repeats",
+                        "Restate the goal, constraints, and latest failure before retrying",
+                        "Split the task into a smaller independently verifiable step",
+                        "Read the target before editing, then avoid re-reading it unless an edit changed it",
+                    ],
+                },
+            });
+        }
+        if (fired.length === 0) {
+            return {
+                fired: [],
+                status: "INACTIVE",
+                note: "no reconciled session met a loop/retry threshold",
+            };
+        }
+        return {
+            fired,
+            status: "ACTIVE",
+            note: `${fired.length} session(s) with loop/retry waste`,
+        };
+    },
+};