@rho-workspace/rho 0.5.4 → 0.5.6

package/dist/plugin-cli.js

@@ -0,0 +1,139 @@
+import * as fs from 'node:fs/promises';
+import { watch } from 'node:fs';
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { parseArgs } from 'node:util';
+import { randomUUID } from 'node:crypto';
+import { Extensions } from './extensions.js';
+import { RhoClient } from './client.js';
+const help = `Independent Rho plugins (API 1)
+  rho plugin create DIRECTORY [--id my-plugin]
+  rho plugin check DIRECTORY
+  rho plugin add SOURCE [--connection FILE]
+  rho plugin list
+  rho plugin update ID [--source SOURCE]
+  rho plugin enable|disable|remove ID
+  rho plugin dev DIRECTORY
+  rho plugin call ID OPERATION --project RELATIVE_FOLDER --input JSON [--change-id ID]
+
+SOURCE: npm package, local folder/.tgz, public HTTPS .tgz, or
+git+https://host/repo.git#ref:relative/package
+Management uses the running Rho's private connection file (default ~/Rho/state/connection.json).
+Only install packages you trust: hosts run native code with your OS permissions.
+Install skips lifecycle scripts. Build packages before adding them.
+dev watches source and installs checked snapshots; an invalid edit keeps the previous version.
+Remove preserves project files, live sessions, receipts and retained package revisions.
+`;
+export async function pluginCli(args) {
+    const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { connection: { type: 'string' }, id: { type: 'string' }, source: { type: 'string' }, project: { type: 'string' }, input: { type: 'string' }, 'change-id': { type: 'string' }, help: { type: 'boolean' } } });
+    const [command, target, operation] = positionals;
+    if (values.help || !command) {
+        process.stdout.write(help);
+        return;
+    }
+    if (command === 'create') {
+        if (!target)
+            throw new Error('Name a new plugin directory.');
+        const id = values.id ?? path.basename(path.resolve(target));
+        if (!/^[a-z0-9][a-z0-9._-]{0,95}$/.test(id))
+            throw new Error('Use a lowercase plugin id containing letters, digits, dots, underscores or hyphens.');
+        await fs.mkdir(path.resolve(target));
+        const manifest = { apiVersion: 1, id, title: id, description: 'An independent Rho plugin.', host: 'host.mjs', operations: [{ id: 'greet', title: 'Greet', description: 'Return a greeting without changing project data.', effect: 'read', methods: [], inputSchema: { type: 'object', properties: { name: { type: 'string', maxLength: 120 } }, required: ['name'], additionalProperties: false } }], skills: [{ id: 'guide', title: 'Use this plugin', file: 'SKILL.md' }], views: [{ id: 'main', title: id, file: 'view.html' }] };
+        const files = {
+            'package.json': JSON.stringify({ name: 'rho-plugin-' + id, version: '0.1.0', type: 'module', license: 'MIT', rhoPlugin: 'rho-plugin.json', files: ['rho-plugin.json', 'host.mjs', 'view.html', 'SKILL.md'] }, null, 2) + '\n',
+            'rho-plugin.json': JSON.stringify(manifest, null, 2) + '\n',
+            'host.mjs': `export async function run(operation, input, context) {\n  if (operation === 'greet') return { greeting: 'Hello, ' + input.name + '!' };\n  throw new Error('Unknown operation');\n}\n`,
+            'SKILL.md': `# ${id}\n\nRead extension.describe for the installed digest and operation schemas. Call greet with a name. This operation reads only. Use a stable changeId for native operations; observe extension.read after a lost reply.\n`,
+            'view.html': `<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${id}</title><style>body{font:16px system-ui;margin:24px;color:#24312b}input,button{font:inherit;padding:8px}output{display:block;margin-top:16px}</style><h1>${id}</h1><form><label>Your name <input name="name" value="World" maxlength="120"></label> <button>Greet</button></form><output aria-live="polite"></output><script>document.querySelector('form').onsubmit=async e=>{e.preventDefault();const out=document.querySelector('output');try{const result=await rho.call('greet',{name:e.target.elements.name.value});out.textContent=result.value?.greeting||result.error}catch(error){out.textContent=error.message}};</script></html>\n`,
+            'README.md': `# ${id}\n\nDevelop: \`rho plugin dev .\`\nCheck: \`rho plugin check .\`\nDistribute: \`npm pack --ignore-scripts\`, then share the tarball, Git package source or publish to your own npm namespace.\n\nSee Rho's docs/THIRD-PARTY-PLUGINS.md for the host and iframe APIs, permissions and contribution process.\n`,
+        };
+        for (const [file, text] of Object.entries(files))
+            await fs.writeFile(path.join(target, file), text, { flag: 'wx' });
+        process.stdout.write(`Created ${path.resolve(target)}. Run rho plugin check, then rho plugin dev.\n`);
+        return;
+    }
+    if (command === 'check') {
+        if (!target)
+            throw new Error('Name a plugin directory.');
+        const checked = await new Extensions('').check(path.resolve(target));
+        process.stdout.write(JSON.stringify({ valid: true, ...checked }, null, 2) + '\n');
+        return;
+    }
+    const client = await RhoClient.fromFile(path.resolve(values.connection ?? path.join(homedir(), 'Rho', 'state', 'connection.json')));
+    const list = async () => (await client.call('extension.list', {})).plugins;
+    const find = async () => { const p = (await list()).find(p => p.id === target); if (!p)
+        throw new Error('Plugin is not installed: ' + target); return p; };
+    // npm/Git staging can take longer than the ordinary 30-second observation client.
+    // There is no execution retry here; a lost response is reconciled with list.
+    const install = async (body) => {
+        const local = body.source.startsWith('file:') ? body.source.slice(5) : body.source;
+        if (await fs.stat(path.resolve(local)).catch(() => null))
+            body = { ...body, source: path.resolve(local) };
+        const response = await fetch(new URL('/api/v2/extension.install', client.connection.url), { method: 'POST', headers: { authorization: 'Bearer ' + client.connection.token, 'content-type': 'application/json' }, body: JSON.stringify(body) });
+        const result = await response.json();
+        if (!result.ok)
+            throw new Error(result.error.message);
+        return result.value;
+    };
+    let result;
+    if (command === 'list')
+        result = await list();
+    else if (command === 'add') {
+        if (!target)
+            throw new Error('Name a package source.');
+        result = await install({ source: target });
+    }
+    else if (command === 'update') {
+        const p = await find();
+        result = await install({ source: values.source ?? p.source, replace: p.id, expectedDigest: p.digest });
+    }
+    else if (['enable', 'disable', 'remove'].includes(command)) {
+        const p = await find();
+        result = await client.call('extension.manage', { pluginId: p.id, expectedDigest: p.digest, action: command });
+    }
+    else if (command === 'call') {
+        if (!operation || !values.project)
+            throw new Error('Call needs an operation and --project.');
+        const p = await find(), project = await client.call('project.open', { path: values.project });
+        const changeId = values['change-id'] ?? randomUUID();
+        process.stderr.write('changeId: ' + changeId + '\n');
+        result = await client.call('extension.call', { projectId: project.id, pluginId: p.id, expectedDigest: p.digest, operation, input: JSON.parse(values.input ?? '{}'), changeId });
+    }
+    else if (command === 'dev') {
+        if (!target)
+            throw new Error('Name a plugin directory.');
+        const root = path.resolve(target), checked = await new Extensions('').check(root);
+        let busy = false, pending = false;
+        const update = async () => {
+            if (busy) {
+                pending = true;
+                return;
+            }
+            busy = true;
+            try {
+                const p = (await list()).find(p => p.id === checked.manifest.id);
+                const installed = await install({ source: root, ...(p ? { replace: p.id, expectedDigest: p.digest } : {}) });
+                process.stdout.write(`Installed ${installed.id} ${installed.version} ${installed.digest}. Reopen its view to load this snapshot.\n`);
+            }
+            catch (e) {
+                process.stderr.write((e instanceof Error ? e.message : String(e)) + '\n');
+            }
+            finally {
+                busy = false;
+                if (pending) {
+                    pending = false;
+                    void update();
+                }
+            }
+        };
+        await update();
+        let timer;
+        watch(root, { recursive: true }, (_event, filename) => { if (filename?.split(/[\\/]/).some(p => p === 'node_modules' || p === '.git'))
+            return; clearTimeout(timer); timer = setTimeout(() => void update(), 400); });
+        process.stdout.write('Watching ' + root + '. Stop with Ctrl-C.\n');
+        return;
+    }
+    else
+        throw new Error('Unknown plugin command.\n' + help);
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+}

package/dist/plugin-inventory.json

@@ -768,6 +768,24 @@
       },
       "listing": {
         "actions": [
+          {
+            "presentation": {
+              "order": 58,
+              "displayName": "External conversations",
+              "description": "Reads retained conversations observed in this project. Input remains in the original client.",
+              "readOnly": true,
+              "runsCode": false
+            }
+          },
+          {
+            "presentation": {
+              "order": 59,
+              "displayName": "External conversation",
+              "description": "Reads native turns, tool outcomes and result receipts without sending or resuming anything.",
+              "readOnly": true,
+              "runsCode": false
+            }
+          },
           {
             "presentation": {
               "order": 62,

package/dist/plugins.d.ts

@@ -74,7 +74,7 @@ export declare class Plugins {
             timeoutSeconds?: number;
         }[];
     };
-    ids(): ("media" | "r" | "agent" | "files" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel" | "skills")[];
+    ids(): ("media" | "r" | "agent" | "files" | "skills" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel")[];
     isKnown(id: string): id is PluginId;
     availabilityFor(id: PluginId): any;
     need<K extends PluginId>(id: K): Modules[K];
@@ -161,10 +161,10 @@ export declare class Plugins {
         reason?: undefined;
     };
     descriptors(): PluginDescriptor[];
-    availableIds(): ("media" | "r" | "agent" | "files" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel" | "skills")[];
+    availableIds(): ("media" | "r" | "agent" | "files" | "skills" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel")[];
     descriptor(id: string): PluginDescriptor | undefined;
     nativeAvailability(rscript: string): Promise<any>;
-    operationOwner(method: string): "media" | "r" | "agent" | "files" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel" | "skills" | undefined;
+    operationOwner(method: string): "media" | "r" | "agent" | "files" | "skills" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel" | undefined;
     operationDeclarations(): {
         owner: string;
         method: string;

package/dist/project-work.d.ts

@@ -1,6 +1,6 @@
 import type { Conversations } from './conversations.js';
 import type { Project } from './state.js';
-import type { observeSessionFiles, readAgentActivity, readExternalAcp } from '@rho-workspace/plugin-agent';
+import type { observeSessionFiles, readAgentActivity, readExternalAcp, listExternalSessions, readExternalSession } from '@rho-workspace/plugin-agent';
 import type { RhoOutput } from './contract.generated.js';
 export declare function projectWork(input: {
     project: Project;
@@ -24,4 +24,6 @@ export declare function projectWork(input: {
     native: Awaited<ReturnType<typeof readAgentActivity>> | null;
     external?: ReturnType<typeof readExternalAcp>;
     inspect?: typeof observeSessionFiles;
+    observed?: ReturnType<typeof listExternalSessions>;
+    readObserved?: typeof readExternalSession;
 }): Promise<RhoOutput<'project.work.read'>>;

package/dist/project-work.js

@@ -20,10 +20,23 @@ export async function projectWork(input) {
         lastMessage: s.lastMessage, omittedMessageChars: s.omittedMessageChars, pendingPermissions: s.pendingPermissions,
         operationIds: [], resourceRefs: [] }));
     const refs = [...owned, ...external].flatMap(s => [...(s.observation?.tools ?? [])].reverse().flatMap(t => t.locations.map(l => ({ path: l.path, session: s.id, tool: t.id }))));
+    const observed = (input.observed?.sessions ?? []).slice(0, 8).map(s => {
+        let turns = [];
+        try {
+            turns = input.readObserved?.(input.project.root, { session: s.id, limit: 2 }).turns ?? [];
+        }
+        catch { /* Summary remains available when detail cannot be read. */ }
+        for (const turn of turns)
+            for (const tool of turn.tools)
+                for (const path of tool.paths)
+                    refs.push({ path, session: s.id, tool: tool.id });
+        const resources = turns.flatMap(t => t.results.filter(r => r.id && r.version && r.projectId === input.project.id).map(r => ({ id: r.id, version: r.version })));
+        return { id: s.id, source: 'external-session', sessionId: s.sessionId, title: s.title, agent: s.producer, state: s.state, version: s.sourceCursor, observation: null, operationIds: [], resourceRefs: [...new Map(resources.map(r => [r.id + '@' + r.version, r])).values()] };
+    });
     const inspected = input.inspect ? await input.inspect(input.project.root, refs) : { files: [], omitted: refs.length };
     return { projectId: input.project.id, cursor: input.cursor, observedAt: new Date().toISOString(),
         notes: { path: notesPath, ...(note ? { documentId: note.id, version: note.version, dirty: note.dirty } : {}) },
-        sessions: [...owned, ...external, ...native], files: inspected.files,
+        sessions: [...owned, ...observed, ...external, ...native], files: inspected.files,
         native: { state: input.native ? 'available' : 'unavailable', message: input.native ? 'Retained native sources; input stays in their original window.' : 'Native activity is not available from the current Host. Reading this view does not start it.' },
-        omitted: { conversations: input.conversations.omitted, fileReferences: inspected.omitted, external: (input.external?.omitted ?? 0) + Math.max(0, externalSessions.length - external.length) } };
+        omitted: { conversations: input.conversations.omitted, fileReferences: inspected.omitted, external: (input.external?.omitted ?? 0) + (input.observed?.omitted ?? 0) + Math.max(0, (input.observed?.sessions.length ?? 0) - observed.length) + Math.max(0, externalSessions.length - external.length) } };
 }

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;
@@ -192,6 +193,13 @@ export declare const descriptions: {
     'workspace.enhance': string;
     'capability.index': string;
     'capability.resolve': string;
+    'extension.list': string;
+    'extension.describe': string;
+    'extension.content': string;
+    'extension.call': string;
+    'extension.read': string;
+    'extension.install': string;
+    'extension.manage': string;
 };
 export declare const errorKinds: string[];
 export declare const errorSchema: {

package/dist/protocol.js

@@ -1,3 +1,4 @@
+import { extensionOperations, extensionResponses, extensionDescriptions } from './extension-contract.js';
 import { evidenceSchema } from './evidence-capture.js';
 import { ownerContracts } from './contracts/owners.generated.js';
 import { enhancementSchemas } from './enhancement-contracts.js';
@@ -42,7 +43,7 @@ for (const owner of ['documents', 'files', 'r', 'requirements', 'tables', 'media
         ownerOperations[method] = contract;
     }
 }
-export const operations = { ...base.operations,
+export const operations = { ...base.operations, ...extensionOperations,
     'protocol.describe': obj({ ...project, method: text, cursor: { type: ['string', 'null'], maxLength: 128 }, limit: { type: 'integer', minimum: 1, maximum: 100 }, maxBytes: { type: 'integer', minimum: 1024, maximum: 65536 } }, []),
     'project.pick': obj({}),
     'project.source.pick': obj({}),
@@ -70,7 +71,8 @@ export const operations = { ...base.operations,
     '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 }),
@@ -86,7 +88,8 @@ export const operations = { ...base.operations,
     '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))
@@ -199,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
@@ -274,7 +280,7 @@ observationSnapshot.required = observationSnapshot.required.filter(key => key !=
 const structuredComposition = contract.structuredCompositionSchema;
 const composition = { anyOf: [contract.legacyCompositionSchema, structuredComposition] };
 const taskMap = { ...contract.taskMapStateSchema, properties: { ...contract.taskMapStateSchema.properties, receipt: obj({ changeId: identity, requestDigest: digest, kind: { enum: ['declare', 'present', 'respond'] }, author: text, version: positive, at: { type: 'string', format: 'date-time' }, outcome: contract.taskMapReceiptField }, ['changeId', 'kind', 'author', 'version', 'at']) } };
-export const responses = { ...base.responses, ...ownerResponses,
+export const responses = { ...base.responses, ...ownerResponses, ...extensionResponses,
     'project.work.read': projectWorkSchema(sessionObservation),
     'project.open': { ...contract.projectRecordSchema, properties: { ...contract.projectRecordSchema.properties, host: contract.cliSchema }, required: [...contract.projectRecordSchema.required, 'host'] },
     'project.pick': response({ cancelled: { type: 'boolean' }, project: { anyOf: [contract.projectSummarySchema, { type: 'null' }] } }),
@@ -332,6 +338,7 @@ export const responses = { ...base.responses, ...ownerResponses,
     '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 }) }),
@@ -374,6 +381,7 @@ export const responses = { ...base.responses, ...ownerResponses,
 };
 responses['session.grant'].properties.profile = operations['session.grant'].properties.profile;
 export const descriptions = {
+    ...extensionDescriptions,
     'workspace.observe': 'Assigned presenter only: bounded layout/basis/owner summary/visibility projection. No feedback, full documents or native trace. Reading starts no model or renderer.',
     'workspace.enhance': 'Assigned presenter only: conditional display emphasis/title/plain Agent note using exact current generation, witness and observation. Does not modify business resources, feedback or protection.',
     'capability.index': 'Read a small role-narrowed index of currently authorized, enabled operations and immutable Skill/contract references.',
@@ -393,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.',
@@ -430,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

@@ -1,3 +1,4 @@
+import { Extensions, extensionLimits } from './extensions.js';
 import { evidenceExportLimits } from './evidence-export.js';
 import * as http from 'node:http';
 import { Plugins, type PluginConfig } from './plugins.js';
@@ -49,6 +50,7 @@ export declare const serviceLimits: {
 export interface ServiceConfig extends Partial<typeof serviceLimits>, Partial<typeof requestLimits>, PluginConfig {
     root: string;
     stateDir: string;
+    extensions?: Partial<typeof extensionLimits>;
     coreBinary?: string;
     rscript: string;
     python?: string;
@@ -93,6 +95,7 @@ export declare const layeredGrantLimits: {
 };
 export declare class RhoService {
     config: ServiceConfig;
+    extensions: Extensions;
     plugins: Plugins;
     state: State;
     bridge: CoreBridge;
@@ -165,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" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel" | "skills")[] | 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;