omo-ai 5.1.12 → 5.1.14

package/bin/lib/child-process.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process"
 
-// POSIX launchers prefer execve and leave no wrapper. This async fallback remains for Windows,
-// missing/failed execve, and daemon attach, whose adapter still launches a child.
+// POSIX launchers prefer execve and leave no wrapper. This async fallback remains for Windows
+// and missing/failed execve.
 // Signals a terminal or supervisor sends to the launcher, and what the launcher does with each.
 // SIGTERM and SIGHUP reach one process, so the child has to be told. SIGINT is delivered to the
 // whole foreground process group by the tty, so the child already has it and forwarding would

package/bin/lib/daemon-adopt.js

@@ -0,0 +1,125 @@
+import { DAEMON_EXIT } from "./daemon-args.js"
+import { parseArgs } from "./thread-args.js"
+
+/**
+ * `omo daemon adopt <session>`: take a session a host holds into this terminal. The session is found
+ * through the thread address book (it must be alive on an `rpc_host` endpoint), the host hands it
+ * over with senpi `release_session {reason:"takeover"}`, and the caller then resumes it here with
+ * the interactive launch on `--session <path>` (a path; `--resume` is the picker).
+ *
+ * What the release takes out never vanishes: `dropped.deliveries` are gateway rows the new owner's
+ * inbox drain applies again (nothing to do here), and `dropped.user_messages` - the user's queued
+ * input an `--interrupt` took out - become this terminal's first prompts in their queued order, or,
+ * when the release is refused after all, are printed so the user can send them again.
+ */
+
+const USAGE = "usage: omo daemon adopt <session-id|name> [--interrupt] [--force] [--json]"
+
+function refusalMessage(code, errorData, interrupt) {
+  const busy = errorData?.busy?.length ? ` (${errorData.busy.join(", ")})` : ""
+  switch (code) {
+    case "turn_active":
+      return interrupt
+        ? `turn_active: the session is still busy after the interrupt${busy}`
+        : `turn_active: the session is running a turn or owes one${busy}; pass --interrupt to stop it and take the session`
+    case "session_busy":
+      return `session_busy: the host is still working on the session${busy}; retry when it is done`
+    case "attached":
+      return `attached: ${errorData?.attachments ?? "?"} client(s) - a Desktop thread or another client owns it; pass --force to take it anyway`
+    case "host_draining":
+      return "host_draining: the host is shutting down; retry once it has handed its sessions over"
+    case "session_closing":
+      return "session_closing: the host is already closing the session"
+    case "release_unsupported":
+      return "release_unsupported: the host cannot hand this session over (a worker session or one without a file)"
+    case "release_failed":
+      return `release_failed: ${errorData?.detail ?? "the host could not write the hand-over"}`
+    case "unknown_session":
+      return "unknown_session: the host no longer holds the session"
+    default:
+      return `${code}: ${errorData?.hint ?? "the host refused the release"}`
+  }
+}
+
+function refusalExit(code) {
+  if (code === "unknown_session" || code === "host_unavailable") return DAEMON_EXIT.notRunning
+  if (code === "release_failed" || code === "internal_error") return DAEMON_EXIT.engineRefused
+  return DAEMON_EXIT.unsupported
+}
+
+function dropped(...replies) {
+  const deliveries = []
+  const userMessages = []
+  for (const reply of replies) {
+    const value = reply?.success === true ? reply.data.dropped : reply?.errorData?.dropped
+    deliveries.push(...(value?.deliveries ?? []))
+    userMessages.push(...(value?.user_messages ?? []).filter((message) => message.trim() !== ""))
+  }
+  return { deliveries, user_messages: userMessages }
+}
+
+/** `release_failed` is re-asked once: a teardown that got far enough answers `unknown_session`, which means the session is released. */
+async function release(sdk, thread, request) {
+  const first = await sdk.release(thread, request)
+  if (first.success || first.error !== "release_failed") return { reply: first, dropped: dropped(first) }
+  const second = await sdk.release(thread, {})
+  if (second.success) return { reply: second, dropped: dropped(first, second) }
+  if (second.error === "unknown_session" && thread.session_path !== null) {
+    return { reply: { success: true, data: { released: true, session_path: thread.session_path, attachments: 0, dropped: dropped(first) } }, dropped: dropped(first) }
+  }
+  return { reply: first, dropped: dropped(first, second) }
+}
+
+/**
+ * @returns an exit code, or `{ launch, cwd }`: the interactive launch arguments that resume the
+ * released session in this terminal, and the directory it runs in.
+ */
+export async function runAdoptCommand(args, { sdk, stdout, stderr }) {
+  // `--json` among the options, before `--`, is read before the parse: a usage error still answers in JSON.
+  const end = args.indexOf("--")
+  const json = (end === -1 ? args : args.slice(0, end)).includes("--json")
+  const outcome = (payload, code) => {
+    if (json) stdout.write(`${JSON.stringify(payload)}\n`)
+    return code
+  }
+  const parsed = parseArgs(args, { booleans: ["--interrupt", "--force", "--json"] })
+  if (parsed.error !== undefined || parsed.positionals.length !== 1) {
+    stderr.write(`omo daemon adopt: ${parsed.error ?? "expects one session"}\n${USAGE}\n`)
+    return outcome({ kind: "refused", error: "usage" }, DAEMON_EXIT.usage)
+  }
+  const interrupt = parsed.flags.has("--interrupt")
+
+  const located = await sdk.locate({ thread: parsed.positionals[0], all_scope: true })
+  if (located.kind !== "ok") {
+    stderr.write(`omo daemon adopt: ${located.error.code}: ${located.error.message}\n`)
+    return outcome({ kind: "refused", error: located.error.code }, located.error.code === "ambiguous_target" ? DAEMON_EXIT.usage : DAEMON_EXIT.notRunning)
+  }
+  const thread = located.thread
+  if (thread.surface === "tui" || thread.endpoint?.kind === "tui") {
+    stderr.write(`omo daemon adopt: ${thread.thread_id} is already a terminal session\n`)
+    return outcome({ kind: "refused", error: "already_terminal", thread_id: thread.thread_id }, DAEMON_EXIT.unsupported)
+  }
+  if (!thread.alive || thread.endpoint === null) {
+    stderr.write(`omo daemon adopt: no running host holds ${thread.thread_id}; resume it with omo --session ${thread.session_path ?? thread.thread_id}\n`)
+    return outcome({ kind: "refused", error: "not_running", thread_id: thread.thread_id }, DAEMON_EXIT.notRunning)
+  }
+
+  const request = { ...(interrupt ? { interrupt: true } : {}), ...(parsed.flags.has("--force") ? { force: true } : {}) }
+  const { reply, dropped: taken } = await release(sdk, thread, request)
+  if (!reply.success) {
+    stderr.write(`omo daemon adopt: ${refusalMessage(reply.error, reply.errorData, interrupt)}\n`)
+    for (const message of taken.user_messages) stderr.write(`  queued message taken out by --interrupt, not delivered: ${message}\n`)
+    return outcome({ kind: "refused", error: reply.error, thread_id: thread.thread_id, dropped: taken }, refusalExit(reply.error))
+  }
+
+  // senpi reads a leading `@` as a file argument even after `--`, so such a message is shown, not replayed.
+  const replayable = taken.user_messages.filter((message) => !message.startsWith("@"))
+  for (const message of taken.user_messages.filter((entry) => entry.startsWith("@"))) stderr.write(`  queued message not replayed (starts with @), send it again: ${message}\n`)
+  const path = reply.data.session_path
+  stderr.write(`omo daemon adopt: ${thread.thread_id} released from ${thread.endpoint.socket}; resuming it here${replayable.length > 0 ? ` with ${replayable.length} queued message(s)` : ""}\n`)
+  // The relaunch carries them as argv, so they are also printed: a launch that fails after the release still leaves them on screen.
+  for (const message of replayable) stderr.write(`  queued message taken out by --interrupt, replayed as a prompt: ${message}\n`)
+  if (taken.deliveries.length > 0) stderr.write(`  ${taken.deliveries.length} gateway deliver${taken.deliveries.length === 1 ? "y returns" : "ies return"} to the session's inbox\n`)
+  outcome({ kind: "released", thread_id: thread.thread_id, session_path: path, attachments: reply.data.attachments, dropped: taken }, DAEMON_EXIT.ok)
+  return { launch: ["--session", path, ...(replayable.length > 0 ? ["--", ...replayable] : [])], cwd: thread.cwd }
+}

package/bin/lib/daemon-args.js

@@ -1,24 +1,8 @@
 /**
- * The `omo daemon` command-line contract: the flags this wrapper consumes, its exit codes, and the
- * small argv helpers `runDaemonCommand` uses. Moved verbatim out of `daemon.js`.
+ * The `omo daemon` command-line contract: its exit codes and the small argv helpers
+ * `runDaemonCommand` uses. Moved verbatim out of `daemon.js`.
  */
 
-/** Flags this wrapper consumes itself; anything else after `attach` belongs to the launch. */
-const DAEMON_FLAGS = new Set([
-  "--json",
-  "--no-upgrade",
-  "--persistent",
-  "--foreground",
-  "--include-workers",
-  "--drain",
-  "--all",
-  "--wait",
-  "--dry-run",
-  "--allow-missing-index",
-  "--prune-store-index",
-])
-const DAEMON_VALUE_FLAGS = new Set(["--store", "--timeout"])
-
 /** A named code per outcome, so a script never has to parse the message to know what happened. */
 export const DAEMON_EXIT = {
   ok: 0,
@@ -35,20 +19,6 @@ export function readTimeoutSeconds(args) {
   return Number.isFinite(value) && value >= 0 ? value : 600
 }
 
-export function attachLaunchArgs(args) {
-  const launchArgs = []
-  for (let index = 1; index < args.length; index += 1) {
-    const argument = args[index]
-    if (DAEMON_FLAGS.has(argument)) continue
-    if (DAEMON_VALUE_FLAGS.has(argument)) {
-      index += 1
-      continue
-    }
-    launchArgs.push(argument)
-  }
-  return launchArgs
-}
-
 export function blockingPause(milliseconds) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds)
 }

package/bin/lib/daemon-operations.js

@@ -38,13 +38,18 @@ export function runStatus({ engine, agentDir, env, json, stdout, stderr, _test }
   return { legacy: false, exitCode: all.result.exitCode, endpoints: all.endpoints }
 }
 
+/** A terminal (`tui`) endpoint is owned by its terminal: no lifecycle command ensures, hands off, drains, stops or waits on it. */
+function operable(endpoint) {
+  return endpoint.endpoint_kind !== "tui"
+}
+
 function liveEndpoints(endpoints) {
-  return endpoints.filter((endpoint) => endpoint.reachable && typeof endpoint.socket === "string")
+  return endpoints.filter((endpoint) => operable(endpoint) && endpoint.reachable && typeof endpoint.socket === "string")
 }
 
 function ownedEndpoints(endpoints) {
   return endpoints.filter((endpoint) => {
-    if (typeof endpoint.socket !== "string") return false
+    if (!operable(endpoint) || typeof endpoint.socket !== "string") return false
     return endpoint.reachable ||
       (endpoint.generations ?? []).some((generation) => generation.alive) ||
       (endpoint.claims_live ?? 0) > 0
@@ -93,6 +98,9 @@ export function runHandoff({ engine, pluginRoot, agentDir, env, policy, config,
   }
   let refused = false
   const commandEnv = hostCommandEnvironment(env, agentDir, config)
+  for (const endpoint of all.endpoints) {
+    if (!operable(endpoint) && typeof endpoint.socket === "string") stdout.write(`${endpoint.socket}: skipped (tui endpoint, owned by its terminal)\n`)
+  }
   for (const endpoint of liveEndpoints(all.endpoints)) {
     const daemon = basename(endpoint.socket) === "rpc.sock"
     const args = daemon

package/bin/lib/daemon-status.js

@@ -26,10 +26,15 @@ export function decorateEndpoints(endpoints, agentDir) {
   })
 }
 
+function isTerminal(endpoint) {
+  return endpoint.endpoint_kind === "tui"
+}
+
 export function aggregateEndpoints(endpoints) {
-  const live = endpoints.filter((endpoint) => endpoint.reachable)
+  const live = endpoints.filter((endpoint) => endpoint.reachable && !isTerminal(endpoint))
   return {
     live: live.length,
+    terminals: endpoints.filter((endpoint) => isTerminal(endpoint) && endpoint.reachable).length,
     shards: live.filter((endpoint) => endpoint.shard?.kind === "p").length,
     threads: live.filter((endpoint) => endpoint.shard?.kind === "i").length,
     sessions: live.reduce((total, endpoint) => total + (endpoint.sessions?.total ?? 0), 0),
@@ -40,6 +45,7 @@ export function aggregateEndpoints(endpoints) {
 }
 
 function endpointKind(endpoint) {
+  if (isTerminal(endpoint)) return "tui"
   if (endpoint.shard?.kind === "p") return "shard"
   if (endpoint.shard?.kind === "i") return "thread"
   if (typeof endpoint.socket === "string" && basename(endpoint.socket) === "rpc.sock") return "daemon"
@@ -89,9 +95,22 @@ function generationLine(generation, endpoint) {
   return `  gen ${generation.generation} (${state}) pid ${metric(generation.pid)} · engine ${generation.engineVersion ?? "?"} · ${sessions} session(s) · rss ${metric(generation.rss_mb)} MB (host ${metric(generation.host_rss_mb)} MB)`
 }
 
+/** A terminal row: `tui <name> pid <n> cwd <path>`, named by its session, else by its socket. */
+function terminalLine(endpoint) {
+  const owner = endpoint.owner ?? {}
+  const socketName = typeof endpoint.socket === "string" ? basename(endpoint.socket, ".sock") : basename(endpoint.dir ?? "unknown")
+  const line = `tui ${owner.session?.name ?? socketName} pid ${metric(owner.pid)} cwd ${owner.cwd ?? "?"}`
+  if (endpoint.alive !== false && endpoint.reachable) return line
+  return `${line}: not responding (${endpoint.reason ?? "unreachable"}; omo daemon gc reaps it once its process is gone)`
+}
+
 export function formatEndpointLines(endpoints) {
   const lines = []
   for (const endpoint of endpoints) {
+    if (isTerminal(endpoint)) {
+      lines.push(terminalLine(endpoint))
+      continue
+    }
     const name = endpointName(endpoint)
     if (!endpoint.reachable) {
       lines.push(`${name}: not running (retained state kept; run omo daemon gc)`)
@@ -104,7 +123,7 @@ export function formatEndpointLines(endpoints) {
   }
   const aggregate = aggregateEndpoints(endpoints)
   lines.push(
-    `hosts: ${aggregate.live} live (${aggregate.shards} shards, ${aggregate.threads} threads) · ${aggregate.sessions} session(s) · rss ${aggregate.rss_mb} MB (host ${aggregate.host_rss_mb} MB) · crashes ${aggregate.crashes} (recorded, newest 50 per endpoint)`,
+    `hosts: ${aggregate.live} live (${aggregate.shards} shards, ${aggregate.threads} threads)${aggregate.terminals > 0 ? ` · ${aggregate.terminals} terminal(s)` : ""} · ${aggregate.sessions} session(s) · rss ${aggregate.rss_mb} MB (host ${aggregate.host_rss_mb} MB) · crashes ${aggregate.crashes} (recorded, newest 50 per endpoint)`,
   )
   return lines
 }

package/bin/lib/daemon.js

@@ -10,7 +10,9 @@ import {
   runStopAll,
 } from "./daemon-operations.js"
 import { runRollbackPrepare } from "./daemon-rollback.js"
-import { attachLaunchArgs, blockingPause, DAEMON_EXIT, readTimeoutSeconds } from "./daemon-args.js"
+import { runAdoptCommand } from "./daemon-adopt.js"
+import { loadThreadSdk } from "./thread.js"
+import { blockingPause, DAEMON_EXIT, readTimeoutSeconds } from "./daemon-args.js"
 import { readDaemonConfig } from "./daemon-config.js"
 
 export { DAEMON_EXIT } from "./daemon-args.js"
@@ -18,7 +20,7 @@ export { daemonReportLines } from "./daemon-doctor-report.js"
 
 /**
  * `omo daemon` - the operator's view of every engine host in one agent dir: the operator daemon on
- * `rpc.sock` (the only endpoint `run` and `attach` ensure), each session's task host (`p-*`), each
+ * `rpc.sock` (the only endpoint `run` ensures), each session's task host (`p-*`), each
  * Desktop thread host (`i-*`), and any other endpoint the engine enumerates. `status`, `gc`,
  * `handoff`, `stop --all` and `rollback-prepare` cover all of them.
  *
@@ -29,15 +31,15 @@ export { daemonReportLines } from "./daemon-doctor-report.js"
  * gets an exit code it can branch on without reading prose.
  */
 
-const SUBCOMMANDS = new Set(["run", "attach", "status", "stop", "handoff", "gc", "rollback-prepare"])
+const SUBCOMMANDS = new Set(["run", "adopt", "status", "stop", "handoff", "gc", "rollback-prepare"])
 /** The subcommands that can bring a host into existence, and therefore need omo's argv source. */
-const NEEDS_SPEC = new Set(["run", "attach", "handoff"])
+const NEEDS_SPEC = new Set(["run", "handoff"])
 
 const USAGE = [
-  "usage: omo daemon <run|attach|status|stop|handoff|gc|rollback-prepare> [options]",
+  "usage: omo daemon <run|adopt|status|stop|handoff|gc|rollback-prepare> [options]",
   "",
   "  run       ensure a daemon is serving this agent dir (start, reuse, or hand off)",
-  "  attach    print the environment a child needs to reach the daemon",
+  "  adopt     take a session a host holds into this terminal (--interrupt, --force)",
   "  status    report who is serving and which sessions exist",
   "  stop      end the daemon; --drain lets in-flight work finish first",
   "  handoff   hand the socket to this build, keeping live sessions",
@@ -63,15 +65,14 @@ function resolvePolicy(args, config) {
 }
 
 /**
- * The engine owns four subcommands - ensure, status, stop, handoff. `run` and `attach` are omo's
- * words for the same ensure: one asks for a daemon, the other asks for a daemon plus the
- * environment to reach it. Mapping them here is what keeps this file from inventing a fifth.
+ * The engine owns four subcommands - ensure, status, stop, handoff. `run` is omo's word for the
+ * ensure. Mapping them here is what keeps this file from inventing a fifth.
  */
-const ENGINE_SUBCOMMAND = { run: "ensure", attach: "ensure", status: "status", stop: "stop", handoff: "handoff" }
+const ENGINE_SUBCOMMAND = { run: "ensure", status: "status", stop: "stop", handoff: "handoff" }
 
 function buildArgs(subcommand, args, { specPath, policy }) {
   const engineArgs = ["host", ENGINE_SUBCOMMAND[subcommand], "--json"]
-  if (subcommand === "run" || subcommand === "attach" || subcommand === "handoff") {
+  if (subcommand === "run" || subcommand === "handoff") {
     engineArgs.push("--launch-spec", specPath, "--policy", policy)
   }
   if (subcommand === "stop" && args.includes("--drain")) engineArgs.push("--drain")
@@ -79,14 +80,6 @@ function buildArgs(subcommand, args, { specPath, policy }) {
   return engineArgs
 }
 
-/** What a child process needs in its environment to reach this daemon rather than start its own. */
-function attachEnv(parsed, agentDir) {
-  return {
-    OMO_ENABLE_SHARED_HOST: "1",
-    OMO_RPC_SOCKET: parsed?.socket ?? join(agentDir, "rpc", "rpc.sock"),
-  }
-}
-
 function summarize(subcommand, parsed, exitCode) {
   if (subcommand === "status") {
     if (exitCode === DAEMON_EXIT.notRunning || parsed === undefined) return "daemon: not running"
@@ -99,6 +92,21 @@ function summarize(subcommand, parsed, exitCode) {
   return `daemon: ${parsed.action ?? subcommand}${pid}`
 }
 
+/** `omo daemon adopt`: the thread SDK finds and releases the session; the result is an exit code or a launch. */
+async function adopt(args, options) {
+  const loaded = await (options.threadSdk ?? loadThreadSdk)({ ...options, cwd: options.cwd ?? process.cwd() })
+  if (loaded.error !== undefined) {
+    options.stderr.write(`omo daemon adopt: ${loaded.error}\n`)
+    return DAEMON_EXIT.unsupported
+  }
+  try {
+    return await runAdoptCommand(args, { sdk: loaded.sdk, stdout: options.stdout, stderr: options.stderr })
+  } finally {
+    // The release already happened; a store that fails to close is logged, never a new outcome.
+    await loaded.sdk.dispose().catch((error) => options.stderr.write(`omo daemon adopt: closing the gateway store failed: ${error instanceof Error ? error.message : String(error)}\n`))
+  }
+}
+
 /**
  * @param args argv after `omo daemon`
  * @param options.engine  something that can run the engine CLI; injected so tests never spawn one
@@ -117,7 +125,9 @@ export function runDaemonCommand(args, options) {
     return DAEMON_EXIT.usage
   }
   if (!SUBCOMMANDS.has(subcommand)) {
-    stderr.write(`omo daemon: unknown subcommand '${subcommand}'\n${USAGE}\n`)
+    // Scripts written for the removed shared-host join get a pointer to what replaced it.
+    const removed = subcommand === "attach" ? "omo daemon: 'attach' was removed; to continue a host session in this terminal, run omo daemon adopt <session>\n" : ""
+    stderr.write(`omo daemon: unknown subcommand '${subcommand}'\n${removed}${USAGE}\n`)
     return DAEMON_EXIT.usage
   }
   // A named pipe is per-process on win32: there is no socket for a second client to attach to,
@@ -133,6 +143,8 @@ export function runDaemonCommand(args, options) {
 
   // Only the subcommands that may START something need the spec; asking who is serving, or
   // asking it to stop, must still work on an install whose plugin payload was never built.
+  if (subcommand === "adopt") return adopt(args.slice(1), options)
+
   const specPath = join(pluginRoot, "daemon-launch-spec.json")
   if (NEEDS_SPEC.has(subcommand) && !existsSync(specPath)) {
     stderr.write(`omo daemon: launch spec missing at ${specPath}\n`)
@@ -219,19 +231,6 @@ export function runDaemonCommand(args, options) {
 
   if (result.stderr) stderr.write(result.stderr)
 
-  if (subcommand === "attach") {
-    if (result.exitCode !== DAEMON_EXIT.ok) return result.exitCode
-    const daemonEnv = attachEnv(parsed, agentDir)
-    // `omo daemon attach --model x`: the trailing args are a normal omo launch that should run
-    // against the daemon, so the caller gets the merged environment back and continues with them.
-    const launchArgs = attachLaunchArgs(args)
-    if (launchArgs.length > 0) return { passthrough: true, args: launchArgs, env: { ...env, ...daemonEnv } }
-    const payload = { ...(parsed ?? {}), env: daemonEnv }
-    if (args.includes("--json")) stdout.write(`${JSON.stringify(payload)}\n`)
-    else for (const [key, value] of Object.entries(daemonEnv)) stdout.write(`${key}=${value}\n`)
-    return DAEMON_EXIT.ok
-  }
-
   if (args.includes("--json") && result.stdout) stdout.write(result.stdout.trim() + "\n")
   else stdout.write(`${summarize(subcommand, parsed, result.exitCode)}\n`)
   return result.exitCode

package/bin/lib/host-status.js

@@ -0,0 +1,59 @@
+import { join } from "node:path"
+import { pathToFileURL } from "node:url"
+
+/**
+ * `omo host status --all`: the engine's inventory line, with `last_activity_at` added to every
+ * terminal (`endpoint_kind: "tui"`) row. The value is the newest entry timestamp of the row's session
+ * file (`owner.session.path`), read by the thread SDK's `readSessionFacts` - the value `omo thread
+ * list` shows as `updated_at` when the endpoint reports none - and `null` when the row names no
+ * session or the bounded reader cannot prove the final complete entry's timestamp. Every other
+ * field, row and the exit code are the engine's.
+ */
+
+/** Set on the engine call the compiled binary makes by re-running itself, so that call is not enriched again. */
+export const HOST_STATUS_RAW_ENV = "OMO_HOST_STATUS_RAW"
+
+export function isHostStatusAll(args, env) {
+  return args[0] === "host" && args[1] === "status" && args.includes("--all") && env[HOST_STATUS_RAW_ENV] !== "1"
+}
+
+export async function sessionActivityReader(pluginRoot) {
+  let module
+  try {
+    module = await import(pathToFileURL(join(pluginRoot, "runtime", "thread-sdk", "sdk.js")).href)
+  } catch {
+    return () => null
+  }
+  if (typeof module.readSessionFacts !== "function") return () => null
+  return (path) => module.readSessionFacts(path)?.updated_at ?? null
+}
+
+function withLastActivity(payload, readActivity) {
+  return {
+    ...payload,
+    endpoints: payload.endpoints.map((row) => {
+      if (row === null || typeof row !== "object" || row.endpoint_kind !== "tui") return row
+      const path = row.owner?.session?.path
+      return { ...row, last_activity_at: typeof path === "string" ? readActivity(path) : null }
+    }),
+  }
+}
+
+function inventory(stdout) {
+  const line = stdout.trim().split("\n").filter((candidate) => candidate.trim() !== "").pop()
+  if (line === undefined) return undefined
+  try {
+    const parsed = JSON.parse(line)
+    return parsed !== null && typeof parsed === "object" && Array.isArray(parsed.endpoints) ? parsed : undefined
+  } catch {
+    return undefined
+  }
+}
+
+export async function runHostStatusAll(args, { engine, env, stdout, stderr, readActivity }) {
+  const result = engine.run(args, { env: { ...env, [HOST_STATUS_RAW_ENV]: "1" } })
+  if (result.stderr !== "") stderr.write(result.stderr)
+  const payload = inventory(result.stdout)
+  stdout.write(payload === undefined ? result.stdout : `${JSON.stringify(withLastActivity(payload, readActivity))}\n`)
+  return result.exitCode
+}

package/bin/lib/launcher.js

@@ -6,6 +6,8 @@ import { doctorCoverageLines } from "./category-coverage.js"
 import { doctorComputerUseLines } from "./computer-use-doctor.js"
 import { doctorConfigLines } from "./config-doctor.js"
 import { runDaemonCommand } from "./daemon.js"
+import { runThreadCommand } from "./thread.js"
+import { isHostStatusAll, runHostStatusAll, sessionActivityReader } from "./host-status.js"
 import { runDoctor } from "./doctor.js"
 import { ensureEnginePrepared, preparePluginLaunchSpec } from "./engine-prepare.js"
 import { migrateLegacyBunGlobalManifest } from "./legacy-bun-global-migration.js"
@@ -231,10 +233,23 @@ export async function runLauncher(args = process.argv.slice(2)) {
     process.exitCode = 2
     return
   }
+  if (command === "thread") {
+    process.exitCode = await runThreadCommand(args.slice(1), {
+      engine: { run: engineHostCall },
+      pluginRoot: join(packageRoot, "plugin"),
+      agentDir: canonicalAgentDir(),
+      env: process.env,
+      cwd: process.cwd(),
+      stdout: process.stdout,
+      stderr: process.stderr,
+      platform: process.platform,
+    })
+    return
+  }
   // The daemon is the engine's to run; omo only supplies the launch spec, the task settings from
   // the omo config (daemon-config.js), and an exit code the caller can branch on.
   if (command === "daemon") {
-    const outcome = runDaemonCommand(args.slice(1), {
+    const outcome = await runDaemonCommand(args.slice(1), {
       engine: { run: engineHostCall },
       migration: { run: rollbackMigrateCall },
       pluginRoot: join(packageRoot, "plugin"),
@@ -244,13 +259,10 @@ export async function runLauncher(args = process.argv.slice(2)) {
       stderr: process.stderr,
       platform: process.platform,
     })
-    // `omo daemon attach <launch args>`: the daemon is reachable, so this becomes a normal launch
-    // whose environment points the engine at the shared socket instead of starting its own.
-    if (typeof outcome === "object") {
-      const senpi = preparedSenpi()
-      await spawnNode(senpi.cliPath, ["--extension", join(packageRoot, "plugin"), ...outcome.args], {
-        env: { ...senpiEnvironment(senpi.packageRoot), ...outcome.env },
-      })
+    // `omo daemon adopt`: the host released the session, so it resumes here as a normal launch, in its own directory.
+    if (typeof outcome === "object" && Array.isArray(outcome.launch)) {
+      if (typeof outcome.cwd === "string" && existsSync(outcome.cwd)) process.chdir(outcome.cwd)
+      await spawnSenpi(outcome.launch, true)
       return
     }
     process.exitCode = outcome
@@ -303,6 +315,17 @@ export async function runLauncher(args = process.argv.slice(2)) {
     await spawnSenpi(args.includes("--no-extensions") ? args : [...args, "--extension", join(packageRoot, "plugin")], false)
     return
   }
+  // `host status --all` stays the engine's answer; omo only adds each terminal row's last activity.
+  if (isHostStatusAll(args, process.env)) {
+    process.exitCode = await runHostStatusAll(args, {
+      engine: { run: engineHostCall },
+      env: process.env,
+      stdout: process.stdout,
+      stderr: process.stderr,
+      readActivity: await sessionActivityReader(join(packageRoot, "plugin")),
+    })
+    return
+  }
   if (earlyCommands.has(command) || command === "update") {
     await spawnSenpi(args, false)
     return

package/bin/lib/provider-map.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "Derived from @code-yeongyu/senpi 2026.10.2 builtinProviders(). builtinProviderIds and oauthProviderIds are the engine registry verbatim; providers maps a source harness id onto the omo provider that serves the same endpoint; oauthLogins maps a source OAuth id onto the omo provider to run /login for. Re-derive all four whenever the senpi pin changes.",
+  "_comment": "Derived from @code-yeongyu/senpi 2026.10.5 builtinProviders(). builtinProviderIds and oauthProviderIds are the engine registry verbatim; providers maps a source harness id onto the omo provider that serves the same endpoint; oauthLogins maps a source OAuth id onto the omo provider to run /login for. Re-derive all four whenever the senpi pin changes.",
   "builtinProviderIds": [
     "alibaba-token-plan",
     "amazon-bedrock",

package/bin/lib/thread-args.js

@@ -0,0 +1,54 @@
+/**
+ * The `omo thread` command-line contract: its exit codes and the one argv parser every subcommand
+ * uses. Exit codes follow `omo daemon` (`daemon-args.js`): 2 usage, 3 nothing answering, 4 not
+ * possible here; a refusal the gateway answered as data is 1 (its `error.code` is in the JSON).
+ */
+
+export const THREAD_EXIT = {
+  ok: 0,
+  refused: 1,
+  usage: 2,
+  unavailable: 3,
+  unsupported: 4,
+  failed: 5,
+}
+
+/**
+ * Splits argv into positionals, boolean flags and value flags. An unknown `--flag`, a value flag
+ * without its value, or a repeated value flag is a usage error; `--` ends flag parsing, so a text
+ * that starts with `-` can still be sent.
+ */
+export function parseArgs(args, { booleans = [], values = [] } = {}) {
+  const flags = new Set()
+  const options = {}
+  const positionals = []
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index]
+    if (argument === "--") {
+      positionals.push(...args.slice(index + 1))
+      break
+    }
+    if (!argument.startsWith("--")) {
+      positionals.push(argument)
+      continue
+    }
+    if (booleans.includes(argument)) {
+      flags.add(argument)
+      continue
+    }
+    if (!values.includes(argument)) return { error: `unknown option '${argument}'` }
+    const value = args[index + 1]
+    if (value === undefined) return { error: `${argument} needs a value` }
+    if (Object.hasOwn(options, argument)) return { error: `${argument} was given twice` }
+    options[argument] = value
+    index += 1
+  }
+  return { flags, options, positionals }
+}
+
+/** A non-negative integer flag value, or undefined when the flag is absent; NaN marks a bad value. */
+export function integerOption(options, name) {
+  const raw = options[name]
+  if (raw === undefined) return undefined
+  return /^\d+$/.test(raw) ? Number(raw) : Number.NaN
+}

package/bin/lib/thread-output.js

@@ -0,0 +1,40 @@
+/**
+ * The human summary `omo thread` prints without `--json`: one line per thread, binding, row or
+ * transcript item. Scripts use `--json`; these lines are for a person and may change.
+ */
+
+function bindingLine(binding) {
+  return `${binding.binding_id} r${binding.revision} ${binding.status} ${binding.platform}:${binding.account_id}/${binding.chat_id}/${binding.thread_id} -> ${binding.session_durable_id}`
+}
+
+function rowLine(row) {
+  const token = row.reply_token === null ? "" : ` (reply token ${row.reply_token})`
+  return `#${row.cursor} ${row.event} [${row.state}] ${row.text}${token}`
+}
+
+const RENDER = {
+  list: (result) =>
+    result.threads.length === 0
+      ? [`no threads in ${result.scope === "all" ? "any workspace" : "this workspace"} (try --all-scope)`]
+      : result.threads.map((thread) => `${thread.thread_id}  ${thread.surface ?? "?"}  ${thread.status}  ${thread.name || "(unnamed)"}  ${thread.cwd}`),
+  send: (result) => [`${result.delivery?.kind ?? "sent"}: delivery ${result.delivery_id} to ${result.thread_id}${result.deduplicated ? " (already sent)" : ""}`],
+  read: (result) => [
+    ...result.items.map((item) => `[${item.role}] ${item.content}`),
+    ...(result.truncated ? [`(truncated; continue with --cursor ${result.next_cursor})`] : []),
+  ],
+  bind: (result) => [`bound ${bindingLine(result.binding)}${result.deduplicated ? " (already bound)" : ""}`],
+  unbind: (result) => [`unbound ${bindingLine(result.binding)}${result.already_closed ? " (already closed)" : ""}`],
+  rebind: (result) => [`rebound ${bindingLine(result.binding)}`],
+  bindings: (result) => [...result.bindings.map(bindingLine), ...(result.next_cursor === null ? [] : [`(more: --cursor ${result.next_cursor})`])],
+  report: (result) => [`reported ${result.event} to ${result.binding_id} at cursor ${result.cursor}${result.reply_token ? ` (reply token ${result.reply_token})` : ""}`],
+  answer: (result) => [`answered through ${result.binding_id} (cursor ${result.cursor})`],
+  outbox: (result) => [
+    ...result.rows.map(rowLine),
+    `next cursor ${result.next_cursor}, acked through ${result.acked === undefined || result.acked === null ? result.acked_cursor : result.acked.acked_cursor}`,
+  ],
+  ack: (result) => [`acked ${result.binding_id} through ${result.acked_cursor}${result.changed ? "" : " (no change)"}`],
+}
+
+export function humanLines(name, result) {
+  return RENDER[name](result)
+}