@phnx-labs/agents-cli 1.22.26 → 1.22.27

package/dist/lib/session/discover.js

@@ -20,6 +20,8 @@ import { parseTimeFilter } from './relative-time.js';
 const execFileAsync = promisify(execFile);
 import { AGENTS, agentConfigDirName, getCliVersion } from '../agents.js';
 import { walkForFilesWithStat } from '../fs-walk.js';
+import { hasCommand } from '../cli-resources.js';
+import { execFileShellSpec } from '../platform/exec.js';
 import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { deriveShortId } from './short-id.js';
@@ -28,7 +30,7 @@ import { extractSessionTopic, extractSlashCommandName, extractSlashCommandFromTo
 import { isSkillInvocation, extractSkills, extractSlashCommands } from './highlights.js';
 import { parseAntigravity, parseCursor } from './parse.js';
 import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket, extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
-import { costOfUsage } from '../pricing/index.js';
+import { costOfUsage, costOfUsageNoCache } from '../pricing/index.js';
 import { machineForSessionFile } from './origin-machine.js';
 export { machineForSessionFile } from './origin-machine.js';
 import { mapBounded } from '../concurrency.js';
@@ -1096,7 +1098,11 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
             toolCallCount: scan.toolCallCount,
             tokenCount: scan.tokenCount,
             outputTokens: scan.outputTokens,
+            inputTokens: scan.inputTokens,
+            cacheReadTokens: scan.cacheReadTokens,
+            cacheWriteTokens: scan.cacheWriteTokens,
             costUsd: scan.costUsd,
+            costUsdNoCache: scan.costUsdNoCache,
             durationMs: scan.durationMs,
             isTeamOrigin,
             prUrl: scan.prUrl,
@@ -1130,7 +1136,11 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
             toolCallCount: scan.toolCallCount,
             tokenCount: scan.tokenCount,
             outputTokens: scan.outputTokens,
+            inputTokens: scan.inputTokens,
+            cacheReadTokens: scan.cacheReadTokens,
+            cacheWriteTokens: scan.cacheWriteTokens,
             costUsd: scan.costUsd,
+            costUsdNoCache: scan.costUsdNoCache,
             durationMs: scan.durationMs,
             topic: scan.topic,
             isTeamOrigin,
@@ -1438,7 +1448,11 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
         messageCount: scan.messageCount,
         tokenCount: scan.tokenCount,
         outputTokens: scan.outputTokens,
+        inputTokens: scan.inputTokens,
+        cacheReadTokens: scan.cacheReadTokens,
+        cacheWriteTokens: scan.cacheWriteTokens,
         costUsd: scan.costUsd,
+        costUsdNoCache: scan.costUsdNoCache,
         durationMs: scan.durationMs,
         account: resolveAccount?.(),
         prUrl: scan.prUrl,
@@ -1576,8 +1590,11 @@ function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
     let messageCount = 0;
     let tokenCount = 0;
     let outputTokens = 0;
+    let inputTokens = 0;
+    let cacheReadTokens = 0;
     let sawTokenCount = false;
     let costUsd = 0;
+    let costUsdNoCache = 0;
     let sawCost = false;
     let firstTsMs;
     let lastTsMs;
@@ -1622,21 +1639,28 @@ function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
                 (typeof gtk.output === 'number' ? gtk.output : 0) +
                     (typeof gtk.thoughts === 'number' ? gtk.thoughts : 0) +
                     (typeof gtk.tool === 'number' ? gtk.tool : 0);
+            // Burn split (RUSH-2287): Gemini has uncached input + cache-read, no cache-write.
+            if (typeof gtk.input === 'number')
+                inputTokens += gtk.input;
+            if (typeof gtk.cached === 'number')
+                cacheReadTokens += gtk.cached;
         }
         // Per-message cost: directional tokens × this message's model price.
         const msgModel = (typeof message.model === 'string' ? message.model : undefined) || sessionModel;
         const tk = message.tokens;
         if (msgModel && tk && typeof tk === 'object') {
-            const c = costOfUsage({
+            const usage = {
                 model: msgModel,
                 inputTokens: typeof tk.input === 'number' ? tk.input : undefined,
                 outputTokens: (typeof tk.output === 'number' ? tk.output : 0) +
                     (typeof tk.thoughts === 'number' ? tk.thoughts : 0) +
                     (typeof tk.tool === 'number' ? tk.tool : 0),
                 cacheReadTokens: typeof tk.cached === 'number' ? tk.cached : undefined,
-            });
+            };
+            const c = costOfUsage(usage);
             if (c > 0) {
                 costUsd += c;
+                costUsdNoCache += costOfUsageNoCache(usage);
                 sawCost = true;
             }
         }
@@ -1659,7 +1683,10 @@ function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
         messageCount,
         tokenCount: sawTokenCount ? tokenCount : undefined,
         outputTokens: sawTokenCount ? outputTokens : undefined,
+        inputTokens: sawTokenCount ? inputTokens : undefined,
+        cacheReadTokens: sawTokenCount ? cacheReadTokens : undefined,
         costUsd: sawCost ? costUsd : undefined,
+        costUsdNoCache: sawCost ? costUsdNoCache : undefined,
         durationMs,
     };
     return { meta, content: userTexts.join('\n') };
@@ -2053,13 +2080,12 @@ async function scanOpenCodeIncremental() {
 // ---------------------------------------------------------------------------
 /** Scan active OpenClaw channels and cron jobs via the openclaw CLI. */
 async function scanOpenClawIncremental() {
-    // Check if openclaw is installed — silently skip if not.
-    try {
-        await execFileAsync('which', ['openclaw']);
-    }
-    catch {
+    // Check if openclaw is installed — silently skip if not. `which` is POSIX-only
+    // (Windows resolves PATH with `where`), so a bare `which` throws ENOENT on every
+    // Windows run and silently disabled the entire OpenClaw scan there — its sessions
+    // never reached the index (RUSH-2286). hasCommand() probes cross-platform.
+    if (!hasCommand('openclaw'))
         return;
-    }
     // TTL cache: skip subprocess calls if we scanned recently. Stored in the
     // meta table so we skip even when no channels/cron exist to produce rows.
     const db = getDB();
@@ -2073,8 +2099,13 @@ async function scanOpenClawIncremental() {
     const scan = { fileMtimeMs: now, fileSize: 0 };
     const entries = [];
     try {
-        const { stdout: output } = await execFileAsync('openclaw', ['channels', 'status'], {
+        // On Windows `openclaw` resolves to a .cmd/.ps1 shim that execFile can't launch
+        // directly; execFileShellSpec composes a shell-safe invocation there and is a
+        // no-op passthrough on POSIX (RUSH-2286).
+        const channelsSpec = execFileShellSpec('openclaw', ['channels', 'status']);
+        const { stdout: output } = await execFileAsync(channelsSpec.command, channelsSpec.args, {
             encoding: 'utf-8',
+            shell: channelsSpec.shell,
         });
         for (const line of output.split('\n')) {
             const match = line.match(/^-\s+\w+\s+(\S+)\s+\((\w+)\):\s*(.+)/);
@@ -2103,8 +2134,10 @@ async function scanOpenClawIncremental() {
         /* channels command failed */
     }
     try {
-        const { stdout: output } = await execFileAsync('openclaw', ['cron', 'list'], {
+        const cronSpec = execFileShellSpec('openclaw', ['cron', 'list']);
+        const { stdout: output } = await execFileAsync(cronSpec.command, cronSpec.args, {
             encoding: 'utf-8',
+            shell: cronSpec.shell,
         });
         const lines = output.split('\n');
         for (let i = 1; i < lines.length; i++) {
@@ -2610,15 +2643,19 @@ async function readDroidMeta(filePath, currentVersion) {
     const settings = readDroidSettings(filePath.replace(/\.jsonl$/, '.settings.json'));
     const model = settings.model || scan.model;
     const tokenCount = settings.tokenCount;
-    const costUsd = model && settings.usage
-        ? costOfUsage({
+    // Droid records a full split (input / cache-read / cache-write / output) in its
+    // settings sidecar, so both the actual and no-cache cost are derivable (RUSH-2287).
+    const usageForCost = model && settings.usage
+        ? {
             model,
             inputTokens: settings.usage.inputTokens,
             outputTokens: settings.usage.outputTokens,
             cacheReadTokens: settings.usage.cacheReadTokens,
             cacheCreationTokens: settings.usage.cacheCreationTokens,
-        })
-        : 0;
+        }
+        : undefined;
+    const costUsd = usageForCost ? costOfUsage(usageForCost) : 0;
+    const costUsdNoCache = usageForCost ? costOfUsageNoCache(usageForCost) : 0;
     const stat = safeStatSync(filePath);
     const cwd = normalizeCwd(scan.cwd || '');
     const meta = {
@@ -2636,7 +2673,11 @@ async function readDroidMeta(filePath, currentVersion) {
         messageCount: scan.messageCount,
         tokenCount,
         outputTokens: settings.usage?.outputTokens,
+        inputTokens: settings.usage?.inputTokens,
+        cacheReadTokens: settings.usage?.cacheReadTokens,
+        cacheWriteTokens: settings.usage?.cacheCreationTokens,
         costUsd: costUsd > 0 ? costUsd : undefined,
+        costUsdNoCache: costUsd > 0 ? costUsdNoCache : undefined,
         durationMs: scan.durationMs,
     };
     return { meta, content: scan.contentText || '' };
@@ -2784,8 +2825,12 @@ export function initClaudeParseState() {
         toolCallCount: 0,
         tokenCount: 0,
         outputTokens: 0,
+        inputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
         sawTokenCount: false,
         costUsd: 0,
+        costUsdNoCache: 0,
         sawCost: false,
         firstTsMs: undefined,
         lastTsMs: undefined,
@@ -2982,21 +3027,34 @@ export function applyClaudeLine(state, parsed) {
     }
     if (typeof usageObj?.output_tokens === 'number')
         state.outputTokens += usageObj.output_tokens;
+    // Burn split (RUSH-2287): accumulate the raw directional counts so `agents
+    // output` can report uncached-input / cache-read / cache-write separately.
+    if (usageObj && typeof usageObj === 'object') {
+        if (typeof usageObj.input_tokens === 'number')
+            state.inputTokens += usageObj.input_tokens;
+        if (typeof usageObj.cache_read_input_tokens === 'number')
+            state.cacheReadTokens += usageObj.cache_read_input_tokens;
+        if (typeof usageObj.cache_creation_input_tokens === 'number')
+            state.cacheWriteTokens += usageObj.cache_creation_input_tokens;
+    }
     // Per-assistant-message cost: each event carries its own model, so we
     // multiply that event's raw token directions by that model's price.
     const model = parsed.message?.model;
     if (typeof model === 'string' && model)
         state.model = model;
     if (model && usageObj && typeof usageObj === 'object') {
-        const eventCost = costOfUsage({
+        const usageForCost = {
             model,
             inputTokens: usageObj.input_tokens,
             outputTokens: usageObj.output_tokens,
             cacheReadTokens: usageObj.cache_read_input_tokens,
             cacheCreationTokens: usageObj.cache_creation_input_tokens,
-        });
+        };
+        const eventCost = costOfUsage(usageForCost);
         if (eventCost > 0) {
             state.costUsd += eventCost;
+            // No-cache scenario: reprice this same event's cache tokens at the input rate.
+            state.costUsdNoCache += costOfUsageNoCache(usageForCost);
             state.sawCost = true;
         }
     }
@@ -3026,7 +3084,11 @@ export function finalizeClaudeScan(state) {
         toolCallCount: state.toolCallCount,
         tokenCount: state.sawTokenCount ? state.tokenCount : undefined,
         outputTokens: state.sawTokenCount ? state.outputTokens : undefined,
+        inputTokens: state.sawTokenCount ? state.inputTokens : undefined,
+        cacheReadTokens: state.sawTokenCount ? state.cacheReadTokens : undefined,
+        cacheWriteTokens: state.sawTokenCount ? state.cacheWriteTokens : undefined,
         costUsd: state.sawCost ? state.costUsd : undefined,
+        costUsdNoCache: state.sawCost ? state.costUsdNoCache : undefined,
         durationMs,
         lastActivity: state.lastTsMs !== undefined ? new Date(state.lastTsMs).toISOString() : undefined,
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
@@ -3082,7 +3144,7 @@ export function serializeClaudeParserState(state, offset, jsonlDroppingOversized
         : allIds;
     const ticket = detectTicket(state.userTexts.join('\n') || undefined, state.gitBranch);
     return {
-        v: 2,
+        v: 3,
         offset,
         jsonlDroppingOversizedLine: jsonlDroppingOversizedLine || undefined,
         timestamp: state.timestamp,
@@ -3101,9 +3163,13 @@ export function serializeClaudeParserState(state, offset, jsonlDroppingOversized
         toolCallCount: state.toolCallCount,
         tokenCount: state.tokenCount,
         outputTokens: state.outputTokens,
+        inputTokens: state.inputTokens,
+        cacheReadTokens: state.cacheReadTokens,
+        cacheWriteTokens: state.cacheWriteTokens,
         sawTokenCount: state.sawTokenCount,
         sawCost: state.sawCost,
         costUsd: state.costUsd,
+        costUsdNoCache: state.costUsdNoCache,
         seenIdsSize: state.seenAssistantIds.size,
         seenIdsRecent,
         sawPrCreate: state.sawPrCreate,
@@ -3163,8 +3229,12 @@ export function hydrateClaudeParseState(prior) {
         toolCallCount: prior.toolCallCount ?? 0,
         tokenCount: prior.tokenCount,
         outputTokens: prior.outputTokens,
+        inputTokens: prior.inputTokens ?? 0,
+        cacheReadTokens: prior.cacheReadTokens ?? 0,
+        cacheWriteTokens: prior.cacheWriteTokens ?? 0,
         sawTokenCount: prior.sawTokenCount,
         costUsd: prior.costUsd,
+        costUsdNoCache: prior.costUsdNoCache ?? 0,
         sawCost: prior.sawCost,
         firstTsMs: prior.firstTsMs,
         lastTsMs: prior.lastTsMs,
@@ -3313,7 +3383,7 @@ function parsePriorClaudeState(row) {
         return null;
     try {
         const parsed = JSON.parse(row.parserState);
-        if (parsed?.v !== 2 || typeof parsed.offset !== 'number' || parsed.toolCalls?.v !== 1)
+        if (parsed?.v !== 3 || typeof parsed.offset !== 'number' || parsed.toolCalls?.v !== 1)
             return null;
         return parsed;
     }
@@ -3469,17 +3539,34 @@ export function applyCodexLine(state, parsed) {
  * exact return-building {@link scanCodexSession} used to run inline.
  */
 export function finalizeCodexScan(state) {
-    // Price the final cumulative token snapshot once, against the session model.
+    // Codex reports one cumulative snapshot: uncached input, cached (cache-read)
+    // input, and output+reasoning. It has no cache-write bucket. Derive the burn
+    // split and both costs (actual + no-cache) from that final snapshot (RUSH-2287).
+    const snap = state.lastTotalTokenUsage;
+    const outputTokens = snap
+        ? (snap.output_tokens ?? 0) + (snap.reasoning_output_tokens ?? 0)
+        : undefined;
     let costUsd;
-    if (state.model && state.lastTotalTokenUsage) {
-        const c = costOfUsage({
+    let costUsdNoCache;
+    let inputTokens;
+    let cacheReadTokens;
+    if (snap) {
+        inputTokens = typeof snap.input_tokens === 'number' ? snap.input_tokens : undefined;
+        cacheReadTokens = typeof snap.cached_input_tokens === 'number' ? snap.cached_input_tokens : undefined;
+    }
+    // Price the final cumulative token snapshot once, against the session model.
+    if (state.model && snap) {
+        const usage = {
             model: state.model,
-            inputTokens: state.lastTotalTokenUsage.input_tokens,
-            outputTokens: (state.lastTotalTokenUsage.output_tokens ?? 0) + (state.lastTotalTokenUsage.reasoning_output_tokens ?? 0),
-            cacheReadTokens: state.lastTotalTokenUsage.cached_input_tokens,
-        });
-        if (c > 0)
+            inputTokens: snap.input_tokens,
+            outputTokens,
+            cacheReadTokens: snap.cached_input_tokens,
+        };
+        const c = costOfUsage(usage);
+        if (c > 0) {
             costUsd = c;
+            costUsdNoCache = costOfUsageNoCache(usage);
+        }
     }
     const durationMs = state.firstTsMs !== undefined && state.lastTsMs !== undefined && state.lastTsMs > state.firstTsMs
         ? state.lastTsMs - state.firstTsMs
@@ -3496,10 +3583,12 @@ export function finalizeCodexScan(state) {
         topic: state.topic,
         messageCount: state.messageCount,
         tokenCount: state.tokenCount,
-        outputTokens: state.lastTotalTokenUsage
-            ? (state.lastTotalTokenUsage.output_tokens ?? 0) + (state.lastTotalTokenUsage.reasoning_output_tokens ?? 0)
-            : undefined,
+        outputTokens,
+        inputTokens,
+        cacheReadTokens,
+        cacheWriteTokens: undefined,
         costUsd,
+        costUsdNoCache,
         durationMs,
         lastActivity: state.lastTsMs !== undefined ? new Date(state.lastTsMs).toISOString() : undefined,
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
@@ -4457,10 +4546,13 @@ export function readGrokMeta(filePath, currentVersion) {
             ? summary.num_messages
             : undefined;
     // Grok records its managed home in summary.grok_home
-    // (…/versions/grok/<version>/home/.grok) — recover the version from it.
+    // (…/versions/grok/<version>/home/.grok) — recover the version from it. The
+    // value is written by the Grok CLI in the writing host's native separators, so
+    // a Windows-authored summary is backslash-separated; normalize to `/` before
+    // matching or the version never resolves on Windows (RUSH-2286).
     let embeddedVersion;
     if (typeof summary?.grok_home === 'string') {
-        embeddedVersion = summary.grok_home.match(/versions\/grok\/([^/]+)\//)?.[1];
+        embeddedVersion = summary.grok_home.replace(/\\/g, '/').match(/versions\/grok\/([^/]+)\//)?.[1];
     }
     const meta = {
         id: sessionId,

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

@@ -21,11 +21,25 @@
  *     the raw file count rather than quietly differing.
  */
 import type { SessionEvent } from './types.js';
+/**
+ * Minimum quiet time after the assistant's last event before a user message
+ * is classified as an **agent silent stall**: the model went quiet on its own
+ * and sat idle until the human resumed. Shorter gaps are normal turn-taking.
+ * 5 minutes is long enough to exclude "user typing the next instruction" and
+ * short enough to catch "went silent mid-task until I said continue."
+ */
+export declare const SILENT_STALL_SECONDS = 300;
 /** Behavioural facets of one session. Serialized as JSON into `session_insights`. */
 export interface InsightFacets {
     toolCounts: Record<string, number>;
     /** Per-model assistant turn counts. `/insights` has no model dimension at all. */
     models: Record<string, number>;
+    /**
+     * Silent stalls attributed to the model that last spoke before the idle gap
+     * (from the nearest preceding `usage`/message model tag). Some models go
+     * quiet more often — this is the laziness split. Key = shortened model id.
+     */
+    silentStallsByModel: Record<string, number>;
     languages: Record<string, number>;
     /** Slash commands the user invoked, by name. */
     slashCommands: Record<string, number>;
@@ -84,6 +98,11 @@ export interface InsightFacets {
  * can be re-bucketed for a different display timezone without re-parsing.
  */
 export declare function computeInsightFacets(events: SessionEvent[], timezoneOffsetMinutes?: number): InsightFacets;
+/**
+ * Classify a long quiet gap after the assistant's last event as an agent silent stall.
+ * Optionally also marks an explicit resume nudge ("continue", …) after that silence.
+ */
+export declare function classifySilentStall(gapSeconds: number, userText: string, friction: Record<string, number>, corrections: Record<string, number>): void;
 /** Percentile of a numeric sample, nearest-rank. Returns 0 for an empty sample. */
 export declare function percentile(values: number[], p: number): number;
 /** Bucket response gaps for display. Returns every bucket, including empty ones. */

package/dist/lib/session/insights.js

@@ -47,18 +47,35 @@ const ERROR_CATEGORIES = [
     [['exit code', 'command failed', 'error:'], 'Command Failed'],
 ];
 /**
- * Gaps longer than this are someone leaving and coming back, not a reply latency.
- * Counted separately rather than silently dropped.
+ * Gaps longer than this leave the reply-latency percentiles (someone left for
+ * lunch / overnight). They still count as silent stalls when the assistant
+ * was the last speaker — the agent had already stopped before the user left.
  */
 const GAP_CEILING_SECONDS = 3600;
+/**
+ * Minimum quiet time after the assistant's last event before a user message
+ * is classified as an **agent silent stall**: the model went quiet on its own
+ * and sat idle until the human resumed. Shorter gaps are normal turn-taking.
+ * 5 minutes is long enough to exclude "user typing the next instruction" and
+ * short enough to catch "went silent mid-task until I said continue."
+ */
+export const SILENT_STALL_SECONDS = 300;
 /** Response-gap buckets, in ascending order. Upper bound is exclusive. */
 const GAP_BUCKETS = [
     ['<10s', 10], ['10-30s', 30], ['30s-1m', 60], ['1-2m', 120],
     ['2-5m', 300], ['5-15m', 900], ['15-60m', Infinity],
 ];
+/** Silent-stall duration buckets (agent idle after its last event). */
+const SILENT_STALL_BUCKETS = [
+    // label, min inclusive, max exclusive (Infinity = open)
+    ['silent stall: 5-15m', 300, 900],
+    ['silent stall: 15-60m', 900, 3600],
+    ['silent stall: 1h+', 3600, Infinity],
+];
 function emptyFacets() {
     return {
-        toolCounts: {}, models: {}, languages: {}, slashCommands: {}, errorCategories: {},
+        toolCounts: {}, models: {}, silentStallsByModel: {}, languages: {},
+        slashCommands: {}, errorCategories: {},
         interruptions: 0, responseGaps: [], gapsOverCeiling: 0,
         linesTouchedBefore: 0, linesTouchedAfter: 0, editingToolCalls: 0,
         filesCreated: 0, filesModified: 0, filesDeleted: 0, gitCommits: 0, gitPushes: 0,
@@ -142,10 +159,18 @@ export function computeInsightFacets(events, timezoneOffsetMinutes = new Date().
     // reported p50 by 63% (143s against a true 88s), because fast replies are common and
     // dropping them all shifts the median right. A 0-second reply is a real reply.
     //
-    // The upper bound stays: past an hour the user went away and came back, which is not
-    // a reply latency. It censors 5.5% of gaps, and `gapsOverCeiling` reports how many so
-    // the number is never quietly truncated.
+    // The upper bound stays for *percentiles only*: past an hour the user often left the
+    // desk, which is not "reply latency." Those gaps still feed silent-stall classification
+    // (the agent had already stopped). `gapsOverCeiling` reports how many so percentiles
+    // are never quietly truncated.
+    //
+    // Silent stall (agent idle): when the gap after the assistant's last event is long
+    // enough that the model clearly stopped mid-session and waited for a human nudge
+    // ("continue", "keep going", or any later message after minutes of silence). This is
+    // the inverse framing of reply latency: same timestamps, attributed to the agent.
     let lastAssistantTs = null;
+    /** Shortened model id of the last assistant activity (for stall attribution). */
+    let lastAssistantModel = null;
     let lastFailedTool = null;
     for (const e of events) {
         const ts = new Date(e.timestamp).getTime();
@@ -157,8 +182,14 @@ export function computeInsightFacets(events, timezoneOffsetMinutes = new Date().
             case 'usage':
                 // 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));
+                if (e.model) {
+                    const m = shortenModel(e.model);
+                    bump(f.models, m);
+                    // Usage rows are the reliable model tag for Claude turns; keep as
+                    // "last model" even when the timestamp is missing so a following
+                    // tool_use still attributes a stall correctly.
+                    lastAssistantModel = m;
+                }
                 break;
             case 'error':
                 bump(f.errorCategories, categorizeError(e.content ?? e.output ?? ''));
@@ -175,12 +206,18 @@ export function computeInsightFacets(events, timezoneOffsetMinutes = new Date().
                 if (e.role === 'assistant') {
                     if (hasTs)
                         lastAssistantTs = ts;
+                    if (e.model)
+                        lastAssistantModel = shortenModel(e.model);
                     break;
                 }
                 if (e.role !== 'user')
                     break;
-                if (!e._synthetic)
-                    classifyCorrection(e.content ?? '', f.correctionSignals);
+                // Synthetic user rows (stop-hook feedback, injected meta) are not a human
+                // resume — skip correction/stall classification and leave lastAssistantTs so
+                // the next real user message still measures the full idle gap.
+                if (e._synthetic)
+                    break;
+                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
@@ -196,6 +233,11 @@ export function computeInsightFacets(events, timezoneOffsetMinutes = new Date().
                             f.responseGaps.push(gap);
                         else if (gap >= GAP_CEILING_SECONDS)
                             f.gapsOverCeiling++;
+                        // Agent silent stall: model stopped; session sat idle until this message.
+                        if (gap >= SILENT_STALL_SECONDS) {
+                            classifySilentStall(gap, e.content ?? '', f.frictionSignals, f.correctionSignals);
+                            bump(f.silentStallsByModel, lastAssistantModel ?? 'unknown');
+                        }
                     }
                 }
                 lastAssistantTs = null;
@@ -207,6 +249,8 @@ export function computeInsightFacets(events, timezoneOffsetMinutes = new Date().
                     break;
                 if (hasTs)
                     lastAssistantTs = ts;
+                if (e.model)
+                    lastAssistantModel = shortenModel(e.model);
                 const args = e.args ?? {};
                 const toolName = e.tool ?? '';
                 if (/askuserquestion/i.test(toolName))
@@ -257,6 +301,24 @@ const CORRECTION_PATTERNS = [
     [/\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"],
 ];
+/** User text that is a pure resume nudge after the agent went silent. */
+const RESUME_NUDGE_PATTERN = /\b(?:continue|keep going|don'?t stop|resume|pick up|you stopped|still there|wake up|hello\??|are you (?:there|stuck)|go on)\b/i;
+/**
+ * Classify a long quiet gap after the assistant's last event as an agent silent stall.
+ * Optionally also marks an explicit resume nudge ("continue", …) after that silence.
+ */
+export function classifySilentStall(gapSeconds, userText, friction, corrections) {
+    for (const [label, min, max] of SILENT_STALL_BUCKETS) {
+        if (gapSeconds >= min && gapSeconds < max) {
+            bump(friction, label);
+            break;
+        }
+    }
+    const normalized = userText.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+    if (normalized && RESUME_NUDGE_PATTERN.test(normalized)) {
+        bump(corrections, 'resume after silent stall');
+    }
+}
 const AUTOMATION_PATTERNS = [
     [/\bgh pr (?:checks|view|merge)\b/i, 'PR babysitting'],
     [/\bagents secrets (?:list|exec|unlock|export)\b/i, 'secrets unlock dance'],
@@ -360,6 +422,8 @@ export function mergeFacets(into, add) {
         bump(into.toolCounts, k, v);
     for (const [k, v] of Object.entries(add.models))
         bump(into.models, k, v);
+    for (const [k, v] of Object.entries(add.silentStallsByModel ?? {}))
+        bump(into.silentStallsByModel, k, v);
     for (const [k, v] of Object.entries(add.languages))
         bump(into.languages, k, v);
     for (const [k, v] of Object.entries(add.slashCommands))
@@ -406,6 +470,7 @@ export function topEntries(counts, limit) {
 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: 'resume after silent stall', category: 'rule', action: 'Never stop mid-task waiting for a human ping — finish the current goal or park with an explicit blocker; keep driving CI/review/merge without going idle.' },
         { 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.' },
@@ -416,6 +481,9 @@ export function buildInsightActions(sessions) {
         { 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: 'silent stall: 5-15m', category: 'rule', action: 'Stop ending turns while work remains open — after a tool batch, take the next step or schedule a real background wait that re-invokes you; do not sit idle until the user says continue.' },
+        { source: 'frictionSignals', label: 'silent stall: 15-60m', category: 'rule', action: 'Long idle after the assistant last spoke is an agent stop, not a user pause — drive open PRs/CI/todos to completion or name a true external blocker instead of going silent.' },
+        { source: 'frictionSignals', label: 'silent stall: 1h+', category: 'rule', action: 'Sessions that sit idle for an hour+ after the model stops are stranded work — use stop-gates, background watches, and queue drain so a human is not the only resume signal.' },
         { 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.' },

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

@@ -5,6 +5,7 @@ export type SessionRecoveryTarget = {
     mode: 'native';
     agent: AgentId;
     version: string;
+    cwd?: string;
     reason: string;
 } | {
     mode: 'continue';
@@ -12,6 +13,13 @@ export type SessionRecoveryTarget = {
     version: string;
     reason: string;
 };
+export type NativeResumeInspection = {
+    available: true;
+    cwd?: string;
+} | {
+    available: false;
+    reason: string;
+};
 export declare class SessionRecoveryError extends Error {
     constructor(message: string);
 }
@@ -21,6 +29,14 @@ export declare function sessionOriginDevice(session: Pick<SessionMeta, 'machine'
 export declare function sessionRecoveryPeer(session: Pick<SessionMeta, 'machine'>, selfCheck?: (host: string) => boolean): string | undefined;
 /** Whether an explicit placement names the session's origin device. */
 export declare function sessionRecoveryDestinationMatches(session: Pick<SessionMeta, 'machine'>, requestedHost: string, self?: string): boolean;
+/**
+ * Prove that the indexed transcript is reachable from the exact active version
+ * home that would receive native resume. Retained trash/backup transcripts are
+ * intentionally rejected here: they remain readable by `/continue`, but a new
+ * installation with the same version number must not native-resume an empty
+ * isolated home.
+ */
+export declare function inspectNativeResumeSession(session: SessionMeta, versionHome: string): NativeResumeInspection;
 /**
  * Decide how a durable session resumes on the device that owns it.
  *
@@ -29,7 +45,7 @@ export declare function sessionRecoveryDestinationMatches(session: Pick<SessionM
  * same harness and uses `/continue`, whose indexed transcript reader can reach
  * retained version trash. No healthy same-harness account is a loud failure.
  */
-export declare function resolveSessionRecoveryFromCandidates(session: SessionMeta, candidates: RotateCandidate[], supportsNative?: (agent: AgentId, version?: string) => boolean): SessionRecoveryTarget;
+export declare function resolveSessionRecoveryFromCandidates(session: SessionMeta, candidates: RotateCandidate[], supportsNative?: (agent: AgentId, version?: string) => boolean, nativeInspection?: NativeResumeInspection): SessionRecoveryTarget;
 export declare function resolveSessionRecovery(session: SessionMeta): Promise<SessionRecoveryTarget>;
 /** Stable self-command used by focus, resume, and attach. The owning device runs
  * the recovery resolver above; callers must not native-resume another version's