@adhdev/daemon-core 0.9.82-rc.15 → 0.9.82-rc.151

package/src/providers/sdk/v1/builders/cli/parse-approval-squash.ts

@@ -0,0 +1,158 @@
+/**
+ * buildParseApprovalFromSquash
+ *
+ * Companion to buildParseApprovalFromTui. Handles the squashed-modal case:
+ * the terminal has re-flowed the approval frame so the rendered text is a
+ * single run of lowercase-alnum bytes (e.g. `doyoutrustthecontentsofthisdirectory…1yescontinue2noquit`).
+ *
+ * Author declares:
+ *   - `cues`        — compact substrings/regexes that identify the modal
+ *   - `footers`     — optional compact substrings that must also be present
+ *   - `buttonRules` — compact→labels mappings used to recover button labels
+ *
+ * Returns the same shape as buildParseApprovalFromTui — a CliApprovalModal
+ * (message + buttons) or null when no rule matches. Caller composes the two
+ * builders: try the regular modal first, then fall back to squash. Codex
+ * needs both because at narrow widths the terminal renders the squash form,
+ * and at wider widths it renders the regular framed form.
+ */
+
+import type {
+  CliApprovalInput,
+  CliApprovalModal,
+  CliParseApprovalFn,
+} from '../../types/cli/index.js';
+
+// ─── Spec mirrors the JSON schema ─────────────────────────────────────
+
+interface SquashCueSpec {
+  compact: string;
+  kind?: 'substring' | 'regex';
+  label?: string;
+  messageWhenMatched?: string;
+}
+
+interface SquashFooterSpec {
+  compact: string;
+  kind?: 'substring' | 'regex';
+}
+
+interface SquashButtonRuleSpec {
+  compact: string;
+  kind?: 'substring' | 'regex';
+  labels: string[];
+}
+
+export interface ApprovalSquashSpec {
+  $schema: 'adhdev:tui/approval-squash@1';
+  cues: SquashCueSpec[];
+  footers?: SquashFooterSpec[];
+  buttonRules: SquashButtonRuleSpec[];
+  scope?: 'tail-window' | 'whole-screen';
+  tailWindowLines?: number;
+}
+
+// ─── Internals ────────────────────────────────────────────────────────
+
+const COMPACT_RE = /[^a-z0-9]+/g;
+
+/**
+ * The canonical normalisation. Identical to codex-cli's `compactText`:
+ * lowercase, then strip everything that is not a-z or 0-9.
+ *
+ * Exported for tests and for the (rare) provider that wants to compose this
+ * with extra normalisation steps.
+ */
+export function compactText(value: string): string {
+  return String(value || '').toLowerCase().replace(COMPACT_RE, '');
+}
+
+function compileRegex(source: string, flags = 'i'): RegExp {
+  try { return new RegExp(source, flags); }
+  catch (e) { throw new Error(`Invalid regex /${source}/${flags}: ${(e as Error).message}`); }
+}
+
+function matchSubstringOrRegex(
+  needle: string,
+  kind: 'substring' | 'regex' | undefined,
+  haystack: string,
+): boolean {
+  if (kind === 'regex') return compileRegex(needle).test(haystack);
+  return haystack.includes(needle);
+}
+
+function scopeText(spec: ApprovalSquashSpec, input: CliApprovalInput): string {
+  const scope = spec.scope ?? 'tail-window';
+  const candidates = [
+    String(input.screenText || ''),
+    String(input.rawBuffer || ''),
+    String(input.buffer || ''),
+    String(input.tail || ''),
+  ].filter(Boolean);
+  const joined = candidates.join('\n');
+  if (scope === 'whole-screen') return joined;
+  const tailLines = spec.tailWindowLines ?? 24;
+  return joined.split('\n').slice(-tailLines).join('\n');
+}
+
+// ─── Public builder ───────────────────────────────────────────────────
+
+export function buildParseApprovalFromSquash(spec: ApprovalSquashSpec): CliParseApprovalFn {
+  if (!Array.isArray(spec.cues) || spec.cues.length === 0) {
+    throw new Error('approval-squash spec must declare at least one cue.');
+  }
+  if (!Array.isArray(spec.buttonRules) || spec.buttonRules.length === 0) {
+    throw new Error('approval-squash spec must declare at least one button rule.');
+  }
+
+  return function parseApproval(input: CliApprovalInput): CliApprovalModal | null {
+    const text = scopeText(spec, input);
+    if (!text) return null;
+    const compact = compactText(text);
+    if (!compact) return null;
+
+    // 1) Find the first matching cue. Its messageWhenMatched (if present) is
+    //    the human-readable modal message; otherwise we fall back to a label
+    //    or empty string.
+    let matchedCue: SquashCueSpec | null = null;
+    for (const cue of spec.cues) {
+      if (matchSubstringOrRegex(cue.compact, cue.kind, compact)) {
+        matchedCue = cue;
+        break;
+      }
+    }
+    if (!matchedCue) return null;
+
+    // 2) If footers are declared, at least one must also match.
+    if (spec.footers && spec.footers.length > 0) {
+      const anyFooter = spec.footers.some((f) =>
+        matchSubstringOrRegex(f.compact, f.kind, compact),
+      );
+      if (!anyFooter) return null;
+    }
+
+    // 3) Find a button rule whose compact pattern is present in the compacted
+    //    text. First match wins.
+    let labels: string[] | null = null;
+    for (const rule of spec.buttonRules) {
+      if (matchSubstringOrRegex(rule.compact, rule.kind, compact)) {
+        labels = rule.labels;
+        break;
+      }
+    }
+    if (!labels || labels.length === 0) return null;
+
+    const message = matchedCue.messageWhenMatched
+      || matchedCue.label
+      || '';
+
+    return { message, buttons: [...labels] };
+  };
+}
+
+// Internal exports for tests.
+export const __internal = {
+  compactText,
+  matchSubstringOrRegex,
+  scopeText,
+};

package/src/providers/sdk/v1/builders/cli/parse-approval.ts

@@ -0,0 +1,245 @@
+/**
+ * buildParseApprovalFromTui
+ *
+ * Turns a `tui/modal@1` block into a runtime
+ * `(input: CliApprovalInput) => CliApprovalModal | null` function.
+ *
+ * Contract rules enforced (sprint-2026-06):
+ *   - Returns null when the question pattern is not visible.
+ *   - Returns null when the button list is empty or shorter than minButtons.
+ *   - Button labels are raw text; never rewritten (e.g. "Yes, and don't ask
+ *     again for X" stays verbatim).
+ *   - Modal scope respects between-last-two-separators / window-around-question
+ *     / whole-screen to avoid false-positives from numbered lists in
+ *     assistant prose.
+ */
+
+import type {
+  CliApprovalInput,
+  CliApprovalModal,
+  CliParseApprovalFn,
+} from '../../types/cli/index.js';
+import {
+  applyVisibleRegion,
+  type VisibleRegionSpec,
+} from './visible-region.js';
+
+// ─── Spec shapes ───────────────────────────────────────────────────────
+
+interface ModalQuestionVariant {
+  regex: string;
+  flags?: string;
+  label?: string;
+}
+
+interface ModalContextHeader {
+  regex: string;
+  flags?: string;
+}
+
+export interface ModalTuiSpec {
+  $schema: 'adhdev:tui/modal@1';
+  questionPattern: string;
+  questionFlags?: string;
+  questionVariants?: ModalQuestionVariant[];
+  buttonPattern: string;
+  buttonFlags?: string;
+  /**
+   * Optional fallback for terminals that render all options on a single line
+   * (e.g. Antigravity feedback survey: `[0] skip [1] yes [2] no [3] still using`).
+   * When per-line button extraction collects fewer than `minButtons`, the
+   * builder makes a second pass with this regex (global match, capture group 1
+   * is the label).
+   */
+  inlineButtonPattern?: string;
+  inlineButtonFlags?: string;
+  scope?: 'between-last-two-separators' | 'window-around-question' | 'whole-screen';
+  scopeWindowLines?: number;
+  contextHeader?: ModalContextHeader;
+  continuationLines?: boolean;
+  minButtons?: number;
+}
+
+// ─── Helpers ───────────────────────────────────────────────────────────
+
+const SEPARATOR_RE = /^(?:─|━|═|━){10,}\s*$/;
+
+function compile(re: string, flags?: string): RegExp {
+  try {
+    return new RegExp(re, flags);
+  } catch (e) {
+    throw new Error(`Invalid regex /${re}/${flags ?? ''}: ${(e as Error).message}`);
+  }
+}
+
+function findQuestionLineIndex(
+  spec: ModalTuiSpec,
+  lines: string[],
+): { index: number; matchedSource: 'primary' | string } | null {
+  const primary = compile(spec.questionPattern, spec.questionFlags ?? 'i');
+  // Search bottom-up to prefer the most recent modal.
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (primary.test(lines[i])) return { index: i, matchedSource: 'primary' };
+  }
+  for (const variant of spec.questionVariants ?? []) {
+    const re = compile(variant.regex, variant.flags ?? 'i');
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      if (re.test(lines[i])) return { index: i, matchedSource: variant.label ?? 'variant' };
+    }
+  }
+  return null;
+}
+
+function scopeLines(
+  spec: ModalTuiSpec,
+  lines: string[],
+  questionIndex: number,
+): { start: number; end: number } {
+  const scope = spec.scope ?? 'between-last-two-separators';
+  if (scope === 'whole-screen') {
+    return { start: 0, end: lines.length };
+  }
+  if (scope === 'window-around-question') {
+    const window = spec.scopeWindowLines ?? 16;
+    return {
+      start: Math.max(0, questionIndex - 2),
+      end: Math.min(lines.length, questionIndex + window),
+    };
+  }
+  // between-last-two-separators
+  let lastSep = -1;
+  let prevSep = -1;
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (SEPARATOR_RE.test(lines[i].trim())) {
+      if (lastSep < 0) lastSep = i;
+      else if (prevSep < 0) {
+        prevSep = i;
+        break;
+      }
+    }
+  }
+  if (lastSep >= 0 && prevSep >= 0) {
+    return { start: prevSep, end: lastSep + 1 };
+  }
+  // Fallback: window around question line.
+  return {
+    start: Math.max(0, questionIndex - 4),
+    end: Math.min(lines.length, questionIndex + 16),
+  };
+}
+
+function extractButtons(
+  spec: ModalTuiSpec,
+  lines: string[],
+  windowStart: number,
+  windowEnd: number,
+): string[] {
+  const buttonRe = compile(spec.buttonPattern, spec.buttonFlags ?? 'm');
+  const out: string[] = [];
+  let i = windowStart;
+  while (i < windowEnd) {
+    const line = lines[i];
+    const m = buttonRe.exec(line);
+    if (m && m[1]) {
+      let label = m[1].trim();
+      // Continuation lines: when enabled, append indented lines below until
+      // the next button or blank.
+      if (spec.continuationLines) {
+        let j = i + 1;
+        while (j < windowEnd) {
+          const next = lines[j];
+          if (!next.trim()) break;
+          if (buttonRe.test(next)) break;
+          // continuation must be indented (not at column 0 like a new section).
+          if (!/^\s+/.test(next)) break;
+          label += ' ' + next.trim();
+          j += 1;
+        }
+        i = j;
+      } else {
+        i += 1;
+      }
+      out.push(label);
+    } else {
+      i += 1;
+    }
+  }
+  return out;
+}
+
+function buildMessage(
+  spec: ModalTuiSpec,
+  lines: string[],
+  questionIndex: number,
+  windowStart: number,
+  windowEnd: number,
+): string {
+  const messageParts: string[] = [];
+  if (spec.contextHeader) {
+    const ctxRe = compile(spec.contextHeader.regex, (spec.contextHeader.flags ?? 'i') + 'm');
+    const haystack = lines.slice(windowStart, windowEnd).join('\n');
+    const m = ctxRe.exec(haystack);
+    if (m) messageParts.push(m[1] ? m[1].trim() : m[0].trim());
+  }
+  messageParts.push(lines[questionIndex].trim());
+  return messageParts.filter(Boolean).join(' — ');
+}
+
+// ─── Public builder ────────────────────────────────────────────────────
+
+function extractInlineButtons(
+  spec: ModalTuiSpec,
+  lines: string[],
+  windowStart: number,
+  windowEnd: number,
+): string[] {
+  if (!spec.inlineButtonPattern) return [];
+  // Always force the `g` flag so we can iterate all matches in the line.
+  const declaredFlags = spec.inlineButtonFlags ?? 'gi';
+  const flags = declaredFlags.includes('g') ? declaredFlags : declaredFlags + 'g';
+  const re = compile(spec.inlineButtonPattern, flags);
+  const out: string[] = [];
+  for (let i = windowStart; i < windowEnd; i += 1) {
+    let m: RegExpExecArray | null;
+    re.lastIndex = 0;
+    while ((m = re.exec(lines[i])) !== null) {
+      const label = (m[1] ?? m[0]).trim();
+      if (label && !out.includes(label)) out.push(label);
+      if (m.index === re.lastIndex) re.lastIndex += 1; // safety against zero-width matches
+    }
+  }
+  return out;
+}
+
+export function buildParseApprovalFromTui(
+  spec: ModalTuiSpec,
+  visibleRegion?: VisibleRegionSpec,
+): CliParseApprovalFn {
+  const minButtons = spec.minButtons ?? 2;
+
+  return function parseApproval(input: CliApprovalInput): CliApprovalModal | null {
+    const rawText = input.screenText ?? input.buffer ?? '';
+    if (!rawText) return null;
+    const text = visibleRegion ? applyVisibleRegion(visibleRegion, rawText) : rawText;
+    const lines = text.split('\n');
+    const question = findQuestionLineIndex(spec, lines);
+    if (!question) return null;
+    const { start, end } = scopeLines(spec, lines, question.index);
+    if (question.index < start || question.index >= end) return null;
+    let buttons = extractButtons(spec, lines, question.index + 1, end);
+    // Inline fallback: when per-line extraction came up short, the terminal
+    // may have rendered every option on the same line ("[0] skip [1] yes …").
+    if (buttons.length < minButtons && spec.inlineButtonPattern) {
+      buttons = extractInlineButtons(spec, lines, question.index, end);
+    }
+    if (buttons.length < minButtons) return null;
+    const message = buildMessage(spec, lines, question.index, start, end);
+    return { message, buttons };
+  };
+}
+
+export const __internal = {
+  findQuestionLineIndex,
+  scopeLines,
+  extractButtons,
+};

package/src/providers/sdk/v1/builders/cli/parse-session.ts

@@ -0,0 +1,276 @@
+/**
+ * buildParseSessionFromTui — synthesize a parseSession function from the
+ * manifest tui block alone.
+ *
+ * Composition:
+ *   1. detectStatus from tui.spinner/modal/settledPrompt/dispatchOrder
+ *      (delegated to buildDetectStatusFromTui)
+ *   2. parseApproval from tui.modal (delegated to buildParseApprovalFromTui)
+ *   3. message extraction from tui.transcriptPty (this file)
+ *
+ * The result has the same shape as the legacy parse_output:
+ *   { status, messages, activeModal, transcriptAuthority?, coverage?, providerSessionId? }
+ *
+ * Identity stamping (providerUnitKey, bubbleId, sequence, bubbleState) is
+ * applied by the caller, mirroring _shared/parse_session.js. We export the
+ * stamper as `normalizeMessageIdentity` for reuse.
+ */
+
+import { buildDetectStatusFromTui, type DetectStatusTuiSpec } from './detect-status.js'
+import { buildParseApprovalFromTui, type ModalTuiSpec } from './parse-approval.js'
+import * as crypto from 'node:crypto'
+
+// ─── Schema types ────────────────────────────────
+
+export interface PrefixSpec {
+    regex: string
+    flags?: string
+}
+
+export interface ToolPrefixSpec extends PrefixSpec {
+    skip?: boolean
+}
+
+export interface ChromePatternSpec {
+    regex: string
+    flags?: string
+    label?: string
+}
+
+export interface TranscriptPtySpec {
+    $schema?: 'adhdev:tui/transcript-pty@1'
+    assistantPrefix: PrefixSpec
+    userPrefix?: PrefixSpec
+    toolPrefix?: ToolPrefixSpec
+    continuationLine?: { indented?: boolean }
+    chromePatterns?: ChromePatternSpec[]
+    stripLeadingChrome?: boolean
+    scope?: 'screen' | 'buffer' | 'tail'
+}
+
+export interface SessionIdExtractionSpec {
+    $schema?: 'adhdev:tui/session-id-extraction@1'
+    regex: string
+    flags?: string
+    scope?: 'screen' | 'tail' | 'buffer'
+    label?: string
+}
+
+export interface ParseSessionTuiSpec {
+    spinner?: any
+    settledPrompt?: any
+    modal?: ModalTuiSpec
+    dispatchOrder?: any
+    transcriptPty: TranscriptPtySpec
+    sessionIdExtraction?: SessionIdExtractionSpec
+}
+
+// ─── Output shape ────────────────────────────────
+
+export interface SynthesizedMessage {
+    role: 'user' | 'assistant'
+    kind?: 'standard' | 'tool'
+    content: string
+    receivedAt?: number
+}
+
+export interface SynthesizedSession {
+    status: string | null
+    messages: SynthesizedMessage[]
+    activeModal: { message: string; buttons: string[] } | null
+    modal: { message: string; buttons: string[] } | null
+    parsedStatus: string | null
+    transcriptAuthority?: 'provider' | 'daemon'
+    coverage?: 'full' | 'tail' | 'current-turn'
+    providerSessionId?: string
+}
+
+// ─── ANSI / line helpers ─────────────────────────
+
+const ANSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]/g
+const OSC_RE = /\x1b\][^\x07\x1b\n]*(?:\x07|\x1b\\|(?=\n|$))/g
+
+function stripAnsi(text: string): string {
+    return String(text || '')
+        .replace(/\x1b\[(\d*)C/g, (_m, n) => ' '.repeat(Math.max(1, Number(n) || 1)))
+        .replace(/\x1b\[\d*D/g, '')
+        .replace(ANSI_RE, '')
+        .replace(OSC_RE, '')
+        .replace(/\x1b[P^_X][\s\S]*?(?:\x07|\x1b\\)/g, '')
+        .replace(/\x1b(?:[@-Z\\-_])/g, '')
+}
+
+function splitLines(text: string): string[] {
+    return stripAnsi(text)
+        .replace(//g, '')
+        .split(/\r?\n/)
+        .map(l => l.replace(/\s+$/, ''))
+}
+
+function pickInputText(input: any, scope: TranscriptPtySpec['scope']): string {
+    if (!input) return ''
+    if (scope === 'screen') return String(input.screenText || input.screen?.text || '')
+    if (scope === 'tail') return String(input.tail || input.recentBuffer || input.buffer || '')
+    return String(input.buffer || input.rawBuffer || input.screenText || '')
+}
+
+// ─── Identity stamping (mirrors _shared/parse_session.js) ─────
+
+function stableHash(value: string): string {
+    return crypto.createHash('sha1').update(String(value || '')).digest('hex').slice(0, 12)
+}
+
+export function normalizeMessageIdentity<T extends { role?: string; kind?: string; content?: string }>(
+    messages: T[],
+    status: string,
+): Array<T & {
+    providerUnitKey: string
+    bubbleId: string
+    sequence: number
+    _turnKey: string
+    bubbleState: 'streaming' | 'final'
+}> {
+    const list = Array.isArray(messages) ? messages : []
+    let turnIndex = -1
+    return list.map((message, index) => {
+        const role = message?.role || 'assistant'
+        const kind = message?.kind || 'standard'
+        const content = typeof message?.content === 'string' ? message.content : ''
+        if (role === 'user' || turnIndex < 0) turnIndex += 1
+        const seed = [role, kind, '', index, content].join('\n')
+        const providerUnitKey = `v2-pty:${role}:${kind}:${index}:${stableHash(seed)}`
+        const bubbleId = `bubble:${providerUnitKey}`
+        const turnKey = `turn:${turnIndex}`
+        const isStreamingTail = status === 'generating' && role === 'assistant' && index === list.length - 1
+        return {
+            ...message,
+            providerUnitKey,
+            bubbleId,
+            sequence: index,
+            _turnKey: turnKey,
+            bubbleState: isStreamingTail ? 'streaming' as const : 'final' as const,
+        }
+    })
+}
+
+// ─── Main builder ────────────────────────────────
+
+export function buildParseSessionFromTui(spec: ParseSessionTuiSpec): (input: any) => SynthesizedSession {
+    if (!spec.transcriptPty) {
+        throw new Error('buildParseSessionFromTui: spec.transcriptPty is required')
+    }
+
+    // Compile regexes once
+    const assistantRe = new RegExp(spec.transcriptPty.assistantPrefix.regex, spec.transcriptPty.assistantPrefix.flags || '')
+    const userRe = spec.transcriptPty.userPrefix
+        ? new RegExp(spec.transcriptPty.userPrefix.regex, spec.transcriptPty.userPrefix.flags || '')
+        : null
+    const toolRe = spec.transcriptPty.toolPrefix
+        ? new RegExp(spec.transcriptPty.toolPrefix.regex, spec.transcriptPty.toolPrefix.flags || '')
+        : null
+    const toolSkip = spec.transcriptPty.toolPrefix?.skip ?? false
+    const chromeRes = (spec.transcriptPty.chromePatterns || []).map(p =>
+        new RegExp(p.regex, p.flags || ''))
+    const requireIndentForContinuation = spec.transcriptPty.continuationLine?.indented ?? false
+    const stripLeadingChrome = spec.transcriptPty.stripLeadingChrome ?? true
+    const scope = spec.transcriptPty.scope ?? 'buffer'
+
+    // Compose detect + approval helpers if their inputs are present.
+    const detectStatus = (spec.spinner || spec.settledPrompt || spec.modal || spec.dispatchOrder)
+        ? buildDetectStatusFromTui({
+            spinner: spec.spinner,
+            settledPrompt: spec.settledPrompt,
+            modal: spec.modal,
+            dispatchOrder: spec.dispatchOrder,
+        })
+        : () => null
+    const parseApproval = spec.modal ? buildParseApprovalFromTui(spec.modal) : () => null
+
+    // Optional session-id extraction (tui/session-id-extraction@1). Compile once
+    // so each parseSession call is a single regex.exec on the chosen scope.
+    const sessionIdRe = spec.sessionIdExtraction
+        ? new RegExp(
+            spec.sessionIdExtraction.regex,
+            spec.sessionIdExtraction.flags ?? 'i',
+        )
+        : null
+    const sessionIdScope: TranscriptPtySpec['scope'] = spec.sessionIdExtraction?.scope ?? 'tail'
+
+    return function parseSession(input: any): SynthesizedSession {
+        // status + modal first
+        const status = detectStatus(input as any) ?? 'idle'
+        const modal = parseApproval(input as any)
+
+        const text = pickInputText(input, scope)
+        const lines = splitLines(text)
+
+        const messages: SynthesizedMessage[] = []
+        let seenFirstRoleLine = !stripLeadingChrome
+
+        for (const raw of lines) {
+            const line = raw
+            if (line.trim() === '') {
+                // Blank line: ends streaming continuation but doesn't add a message.
+                continue
+            }
+
+            // Chrome filter
+            let isChrome = false
+            for (const cre of chromeRes) {
+                if (cre.test(line)) { isChrome = true; break }
+            }
+            if (isChrome) continue
+
+            // Role detection
+            const userMatch = userRe ? line.match(userRe) : null
+            const toolMatch = toolRe ? line.match(toolRe) : null
+            const assistMatch = line.match(assistantRe)
+
+            if (userMatch) {
+                seenFirstRoleLine = true
+                const content = (userMatch[1] ?? userMatch[0]).trim()
+                if (content) messages.push({ role: 'user', kind: 'standard', content })
+                continue
+            }
+            if (toolMatch) {
+                seenFirstRoleLine = true
+                if (toolSkip) continue
+                const content = (toolMatch[1] ?? toolMatch[0]).trim()
+                if (content) messages.push({ role: 'assistant', kind: 'tool', content })
+                continue
+            }
+            if (assistMatch) {
+                seenFirstRoleLine = true
+                const content = (assistMatch[1] ?? assistMatch[0]).trim()
+                if (content) messages.push({ role: 'assistant', kind: 'standard', content })
+                continue
+            }
+
+            if (!seenFirstRoleLine) continue
+
+            // Continuation rule
+            if (requireIndentForContinuation && !/^\s/.test(line)) continue
+            const last = messages[messages.length - 1]
+            if (!last) continue
+            const cont = line.replace(/^\s+/, '')
+            if (cont) last.content = last.content ? `${last.content}\n${cont}` : cont
+        }
+
+        const result: SynthesizedSession = {
+            status,
+            messages,
+            activeModal: modal,
+            modal,
+            parsedStatus: status,
+        }
+
+        if (sessionIdRe) {
+            const haystack = stripAnsi(pickInputText(input, sessionIdScope))
+            const match = haystack.match(sessionIdRe)
+            const captured = match?.[1]?.trim()
+            if (captured) result.providerSessionId = captured
+        }
+
+        return result
+    }
+}