@code-yeongyu/senpi 2026.11.6-1 → 2026.11.6-2

package/dist/core/extensions/builtin/goal/stop-pause.js

@@ -4,6 +4,11 @@ export function stopHoldLive(ctx) {
     return (ctx.getPauseState?.().holds.some((hold) => hold.kind === "session_hold" && hold.key !== "interrupted-run") ===
         true);
 }
+/** The session reopened over a run that never finished: its process died mid-turn (senpi#4683, senpi#5755). */
+export function interruptedRunHeld(ctx) {
+    return (ctx.getPauseState?.().holds.some((hold) => hold.kind === "session_hold" && hold.key === "interrupted-run") ===
+        true);
+}
 export function markStopPaused(pi, goalId) {
     pi.appendEntry(GOAL_STOP_PAUSED_ENTRY, { goalId });
 }

package/dist/core/extensions/builtin/herdr/herdr-state.d.ts

@@ -1,3 +1,4 @@
+import type { TerminalMonitorStateEvent } from "../monitor-state-event.ts";
 /** How the user must act on a block, as OSC 7501 names it: a permission approval or a typed answer. */
 export type HerdrBlockedKind = "permission" | "question";
 export interface HerdrBlock {
@@ -9,6 +10,8 @@ export interface HerdrState {
     readonly turnActive: boolean;
     readonly childCount: number;
     readonly monitorCount: number;
+    /** Live monitors with no deadline (persistent watches, or watches without a timeout): they may never fire. */
+    readonly openEndedMonitorCount: number;
     readonly wakeSources: ReadonlyMap<string, number>;
 }
 export type HerdrStateEvent = {
@@ -26,6 +29,7 @@ export type HerdrStateEvent = {
 } | {
     type: "monitors";
     count: number;
+    openEnded: number;
 } | {
     type: "wake-source";
     source: string;
@@ -35,6 +39,12 @@ export interface HerdrReport {
     state: "blocked" | "working" | "idle";
     message?: string;
 }
+/**
+ * How many of the broadcast watches have no deadline: a persistent watch, or one with no timeout. A one-shot watch
+ * with a deadline either fires or times out, and both wake the session, so it is bounded. A payload without per-watch
+ * detail counts none as open-ended, keeping the pane working as before the split.
+ */
+export declare function openEndedMonitors(event: TerminalMonitorStateEvent): number;
 export declare function initialHerdrState(): HerdrState;
 export declare function reduceHerdrState(state: HerdrState, event: HerdrStateEvent): HerdrState;
 export declare function selectHerdrReport(state: HerdrState): HerdrReport;

package/dist/core/extensions/builtin/herdr/herdr-state.js

@@ -1,5 +1,20 @@
 /** Wake sources whose work is already reported through a dedicated field or the blocked state. */
 const REPRESENTED_WAKE_SOURCES = new Set(["terminal-monitors", "senpi-task", "ask-user"]);
+/**
+ * Wake sources that may stay live with no end in sight (a server left running). Once the turn has ended they are named
+ * in the message of an idle report instead of keeping the pane working forever; every other source is bounded work
+ * that will start a turn and keeps the pane working (#6150). Monitors are split per watch by `openEndedMonitors`.
+ */
+const OPEN_ENDED_WAKE_SOURCES = new Set(["terminal-background-sessions"]);
+/**
+ * How many of the broadcast watches have no deadline: a persistent watch, or one with no timeout. A one-shot watch
+ * with a deadline either fires or times out, and both wake the session, so it is bounded. A payload without per-watch
+ * detail counts none as open-ended, keeping the pane working as before the split.
+ */
+export function openEndedMonitors(event) {
+    return (event.monitors ?? []).filter((watch) => watch.persistent === true || typeof watch.deadlineMs !== "number")
+        .length;
+}
 const WAKE_SOURCE_LABELS = {
     "terminal-background-sessions": ["background session", "background sessions"],
     "senpi-codemode": ["detached eval cell", "detached eval cells"],
@@ -7,7 +22,14 @@ const WAKE_SOURCE_LABELS = {
     "loop-guard-hard-stop": ["loop-guard recovery pending", "loop-guard recoveries pending"],
 };
 export function initialHerdrState() {
-    return { blocked: new Map(), turnActive: false, childCount: 0, monitorCount: 0, wakeSources: new Map() };
+    return {
+        blocked: new Map(),
+        turnActive: false,
+        childCount: 0,
+        monitorCount: 0,
+        openEndedMonitorCount: 0,
+        wakeSources: new Map(),
+    };
 }
 export function reduceHerdrState(state, event) {
     switch (event.type) {
@@ -16,7 +38,7 @@ export function reduceHerdrState(state, event) {
         case "children":
             return { ...state, childCount: event.count };
         case "monitors":
-            return { ...state, monitorCount: event.count };
+            return { ...state, monitorCount: event.count, openEndedMonitorCount: Math.min(event.openEnded, event.count) };
         case "wake-source": {
             if ((state.wakeSources.get(event.source) ?? 0) === event.count)
                 return state;
@@ -43,20 +65,26 @@ export function selectHerdrReport(state) {
     if (state.blocked.size > 0)
         return { state: "blocked", message: state.blocked.values().next().value?.label };
     const parts = [];
+    let bounded = false;
     const childCount = Math.max(state.childCount, state.wakeSources.get("senpi-task") ?? 0);
-    if (childCount > 0)
+    if (childCount > 0) {
         parts.push(`${childCount} subagent${childCount === 1 ? "" : "s"} running`);
+        bounded = true;
+    }
     if (state.monitorCount > 0)
         parts.push(`${state.monitorCount} monitor${state.monitorCount === 1 ? "" : "s"} live`);
+    if (state.monitorCount > state.openEndedMonitorCount)
+        bounded = true;
     for (const [source, count] of [...state.wakeSources].sort(([left], [right]) => left.localeCompare(right))) {
         if (REPRESENTED_WAKE_SOURCES.has(source))
             continue;
         const label = WAKE_SOURCE_LABELS[source];
         parts.push(label === undefined ? `${count} ${source}` : `${count} ${count === 1 ? label[0] : label[1]}`);
+        if (!OPEN_ENDED_WAKE_SOURCES.has(source))
+            bounded = true;
     }
-    return state.turnActive || parts.length > 0
-        ? { state: "working", message: parts.length > 0 ? parts.join(" + ") : undefined }
-        : { state: "idle" };
+    const reported = state.turnActive || bounded ? "working" : "idle";
+    return parts.length > 0 ? { state: reported, message: parts.join(" + ") } : { state: reported };
 }
 /** The kind of the block the report shows, the oldest open one, matching `selectHerdrReport`'s message. */
 export function selectHerdrBlockedKind(state) {

package/dist/core/extensions/builtin/herdr/index.js

@@ -5,7 +5,7 @@ import { debuglog } from "node:util";
 import { APP_COMMAND } from "../../../../config.js";
 import { isTerminalMonitorStateEvent, isWakeSourceStateEvent, TERMINAL_MONITOR_STATE_EVENT, WAKE_SOURCE_STATE_EVENT, } from "../monitor-state-event.js";
 import { HerdrClient } from "./herdr-client.js";
-import { initialHerdrState, isHerdrBlockedEvent, reduceHerdrState, selectHerdrBlockedKind, selectHerdrReport, } from "./herdr-state.js";
+import { initialHerdrState, isHerdrBlockedEvent, openEndedMonitors, reduceHerdrState, selectHerdrBlockedKind, selectHerdrReport, } from "./herdr-state.js";
 /**
  * Herdr keys prompt delivery and session restore on agent labels it knows, so the protocol agent stays `pi`.
  * The product command (`omo`, `senpi`, `pi`) travels in this display-only pane token instead (omo#12395).
@@ -130,7 +130,11 @@ export function createHerdrExtension(deps) {
             subscriptions.push(pi.events.on(TERMINAL_MONITOR_STATE_EVENT, (data) => {
                 if (stopped || !isTerminalMonitorStateEvent(data))
                     return;
-                state = reduceHerdrState(state, { type: "monitors", count: data.activeCount });
+                state = reduceHerdrState(state, {
+                    type: "monitors",
+                    count: data.activeCount,
+                    openEnded: openEndedMonitors(data),
+                });
                 return publish();
             }));
             subscriptions.push(pi.events.on(WAKE_SOURCE_STATE_EVENT, (data) => {

package/dist/core/extensions/builtin/mcp/service.d.ts

@@ -76,7 +76,12 @@ export declare class McpService {
     isDisposed(): boolean;
     getConnection(name: string): ServerConnection | undefined;
     reconnectServer(name: string): Promise<void>;
-    getServerSnapshots(): McpServerSnapshot[];
+    /**
+     * The lifecycle-only server snapshots. Without a session id these still list the merged config of all live
+     * sessions, as the /mcp command and the manager TUI expect. With one, only the servers that session declares
+     * (senpi#3001): a caller that can name its session gets no peer data.
+     */
+    getServerSnapshots(sessionId?: string): McpServerSnapshot[];
     getLogLines(name: string, maxLines: number): string[];
     getServerExposureStatus(name: string): Promise<McpServerExposureStatus>;
     recordCall(name: string, elapsedMs: number, failed: boolean): void;
@@ -85,6 +90,9 @@ export declare class McpService {
      * Return the attach-time inventory captured for one session. This is the
      * handoff consumed by RPC's session-owned adapter; it deliberately
      * does not expose or derive from the lifecycle-only server snapshots.
+     * A caller that passes no session id gets no peer data while more than
+     * one session is live (senpi#3001): with a single live session the stored
+     * snapshot is that session's own, so the id-less read keeps working.
      */
     getWireStatusSnapshot(sessionId?: string): McpWireStatusSnapshot;
     /** Route compatibility callers through the shared ownership-aware scanner. */

package/dist/core/extensions/builtin/mcp/service.js

@@ -295,6 +295,14 @@ export class McpService {
         const releasedId = released?.sessionId;
         if (releasedId !== undefined && !live.some((binding) => binding.sessionId === releasedId)) {
             this.#wireStatusBySession.delete(releasedId);
+            // The id-less read falls back to #latestWireStatus once a single session is live, so rebind it to the
+            // remaining session's own snapshot (senpi#3001): without this, the released session's status outlives
+            // it whenever the release carries no reason and no re-sync re-captures.
+            const remaining = live.at(-1);
+            this.#latestWireStatus =
+                remaining?.sessionId !== undefined
+                    ? (this.#wireStatusBySession.get(remaining.sessionId) ?? { servers: [] })
+                    : { servers: [] };
         }
         const latest = live.at(-1);
         if (latest !== undefined) {
@@ -544,6 +552,10 @@ export class McpService {
     }
     /** Refresh and return the current session-owned MCP wire inventory. */
     async refreshWireStatusSnapshot(sessionId) {
+        // A caller that passes no session id gets no peer data while more than one session is live (senpi#3001);
+        // capturing here would store the most recently attached session's status for it to read back.
+        if (sessionId === undefined && this.#liveBindings().length > 1)
+            return { servers: [] };
         return this.#refreshWireStatus(sessionId, () => this.#statusOwner(sessionId));
     }
     /** `owner` is resolved when the queued capture runs, so it sees the bindings current at that point. */
@@ -617,7 +629,21 @@ export class McpService {
         }
         await reconnectMcpNow(entry.connection);
     }
-    getServerSnapshots() {
+    /**
+     * The lifecycle-only server snapshots. Without a session id these still list the merged config of all live
+     * sessions, as the /mcp command and the manager TUI expect. With one, only the servers that session declares
+     * (senpi#3001): a caller that can name its session gets no peer data.
+     */
+    getServerSnapshots(sessionId) {
+        if (sessionId !== undefined) {
+            const owner = this.#statusOwner(sessionId);
+            if (owner === undefined)
+                return [];
+            const names = new Set(Object.keys(owner.config.servers));
+            return [...names]
+                .sort()
+                .map((name) => this.#serverSnapshot(name, owner.config.servers[name], this.#entryForName(name)));
+        }
         const names = new Set(Object.keys(this.#config?.servers ?? {}));
         for (const entry of this.#connections.values())
             names.add(entry.name);
@@ -658,8 +684,13 @@ export class McpService {
      * Return the attach-time inventory captured for one session. This is the
      * handoff consumed by RPC's session-owned adapter; it deliberately
      * does not expose or derive from the lifecycle-only server snapshots.
+     * A caller that passes no session id gets no peer data while more than
+     * one session is live (senpi#3001): with a single live session the stored
+     * snapshot is that session's own, so the id-less read keeps working.
      */
     getWireStatusSnapshot(sessionId) {
+        if (sessionId === undefined && this.#liveBindings().length > 1)
+            return { servers: [] };
         return sessionId === undefined
             ? this.#latestWireStatus
             : (this.#wireStatusBySession.get(sessionId) ?? { servers: [] });

package/dist/core/extensions/builtin/terminal/rpc-monitor-remote.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The remote half of an rpc watch: one `RpcRemoteSource` subscription for a `<device>/<session>` or
+ * `<device>/*` target. Records go through the watch's own render path with the device in the socket's
+ * place, so a remote line reads exactly like a local one. A resync after a gap reports each change once,
+ * a turn end is reported once per `turnId`, and the source's cursor rides the monitor checkpoint.
+ */
+import type { RpcRecord } from "./rpc-monitor-observer.ts";
+import { type RpcMonitorRenderer } from "./rpc-monitor-render.ts";
+import type { RpcEvents } from "./rpc-monitor-targets.ts";
+import type { RpcRemoteSource, RpcRemoteTarget } from "./rpc-remote-source.ts";
+/** What a remote watch persists: the source's resume cursor and the turns already reported per session. */
+export interface RpcRemoteCheckpoint {
+    readonly cursor?: string;
+    readonly settled: Readonly<Record<string, readonly string[]>>;
+}
+export interface RpcRemoteFeedHost {
+    readonly renderer: RpcMonitorRenderer;
+    readonly hosts: Map<string, {
+        instanceId: string;
+        generation: string;
+    }>;
+    record(socket: string, record: RpcRecord): void;
+    line(line: string): void;
+    checkpoint(): void;
+    ended(summary: string): void;
+}
+export interface RpcRemoteFeedOptions {
+    readonly events: RpcEvents;
+    readonly exclude: readonly string[];
+    readonly source: RpcRemoteSource;
+    readonly saved?: RpcRemoteCheckpoint;
+}
+export declare class RpcRemoteFeed {
+    #private;
+    constructor(target: RpcRemoteTarget, options: RpcRemoteFeedOptions, host: RpcRemoteFeedHost);
+    /** Opens the subscription; resolves to the arm-time rows. Callbacks before the open resolves wait for it. */
+    start(): Promise<string[]>;
+    stop(): void;
+    checkpoint(): RpcRemoteCheckpoint;
+    /** After a restore: the turns that settled while nothing watched, which the saved checkpoint had not seen. */
+    diffSettled(saved: RpcRemoteCheckpoint | undefined): string[];
+}
+//# sourceMappingURL=rpc-monitor-remote.d.ts.map

package/dist/core/extensions/builtin/terminal/rpc-monitor-remote.js

@@ -0,0 +1,158 @@
+import { detachedLabel, sessionKey } from "./rpc-monitor-render.js";
+const REMOTE_INSTANCE = "remote";
+/** Turn ids remembered per session: enough to drop a resnapshot's repeats, bounded for a long watch. */
+const SETTLED_KEPT = 16;
+export class RpcRemoteFeed {
+    #target;
+    #options;
+    #host;
+    #settled = new Map();
+    #cursor;
+    #opened = [];
+    #subscription;
+    #lostReported = false;
+    #stopped = false;
+    constructor(target, options, host) {
+        this.#target = target;
+        this.#options = options;
+        this.#host = host;
+        for (const [key, turns] of Object.entries(options.saved?.settled ?? {}))
+            this.#settled.set(key, [...turns]);
+        this.#cursor = options.saved?.cursor;
+    }
+    /** Opens the subscription; resolves to the arm-time rows. Callbacks before the open resolves wait for it. */
+    async start() {
+        const pending = [];
+        let ready = false;
+        const run = (step) => {
+            if (this.#stopped)
+                return;
+            if (ready)
+                step();
+            else
+                pending.push(step);
+        };
+        const { events, exclude, source } = this.#options;
+        const subscription = await source.open(this.#target, { events, exclude, ...(this.#cursor === undefined ? {} : { resumeFrom: this.#cursor }) }, {
+            record: (record) => run(() => this.#record(record)),
+            resynced: (state) => run(() => this.#resync(state)),
+            cursor: (cursor) => run(() => {
+                this.#cursor = cursor;
+                this.#host.checkpoint();
+            }),
+            lost: (reason) => run(() => this.#lost(reason)),
+            ended: (reason) => run(() => this.#ended(reason)),
+        });
+        if (this.#stopped) {
+            subscription.stop();
+            return [];
+        }
+        this.#subscription = subscription;
+        const { initial } = subscription;
+        const device = this.#target.device;
+        this.#host.hosts.set(device, { instanceId: REMOTE_INSTANCE, generation: initial.generation ?? "" });
+        this.#opened = initial.settledTurns ?? [];
+        for (const turn of this.#opened)
+            this.#remember(turnKey(device, turn), turn.turnId);
+        if (initial.cursor !== undefined)
+            this.#cursor = initial.cursor;
+        const rows = this.#host.renderer.seed(device, initial.rows);
+        this.#host.checkpoint();
+        ready = true;
+        for (const step of pending.splice(0))
+            step();
+        return rows;
+    }
+    stop() {
+        this.#stopped = true;
+        this.#subscription?.stop();
+        this.#subscription = undefined;
+    }
+    checkpoint() {
+        const settled = Object.fromEntries([...this.#settled].map(([key, turns]) => [key, [...turns]]));
+        return this.#cursor === undefined ? { settled } : { cursor: this.#cursor, settled };
+    }
+    /** After a restore: the turns that settled while nothing watched, which the saved checkpoint had not seen. */
+    diffSettled(saved) {
+        return this.#opened
+            .filter((turn) => !saved?.settled[turnKey(this.#target.device, turn)]?.includes(turn.turnId))
+            .map((turn) => settledLine(turnKey(this.#target.device, turn), turn.turnId));
+    }
+    #record(record) {
+        const device = this.#target.device;
+        if (record.type !== "agent_settled" || typeof record.turnId !== "string") {
+            this.#host.record(device, record);
+            return;
+        }
+        const key = sessionKey(device, record);
+        if (this.#seen(key, record.turnId))
+            return;
+        this.#remember(key, record.turnId);
+        this.#host.record(device, record);
+        this.#host.checkpoint();
+    }
+    #resync(state) {
+        const device = this.#target.device;
+        const lines = [];
+        const host = this.#host.hosts.get(device);
+        if (state.generation !== undefined) {
+            if (host !== undefined && host.generation !== state.generation)
+                lines.push(`rpc host ${device} restarted (generation ${host.generation} -> ${state.generation})`);
+            this.#host.hosts.set(device, { instanceId: REMOTE_INSTANCE, generation: state.generation });
+        }
+        const before = new Map([...this.#host.renderer.statuses()].filter(([key]) => key.startsWith(`${device}#`)));
+        const now = new Map(state.rows.map((row) => [sessionKey(device, row), String(row.status)]));
+        for (const [key, status] of now) {
+            const was = before.get(key) ?? "unknown";
+            if (was !== status)
+                lines.push(`rpc ${detachedLabel(key)} status ${was} -> ${status} (changed while detached)`);
+        }
+        for (const key of before.keys())
+            if (!now.has(key))
+                lines.push(`rpc ${detachedLabel(key)} closed (gone while detached)`);
+        for (const turn of state.settledTurns ?? []) {
+            const key = turnKey(device, turn);
+            if (this.#seen(key, turn.turnId))
+                continue;
+            this.#remember(key, turn.turnId);
+            lines.push(settledLine(key, turn.turnId));
+        }
+        this.#host.renderer.forgetSocket(device);
+        this.#host.renderer.seed(device, state.rows);
+        if (state.cursor !== undefined)
+            this.#cursor = state.cursor;
+        this.#lostReported = false;
+        for (const line of lines)
+            this.#host.line(line);
+        this.#host.checkpoint();
+    }
+    #lost(reason) {
+        if (this.#lostReported)
+            return;
+        this.#lostReported = true;
+        this.#host.line(`rpc device ${this.#target.device} unreachable (${reason}); re-watching`);
+    }
+    #ended(reason) {
+        this.#host.line(`rpc ${this.#target.device}/${this.#target.session} access ended (${reason})`);
+        this.#host.ended(`access ended (${reason})`);
+    }
+    #seen(key, turnId) {
+        return this.#settled.get(key)?.includes(turnId) === true;
+    }
+    #remember(key, turnId) {
+        const turns = this.#settled.get(key) ?? [];
+        if (turns.includes(turnId))
+            return;
+        turns.push(turnId);
+        if (turns.length > SETTLED_KEPT)
+            turns.shift();
+        this.#settled.set(key, turns);
+    }
+}
+function turnKey(device, turn) {
+    return `${device}#${turn.sessionId}`;
+}
+function settledLine(key, turnId) {
+    return `rpc ${detachedLabel(key)} turn ${turnId} settled while detached`;
+}
+//# sourceMappingURL=rpc-monitor-remote.js.map

package/dist/core/extensions/builtin/terminal/rpc-monitor-render.d.ts

@@ -19,4 +19,6 @@ export declare class RpcMonitorRenderer {
     render(socket: string, record: RpcRecord): string | undefined;
 }
 export declare function sessionKey(socket: string, record: RpcRecord): string;
+/** How a line about a session nobody watched names it: the first 8 characters of its key's session id. */
+export declare function detachedLabel(key: string): string;
 //# sourceMappingURL=rpc-monitor-render.d.ts.map

package/dist/core/extensions/builtin/terminal/rpc-monitor-render.js

@@ -102,6 +102,10 @@ export class RpcMonitorRenderer {
 export function sessionKey(socket, record) {
     return `${socket}#${String(record.sessionId)}`;
 }
+/** How a line about a session nobody watched names it: the first 8 characters of its key's session id. */
+export function detachedLabel(key) {
+    return key.slice(key.lastIndexOf("#") + 1).slice(0, 8);
+}
 function labelOf(record) {
     const task = contextTask(record);
     if (task !== undefined)

package/dist/core/extensions/builtin/terminal/rpc-monitor-source.d.ts

@@ -4,9 +4,10 @@
  * file watches. A paused watch counts the lines it drops; a line identical to the previous one is
  * dropped (consecutive dedupe), on top of the notifier's same-batch rule.
  */
-import { type MonitorRecordBase, type MonitorSourceHost } from "./monitor-types.ts";
+import { type MonitorEndedReason, type MonitorRecordBase, type MonitorSourceHost } from "./monitor-types.ts";
 import type { RpcEvents, RpcTarget } from "./rpc-monitor-targets.ts";
 import { type RpcMonitorCheckpoint, RpcMonitorWatch } from "./rpc-monitor-watch.ts";
+import type { RpcRemoteSource } from "./rpc-remote-source.ts";
 export interface RegisterRpcMonitorOptions {
     readonly description: string;
     readonly target: RpcTarget;
@@ -22,6 +23,8 @@ export interface RegisterRpcMonitorOptions {
     readonly agentDir: string;
     /** Endpoint discovery override (tests); defaults to the endpoints registered under `agentDir`. */
     readonly endpoints?: () => Promise<readonly string[]>;
+    /** Remote source override (tests); defaults to the one an extension registered. */
+    readonly remoteSource?: RpcRemoteSource;
     /** A restore's saved view: the lines for what changed are injected once the watch has joined. */
     readonly restoredFrom?: RpcMonitorCheckpoint;
     readonly onCheckpoint?: (monitorId: string, checkpoint: RpcMonitorCheckpoint) => void;
@@ -46,7 +49,7 @@ export declare class RpcMonitorSource {
         rows: string[];
     }>;
     /** Ends one watch; false when the id is not a live rpc watch. */
-    settle(id: string, summary: string): boolean;
+    settle(id: string, summary: string, reason?: MonitorEndedReason): boolean;
     settleAll(summary: string): number;
 }
 //# sourceMappingURL=rpc-monitor-source.d.ts.map

package/dist/core/extensions/builtin/terminal/rpc-monitor-source.js

@@ -4,7 +4,7 @@
  * file watches. A paused watch counts the lines it drops; a line identical to the previous one is
  * dropped (consecutive dedupe), on top of the notifier's same-batch rule.
  */
-import { allocateMonitorId } from "./monitor-types.js";
+import { allocateMonitorId, } from "./monitor-types.js";
 import { RpcMonitorWatch } from "./rpc-monitor-watch.js";
 /**
  * The summary an RPC watch settles with when its own deadline fires. An RPC watch observes
@@ -38,6 +38,9 @@ export class RpcMonitorSource {
             events: options.events,
             exclude: options.exclude,
             ...(options.endpoints === undefined ? {} : { endpoints: options.endpoints }),
+            ...(options.remoteSource === undefined ? {} : { remoteSource: options.remoteSource }),
+            ...(options.restoredFrom === undefined ? {} : { restoredFrom: options.restoredFrom }),
+            ended: (summary) => this.settle(id, summary, "exit"),
             line: (line) => this.#line(id, line),
             ...(options.onCheckpoint === undefined
                 ? {}
@@ -67,14 +70,21 @@ export class RpcMonitorSource {
         };
         this.#records.set(id, record);
         this.#host.changed();
-        const rows = await watch.start();
+        const rows = await watch.start().catch((error) => {
+            // Only a remote open rejects: the watch never ran, so it leaves without a summary or an ended event.
+            watch.stop();
+            clearTimeout(record.deadline);
+            this.#records.delete(id);
+            this.#host.changed();
+            throw error;
+        });
         if (options.restoredFrom !== undefined)
             for (const line of watch.diffSince(options.restoredFrom))
                 this.#line(id, line);
         return { id, monitorId, rows };
     }
     /** Ends one watch; false when the id is not a live rpc watch. */
-    settle(id, summary) {
+    settle(id, summary, reason) {
         const record = this.#records.get(id);
         if (record === undefined || record.settled)
             return false;
@@ -85,7 +95,12 @@ export class RpcMonitorSource {
         this.#host.changed();
         if (summary !== "watcher disposed")
             this.#host.emit(record, { type: "summary", id, description: record.description, summary });
-        this.#host.ended(record, summary === RPC_WATCHER_TIMED_OUT_SUMMARY ? "timeout" : summary === "watcher disposed" ? "disposed" : "killed", null);
+        this.#host.ended(record, reason ??
+            (summary === RPC_WATCHER_TIMED_OUT_SUMMARY
+                ? "timeout"
+                : summary === "watcher disposed"
+                    ? "disposed"
+                    : "killed"), null);
         return true;
     }
     settleAll(summary) {

package/dist/core/extensions/builtin/terminal/rpc-monitor-targets.d.ts

@@ -10,6 +10,10 @@ export type RpcTarget = {
 } | {
     readonly kind: "task";
     readonly taskId: string;
+} | {
+    readonly kind: "remote";
+    readonly device: string;
+    readonly session: string;
 };
 export type RpcEvents = "all" | readonly string[];
 export declare function parseRpcTarget(target: string, selfDurableId: string | undefined): RpcTarget | {

package/dist/core/extensions/builtin/terminal/rpc-monitor-targets.js

@@ -7,6 +7,10 @@
  * makes the observer an attachment.
  */
 import { listHostEndpoints } from "../../../../modes/rpc/host-endpoints.js";
+import { currentRpcRemoteSource } from "./rpc-remote-source.js";
+// `<device>/<session>` or `<device>/*`: one `/`, no leading `/`, not a `.jsonl` path, not a drive letter.
+const REMOTE_TARGET = /^(?<device>[^/]+)\/(?<session>[^/]+)$/;
+const DRIVE_LETTER = /^[A-Za-z]:$/;
 const STATUS_KINDS = new Set(["session_status", "effect_status"]);
 export function parseRpcTarget(target, selfDurableId) {
     const trimmed = target.trim();
@@ -23,8 +27,19 @@ export function parseRpcTarget(target, selfDurableId) {
         return { kind: "all" };
     if (trimmed.startsWith("st_"))
         return { kind: "task", taskId: trimmed };
+    const remote = REMOTE_TARGET.exec(trimmed)?.groups;
+    if (remote?.device !== undefined && remote.session !== undefined && isRemoteShape(trimmed, remote.device)) {
+        if (currentRpcRemoteSource() === undefined)
+            return {
+                error: `target "${trimmed}" names a session on another device; remote targets need the omo remote surface`,
+            };
+        return { kind: "remote", device: remote.device, session: remote.session };
+    }
     return { kind: "id", id: trimmed };
 }
+function isRemoteShape(target, device) {
+    return !target.endsWith(".jsonl") && !DRIVE_LETTER.test(device);
+}
 /** `["session_status", "effect_status"]` for children, `["session_status"]` otherwise. */
 export function defaultEvents(target) {
     return target.kind === "children" ? ["session_status", "effect_status"] : ["session_status"];

package/dist/core/extensions/builtin/terminal/rpc-monitor-watch.d.ts

@@ -1,4 +1,6 @@
+import { type RpcRemoteCheckpoint } from "./rpc-monitor-remote.ts";
 import { type RpcEvents, type RpcTarget } from "./rpc-monitor-targets.ts";
+import { type RpcRemoteSource } from "./rpc-remote-source.ts";
 export declare const RPC_RESCAN_MS = 30000;
 /** What a restore compares against: each endpoint's host identity and each session's last status. */
 export interface RpcMonitorCheckpoint {
@@ -7,6 +9,8 @@ export interface RpcMonitorCheckpoint {
         readonly generation: string;
     }>>;
     readonly statuses: Readonly<Record<string, string>>;
+    /** A remote target's resume position (absent for local targets). */
+    readonly remote?: RpcRemoteCheckpoint;
 }
 export interface RpcWatchOptions {
     readonly agentDir: string;
@@ -19,6 +23,12 @@ export interface RpcWatchOptions {
     readonly line: (line: string) => void;
     /** The watch's view changed (a host joined, a status moved): persist it. */
     readonly checkpoint?: (checkpoint: RpcMonitorCheckpoint) => void;
+    /** The source serving a remote target; defaults to the one an extension registered. */
+    readonly remoteSource?: RpcRemoteSource;
+    /** A restore's saved view: a remote target resumes from its cursor. */
+    readonly restoredFrom?: RpcMonitorCheckpoint;
+    /** A remote target's access ended for good: the monitor settles with this summary. */
+    readonly ended?: (summary: string) => void;
 }
 export declare class RpcMonitorWatch {
     #private;