@phenx-inc/ctlsurf 0.13.6 → 0.14.1

package/src/main/observer/spans.ts

@@ -0,0 +1,170 @@
+import type { LedgerEvent, Span, SpanKind, WorkRef } from './types'
+import { extractTicketRefs } from './tier0'
+
+/**
+ * Span Tracker — deterministic time attribution (spec §5).
+ *
+ * A span is a contiguous interval attributed to a work item. The activity
+ * sub-ledger (agent_active / human_active / idle) is derived purely from
+ * pty timing — no model needed:
+ *   - agent_active: the AgentStateMonitor reports the agent busy
+ *   - human_active: a human keystroke landed within the last HUMAN_WINDOW_MS
+ *   - idle: everything else
+ *
+ * Deterministic segmentation first: a new external ticket id in a user
+ * message closes the current span and opens a new one (boundary_source
+ * `tier0`). Tier 1 can also emit a boundary from its span hypothesis
+ * (`tier1`), costing ~20 output tokens inside a call already happening.
+ */
+
+const HUMAN_WINDOW_MS = 15_000
+
+const BUG_HINT = /\b(bug|fix|broken|crash|error|regression|doesn'?t work|not working)\b/i
+const CHORE_HINT = /\b(bump|upgrade|rename|cleanup|clean up|chore|reformat|typo)\b/i
+
+export type SpanSink = (span: Span) => void
+
+export class SpanTracker {
+  private readonly session: string
+  private readonly sink: SpanSink
+  private readonly now: () => number
+
+  private spanSeq = 0
+  private start = 0
+  private workRef: WorkRef = { node: null, external: [] }
+  private kind: SpanKind = 'unticketed'
+  private firstEventId: string | null = null
+  private lastEventId: string | null = null
+
+  private agentBusy = false
+  private lastHumanAt = 0
+  private lastAccountAt = 0
+  private activityMs = { agent: 0, human: 0, idle: 0 }
+  private started = false
+
+  constructor(session: string, sink: SpanSink, now: () => number = Date.now) {
+    this.session = session
+    this.sink = sink
+    this.now = now
+  }
+
+  /** Begin attribution at session start. */
+  begin(): void {
+    if (this.started) return
+    this.started = true
+    const t = this.now()
+    this.start = t
+    this.lastAccountAt = t
+  }
+
+  /** A human keystroke reached the pty. */
+  noteHumanInput(): void {
+    if (!this.started) return
+    this.account()
+    this.lastHumanAt = this.now()
+  }
+
+  /** Agent activity state changed (from AgentStateMonitor). */
+  noteAgentState(state: string): void {
+    if (!this.started) return
+    this.account()
+    this.agentBusy = state === 'busy'
+  }
+
+  /**
+   * A ledger event arrived. Detects deterministic boundaries: a user message
+   * referencing a different external ticket id switches the work item.
+   */
+  noteEvent(event: LedgerEvent): void {
+    if (!this.started) return
+    this.account()
+    if (!this.firstEventId) this.firstEventId = event.id
+    this.lastEventId = event.id
+
+    if (event.type !== 'user_message' || !event.text) return
+    const refs = extractTicketRefs(event.text)
+    if (refs.length === 0) {
+      if (this.workRef.external.length === 0) this.kind = this.inferKind(event.text, null)
+      return
+    }
+    const known = this.workRef.external
+    if (known.length === 0) {
+      // Attribution was unknown until now: the first ticket mention names
+      // the current span rather than splitting off a leading stub.
+      this.workRef = { node: null, external: refs }
+      this.kind = this.inferKind(event.text, refs[0])
+    } else if (!refs.some((r) => known.includes(r))) {
+      this.closeSpan('tier0')
+      this.workRef = { node: null, external: refs }
+      this.kind = this.inferKind(event.text, refs[0])
+      this.firstEventId = event.id
+      this.lastEventId = event.id
+    }
+  }
+
+  /** Tier-1 detected a context switch the structural signals missed. */
+  applyBoundary(newWorkRef: string | undefined, kind: SpanKind | undefined): void {
+    if (!this.started) return
+    this.account()
+    this.closeSpan('tier1')
+    this.workRef = newWorkRef
+      ? { node: null, external: extractTicketRefs(newWorkRef).length ? extractTicketRefs(newWorkRef) : [newWorkRef] }
+      : { node: null, external: [] }
+    this.kind = kind || (this.workRef.external.length ? 'feature' : 'unticketed')
+  }
+
+  /** Session over: close and emit the final span. */
+  end(): void {
+    if (!this.started) return
+    this.account()
+    this.closeSpan('tier0')
+    this.started = false
+  }
+
+  /** Current hypothesis (fed to Tier 1 as rolling state). */
+  currentWorkRef(): string {
+    return this.workRef.external.join(',') || '(unticketed)'
+  }
+
+  private inferKind(text: string, ref: string | null): SpanKind {
+    if (BUG_HINT.test(text)) return 'bug'
+    if (CHORE_HINT.test(text)) return 'chore'
+    return ref ? 'feature' : 'unticketed'
+  }
+
+  private account(): void {
+    const t = this.now()
+    const delta = t - this.lastAccountAt
+    if (delta <= 0) return
+    if (this.agentBusy) this.activityMs.agent += delta
+    else if (t - this.lastHumanAt < HUMAN_WINDOW_MS) this.activityMs.human += delta
+    else this.activityMs.idle += delta
+    this.lastAccountAt = t
+  }
+
+  private closeSpan(source: Span['boundary_source']): void {
+    const t = this.now()
+    if (t - this.start < 1_000) return // ignore zero-length churn
+    const span: Span = {
+      type: 'observer.span',
+      id: `spn_${this.session.slice(4, 10)}_${++this.spanSeq}`,
+      session: this.session,
+      work_ref: this.workRef,
+      kind: this.kind,
+      start: new Date(this.start).toISOString(),
+      end: new Date(t).toISOString(),
+      activity: {
+        agent_active_s: Math.round(this.activityMs.agent / 1000),
+        human_active_s: Math.round(this.activityMs.human / 1000),
+        idle_s: Math.round(this.activityMs.idle / 1000),
+      },
+      boundary_source: source,
+      receipts: [this.firstEventId, this.lastEventId].filter((r): r is string => !!r),
+    }
+    this.sink(span)
+    this.start = t
+    this.activityMs = { agent: 0, human: 0, idle: 0 }
+    this.firstEventId = null
+    this.lastEventId = null
+  }
+}

package/src/main/observer/store.ts

@@ -0,0 +1,200 @@
+import type { CtlsurfApi } from '../ctlsurfApi'
+import type { Finding } from './types'
+import { log as baseLog } from '../logger'
+
+const FINDINGS_TITLE = 'Observer Findings'
+const FINDINGS_KEY = 'observer_findings'
+const LOG_TITLE = 'Observer'
+const LOG_KEY = 'observer_log'
+const AGENT_DATASTORE_PAGE_TITLE = 'Agent Datastore'
+
+/**
+ * Observer → ctlsurf delivery (spec §7.1).
+ *
+ * Findings land in an "Observer Findings" datastore and session digests in
+ * an "Observer" log block, both on the project's Agent Datastore page —
+ * the same resolution pattern as TicketStore/TimeTracker (folder by path →
+ * Agent Datastore page → find/create block by system_key). Everything is
+ * best-effort: delivery failures are logged, never thrown.
+ */
+
+const SEVERITY_OPTIONS = [
+  { value: 'info', color: 'gray' },
+  { value: 'warn', color: 'yellow' },
+  { value: 'high', color: 'orange' },
+  { value: 'critical', color: 'red' },
+]
+const CATEGORY_OPTIONS = [
+  { value: 'assumption', color: 'blue' },
+  { value: 'license', color: 'purple' },
+  { value: 'security', color: 'red' },
+  { value: 'destructive', color: 'red' },
+  { value: 'scope_drift', color: 'yellow' },
+  { value: 'unverified_claim', color: 'orange' },
+  { value: 'test_integrity', color: 'red' },
+  { value: 'contradiction', color: 'red' },
+  { value: 'bad_practice', color: 'yellow' },
+  { value: 'dependency', color: 'blue' },
+]
+const STATUS_OPTIONS = [
+  { value: 'open', color: 'blue' },
+  { value: 'ack', color: 'yellow' },
+  { value: 'dismissed', color: 'gray' },
+  { value: 'resolved', color: 'green' },
+  { value: 'escalated', color: 'red' },
+]
+
+interface ColumnSpec {
+  name: string
+  type: string
+  options?: Array<{ value: string; color?: string }>
+}
+
+const COLUMNS: ColumnSpec[] = [
+  { name: 'Time', type: 'date' },
+  { name: 'Title', type: 'text' },
+  { name: 'Category', type: 'select', options: CATEGORY_OPTIONS },
+  { name: 'Severity', type: 'select', options: SEVERITY_OPTIONS },
+  { name: 'Confidence', type: 'number' },
+  { name: 'Detail', type: 'text' },
+  { name: 'Receipts', type: 'text' },
+  { name: 'Session', type: 'text' },
+  { name: 'Tier', type: 'number' },
+  { name: 'Status', type: 'select', options: STATUS_OPTIONS },
+]
+
+function log(...args: unknown[]): void {
+  baseLog('[observer-store]', ...args)
+}
+
+function findPageByTitle(pages: any[], title: string): any | null {
+  for (const p of pages) {
+    if (p?.title === title) return p
+    if (p?.children?.length) {
+      const c = findPageByTitle(p.children, title)
+      if (c) return c
+    }
+  }
+  return null
+}
+
+export class ObserverStore {
+  private api: CtlsurfApi
+  private findingsCache = new Map<string, string>()
+  private logCache = new Map<string, string>()
+
+  constructor(api: CtlsurfApi) {
+    this.api = api
+  }
+
+  async addFindings(cwd: string, findings: Finding[]): Promise<void> {
+    if (findings.length === 0 || !this.api.getApiKey()) return
+    try {
+      const blockId = await this.ensureBlock(cwd, this.findingsCache, {
+        type: 'datastore',
+        title: FINDINGS_TITLE,
+        systemKey: FINDINGS_KEY,
+        columns: COLUMNS,
+      })
+      if (!blockId) return
+      for (const f of findings) {
+        await this.api.addRow(blockId, {
+          Time: f.ts,
+          Title: f.title,
+          Category: f.category,
+          Severity: f.severity,
+          Confidence: Math.round(f.confidence * 100) / 100,
+          Detail: f.detail,
+          Receipts: f.receipts.join(', '),
+          Session: f.session,
+          Tier: f.tier,
+          Status: f.status,
+        })
+      }
+      log(`Delivered ${findings.length} finding(s) for ${cwd}`)
+    } catch (err: any) {
+      log(`addFindings failed for ${cwd}: ${err?.message || err}`)
+    }
+  }
+
+  async appendDigest(
+    cwd: string,
+    digest: string,
+    data: Record<string, unknown>,
+  ): Promise<void> {
+    if (!this.api.getApiKey()) return
+    try {
+      const blockId = await this.ensureBlock(cwd, this.logCache, {
+        type: 'log',
+        title: LOG_TITLE,
+        systemKey: LOG_KEY,
+      })
+      if (!blockId) return
+      await this.api.appendLog(blockId, 'session_digest', digest, data)
+      log(`Delivered session digest for ${cwd}`)
+    } catch (err: any) {
+      log(`appendDigest failed for ${cwd}: ${err?.message || err}`)
+    }
+  }
+
+  /** Folder by path → Agent Datastore page → find/create block by system_key. */
+  private async ensureBlock(
+    cwd: string,
+    cache: Map<string, string>,
+    spec: { type: string; title: string; systemKey: string; columns?: ColumnSpec[] },
+  ): Promise<string | null> {
+    const cached = cache.get(cwd)
+    if (cached) return cached
+
+    let folder: any = null
+    try {
+      folder = await this.api.findFolderByPath(cwd)
+    } catch {
+      return null
+    }
+    if (!folder?.id) return null
+
+    const folderDetail = await this.api.getFolder(folder.id)
+    const agentPage = findPageByTitle(folderDetail?.pages || [], AGENT_DATASTORE_PAGE_TITLE)
+    if (!agentPage?.id) return null
+
+    const summaries = (await this.api.getPageBlockSummaries(agentPage.id)) || []
+    for (const s of summaries.filter((b: any) => b?.type === spec.type && b?.id)) {
+      try {
+        const block = await this.api.getBlock(s.id)
+        const props = (block?.props || {}) as Record<string, unknown>
+        if (props.system_key === spec.systemKey || s.title === spec.title) {
+          if (props.system_key !== spec.systemKey) {
+            await this.api.updateBlock(s.id, { props: { ...props, system_key: spec.systemKey } }).catch(() => { /* ignore */ })
+          }
+          cache.set(cwd, s.id)
+          return s.id
+        }
+      } catch { /* try the next candidate */ }
+    }
+
+    const props: Record<string, unknown> = { system_key: spec.systemKey }
+    if (spec.columns) {
+      props.columns = spec.columns.map((c, i) => ({
+        id: `col_${i}`,
+        name: c.name,
+        type: c.type,
+        ...(c.options ? { options: c.options } : {}),
+      }))
+    } else {
+      props.entries = []
+      props.max_entries = 500
+    }
+    const created = await this.api.createBlock(agentPage.id, {
+      type: spec.type,
+      title: spec.title,
+      props,
+    })
+    if (created?.id) {
+      log(`Created "${spec.title}" block on Agent Datastore page for ${cwd}`)
+      cache.set(cwd, created.id)
+      return created.id
+    }
+    return null
+  }
+}

package/src/main/observer/tier0.ts

@@ -0,0 +1,234 @@
+import path from 'path'
+import type { LedgerEvent, Tier0Tag } from './types'
+
+/**
+ * Tier 0 — static taggers + truncation policy (spec §3.1, Phase 1 cut).
+ *
+ * Zero model cost. Pure pattern matches that annotate ledger events for
+ * downstream tiers, plus the truncation policy applied to what Tier 1 reads
+ * (the full output stays in the ledger).
+ *
+ * No gates yet: destructive patterns are tagged `would_gate:*` (log-only
+ * "would have gated") and surface in the digest, never block.
+ */
+
+// ─── Truncation policy ───────────────────────────
+
+const TRUNCATE_THRESHOLD = 2_000
+const HEAD_CHARS = 900
+const TAIL_CHARS = 400
+const MAX_ERROR_LINES = 5
+
+/** Head + tail + structural summary for oversized tool output. */
+export function truncateForTier1(content: string): string {
+  if (content.length <= TRUNCATE_THRESHOLD) return content
+  const lines = content.split('\n')
+  const errorLines = lines
+    .filter((l) => /\b(error|failed|failure|exception|traceback|fatal)\b/i.test(l))
+    .slice(0, MAX_ERROR_LINES)
+  const summaryParts = [`[truncated: ${content.length} chars, ${lines.length} lines]`]
+  if (errorLines.length > 0) {
+    summaryParts.push(`[error lines: ${errorLines.map((l) => l.trim().slice(0, 160)).join(' | ')}]`)
+  }
+  return `${content.slice(0, HEAD_CHARS)}\n…\n${content.slice(-TAIL_CHARS)}\n${summaryParts.join('\n')}`
+}
+
+// ─── Pattern tables ──────────────────────────────
+
+/** Assumption phrases in agent text — the residue of unstated decisions. */
+const ASSUMPTION_PATTERNS =
+  /\bI(?:'|’)?ll assume\b|\bI(?:'|’)?m assuming\b|\bassuming (?:that|the|you|it)\b|\bfor simplicity\b|\bin production you(?:'|’)?d\b|\bshould work\b|\bfor now\b|\bas a placeholder\b|\bhardcod(?:e|ed|ing) for now\b/i
+
+/** Completion claims the ledger can ground-truth against. */
+const TEST_CLAIM_PATTERNS =
+  /\btests? (?:are |all |now )?(?:pass|passing|green)\b|\ball (?:tests? )?green\b|\btest suite passes\b/i
+const DEPLOY_CLAIM_PATTERNS = /\b(?:deployed|published|released) (?:to|the|successfully)\b|\bsuccessfully (?:deployed|published)\b/i
+
+/** Dependency manifests whose diffs deserve license/pinning review. */
+const MANIFEST_FILES =
+  /\b(?:package\.json|package-lock\.json|yarn\.lock|pnpm-lock\.yaml|Cargo\.toml|Cargo\.lock|requirements(?:-[\w]+)?\.txt|pyproject\.toml|poetry\.lock|Pipfile(?:\.lock)?|go\.mod|go\.sum|Gemfile(?:\.lock)?|composer\.json|composer\.lock)\b/
+
+/** Dependency-adding commands. */
+const DEP_ADD_COMMANDS =
+  /\b(?:npm|pnpm|yarn|bun)\s+(?:install|add|i)\s+(?!-D\s*$)\S|\bpip3?\s+install\s+\S|\bcargo\s+add\s+\S|\bgo\s+get\s+\S|\bgem\s+install\s+\S|\bcomposer\s+require\s+\S/
+
+/** Test-runner invocations (paired with exit results for ground truth). */
+const TEST_COMMANDS =
+  /(?:^|[;&|]\s*)(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?test\b|\bpytest\b|\bjest\b|\bvitest\b|\bgo\s+test\b|\bcargo\s+(?:test|nextest)\b|\brspec\b|\bphpunit\b|\bmvn\s+test\b|\bgradle(?:w)?\s+test\b/
+
+/** Secret-shaped strings: known prefixes only (near-zero false positives). */
+const SECRET_PATTERNS: Array<{ re: RegExp; label: string }> = [
+  { re: /\bAKIA[0-9A-Z]{16}\b/, label: 'AWS access key id' },
+  { re: /\bghp_[A-Za-z0-9]{36,}\b/, label: 'GitHub personal access token' },
+  { re: /\bgithub_pat_[A-Za-z0-9_]{22,}\b/, label: 'GitHub fine-grained PAT' },
+  { re: /\bsk-ant-[A-Za-z0-9_-]{24,}\b/, label: 'Anthropic API key' },
+  { re: /\bsk-[A-Za-z0-9]{40,}\b/, label: 'API secret key' },
+  { re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/, label: 'Slack token' },
+  { re: /-----BEGIN (?:RSA |EC |OPENSSH |PGP )?PRIVATE KEY-----/, label: 'private key material' },
+]
+
+/** External ticket ids (Jira/Linear style) — feeds span attribution. */
+const TICKET_REF = /\b[A-Z][A-Z0-9]{1,9}-\d{1,6}\b/g
+/** Common uppercase tokens that match the Jira shape but aren't tickets. */
+const TICKET_REF_STOPLIST = /^(?:UTF|ISO|SHA|MD|RFC|CVE|GPT|HTTP|TLS|X|V)\d*-/
+
+// ─── Would-gate rules (log-only in Phase 1) ──────
+
+interface GateRule {
+  rule: string
+  severity: Tier0Tag['severity']
+  test: (command: string, cwd: string) => boolean
+}
+
+const GATE_RULES: GateRule[] = [
+  {
+    rule: 'would_gate:rm_rf_outside_workspace',
+    severity: 'high',
+    test: (cmd, cwd) => {
+      const m = cmd.match(/\brm\s+(-[a-zA-Z]*[rf][a-zA-Z]*\s+)+(.+)/)
+      if (!m) return false
+      const targets = m[2].split(/\s+/).filter((t) => t && !t.startsWith('-'))
+      return targets.some((t) => {
+        if (t === '/' || t === '/*' || t === '~' || t === '~/') return true
+        if (!path.isAbsolute(t)) return false
+        return !t.startsWith(cwd)
+      })
+    },
+  },
+  {
+    rule: 'would_gate:force_push',
+    severity: 'high',
+    test: (cmd) => /\bgit\s+push\b/.test(cmd) && /\s(?:--force(?!-with-lease)|-f)\b/.test(cmd),
+  },
+  {
+    rule: 'would_gate:chmod_777',
+    severity: 'warn',
+    test: (cmd) => /\bchmod\s+(-[a-zA-Z]+\s+)*0?777\b/.test(cmd),
+  },
+  {
+    rule: 'would_gate:curl_pipe_sh',
+    severity: 'high',
+    test: (cmd) => /\b(?:curl|wget)\b[^|;&]*\|\s*(?:sudo\s+)?(?:ba|z|da)?sh\b/.test(cmd),
+  },
+  {
+    rule: 'would_gate:drop_table',
+    severity: 'high',
+    test: (cmd) => /\bDROP\s+(?:TABLE|DATABASE|SCHEMA)\b/i.test(cmd),
+  },
+  {
+    rule: 'would_gate:env_file_write',
+    severity: 'warn',
+    test: (cmd) => /(?:>>?\s*|tee\s+(?:-a\s+)?)\S*\.env(?:\.\w+)?\b/.test(cmd),
+  },
+  {
+    rule: 'would_gate:tls_verify_off',
+    severity: 'warn',
+    test: (cmd) =>
+      /\bcurl\b[^|;&]*\s(?:-k|--insecure)\b/.test(cmd) ||
+      /NODE_TLS_REJECT_UNAUTHORIZED\s*=\s*0/.test(cmd) ||
+      /\bgit\s+config\b.*http\.sslVerify\s+false/i.test(cmd),
+  },
+]
+
+// ─── Tagger ──────────────────────────────────────
+
+/** Extract external ticket references from text (deduped, stoplisted). */
+export function extractTicketRefs(text: string): string[] {
+  const refs = new Set<string>()
+  for (const m of text.match(TICKET_REF) || []) {
+    if (!TICKET_REF_STOPLIST.test(m)) refs.add(m)
+  }
+  return [...refs]
+}
+
+/** Annotate one normalized event with Tier-0 tags. */
+export function tagEvent(event: LedgerEvent, cwd: string): Tier0Tag[] {
+  const tags: Tier0Tag[] = []
+  const text = event.text || ''
+  const input = event.input || ''
+
+  if (event.type === 'agent_message') {
+    const assumption = text.match(ASSUMPTION_PATTERNS)
+    if (assumption) tags.push({ rule: 'assumption_language', severity: 'info', note: assumption[0] })
+    const testClaim = text.match(TEST_CLAIM_PATTERNS)
+    if (testClaim) tags.push({ rule: 'claim_tests_pass', severity: 'info', note: testClaim[0] })
+    const deployClaim = text.match(DEPLOY_CLAIM_PATTERNS)
+    if (deployClaim) tags.push({ rule: 'claim_deployed', severity: 'info', note: deployClaim[0] })
+  }
+
+  if (event.type === 'user_message' || event.type === 'agent_message') {
+    for (const ref of extractTicketRefs(text)) {
+      tags.push({ rule: 'ticket_ref', severity: 'info', note: ref })
+    }
+  }
+
+  if (event.type === 'tool_use') {
+    if (MANIFEST_FILES.test(input)) {
+      tags.push({ rule: 'manifest_change', severity: 'warn', note: input.match(MANIFEST_FILES)?.[0] })
+    }
+    if (DEP_ADD_COMMANDS.test(input)) {
+      tags.push({ rule: 'dependency_add', severity: 'warn', note: input.slice(0, 160) })
+    }
+    if (TEST_COMMANDS.test(input)) {
+      tags.push({ rule: 'test_command', severity: 'info', note: input.slice(0, 160) })
+    }
+    for (const gate of GATE_RULES) {
+      if (gate.test(input, cwd)) {
+        tags.push({ rule: gate.rule, severity: gate.severity, note: input.slice(0, 160) })
+      }
+    }
+  }
+
+  const secretHaystack = `${text}\n${input}`
+  for (const { re, label } of SECRET_PATTERNS) {
+    if (re.test(secretHaystack)) {
+      tags.push({ rule: 'secret_material', severity: 'high', note: label })
+      break
+    }
+  }
+
+  return tags
+}
+
+// ─── Ground truth: claim vs ledger (spec §4) ─────
+
+export interface ClaimCheckResult {
+  verified: boolean
+  detail: string
+  receipts: string[]
+}
+
+/**
+ * "Tests pass" is decidable from the ledger, not vibes: was a test command
+ * actually run since the last user message, and did its result succeed?
+ * Tuned aggressive — nearly false-positive-free by construction.
+ */
+export function checkTestClaim(recent: LedgerEvent[], claimEventId: string): ClaimCheckResult {
+  let lastUserIdx = -1
+  for (let i = recent.length - 1; i >= 0; i--) {
+    if (recent[i].type === 'user_message') { lastUserIdx = i; break }
+  }
+  const windowEvents = recent.slice(lastUserIdx + 1)
+
+  const testRuns = windowEvents.filter(
+    (e) => e.type === 'tool_use' && (e.tags || []).some((t) => t.rule === 'test_command'),
+  )
+  if (testRuns.length === 0) {
+    return {
+      verified: false,
+      detail: `Agent claimed tests pass at ${claimEventId}; no test command in the ledger since the last human message.`,
+      receipts: [claimEventId],
+    }
+  }
+
+  const lastRun = testRuns[testRuns.length - 1]
+  const result = windowEvents.find((e) => e.type === 'tool_result' && e.toolUseId && e.toolUseId === lastRun.toolUseId)
+  if (result?.isError) {
+    return {
+      verified: false,
+      detail: `Agent claimed tests pass at ${claimEventId}; most recent test run ${lastRun.id} failed (${result.id}).`,
+      receipts: [claimEventId, lastRun.id, result.id],
+    }
+  }
+  return { verified: true, detail: '', receipts: [claimEventId, lastRun.id] }
+}