improvement(logs): only flag genuine regex intent, document the truncated invariant

Review follow-ups on the literal log-grep.

The `patternNotice` fired on any regex metacharacter, which includes `.` — so
ordinary literal searches (`example.com`, `file.pdf`, `v1.2.3`,
`block_1.output`) were told their pattern "was not interpreted as a regex",
inviting the agent to retry a search that had in fact worked. Measured 10 false
notices across 19 realistic literal searches. `REGEX_INTENT` now keys on actual
regex intent — escape classes, character class, group, alternation, a
leading/trailing anchor, or a repetition quantifier — which drops that to 0/19
while still flagging all 10 regex attempts tested.

`truncated` gains a TSDoc block stating its invariant: it reports that trace was
left unread, not that a budget was reached. Every point that skips work goes
through `done()`, which sets it, so a budget exhausted by the final match
correctly reports `false`. Raised by Cursor Bugbot; behavior is right, the
contract was just implicit.

Also drops `snippetAround`'s `maxChars` parameter, which every caller passed
from the state object it already receives.

Author: waleedlatif1

apps/sim/lib/logs/log-views.test.ts

@@ -177,6 +177,16 @@ describe('grepSpans', () => {
     expect(result.patternNotice).toContain('literal')
   })
 
+  it.each(['example.com', 'file.pdf', 'v1.2.3', 'block_1.output', '$0.42', 'why?'])(
+    'does not warn about regex on the ordinary literal %s',
+    async (pattern) => {
+      const spans = [span({ output: { v: `saw ${pattern} here` } })]
+      const result = await grepSpans(spans, pattern, ctx)
+      expect(result.matches.some((m) => m.field === 'output')).toBe(true)
+      expect(result.patternNotice).toBeUndefined()
+    }
+  )
+
   it('does not interpret a regex pattern, and says so', async () => {
     const spans = [span({ output: { v: 'status=503' } })]
 

apps/sim/lib/logs/log-views.ts

@@ -188,6 +188,12 @@ export interface GrepSpanMatch {
 
 export interface GrepSpansResult {
   matches: GrepSpanMatch[]
+  /**
+   * Whether the scan stopped with trace left unread — not whether a budget was
+   * reached. Every point that skips work goes through `done`, which sets this,
+   * so a budget exhausted by the very last match reports `false`: the caller's
+   * results are complete, and nothing was withheld.
+   */
   truncated: boolean
   /**
    * Present when the pattern contained regex syntax, which is matched literally.
@@ -224,8 +230,17 @@ function escapeRegExp(input: string): string {
   return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
-/** Regex syntax in a pattern signals the caller expected regex semantics. */
-const REGEX_METACHARACTERS = /[.*+?^${}()|[\]\\]/
+/**
+ * Signals that the caller wrote a pattern *intending* regex semantics: escape
+ * classes, a character class, a group, alternation, a leading/trailing anchor,
+ * or a repetition quantifier.
+ *
+ * Deliberately narrower than the set `escapeRegExp` escapes. A bare `.` or `?`
+ * is ordinary text in the things people actually grep for — `example.com`,
+ * `file.pdf`, `v1.2.3`, `block_1.output` — and flagging those would tell the
+ * caller its correct search was misinterpreted, prompting a pointless retry.
+ */
+const REGEX_INTENT = /\\[dwsbDWSB]|[[\]()|*+]|^\^|\$$|\{\d+,?\d*\}/
 
 /**
  * Compile a caller-supplied grep pattern as a case-insensitive literal.
@@ -244,7 +259,7 @@ const REGEX_METACHARACTERS = /[.*+?^${}()|[\]\\]/
  */
 function compilePattern(pattern: string): { regex: RegExp; notice?: string } {
   const regex = new RegExp(escapeRegExp(pattern), 'i')
-  if (!REGEX_METACHARACTERS.test(pattern)) return { regex }
+  if (!REGEX_INTENT.test(pattern)) return { regex }
   return {
     regex,
     notice:
@@ -266,9 +281,10 @@ function runTimed<T>(state: GrepState, match: (regex: RegExp) => T): T {
   }
 }
 
-function snippetAround(text: string, state: GrepState, maxChars: number): string {
+function snippetAround(text: string, state: GrepState): string {
   const m = runTimed(state, (regex) => regex.exec(text))
   const index = m ? m.index : 0
+  const maxChars = state.maxSnippetChars
   const half = Math.floor(maxChars / 2)
   const start = Math.max(0, index - half)
   const end = Math.min(text.length, start + maxChars)
@@ -304,7 +320,7 @@ function recordIfMatch(
     blockId: span.blockId,
     name: span.name,
     field,
-    snippet: snippetAround(text, state, state.maxSnippetChars),
+    snippet: snippetAround(text, state),
   })
   if (state.matches.length >= state.maxMatches) state.truncated = true
 }