fix: correct false non-interactive classification for large sessions

server/coding-cli/session-indexer.ts

@@ -47,6 +47,46 @@ function maxDefined(a: number | undefined, b: number | undefined): number | unde
   return Math.max(a, b)
 }
 
+// Byte pattern for a text user message (content is a string, not a tool_result array).
+const USER_TEXT_PATTERN = Buffer.from('"role":"user","content":"')
+
+/**
+ * Fast byte scan of a full file for multiple text user messages.
+ * Returns true if >1 match is found, indicating the session is interactive.
+ */
+export async function scanFileForUserTextMessages(filePath: string): Promise<boolean> {
+  try {
+    const fd = await fsp.open(filePath, 'r')
+    try {
+      const stat = await fd.stat()
+      const chunkSize = 64 * 1024
+      let found = 0
+      const buf = Buffer.alloc(chunkSize + USER_TEXT_PATTERN.length)
+      let position = 0
+      while (position < stat.size) {
+        const readSize = Math.min(chunkSize + USER_TEXT_PATTERN.length, stat.size - position)
+        const { bytesRead } = await fd.read(buf, 0, readSize, position)
+        // Skip byte 0 on non-first chunks — it was already the last scannable
+        // position in the previous chunk's overlap region.
+        let offset = position > 0 ? 1 : 0
+        while (offset < bytesRead) {
+          const idx = buf.indexOf(USER_TEXT_PATTERN, offset)
+          if (idx === -1 || idx >= bytesRead) break
+          found++
+          if (found > 1) return true
+          offset = idx + USER_TEXT_PATTERN.length
+        }
+        position += chunkSize
+      }
+    } finally {
+      await fd.close()
+    }
+  } catch {
+    // If we can't read the file, leave the classification as-is.
+  }
+  return false
+}
+
 function findNearestExistingAncestor(targetPath: string): string {
   let current = normalizeFilePath(targetPath)
   let parent = path.dirname(current)
@@ -607,6 +647,13 @@ export class CodingCliSessionIndexer {
 
     const snippet = await readSessionSnippet(filePath)
     const meta = await provider.parseSessionFile(snippet.content, filePath)
+    // Snippet-based parsing can misclassify large sessions as non-interactive
+    // when text user messages fall outside the head+tail window. A fast byte
+    // scan of the full file for the user-text pattern corrects this cheaply.
+    if (snippet.truncated && meta.isNonInteractive) {
+      const hasMultipleUserMessages = await scanFileForUserTextMessages(filePath)
+      if (hasMultipleUserMessages) meta.isNonInteractive = undefined
+    }
     if (snippet.truncated && provider.name === 'codex') {
       const tailMeta = snippet.tailContent
         ? await provider.parseSessionFile(snippet.tailContent, filePath)

test/unit/server/coding-cli/scan-user-text-messages.test.ts

@@ -0,0 +1,148 @@
+// Tests for scanFileForUserTextMessages — byte-level fallback that corrects
+// false non-interactive classification on large truncated session files.
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import path from 'path'
+import os from 'os'
+import fsp from 'fs/promises'
+import { scanFileForUserTextMessages } from '../../../../server/coding-cli/session-indexer.js'
+
+let tempDir: string
+
+beforeEach(async () => {
+  tempDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'freshell-scan-test-'))
+})
+
+afterEach(async () => {
+  await fsp.rm(tempDir, { recursive: true, force: true })
+})
+
+function jsonlLine(obj: Record<string, unknown>): string {
+  return JSON.stringify(obj)
+}
+
+function userTextMessage(content: string): string {
+  return jsonlLine({
+    type: 'user',
+    message: { role: 'user', content },
+  })
+}
+
+function userToolResult(): string {
+  return jsonlLine({
+    type: 'user',
+    message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'abc', content: '' }] },
+  })
+}
+
+function assistantMessage(text: string): string {
+  return jsonlLine({
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text }] },
+  })
+}
+
+describe('scanFileForUserTextMessages', () => {
+  it('returns false for empty file', async () => {
+    const filePath = path.join(tempDir, 'empty.jsonl')
+    await fsp.writeFile(filePath, '')
+    expect(await scanFileForUserTextMessages(filePath)).toBe(false)
+  })
+
+  it('returns false for single text user message', async () => {
+    const filePath = path.join(tempDir, 'single.jsonl')
+    await fsp.writeFile(filePath, [
+      userTextMessage('Hello'),
+      assistantMessage('Hi there'),
+    ].join('\n'))
+    expect(await scanFileForUserTextMessages(filePath)).toBe(false)
+  })
+
+  it('returns true for two text user messages', async () => {
+    const filePath = path.join(tempDir, 'two.jsonl')
+    await fsp.writeFile(filePath, [
+      userTextMessage('Hello'),
+      assistantMessage('Hi there'),
+      userTextMessage('Do something'),
+      assistantMessage('Done'),
+    ].join('\n'))
+    expect(await scanFileForUserTextMessages(filePath)).toBe(true)
+  })
+
+  it('does not count tool_result user messages toward interactivity', async () => {
+    const filePath = path.join(tempDir, 'tool-results.jsonl')
+    await fsp.writeFile(filePath, [
+      userTextMessage('Hello'),
+      assistantMessage('Let me check'),
+      userToolResult(),
+      userToolResult(),
+      userToolResult(),
+    ].join('\n'))
+    expect(await scanFileForUserTextMessages(filePath)).toBe(false)
+  })
+
+  it('returns true when text messages are separated by many tool_result messages', async () => {
+    const filePath = path.join(tempDir, 'mixed.jsonl')
+    const lines = [
+      userTextMessage('First question'),
+      assistantMessage('Working on it'),
+    ]
+    // Add many tool_result exchanges in between
+    for (let i = 0; i < 50; i++) {
+      lines.push(userToolResult())
+      lines.push(assistantMessage(`Step ${i}`))
+    }
+    lines.push(userTextMessage('Second question'))
+    lines.push(assistantMessage('Here you go'))
+    await fsp.writeFile(filePath, lines.join('\n'))
+    expect(await scanFileForUserTextMessages(filePath)).toBe(true)
+  })
+
+  it('handles pattern spanning chunk boundaries', async () => {
+    // Create a file where user text messages are separated by enough data
+    // to span multiple 64KB chunks
+    const filePath = path.join(tempDir, 'large.jsonl')
+    const lines = [userTextMessage('First message')]
+    // Pad with large assistant messages to push past 64KB
+    const bigText = 'x'.repeat(70_000)
+    lines.push(assistantMessage(bigText))
+    lines.push(userTextMessage('Second message'))
+    await fsp.writeFile(filePath, lines.join('\n'))
+    expect(await scanFileForUserTextMessages(filePath)).toBe(true)
+  })
+
+  it('does not double-count a pattern at an exact chunk boundary', async () => {
+    // Place a single user text message so the target byte pattern starts at
+    // exactly byte 64KB — the overlap position scanned by both adjacent chunks.
+    const chunkSize = 64 * 1024
+    const filePath = path.join(tempDir, 'boundary.jsonl')
+    const pattern = '"role":"user","content":"'
+    // Build a user message line, then figure out where the pattern sits inside it
+    const userLine = userTextMessage('Only message')
+    const patternOffsetInLine = userLine.indexOf(pattern)
+    // Pad so that (padding + \n + patternOffsetInLine) = chunkSize
+    const prefixLength = chunkSize - 1 - patternOffsetInLine // -1 for \n separator
+    const padding = 'x'.repeat(prefixLength)
+    const content = padding + '\n' + userLine
+    // Sanity-check alignment
+    expect(content.indexOf(pattern)).toBe(chunkSize)
+    await fsp.writeFile(filePath, content)
+    // Only one text user message — must return false, not double-count
+    expect(await scanFileForUserTextMessages(filePath)).toBe(false)
+  })
+
+  it('returns false for nonexistent file', async () => {
+    const filePath = path.join(tempDir, 'nonexistent.jsonl')
+    expect(await scanFileForUserTextMessages(filePath)).toBe(false)
+  })
+
+  it('returns false for file with only tool_result user messages', async () => {
+    const filePath = path.join(tempDir, 'only-tools.jsonl')
+    await fsp.writeFile(filePath, [
+      userToolResult(),
+      assistantMessage('Done'),
+      userToolResult(),
+      assistantMessage('Done again'),
+    ].join('\n'))
+    expect(await scanFileForUserTextMessages(filePath)).toBe(false)
+  })
+})