tomo-ai 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -1,6 +1,31 @@
 # Changelog
 
-## Unreleased
+## 0.8.3 (2026-06-11)
+
+### Features
+
+- **Experimental message steering** (#142). New `steering` config (`TOMO_STEERING=true`, default off) lets user messages that arrive during an in-flight tool-using turn bypass the per-session queue and inject at the next tool-call boundary. If the current turn has no boundary left, the message runs as the next follow-up turn. Cron, continuity, and other system-originated turns continue to queue normally.
+
+### Bug fixes
+
+- **Six high-severity fixes from a codebase review** (#140):
+  - Fresh installs no longer crash on every CLI command (including `tomo init` and `--help`) when no channel is configured — channel validation moved from config load to daemon startup, and `tomo start` now validates before spawning the background child instead of printing "started" while the daemon silently dies.
+  - The iMessage webhook server binds `127.0.0.1` instead of all interfaces and caps request bodies at 1 MB; the webhook is also registered as the literal `127.0.0.1` (BlueBubbles could resolve `localhost` to `::1` and get connection refused), with stale `localhost`-form registrations from earlier versions cleaned up on upgrade.
+  - The cron scheduler no longer re-fires a due job on every 30s poll while a long agent run is still in flight (re-entrancy guard on `tick()`), and tick errors are caught instead of becoming unhandled rejections.
+  - Telegram streaming no longer silently drops content when a send/edit fails: progress is only advanced on success, the final flush retries with backoff, blocks over 4096 chars roll over into a new message, and `send()` chunks long text like iMessage does.
+  - `tomo backup restore` no longer deletes the preserved `.claude` directory along with the workspace tree; the backup's custom skills are merged in without overwriting live ones.
+  - The LCM compact nudge goes through the per-session queue instead of a fire-and-forget run that could overlap the next user message.
+- **Multi-process race and atomic-write fixes** (#141). The daemon and CLI commands (`tomo cron add`, `tomo sessions clear`, `tomo config`, `tomo lcm prune-tools`) mutate the same files and could clobber each other:
+  - `SessionStore` registry mutators and list APIs reload from disk before acting, so CLI-side changes are no longer reverted by the daemon's next stale save.
+  - `CronStore.markRun`/`remove` reload before saving, so a job added while the daemon executes another job is no longer silently deleted.
+  - The MCP OAuth token store, pet store, and SDK session repair now write atomically (temp + rename) — a crash mid-write previously left truncated JSON that could permanently discard every MCP server's refresh token.
+  - `tomo lcm prune-tools` rewrites the live SDK JSONL with the same concurrent-append-safe machinery as compaction, instead of a plain read/write that could truncate events the SDK was appending mid-prune.
+
+### Other
+
+- Raise minimum Node version to 22.12 (#139).
+- Internal cleanup: extracted shared `fs-utils`, `jsonl`, and session-key helpers (#138).
+- Bump `commander` 14.0.3 → 15.0.0 (#123).
 
 ## 0.8.2 (2026-06-08)
 

package/README.md

@@ -31,7 +31,7 @@ That's it. Open Telegram and message your bot.
 
 ## Requirements
 
-- Node.js 22+
+- Node.js 22.12+
 - [Claude Code](https://claude.com/claude-code) installed. Authenticate Claude Code for direct Claude models, or configure a LiteLLM gateway for non-Claude backends.
 - At least one channel:
   - **Telegram** — bot token from [@BotFather](https://t.me/BotFather)
@@ -225,6 +225,7 @@ Run `tomo config` for interactive setup, or edit `~/.tomo/config.json` directly:
   },
   "maxTurns": 50,
   "saveInboundImages": true,
+  "steering": false,
   "continuity": true,
   "continuityScript": {
     "path": "~/bin/tomo-continuity.sh",
@@ -252,6 +253,7 @@ Environment variables override config file values:
 | `TOMO_LITELLM_MODE` | Optional LiteLLM mode: `anthropic-compatible` or `chatgpt-subscription` |
 | `TOMO_WORKSPACE` | Override workspace directory |
 | `TOMO_MAX_TURNS` | Override per-turn tool-use ceiling (default: `50`) |
+| `TOMO_STEERING` | Set `true` to steer mid-turn messages into the in-flight turn (experimental, default: `false`) |
 | `TOMO_CONTINUITY_SCRIPT` | Override the optional continuity script path |
 | `TOMO_CONTINUITY_SCRIPT_TIMEOUT_MS` | Override continuity script timeout (default: `30000`) |
 | `TOMO_CONTINUITY_SCRIPT_MAX_OUTPUT_CHARS` | Override continuity script stdout/stderr cap (default: `8000`) |
@@ -259,6 +261,10 @@ Environment variables override config file values:
 
 `continuityScript` can also be a simple path string, e.g. `"continuityScript": "~/bin/tomo-continuity.sh"`. Relative paths resolve under `~/.tomo`; the script runs once per scheduled heartbeat and manual `tomo continuity` trigger, and its stdout/stderr or failure status is appended to the normal continuity prompt.
 
+### Steering (experimental)
+
+By default, a message you send while Tomo is mid-task waits in a queue until the current turn finishes. With `"steering": true`, messages sent during a long tool-using turn are injected into it at the next tool-call boundary — so "stop", "wait", or extra context reaches the model immediately instead of after the task completes. If the turn has no tool calls left, the message runs as its own follow-up turn right after. iMessage fragment settling still applies before injection; system-originated turns (cron, continuity) keep their normal queued behavior. This relies on the Claude Agent SDK's mid-turn message queue and is off by default.
+
 ### LiteLLM / ChatGPT Subscription Models
 
 Tomo still runs through Claude Agent SDK, but you can point the SDK at a local LiteLLM proxy and select a LiteLLM model name such as `chatgpt/gpt-5.5`. This keeps Tomo's Claude SDK sessions, memory, workspace, MCP tools, and LCM behavior while LiteLLM translates Anthropic `/v1/messages` streaming calls to the ChatGPT subscription backend.

package/defaults/skills/system/CONFIG.md

@@ -49,6 +49,7 @@ Before direct edits, copy `~/.tomo/config.json` to `~/.tomo/config.json.bak`. Ch
     "apiKey": "sk-tomo-local"
   },
   "maxTurns": 50,
+  "steering": false,
   "mcpServers": {
     "github-copilot": {
       "type": "http",
@@ -96,6 +97,7 @@ Before direct edits, copy `~/.tomo/config.json` to `~/.tomo/config.json.bak`. Ch
 | `litellm.baseUrl` | string | Optional LiteLLM proxy base URL, e.g. `http://localhost:4000`. When set, Tomo still uses Claude Agent SDK but sends SDK model calls to the proxy via `ANTHROPIC_BASE_URL`. |
 | `litellm.apiKey` | string | LiteLLM proxy key sent as `ANTHROPIC_API_KEY`. This is the proxy key, not an Anthropic key. For ChatGPT subscription models, LiteLLM owns the OAuth device flow and token storage. |
 | `maxTurns` | number | Max agent turns per single user message (one turn ≈ one tool-use round). Default `50`. Raise if you see "max turns exceeded" on long tool chains. |
+| `steering` | boolean | Experimental. Default `false`. When `true`, user messages that arrive while a turn is in flight bypass the per-session queue and are injected at the next tool-call boundary. If the current turn has no boundary left, the message runs as a follow-up turn. Cron, continuity, and other system-originated turns still queue normally. Also settable with `TOMO_STEERING=true`. |
 | `mcpServers` | object | External MCP servers keyed by server name. Supports stdio (`command`, `args`, `env`), HTTP (`type: "http"`, `url`, `headers`), and SSE (`type: "sse"`, `url`, `headers`). Environment variables like `${HOME}` expand in `url`, `headers`, `env`, and `args`. |
 | `mcpServers.<name>.oauth` | object | Optional harness-managed OAuth for HTTP/SSE MCP servers. Supports `authorizationServer` (optional; omitted = discover from the MCP server), `clientId` (optional if dynamic registration is available), `scopes`, `tokenStoreKey`, `redirectUri`, and `clientName`. Tokens are stored outside agent context in `workspace/secrets/mcp-oauth.json` (`0600`). |
 | `mcpAllowedTools` | string[] | Auto-allowed external MCP tools. If omitted, Tomo defaults to `mcp__<server>__*` for every configured external server. Set this to narrow tool access, e.g. `["mcp__github__list_issues"]`. |
@@ -132,5 +134,5 @@ Start it with `litellm --config ~/litellm-chatgpt.yaml`, then set Tomo's model t
 ## Requirements and overrides
 
 - **At least one channel must be configured** — either `channels.telegram.token` or `channels.imessage.url`. Startup fails otherwise.
-- **Env vars override file values** where they exist: `TELEGRAM_BOT_TOKEN`, `IMESSAGE_URL`, `IMESSAGE_PASSWORD`, `IMESSAGE_WEBHOOK_PORT`, `CLAUDE_MODEL`, `TOMO_LITELLM_BASE_URL`, `TOMO_LITELLM_API_KEY`, `TOMO_LITELLM_MODE`, `TOMO_CITY`, `TOMO_CONTINUITY`, `TOMO_WORKSPACE`, `SESSIONS_DIR`, `HISTORY_LIMIT`, `TOMO_MAX_TURNS`.
+- **Env vars override file values** where they exist: `TELEGRAM_BOT_TOKEN`, `IMESSAGE_URL`, `IMESSAGE_PASSWORD`, `IMESSAGE_WEBHOOK_PORT`, `CLAUDE_MODEL`, `TOMO_LITELLM_BASE_URL`, `TOMO_LITELLM_API_KEY`, `TOMO_LITELLM_MODE`, `TOMO_CITY`, `TOMO_CONTINUITY`, `TOMO_WORKSPACE`, `SESSIONS_DIR`, `HISTORY_LIMIT`, `TOMO_MAX_TURNS`, `TOMO_STEERING`.
 - `workspaceDir`, `sessionsDir`, `historyLimit` are env-only — they're not read from the JSON file.

package/defaults/skills/system/SKILL.md

@@ -72,6 +72,9 @@ Before changing `~/.tomo/config.json` directly, copy the current file to `~/.tom
 ### Streaming
 Responses stream to Telegram in real-time — messages update every 1.5s as tokens arrive.
 
+### Message steering
+If `steering: true` is set in `~/.tomo/config.json`, user messages that arrive during a long tool-using turn are injected into the in-flight turn at the next tool-call boundary instead of waiting behind it. Use this to treat mid-task corrections like "stop", "wait", or added context as immediately relevant. If there is no remaining tool boundary, the message runs as the next follow-up turn. Cron, continuity, and other system-originated turns still queue normally.
+
 ### MEDIA: tag
 To send an image/file to the user, include `MEDIA:/path/to/file.png` in your response. The harness strips it from text and sends the file. Text before/after becomes the caption.
 

package/dist/agent/live-session.d.ts

@@ -15,6 +15,15 @@ export interface MessageRequest {
     resolve: (response: string) => void;
     reject: (err: Error) => void;
 }
+/**
+ * Sentinel resolution for a steered message that merged into the in-flight
+ * turn: that turn's owner request receives (and delivers) the combined
+ * response, so the steered caller gets this empty marker instead. The empty
+ * string is safe as a sentinel only because send()/steer() can never
+ * legitimately resolve with "" — empty turns fall back to "I'm not sure how
+ * to respond to that." in the result handler.
+ */
+export declare const STEER_MERGED = "";
 export interface QueryResult {
     costUsd: number;
     inputTokens: number;
@@ -30,8 +39,13 @@ export interface QueryResult {
 }
 export declare class LiveSession {
     private q;
-    private pendingMessage;
+    private inputQueue;
+    private inputWaiter;
     private currentRequest;
+    private mergedRequests;
+    private pendingSteers;
+    private promotedSteerText;
+    private idleWaiters;
     private parts;
     private streamingText;
     private sessionId;
@@ -45,8 +59,41 @@ export declare class LiveSession {
     private activeStreamBlockTypes;
     constructor(options: ReturnType<typeof sdkOptions>, sessionKey?: string, turnBudget?: TurnBudget);
     private messageGenerator;
+    private pushInput;
     private consumeEvents;
+    /**
+     * Reject the in-flight turn's owner plus any merged/pending steered
+     * requests, clear turn state, and wake idle waiters. No-op when idle.
+     */
+    private failTurn;
+    /** Resolves when no turn is in flight (or the session dies). */
+    waitForIdle(): Promise<void>;
+    private notifyIdle;
+    /**
+     * True while a turn is in flight — including steered messages the CLI may
+     * still run as a follow-up turn after the current one resolves.
+     */
+    isBusy(): boolean;
     private handleEvent;
+    /**
+     * Observability-only path for subagent events (parent_tool_use_id set):
+     * log tool activity so subagent work shows up in the logs, but never touch
+     * turn state (parts/streamingText) or channel-facing callbacks.
+     */
+    private logSubagentEvent;
+    private logToolResults;
+    /**
+     * Steered-message bookkeeping from the CLI's replay events (requires the
+     * --replay-user-messages flag, passed via extraArgs when config.steering
+     * is on; non-replay user events never carry steered text verbatim, so
+     * matching is restricted to isReplay events to avoid false positives).
+     * Two shapes appear:
+     *   - A pending steer's text echoed mid-turn → the CLI injected it into
+     *     the in-flight turn at a tool boundary; fold it into this turn.
+     *   - The promoted steer's own text echoed at its turn's start → the CLI
+     *     batched the remaining queued steers into that promoted turn.
+     */
+    private matchSteerEchoes;
     private logContextUsage;
     send(text: string, onText?: (text: string) => void, images?: Array<{
         data: string;
@@ -56,6 +103,30 @@ export declare class LiveSession {
         mediaType: string;
         filename?: string;
     }>): Promise<string>;
+    /**
+     * Inject a message into the in-flight turn instead of waiting behind it
+     * (config `steering`). The CLI delivers it at the next tool-call boundary;
+     * if the turn has no boundary left, the CLI queues it and runs it as the
+     * next turn. Resolution:
+     *   - merged into the in-flight turn → resolves with STEER_MERGED; the
+     *     turn's owner request streams and resolves the combined response.
+     *   - ran as its own follow-up turn → resolves with that turn's response,
+     *     streamed through the callbacks passed here.
+     * Falls back to a plain send() when no turn is in flight.
+     */
+    steer(text: string, onText?: (text: string) => void, images?: Array<{
+        data: string;
+        mediaType: string;
+    }>, onBlockComplete?: (text: string) => void | Promise<void>, documents?: Array<{
+        data: string;
+        mediaType: string;
+        filename?: string;
+    }>): Promise<string>;
+    /**
+     * Timeout path for a steered request: detach it from whichever slot it
+     * occupies; if it owns the in-flight turn, fail the whole turn.
+     */
+    private dropRequest;
     getSessionId(): string | null;
     isAlive(): boolean;
     close(): void;

package/dist/agent/live-session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live-session.d.ts","sourceRoot":"","sources":["../../src/agent/live-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,cAAc,EAAmB,MAAM,gCAAgC,CAAC;AAEzG,OAAO,EAAmB,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAErF,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,cAAc,CAAC;IACxB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,MAAM,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACvD;AAmDD,qBAAa,WAAW;IACtB,OAAO,CAAC,CAAC,CAAQ;IACjB,OAAO,CAAC,cAAc,CAAgD;IACtE,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,aAAa,CAAM;IAC3B,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,KAAK,CAAQ;IACrB,UAAU,EAAE,WAAW,GAAG,IAAI,CAAQ;IACtC,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,UAAU,CAAyB;IAG3C,OAAO,CAAC,gBAAgB,CAA6B;IACrD,OAAO,CAAC,sBAAsB,CAA6B;gBAE/C,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU;YAOjF,gBAAgB;YAUjB,aAAa;YAeb,WAAW;YAyIX,eAAe;IA6CvB,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,EAC/B,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,EACnD,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACxD,SAAS,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GACxE,OAAO,CAAC,MAAM,CAAC;IA2DlB,YAAY,IAAI,MAAM,GAAG,IAAI;IAI7B,OAAO,IAAI,OAAO;IAIlB,KAAK,IAAI,IAAI;CAId"}
+{"version":3,"file":"live-session.d.ts","sourceRoot":"","sources":["../../src/agent/live-session.ts"],"names":[],"mappings":"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"}

package/dist/agent/live-session.js

@@ -1,6 +1,16 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { log } from "../logger.js";
 import { resetTurnBudget } from "./sdk-options.js";
+/**
+ * Sentinel resolution for a steered message that merged into the in-flight
+ * turn: that turn's owner request receives (and delivers) the combined
+ * response, so the steered caller gets this empty marker instead. The empty
+ * string is safe as a sentinel only because send()/steer() can never
+ * legitimately resolve with "" — empty turns fall back to "I'm not sure how
+ * to respond to that." in the result handler.
+ */
+export const STEER_MERGED = "";
+const TIMEOUT_MS = 10 * 60 * 1000; // 10 minute timeout per send()/steer()
 function summarizeToolResult(content) {
     // Tool results arrive as either a string or an array of content blocks
     // ({type:"text",text:"..."} | {type:"image",...} | etc.). We flatten to a
@@ -49,10 +59,54 @@ function isTextBlock(block) {
 function isToolUseBlock(block) {
     return isObject(block) && block.type === "tool_use" && typeof block.name === "string";
 }
+function buildContentBlocks(text, images, documents) {
+    const content = [];
+    if (images && images.length > 0) {
+        for (const img of images) {
+            content.push({
+                type: "image",
+                source: { type: "base64", media_type: img.mediaType, data: img.data },
+            });
+        }
+    }
+    if (documents && documents.length > 0) {
+        for (const doc of documents) {
+            const block = {
+                type: "document",
+                source: { type: "base64", media_type: doc.mediaType, data: doc.data },
+            };
+            if (doc.filename)
+                block.title = doc.filename;
+            content.push(block);
+        }
+    }
+    content.push({ type: "text", text });
+    return content;
+}
 export class LiveSession {
     q;
-    pendingMessage = null;
+    // Input messages waiting for the SDK to pull them through messageGenerator.
+    // The SDK pumps this eagerly (writes to the CLI as soon as we yield), which
+    // is what lets steer() inject a message while a turn is in flight.
+    inputQueue = [];
+    inputWaiter = null;
+    // The request that owns the in-flight turn: its callbacks receive the
+    // stream and it resolves with the turn's full response.
     currentRequest = null;
+    // Steered requests confirmed merged into the in-flight turn (we saw the CLI
+    // echo their message back mid-turn). Resolved with STEER_MERGED at result.
+    mergedRequests = [];
+    // Steered requests injected but not yet seen in the event stream. If they
+    // miss the in-flight turn's tool boundaries, the CLI queues them and runs
+    // them as the next turn (promoted at result time).
+    pendingSteers = [];
+    // Text of the steered request promoted to own the current turn, if any.
+    // Used to detect the CLI batching the remaining queued steers into that
+    // turn (see matchSteerEchoes).
+    promotedSteerText = null;
+    // send() callers waiting for the session to go idle (steered messages can
+    // keep the session busy past the turn the agent-level queue saw finish).
+    idleWaiters = [];
     parts = [];
     streamingText = "";
     sessionId = null;
@@ -74,13 +128,19 @@ export class LiveSession {
     }
     async *messageGenerator() {
         while (this.alive) {
-            const msg = await new Promise((resolve) => {
-                this.pendingMessage = resolve;
-            });
-            this.pendingMessage = null;
-            yield msg;
+            while (this.inputQueue.length === 0) {
+                if (!this.alive)
+                    return;
+                await new Promise((resolve) => { this.inputWaiter = resolve; });
+                this.inputWaiter = null;
+            }
+            yield this.inputQueue.shift();
         }
     }
+    pushInput(msg) {
+        this.inputQueue.push(msg);
+        this.inputWaiter?.();
+    }
     async consumeEvents() {
         try {
             for await (const event of this.q) {
@@ -88,15 +148,65 @@ export class LiveSession {
             }
         }
         catch (err) {
-            // If there's a pending request, reject it
-            if (this.currentRequest) {
-                this.currentRequest.reject(err instanceof Error ? err : new Error(String(err)));
-                this.currentRequest = null;
-            }
+            this.failTurn(err instanceof Error ? err : new Error(String(err)));
         }
         this.alive = false;
+        this.inputWaiter?.();
+        // Reject anything still in flight so callers fail fast instead of
+        // hanging until their timeout, and wake idle waiters so a queued send()
+        // can observe the dead session.
+        this.failTurn(new Error("Session is closed"));
+    }
+    /**
+     * Reject the in-flight turn's owner plus any merged/pending steered
+     * requests, clear turn state, and wake idle waiters. No-op when idle.
+     */
+    failTurn(err) {
+        const requests = [];
+        if (this.currentRequest)
+            requests.push(this.currentRequest);
+        requests.push(...this.mergedRequests, ...this.pendingSteers.map((e) => e.req));
+        this.currentRequest = null;
+        this.mergedRequests = [];
+        this.pendingSteers = [];
+        this.promotedSteerText = null;
+        for (const r of requests)
+            r.reject(err);
+        this.notifyIdle();
+    }
+    /** Resolves when no turn is in flight (or the session dies). */
+    async waitForIdle() {
+        while (this.alive && this.isBusy()) {
+            await new Promise((resolve) => this.idleWaiters.push(resolve));
+        }
+    }
+    notifyIdle() {
+        const waiters = this.idleWaiters;
+        this.idleWaiters = [];
+        for (const w of waiters)
+            w();
+    }
+    /**
+     * True while a turn is in flight — including steered messages the CLI may
+     * still run as a follow-up turn after the current one resolves.
+     */
+    isBusy() {
+        return this.currentRequest !== null || this.mergedRequests.length > 0 || this.pendingSteers.length > 0;
     }
     async handleEvent(event) {
+        // Events originating inside a subagent (Agent tool) carry
+        // parent_tool_use_id. They must never reach the channel-facing callbacks:
+        // the subagent's interim narration would ship to the user as Tomo's own
+        // words mid-turn, and its text would pollute `parts` (so it could also
+        // surface in the final response — or be silently dropped, depending on
+        // whether a request happened to be in flight when the block arrived).
+        // The subagent's outcome reaches the user when the main agent folds the
+        // Agent tool result into its own reply.
+        const parentToolUseId = event.parent_tool_use_id ?? null;
+        if (parentToolUseId) {
+            this.logSubagentEvent(event);
+            return;
+        }
         const req = this.currentRequest;
         if (event.type === "stream_event") {
             const se = event;
@@ -146,16 +256,11 @@ export class LiveSession {
                 }
             }
         }
+        if (event.type === "user" && event.message?.content && event.isReplay === true) {
+            this.matchSteerEchoes(event.message.content);
+        }
         if (event.type === "user" && event.message?.content && Array.isArray(event.message.content)) {
-            for (const block of event.message.content) {
-                if (block && typeof block === "object" && "type" in block && block.type === "tool_result") {
-                    const tr = block;
-                    const name = tr.tool_use_id ? this.pendingToolNames.get(tr.tool_use_id) : undefined;
-                    if (tr.tool_use_id)
-                        this.pendingToolNames.delete(tr.tool_use_id);
-                    log.info({ tool: name ?? "?", is_error: tr.is_error ?? false }, `result: ${summarizeToolResult(tr.content)}`);
-                }
-            }
+            this.logToolResults(event.message.content, false);
         }
         if (event.type === "system" && event.subtype === "compact_boundary") {
             const compact = event;
@@ -200,7 +305,95 @@ export class LiveSession {
             this.streamingText = "";
             this.activeStreamBlockTypes.clear();
             req?.resolve(response);
+            for (const m of this.mergedRequests)
+                m.resolve(STEER_MERGED);
+            this.mergedRequests = [];
             this.currentRequest = null;
+            this.promotedSteerText = null;
+            if (this.pendingSteers.length > 0) {
+                // Steered messages that missed this turn's tool boundaries were
+                // queued by the CLI and run next. Promote only the FIRST as the
+                // next turn's owner (its callbacks receive the stream); the rest
+                // stay pending — if the CLI batches them into the promoted turn we
+                // detect it via replay echoes (see matchSteerEchoes), otherwise
+                // they're promoted in order by subsequent results.
+                const [first, ...rest] = this.pendingSteers;
+                this.pendingSteers = rest;
+                this.currentRequest = first.req;
+                this.promotedSteerText = first.text;
+            }
+            else {
+                this.notifyIdle();
+            }
+        }
+    }
+    /**
+     * Observability-only path for subagent events (parent_tool_use_id set):
+     * log tool activity so subagent work shows up in the logs, but never touch
+     * turn state (parts/streamingText) or channel-facing callbacks.
+     */
+    logSubagentEvent(event) {
+        if (event.type === "assistant" && event.message?.content) {
+            for (const block of event.message.content) {
+                if (isToolUseBlock(block)) {
+                    if (block.id)
+                        this.pendingToolNames.set(block.id, block.name);
+                    log.info({ tool: block.name, subagent: true }, summarizeToolInput(block.name, block.input));
+                }
+            }
+        }
+        if (event.type === "user" && event.message?.content && Array.isArray(event.message.content)) {
+            this.logToolResults(event.message.content, true);
+        }
+    }
+    logToolResults(content, subagent) {
+        for (const block of content) {
+            if (block && typeof block === "object" && "type" in block && block.type === "tool_result") {
+                const tr = block;
+                const name = tr.tool_use_id ? this.pendingToolNames.get(tr.tool_use_id) : undefined;
+                if (tr.tool_use_id)
+                    this.pendingToolNames.delete(tr.tool_use_id);
+                log.info({ tool: name ?? "?", is_error: tr.is_error ?? false, ...(subagent ? { subagent: true } : {}) }, `result: ${summarizeToolResult(tr.content)}`);
+            }
+        }
+    }
+    /**
+     * Steered-message bookkeeping from the CLI's replay events (requires the
+     * --replay-user-messages flag, passed via extraArgs when config.steering
+     * is on; non-replay user events never carry steered text verbatim, so
+     * matching is restricted to isReplay events to avoid false positives).
+     * Two shapes appear:
+     *   - A pending steer's text echoed mid-turn → the CLI injected it into
+     *     the in-flight turn at a tool boundary; fold it into this turn.
+     *   - The promoted steer's own text echoed at its turn's start → the CLI
+     *     batched the remaining queued steers into that promoted turn.
+     */
+    matchSteerEchoes(content) {
+        if (this.pendingSteers.length === 0)
+            return;
+        const texts = [];
+        if (typeof content === "string") {
+            texts.push(content);
+        }
+        else if (Array.isArray(content)) {
+            for (const block of content) {
+                if (isTextBlock(block))
+                    texts.push(block.text);
+            }
+        }
+        for (const text of texts) {
+            if (this.promotedSteerText !== null && text === this.promotedSteerText) {
+                log.info({ session: this.sessionKey, count: this.pendingSteers.length }, "Queued steered messages batched into the promoted turn");
+                this.mergedRequests.push(...this.pendingSteers.map((e) => e.req));
+                this.pendingSteers = [];
+                return;
+            }
+            const idx = this.pendingSteers.findIndex((e) => e.text === text);
+            if (idx !== -1) {
+                const [entry] = this.pendingSteers.splice(idx, 1);
+                this.mergedRequests.push(entry.req);
+                log.info({ session: this.sessionKey }, "Steered message joined the in-flight turn");
+            }
         }
     }
     async logContextUsage(result, turnCost, totalCost, input, output, cacheRead, cacheCreated) {
@@ -241,37 +434,21 @@ export class LiveSession {
         }, "Run completed (%s)", result.subtype);
     }
     async send(text, onText, images, onBlockComplete, documents) {
+        if (!this.alive)
+            throw new Error("Session is closed");
+        // Steered messages can keep the session busy past the turn that the
+        // agent-level queue serialized against (they may run as a follow-up
+        // turn), so wait for true idleness before dispatching.
+        await this.waitForIdle();
         if (!this.alive)
             throw new Error("Session is closed");
         // Fresh maxTurns budget per user message — warnings fire once per send().
         if (this.turnBudget)
             resetTurnBudget(this.turnBudget);
-        const TIMEOUT_MS = 10 * 60 * 1000; // 10 minute timeout per send()
-        const content = [];
-        if (images && images.length > 0) {
-            for (const img of images) {
-                content.push({
-                    type: "image",
-                    source: { type: "base64", media_type: img.mediaType, data: img.data },
-                });
-            }
-        }
-        if (documents && documents.length > 0) {
-            for (const doc of documents) {
-                const block = {
-                    type: "document",
-                    source: { type: "base64", media_type: doc.mediaType, data: doc.data },
-                };
-                if (doc.filename)
-                    block.title = doc.filename;
-                content.push(block);
-            }
-        }
-        content.push({ type: "text", text });
+        const content = buildContentBlocks(text, images, documents);
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
-                this.currentRequest = null;
-                reject(new Error("Query timed out after 10 minutes"));
+                this.failTurn(new Error("Query timed out after 10 minutes"));
             }, TIMEOUT_MS);
             const wrappedResolve = (val) => { clearTimeout(timer); resolve(val); };
             const wrappedReject = (err) => { clearTimeout(timer); reject(err); };
@@ -285,14 +462,68 @@ export class LiveSession {
             this.parts = [];
             this.streamingText = "";
             this.activeStreamBlockTypes.clear();
-            if (this.pendingMessage && this.currentRequest) {
-                this.pendingMessage(this.currentRequest.message);
-            }
-            else {
-                wrappedReject(new Error("Session not ready to receive messages"));
-            }
+            this.pushInput(this.currentRequest.message);
+        });
+    }
+    /**
+     * Inject a message into the in-flight turn instead of waiting behind it
+     * (config `steering`). The CLI delivers it at the next tool-call boundary;
+     * if the turn has no boundary left, the CLI queues it and runs it as the
+     * next turn. Resolution:
+     *   - merged into the in-flight turn → resolves with STEER_MERGED; the
+     *     turn's owner request streams and resolves the combined response.
+     *   - ran as its own follow-up turn → resolves with that turn's response,
+     *     streamed through the callbacks passed here.
+     * Falls back to a plain send() when no turn is in flight.
+     */
+    async steer(text, onText, images, onBlockComplete, documents) {
+        if (!this.alive)
+            throw new Error("Session is closed");
+        if (!this.isBusy())
+            return this.send(text, onText, images, onBlockComplete, documents);
+        // New instructions arrived — refresh the turn budget like any user message.
+        if (this.turnBudget)
+            resetTurnBudget(this.turnBudget);
+        const content = buildContentBlocks(text, images, documents);
+        return new Promise((resolve, reject) => {
+            let req = null;
+            const timer = setTimeout(() => {
+                if (req)
+                    this.dropRequest(req, new Error("Query timed out after 10 minutes"));
+            }, TIMEOUT_MS);
+            req = {
+                // priority "next" is the CLI's default for queued commands; set it
+                // explicitly so mid-turn injection (drained at tool boundaries via
+                // getCommandsByMaxPriority("next")) doesn't depend on the default.
+                message: { type: "user", message: { role: "user", content: content }, parent_tool_use_id: null, priority: "next" },
+                onText,
+                onBlockComplete,
+                resolve: (val) => { clearTimeout(timer); resolve(val); },
+                reject: (err) => { clearTimeout(timer); reject(err); },
+            };
+            this.pendingSteers.push({ req, text });
+            this.pushInput(req.message);
         });
     }
+    /**
+     * Timeout path for a steered request: detach it from whichever slot it
+     * occupies; if it owns the in-flight turn, fail the whole turn.
+     */
+    dropRequest(req, err) {
+        if (this.currentRequest === req) {
+            this.failTurn(err);
+            return;
+        }
+        const mi = this.mergedRequests.indexOf(req);
+        if (mi !== -1)
+            this.mergedRequests.splice(mi, 1);
+        const si = this.pendingSteers.findIndex((e) => e.req === req);
+        if (si !== -1)
+            this.pendingSteers.splice(si, 1);
+        req.reject(err);
+        if (!this.isBusy())
+            this.notifyIdle();
+    }
     getSessionId() {
         return this.sessionId;
     }
@@ -301,6 +532,7 @@ export class LiveSession {
     }
     close() {
         this.alive = false;
+        this.inputWaiter?.();
         this.q.close();
     }
 }