@rho-workspace/rho 0.5.5 → 0.5.7

package/dist/conversations.js

@@ -1,5 +1,6 @@
 import { projectPath, commandFiles, buildWorkGraph } from './work-graph.js';
 import { notesInstructions, projectNotesPath } from './project-notes.js';
+import { uiContextPrompt } from './ui-context.js';
 import { addSpend, describeLimits, describable, fileFacts, figureContext, raster } from './file-describer.js';
 import { agentTurnLimit, displayCommand, toolActivity } from './conversation-presentation.js';
 import { privateEvidencePath } from './evidence-capture.js';
@@ -8,6 +9,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, installedAcpAgents, knownAcpAgent, locate, 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.
@@ -15,6 +17,9 @@ import { atomicJson, canonical, digest, Fault, now, readJson, requireThat } from
 // settings stays, and a model without Auto falls back to Accept edits with the adapter's warning.
 const claudePreferred = { mode: { value: 'auto', replaces: ['default'] } };
 export const conversationLimits = {
+    // Per-message interface observations: omit and count extra views; refuse an
+    // observation still larger than the byte budget before sending the message.
+    maxUiContextBytes: 16384, maxUiContextViews: 32,
     // Conversations kept per project, not counting the trash; starting or restoring another is
     // refused. The trash keeps as many again; past that, moving one there is refused.
     maxConversations: 64,
@@ -55,6 +60,9 @@ export const conversationLimits = {
     // Settings chosen for one Agent or one conversation, and the length of one chosen value;
     // more are refused.
     maxChoices: 12, maxChoiceChars: 512,
+    // ACP Agents the person adds in Rho, kept in this service's Agent settings and offered in every
+    // project; adding another is refused until one is removed.
+    maxAddedAgents: 16,
     // Files compared on disk before and after a message, to record which changed during it; past
     // this many the comparison stops and the record says it is partial. Changes kept per message;
     // more are counted.
@@ -127,7 +135,13 @@ function compare(before, after, limit) {
     changed.sort((a, b) => (a.modifiedAt ?? '\uffff').localeCompare(b.modifiedAt ?? '\uffff') || a.path.localeCompare(b.path));
     return { changed: changed.slice(0, limit), omitted: Math.max(0, changed.length - limit), partial };
 }
-const backends = ['claude-acp', 'codex-acp', 'acp'];
+const builtIn = ['claude-acp', 'codex-acp', 'acp'];
+const addedName = /^acp:[a-z0-9][a-z0-9-]{0,39}$/;
+const backendName = (value) => typeof value === 'string' && (builtIn.includes(value) || addedName.test(value));
+const generic = (backend) => backend === 'acp' || !!backend?.startsWith('acp:');
+const sameCommand = (a, b) => a.file === b.file && a.args.length === b.args.length && a.args.every((arg, i) => arg === b.args[i]);
+// DeepSeek Harness's own ACP command, which continues the sessions Harness keeps in this folder.
+const harnessCommand = (command) => !!command && (knownAcpAgent(command)?.id === 'dsh' || [command.file, ...command.args].some(part => /(^|[\\/])dsh(\.[a-z]+)?$/i.test(part)));
 const blankSettings = () => ({ format: 1, version: 0, updatedAt: null, backend: null, choices: {}, offered: {} });
 const acpDriver = (driver) => !!driver && 'configure' in driver;
 const identity = /^c-[a-f0-9]{16}$/;
@@ -137,6 +151,9 @@ function cut(text, maxBytes) {
     // Cut on a character boundary; the cut is reported, never silent.
     return { text: Buffer.from(text).subarray(0, maxBytes).toString('utf8').replace(/�+$/, ''), cut: true };
 }
+// Some Agents (Kimi Code) title a session with the start of its first prompt, which carries the
+// interface context Rho appends to the person's words; the title keeps the person's words.
+const agentTitleOf = (title) => title ? title.split(/\s*Rho interface context for this message:/)[0].trim() || null : null;
 function titleOf(text) { const line = text.trim().split('\n')[0].trim(); return line.length > 80 ? line.slice(0, 79) + '…' : line; }
 // An Agent reports a session it no longer has, in its own words: the ACP load answers "Resource
 // not found", Claude Code says the session does not exist, and a load that cannot run at all says
@@ -186,6 +203,8 @@ export class Conversations {
     drivers = new Map();
     permissions = new Map();
     checks = new Map();
+    // Agents being added, by command: a second request for the same command waits for the first.
+    adding = new Map();
     // Descriptions being written by a model now, by project, conversation, message and file.
     writing = new Set();
     describing = { ...describeLimits };
@@ -232,9 +251,10 @@ export class Conversations {
         const last = c.turns.at(-1), usage = c.observation?.usage;
         const costs = c.turns.map(t => t.result?.costUsd).filter((v) => typeof v === 'number');
         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 ?? {},
+            listed: 2, turnLimit: !!last && agentTurnLimit(last), waitingPermission: last?.state === 'running' && !!last.permissions?.some(p => p.state === 'pending'), backend: c.backend ?? 'claude-cli', agentTitle: agentTitleOf(c.observation?.info?.title), 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);
@@ -391,10 +411,12 @@ export class Conversations {
     // Without an Agent or settings named in the request, the person's saved ones are used and
     // recorded with the conversation.
     async start(project, by, input) {
-        requireThat(!input.backend || backends.includes(input.backend), 'invalid', 'Choose Claude Code or Codex.');
+        requireThat(!input.backend || backendName(input.backend), 'invalid', 'Choose an Agent Rho starts.');
         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 } : {}),
+            ...(input.uiContext ? { uiContext: input.uiContext } : {}), ...(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,16 +426,35 @@ 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';
+            // A saved Agent the person has since removed is not used; the service's own is.
+            const savedBackend = saved.backend && (!saved.backend.startsWith('acp:') || this.commandOf(saved.backend, saved)) ? saved.backend : null;
+            const backend = from?.backend ?? input.backend ?? savedBackend ?? this.config.backend ?? 'claude-acp';
+            const command = generic(backend) ? this.commandOf(backend, saved) : undefined;
+            requireThat(!generic(backend) || command, 'unavailable', backend === 'acp' ? 'No ACP command was named when Rho started. Add the Agent under Agents in Rho. Nothing was sent.' : 'That Agent is not added in Rho. Add it under Agents first. Nothing was sent.');
             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 } : {}) };
+            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' : generic(backend) ? 'acp' : 'claude-code', nativeSessionId: backend === 'claude-cli' ? randomUUID() : null, confirmed: false, principal: null, title: titleOf(text), turns: [], ...(config && Object.keys(config).length ? { config } : {}), ...(command ? { acpCommand: command } : {}) };
             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];
+            if (input.uiContext)
+                turn.uiContext = await this.ports.uiContext?.(project, input.uiContext, this.limits);
             c.turns.push(turn);
             // Recorded before the process starts, so a crash in between leaves an unknown message, never a resend.
             await this.write(project, c);
@@ -421,8 +462,31 @@ 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 } : {}) }));
+        const text = this.message(input.text), requestDigest = digest(canonical({ text, ...(input.contexts?.length ? { contexts: input.contexts } : {}), ...(input.uiContext ? { uiContext: input.uiContext } : {}), ...(input.continuationOf ? { continuationOf: input.continuationOf } : {}) }));
         return this.serial(project.id, async () => {
             const c = await this.load(project, input.conversationId), existing = c.turns.find(t => t.changeId === input.changeId);
             if (existing) {
@@ -444,6 +508,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)
@@ -456,6 +523,8 @@ export class Conversations {
                 turn.continuationOf = input.continuationOf;
             if (input.contexts?.length)
                 turn.contexts = [...input.contexts];
+            if (input.uiContext)
+                turn.uiContext = await this.ports.uiContext?.(project, input.uiContext, this.limits);
             c.turns.push(turn);
             await this.write(project, c);
             this.launch(project, c, turn);
@@ -468,7 +537,7 @@ export class Conversations {
         this.choices({ [input.configId]: input.value });
         return this.serial(project.id, async () => {
             const c = await this.load(project, input.conversationId), last = c.turns.at(-1);
-            requireThat(c.backend === 'claude-acp' || c.backend === 'codex-acp' || c.backend === 'acp', 'unavailable', 'This conversation\'s Agent has no settings Rho can change.');
+            requireThat(c.backend === 'claude-acp' || c.backend === 'codex-acp' || generic(c.backend), 'unavailable', 'This conversation\'s Agent has no settings Rho can change.');
             requireThat(!c.trashedAt, 'conflict', 'This conversation is in the trash. Restore it to change its settings.');
             requireThat(!last || last.state !== 'running' || !this.liveTurn(project, c, last), 'conflict', 'The Agent is answering. Change its settings after this message.');
             const driver = this.drivers.get(project.id + '/' + c.id)?.driver;
@@ -509,20 +578,53 @@ export class Conversations {
         return value;
     }
     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 } };
+        const service = this.config.backend ?? 'claude-acp', added = s.added ?? [];
+        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(s),
+            added: added.map(a => ({ backend: a.backend, name: a.name, command: [a.command.file, ...a.command.args], addedAt: a.addedAt })),
+            // The ACP Agents Rho knows that are installed here and not yet added. Finding them reads PATH.
+            installed: installedAcpAgents(process.env).filter(i => !(this.config.acpCommand && sameCommand(i.command, this.config.acpCommand)) && !added.some(a => sameCommand(a.command, i.command)))
+                .map(i => ({ id: i.id, name: i.name, command: [i.command.file, ...i.command.args] })) };
+    }
+    // The command that starts an ACP Agent other than Claude Code or Codex: one the person added, or
+    // the one named when this service started.
+    commandOf(backend, s) {
+        return backend === 'acp' ? this.config.acpCommand : s.added?.find(a => a.backend === backend)?.command;
+    }
+    // Which Agents this service can start: the person's installed clients, found as the adapters
+    // find them, the ACP command named when it started and the ACP Agents the person added. Looking
+    // starts nothing. The named command's Agent is named as Rho knows it, else as it named itself the
+    // last time it answered, else by its program.
+    agents(s) {
+        const found = (problem) => problem ? { found: false, problem } : { found: true };
+        const command = this.config.acpCommand, reported = s.offered.acp?.adapter?.name;
+        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: knownAcpAgent(command)?.name ?? (harnessCommand(command) ? 'DeepSeek Harness' : reported || path.basename(command.file).replace(/\.(exe|cmd)$/i, '')) } : { found: false, problem: 'No ACP command was named when Rho started.' },
+            ...Object.fromEntries((s.added ?? []).map(a => [a.backend, locate(a.command.file, process.env) ? { found: true, name: a.name }
+                    : { found: false, name: a.name, problem: `${a.name} is no longer at ${a.command.file}. Install it again, or remove it and add it again.` }]))
+        };
+    }
+    // The Agent that continues DeepSeek Harness's sessions: Harness's own ACP command, named when
+    // Rho started or added by the person.
+    async harness() {
+        if (harnessCommand(this.config.acpCommand))
+            return 'acp';
+        return (await this.readSettings()).added?.find(a => harnessCommand(a.command))?.backend ?? null;
     }
     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
     // whole and must be among the values it last offered; a stale version is refused.
     async updateSettings(input) {
         requireThat(this.config.settingsFile, 'unavailable', 'This service keeps no Agent settings.');
-        requireThat(input.backend == null || backends.includes(input.backend), 'invalid', 'Choose Claude Code or Codex.');
         return this.serial('settings', async () => {
             const s = await this.readSettings();
             requireThat(s.version === input.expectedVersion, 'conflict', 'The Agent settings changed in another tab. Read them again.', { version: s.version });
+            const startable = (backend) => backendName(backend) && (builtIn.includes(backend) || !!this.commandOf(backend, s));
+            requireThat(input.backend == null || startable(input.backend), 'invalid', 'Choose an Agent Rho starts.');
             for (const [backend, values] of Object.entries(input.choices ?? {})) {
-                requireThat(backends.includes(backend), 'invalid', 'Choose Claude Code or Codex.');
+                requireThat(startable(backend), 'invalid', 'Choose an Agent Rho starts.');
                 this.choices(values);
                 const offered = s.offered[backend]?.options;
                 requireThat(offered || !Object.keys(values).length, 'unavailable', 'Check what this Agent offers first.');
@@ -546,7 +648,7 @@ export class Conversations {
     // ends the process; no message is sent. The protected resource is local Agent processes: one
     // check per Agent at a time (a second request waits for the same one), each bounded by connectTimeoutMs.
     async check(project, input) {
-        requireThat(backends.includes(input.backend), 'invalid', 'Choose Claude Code or Codex.');
+        requireThat(backendName(input.backend), 'invalid', 'Choose an Agent Rho starts.');
         requireThat(this.config.settingsFile, 'unavailable', 'This service keeps no Agent settings.');
         requireThat(!this.closing, 'unavailable', 'Rho is closing. Nothing was started.');
         let pending = this.checks.get(input.backend);
@@ -560,7 +662,9 @@ export class Conversations {
     async inspect(project, backend) {
         const { ClaudeAcpConversation, CodexAcpConversation, GenericAcpConversation } = await import('@rho-workspace/plugin-agent/conversation');
         const common = { cwd: project.root, mcpServers: [], limits: this.limits };
-        const driver = backend === 'codex-acp' ? new CodexAcpConversation({ ...this.config.codexAcp, ...common, codex: this.config.codex }) : backend === 'acp' ? new GenericAcpConversation({ ...common, command: this.config.acpCommand }) : new ClaudeAcpConversation({ preferred: claudePreferred, ...this.config.claudeAcp, ...common, claude: this.binary });
+        const command = generic(backend) ? this.commandOf(backend, await this.readSettings()) : undefined;
+        requireThat(!generic(backend) || command, 'unavailable', backend === 'acp' ? 'No ACP command was named when Rho started.' : 'That Agent is not added in Rho.');
+        const driver = backend === 'codex-acp' ? new CodexAcpConversation({ ...this.config.codexAcp, ...common, codex: this.config.codex }) : command ? new GenericAcpConversation({ ...common, command }) : new ClaudeAcpConversation({ preferred: claudePreferred, ...this.config.claudeAcp, ...common, claude: this.binary });
         let found;
         try {
             found = await driver.inspect();
@@ -581,6 +685,77 @@ export class Conversations {
             await atomicJson(this.config.settingsFile, s);
         });
     }
+    // An ACP Agent the person adds for new conversations in every project. Rho starts its command once
+    // in this project, as a check does (it opens a session, reads what the Agent offers and removes
+    // the session; no message is sent), and keeps it only when the Agent answered. The command is
+    // the person's own: a program on PATH or a path to one, and its arguments. Adding the same
+    // command again checks it again; one start per command runs at a time.
+    async addAgent(project, input) {
+        requireThat(this.config.settingsFile, 'unavailable', 'This service keeps no Agent settings.');
+        requireThat(!this.closing, 'unavailable', 'Rho is closing. Nothing was started.');
+        const [program, ...args] = input.command;
+        const file = locate(program, process.env);
+        requireThat(file, 'unavailable', `${program} was not found ${/[\\/]/.test(program) ? 'there' : 'on PATH'}. Install it, or give the path of its program.`);
+        const command = { file: path.resolve(file), args }, key = JSON.stringify(command);
+        let pending = this.adding.get(key);
+        if (!pending) {
+            pending = this.addOnce(project, command).finally(() => this.adding.delete(key));
+            this.adding.set(key, pending);
+        }
+        return pending;
+    }
+    async addOnce(project, command) {
+        const known = knownAcpAgent(command), label = known?.name ?? path.basename(command.file);
+        const room = (s) => requireThat(s.added?.some(a => sameCommand(a.command, command)) || (s.added?.length ?? 0) < this.limits.maxAddedAgents, 'limit', `Rho keeps at most ${this.limits.maxAddedAgents} added Agents. Remove one first. Nothing was started.`, { limit: 'maxAddedAgents', maximum: this.limits.maxAddedAgents });
+        room(await this.readSettings());
+        const { GenericAcpConversation } = await import('@rho-workspace/plugin-agent/conversation');
+        let found;
+        try {
+            found = await new GenericAcpConversation({ cwd: project.root, mcpServers: [], limits: this.limits, command }).inspect();
+        }
+        catch (error) {
+            throw new Fault('unavailable', `${label} did not start as an ACP Agent (${(error instanceof Error ? error.message : String(error)).replace(/\.$/, '')}). Nothing was added.`);
+        }
+        return this.serial('settings', async () => {
+            const s = await this.readSettings(), added = s.added ?? [], existing = added.find(a => sameCommand(a.command, command));
+            room(s);
+            const name = existing?.name ?? known?.name ?? found.adapter?.name ?? label;
+            const backend = existing?.backend ?? this.newName(known?.id ?? found.adapter?.name ?? label, added);
+            if (!existing)
+                s.added = [...added, { backend, name, command, addedAt: now() }];
+            s.offered[backend] = { at: now(), source: 'check', adapter: found.adapter, options: found.options, omitted: found.omitted };
+            s.version++;
+            s.updatedAt = now();
+            await atomicJson(this.config.settingsFile, s);
+            return this.settingsView(s);
+        });
+    }
+    newName(seed, added) {
+        const base = seed.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 32) || 'agent';
+        for (let n = 1;; n++) {
+            const name = `acp:${base}${n > 1 ? '-' + n : ''}`;
+            if (!added.some(a => a.backend === name))
+                return name;
+        }
+    }
+    // Removing an added Agent takes it out of every Agent menu. Its conversations stay, each with
+    // the command it started with, so they can still be read and continued.
+    async removeAgent(input) {
+        requireThat(this.config.settingsFile, 'unavailable', 'This service keeps no Agent settings.');
+        return this.serial('settings', async () => {
+            const s = await this.readSettings(), backend = input.backend;
+            requireThat(s.added?.some(a => a.backend === backend), 'not_found', 'No Agent added in Rho has that name.');
+            s.added = s.added.filter(a => a.backend !== backend);
+            delete s.choices[backend];
+            delete s.offered[backend];
+            if (s.backend === backend)
+                s.backend = null;
+            s.version++;
+            s.updatedAt = now();
+            await atomicJson(this.config.settingsFile, s);
+            return this.settingsView(s);
+        });
+    }
     // A stop is a request until the driver confirms it; what was already done stays done.
     async stop(project, by, input) {
         return this.serial(project.id, async () => {
@@ -733,12 +908,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);
@@ -754,7 +937,7 @@ export class Conversations {
             const observed = { observation: c.observation, observe: (observation) => {
                     requireThat(observation.sessionId === c.acpSessionId, 'conflict', 'The observed Agent session differs from the retained identity.');
                     requireThat(Buffer.byteLength(JSON.stringify(observation)) <= this.limits.maxObservationBytes, 'limit', 'The session projection exceeded maxObservationBytes; prior observations were kept.');
-                    const config = observation.config, learned = config && config.at !== c.observation?.config?.at && config.origin === 'initial' && !c.config && (c.backend === 'claude-acp' || c.backend === 'codex-acp' || c.backend === 'acp');
+                    const config = observation.config, learned = config && config.at !== c.observation?.config?.at && config.origin === 'initial' && !c.config && (c.backend === 'claude-acp' || c.backend === 'codex-acp' || generic(c.backend));
                     c.observation = observation;
                     this.schedule(project, c);
                     for (const live of this.live.values())
@@ -770,13 +953,16 @@ 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 };
+            // A conversation started before Rho kept its ACP command uses the one named at this start.
+            const command = generic(c.backend) ? c.acpCommand ?? (c.backend === 'acp' ? this.config.acpCommand : undefined) : undefined;
+            requireThat(!generic(c.backend) || command, 'unavailable', 'This conversation\'s ACP Agent was named when Rho started, and this start names none. Start Rho with the same --acp-command to continue it.');
             const driver = c.backend === 'codex-acp'
                 ? new CodexAcpConversation({ ...this.config.codexAcp, ...common, codex: this.config.codex })
                 : c.backend === 'claude-acp'
                     ? new ClaudeAcpConversation({ preferred: claudePreferred, ...this.config.claudeAcp, ...common, claude: this.binary, plugins: [...this.config.claudeAcp?.plugins ?? [], ...await this.ports.claudePlugins?.(project) ?? []] })
-                    : c.backend === 'acp'
-                        ? new GenericAcpConversation({ ...common, command: this.config.acpCommand })
+                    : command
+                        ? new GenericAcpConversation({ ...common, command })
                         : new ClaudeCliConversation({ cwd: project.root, binary: this.binary, sessionId: c.nativeSessionId, confirmed: c.confirmed, projectName: project.name ?? path.basename(project.root), mcpServers, limits: this.limits, instructions });
             this.drivers.set(key, { driver, project, conversation: c });
             return driver;
@@ -965,7 +1151,7 @@ export class Conversations {
                     }
                 }
             });
-            const utterance = turn.text + (turn.continuationOf ? '\n\nOriginal task:\n' + c.turns[0].text : '') + (turn.contexts?.length ? '\n\nRead these exact frozen review contexts with context.read before responding: ' + turn.contexts.join(', ') + '. Reply with annotation.reply and explicit result resource versions.' : '');
+            const utterance = turn.text + uiContextPrompt(turn.uiContext) + (turn.continuationOf ? '\n\nOriginal task:\n' + c.turns[0].text : '') + (turn.contexts?.length ? '\n\nRead these exact frozen review contexts with context.read before responding: ' + turn.contexts.join(', ') + '. Reply with annotation.reply and explicit result resource versions.' : '');
             // The Agent's session ended with its process: after Rho restarts, and on a machine that
             // never ran the session a project was copied from. The messages Rho kept are the record, so
             // the message runs in a new session told what was said before. Nothing is resent as a new
@@ -1071,7 +1257,7 @@ export class Conversations {
         const given = shown.get(file);
         const reason = !enabled ? 'Descriptions by a model are switched off; the facts are kept.'
             : c.backend === 'codex-acp' ? 'Descriptions are written with Claude Code; this session\'s Agent is Codex.'
-                : c.backend === 'acp' ? 'Descriptions are written with Claude Code; this session\'s Agent is a configured ACP agent.'
+                : generic(c.backend) ? 'Descriptions are written with Claude Code; this session\'s Agent is another ACP Agent.'
                     : !this.ports.describe ? 'No model is set up to describe files.' : null;
         const keep = (why) => { if (record.reason !== why) {
             record.state = record.sentence ? 'described' : 'facts';

package/dist/discovery.js

@@ -4,10 +4,10 @@ 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']),
-    ...['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']),
+    ...['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', 'composition.delete', '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']),
+    ...['extension.call', 'extension.install', 'extension.manage', 'extension.market.change', 'action.retry', 'action.cancel'].map(m => [m, 'native']),
 ]);
 const rhoSummary = 'The project in Rho: its folder\'s entries, managed runs, the views on the person\'s screen and what is selected in them, the task map, and which plugins are on.';
 const metadata = new Set(['capability.index', 'capability.resolve', 'binding.activity.append', 'task.routing.put', 'feedback.submit', 'view.observe', 'view.observations.read']);

package/dist/extension-contract.d.ts

@@ -35,6 +35,18 @@ export declare const extensionOperations: {
         required: string[];
         additionalProperties: boolean;
     };
+    'extension.market.change': {
+        oneOf: {
+            type: string;
+            properties: Record<string, unknown>;
+            required: string[];
+            additionalProperties: boolean;
+        }[];
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
     'extension.manage': {
         type: string;
         properties: Record<string, unknown>;
@@ -49,6 +61,12 @@ export declare const extensionResponses: {
         required: string[];
         additionalProperties: boolean;
     };
+    'extension.market.change': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
     'extension.describe': {
         type: string;
         properties: Record<string, unknown>;
@@ -88,6 +106,7 @@ export declare const extensionResponses: {
 };
 export declare const extensionDescriptions: {
     'extension.list': string;
+    'extension.market.change': string;
     'extension.describe': string;
     'extension.content': string;
     'extension.call': string;

package/dist/extension-contract.js

@@ -1,5 +1,6 @@
 // Installed third-party packages are application assembly, independent of the
 // functional owners compiled into Rho. This protocol never imports their code.
+import { marketEntrySchema } from './extension-markets.js';
 const str = { type: 'string', minLength: 1, maxLength: 1024 };
 const id = { type: 'string', pattern: '^[a-z0-9][a-z0-9._-]{0,95}$' };
 const sha = { type: 'string', pattern: '^[a-f0-9]{64}$' };
@@ -7,13 +8,19 @@ const object = (properties, required = Object.keys(properties)) => ({ type: 'obj
 const json = { type: 'object', additionalProperties: true };
 const project = { projectId: str };
 const selected = { ...project, pluginId: id, expectedDigest: sha };
+const marketOrigin = object({ id, title: str, url: str, digest: sha, keywords: { type: 'array', maxItems: 16, items: { type: 'string', minLength: 1, maxLength: 64 } } }, ['id', 'title', 'url', 'digest']);
+const marketSelection = object({ id, expectedDigest: sha, pluginId: id });
+const revision = { type: 'integer', minimum: 1 };
+const marketChange = { ...object({ action: { enum: ['add', 'refresh', 'remove'] }, url: str, id, expectedRevision: revision }, ['action']), oneOf: [object({ action: { const: 'add' }, url: str }), object({ action: { enum: ['refresh', 'remove'] }, id, expectedRevision: revision })] };
+const market = object({ id, url: str, title: str, revision, digest: sha, fetchedAt: str, checkedAt: str, error: { type: ['string', 'null'] }, plugins: { type: 'array', items: marketEntrySchema } });
 export const extensionOperations = {
     'extension.list': object(project, []),
     'extension.describe': object({ ...project, pluginId: id }),
     'extension.content': object({ ...selected, kind: { enum: ['skill', 'view'] }, entryId: id }),
     'extension.call': object({ ...selected, operation: id, input: json, changeId: { type: 'string', pattern: '^[A-Za-z0-9._:@-]{1,128}$' } }),
     'extension.read': object({ ...project, invocationId: sha }),
-    'extension.install': object({ source: str, replace: id, expectedDigest: sha }, ['source']),
+    'extension.install': object({ source: str, replace: id, expectedDigest: sha, market: marketSelection }, ['source']),
+    'extension.market.change': marketChange,
     'extension.manage': object({ pluginId: id, expectedDigest: sha, action: { enum: ['enable', 'disable', 'remove'] } }),
 };
 const array = (items) => ({ type: 'array', items });
@@ -23,15 +30,16 @@ const manifest = { ...object({ apiVersion: { const: 1 }, id, title: text, descri
         operations: array({ ...object({ id, title: text, description: text, effect: { enum: ['read', 'native'] }, methods: array(text), inputSchema: json }), additionalProperties: true }),
         skills: array(entry), views: array(entry),
     }, ['apiVersion', 'id', 'title', 'description', 'operations', 'skills', 'views']), additionalProperties: true };
-const installed = { id, name: text, version: text, title: text, description: text, digest: sha, source: text, sourceCommit: text, enabled: { type: 'boolean' }, installedAt: text };
-const installedRequired = Object.keys(installed).filter(key => key !== 'sourceCommit');
+const installed = { id, name: text, version: text, title: text, description: text, digest: sha, source: text, sourceCommit: text, market: marketOrigin, enabled: { type: 'boolean' }, installedAt: text };
+const installedRequired = Object.keys(installed).filter(key => !['sourceCommit', 'market'].includes(key));
 const descriptor = object({ ...installed, manifest }, [...installedRequired, 'manifest']);
 const receipt = object({ invocationId: sha, caller: text, projectId: text, pluginId: id, packageDigest: sha, operation: id, requestDigest: sha,
     state: { enum: ['pending', 'completed', 'unknown'] }, startedAt: text, endedAt: text, value: {}, error: text,
     delegations: array(object({ method: text, request: {}, state: { enum: ['pending', 'completed', 'unknown'] }, value: {}, error: text }, ['method', 'request', 'state'])),
 }, ['invocationId', 'caller', 'projectId', 'pluginId', 'packageDigest', 'operation', 'requestDigest', 'state', 'startedAt']);
 export const extensionResponses = {
-    'extension.list': object({ plugins: array(object(installed, installedRequired)), directory: array(object({ id, title: text, version: text, description: text, source: text, repository: text, needs: text })), limits: json }),
+    'extension.list': object({ plugins: array(object(installed, installedRequired)), directory: array(object({ id, title: text, version: text, description: text, source: text, repository: text, needs: text })), markets: array(market), limits: json }),
+    'extension.market.change': object({ markets: array(market) }),
     'extension.describe': descriptor,
     'extension.install': descriptor,
     'extension.content': object({ pluginId: id, packageDigest: sha, entryId: id, kind: { enum: ['skill', 'view'] }, title: text, text }),
@@ -40,7 +48,8 @@ export const extensionResponses = {
     'extension.manage': object({ pluginId: id, action: { enum: ['enable', 'disable', 'remove'] }, retained: text }),
 };
 export const extensionDescriptions = {
-    'extension.list': 'List independently installed third-party packages and their enabled state, source and immutable digest. Reads start no plugin or runtime. Use extension.describe to discover operation schemas and Skills.',
+    'extension.list': 'List installed third-party packages, the bundled directory and retained remote market indexes. Listing makes no network request and starts no plugin or runtime. Use extension.describe for installed operation schemas and Skills.',
+    'extension.market.change': 'Local person/operator: add an HTTPS plugin market index, refresh it explicitly, or remove its source. Failed refresh retains the last valid index; removal preserves installed plugins. Listing never refreshes a source.',
     'extension.describe': 'Read an installed third-party package manifest, operation input schemas, required Rho methods, Skills and views. Read its Skill with extension.content before use. Disabled packages cannot run.',
     'extension.content': 'Read one installed plugin Skill or standalone HTML view at its selected package digest. Reading starts no plugin or runtime.',
     'extension.call': 'Call an enabled third-party operation at the described package digest, under the caller and project. The package runs trusted native code. Non-read calls retain the original changeId: repeat observes that invocation, including unknown outcomes, without re-execution. Completion is not scientific validity.',
@@ -48,5 +57,5 @@ export const extensionDescriptions = {
     'extension.install': 'Local person/operator: install a trusted prebuilt npm package, local folder, tarball, or Git source. Lifecycle scripts are disabled. Replacement stages and checks the new package before switching; use replace and expectedDigest for updates.',
     'extension.manage': 'Local person/operator: enable, disable or remove an installed third-party package at the expected digest. Existing native tasks, R sessions, project files and retained receipts are preserved.',
 };
-export const extensionManagement = ['extension.install', 'extension.manage'];
+export const extensionManagement = ['extension.install', 'extension.manage', 'extension.market.change'];
 export const extensionMethods = Object.keys(extensionOperations);

package/dist/extension-markets.d.ts

@@ -0,0 +1,74 @@
+export declare const marketLimits: {
+    maxMarkets: number;
+    maxMarketBytes: number;
+    maxMarketEntries: number;
+    marketTimeoutMs: number;
+};
+export declare const marketEntrySchema: {
+    type: string;
+    properties: Record<string, unknown>;
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const marketIndexSchema: {
+    type: string;
+    properties: Record<string, unknown>;
+    required: string[];
+    additionalProperties: boolean;
+};
+export interface MarketEntry {
+    id: string;
+    title: string;
+    version: string;
+    description: string;
+    source: string;
+    repository: string;
+    needs: string;
+    keywords?: string[];
+}
+export interface ExtensionMarket {
+    id: string;
+    url: string;
+    title: string;
+    revision: number;
+    digest: string;
+    fetchedAt: string;
+    checkedAt: string;
+    error: string | null;
+    plugins: MarketEntry[];
+}
+export interface MarketSelection {
+    id: string;
+    expectedDigest: string;
+    pluginId: string;
+}
+export type MarketChange = {
+    action: 'add';
+    url: string;
+} | {
+    action: 'refresh' | 'remove';
+    id: string;
+    expectedRevision: number;
+};
+export declare class ExtensionMarkets {
+    readonly directory: string;
+    readonly limits: typeof marketLimits;
+    private values;
+    constructor(directory: string, limits: typeof marketLimits);
+    init(): Promise<void>;
+    list(): ExtensionMarket[];
+    private save;
+    private fetch;
+    private observe;
+    change(input: MarketChange): Promise<ExtensionMarket[]>;
+    select(selection: MarketSelection, source: string): {
+        entry: MarketEntry;
+        origin: {
+            id: string;
+            title: string;
+            url: string;
+            digest: string;
+            keywords: string[];
+        };
+    };
+}