@phnx-labs/agents-cli 1.20.33 → 1.20.35

package/dist/lib/session/parse.js

@@ -96,6 +96,9 @@ export function parseSession(filePath, agent) {
         case 'gemini':
             events = parseGemini(filePath);
             break;
+        case 'antigravity':
+            events = parseAntigravity(filePath);
+            break;
         case 'opencode':
             events = parseOpenCode(filePath);
             break;
@@ -131,6 +134,12 @@ export function detectAgent(filePath) {
         return 'claude';
     if (filePath.includes('/.codex/') || filePath.includes('\\.codex\\'))
         return 'codex';
+    // Antigravity lives under ~/.gemini/antigravity-cli/conversations/<uuid>.db, so
+    // it must be matched BEFORE the generic /.gemini/ check below or it would be
+    // misdetected as Gemini.
+    if ((filePath.includes('/antigravity-cli/conversations/') || filePath.includes('\\antigravity-cli\\conversations\\'))
+        && filePath.endsWith('.db'))
+        return 'antigravity';
     if (filePath.includes('/.gemini/') || filePath.includes('\\.gemini\\'))
         return 'gemini';
     if (filePath.includes('/.grok/') || filePath.includes('\\.grok\\'))
@@ -178,6 +187,11 @@ export function summarizeToolUse(tool, args) {
         case 'WebSearch':
         case 'WebFetch':
             return `${tool}: ${truncate(args.query || args.url || '', 80)}`;
+        // Codex plan tool: arrives as a function_call with {plan:[{step,status}]}.
+        case 'update_plan': {
+            const steps = Array.isArray(args.plan) ? args.plan.length : 0;
+            return `Plan: ${steps} step${steps === 1 ? '' : 's'}`;
+        }
         // Codex tools
         case 'exec_command':
             return `Bash: ${truncate(String(args.command || args.cmd || '').replace(/\n/g, ' ').trim(), 120)}`;
@@ -418,6 +432,16 @@ export function parseClaudeContent(content) {
 export function parseCodex(filePath) {
     return parseCodexContent(safeReadSessionFile(filePath));
 }
+/**
+ * Extract the target file path from a Codex apply_patch envelope. The patch body
+ * opens with `*** Begin Patch` and carries one or more file ops of the form
+ * `*** Update File: <path>` / `*** Add File: <path>` / `*** Delete File: <path>`.
+ * Returns the first file path found, or undefined for an unparseable body.
+ */
+function applyPatchTargetPath(input) {
+    const m = input.match(/^\*\*\* (?:Update|Add|Delete) File: (.+)$/m);
+    return m ? m[1].trim() : undefined;
+}
 /**
  * Parse Codex JSONL *content* (already read into a string) into normalized
  * events. Split from `parseCodex` so the tail reader can parse just the last
@@ -449,6 +473,23 @@ export function parseCodexContent(content) {
             });
             continue;
         }
+        if (lineType === 'event_msg') {
+            // Web search is reported out-of-band as event_msg (not response_item).
+            // The paired begin (`web_search_call`) has no query; only `web_search_end`
+            // carries the resolved query string, so we emit exactly one tool_use per
+            // search off the end event and ignore the begin to avoid duplicates.
+            if (payload.type === 'web_search_end') {
+                const query = typeof payload.query === 'string' ? payload.query : '';
+                events.push({
+                    type: 'tool_use',
+                    agent: 'codex',
+                    timestamp,
+                    tool: 'WebSearch',
+                    args: { query },
+                });
+            }
+            continue;
+        }
         if (lineType === 'response_item') {
             const ptype = payload.type;
             if (ptype === 'message') {
@@ -523,6 +564,45 @@ export function parseCodexContent(content) {
                 if (callId)
                     callMap.delete(callId);
             }
+            else if (ptype === 'custom_tool_call') {
+                // Codex edits arrive as custom_tool_call (apply_patch), NOT function_call.
+                const rawName = payload.name || 'unknown';
+                const input = typeof payload.input === 'string' ? payload.input : '';
+                const isApplyPatch = rawName === 'apply_patch';
+                const patchPath = isApplyPatch ? applyPatchTargetPath(input) : undefined;
+                // Normalize apply_patch to the shared Edit tool so it flows through
+                // artifact discovery (WRITE_TOOLS) and the Edit summarizer.
+                const tool = isApplyPatch ? 'Edit' : rawName;
+                const args = { input: input.length > 500 ? input.slice(0, 497) + '...' : input };
+                if (patchPath)
+                    args.file_path = patchPath;
+                const callId = payload.call_id || payload.id;
+                if (callId)
+                    callMap.set(callId, { name: tool, args });
+                events.push({
+                    type: 'tool_use',
+                    agent: 'codex',
+                    timestamp,
+                    tool,
+                    args,
+                    path: patchPath,
+                });
+            }
+            else if (ptype === 'custom_tool_call_output') {
+                const callId = payload.call_id || payload.id;
+                const callInfo = callId ? callMap.get(callId) : undefined;
+                const output = String(payload.output || '');
+                events.push({
+                    type: 'tool_result',
+                    agent: 'codex',
+                    timestamp,
+                    tool: callInfo?.name,
+                    success: true,
+                    output: output.length > 500 ? output.slice(0, 497) + '...' : output,
+                });
+                if (callId)
+                    callMap.delete(callId);
+            }
             else if (ptype === 'reasoning') {
                 // Codex reasoning -- try to get the readable summary
                 const summaries = payload.summary || [];
@@ -670,6 +750,204 @@ function extractGeminiContent(content) {
     }
     return '';
 }
+/** Read a base-128 varint from `b` at offset `i`; returns [value, nextOffset]. */
+function readVarint(b, i) {
+    let shift = 0;
+    let val = 0;
+    for (;;) {
+        const byte = b[i++];
+        val += (byte & 0x7f) * 2 ** shift;
+        if ((byte & 0x80) === 0)
+            break;
+        shift += 7;
+    }
+    return [val, i];
+}
+/** Decode a protobuf message into a flat list of fields (one nesting level). */
+function decodeProtoMessage(b) {
+    const out = [];
+    let i = 0;
+    while (i < b.length) {
+        let tag;
+        [tag, i] = readVarint(b, i);
+        const field = tag >>> 3;
+        const wire = tag & 7;
+        if (wire === 0) {
+            let v;
+            [v, i] = readVarint(b, i);
+            out.push({ field, wire, value: v });
+        }
+        else if (wire === 2) {
+            let len;
+            [len, i] = readVarint(b, i);
+            out.push({ field, wire, value: b.subarray(i, i + len) });
+            i += len;
+        }
+        else if (wire === 5) {
+            i += 4; // fixed32 — skipped
+            out.push({ field, wire, value: 0 });
+        }
+        else if (wire === 1) {
+            i += 8; // fixed64 — skipped
+            out.push({ field, wire, value: 0 });
+        }
+        else {
+            break; // unknown wire type — stop to avoid runaway reads
+        }
+    }
+    return out;
+}
+const ANTIGRAVITY_TEXT_DECODER = new TextDecoder('utf-8', { fatal: false });
+/**
+ * Recursively locate the tool-call node: the first sub-message that carries an
+ * f2 string tool-name AND an f3 JSON-args string. Also captures the f1 call id
+ * (used to dedupe the request + completion steps) and the f30/f31 human labels.
+ */
+function findAntigravityToolCall(fields) {
+    let id;
+    let name;
+    let argsJson;
+    let summary;
+    let action;
+    const subs = [];
+    for (const f of fields) {
+        if (f.wire !== 2)
+            continue;
+        const bytes = f.value;
+        const s = ANTIGRAVITY_TEXT_DECODER.decode(bytes);
+        if (f.field === 1 && !id && /^[a-z0-9]{4,16}$/.test(s))
+            id = s;
+        else if (f.field === 2 && !name && /^[a-z][a-z_]{2,30}$/.test(s))
+            name = s;
+        else if (f.field === 3 && !argsJson && s.startsWith('{') && s.includes('"toolAction"'))
+            argsJson = s;
+        else if (f.field === 30 && !summary)
+            summary = s;
+        else if (f.field === 31 && !action)
+            action = s;
+        else {
+            try {
+                subs.push(decodeProtoMessage(bytes));
+            }
+            catch {
+                /* not a nested message */
+            }
+        }
+    }
+    if (name && argsJson) {
+        let args = {};
+        try {
+            args = JSON.parse(argsJson);
+        }
+        catch {
+            args = { _raw: argsJson };
+        }
+        return { id, name, args, summary, action };
+    }
+    for (const sub of subs) {
+        const hit = findAntigravityToolCall(sub);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+/**
+ * Map an Antigravity tool name onto the shared normalized vocabulary that the
+ * renderer already handles (so no render.ts changes are needed). Unknown tools
+ * pass through untouched (with their JSON args) so future tools are captured.
+ */
+const ANTIGRAVITY_TOOL_MAP = {
+    run_command: 'Bash',
+    view_file: 'Read',
+    read_file: 'Read',
+    list_dir: 'LS',
+    grep_search: 'Grep',
+    replace_file_content: 'Edit',
+    write_to_file: 'Write',
+    // Web tools surface identically once observed:
+    search_web: 'WebSearch',
+    read_url: 'WebFetch',
+    execute_url: 'WebFetch',
+};
+/**
+ * Parse an Antigravity conversation SQLite DB into normalized tool_use events.
+ * Deduped by the tool-call id so each tool appears once (Antigravity writes a
+ * request step and a completion step that share the id).
+ */
+export function parseAntigravity(dbPath) {
+    let rows;
+    try {
+        rows = execFileSync('sqlite3', ['-separator', '\t', dbPath, 'SELECT idx, step_type, quote(step_payload) FROM steps ORDER BY idx;'], {
+            encoding: 'utf-8',
+            timeout: 10000,
+            maxBuffer: 64 * 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        /* DB not accessible, sqlite3 missing, or query failed */
+        return [];
+    }
+    // Single timestamp for the whole session: the steps table carries no per-step
+    // time column, so fall back to the DB file's mtime for a stable, sortable value.
+    let timestamp = new Date().toISOString();
+    try {
+        timestamp = fs.statSync(dbPath).mtime.toISOString();
+    }
+    catch {
+        /* file vanished between query and stat — keep now() */
+    }
+    const events = [];
+    const seenCallIds = new Set();
+    for (const line of rows.split('\n')) {
+        if (!line.trim())
+            continue;
+        const tab1 = line.indexOf('\t');
+        if (tab1 === -1)
+            continue;
+        const tab2 = line.indexOf('\t', tab1 + 1);
+        if (tab2 === -1)
+            continue;
+        const hex = line.slice(tab2 + 1).trim();
+        // sqlite3 quote() renders a BLOB as X'...'; anything else (NULL) is skipped.
+        if (!hex.startsWith("X'") || !hex.endsWith("'"))
+            continue;
+        const bytes = Uint8Array.from(Buffer.from(hex.slice(2, -1), 'hex'));
+        let fields;
+        try {
+            fields = decodeProtoMessage(bytes);
+        }
+        catch {
+            continue;
+        }
+        const call = findAntigravityToolCall(fields);
+        if (!call)
+            continue;
+        // Dedupe: the request + completion steps of one tool share the f1 call id.
+        if (call.id) {
+            if (seenCallIds.has(call.id))
+                continue;
+            seenCallIds.add(call.id);
+        }
+        const norm = ANTIGRAVITY_TOOL_MAP[call.name] || call.name;
+        const a = call.args || {};
+        events.push({
+            type: 'tool_use',
+            agent: 'antigravity',
+            timestamp,
+            tool: norm,
+            args: a,
+            command: norm === 'Bash' ? a.CommandLine : undefined,
+            // Antigravity uses PascalCase arg keys; probe the known path-bearing ones.
+            path: a.AbsolutePath || a.TargetFile || a.DirectoryPath || a.SearchPath || undefined,
+            // Antigravity's own short human label — free, high quality. It surfaces
+            // either as the f30 string or (more reliably) as `toolSummary` inside the
+            // f3 JSON args.
+            content: call.summary || (typeof a.toolSummary === 'string' ? a.toolSummary : undefined) || undefined,
+        });
+    }
+    return events;
+}
 // ---------------------------------------------------------------------------
 // OpenCode parser
 // ---------------------------------------------------------------------------
@@ -1086,7 +1364,10 @@ export function parseKimi(filePath) {
                 const fn = event.function || {};
                 const toolName = typeof event.name === 'string' ? event.name : (fn.name || 'unknown');
                 let args = {};
-                if (typeof fn.arguments === 'string') {
+                if (event.args && typeof event.args === 'object') {
+                    args = event.args;
+                }
+                else if (typeof fn.arguments === 'string') {
                     try {
                         args = JSON.parse(fn.arguments);
                     }
@@ -1212,7 +1493,7 @@ export function parseDroid(filePath) {
                     tool: toolName,
                     args: toolInput,
                     path: toolInput.file_path || toolInput.path || undefined,
-                    command: toolName === 'Bash' ? toolInput.command : undefined,
+                    command: (toolName === 'Bash' || toolName === 'Execute') ? toolInput.command : undefined,
                 });
             }
             else if (block.type === 'tool_result') {

package/dist/lib/session/pid-registry.d.ts

@@ -0,0 +1,21 @@
+export interface PidSessionEntry {
+    pid: number;
+    agent: string;
+    /** The launch session id. Present for agents launched with a known id (Claude). */
+    sessionId?: string;
+    cwd?: string;
+    /**
+     * `$TMUX_PANE` at launch — stored for diagnostics and possible future
+     * disambiguation. NOT currently consulted on read: the listing path keys
+     * purely on pid (stale entries are pruned when the pid dies), so this is
+     * metadata, not an anti-collision key.
+     */
+    tmuxPane?: string;
+    startedAtMs: number;
+}
+/** Record a launched agent process. Never throws — the registry is an optimization. */
+export declare function writePidSessionEntry(entry: PidSessionEntry): void;
+/** Look up a live pid's recorded session. Returns undefined if absent/corrupt. */
+export declare function readPidSessionEntry(pid: number): PidSessionEntry | undefined;
+/** Remove entries whose pid is no longer alive. Best-effort housekeeping. */
+export declare function prunePidSessionRegistry(isAlive: (pid: number) => boolean): void;

package/dist/lib/session/pid-registry.js

@@ -0,0 +1,80 @@
+/**
+ * Per-PID session registry — the headless equivalent of the swarmify VS Code
+ * extension's `live-terminals.json`.
+ *
+ * On a machine with no terminal extension (a bare SSH/tmux host), the only way
+ * `ag sessions --active` can attribute a `ps`-discovered agent process to a
+ * session is to guess "newest .jsonl in the cwd" — which collapses N agents
+ * sharing one repo onto a single session (all rows show the same topic/id).
+ *
+ * `ag run` closes that gap by recording, at spawn time, one file per launched
+ * agent process keyed by its OS pid: the exact session id it was launched with
+ * (Claude is started with `--session-id <uuid>`, so the launcher knows it),
+ * plus agent/cwd/tmux pane. The active-sessions headless path reads it back for
+ * an exact pid -> session match instead of a heuristic.
+ *
+ * Best-effort throughout: a failed write or a corrupt file degrades to the old
+ * heuristic, never throws into the launch or the listing path.
+ */
+import fs from 'fs';
+import path from 'path';
+import { getTerminalsDir } from '../state.js';
+function pidRegistryDir() {
+    return path.join(getTerminalsDir(), 'by-pid');
+}
+function entryPath(pid) {
+    return path.join(pidRegistryDir(), `${pid}.json`);
+}
+/** Record a launched agent process. Never throws — the registry is an optimization. */
+export function writePidSessionEntry(entry) {
+    if (!entry.pid || entry.pid < 1)
+        return;
+    try {
+        fs.mkdirSync(pidRegistryDir(), { recursive: true });
+        fs.writeFileSync(entryPath(entry.pid), JSON.stringify(entry), 'utf8');
+    }
+    catch {
+        /* degrade to the newest-jsonl heuristic */
+    }
+}
+/** Look up a live pid's recorded session. Returns undefined if absent/corrupt. */
+export function readPidSessionEntry(pid) {
+    let raw;
+    try {
+        raw = fs.readFileSync(entryPath(pid), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && typeof parsed.pid === 'number') {
+            return parsed;
+        }
+    }
+    catch {
+        /* unparseable */
+    }
+    return undefined;
+}
+/** Remove entries whose pid is no longer alive. Best-effort housekeeping. */
+export function prunePidSessionRegistry(isAlive) {
+    let files;
+    try {
+        files = fs.readdirSync(pidRegistryDir()).filter(f => f.endsWith('.json'));
+    }
+    catch {
+        return;
+    }
+    for (const f of files) {
+        const pid = Number(f.slice(0, -'.json'.length));
+        if (!Number.isInteger(pid) || isAlive(pid))
+            continue;
+        try {
+            fs.unlinkSync(path.join(pidRegistryDir(), f));
+        }
+        catch {
+            /* raced with another writer/pruner */
+        }
+    }
+}

package/dist/lib/session/remote-active.d.ts

@@ -0,0 +1,26 @@
+import type { ActiveSession } from './active.js';
+/**
+ * Recursion guard, passed as an env var (not a CLI flag) so an OLDER remote
+ * `agents` that predates this feature ignores it harmlessly instead of erroring
+ * on an unknown option. A remote new enough to fan out reads it and stays local.
+ */
+export declare const NO_FANOUT_ENV = "AGENTS_SESSIONS_LOCAL";
+/**
+ * Parse a peer's `--active --json` stdout into active sessions, tagging each
+ * with `machine`. Defensive against version skew / partial output: non-JSON or
+ * a non-array yields `[]`, and non-object entries are dropped rather than
+ * throwing. Exported for unit testing without a live tailnet.
+ */
+export declare function parseRemoteActive(stdout: string, machine: string): ActiveSession[];
+export interface RemoteActiveResult {
+    sessions: ActiveSession[];
+    /** How many peer machines we attempted to reach (drives the empty-fleet tip). */
+    deviceCount: number;
+}
+/**
+ * Gather active sessions from other machines. With an explicit `hosts` list
+ * (from `--host`), fan out to exactly those. Otherwise sweep the registered,
+ * online devices from `ag devices`, excluding this machine and any without an
+ * address. Results from all peers run in parallel and are flattened.
+ */
+export declare function gatherRemoteActive(hosts?: string[]): Promise<RemoteActiveResult>;

package/dist/lib/session/remote-active.js

@@ -0,0 +1,141 @@
+/**
+ * Cross-machine fan-out for `agents sessions --active`.
+ *
+ * A single `getActiveSessions()` only sees the local machine. To show the whole
+ * fleet in one view, we run `agents sessions --active --json --local` on each
+ * peer over SSH and merge the parsed results, tagging every row with the machine
+ * it came from so the renderer can bucket by computer.
+ *
+ * Peers are the registered, online devices from `ag devices` (or an explicit
+ * `--host` list). `--local` on the remote invocation is critical: it stops the
+ * peer from fanning out to *its* devices, so the sweep never recurses.
+ *
+ * A dead or slow host is skipped with a stderr note, never fatal — one asleep
+ * laptop must not blank the whole view. SSH runs are async + parallel (a fresh
+ * `spawn`, not the sync `sshExec`) so N peers cost one round-trip, not N.
+ */
+import { spawn } from 'child_process';
+import chalk from 'chalk';
+import { SSH_OPTS, controlOpts, assertValidSshTarget, shellQuote } from '../ssh-exec.js';
+import { sshTargetFor } from '../devices/connect.js';
+import { loadDevices } from '../devices/registry.js';
+import { machineId, normalizeHost } from './sync/config.js';
+/** Per-host SSH budget. Slightly above SSH_OPTS' ConnectTimeout=10 so a
+ * reachable-but-slow remote still answers before we give up. */
+const REMOTE_TIMEOUT_MS = 12_000;
+/**
+ * Recursion guard, passed as an env var (not a CLI flag) so an OLDER remote
+ * `agents` that predates this feature ignores it harmlessly instead of erroring
+ * on an unknown option. A remote new enough to fan out reads it and stays local.
+ */
+export const NO_FANOUT_ENV = 'AGENTS_SESSIONS_LOCAL';
+/** The command run on each peer: answer for itself, as JSON, without recursing. */
+function remoteActiveCommand() {
+    const inner = `${NO_FANOUT_ENV}=1 agents sessions --active --json`;
+    return `bash -lc ${shellQuote(inner)}`;
+}
+/**
+ * Parse a peer's `--active --json` stdout into active sessions, tagging each
+ * with `machine`. Defensive against version skew / partial output: non-JSON or
+ * a non-array yields `[]`, and non-object entries are dropped rather than
+ * throwing. Exported for unit testing without a live tailnet.
+ */
+export function parseRemoteActive(stdout, machine) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const out = [];
+    for (const x of parsed) {
+        if (x && typeof x === 'object' && !Array.isArray(x)) {
+            out.push({ ...x, machine });
+        }
+    }
+    return out;
+}
+/** Run one remote `agents sessions --active --json --local` and capture stdout.
+ * Resolves `{ code: null }` on spawn error or timeout (host treated as dead). */
+function sshCapture(target, remoteCmd, timeoutMs) {
+    assertValidSshTarget(target);
+    return new Promise((resolve) => {
+        const args = [...SSH_OPTS, ...controlOpts(), target, remoteCmd];
+        const child = spawn('ssh', args, { stdio: ['ignore', 'pipe', 'ignore'] });
+        let stdout = '';
+        let settled = false;
+        const done = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code, stdout });
+        };
+        const timer = setTimeout(() => { child.kill('SIGKILL'); done(null); }, timeoutMs);
+        child.stdout.on('data', (d) => { stdout += d.toString(); });
+        child.on('error', () => done(null));
+        child.on('close', (code) => done(code));
+    });
+}
+async function fetchByTarget(target, machine, display) {
+    const { code, stdout } = await sshCapture(target, remoteActiveCommand(), REMOTE_TIMEOUT_MS);
+    if (code !== 0) {
+        process.stderr.write(chalk.gray(`  ${display}: unreachable or no agents CLI — skipped\n`));
+        return [];
+    }
+    return parseRemoteActive(stdout, machine);
+}
+/**
+ * Gather active sessions from other machines. With an explicit `hosts` list
+ * (from `--host`), fan out to exactly those. Otherwise sweep the registered,
+ * online devices from `ag devices`, excluding this machine and any without an
+ * address. Results from all peers run in parallel and are flattened.
+ */
+export async function gatherRemoteActive(hosts) {
+    const self = machineId();
+    const targets = [];
+    if (hosts && hosts.length > 0) {
+        for (const h of hosts) {
+            try {
+                assertValidSshTarget(h);
+            }
+            catch {
+                process.stderr.write(chalk.gray(`  ${h}: not a valid ssh target — skipped\n`));
+                continue;
+            }
+            const bareHost = h.split('@').pop() || h;
+            targets.push({ target: h, machine: normalizeHost(bareHost), name: h });
+        }
+    }
+    else {
+        let reg;
+        try {
+            reg = await loadDevices();
+        }
+        catch {
+            return { sessions: [], deviceCount: 0 };
+        }
+        for (const d of Object.values(reg)) {
+            if (d.tailscale?.online !== true)
+                continue;
+            if (normalizeHost(d.name) === self)
+                continue;
+            // Only machines that can actually run the CLI. iOS/tablet nodes register as
+            // `unknown` platform and can never answer, so skip them rather than burn a
+            // full ConnectTimeout on each.
+            if (d.platform !== 'windows' && d.platform !== 'linux' && d.platform !== 'macos')
+                continue;
+            try {
+                targets.push({ target: sshTargetFor(d), machine: normalizeHost(d.name), name: d.name });
+            }
+            catch {
+                // No address on the profile — nothing to dial; skip silently.
+            }
+        }
+    }
+    const results = await Promise.all(targets.map((t) => fetchByTarget(t.target, t.machine, t.name)));
+    return { sessions: results.flat(), deviceCount: targets.length };
+}

package/dist/lib/session/remote.js

@@ -27,6 +27,7 @@ import { join } from 'path';
 import { createHash } from 'crypto';
 import chalk from 'chalk';
 import { getCacheDir } from '../state.js';
+import { SSH_OPTS, controlOpts } from '../ssh-exec.js';
 import { formatRelativeTime } from './relative-time.js';
 import { terminalWidth } from './width.js';
 /**
@@ -96,11 +97,6 @@ export function buildRemoteCommand(forwardedArgs, columns) {
     const withCols = columns && columns > 0 ? `COLUMNS=${columns} ${inner}` : inner;
     return `bash -lc ${shellQuote(withCols)}`;
 }
-const SSH_OPTS = [
-    '-o', 'BatchMode=yes',
-    '-o', 'StrictHostKeyChecking=accept-new',
-    '-o', 'ConnectTimeout=10',
-];
 /**
  * Classify an ssh `spawnSync` result. ssh(1) reserves exit 255 for its own
  * connection-layer failures (host down, timeout, refused, auth, changed host
@@ -186,7 +182,7 @@ export function runRemoteSessions(hosts, argv = process.argv) {
     for (const host of hosts) {
         if (multi)
             process.stdout.write(chalk.cyan(`\n── ${host} ──\n`));
-        const res = spawnSync('ssh', [...SSH_OPTS, host, remoteCmd], {
+        const res = spawnSync('ssh', [...SSH_OPTS, ...controlOpts(), host, remoteCmd], {
             encoding: 'utf8',
             maxBuffer: 64 * 1024 * 1024,
         });

package/dist/lib/session/render.js

@@ -541,7 +541,7 @@ export function renderSummary(events, cwd) {
                 if (p)
                     filesReadAbs.add(p);
             }
-            else if (['Write', 'Edit', 'write_file', 'edit_file', 'create_file', 'replace', 'patch'].includes(tool)) {
+            else if (['Write', 'Edit', 'Create', 'write_file', 'edit_file', 'create_file', 'replace', 'patch'].includes(tool)) {
                 if (p) {
                     if (p.includes('.claude/plans/') && p.endsWith('.md')) {
                         planFilePath = p;

package/dist/lib/session/sync/config.d.ts

@@ -33,6 +33,14 @@ export declare function loadR2Config(): R2Config;
  * does not re-storm every cycle. `now` is injectable for tests.
  */
 export declare function isSyncConfigured(now?: number): boolean;
+/**
+ * Normalize a raw hostname into a stable device id: first label only,
+ * lowercased, non-alphanumerics collapsed to hyphens. `zion.tail…ts.net` and
+ * `ZION` both become `zion`. The single source for this transform — machineId()
+ * and cross-machine session grouping must agree or the local machine won't
+ * match its own registry key.
+ */
+export declare function normalizeHost(raw: string): string;
 /**
  * This machine's stable, human-readable id, used as its R2 prefix and mirror
  * directory name. Tailnet hostnames (zion, yosemite-s0, mac-mini) are already