@@ -27,6 +27,10 @@ import {
   loadOpenCodeVisualsSkill,
   type AcpVisualsSkillLoader
 } from './acp-visuals-skill'
+import type { StructuredAgentSessionHistory } from '../native-chat/structured-agent-cli-conversations'
+import { GROK_SESSION_HISTORY } from '../grok/grok-session-history'
+import { OPENCODE_SESSION_HISTORY } from '../opencode/opencode-session-history'
+import { OMP_SESSION_HISTORY } from '../omp/omp-session-history'
 
 /** How an agent lists its models without a session: from its `initialize` answer (plus extension
  *  requests), from a listing command, or not at all. Never `authenticate` or `session/new`. */
@@ -87,6 +91,8 @@ export type AcpLaunchSpec = {
   modelDiscovery: AcpModelDiscovery
   /** How a launch loads the inline-visuals skill; absent, the agent's chats have no visuals. */
   visualsSkill?: AcpVisualsSkillLoader
+  /** How the agent's chats own the Session History rows their conversations list as. */
+  sessionHistory: StructuredAgentSessionHistory
 }
 
 const GROK_LAUNCH_SPEC: AcpLaunchSpec = {
@@ -119,7 +125,8 @@ const GROK_LAUNCH_SPEC: AcpLaunchSpec = {
     listingNamesConfiguredModel: false
   },
   visualsSkill: loadGrokVisualsSkill,
-  compaction: true
+  compaction: true,
+  sessionHistory: GROK_SESSION_HISTORY
 }
 
 // `opencode acp` on 1.x serves in-process; on 2.x it starts a private `opencode serve --stdio` child
@@ -157,7 +164,8 @@ const OPENCODE_LAUNCH_SPEC: AcpLaunchSpec = {
     listingNamesConfiguredModel: false
   },
   visualsSkill: loadOpenCodeVisualsSkill,
-  compaction: true
+  compaction: true,
+  sessionHistory: OPENCODE_SESSION_HISTORY
 }
 
 // OMP serves ACP through `omp acp`; its environment reaches it as the user set it.
@@ -184,7 +192,8 @@ const OMP_LAUNCH_SPEC: AcpLaunchSpec = {
     reason: 'omp has no session-free listing that matches what its chats offer'
   },
   visualsSkill: loadOmpVisualsSkill,
-  compaction: true
+  compaction: true,
+  sessionHistory: OMP_SESSION_HISTORY
 }
 
 export const ACP_LAUNCH_SPECS: readonly AcpLaunchSpec[] = [
 
@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest'
+import { commandProgramIndex, shellCommands } from './shell-command-words'
+
+const commands = (text: string) => [...shellCommands(text)]
+
+describe('shellCommands', () => {
+  it('splits at separators glued to words, outside quotes only', () => {
+    expect(commands(`cd /x&&a -s 1;b|c||d&e`)).toEqual([
+      ['cd', '/x'],
+      ['a', '-s', '1'],
+      ['b'],
+      ['c'],
+      ['d'],
+      ['e']
+    ])
+    expect(commands(`a "x;y" 'p|q&&r' z`)).toEqual([['a', 'x;y', 'p|q&&r', 'z']])
+  })
+
+  it('joins quoted runs into one word', () => {
+    expect(commands(`a --session="s 1" -r='x'y 'it'"'"'s'`)).toEqual([
+      ['a', '--session=s 1', '-r=xy', "it's"]
+    ])
+    expect(commands(`a "say \\"hi\\"" b`)).toEqual([['a', 'say \\"hi\\"', 'b']])
+  })
+
+  it('keeps redirections inside the command', () => {
+    expect(commands(`a 2>&1 >log b&>/dev/null c`)).toEqual([
+      ['a', '2>&1', '>log', 'b&>/dev/null', 'c']
+    ])
+  })
+
+  it('reads an unclosed quote as a character', () => {
+    expect(commands(`a "b c; d`)).toEqual([['a', '"b', 'c'], ['d']])
+  })
+
+  it('continues a line after a continuation mark', () => {
+    expect(commands('a \\\n -r 1\r\nb x`\r\ny')).toEqual([
+      ['a', '-r', '1'],
+      ['b', 'x', 'y']
+    ])
+  })
+
+  it('stays linear on long and unbalanced texts', () => {
+    const size = 2 * 1024 * 1024
+    expect(commands('a'.repeat(size))[0]![0]).toHaveLength(size)
+    expect(commands(`"${' \\"'.repeat(size / 3)}`)).toHaveLength(1)
+    expect(commands(`'${" '".repeat(size / 2)}`)).toHaveLength(1)
+  })
+})
+
+describe('commandProgramIndex', () => {
+  it.each([
+    [['claude', '-r', 'x'], 0],
+    [['A=1', 'B=2', 'claude'], 2],
+    [['env', '-i', 'A=1', 'claude'], 3],
+    [['sudo', '-E', 'claude'], 2],
+    [['pnpm', 'dlx', 'claude'], 2],
+    [['nohup', 'claude'], 1],
+    [['time', 'codex', 'resume', 'x'], 1],
+    [['wsl.exe', '--', 'claude'], 2],
+    [['/usr/bin/env', 'claude'], 1],
+    [['A=1'], -1]
+  ])('finds the program of %j at %i', (words, index) => {
+    expect(commandProgramIndex(words)).toBe(index)
+  })
+})
@@ -0,0 +1,137 @@
+// Reads a command line as a shell would, only as far as the resume guard needs: into commands,
+// each a list of words with their quotes removed. One pass, so a long terminal text stays linear.
+
+const BLANKS = /[^\S\r\n]+/y
+// Unquoted text, or a redirection: `>&`, `<&` and `&>` do not end a command.
+const WORD_PIECE = /[^\s&|;"'<>]+|[<>]&|&>|[<>]/y
+const SEPARATOR = /&&|\|\||[&|;]|\r\n|\r|\n/y
+const LINE_BREAKS = new Set(['\r\n', '\r', '\n'])
+// POSIX `\`, PowerShell `` ` `` and cmd `^` before a line break continue the command.
+const CONTINUATION_MARKS = new Set(['\\', '`', '^'])
+
+type ShellToken = { word: string; continuesLine: boolean } | { separator: string }
+
+/** Each command of `text`, as its words. Outside quotes, `&&`, `||`, `;`, `|`, `&` and a line
+ *  break end a command, even glued to a word (`cd /x&&claude`). */
+export function* shellCommands(text: string): Generator<string[]> {
+  let words: string[] = []
+  let continuesLine = false
+  for (const token of shellTokens(text)) {
+    if ('word' in token) {
+      words.push(token.word)
+      continuesLine = token.continuesLine
+      continue
+    }
+    if (continuesLine && LINE_BREAKS.has(token.separator)) {
+      const continued = words.pop()!.slice(0, -1)
+      if (continued) {
+        words.push(continued)
+      }
+    } else if (words.length > 0) {
+      yield words
+      words = []
+    }
+    continuesLine = false
+  }
+  if (words.length > 0) {
+    yield words
+  }
+}
+
+function* shellTokens(text: string): Generator<ShellToken> {
+  // Once a quote of a kind has no closing quote, no later one of that kind has either.
+  const unclosedFrom = { '"': text.length, "'": text.length }
+  let index = 0
+  while (index < text.length) {
+    BLANKS.lastIndex = index
+    if (BLANKS.test(text)) {
+      index = BLANKS.lastIndex
+      continue
+    }
+    // A word joins unquoted text and quoted runs: `--session="a b"` is one word.
+    const pieces: string[] = []
+    let continuesLine = false
+    while (index < text.length) {
+      WORD_PIECE.lastIndex = index
+      const quote = text[index]
+      if (WORD_PIECE.test(text)) {
+        pieces.push(text.slice(index, WORD_PIECE.lastIndex))
+        index = WORD_PIECE.lastIndex
+        continuesLine = CONTINUATION_MARKS.has(text[index - 1]!)
+      } else if (quote === '"' || quote === "'") {
+        const close = index < unclosedFrom[quote] ? closingQuote(text, index) : -1
+        if (close === -1) {
+          unclosedFrom[quote] = index
+        }
+        pieces.push(close === -1 ? quote : text.slice(index + 1, close))
+        continuesLine = false
+        index = close === -1 ? index + 1 : close + 1
+      } else {
+        break
+      }
+    }
+    if (pieces.length > 0) {
+      yield { word: pieces.length === 1 ? pieces[0]! : pieces.join(''), continuesLine }
+      continue
+    }
+    SEPARATOR.lastIndex = index
+    const separator = SEPARATOR.exec(text)![0]
+    yield { separator }
+    index += separator.length
+  }
+}
+
+/** The index of the quote closing the one at `open`; a double quote escaped by `\` does not. */
+function closingQuote(text: string, open: number): number {
+  const quote = text[open]!
+  for (let at = text.indexOf(quote, open + 1); at !== -1; at = text.indexOf(quote, at + 1)) {
+    let backslashes = 0
+    while (quote === '"' && text[at - 1 - backslashes] === '\\') {
+      backslashes += 1
+    }
+    if (backslashes % 2 === 0) {
+      return at
+    }
+  }
+  return -1
+}
+
+/** The name a word runs as: its path's last name, lower-case. */
+export function commandName(word: string): string {
+  return word.slice(Math.max(word.lastIndexOf('/'), word.lastIndexOf('\\')) + 1).toLowerCase()
+}
+
+const ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/
+const LAUNCHERS = new Set([
+  'env',
+  'exec',
+  'command',
+  'sudo',
+  'nohup',
+  'time',
+  'npx',
+  'bunx',
+  'wsl',
+  'wsl.exe'
+])
+
+/** The index of the program a command runs: its first word past `VAR=x` prefixes and launchers
+ *  (`env`, `exec`, `command`, `sudo`, `nohup`, `time`, `npx`, `bunx`, `pnpm dlx`, `wsl --`) with their
+ *  options; -1 if none. */
+export function commandProgramIndex(words: readonly string[]): number {
+  let launched = false
+  for (let index = 0; index < words.length; index += 1) {
+    const word = words[index]!
+    if (ASSIGNMENT.test(word) || (launched && word.startsWith('-'))) {
+      continue
+    }
+    const name = commandName(word)
+    if (name === 'pnpm' && words[index + 1] === 'dlx') {
+      index += 1
+    } else if (!LAUNCHERS.has(name)) {
+      return index
+    }
+    launched = true
+  }
+  return -1
+}