@phnx-labs/agents-cli 1.22.25 → 1.22.26

package/dist/lib/session/discover.js

@@ -877,6 +877,7 @@ async function scanRoutineArchivesIncremental(agent, onProgress) {
                     meta: result.meta,
                     content: result.content,
                     scan,
+                    events: result.events,
                     toolCalls: result.toolCalls,
                     toolIndexMode: result.toolIndexMode,
                 });
@@ -1756,7 +1757,7 @@ async function scanAntigravityIncremental(onProgress) {
             const result = readAntigravityMeta(filePath, currentVersion);
             if (result && !seen.has(result.meta.id)) {
                 seen.add(result.meta.id);
-                entries.push({ meta: result.meta, content: result.content, scan });
+                entries.push({ meta: result.meta, content: result.content, scan, events: result.events });
             }
             else {
                 touched.push({ filePath, scan });
@@ -1802,23 +1803,28 @@ function readAntigravityMeta(filePath, currentVersion) {
         topic: topic ? topic.slice(0, 120) : undefined,
         messageCount: events.length,
     };
-    return { meta, content: contentParts.join('\n') };
+    return { meta, content: contentParts.join('\n'), events };
 }
 // ---------------------------------------------------------------------------
 // OpenCode
 // ---------------------------------------------------------------------------
 const OPENCODE_DB = path.join(HOME, '.local', 'share', 'opencode', 'opencode.db');
 let cachedOpenCodeAccount;
-/** Query the active OpenCode account email from its SQLite database. */
-async function getOpenCodeAccount() {
+/**
+ * Query the active OpenCode account email from its SQLite database.
+ *
+ * Takes the scan's already-open handle so a scan opens `opencode.db` exactly
+ * once (RUSH-2210); opens its own only when called without one.
+ */
+function getOpenCodeAccount(handle) {
     if (cachedOpenCodeAccount !== undefined)
         return cachedOpenCodeAccount || undefined;
     // Read through the node/bun SQLite wrapper (not the `sqlite3` CLI) so this
     // works on every OS — the CLI is absent on Windows.
-    let db;
+    let owned;
     try {
-        if (fs.existsSync(OPENCODE_DB)) {
-            db = new Database(OPENCODE_DB);
+        const db = handle ?? (fs.existsSync(OPENCODE_DB) ? (owned = new Database(OPENCODE_DB)) : undefined);
+        if (db) {
             const row = db
                 .prepare('SELECT email FROM control_account WHERE active=1 LIMIT 1;')
                 .get();
@@ -1832,13 +1838,63 @@ async function getOpenCodeAccount() {
     catch { /* DB not accessible, sqlite module unavailable, or query failed */ }
     finally {
         try {
-            db?.close();
+            owned?.close();
         }
         catch { /* best-effort close */ }
     }
     cachedOpenCodeAccount = '';
     return undefined;
 }
+/**
+ * The per-session ledger stamp for an OpenCode row: the newest write time across
+ * the session's own row, its messages, and its parts, paired with the total byte
+ * length of that session's message + part payloads.
+ *
+ * OpenCode keeps every session in ONE shared SQLite file, so that file's
+ * mtime/size changes whenever *any* session is written. Stamping each session
+ * with the whole-DB stat therefore invalidated every indexed session on every
+ * scan: up to `LIMIT 1000` sessions were re-emitted into `upsertSessionsBatch`,
+ * and its enrichment step re-opened `opencode.db` once per re-emitted entry via
+ * `parseSession` (RUSH-2210).
+ *
+ * `s.time_updated` alone is NOT that session's change signal, which is the trap
+ * this shape exists to avoid. On a real database, parts land long after the
+ * session row was last touched — e.g. `ses_3955202dfffe…` carried
+ * `time_updated = 1771316403087` with its newest part at `1771331512162`, over
+ * four hours later. So the stamp maxes `time_updated` with the newest message
+ * and part times, and pairs it with a byte total that also moves when an
+ * existing part's `data` is rewritten in place (a streaming turn) without any
+ * new row or timestamp.
+ *
+ * The byte total is a REAL size, not a repurposed counter, because
+ * `sessions.file_size` is read back as bytes elsewhere: `ensureToolIndex` uses
+ * it as the tool-backfill byte budget and `toolCallsForBackfill` as the 16 MiB
+ * in-memory parser cap (`tool-index.ts`). A message/part byte total is the
+ * honest cost of parsing that session — strictly better than the whole-DB size
+ * this column used to hold for every OpenCode row.
+ *
+ * The size is `LENGTH(CAST(data AS BLOB))`, not `LENGTH(data)`: SQLite's
+ * `LENGTH()` on a TEXT column counts CHARACTERS, so a CJK/emoji-heavy transcript
+ * would under-report its real size by up to 4x — and this number is a byte
+ * budget downstream.
+ *
+ * A degenerate row — nothing but zeros/NaN for every time AND no payload at all
+ * — falls back to the whole-DB stat, keeping the pre-RUSH-2210 always-rescan
+ * behavior for exactly those rows rather than pinning them to a stamp that never
+ * changes.
+ */
+function openCodeSessionStamp(times, bytes, dbScan) {
+    // A positive time, not merely a finite one: the SQL COALESCEs the aggregates
+    // to 0, so `Number.isFinite` alone would accept a row that told us nothing and
+    // this branch could never fire.
+    const known = [times.timeUpdated, times.lastMessageAt, times.lastPartAt, times.timeCreated]
+        .filter(t => Number.isFinite(t) && t > 0);
+    const size = (Number.isFinite(bytes.messageBytes) ? bytes.messageBytes : 0)
+        + (Number.isFinite(bytes.partBytes) ? bytes.partBytes : 0);
+    if (known.length === 0 && size === 0)
+        return dbScan;
+    return { fileMtimeMs: known.length === 0 ? 0 : Math.floor(Math.max(...known)), fileSize: size };
+}
 /** Scan OpenCode sessions from its SQLite database when the DB file has changed. */
 async function scanOpenCodeIncremental() {
     if (!fs.existsSync(OPENCODE_DB))
@@ -1846,8 +1902,9 @@ async function scanOpenCodeIncremental() {
     const stat = safeStatSync(OPENCODE_DB);
     if (!stat)
         return;
-    // OpenCode is one big DB; we use its mtime/size as the ledger for the
-    // entire fleet of OpenCode sessions.
+    // OpenCode is one big DB. Its mtime/size is the cheap "did ANYTHING change"
+    // short-circuit for the whole harness — not the per-session stamp, which each
+    // row carries itself (see openCodeSessionStamp, RUSH-2210).
     const currentScan = {
         fileMtimeMs: Math.floor(stat.mtimeMs),
         fileSize: stat.size,
@@ -1856,7 +1913,6 @@ async function scanOpenCodeIncremental() {
     if (prev && prev.fileMtimeMs === currentScan.fileMtimeMs && prev.fileSize === currentScan.fileSize) {
         return;
     }
-    const account = await getOpenCodeAccount();
     const currentVersion = await getCurrentAgentVersion('opencode');
     // Read through the node/bun SQLite wrapper (not the `sqlite3` CLI) so this
     // works on every OS — the CLI is absent on Windows.
@@ -1871,14 +1927,28 @@ async function scanOpenCodeIncremental() {
         s.time_created AS time_created,
         s.time_updated AS time_updated,
         COALESCE(stats.message_count, 0) AS message_count,
+        COALESCE(stats.last_message_at, 0) AS last_message_at,
+        COALESCE(stats.message_bytes, 0) AS message_bytes,
+        COALESCE(parts.last_part_at, 0) AS last_part_at,
+        COALESCE(parts.part_bytes, 0) AS part_bytes,
         stats.token_count AS token_count,
         stats.output_tokens AS output_tokens,
         COALESCE(stats.has_token_data, 0) AS has_token_data
       FROM session s
+      LEFT JOIN (
+        SELECT
+          session_id,
+          MAX(time_created) AS last_part_at,
+          SUM(LENGTH(CAST(data AS BLOB))) AS part_bytes
+        FROM part
+        GROUP BY session_id
+      ) parts ON parts.session_id = s.id
       LEFT JOIN (
         SELECT
           session_id,
           COUNT(*) AS message_count,
+          MAX(time_created) AS last_message_at,
+          SUM(LENGTH(CAST(data AS BLOB))) AS message_bytes,
           SUM(
             COALESCE(json_extract(data, '$.tokens.input'), 0) +
             COALESCE(json_extract(data, '$.tokens.output'), 0) +
@@ -1896,16 +1966,42 @@ async function scanOpenCodeIncremental() {
       LIMIT 1000;
     `.replace(/\n/g, ' ');
         db = new Database(OPENCODE_DB);
+        const account = getOpenCodeAccount(db);
         const rows = db.prepare(query).all();
-        const entries = [];
-        for (const row of rows) {
+        // Two passes. First derive each row's identity + per-session stamp, then
+        // bulk-load the prior stamps in ONE query and keep only the rows that
+        // actually changed. Skipped rows never reach upsertSessionsBatch, so they
+        // never pay its per-entry `parseSession` re-open of this same DB.
+        const asInt = (v) => typeof v === 'number' ? v : parseInt(String(v), 10);
+        const candidates = rows.flatMap(row => {
             const id = typeof row.id === 'string' ? row.id : '';
             if (!id)
-                continue;
+                return [];
+            const filePath = `${OPENCODE_DB}#${id}`;
+            return [{
+                    row,
+                    id,
+                    filePath,
+                    scan: openCodeSessionStamp({
+                        timeUpdated: asInt(row.time_updated),
+                        timeCreated: asInt(row.time_created),
+                        lastMessageAt: asInt(row.last_message_at),
+                        lastPartAt: asInt(row.last_part_at),
+                    }, { messageBytes: asInt(row.message_bytes), partBytes: asInt(row.part_bytes) }, currentScan),
+                }];
+        });
+        const priorStamps = getScanStampsForPaths(candidates.map(c => c.filePath));
+        const changed = candidates.filter(c => {
+            const prevStamp = priorStamps.get(c.filePath);
+            return !prevStamp
+                || prevStamp.fileMtimeMs !== c.scan.fileMtimeMs
+                || prevStamp.fileSize !== c.scan.fileSize;
+        });
+        const entries = [];
+        for (const { row, id, filePath, scan } of changed) {
             const title = typeof row.title === 'string' ? row.title : '';
             const directory = typeof row.directory === 'string' ? row.directory : '';
             const version = typeof row.version === 'string' ? row.version : '';
-            const asInt = (v) => typeof v === 'number' ? v : parseInt(String(v), 10);
             const timeCreated = asInt(row.time_created);
             const timeUpdated = asInt(row.time_updated);
             const messageCount = asInt(row.message_count);
@@ -1926,7 +2022,7 @@ async function scanOpenCodeIncremental() {
                 lastActivity,
                 project: directory ? path.basename(directory) : undefined,
                 cwd: directory ? normalizeCwd(directory) : undefined,
-                filePath: `${OPENCODE_DB}#${id}`,
+                filePath,
                 version: resolveSessionVersion('opencode', OPENCODE_DB, version || undefined, currentVersion),
                 account,
                 topic,
@@ -1934,7 +2030,7 @@ async function scanOpenCodeIncremental() {
                 tokenCount: hasTokenData && !Number.isNaN(tokenCount) ? tokenCount : undefined,
                 outputTokens: hasTokenData && !Number.isNaN(outputTokens) ? outputTokens : undefined,
             };
-            entries.push({ meta, content: topic || '', scan: currentScan });
+            entries.push({ meta, content: topic || '', scan });
         }
         upsertSessionsBatch(entries);
         // Stamp the OpenCode DB itself so we can short-circuit on the next run.
@@ -3902,7 +3998,7 @@ async function scanCursorIncremental(onProgress) {
             const result = readCursorMeta(filePath, currentVersion);
             if (result && !seen.has(result.meta.id)) {
                 seen.add(result.meta.id);
-                entries.push({ meta: result.meta, content: result.content, scan });
+                entries.push({ meta: result.meta, content: result.content, scan, events: result.events });
             }
             else {
                 touched.push({ filePath, scan });
@@ -3998,7 +4094,7 @@ export function readCursorMeta(filePath, currentVersion) {
         messageCount: events.filter((event) => event.type === 'message').length,
         todos: extractTodoProgressFromEvents(events),
     };
-    return { meta, content: userTexts.join('\n') };
+    return { meta, content: userTexts.join('\n'), events };
 }
 // ---------------------------------------------------------------------------
 // Kimi

package/dist/lib/session/insights.d.ts

@@ -71,6 +71,10 @@ export interface InsightFacets {
     assistantTurns: number;
     toolCount: number;
     errorCount: number;
+    /** Deterministic evidence buckets used by the actions-forward report. */
+    frictionSignals: Record<string, number>;
+    correctionSignals: Record<string, number>;
+    automationSignals: Record<string, number>;
 }
 /**
  * Compute every behavioural facet of one session from its parsed events.
@@ -124,3 +128,17 @@ export declare function topEntries(counts: Record<string, number>, limit: number
     name: string;
     count: number;
 }>;
+export type InsightActionCategory = 'rule' | 'skill' | 'automation' | 'product';
+export interface InsightAction {
+    priority: 'high' | 'medium' | 'low';
+    category: InsightActionCategory;
+    action: string;
+    evidenceCount: number;
+    sampleSessionIds: string[];
+}
+export interface SessionFacetEvidence {
+    id: string;
+    facets: InsightFacets;
+}
+/** Build a stable, evidence-backed action list without exposing transcript text. */
+export declare function buildInsightActions(sessions: SessionFacetEvidence[]): InsightAction[];

package/dist/lib/session/insights.js

@@ -65,6 +65,7 @@ function emptyFacets() {
         shellCommandsSeen: 0,
         messageHours: new Array(24).fill(0), userTurns: 0, assistantTurns: 0,
         toolCount: 0, errorCount: 0,
+        frictionSignals: {}, correctionSignals: {}, automationSignals: {},
     };
 }
 function bump(map, key, by = 1) {
@@ -145,6 +146,7 @@ export function computeInsightFacets(events, timezoneOffsetMinutes = new Date().
     // a reply latency. It censors 5.5% of gaps, and `gapsOverCeiling` reports how many so
     // the number is never quietly truncated.
     let lastAssistantTs = null;
+    let lastFailedTool = null;
     for (const e of events) {
         const ts = new Date(e.timestamp).getTime();
         const hasTs = !Number.isNaN(ts);
@@ -153,13 +155,21 @@ export function computeInsightFacets(events, timezoneOffsetMinutes = new Date().
                 f.interruptions++;
                 break;
             case 'usage':
-                // shortenModel so the label matches `agents sessions <id>` and `trends`
+                // shortenModel so the label matches `agents sessions <id>` and `insights mix`
                 // rather than printing the raw id beside their shortened one.
                 if (e.model)
                     bump(f.models, shortenModel(e.model));
                 break;
             case 'error':
                 bump(f.errorCategories, categorizeError(e.content ?? e.output ?? ''));
+                if (e.tool && e.tool === lastFailedTool)
+                    bump(f.frictionSignals, `failed tool loop: ${e.tool}`);
+                lastFailedTool = e.tool ?? null;
+                classifyFriction(e.content ?? e.output ?? '', f.frictionSignals);
+                break;
+            case 'tool_result':
+                if (e.success !== false && e.outcome !== 'error')
+                    lastFailedTool = null;
                 break;
             case 'message':
                 if (e.role === 'assistant') {
@@ -169,6 +179,8 @@ export function computeInsightFacets(events, timezoneOffsetMinutes = new Date().
                 }
                 if (e.role !== 'user')
                     break;
+                if (!e._synthetic)
+                    classifyCorrection(e.content ?? '', f.correctionSignals);
                 if (hasTs) {
                     // Local-time hour. parse.ts falls back to `new Date()` for a record with no
                     // timestamp; those are indistinguishable here, but they are rare and would
@@ -197,6 +209,8 @@ export function computeInsightFacets(events, timezoneOffsetMinutes = new Date().
                     lastAssistantTs = ts;
                 const args = e.args ?? {};
                 const toolName = e.tool ?? '';
+                if (/askuserquestion/i.test(toolName))
+                    classifyAskStall(args, f.correctionSignals);
                 // Keyed on the SHARED cross-harness vocabulary, not Claude's literals. Keying
                 // on 'Edit'|'MultiEdit'|'Write' meant codex (whose vocabulary is exec /
                 // exec_command / write_stdin) reported 5,197 tool calls and exactly zero lines
@@ -218,6 +232,7 @@ export function computeInsightFacets(events, timezoneOffsetMinutes = new Date().
                     f.shellCommandsSeen++;
                     f.gitCommits += countGitOp(e.command, 'commit');
                     f.gitPushes += countGitOp(e.command, 'push');
+                    classifyAutomation(e.command, f.automationSignals);
                 }
                 break;
             }
@@ -228,6 +243,59 @@ export function computeInsightFacets(events, timezoneOffsetMinutes = new Date().
     }
     return f;
 }
+const FRICTION_PATTERNS = [
+    [/blocked by|guard(?:rail)? (?:blocked|denied)|permission denied/i, 'blocked guard'],
+    [/\b(?:ci|check|workflow)\b.*\b(?:red|fail(?:ed|ure)?)\b|\b(?:red|failed)\b.*\bci\b/i, 'CI red loop'],
+    [/merge conflict|conflict in |CONFLICT \(/i, 'merge conflict'],
+];
+const CORRECTION_PATTERNS = [
+    [/\b(?:continue|keep going|don'?t stop)\b/i, 'continue / keep going'],
+    [/\b(?:yes|go ahead|do it|merge it)\b/i, 'approval repeated'],
+    [/\b(?:are we done|done end.to.end|what(?:'s| is) left)\b/i, 'done end-to-end?'],
+    [/\b(?:did you merge|merged\??)\b/i, 'did you merge?'],
+    [/\bwhat(?:'s| is) next\??\b/i, "what's next?"],
+    [/\b(?:check now|check again|try now|did it work)\b/i, 'check now'],
+    [/\b(?:don'?t ask|just do it|run what)\b/i, "don't ask / just do it"],
+];
+const AUTOMATION_PATTERNS = [
+    [/\bgh pr (?:checks|view|merge)\b/i, 'PR babysitting'],
+    [/\bagents secrets (?:list|exec|unlock|export)\b/i, 'secrets unlock dance'],
+    [/\bgit (?:fetch|rebase|merge|push)\b/i, 'git reconcile recipe'],
+    [/\b(?:scp|rsync|agents ssh)\b/i, 'fleet file transfer'],
+    [/\b(?:release\.sh|deploy\.sh|npm publish)\b/i, 'release / deploy recipe'],
+];
+function classifyFriction(text, counts) {
+    for (const [pattern, label] of FRICTION_PATTERNS)
+        if (pattern.test(text))
+            bump(counts, label);
+}
+function classifyCorrection(text, counts) {
+    const normalized = text.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+    for (const [pattern, label] of CORRECTION_PATTERNS)
+        if (pattern.test(normalized))
+            bump(counts, label);
+}
+function classifyAskStall(args, counts) {
+    const text = JSON.stringify(args).toLowerCase();
+    const categories = [
+        [/release|ship|deploy|publish/, 'Ask stall: release / ship / deploy'],
+        [/what'?s next|next step|next move/, "Ask stall: what's next?"],
+        [/merge|reconcile|rebase/, 'Ask stall: merge / reconcile'],
+        [/direction|approach|implementation/, 'Ask stall: direction / approach'],
+    ];
+    for (const [pattern, label] of categories) {
+        if (pattern.test(text)) {
+            bump(counts, label);
+            return;
+        }
+    }
+    bump(counts, 'AskUserQuestion');
+}
+function classifyAutomation(command, counts) {
+    for (const [pattern, label] of AUTOMATION_PATTERNS)
+        if (pattern.test(command))
+            bump(counts, label);
+}
 /** Percentile of a numeric sample, nearest-rank. Returns 0 for an empty sample. */
 export function percentile(values, p) {
     if (values.length === 0)
@@ -298,6 +366,12 @@ export function mergeFacets(into, add) {
         bump(into.slashCommands, k, v);
     for (const [k, v] of Object.entries(add.errorCategories))
         bump(into.errorCategories, k, v);
+    for (const [k, v] of Object.entries(add.frictionSignals ?? {}))
+        bump(into.frictionSignals, k, v);
+    for (const [k, v] of Object.entries(add.correctionSignals ?? {}))
+        bump(into.correctionSignals, k, v);
+    for (const [k, v] of Object.entries(add.automationSignals ?? {}))
+        bump(into.automationSignals, k, v);
     into.interruptions += add.interruptions;
     into.responseGaps.push(...add.responseGaps);
     into.gapsOverCeiling += add.gapsOverCeiling;
@@ -328,3 +402,71 @@ export function topEntries(counts, limit) {
         .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name))
         .slice(0, limit);
 }
+/** Build a stable, evidence-backed action list without exposing transcript text. */
+export function buildInsightActions(sessions) {
+    const specs = [
+        { source: 'correctionSignals', label: 'continue / keep going', category: 'rule', action: 'Keep working through the delivery chain without waiting for another “continue”.' },
+        { source: 'correctionSignals', label: 'approval repeated', category: 'rule', action: 'Treat the original build or ship request as authorization for routine follow-through.' },
+        { source: 'correctionSignals', label: 'done end-to-end?', category: 'rule', action: 'Verify the user-visible outcome before declaring the task complete.' },
+        { source: 'correctionSignals', label: 'did you merge?', category: 'automation', action: 'Automate PR review, CI watching, and merge-on-green as one durable workflow.' },
+        { source: 'correctionSignals', label: "what's next?", category: 'rule', action: 'State and execute the next in-scope step instead of asking the owner to steer implementation.' },
+        { source: 'correctionSignals', label: 'check now', category: 'automation', action: 'Add bounded status polling with a terminal success or failure signal.' },
+        { source: 'correctionSignals', label: "don't ask / just do it", category: 'rule', action: 'Reserve questions for genuine product or scope choices.' },
+        { source: 'correctionSignals', label: 'Ask stall: release / ship / deploy', category: 'skill', action: 'Teach release workflows to carry publish, tag, rollout, and live verification as one chain.' },
+        { source: 'correctionSignals', label: "Ask stall: what's next?", category: 'rule', action: 'Remove workflow-stall “what next?” prompts from agent guidance.' },
+        { source: 'correctionSignals', label: 'Ask stall: merge / reconcile', category: 'skill', action: 'Encode the safe merge and reconcile path in the git workflow skill.' },
+        { source: 'correctionSignals', label: 'Ask stall: direction / approach', category: 'rule', action: 'Let agents choose implementation details after scope is clear.' },
+        { source: 'frictionSignals', label: 'blocked guard', category: 'product', action: 'Make guard failures return the safe next command and exact blocked operation.' },
+        { source: 'frictionSignals', label: 'CI red loop', category: 'automation', action: 'Deduplicate CI watchers and turn repeated red checks into one stateful wait.' },
+        { source: 'frictionSignals', label: 'merge conflict', category: 'skill', action: 'Standardize conflict diagnosis and fix-forward reconciliation.' },
+        { source: 'automationSignals', label: 'PR babysitting', category: 'automation', action: 'Bundle PR checks, review collection, comment handling, and merge-on-green.' },
+        { source: 'automationSignals', label: 'secrets unlock dance', category: 'product', action: 'Provide one headless secrets-backed command path for repeated credential operations.' },
+        { source: 'automationSignals', label: 'git reconcile recipe', category: 'skill', action: 'Promote repeated git reconciliation commands into the canonical workflow.' },
+        { source: 'automationSignals', label: 'fleet file transfer', category: 'product', action: 'Add a first-class fleet file transfer command with host/path validation.' },
+        { source: 'automationSignals', label: 'release / deploy recipe', category: 'automation', action: 'Turn repeated release shell recipes into a checked-in release script.' },
+    ];
+    const actions = [];
+    for (const spec of specs) {
+        let evidenceCount = 0;
+        const ids = [];
+        for (const session of sessions) {
+            const count = session.facets[spec.source]?.[spec.label] ?? 0;
+            if (count <= 0)
+                continue;
+            evidenceCount += count;
+            if (ids.length < 3)
+                ids.push(session.id.slice(0, 8));
+        }
+        if (evidenceCount === 0)
+            continue;
+        actions.push({
+            priority: evidenceCount >= 10 ? 'high' : evidenceCount >= 3 ? 'medium' : 'low',
+            category: spec.category,
+            action: spec.action,
+            evidenceCount,
+            sampleSessionIds: ids,
+        });
+    }
+    let failedLoopCount = 0;
+    const failedLoopIds = [];
+    for (const session of sessions) {
+        const count = Object.entries(session.facets.frictionSignals ?? {})
+            .filter(([label]) => label.startsWith('failed tool loop:'))
+            .reduce((sum, [, value]) => sum + value, 0);
+        if (count <= 0)
+            continue;
+        failedLoopCount += count;
+        if (failedLoopIds.length < 3)
+            failedLoopIds.push(session.id.slice(0, 8));
+    }
+    if (failedLoopCount > 0) {
+        actions.push({
+            priority: failedLoopCount >= 10 ? 'high' : failedLoopCount >= 3 ? 'medium' : 'low',
+            category: 'automation',
+            action: 'Detect repeated failures of the same tool and stop the retry loop with a different recovery path.',
+            evidenceCount: failedLoopCount,
+            sampleSessionIds: failedLoopIds,
+        });
+    }
+    return actions.sort((a, b) => b.evidenceCount - a.evidenceCount || a.action.localeCompare(b.action));
+}