@rho-workspace/rho 0.5.5 → 0.5.6

package/dist/conversations.js

@@ -8,6 +8,7 @@ import path from 'node:path';
 import { createHash, randomBytes, randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { atomicJson, canonical, digest, Fault, now, readJson, requireThat } from '@rho-workspace/plugin-contracts';
+import { acpEnvironment, missingClient } from '@rho-workspace/plugin-agent/acp-command';
 // Rho holds user messages and their original identities. The selected Agent plugin
 // owns the connection, native session and protocol. Reads never start a driver.
 // A new Claude Code session opens in Manual mode unless the person's Claude settings name another.
@@ -234,7 +235,8 @@ export class Conversations {
         return { conversationId: c.id, changeId: c.changeId, requestDigest: c.requestDigest, title: c.title, client: c.client, principal: c.principal, createdAt: c.createdAt, updatedAt: c.updatedAt, version: c.version, turns: c.turns.length, state: last?.state ?? 'idle', lastAt: last?.endedAt ?? last?.sentAt ?? c.createdAt,
             listed: 2, turnLimit: !!last && agentTurnLimit(last), waitingPermission: last?.state === 'running' && !!last.permissions?.some(p => p.state === 'pending'), backend: c.backend ?? 'claude-cli', agentTitle: c.observation?.info?.title ?? null, adapter: c.adapter ?? null, model: [...c.turns].reverse().find(t => t.model)?.model ?? null, config: c.config ?? {},
             usage: usage ? { used: usage.used, size: usage.size, cost: usage.cost ?? null } : null, costUsd: costs.length ? costs.reduce((a, b) => a + b, 0) : null,
-            sessionId: c.acpSessionId ?? c.nativeSessionId ?? null, trashedAt: c.trashedAt ?? null };
+            sessionId: c.acpSessionId ?? c.nativeSessionId ?? null, trashedAt: c.trashedAt ?? null,
+            origin: c.origin ? { producer: c.origin.producer, where: c.origin.where, ...(c.origin.copy ? { copyOf: c.origin.sessionId } : {}) } : null };
     }
     async write(project, c) {
         const directory = await this.folder(project);
@@ -394,7 +396,9 @@ export class Conversations {
         requireThat(!input.backend || backends.includes(input.backend), 'invalid', 'Choose Claude Code or Codex.');
         if (input.config)
             this.choices(input.config);
-        const text = this.message(input.text), requestDigest = digest(canonical({ text, ...(input.contexts?.length ? { contexts: input.contexts } : {}), ...(input.backend ? { backend: input.backend } : {}), ...(input.config ? { config: input.config } : {}) }));
+        const from = input.continue;
+        const text = this.message(input.text), requestDigest = digest(canonical({ text, ...(input.contexts?.length ? { contexts: input.contexts } : {}), ...(input.backend ? { backend: input.backend } : {}), ...(input.config ? { config: input.config } : {}),
+            ...(from ? { continue: { producer: from.producer, sessionId: from.sessionId, copy: from.copy } } : {}) }));
         return this.serial(project.id, async () => {
             const index = await this.index(project), existing = index.conversations.find(x => x.changeId === input.changeId);
             requireThat(!index.deleted?.some(x => x.changeId === input.changeId), 'conflict', 'That request started a conversation that was later deleted. It is not started again.');
@@ -404,13 +408,26 @@ export class Conversations {
                 return this.reply(project, c, c.turns[0]);
             }
             requireThat(index.conversations.filter(x => !x.trashedAt).length < this.limits.maxConversations, 'limit', `This project keeps at most ${this.limits.maxConversations} conversations started in Rho. Move one to the trash to start another.`, { limit: 'maxConversations', maximum: this.limits.maxConversations });
+            if (from && !from.copy) {
+                const already = index.conversations.find(x => x.sessionId === from.sessionId);
+                requireThat(!already, 'conflict', already?.trashedAt ? 'This session is a conversation in the trash. Restore it to continue.' : 'This session already continues as a conversation here. Open it to send your message.');
+                await this.notHeld(project, from.producer, from.sessionId, false);
+            }
             this.capacity();
             const saved = await this.readSettings();
-            const backend = input.backend ?? saved.backend ?? this.config.backend ?? 'claude-acp';
+            const backend = from?.backend ?? input.backend ?? saved.backend ?? this.config.backend ?? 'claude-acp';
             const config = backend === 'claude-cli' ? undefined : input.config ?? saved.choices[backend];
             const at = now(), c = { format: 2, backend, id: 'c-' + randomBytes(8).toString('hex'), changeId: input.changeId, requestDigest, createdAt: at, createdBy: by, updatedAt: at, version: 0, client: backend === 'codex-acp' ? 'codex' : backend === 'acp' ? 'acp' : 'claude-code', nativeSessionId: backend === 'claude-cli' ? randomUUID() : null, confirmed: false, principal: null, title: titleOf(text), turns: [], ...(config && Object.keys(config).length ? { config } : {}) };
             for (const id of input.contexts ?? [])
                 await this.ports.context?.(project, id);
+            if (from) {
+                c.origin = { producer: from.producer, sessionId: from.sessionId, where: from.where, copy: from.copy };
+                if (from.copy)
+                    c.forkFrom = from.sessionId;
+                else
+                    c.acpSessionId = from.sessionId;
+                c.title = from.title;
+            }
             const turn = this.turn(input.changeId, requestDigest, by, text, 1);
             if (input.contexts?.length)
                 turn.contexts = [...input.contexts];
@@ -421,6 +438,29 @@ export class Conversations {
             return this.reply(project, c, turn);
         });
     }
+    /** Whether a process holding a session open is Rho's own connection to this conversation: the
+     * Agent its adapter started. */
+    async owns(project, conversationId, pid) {
+        const adapter = this.drivers.get(project.id + '/' + conversationId)?.driver?.pid;
+        if (!adapter || !pid || process.platform === 'win32')
+            return false;
+        const { execFile } = await import('node:child_process');
+        let current = pid;
+        for (let depth = 0; depth < 4 && current > 1; depth++) {
+            const parent = await new Promise(resolve => execFile('ps', ['-o', 'ppid=', '-p', String(current)], { timeout: 2000 }, (error, out) => resolve(error ? 0 : Number(String(out).trim()))));
+            if (parent === adapter)
+                return true;
+            current = parent;
+        }
+        return false;
+    }
+    async notHeld(project, producer, sessionId, existing, conversationId) {
+        if (producer !== 'claude-code' && producer !== 'codex')
+            return;
+        const found = await this.ports.nativeSession?.(project, producer, sessionId) ?? null;
+        const holder = found?.open && !(conversationId && await this.owns(project, conversationId, found.open.pid)) ? found.open : null;
+        requireThat(!holder, 'condition', `This session is open in ${holder?.where ?? 'another window'}. Close it there to continue here${existing ? '' : ', or continue a copy'}. Nothing was sent.`, { heldBy: holder?.where ?? null });
+    }
     async send(project, by, input) {
         const text = this.message(input.text), requestDigest = digest(canonical({ text, ...(input.contexts?.length ? { contexts: input.contexts } : {}), ...(input.continuationOf ? { continuationOf: input.continuationOf } : {}) }));
         return this.serial(project.id, async () => {
@@ -444,6 +484,9 @@ export class Conversations {
                 requireThat(!alive, 'conflict', `The Agent from before Rho restarted may still be answering (process ${last.pid}). End that process before sending another message.`);
             }
             requireThat(c.turns.length < this.limits.maxTurns, 'limit', `A conversation keeps at most ${this.limits.maxTurns} messages. Start a new conversation.`, { limit: 'maxTurns', maximum: this.limits.maxTurns });
+            // A session continued in a terminal or another app may be open there now.
+            if (c.acpSessionId && (c.client === 'claude-code' || c.client === 'codex'))
+                await this.notHeld(project, c.client, c.acpSessionId, true, c.id);
             requireThat(Buffer.byteLength(JSON.stringify({ ...c, observation: undefined })) + this.limits.maxObservationBytes + this.limits.maxTurnBytes + this.limits.maxMessageBytes <= this.limits.maxRecordBytes, 'limit', 'This conversation has reached the size Rho keeps. Start a new conversation.', { limit: 'maxRecordBytes', maximum: this.limits.maxRecordBytes });
             this.capacity();
             for (const old of c.turns)
@@ -510,7 +553,19 @@ export class Conversations {
     }
     settingsView(s) {
         const service = this.config.backend ?? 'claude-acp';
-        return { version: s.version, updatedAt: s.updatedAt, backend: s.backend, serviceBackend: service, choices: s.choices, offered: s.offered, checking: [...this.checks.keys()], describe: { enabled: s.describe?.enabled !== false } };
+        return { version: s.version, updatedAt: s.updatedAt, backend: s.backend, serviceBackend: service, choices: s.choices, offered: s.offered, checking: [...this.checks.keys()], describe: { enabled: s.describe?.enabled !== false }, agents: this.agents() };
+    }
+    // Which Agents this service can start: the person's installed clients, found as the adapters
+    // find them, and an ACP command the person named. Looking starts nothing.
+    agents() {
+        const found = (problem) => problem ? { found: false, problem } : { found: true };
+        const command = this.config.acpCommand;
+        return {
+            // A command the embedding names is its own choice and is not looked for, as the adapters do.
+            'claude-acp': found(this.config.claudeAcp?.command ? null : missingClient('claude', acpEnvironment('claude', { ...process.env }, this.binary))),
+            'codex-acp': found(this.config.codexAcp?.command ? null : missingClient('codex', acpEnvironment('codex', { ...process.env }, this.config.codex))),
+            acp: command ? { found: true, name: /(^|[\\/])dsh(\.[a-z]+)?$/i.test(command.file) || command.args.some(a => /(^|[\\/])dsh(\.[a-z]+)?$/i.test(a)) ? 'DeepSeek Harness' : null } : { found: false, problem: 'Start Rho with --agent-backend acp --acp-command to use another ACP Agent.' }
+        };
     }
     async settings() { return this.settingsView(await this.readSettings()); }
     // The person's Agent and settings for new conversations. Each Agent's choices are replaced as a
@@ -733,12 +788,20 @@ export class Conversations {
             }
         });
     }
+    async changedElsewhere(project, c) {
+        if (!c.acpSessionId || (c.client !== 'claude-code' && c.client !== 'codex'))
+            return false;
+        const previous = c.turns.at(-2), found = await this.ports.nativeSession?.(project, c.client, c.acpSessionId).catch(() => null);
+        return !!found && !!previous?.endedAt && Date.parse(found.lastAt) > Date.parse(previous.endedAt) + 5000;
+    }
     async driver(project, c) {
         return this.serial('driver-pool', async () => {
             const key = project.id + '/' + c.id, old = this.drivers.get(key);
             if (old?.timer)
                 clearTimeout(old.timer);
-            if (old?.driver.connected)
+            // An open connection keeps the session as it last saw it. When the session went on in
+            // another window since, it is opened again from the Agent's own record.
+            if (old?.driver.connected && !await this.changedElsewhere(project, c))
                 return old.driver;
             if (old)
                 await this.retire(key);
@@ -770,7 +833,7 @@ export class Conversations {
                 } };
             // Every session started here is told about the project's shared notes and its section.
             const instructions = notesInstructions(c.id, { notebook: !!this.ports.notebook?.() });
-            const common = { cwd: project.root, mcpServers, limits: this.limits, sessionId: c.acpSessionId, config: c.config, instructions, ...observed };
+            const common = { cwd: project.root, mcpServers, limits: this.limits, sessionId: c.acpSessionId, ...(!c.acpSessionId && c.forkFrom ? { forkFrom: c.forkFrom } : {}), config: c.config, instructions, ...observed };
             const driver = c.backend === 'codex-acp'
                 ? new CodexAcpConversation({ ...this.config.codexAcp, ...common, codex: this.config.codex })
                 : c.backend === 'claude-acp'

package/dist/discovery.js

@@ -4,7 +4,7 @@ import { protocol } from './protocol.js';
 import { schemaClosure } from './protocol-discovery.js';
 const size = (v) => Buffer.byteLength(JSON.stringify(v)) + 64;
 export const applicationEffects = Object.fromEntries([
-    ...['extension.list', 'extension.describe', 'extension.content', 'extension.read', 'protocol.describe', 'protocol.validate', 'project.entries', 'capability.list', 'skill.list', 'skill.read', 'action.lookup', 'action.observe', 'action.output', 'action.list', 'composition.read', 'observation.snapshot', 'interaction.selection.read', 'workspace.observe', 'task.map.read'].map(m => [m, 'read']),
+    ...['session.instructions', 'extension.list', 'extension.describe', 'extension.content', 'extension.read', 'protocol.describe', 'protocol.validate', 'project.entries', 'capability.list', 'skill.list', 'skill.read', 'action.lookup', 'action.observe', 'action.output', 'action.list', 'composition.read', 'observation.snapshot', 'interaction.selection.read', 'workspace.observe', 'task.map.read'].map(m => [m, 'read']),
     ...['composition.put', 'view.close', 'capability.configure', 'composition.apply', 'composition.undo', 'view.protection.set', 'interaction.selection.set', 'selection.set', 'workspace.enhance', 'task.map.declare', 'task.map.present', 'task.map.respond'].map(m => [m, 'metadata']),
     ...['workspace.save', 'workspace.export', 'workspace.restore', 'action.export'].map(m => [m, 'file']),
     ...['extension.call', 'extension.install', 'extension.manage', 'action.retry', 'action.cancel'].map(m => [m, 'native']),

package/dist/protocol.d.ts

@@ -173,6 +173,7 @@ export declare const descriptions: {
     'conversation.settings.update': string;
     'conversation.settings.check': string;
     'session.connect': string;
+    'session.instructions': string;
     'conversation.read': string;
     'project.work.read': string;
     'resource.register': string;

package/dist/protocol.js

@@ -71,7 +71,8 @@ export const operations = { ...base.operations, ...extensionOperations,
     'data.compare': obj({ ...project, left: ref, right: ref, options: obj({ leftKey: text, rightKey: text, leftNamespace: text, rightNamespace: text, mapping: { const: 'equal-string' }, leftField: text, rightField: text, join: { enum: ['left', 'inner', 'full'] } }) }),
     'media.describe': obj({ ...project, resource: ref }),
     // A conversation the person starts in Rho: their words, under a request identity they hold.
-    'conversation.start': obj({ ...project, changeId, text: { type: 'string', minLength: 1, maxLength: 16384 }, backend: agentBackend, config: choices, contexts: { ...array(digest), maxItems: 8 } }, ['projectId', 'changeId', 'text']),
+    'conversation.start': obj({ ...project, changeId, text: { type: 'string', minLength: 1, maxLength: 16384 }, backend: agentBackend, config: choices, contexts: { ...array(digest), maxItems: 8 },
+        continue: obj({ session: { type: 'string', pattern: '^x-[a-f0-9]{64}$' }, copy: { type: 'boolean' } }, ['session']) }, ['projectId', 'changeId', 'text']),
     'conversation.send': obj({ ...project, conversationId: changeId, changeId, text: { type: 'string', minLength: 1, maxLength: 16384 }, contexts: { ...array(digest), maxItems: 8 }, continuationOf: changeId }, ['projectId', 'conversationId', 'changeId', 'text']),
     'conversation.permission': obj({ ...project, conversationId: changeId, turnId: changeId, permissionId: changeId, optionId: { type: 'string', minLength: 1, maxLength: 256 } }),
     'conversation.stop': obj({ ...project, conversationId: changeId, turnId: changeId }),
@@ -87,7 +88,8 @@ export const operations = { ...base.operations, ...extensionOperations,
     'conversation.settings.update': obj({ ...project, expectedVersion: integer, backend: { anyOf: [agentBackend, { type: 'null' }] }, choices: obj({ 'claude-acp': choices, 'codex-acp': choices, 'acp': choices }, []), describe: obj({ enabled: { type: 'boolean' } }, ['enabled']) }, ['projectId', 'expectedVersion']),
     'conversation.settings.check': obj({ ...project, backend: agentBackend }),
     // Claude Code or Codex running outside Rho, given this project and told how to start Rho's MCP server.
-    'session.connect': obj({ ...project, agent: outsideAgent })
+    'session.connect': obj({ ...project, agent: outsideAgent }),
+    'session.instructions': obj(project)
 };
 // Every owner-declared operation and response comes from the snapshot, scoped once.
 for (const [method, contract] of Object.entries(ownerOperations))
@@ -200,14 +202,17 @@ const catalog = { ...contract.capabilityCatalogSchema };
 const conversationSummary = response({ conversationId: text, title: text, client: text, principal: { anyOf: [text, { type: 'null' }] }, createdAt: text, updatedAt: text, version: integer, turns: integer, state: { enum: ['idle', 'running', 'completed', 'failed', 'stopped', 'unknown'] }, lastAt: text,
     backend: text, agentTitle: { anyOf: [text, { type: 'null' }] }, adapter: { anyOf: [response({ name: text, version: text }, ['name']), { type: 'null' }] }, model: { anyOf: [text, { type: 'null' }] }, config: choices, turnLimit: { type: 'boolean' }, waitingPermission: { type: 'boolean' },
     usage: { anyOf: [response({ used: { type: 'number', minimum: 0 }, size: { type: 'number', minimum: 0 }, cost: { anyOf: [response({ amount: { type: 'number' }, currency: text }), { type: 'null' }] } }), { type: 'null' }] },
-    costUsd: { anyOf: [{ type: 'number' }, { type: 'null' }] }, sessionId: { anyOf: [text, { type: 'null' }] }, trashedAt: { anyOf: [text, { type: 'null' }] } }, ['conversationId', 'title', 'client', 'principal', 'createdAt', 'updatedAt', 'version', 'turns', 'state', 'lastAt']);
+    costUsd: { anyOf: [{ type: 'number' }, { type: 'null' }] }, sessionId: { anyOf: [text, { type: 'null' }] }, trashedAt: { anyOf: [text, { type: 'null' }] },
+    origin: { anyOf: [response({ producer: text, where: text, copyOf: text }, ['producer', 'where']), { type: 'null' }] } }, ['conversationId', 'title', 'client', 'principal', 'createdAt', 'updatedAt', 'version', 'turns', 'state', 'lastAt']);
 const sessionObservation = ownerSchema('agent-session', 'sessionObservationSchema');
 // What one Agent offered, from a check or a conversation's first session, and the person's choices.
 const offered = response({ at: text, source: { enum: ['check', 'conversation'] }, adapter: { anyOf: [response({ name: text, version: text }, ['name']), { type: 'null' }] }, options: array(ownerSchema('agent-session', 'configOptionSchema')), omitted: integer });
 const agentSettings = response({ version: integer, updatedAt: { anyOf: [text, { type: 'null' }] }, backend: { anyOf: [agentBackend, { type: 'null' }] }, serviceBackend: { enum: ['claude-acp', 'codex-acp', 'claude-cli', 'acp'] },
     choices: response({ 'claude-acp': choices, 'codex-acp': choices, 'acp': choices }, []), offered: response({ 'claude-acp': offered, 'codex-acp': offered, 'acp': offered }, []), checking: array(agentBackend),
     // Whether a model describes the files a message writes; the facts are read either way.
-    describe: response({ enabled: { type: 'boolean' } }) }, ['version', 'updatedAt', 'backend', 'serviceBackend', 'choices', 'offered', 'checking']);
+    describe: response({ enabled: { type: 'boolean' } }),
+    // Which Agents this service can start, without starting them.
+    agents: response(Object.fromEntries(['claude-acp', 'codex-acp', 'acp'].map(k => [k, response({ found: { type: 'boolean' }, problem: text, name: { anyOf: [text, { type: 'null' }] } }, ['found'])]))) }, ['version', 'updatedAt', 'backend', 'serviceBackend', 'choices', 'offered', 'checking']);
 // A tool step keeps its original identity, the Agent's bounded human title, its ACP
 // category and one identifying input (command, path, pattern or query), for a command the
 // Agent's own few words on what it is for (purpose), when it was
@@ -333,6 +338,7 @@ export const responses = { ...base.responses, ...ownerResponses, ...extensionRes
     'conversation.settings.update': agentSettings,
     'conversation.settings.check': agentSettings,
     'session.connect': response({ principal: text, label: text, methods: integer, granted: { type: 'boolean' }, added: addedTo }),
+    'session.instructions': response({ request: text, prompt: text, command: array(text) }),
     'protocol.describe': response({ apiVersion: { const: '2.0' }, schemaVersion: { const: 2 }, revision: digest, entries: array(response({ method: text, summary: text })), next: { type: ['string', 'null'] }, complete: { type: 'boolean' }, contract: response({ method: text, inputSchema: { type: 'object' }, outputSchema: { type: 'object' }, definitions: { type: 'object' }, description: text }) }, ['apiVersion', 'schemaVersion', 'revision', 'entries', 'next', 'complete']),
     'capability.list': { ...catalog, properties: { ...catalog.properties, host: contract.cliSchema }, required: [...(catalog.required ?? []), 'host'] },
     'capability.configure': response({ version: positive, enabled: array(text), receipt: response({ changeId: text, author: text, version: positive, enabled: array(text), at: text }) }),
@@ -395,7 +401,7 @@ export const descriptions = {
     'action.submit': 'Execute the explicitly selected project R script snapshot and requirements. Persist operationId before delivery; identical retries retain the original Core identity. Output directory is the first R argument, followed by explicit args or frozen resource paths. Artifact paths are output-relative; completion is run-directory-relative, returned as plan.completion, so an inventory can remain beside immutable producer artifacts.',
     'binding.activity.append': 'Registered native adapter only: retain original CLI tool and artifact-ready observations. This does not execute, validate, or present artifacts.',
     'task.routing.put': 'Control plane only: conditionally assign one task and business binding to this project without starting a native session.',
-    'conversation.start': 'Person at this machine only: start a conversation with the selected Claude Code or Codex Agent in this project. Rho selects the Agent plugin backend, attaches this project\'s MCP grant and records the message before sending it. Without backend or config, the person\'s saved Agent and settings are used and recorded with the conversation. A repeated changeId with the same text returns the original conversation and starts nothing.',
+    'conversation.start': 'Person at this machine only: start a conversation with the selected Claude Code or Codex Agent in this project. Rho selects the Agent plugin backend, attaches this project\'s MCP grant and records the message before sending it. Without backend or config, the person\'s saved Agent and settings are used and recorded with the conversation. A repeated changeId with the same text returns the original conversation and starts nothing. With continue, the message continues an Agent session listed by agent.sessions.list (one started in a terminal, an editor or the Agent\'s own app) through that same session, or through a copy of it with copy; a session another live window holds open is refused unless copied.',
     'conversation.send': 'Person at this machine only: send the next message to a conversation started in Rho. A continuationOf links a new message to the latest confirmed Agent turn-limit stop; the original request is not resent. Refused while the previous message is being answered. A repeated changeId with the same input returns the original message.',
     'conversation.decide': 'Person at this machine only: say to use an answer, or that it needs changes and why. The decision holds for the file versions that message kept when it was given and says nothing of later versions. A new decision supersedes the one before; none is removed. Refused while the Agent is still answering.',
     'conversation.stop': 'Person at this machine only: ask the original Agent to stop answering one message. ACP cancellation is confirmed by the original prompt response; a lost connection keeps the outcome unknown. Legacy CLI conversations confirm process exit. Steps already taken stay done.',
@@ -432,6 +438,7 @@ export const descriptions = {
     'conversation.settings.update': 'Person at this machine only: choose the Agent and its settings for new conversations, among the values that Agent last offered, and whether a model describes the files a message writes. A stale expectedVersion is refused.',
     'conversation.settings.check': 'Person at this machine only: start the chosen Agent in this project to read the settings it offers, then remove that session and end the process. No message is sent; one check per Agent runs at a time.',
     'session.connect': 'Person at this machine only: give Claude Code or Codex running outside Rho access to this project, then add Rho\'s MCP server with that Agent\'s own `mcp add` (Claude Code: for this project folder; Codex: in its user configuration). A grant whose connection still reaches this service is kept, so a connected session keeps working; a new grant the Agent refuses is removed. No message is sent and no Agent session starts.',
+    'session.instructions': 'Person at this machine or operator only: read a prompt for the person\'s own MCP client to connect itself to this existing project. Returns local launcher paths, never credential contents. Reading or copying grants no access, edits no client configuration and starts no runtime.',
     'conversation.read': 'Read a conversation started in Rho: the person\'s messages, the Agent\'s visible text and tool steps, and how each message ended. Reading starts and resumes nothing.',
     'project.work.read': 'Person at this machine only: read linked Agent sessions, retained native activity identities, current referenced files and the shared notes document. Source cursors and resource versions remain independent. Does not start an Agent, collector or Host.',
     'resource.register': 'Declare scoped existing bytes and their type/schema at the supplied digest. This read and registration starts no runtime.',

package/dist/server.d.ts

@@ -168,22 +168,14 @@ export declare class RhoService {
     agentConnection(projectId: string, externalSessionId: string, file: string, methods?: string[], pluginFilter?: string[], profile?: 'layered-business' | 'layered-presentation', who?: {
         label?: string;
         conversationId?: string;
-    }): Promise<{
-        apiVersion: "2.0";
-        pluginFilter?: ("media" | "r" | "agent" | "files" | "skills" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel")[] | undefined;
-        profile?: "layered-business" | "layered-presentation" | undefined;
-        url: string;
-        token: string;
-        projectId: string;
-        externalSessionId: string;
-        methods: string[];
-    }>;
+    }): Promise<any>;
     private authenticate;
     private handle;
     private readBody;
     private json;
     private serial;
     private recordActivity;
+    private agentSessions;
     private projectActivity;
     private agentSummaries;
     private dataDir;

package/dist/server.js

@@ -19,7 +19,7 @@ import { Interactions } from './interactions.js';
 import { TaskMap } from './task-map.js';
 import { Capabilities } from './capabilities.js';
 import { BrowserAccess, localBrowserId, localBrowserPrincipal } from './browser-access.js';
-import { addToAgent, connectLimits, mcpCommand, mcpName, outsideLabel } from './agent-connect.js';
+import { addToAgent, connectionInstructions, connectLimits, mcpCommand, mcpName, outsideLabel } from './agent-connect.js';
 import { NativeFolderPicker, nativeFolderLimits } from './native-folders.js';
 import { homedir } from 'node:os';
 import { serveWeb, servePageFrame, pageFramePath, extensionFramePath, webRoot, installedWebEntries } from './web-assets.js';
@@ -452,6 +452,7 @@ export class RhoService {
                 return [await writeClaudePlugin(path.join(this.state.directory, 'claude-plugins'), { name: 'rho', version: selectedPluginVersions.agent, description: 'Skills and hooks of the plugins selected in Rho.', ...declared })];
             },
             changed: async (project, conversationId) => { void this.serial(project.id, () => this.emit(project, 'conversation.changed', conversationId, localBrowserId)).catch(() => { }); },
+            nativeSession: async (project, producer, sessionId) => (await import('@rho-workspace/plugin-agent/native-sessions')).nativeSession(project.root, producer, sessionId),
             // The person's own Claude Code when one is named, with no tools and in an empty folder of
             // Rho's state, so it reads only what it is given and loads no project instructions. What
             // a call cost comes from Claude Code when it knows the model's price, else from models.dev.
@@ -570,11 +571,22 @@ export class RhoService {
         requireThat(selected.every(m => !extensionManagement.includes(m) && !!operations[m] && !m.startsWith('agent.sessions.') && !m.startsWith('session.') && !m.startsWith('conversation.') && (!m.startsWith('project.') || m === 'project.entries') && !['task.routing.put', 'console.run', 'console.stop', 'kernel.stop'].includes(m)), 'invalid', 'Unknown or operator-only Agent capability.');
         requireThat(await Promise.all(selected.map(method => capabilities.isAvailable(method, state))).then(values => values.every(Boolean)), 'unavailable', 'A requested Agent operation has no selected provider.');
         requireThat(!profile || new Set(['capability.index', 'capability.resolve', ...selected]).size <= layeredGrantLimits.maxMethods, 'limit', `Layered connection methods exceed the ${layeredGrantLimits.maxMethods}-method profile; choose an explicit narrower grant.`, { limit: 'maxMethods', maximum: layeredGrantLimits.maxMethods });
-        const token = randomBytes(32).toString('hex');
         const id = 'agent:' + digest(projectId + ':' + externalSessionId).slice(0, 32);
+        const grantedMethods = [...new Set([...(profile ? ['capability.index', 'capability.resolve'] : ['protocol.describe', 'capability.list']), ...selected])];
+        const existing = this.state.principals.find(p => p.id === id);
+        const kept = await fs.readFile(file, 'utf8').then(text => JSON.parse(text), () => null);
+        // Repeating the same setup must not disconnect a client already using its grant.
+        // Changed scope, expired access or a stale address still requires a fresh credential.
+        if (existing && !(existing.expiresAt && Date.parse(existing.expiresAt) <= Date.now())
+            && kept?.url === this.url && kept.projectId === projectId && kept.externalSessionId === externalSessionId
+            && typeof kept.token === 'string' && digest(kept.token) === existing.tokenHash
+            && canonical([...existing.methods].sort()) === canonical([...grantedMethods].sort())
+            && kept.profile === profile && canonical(existing.pluginFilter ?? []) === canonical(pluginFilter ?? []))
+            return kept;
+        const token = randomBytes(32).toString('hex');
         this.state.principals = this.state.principals.filter(p => p.id !== id);
         requireThat(!pluginFilter || pluginFilter.every(id => this.plugins.isKnown(id)), 'invalid', 'Unknown MCP plugin filter.');
-        await this.state.addPrincipal({ id, tokenHash: digest(token), projectId, label: who.label ?? externalSessionId, ...(who.conversationId ? { conversationId: who.conversationId } : {}), methods: [...new Set([...(profile ? ['capability.index', 'capability.resolve'] : ['protocol.describe', 'capability.list']), ...selected])], ...(profile ? { profile } : {}), ...(pluginFilter ? { pluginFilter } : {}) });
+        await this.state.addPrincipal({ id, tokenHash: digest(token), projectId, label: who.label ?? externalSessionId, ...(who.conversationId ? { conversationId: who.conversationId } : {}), methods: grantedMethods, ...(profile ? { profile } : {}), ...(pluginFilter ? { pluginFilter } : {}) });
         const connection = { url: this.url, token, projectId, externalSessionId, methods: [...new Set([...(profile ? ['capability.index', 'capability.resolve'] : []), ...selected])], ...(profile ? { profile } : {}), ...(pluginFilter ? { pluginFilter } : {}), apiVersion: '2.0' };
         await atomicJson(file, connection);
         return connection;
@@ -785,6 +797,32 @@ export class RhoService {
     // What the project's Agents did, for the person's screen:
     // only principals whose grant names this project, only the fields the activity record
     // keeps. A grant is the scope; an Agent need not have opened a binding.
+    // Every Agent session in the project folder, wherever it was started: Harness conversations Rho
+    // observes and the sessions Claude Code and Codex keep in their own files. Each names the Agent
+    // Rho continues it with and the Rho conversation that already continues it. Reads files only.
+    async agentSessions(p) {
+        const agent = this.plugins.optional('agent');
+        const external = agent ? agent.listExternalSessions(p.root) : { sessions: [], omitted: 0 };
+        const native = (await import('@rho-workspace/plugin-agent/native-sessions')).listNativeSessions(p.root);
+        const conversations = [...await this.conversations.list(p, {}), ...await this.conversations.list(p, { trashed: true })];
+        const bySession = new Map(conversations.filter(c => c.sessionId).map(c => [c.sessionId, c]));
+        const sessions = [...external.sessions, ...native.sessions].flatMap(s => {
+            const conversation = bySession.get(s.sessionId);
+            if (conversation?.trashedAt)
+                return [];
+            const continueWith = s.producer === 'claude-code' ? 'claude-acp' : s.producer === 'codex' ? 'codex-acp' : s.producer === 'dsh' && this.config.acpCommand ? 'acp' : null;
+            // Harness reports a turn in progress, not whether a window holds the session idle; a turn
+            // Rho itself is running is Rho's.
+            const open = s.producer === 'dsh' && s.state === 'running' && conversation?.state !== 'running' ? { where: 'DeepSeek Harness' } : s.open;
+            return [{ ...s, continueWith, ...(open !== undefined ? { open } : {}), ...(conversation ? { conversationId: conversation.conversationId } : {}) }];
+        });
+        // A session held only by Rho's own connection is not open elsewhere.
+        for (const s of sessions)
+            if (s.open && s.conversationId && await this.conversations.owns(p, s.conversationId, s.open.pid))
+                s.open = null;
+        sessions.sort((a, b) => b.lastAt.localeCompare(a.lastAt));
+        return { sessions: sessions.slice(0, 128), omitted: external.omitted + native.omitted + Math.max(0, sessions.length - 128) };
+    }
     async projectActivity(p) {
         const agent = this.plugins.project(p.root, p.id).agent;
         if (!agent)
@@ -1156,10 +1194,15 @@ export class RhoService {
             await this.emit(p, 'composition.changed', b.compositionId);
             return { document, viewId, composition };
         }
+        if (method === 'session.instructions') {
+            requireThat(principal.id === localBrowserId || principal.id === 'operator', 'unauthorized', 'Only the person at this machine can read Agent setup instructions.');
+            return connectionInstructions(p, this.state.directory);
+        }
         if (method === 'session.grant') {
             requireThat(principal.id === 'operator', 'unauthorized', 'Only the local operator may provision a project-scoped session.');
             const file = path.join(this.state.directory, 'agent-' + digest(p.id + ':' + b.externalSessionId) + '.json');
             const connection = await this.agentConnection(p.id, b.externalSessionId, file, b.methods, undefined, b.profile);
+            await this.emit(p, 'activity.changed', method);
             return { profile: connection.profile, connectionFile: file, projectId: p.id, methods: connection.methods, transport: 'stdio-mcp', externalSessionId: b.externalSessionId };
         }
         // The person's own Claude Code or Codex, outside Rho: the same grant the operator gives, kept
@@ -1190,11 +1233,16 @@ export class RhoService {
         // The person at this machine talks to a conversation Rho started; Agents and narrower links
         // cannot start one, and an Agent started this way cannot start another.
         if (method.startsWith('agent.sessions.')) {
-            requireThat(principal.id === localBrowserId, 'unauthorized', 'External conversation history belongs to the person at this machine.');
-            const agent = this.plugins.need('agent');
+            requireThat(principal.id === localBrowserId, 'unauthorized', 'Agent session history belongs to the person at this machine.');
             if (method === 'agent.sessions.list')
-                return agent.listExternalSessions(p.root);
-            return agent.readExternalSession(p.root, b);
+                return this.agentSessions(p);
+            const listed = (await this.agentSessions(p)).sessions.find(s => s.id === b.session);
+            requireThat(listed, 'not_found', 'That Agent session is not in this project.');
+            const read = listed.producer === 'claude-code' || listed.producer === 'codex'
+                ? await (await import('@rho-workspace/plugin-agent/native-sessions')).readNativeSession(p.root, b)
+                : this.plugins.need('agent').readExternalSession(p.root, b);
+            requireThat(read, 'not_found', 'That Agent session is no longer in this project.');
+            return { ...read, session: { ...read.session, ...listed } };
         }
         if (method === 'project.work.read') {
             requireThat(principal.id === localBrowserId, 'scope', 'Project work is available to the person at this machine.');
@@ -1235,10 +1283,25 @@ export class RhoService {
             if (method === 'conversation.settings.read')
                 return this.conversations.settings();
             this.plugins.need('agent');
+            if (method === 'conversation.start' && b.continue) {
+                const listed = (await this.agentSessions(p)).sessions.find(s => s.id === b.continue.session);
+                requireThat(listed, 'not_found', 'That Agent session is not in this project. Nothing was sent.');
+                requireThat(listed.continueWith, 'condition', listed.producer === 'dsh'
+                    ? 'Rho continues DeepSeek Harness sessions through Harness\'s ACP command. Start Rho with --agent-backend acp --acp-command \'["dsh","acp"]\', or continue in Harness. Nothing was sent.'
+                    : 'Rho cannot continue this Agent\'s sessions. Nothing was sent.');
+                requireThat(!listed.conversationId, 'conflict', 'This session already continues as a conversation here. Open it to send your message.');
+                requireThat(!b.continue.copy || listed.producer !== 'dsh', 'condition', 'DeepSeek Harness cannot copy a session. Continue it in place once it is not answering. Nothing was sent.');
+                requireThat(!listed.open || listed.producer !== 'dsh', 'condition', 'DeepSeek Harness is answering in this session now. Continue it once that turn ends. Nothing was sent.', { heldBy: 'DeepSeek Harness' });
+                return this.conversations.start(p, principal.id, { ...b, continue: { producer: listed.producer, sessionId: listed.sessionId, title: listed.title, where: listed.where ?? (listed.producer === 'dsh' ? 'DeepSeek Harness' : 'another window'), copy: !!b.continue.copy, backend: listed.continueWith } });
+            }
             if (method === 'conversation.start')
                 return this.conversations.start(p, principal.id, b);
-            if (method === 'conversation.send')
+            if (method === 'conversation.send') {
+                // A Harness session reports its own turns through its adapter; Rho does not write into one it is answering.
+                const listed = (await this.agentSessions(p)).sessions.find(s => s.conversationId === b.conversationId && s.producer === 'dsh');
+                requireThat(!listed?.open, 'condition', 'DeepSeek Harness is answering in this session now. Send once that turn ends. Nothing was sent.', { heldBy: 'DeepSeek Harness' });
                 return this.conversations.send(p, principal.id, b);
+            }
             if (method === 'conversation.configure')
                 return this.conversations.configure(p, principal.id, b);
             if (method === 'conversation.settings.update')