@promus/cli 0.24.17

package/src/ui/approval-summary.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, it } from 'bun:test'
+import { summarizeApprovalSubject } from './approval-summary'
+
+describe('summarizeApprovalSubject', () => {
+  it('renders chain.send native with amount + recipient', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'chain.send',
+        amount: '0.001',
+        recipient: '0xC635e6Eb223aE14143E23cEEa9440bC773dc87Ec',
+        token: '0G',
+        reason: 'native/ERC-20 transfer',
+      }),
+    ).toBe('send 0.001 0G to 0xC635…87Ec')
+  })
+
+  it('renders chain.send ERC-20 with explicit token symbol', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'chain.send',
+        amount: '0.5',
+        recipient: '0xC635e6Eb223aE14143E23cEEa9440bC773dc87Ec',
+        token: 'USDCe',
+        reason: 'native/ERC-20 transfer',
+      }),
+    ).toBe('send 0.5 USDCe to 0xC635…87Ec')
+  })
+
+  it('renders chain.wrap as the arrow form (no recipient noise)', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'chain.send',
+        amount: '0.01',
+        token: '0G→W0G',
+        reason: 'wrap native to W0G',
+      }),
+    ).toBe('0.01 0G→W0G')
+  })
+
+  it('renders chain.unwrap', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'chain.send',
+        amount: '0.01',
+        token: 'W0G→0G',
+        reason: 'unwrap W0G to native',
+      }),
+    ).toBe('0.01 W0G→0G')
+  })
+
+  it('renders chain.swap with token-pair encoding', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'chain.swap',
+        amount: '0.005',
+        token: '0G→USDCe',
+        reason: 'JAINE swap execution',
+      }),
+    ).toBe('swap 0.005 0G→USDCe')
+  })
+
+  it('renders chain.swap with empty amt + tok', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'chain.swap',
+        reason: 'JAINE swap execution',
+      }),
+    ).toBe('swap')
+  })
+
+  it('renders stake.stake', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'chain.stake',
+        amount: '0.02',
+        token: '0G→stOG',
+        reason: 'Gimo stake',
+      }),
+    ).toBe('0.02 0G→stOG')
+  })
+
+  it('renders stake.unstake', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'chain.stake',
+        amount: '0.01',
+        token: 'stOG→0G (queued)',
+        reason: 'Gimo unstake',
+      }),
+    ).toBe('0.01 stOG→0G (queued)')
+  })
+
+  it('renders stake.claim with no amount', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'chain.stake',
+        token: 'claim queued 0G',
+        reason: 'Gimo claim',
+      }),
+    ).toBe('claim queued 0G')
+  })
+
+  it('renders chain.write with signature + recipient + value', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'chain.write',
+        recipient: '0x9e71d79f06f956d4d2666b5c93dafab721c84721',
+        command: 'transfer(address,uint256)',
+        amount: '1 wei',
+        reason: 'arbitrary state-changing call',
+      }),
+    ).toBe('transfer(address,uint256) (value: 1 wei) on 0x9e71…4721')
+  })
+
+  it('renders chain.write with no value', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'chain.write',
+        recipient: '0x9e71d79f06f956d4d2666b5c93dafab721c84721',
+        command: 'totalSupply()',
+        reason: 'arbitrary state-changing call',
+      }),
+    ).toBe('totalSupply() on 0x9e71…4721')
+  })
+
+  it('falls back to command for shell.run', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'shell.run',
+        command: 'rm -rf /tmp/foo',
+        reason: 'shell command execution',
+      }),
+    ).toBe('rm -rf /tmp/foo')
+  })
+
+  it('falls back to path for fs.write', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'fs.write',
+        path: '/tmp/x.txt',
+        reason: 'fs.write request',
+      }),
+    ).toBe('/tmp/x.txt')
+  })
+
+  it('falls back to (unspecified) when nothing usable', () => {
+    expect(
+      summarizeApprovalSubject({
+        kind: 'fs.patch',
+        reason: 'fs.patch request',
+      }),
+    ).toBe('(unspecified)')
+  })
+})

package/src/ui/approval-summary.ts

@@ -0,0 +1,34 @@
+import type { PermissionRequest } from '@promus/core'
+import { shortAddr } from '../util/format'
+
+/**
+ * Body line for the approval modal. Friendly text for value-moving onchain
+ * kinds; falls back to command/path for shell.run / fs.write / code.execute.
+ *
+ * Why the `'→'` sniff in chain.send: chain.wrap and chain.unwrap reuse
+ * `chain.send` as their permission kind but encode the operation in `token`
+ * (`0G→W0G` / `W0G→0G`) and have no recipient to display.
+ */
+export function summarizeApprovalSubject(req: PermissionRequest): string {
+  const amt = req.amount ?? ''
+  const tok = req.token ?? ''
+  switch (req.kind) {
+    case 'chain.send': {
+      if (tok.includes('→')) return `${amt} ${tok}`.trim()
+      const tokenLabel = tok || '0G'
+      return `send ${amt} ${tokenLabel} to ${shortAddr(req.recipient)}`
+    }
+    case 'chain.swap':
+      if (!amt && !tok) return 'swap'
+      return `swap ${amt} ${tok}`.trim()
+    case 'chain.stake':
+      if (!amt) return tok || 'stake operation'
+      return `${amt} ${tok}`.trim()
+    case 'chain.write': {
+      const valuePart = amt ? ` (value: ${amt})` : ''
+      return `${req.command ?? '?'}${valuePart} on ${shortAddr(req.recipient)}`
+    }
+    default:
+      return req.command ?? req.path ?? '(unspecified)'
+  }
+}

package/src/ui/markdown-parse.ts

@@ -0,0 +1,219 @@
+/**
+ * Lightweight markdown parser for the assistant chat rows. Pure logic only,
+ * no JSX, so tests can import without dragging in the JSX runtime (CI's bun
+ * defaults to react-jsx and fails to resolve `react/jsx-dev-runtime` when
+ * a .tsx file is imported by a test).
+ *
+ * Subset the brain actually emits: `**bold**`, `*italic*`, `` `code` ``,
+ * `# headings`, `- bullet lists`, `1. numbered lists`, fenced code blocks,
+ * GFM tables (`| col | col |` + `|---|---|` separator).
+ */
+
+export interface MdSegment {
+  text: string
+  fg?: string
+  bold?: boolean
+  italic?: boolean
+}
+
+export const MD_COLORS = {
+  text: '#e5e7eb',
+  code: '#fda4af',
+  heading: '#fbbf24',
+  bullet: '#94a3b8',
+  codeBlock: '#f9a8d4',
+  tableBorder: '#6b7280',
+  tableHeader: '#fbbf24',
+}
+
+/**
+ * Parse a single line's inline markup (`**bold**`, `*italic*`, `` `code` ``)
+ * into a flat list of segments. Caller handles the line-level structure.
+ */
+function parseInline(line: string, baseFg: string = MD_COLORS.text): MdSegment[] {
+  const out: MdSegment[] = []
+  let i = 0
+  let plain = ''
+  const flushPlain = () => {
+    if (plain) {
+      out.push({ text: plain, fg: baseFg })
+      plain = ''
+    }
+  }
+  while (i < line.length) {
+    if (line[i] === '`') {
+      const end = line.indexOf('`', i + 1)
+      if (end > i) {
+        flushPlain()
+        out.push({ text: line.slice(i + 1, end), fg: MD_COLORS.code })
+        i = end + 1
+        continue
+      }
+    }
+    if (line[i] === '*' && line[i + 1] === '*') {
+      const end = line.indexOf('**', i + 2)
+      if (end > i + 2) {
+        flushPlain()
+        out.push({ text: line.slice(i + 2, end), fg: baseFg, bold: true })
+        i = end + 2
+        continue
+      }
+    }
+    if (line[i] === '*' && line[i + 1] !== '*' && line[i + 1] !== ' ') {
+      const end = line.indexOf('*', i + 1)
+      if (end > i + 1 && line[end - 1] !== ' ' && line[end + 1] !== '*') {
+        flushPlain()
+        out.push({ text: line.slice(i + 1, end), fg: baseFg, italic: true })
+        i = end + 1
+        continue
+      }
+    }
+    plain += line[i]
+    i++
+  }
+  flushPlain()
+  return out
+}
+
+// GFM table separator row: `|---|---|` (optionally with alignment colons).
+// Allows single-column tables (`|---|`), multi-column (`|---|---|`), and
+// missing leading/trailing pipes (`---|---`).
+const TABLE_SEPARATOR_RE = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?\s*$/
+
+function parseTableRow(line: string): string[] {
+  const trimmed = line.trim().replace(/^\|/, '').replace(/\|$/, '')
+  return trimmed.split('|').map(c => c.trim())
+}
+
+/**
+ * Detect a GFM table starting at `lines[startIdx]`. Returns the parsed rows
+ * (header included as row 0) plus the index AFTER the last data row, or null
+ * if no table block matches.
+ */
+function detectTable(lines: string[], startIdx: number): { rows: string[][]; end: number } | null {
+  const header = lines[startIdx]
+  if (header === undefined) return null
+  if (!/^\s*\|.+\|?\s*$/.test(header)) return null
+  const sep = lines[startIdx + 1]
+  if (!sep || !TABLE_SEPARATOR_RE.test(sep)) return null
+
+  const rows: string[][] = [parseTableRow(header)]
+  let i = startIdx + 2
+  while (i < lines.length) {
+    const ln = lines[i]
+    if (ln === undefined || !/^\s*\|.+\|?\s*$/.test(ln)) break
+    rows.push(parseTableRow(ln))
+    i++
+  }
+  return { rows, end: i }
+}
+
+/**
+ * Render a parsed table as flat segments. Uses box-drawing characters for the
+ * separator under the header row; columns are padded to the widest cell. First
+ * row is rendered bold + heading color so it stands out.
+ */
+function renderTable(rows: string[][], out: MdSegment[], pushNewline: () => void): void {
+  if (rows.length === 0) return
+  const colCount = Math.max(...rows.map(r => r.length))
+  const widths = new Array(colCount).fill(0) as number[]
+  for (const row of rows) {
+    for (let c = 0; c < row.length; c++) {
+      widths[c] = Math.max(widths[c]!, row[c]!.length)
+    }
+  }
+  for (let r = 0; r < rows.length; r++) {
+    pushNewline()
+    const row = rows[r]!
+    const cells: string[] = []
+    for (let c = 0; c < colCount; c++) {
+      const cell = (row[c] ?? '').padEnd(widths[c]!, ' ')
+      cells.push(cell)
+    }
+    const lineText = `│ ${cells.join(' │ ')} │`
+    out.push({
+      text: lineText,
+      fg: r === 0 ? MD_COLORS.tableHeader : MD_COLORS.text,
+      bold: r === 0,
+    })
+    if (r === 0) {
+      pushNewline()
+      const sep = `├${widths.map(w => '─'.repeat(w + 2)).join('┼')}┤`
+      out.push({ text: sep, fg: MD_COLORS.tableBorder })
+    }
+  }
+}
+
+/**
+ * Parse the full text into a flat list of segments separated by newlines.
+ * Block-level structure is encoded as styled prefixes in the segments
+ * (heading -> bold colored line; bullet -> "• " + content; table -> aligned
+ * cells with box-drawing separator).
+ */
+export function parseMarkdown(text: string): MdSegment[] {
+  if (!text) return []
+  const out: MdSegment[] = []
+  const lines = text.split('\n')
+  let inFence = false
+  let firstLine = true
+
+  const pushNewline = () => {
+    if (!firstLine) out.push({ text: '\n', fg: MD_COLORS.text })
+    firstLine = false
+  }
+
+  let i = 0
+  while (i < lines.length) {
+    const rawLine = lines[i]!
+    if (rawLine.trim().startsWith('```')) {
+      inFence = !inFence
+      i++
+      continue
+    }
+    if (inFence) {
+      pushNewline()
+      out.push({ text: rawLine, fg: MD_COLORS.codeBlock })
+      i++
+      continue
+    }
+    const headingMatch = rawLine.match(/^(#{1,6})\s+(.*)$/)
+    if (headingMatch) {
+      pushNewline()
+      const inner = parseInline(headingMatch[2]!, MD_COLORS.heading)
+      for (const seg of inner) {
+        out.push({ ...seg, fg: seg.fg ?? MD_COLORS.heading, bold: true })
+      }
+      i++
+      continue
+    }
+    const table = detectTable(lines, i)
+    if (table) {
+      renderTable(table.rows, out, pushNewline)
+      i = table.end
+      continue
+    }
+    const bulletMatch = rawLine.match(/^(\s*)([-*])\s+(.*)$/)
+    if (bulletMatch) {
+      pushNewline()
+      out.push({ text: `${bulletMatch[1]}• `, fg: MD_COLORS.bullet })
+      out.push(...parseInline(bulletMatch[3]!))
+      i++
+      continue
+    }
+    const numberedMatch = rawLine.match(/^(\s*)(\d+)\.\s+(.*)$/)
+    if (numberedMatch) {
+      pushNewline()
+      out.push({
+        text: `${numberedMatch[1]}${numberedMatch[2]}. `,
+        fg: MD_COLORS.bullet,
+      })
+      out.push(...parseInline(numberedMatch[3]!))
+      i++
+      continue
+    }
+    pushNewline()
+    out.push(...parseInline(rawLine))
+    i++
+  }
+  return out
+}

package/src/ui/markdown.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, it } from 'bun:test'
+// Import from the .ts file (pure logic) so the test doesn't trigger the
+// JSX transform on markdown.tsx. CI's bun runtime resolves react-jsx by
+// default unless a per-file pragma or workspace tsconfig override applies,
+// and pulling solid-js JSX into the test file isn't worth the coupling.
+import { parseMarkdown } from './markdown-parse'
+
+describe('parseMarkdown', () => {
+  it('renders plain text as a single segment', () => {
+    const segs = parseMarkdown('hello world')
+    expect(segs).toHaveLength(1)
+    expect(segs[0]?.text).toBe('hello world')
+    expect(segs[0]?.bold).toBeUndefined()
+  })
+
+  it('parses **bold** as bold segment between plain', () => {
+    const segs = parseMarkdown('the **fast** fox')
+    const labels = segs.map(s => `${s.text}${s.bold ? '*' : ''}`)
+    expect(labels).toContain('fast*')
+    expect(segs.find(s => s.text === 'fast')?.bold).toBe(true)
+  })
+
+  it('parses *italic* as italic segment', () => {
+    const segs = parseMarkdown('the *quick* fox')
+    expect(segs.find(s => s.text === 'quick')?.italic).toBe(true)
+  })
+
+  it('parses `code` as code-colored segment', () => {
+    const segs = parseMarkdown('use `browser.snapshot` next')
+    const code = segs.find(s => s.text === 'browser.snapshot')
+    expect(code?.fg).toBeDefined()
+    expect(code?.fg).not.toBe('#e5e7eb')
+  })
+
+  it('renders heading with bold + heading color, drops the # prefix', () => {
+    const segs = parseMarkdown('# Title\nbody')
+    const titleSeg = segs.find(s => s.text === 'Title')
+    expect(titleSeg?.bold).toBe(true)
+    expect(titleSeg?.fg).not.toBe('#e5e7eb')
+    // The leading '#' should not appear as text
+    expect(segs.some(s => s.text.startsWith('#'))).toBe(false)
+  })
+
+  it('renders bullet lists with bullet glyph + content', () => {
+    const segs = parseMarkdown('- one\n- two')
+    const bullets = segs.filter(s => s.text.includes('•'))
+    expect(bullets.length).toBe(2)
+    // Bullet should be a SEPARATE segment from content (different style)
+    expect(segs.find(s => s.text === 'one')).toBeDefined()
+    expect(segs.find(s => s.text === 'two')).toBeDefined()
+  })
+
+  it('renders fenced code block with code-block color, skips fence lines', () => {
+    const segs = parseMarkdown('```ts\nconst x = 1;\nconst y = 2;\n```')
+    const codeLines = segs.filter(s => s.text.includes('const'))
+    expect(codeLines.length).toBe(2)
+    expect(codeLines[0]?.fg).toBeDefined()
+    // Fence syntax (```ts and ```) should NOT appear in output
+    expect(segs.some(s => s.text.startsWith('```'))).toBe(false)
+  })
+
+  it('parses inline code inside bold without breaking either', () => {
+    const segs = parseMarkdown('use **`foo`** now')
+    // The combined ** + `` is unusual; we accept either bold-with-code or plain-with-code, but no crash
+    expect(segs.length).toBeGreaterThan(0)
+  })
+
+  it('preserves newlines between blocks', () => {
+    const segs = parseMarkdown('one\ntwo\nthree')
+    const newlines = segs.filter(s => s.text === '\n')
+    expect(newlines.length).toBe(2)
+  })
+
+  it('handles the screenshot regression case (mixed bold + inline code + bullets)', () => {
+    const text = `**What I did successfully:**
+- \`browser.navigate\` → done
+- \`browser.type\` worked
+
+**What failed:**
+- \`browser.snapshot\` returned home`
+    const segs = parseMarkdown(text)
+    // Bold "What I did successfully:" present
+    expect(segs.find(s => s.text === 'What I did successfully:' && s.bold)).toBeDefined()
+    // Inline code segments
+    expect(segs.find(s => s.text === 'browser.navigate')).toBeDefined()
+    expect(segs.find(s => s.text === 'browser.snapshot')).toBeDefined()
+    // No literal ** or ` in output
+    expect(segs.some(s => s.text.includes('**'))).toBe(false)
+    expect(segs.some(s => s.text.includes('`'))).toBe(false)
+  })
+
+  // v0.22.0: brain emits GFM tables. Previously the renderer treated every
+  // `|...|` line as plain text, leaving the operator with literal pipes + a
+  // useless separator row. The new path detects header + `|---|---|` + data
+  // rows and emits aligned cells with a box-drawing divider.
+  describe('GFM tables', () => {
+    it('renders a 2-column table with header + data rows', () => {
+      const md = '| Mode | Behavior |\n|------|----------|\n| yolo | auto |\n| prompt | modal |'
+      const segs = parseMarkdown(md)
+      // Header row text should contain both column headers + box-drawing pipes
+      const headerSeg = segs.find(s => s.text.includes('Mode') && s.text.includes('Behavior'))
+      expect(headerSeg).toBeDefined()
+      expect(headerSeg?.bold).toBe(true)
+      expect(headerSeg?.text).toContain('│')
+      // Separator row should be present once
+      expect(segs.some(s => s.text.includes('─') && s.text.includes('┼'))).toBe(true)
+      // Data rows
+      expect(segs.some(s => s.text.includes('yolo') && s.text.includes('auto'))).toBe(true)
+      expect(segs.some(s => s.text.includes('prompt') && s.text.includes('modal'))).toBe(true)
+      // Cells are padded to a common width — column 0 should be 6 chars wide
+      // ("prompt") so "yolo" appears as "yolo  " (4 + 2 spaces of padding).
+      const yoloRow = segs.find(s => s.text.includes('yolo'))
+      expect(yoloRow?.text).toMatch(/yolo\s{2,}/)
+    })
+
+    it('pads short cells so columns align', () => {
+      const md = '| col |\n|-----|\n| a |\n| longer cell |'
+      const segs = parseMarkdown(md)
+      const longRow = segs.find(s => s.text.includes('longer cell'))
+      const shortRow = segs.find(s => s.text.match(/│\s+a\s+│/))
+      expect(longRow).toBeDefined()
+      expect(shortRow).toBeDefined()
+      // Both rows should have identical visual width (same number of chars)
+      expect(shortRow?.text.length).toBe(longRow?.text.length)
+    })
+
+    it('falls through to plain text when no separator row follows the header', () => {
+      const md = '| col1 | col2 |\nplain text below'
+      const segs = parseMarkdown(md)
+      // No table-style border characters
+      expect(segs.some(s => s.text.includes('│'))).toBe(false)
+      expect(segs.some(s => s.text.includes('┼'))).toBe(false)
+    })
+
+    it('does not emit em-dashes in the separator row (project rule)', () => {
+      const md = '| col |\n|-----|\n| a |'
+      const segs = parseMarkdown(md)
+      // U+2014 (em-dash) must NOT appear anywhere in the rendered output.
+      // U+2013 (en-dash) also forbidden. Only ASCII hyphens or box-drawing
+      // U+2500 are allowed.
+      const joined = segs.map(s => s.text).join('')
+      expect(joined.includes('—')).toBe(false)
+      expect(joined.includes('–')).toBe(false)
+    })
+  })
+})

package/src/ui/markdown.tsx

@@ -0,0 +1,37 @@
+import { For } from 'solid-js'
+import { parseMarkdown } from './markdown-parse'
+
+export {
+  parseMarkdown,
+  MD_COLORS,
+  type MdSegment,
+} from './markdown-parse'
+
+/**
+ * Render parsed markdown segments as opentui spans inside an existing
+ * `<text>` block. Caller owns the wrapping `<text>` (so wrapMode + flexGrow
+ * stay configurable).
+ *
+ * Why custom rather than opentui's built-in `<markdown>`: promus already
+ * renders assistant text inside a row that has a fixed-width prefix
+ * gutter; switching to `<markdown>` would break the indent and gutter
+ * alignment because it owns its own layout. A custom renderer that emits
+ * spans keeps the existing AssistantTextRow flow intact.
+ */
+export function MarkdownSegments(props: { text: string }) {
+  const segments = () => parseMarkdown(props.text)
+  return (
+    <For each={segments()}>
+      {seg => {
+        // opentui's SpanProps type omits fg/bold/italic but the runtime
+        // accepts them. Cast through an object spread to bypass the check.
+        const styles = {
+          ...(seg.fg ? { fg: seg.fg } : {}),
+          ...(seg.bold ? { bold: true } : {}),
+          ...(seg.italic ? { italic: true } : {}),
+        } as Record<string, unknown>
+        return <span {...styles}>{seg.text}</span>
+      }}
+    </For>
+  )
+}

package/src/ui/state.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'bun:test'
+import { createChatState } from './state'
+
+describe('createChatState — v0.24.4 isLocalGateway', () => {
+  it('exposes isLocalGateway=true when the local-gateway flag is passed', () => {
+    const state = createChatState({
+      initialSystem: 'connected to local gateway (~/.promus/agents/abcd1234/gateway.sock)',
+      identityLabel: 'agent specter  0xabc',
+      approvalsMode: 'prompt',
+      isLocalGateway: true,
+    })
+    expect(state.isLocalGateway).toBe(true)
+  })
+
+  it('defaults isLocalGateway=false when omitted (sandbox path)', () => {
+    const state = createChatState({
+      initialSystem: 'connected to sandbox 12345678 @ https://sandbox.example',
+      identityLabel: 'agent enigma  0xdef',
+      approvalsMode: 'prompt',
+    })
+    expect(state.isLocalGateway).toBe(false)
+  })
+
+  it('treats explicit isLocalGateway=false as sandbox mode', () => {
+    const state = createChatState({
+      initialSystem: 'connected to sandbox 12345678 @ https://sandbox.example',
+      identityLabel: 'agent enigma  0xdef',
+      approvalsMode: 'off',
+      isLocalGateway: false,
+    })
+    expect(state.isLocalGateway).toBe(false)
+  })
+
+  it('keeps sandboxBalance() null at construction so the statusbar Show gate hides the segment until setSandboxBalance fires', () => {
+    const localState = createChatState({
+      initialSystem: 'connected to local gateway',
+      identityLabel: 'agent specter  0xabc',
+      approvalsMode: 'off',
+      isLocalGateway: true,
+    })
+    // v0.24.4: chat-sandbox.tsx skips setSandboxBalance entirely for local
+    // gateway deploys. Re-affirm the default so any future setter regression
+    // surfaces here.
+    expect(localState.sandboxBalance()).toBeNull()
+  })
+
+  it('seeds the initial system row from initialSystem (local-gateway label form)', () => {
+    const state = createChatState({
+      initialSystem: 'connected to local gateway (~/.promus/agents/abcd1234/gateway.sock)',
+      identityLabel: 'agent specter  0xabc',
+      approvalsMode: 'prompt',
+      isLocalGateway: true,
+    })
+    const first = state.rows()[0]
+    expect(first).toBeDefined()
+    if (!first) throw new Error('rows()[0] missing')
+    expect(first.role).toBe('system')
+    expect(first.text).toContain('local gateway')
+    expect(first.text).not.toContain('sandbox')
+  })
+
+  it('seeds the initial system row from initialSystem (sandbox label form)', () => {
+    const state = createChatState({
+      initialSystem: 'connected to sandbox 12345678 @ https://sandbox.example',
+      identityLabel: 'agent enigma  0xdef',
+      approvalsMode: 'prompt',
+    })
+    const first = state.rows()[0]
+    expect(first).toBeDefined()
+    if (!first) throw new Error('rows()[0] missing')
+    expect(first.role).toBe('system')
+    expect(first.text).toContain('sandbox 12345678')
+  })
+})