@excitedjs/tm 1.1.0

package/src/verbs/history.ts

@@ -0,0 +1,190 @@
+/**
+ * `tm history <name> [index]` — turn-by-turn history. Decision multi-engine-tui-architecture
+ * §"`history` and `mem` stay" keeps the verb alive on both engines.
+ * The Claude engine reads `~/.claude/projects/<encoded>/*.jsonl`;
+ * the Codex engine reads rollout JSONL files from `~/.codex/sessions`.
+ * List mode merges both engines by mtime; detail mode accepts either a
+ * Claude sid prefix or a Codex thread-id prefix.
+ */
+
+import { formatHistory } from './format'
+import type { Engine } from '../engines/engine'
+import type {
+  EngineKind,
+  HistoryListEntry,
+  HistoryRequest,
+  HistoryResult,
+  TeammateName,
+} from '../engines/types'
+import type { TmResult } from '../tm'
+import type { VerbContext } from './context'
+import { resolveTargetEngine } from './resolve'
+import { hasCodexHistoryForCwd } from '../engines/codex/history'
+import { fmtAge } from '../engines/claude/clock'
+
+export interface HistoryArgs {
+  readonly name: TeammateName
+  readonly cwd: string | null
+  /** `null` = list view; non-null = engine-specific detail selector. */
+  readonly index: string | null
+}
+
+interface HistoryTarget {
+  readonly engine: Engine
+  readonly resolved: boolean
+  readonly codexFromHistory: boolean
+}
+
+async function resolveHistoryTarget(args: HistoryArgs, ctx: VerbContext): Promise<HistoryTarget | TmResult> {
+  const resolved = await ctx.router.resolve(args.name)
+  const codexFromHistory =
+    resolved === null &&
+    args.cwd !== null &&
+    ctx.engines.get('codex') !== undefined &&
+    hasCodexHistoryForCwd(args.cwd, ctx.engineContext.env)
+  const engine = codexFromHistory
+    ? ctx.engines.get('codex')!
+    : resolved?.engine ?? await resolveTargetEngine(args.name, ctx)
+  if ('code' in engine) return engine
+  return { engine, resolved: resolved !== null, codexFromHistory }
+}
+
+function historyCandidateEngines(target: HistoryTarget, ctx: VerbContext): readonly Engine[] {
+  const engines: Engine[] = []
+  const add = (engine: Engine | undefined): void => {
+    if (engine === undefined) return
+    if (!engines.some((candidate) => candidate.kind === engine.kind)) engines.push(engine)
+  }
+
+  if (target.engine.kind === 'codex' && !target.codexFromHistory && !target.resolved) {
+    add(target.engine)
+    return engines
+  }
+
+  add(ctx.engines.get('claude'))
+  add(ctx.engines.get('codex'))
+  add(target.engine)
+  return engines
+}
+
+/**
+ * Detail-mode prefix → engine, when the UUID version digit is reachable
+ * inside the prefix. Claude sids are random UUIDv4 (`xxxxxxxx-xxxx-4xxx-...`);
+ * Codex thread ids are UUIDv7 (`xxxxxxxx-xxxx-7xxx-...`). Stripping `-` and
+ * inspecting the 13th hex char (index 12) gives the version regardless of
+ * whether the caller pasted the canonical dashed form or a raw hex run.
+ * Returns `null` when the prefix is too short to reach the version digit,
+ * or when the version digit is neither `4` nor `7` — both cases fall back
+ * to the existing dual-engine probe rather than silently misroute.
+ */
+function detailEngineFromPrefix(prefix: string): EngineKind | null {
+  const stripped = prefix.replace(/-/g, '')
+  if (stripped.length < 13) return null
+  const versionChar = stripped[12]
+  if (versionChar === '4') return 'claude'
+  if (versionChar === '7') return 'codex'
+  return null
+}
+
+function fmtSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`
+  if (bytes < 1048576) return `${Math.trunc(bytes / 1024)}K`
+  if (bytes < 1073741824) return `${toFixed1HalfEven(bytes / 1048576)}M`
+  return `${toFixed1HalfEven(bytes / 1073741824)}G`
+}
+
+function toFixed1HalfEven(value: number): string {
+  const tenths = value * 10
+  const floor = Math.floor(tenths)
+  const frac = tenths - floor
+  let rounded: number
+  if (frac < 0.5) rounded = floor
+  else if (frac > 0.5) rounded = floor + 1
+  else rounded = floor % 2 === 0 ? floor : floor + 1
+  return (rounded / 10).toFixed(1)
+}
+
+function sortedHistoryEntries(entries: readonly HistoryListEntry[]): readonly HistoryListEntry[] {
+  return [...entries].sort((a, b) =>
+    b.mtimeMs - a.mtimeMs ||
+    (a.engine < b.engine ? -1 : a.engine > b.engine ? 1 : 0) ||
+    (a.id < b.id ? -1 : a.id > b.id ? 1 : 0),
+  )
+}
+
+async function formatHistoryEntries(
+  entries: readonly HistoryListEntry[],
+  ctx: VerbContext,
+): Promise<TmResult> {
+  const nowMs = ctx.engineContext.now()
+  const rows: string[][] = [[' ', 'ENGINE', 'ID', 'AGE', 'SIZE', 'TOPIC']]
+  // Full id, not an 8-char prefix: `tm resume` requires the canonical UUID
+  // and silently rejects a prefix with a misleading "wrong repo" error.
+  // Listing the full id keeps history → resume copy-paste lossless.
+  for (const entry of sortedHistoryEntries(entries)) {
+    rows.push([
+      entry.active ? '*' : ' ',
+      entry.engine,
+      entry.id,
+      fmtAge(Math.max(0, Math.floor((nowMs - entry.mtimeMs) / 1000))),
+      fmtSize(entry.size),
+      entry.topic,
+    ])
+  }
+  return ctx.runColumn(`${rows.map((row) => row.join('\t')).join('\n')}\n`)
+}
+
+function raw(result: HistoryResult): TmResult {
+  return formatHistory(result)
+}
+
+export async function historyVerb(args: HistoryArgs, ctx: VerbContext): Promise<TmResult> {
+  const target = await resolveHistoryTarget(args, ctx)
+  if ('code' in target) return target
+  const req: HistoryRequest = { name: args.name, cwd: args.cwd, index: args.index }
+
+  if (args.index !== null) {
+    // UUID-version short-circuit: when the prefix is long enough to expose
+    // the version digit (claude=v4, codex=v7), route to that one engine and
+    // skip the cross-engine probe. The other engine cannot hold a session
+    // whose id begins with the wrong version digit, so probing it would only
+    // walk a rollout tree that is guaranteed to miss.
+    const shortCircuit = detailEngineFromPrefix(args.index)
+    const shortCircuitEngine = shortCircuit !== null ? ctx.engines.get(shortCircuit) : undefined
+    if (shortCircuitEngine !== undefined) {
+      return raw(await shortCircuitEngine.history(req, ctx.engineContext))
+    }
+
+    const engines = historyCandidateEngines(target, ctx)
+    const results = await Promise.all(
+      engines.map(async (engine) => ({ engine, result: await engine.history(req, ctx.engineContext) })),
+    )
+    const successes = results
+      .map(({ result }) => raw(result))
+      .filter((result) => result.code === 0)
+    if (successes.length === 1) return successes[0]!
+    if (successes.length > 1) {
+      return {
+        code: 1,
+        stdout: '',
+        stderr: `tm: history: prefix '${args.index}' matches entries in multiple engines - be more specific\n`,
+      }
+    }
+    const targetResult = results.find(({ engine }) => engine.kind === target.engine.kind)?.result ??
+      await target.engine.history(req, ctx.engineContext)
+    return raw(targetResult)
+  }
+
+  const engines = historyCandidateEngines(target, ctx)
+  const results = await Promise.all(
+    engines.map(async (engine) => ({ engine, result: await engine.history(req, ctx.engineContext) })),
+  )
+  const entries = results.flatMap(({ result }) =>
+    result.kind === 'list' && result.entries !== undefined ? [...result.entries] : [],
+  )
+  if (entries.length > 0) return formatHistoryEntries(entries, ctx)
+
+  const targetResult = results.find(({ engine }) => engine.kind === target.engine.kind)?.result ??
+    await target.engine.history(req, ctx.engineContext)
+  return raw(targetResult)
+}

package/src/verbs/kill.ts

@@ -0,0 +1,61 @@
+/**
+ * `tm kill <name>` — release the teammate. Decision multi-engine-tui-architecture amend lines
+ * 163-169 fix the default impl: resolve through the router, ask the
+ * engine to kill, remove the identity JSON on success. The "remove
+ * identity" step is what frees the name for a subsequent `tm spawn`.
+ *
+ * The engine's `kill` is the single place that decides what "stop the
+ * teammate" means for that engine (tmux session kill / Codex daemon
+ * SIGTERM / etc); the verb owns identity bookkeeping and exit code.
+ */
+
+import { existsSync } from 'node:fs'
+
+import { formatKill } from './format'
+import { identityFile } from '../persistence/identity-store'
+import type { TeammateName } from '../engines/types'
+import type { TmResult } from '../tm'
+import type { VerbContext } from './context'
+
+/**
+ * `tm kill` is idempotent: a missing teammate still has to clear stale
+ * markers and return "not running" with exit 0. When the router cannot
+ * resolve a name, the verb falls through to the Claude engine — its
+ * `kill` is the only one that knows the tmux + on-disk marker layout the
+ * legacy `cmd_kill` cleaned up unconditionally. A registered Codex
+ * teammate would have been resolved by the router on the JSON path; if
+ * neither router resolves a name, it cannot be a live Codex daemon.
+ *
+ * Schema-1 record recovery: a legacy identity JSON whose engine has
+ * long-since died (no tmux session, no Codex daemon) leaves
+ * `engine.kill()` returning `not-found`. The verb still has to clear
+ * the stale `/tmp/teammate-<name>.json` so the next `tm spawn` is not
+ * blocked by an `O_EXCL` collision — `tm kill` is the documented
+ * recovery action for the schema-1 → schema-2 migration. The
+ * existence probe runs against the raw on-disk file (independent of
+ * schema parse), so a record this build cannot parse still gets
+ * swept.
+ */
+export async function killVerb(name: TeammateName, ctx: VerbContext): Promise<TmResult> {
+  const resolved = await ctx.router.resolve(name)
+  const engine = resolved?.engine ?? ctx.engines.get('claude')
+  if (engine === undefined) return formatKill(name, { kind: 'not-found' })
+  const hadIdentityFile = existsSync(identityFile(name))
+  const result = await engine.kill({ name }, ctx.engineContext)
+  // Archive before remove: a later `tm resume <name> <sid>` /
+  // `tm history <name>` reads the snapshot to recover the killed
+  // teammate's cwd / repo / worktreeSlug / displayName, so the agent
+  // never has to scrape `/tmp` directly.
+  if (result.kind === 'killed' || (result.kind === 'not-found' && hadIdentityFile)) {
+    await ctx.identity.archive(name)
+    await ctx.identity.remove(name)
+  }
+  if (result.kind === 'not-found' && hadIdentityFile) {
+    return {
+      code: 0,
+      stdout: `killed: ${name}\n`,
+      stderr: `tm kill: ${name}: cleared stale identity record (engine had no live process)\n`,
+    }
+  }
+  return formatKill(name, result)
+}

package/src/verbs/last.ts

@@ -0,0 +1,34 @@
+/**
+ * `tm last <name>` — reprint the last completed assistant reply.
+ */
+
+import type { LastRequest, TeammateName, TextResult } from '../engines/types'
+import type { TmResult } from '../tm'
+import type { VerbContext } from './context'
+import { resolveTargetEngine } from './resolve'
+
+function formatLast(result: TextResult): TmResult {
+  if (result.tmResult !== undefined) return result.tmResult
+  switch (result.kind) {
+    case 'text':
+      return { code: 0, stdout: result.text, stderr: '' }
+    case 'not-found':
+      return { code: 1, stdout: '', stderr: `tm: last: ${result.reason}\n` }
+    case 'not-supported':
+      return { code: 0, stdout: '', stderr: `  not supported: ${result.reason}\n` }
+    case 'failed':
+      return { code: 1, stdout: '', stderr: `tm: ${result.message}\n` }
+  }
+}
+
+export async function lastVerb(
+  name: TeammateName,
+  ctx: VerbContext,
+  options: { readonly verbose?: boolean } = {},
+): Promise<TmResult> {
+  const engine = await resolveTargetEngine(name, ctx)
+  if ('code' in engine) return engine
+
+  const req: LastRequest = { name, verbose: options.verbose === true }
+  return formatLast(await engine.last(req, ctx.engineContext))
+}

package/src/verbs/ls.ts

@@ -0,0 +1,27 @@
+/**
+ * `tm ls` — fleet-wide teammate listing. Decision multi-engine-tui-architecture amend
+ * §"Fleet-visibility verbs" makes this verb engine-agnostic: it
+ * iterates every registered engine, calls `Engine.list()` in parallel,
+ * and concatenates the rows. A Codex daemon teammate with no tmux
+ * session is therefore visible to `tm ls` for the first time.
+ *
+ * The default impl below is the one decision multi-engine-tui-architecture amend lines 150-155
+ * lock in. Engines do not override `tm ls` unless their listing output
+ * needs to differ from the shared format — and even then they extend
+ * the row shape, not the verb.
+ */
+
+import { formatListing, noEngineRegistered } from './format'
+import type { VerbContext } from './context'
+import type { TmResult } from '../tm'
+
+export async function lsVerb(ctx: VerbContext): Promise<TmResult> {
+  // An empty registry means production wiring is incomplete — the verb must
+  // surface that loudly, not silently report "no teammates". A zero-engine
+  // process is a misconfiguration, not a fleet state.
+  const engines = ctx.engines.registered()
+  if (engines.length === 0) return noEngineRegistered()
+
+  const listings = await Promise.all(engines.map((engine) => engine.list(ctx.engineContext)))
+  return formatListing(listings.flat())
+}

package/src/verbs/mem.ts

@@ -0,0 +1,40 @@
+/**
+ * `tm mem <name>` — project memory dump. Decision multi-engine-tui-architecture §"`history`
+ * and `mem` stay" keeps the verb alive across engines. The Claude
+ * engine reads `~/.claude/projects/<encoded>/memory/`; the Codex
+ * engine returns `not-supported`.
+ */
+
+import type { MemoryRequest, TeammateName, TextResult } from '../engines/types'
+import type { TmResult } from '../tm'
+import type { VerbContext } from './context'
+import { resolveTargetEngine } from './resolve'
+
+function formatMem(engineKind: string, result: TextResult): TmResult {
+  if (result.tmResult !== undefined) return result.tmResult
+  switch (result.kind) {
+    case 'text':
+      return { code: 0, stdout: result.text, stderr: '' }
+    case 'not-supported':
+      return {
+        code: 0,
+        stdout: '',
+        stderr:
+          engineKind === 'claude'
+            ? `${result.reason}\n`
+            : `  not supported: ${result.reason}\n`,
+      }
+    case 'not-found':
+      return { code: 1, stdout: '', stderr: `tm: mem: ${result.reason}\n` }
+    case 'failed':
+      return { code: 1, stdout: '', stderr: `tm: ${result.message}\n` }
+  }
+}
+
+export async function memVerb(name: TeammateName, ctx: VerbContext): Promise<TmResult> {
+  const engine = await resolveTargetEngine(name, ctx)
+  if ('code' in engine) return engine
+
+  const req: MemoryRequest = { name }
+  return formatMem(engine.kind, await engine.mem(req, ctx.engineContext))
+}

package/src/verbs/poll.ts

@@ -0,0 +1,61 @@
+/**
+ * `tm poll <repo> <regex> [timeout]` — block until a teammate's pane
+ * matches a regex, or a timeout elapses (a diagnostic verb).
+ *
+ * The poll loop is native; the match itself delegates to the real
+ * `grep -E`, the way `states` delegates alignment to `column`. `tm`'s
+ * `capture-pane | grep -qE` runs under `set -o pipefail`, so a match
+ * needs both the capture to succeed and `grep` to exit 0.
+ *
+ * Claude-only at the verb level: the codex driver does not run inside
+ * tmux, so a `tm poll codex-1 ...` falls through to the no-session
+ * error (which is the same shape tmux would emit anyway).
+ */
+
+import { requireSession, resolvePaneTarget } from '../engines/claude/tmux'
+import { isNonNegativeInteger, sleepMs } from '../engines/claude/clock'
+import type { TmResult } from '../tm'
+import type { GrepRunner } from '../grep'
+import type { TmuxRunner } from '../tmux'
+
+export interface PollEnv {
+  readonly runTmux: TmuxRunner
+  readonly runGrep: GrepRunner
+}
+
+export async function pollVerb(args: readonly string[], env: PollEnv): Promise<TmResult> {
+  const repo = args[0] ?? ''
+  const pattern = args[1] ?? ''
+  if (repo === '' || pattern === '') {
+    return die('usage: tm poll <repo> <regex> [timeout=180]')
+  }
+  // `||`, not `??`: `tm`'s `${3:-180}` also defaults on an empty-string arg.
+  const timeoutArg = args[2] || '180'
+
+  const sessionMissing = await requireSession(repo, env.runTmux)
+  if (sessionMissing !== null) return sessionMissing
+
+  const pane = await resolvePaneTarget(repo, env.runTmux)
+  if (pane === '') return die(`could not resolve pane target for ${repo}`)
+
+  // Same `[[ ^[0-9]+$ ]]` guard `send` / `wait` / `compact` use for their
+  // `--timeout` — a malformed value would otherwise become a NaN loop.
+  if (!isNonNegativeInteger(timeoutArg)) return { code: 1, stdout: '', stderr: '' }
+  const end = Math.floor(Date.now() / 1000) + Number(timeoutArg)
+  while (Math.floor(Date.now() / 1000) < end) {
+    const capture = await env.runTmux(['capture-pane', '-t', pane, '-p', '-S', '-300'])
+    if (capture.code === 0 && (await env.runGrep(pattern, capture.stdout)) === 0) {
+      return { code: 0, stdout: `matched: ${pattern}\n`, stderr: '' }
+    }
+    await sleepMs(3000)
+  }
+  return {
+    code: 1,
+    stdout: '',
+    stderr: `tm: timeout after ${timeoutArg}s waiting for /${pattern}/ in ${repo}\n`,
+  }
+}
+
+function die(message: string): TmResult {
+  return { code: 1, stdout: '', stderr: `tm: ${message}\n` }
+}

package/src/verbs/reload.ts

@@ -0,0 +1,17 @@
+/**
+ * `tm reload <name>` — ask one teammate to reload its plugin set.
+ */
+
+import { formatReload } from './format'
+import type { ReloadRequest, TeammateName } from '../engines/types'
+import type { TmResult } from '../tm'
+import type { VerbContext } from './context'
+import { resolveTargetEngine } from './resolve'
+
+export async function reloadVerb(name: TeammateName, ctx: VerbContext): Promise<TmResult> {
+  const engine = await resolveTargetEngine(name, ctx)
+  if ('code' in engine) return engine
+
+  const req: ReloadRequest = { name }
+  return formatReload(await engine.reload(req, ctx.engineContext))
+}

package/src/verbs/resolve.ts

@@ -0,0 +1,14 @@
+import type { Engine } from '../engines/engine'
+import type { TeammateName } from '../engines/types'
+import type { TmResult } from '../tm'
+import type { VerbContext } from './context'
+import { noEngineRegistered } from './format'
+
+export async function resolveTargetEngine(
+  name: TeammateName,
+  ctx: VerbContext,
+): Promise<Engine | TmResult> {
+  const resolved = await ctx.router.resolve(name)
+  if (resolved !== null) return resolved.engine
+  return ctx.engines.get('claude') ?? noEngineRegistered()
+}

package/src/verbs/resume.ts

@@ -0,0 +1,170 @@
+/**
+ * `tm resume <name> [checkpoint]` — relaunch a previous teammate session.
+ *
+ * Engine selection priority (literal per the resume-probing design):
+ *   1. explicit `--engine` flag       — caller's override, wins unconditionally
+ *   2. checkpoint-from-rollout        — a Codex thread-id maps to a rollout
+ *      (existing `codexFromRollout` logic — preserves `tm resume <name> <thread-id>`
+ *      after `tm kill` has removed the base record)
+ *   3. router resolution              — an existing teammate's recorded engine
+ *   4. cwd probing                    — both engines are asked whether they
+ *      hold history for the teammate's cwd; single candidate auto-routes,
+ *      double candidate is an ambiguity error, no candidate is "no resumable
+ *      session" — see decision context in the PR.
+ *   5. not-found                      — when probing cannot run (cwd unknown)
+ *      and the identity router cannot resolve the name.
+ */
+
+import { hasClaudeHistoryForCwd } from '../engines/claude/history'
+import { hasCodexHistoryForCwd } from '../engines/codex/history'
+import { formatResume } from './format'
+import { findCodexRolloutFile, readRolloutSessionCwd } from '../engines/codex/rollout'
+import { resolveTargetEngine } from './resolve'
+import type { Engine } from '../engines/engine'
+import type { EngineKind, ResumeRequest, TeammateName } from '../engines/types'
+import type { TmResult } from '../tm'
+import type { VerbContext } from './context'
+
+/**
+ * Recognise a worktree-shaped cwd
+ * (`<repo>/.claude/worktrees/<slug>`). The shape is the contract
+ * both engines launch worktree teammates under, so the same parser
+ * works whether the rollout was written by a Claude or a Codex
+ * teammate. Returns `null` when `cwd` does not have the suffix —
+ * the caller then falls back to "treat cwd as the repo itself"
+ * (`--no-worktree` mode).
+ *
+ * Exported so the unit test pinning the resume-after-clean-kill
+ * recovery shape can target this directly without standing up
+ * a real Codex daemon.
+ */
+export function parseWorktreeCwd(cwd: string): { repo: string; slug: string } | null {
+  const m = cwd.match(/^(.*?)\/\.claude\/worktrees\/([^/]+)\/?$/)
+  if (m === null) return null
+  const repo = m[1] ?? ''
+  const slug = m[2] ?? ''
+  if (repo.length === 0 || slug.length === 0) return null
+  return { repo, slug }
+}
+
+export interface ResumeArgs {
+  readonly name: TeammateName
+  readonly repo: string | null
+  readonly cwd: string | null
+  readonly worktreeSlug: string | null
+  readonly checkpoint: string | null
+  readonly prompt: string | null
+  readonly displayName: string | null
+  /** `tm resume --engine claude|codex` — overrides every other selector. */
+  readonly engineHint: EngineKind | null
+  /** `~/.claude/projects` (or test override) — needed for Claude-side probing. */
+  readonly projectsDir: string
+  /**
+   * Whether `cwd` was derived from a real source (an existing identity
+   * record, a Codex base record/meta, or a dispatcher subdirectory)
+   * rather than the last-resort fallback. Probing must skip itself
+   * when this is `false`, or it would match the dispatcher's own
+   * transcripts and false-route.
+   */
+  readonly cwdProbeable: boolean
+}
+
+function die(message: string): TmResult {
+  return { code: 1, stdout: '', stderr: `tm: ${message}\n` }
+}
+
+async function dispatchResume(engine: Engine, args: ResumeArgs, ctx: VerbContext): Promise<TmResult> {
+  const req: ResumeRequest = {
+    name: args.name,
+    repo: args.repo,
+    cwd: args.cwd,
+    worktreeSlug: args.worktreeSlug,
+    checkpoint: args.checkpoint,
+    prompt: args.prompt,
+    displayName: args.displayName,
+  }
+  return formatResume(await engine.resume(req, ctx.engineContext))
+}
+
+export async function resumeVerb(args: ResumeArgs, ctx: VerbContext): Promise<TmResult> {
+  // 1. Explicit --engine wins unconditionally — caller's override.
+  if (args.engineHint !== null) {
+    const engine = ctx.engines.get(args.engineHint)
+    if (engine === undefined) {
+      return die(`resume: --engine ${args.engineHint} is not registered in this process`)
+    }
+    return dispatchResume(engine, args, ctx)
+  }
+
+  // 2. Checkpoint reverse-lookup — a passed thread-id that maps to a
+  // Codex rollout. Preserves `tm resume <name> <thread-id>` after
+  // `tm kill` has removed the live identity + Codex meta records.
+  //
+  // After a clean kill, `args.cwd` came from `cwdForName`'s last-resort
+  // fallback (no identity → no Codex meta → no `<dispatcherDir>/<name>`
+  // dir → dispatcher dir). Spawning the resumed daemon at the
+  // dispatcher dir would silently launch follow-up turns in the wrong
+  // workspace. The rollout's `session_meta.cwd` header records the
+  // daemon's original launch cwd verbatim; use it to override the
+  // fallback when the dispatcher would otherwise route blind. When
+  // the rollout cwd has the worktree shape
+  // (`.../.claude/worktrees/<slug>`), split out `repo` and
+  // `worktreeSlug` so the engine re-provisions the worktree if a
+  // prior `tm kill` removed it. The identity-known path (no kill, or
+  // `--name` matches a live record) already has the right cwd in
+  // `args.cwd`, so the override only fires when `cwdForName` could
+  // not produce a teammate-specific cwd.
+  const codex = ctx.engines.get('codex')
+  if (args.checkpoint !== null && codex !== undefined) {
+    const rollout = findCodexRolloutFile(args.checkpoint, ctx.engineContext.env)
+    if (rollout !== null) {
+      const rolloutCwd = readRolloutSessionCwd(rollout.path)
+      const shouldRecover = rolloutCwd !== null && (args.cwd === null || !args.cwdProbeable)
+      let recovered = args
+      if (shouldRecover && rolloutCwd !== null) {
+        const parts = parseWorktreeCwd(rolloutCwd)
+        recovered = parts === null
+          ? { ...args, cwd: rolloutCwd, repo: rolloutCwd, worktreeSlug: null }
+          : { ...args, cwd: rolloutCwd, repo: parts.repo, worktreeSlug: parts.slug }
+      }
+      return dispatchResume(codex, recovered, ctx)
+    }
+  }
+
+  // 3. Router — an existing teammate's recorded engine.
+  const resolved = await ctx.router.resolve(args.name)
+  if (resolved !== null) {
+    return dispatchResume(resolved.engine, args, ctx)
+  }
+
+  // 4. cwd probing — single candidate auto-routes; double = ambiguity error.
+  // Probing is only meaningful when there is no checkpoint to disambiguate,
+  // and only safe when the cwd actually points at the teammate's repo.
+  if (args.checkpoint === null && args.cwd !== null && args.cwdProbeable) {
+    const claude = ctx.engines.get('claude')
+    const codexHas = codex !== undefined && hasCodexHistoryForCwd(args.cwd, ctx.engineContext.env)
+    const claudeHas = claude !== undefined && hasClaudeHistoryForCwd(args.cwd, args.projectsDir)
+
+    if (codexHas && claudeHas) {
+      return die(
+        `resume: ambiguous — both codex and claude have resumable history for ` +
+          `cwd ${args.cwd}. Pass --engine codex|claude, or give an explicit ` +
+          `<sid> (claude) / <thread-id> (codex).`,
+      )
+    }
+    if (codexHas) return dispatchResume(codex!, args, ctx)
+    if (claudeHas) return dispatchResume(claude!, args, ctx)
+    return die(
+      `resume: no resumable session for ${args.name} — no Claude transcript ` +
+        `under projectsDir and no Codex rollout for cwd ${args.cwd}. ` +
+        `To start a new session, use 'tm spawn ${args.name} [--engine codex|claude]'.`,
+    )
+  }
+
+  // 5. Not found — cwd is unknown (or checkpoint passed but unmatched). The
+  // production router may have migrated a live pre-identity teammate above;
+  // if resolution is still empty, there is no engine-safe target.
+  const engine = await resolveTargetEngine(args.name, ctx)
+  if ('code' in engine) return engine
+  return dispatchResume(engine, args, ctx)
+}

package/src/verbs/send.ts

@@ -0,0 +1,36 @@
+/**
+ * `tm send <name> --prompt p` — atomic round-trip. Decision multi-engine-tui-architecture
+ * §"Round-trips are atomic by default" makes wait the only path;
+ * `--no-wait` is removed. The verb resolves the teammate through the
+ * router and dispatches to `Engine.send`; the engine owns the
+ * transport.
+ */
+
+import { formatTurn } from './format'
+import type { SendRequest, TeammateName } from '../engines/types'
+import type { TmResult } from '../tm'
+import type { VerbContext } from './context'
+import { resolveTargetEngine } from './resolve'
+
+export interface SendArgs {
+  readonly name: TeammateName
+  readonly prompt: string
+  readonly timeoutMs: number | null
+  readonly paneQuiet: boolean
+}
+
+export async function sendVerb(args: SendArgs, ctx: VerbContext): Promise<TmResult> {
+  const engine = await resolveTargetEngine(args.name, ctx)
+  if ('code' in engine) return engine
+  if (args.paneQuiet && engine.kind !== 'claude') {
+    return { code: 1, stdout: '', stderr: 'tm: tm send: --pane-quiet is not supported for codex teammates\n' }
+  }
+
+  const req: SendRequest = {
+    name: args.name,
+    prompt: args.prompt,
+    timeoutMs: args.timeoutMs,
+    paneQuiet: args.paneQuiet,
+  }
+  return formatTurn(await engine.send(req, ctx.engineContext))
+}