@rho-workspace/rho 0.5.5 → 0.5.7

package/dist/plugin-presentation.d.ts

@@ -1,4 +1,4 @@
-import type { CapabilityCatalog, CapabilityPlugin } from './browser.js';
+import type { CapabilityCatalog, CapabilityPlugin, EntryPresentation } from './browser.js';
 export declare function pluginPresentation(plugin: CapabilityPlugin): {
     displayName: string;
     tagline: string;
@@ -35,6 +35,7 @@ export declare function pluginGroups(plugins: CapabilityPlugin[]): {
         id: string;
         package: string;
         version?: string;
+        packageVersion?: string;
         requires?: string[];
         selected: boolean;
         packagePresent: boolean;
@@ -57,9 +58,40 @@ export declare function pluginGroups(plugins: CapabilityPlugin[]): {
                     readOnly?: boolean;
                     runsCode?: boolean;
                 };
+                intent?: string;
+                requires?: string[];
+                example?: {
+                    method: string;
+                    input: {};
+                };
+                failureRecipes?: {
+                    kind: string;
+                    message: string;
+                    next: string;
+                }[];
+                verify?: {
+                    command: string;
+                    description: string;
+                };
+            }[];
+            operations?: {
+                method: string;
+                version: string;
+                effect: "read" | "metadata" | "document" | "file" | "native";
+                requires: string[];
+                presentation?: {
+                    displayName?: string;
+                    description?: string;
+                    order?: number;
+                    readOnly?: boolean;
+                    runsCode?: boolean;
+                };
             }[];
             actions?: {
-                presentation: {
+                id?: string;
+                version?: string;
+                requires?: string[];
+                presentation?: {
                     displayName?: string;
                     description?: string;
                     order?: number;
@@ -71,6 +103,9 @@ export declare function pluginGroups(plugins: CapabilityPlugin[]): {
                 id: string;
                 version: string;
                 ui: string;
+                bindings?: {
+                    [k: string]: string;
+                };
                 presentation?: {
                     displayName?: string;
                     description?: string;
@@ -79,6 +114,29 @@ export declare function pluginGroups(plugins: CapabilityPlugin[]): {
                     runsCode?: boolean;
                 };
             }[];
+            cli?: string[];
+            mcp?: {
+                entry: string;
+                transport: string;
+                tools: {
+                    name: string;
+                    description: string;
+                }[];
+            };
+            claudeCode?: {
+                skills?: {
+                    skill: string;
+                    name: string;
+                    description: string;
+                }[];
+                hooks?: {
+                    id?: string;
+                    event: string;
+                    matcher: string;
+                    entry: string;
+                    timeoutSeconds?: number;
+                }[];
+            };
         };
         presentation?: {
             displayName?: string;
@@ -122,8 +180,16 @@ export declare function pluginGroups(plugins: CapabilityPlugin[]): {
     }[];
 }[];
 export declare function pluginEntries(catalog: CapabilityCatalog, pluginId: string): {
+    operations: {
+        method: string;
+        effect?: string;
+        presentation?: EntryPresentation;
+        state?: string;
+        authorized?: boolean;
+    }[];
     actions: {
         displayName: string;
+        identities: string[];
         description: string;
         readOnly: boolean;
         runsCode: boolean;
@@ -132,10 +198,19 @@ export declare function pluginEntries(catalog: CapabilityCatalog, pluginId: stri
         id: string;
         version: string;
         ui: string;
+        package: string | undefined;
+        packageVersion: string | undefined;
+        bindings: {
+            [k: string]: string;
+        };
         displayName: string;
         description: string;
         readOnly: boolean | undefined;
         runsCode: boolean | undefined;
+        propsSchema: {
+            required?: string[];
+            properties?: Record<string, unknown>;
+        } | undefined;
     }[];
     skills: {
         id: string;
@@ -148,5 +223,33 @@ export declare function pluginEntries(catalog: CapabilityCatalog, pluginId: stri
             readOnly?: boolean;
             runsCode?: boolean;
         };
+        intent?: string;
+        requires?: string[];
+        example?: {
+            method: string;
+            input: {};
+        };
+        failureRecipes?: {
+            kind: string;
+            message: string;
+            next: string;
+        }[];
+        verify?: {
+            command: string;
+            description: string;
+        };
     }[];
 };
+export declare function pluginMatches(catalog: CapabilityCatalog, plugin: CapabilityPlugin, query: string): boolean;
+export type PluginKind = {
+    kind: 'ui' | 'page' | 'mcp' | 'skills' | 'claude-code' | 'mcp-server' | 'cli';
+    label: string;
+    count?: number;
+    detail: string;
+};
+export declare function pluginKinds(plugin: CapabilityPlugin, entries: ReturnType<typeof pluginEntries>): PluginKind[];
+export type ViewSubject = 'document' | 'markdown' | 'html' | 'table' | 'media' | 'object' | 'draft' | 'none';
+export declare function viewSubject(view: {
+    id: string;
+    bindings: Record<string, string>;
+}): ViewSubject;

package/dist/plugin-presentation.js

@@ -23,33 +23,87 @@ export function pluginGroups(plugins) {
 }
 export function pluginEntries(catalog, pluginId) {
     const plugin = catalog.plugins.find(p => p.id === pluginId);
-    const operations = catalog.operations.filter(o => o.owner === pluginId);
+    // Keep retained descriptions when an owner is absent, and overlay live state
+    // only for the exact method. Display copy is optional; identity never is.
+    const methods = new Map();
+    for (const operation of [...(plugin?.listing?.operations ?? []), ...catalog.operations.filter(o => o.owner === pluginId)]) {
+        methods.set(operation.method, { ...methods.get(operation.method), ...operation });
+    }
+    const operations = [...methods.values()];
     const actions = [...(catalog.actions ?? []), ...(catalog.unavailableActions ?? [])].filter(a => a.pluginId === pluginId);
     const groups = new Map();
     for (const entry of [...operations, ...actions, ...(plugin?.listing?.actions ?? [])]) {
-        const displayName = entry.presentation?.displayName;
+        const identity = 'method' in entry ? entry.method : entry.id;
+        const displayName = entry.presentation?.displayName || identity;
         if (!displayName)
             continue;
         // Several methods can expose one owner-authored human action. A group is
         // read-only only when every declared member is explicitly read-only.
         if (!groups.has(displayName))
-            groups.set(displayName, { displayName, presentations: [] });
+            groups.set(displayName, { displayName, identities: [], presentations: [] });
+        if (identity && !groups.get(displayName).identities.includes(identity))
+            groups.get(displayName).identities.push(identity);
         groups.get(displayName).presentations.push(entry.presentation);
     }
+    const components = new Map();
+    for (const component of [...(plugin?.listing?.views ?? []), ...catalog.components.filter(c => c.pluginId === pluginId)]) {
+        components.set(component.id + '@' + component.version, component);
+    }
     return {
+        operations,
         actions: [...groups.values()].sort((a, b) => Math.min(...a.presentations.map(p => p?.order ?? Infinity)) - Math.min(...b.presentations.map(p => p?.order ?? Infinity))).map(group => ({
             displayName: group.displayName,
+            identities: group.identities,
             description: [...new Set(group.presentations.flatMap(p => p?.description ? [p.description] : []))].join(' '),
             readOnly: group.presentations.every(p => p?.readOnly === true),
             runsCode: group.presentations.some(p => p?.runsCode === true),
         })),
-        views: [...catalog.components.filter(c => c.pluginId === pluginId), ...(plugin?.listing?.views ?? [])].map(c => ({
+        views: [...components.values()].map(c => ({
             id: c.id, version: c.version, ui: c.ui,
-            displayName: c.presentation?.displayName ?? '',
+            package: ('uiPackage' in c && c.uiPackage) || plugin?.package,
+            packageVersion: ('uiPackageVersion' in c && c.uiPackageVersion) || plugin?.packageVersion,
+            bindings: c.bindings ?? {},
+            displayName: c.presentation?.displayName || c.id,
             description: c.presentation?.description ?? '',
             readOnly: c.presentation?.readOnly,
             runsCode: c.presentation?.runsCode,
+            // The live component's props contract, when the owner is loaded; retained listings carry none.
+            propsSchema: 'propsSchema' in c ? c.propsSchema : undefined,
         })),
         skills: plugin?.listing?.skills ?? [],
     };
 }
+export function pluginMatches(catalog, plugin, query) {
+    const entries = pluginEntries(catalog, plugin.id);
+    return JSON.stringify([plugin.id, plugin.package, plugin.presentation, entries, plugin.listing?.claudeCode, plugin.listing?.mcp]).toLowerCase().includes(query.trim().toLowerCase());
+}
+export function pluginKinds(plugin, entries) {
+    const listing = plugin.listing, note = pluginPresentation(plugin).viewNote, kinds = [];
+    if (entries.views.length)
+        kinds.push({ kind: 'ui', label: 'UI', count: entries.views.length, detail: entries.views.length === 1 ? 'One view in the browser' : entries.views.length + ' views in the browser' });
+    else
+        kinds.push({ kind: 'page', label: note === 'Its own page in each project' ? 'Rho page' : note === 'Inside other views' ? 'In other views' : 'No view', detail: note || 'No view of its own; your Agent uses it' });
+    if (entries.operations.length)
+        kinds.push({ kind: 'mcp', label: 'MCP tools', count: entries.operations.length, detail: 'Operations an Agent calls over the shared Rho MCP connection' });
+    if (entries.skills.length)
+        kinds.push({ kind: 'skills', label: 'Skills', count: entries.skills.length, detail: 'Instructions an Agent reads before using it' });
+    if (listing?.claudeCode) {
+        const parts = [...(listing.claudeCode.skills ?? []).map(s => 'Skill /' + s.name), ...(listing.claudeCode.hooks ?? []).map(h => h.event + ' hook')];
+        kinds.push({ kind: 'claude-code', label: 'Claude Code', detail: parts.join(', ') || 'Native entries for Claude Code sessions Rho starts' });
+    }
+    if (listing?.mcp)
+        kinds.push({ kind: 'mcp-server', label: 'MCP server', count: listing.mcp.tools.length, detail: 'Serves Rho to Agents over ' + listing.mcp.transport });
+    if (listing?.cli?.length)
+        kinds.push({ kind: 'cli', label: 'CLI', count: listing.cli.length, detail: listing.cli.join(', ') });
+    return kinds;
+}
+export function viewSubject(view) {
+    const [key, kind] = Object.entries(view.bindings)[0] ?? [];
+    if (!key)
+        return 'none';
+    if (key === 'draft')
+        return 'draft';
+    if (kind === 'document')
+        return view.id === 'markdown.reader' ? 'markdown' : view.id === 'html.reader' ? 'html' : 'document';
+    return kind === 'table' || kind === 'media' || kind === 'object' ? kind : 'none';
+}

package/dist/plugins.d.ts

@@ -23,6 +23,7 @@ declare const entries: {
     agent: () => Promise<typeof import("@rho-workspace/plugin-agent")>;
     console: () => Promise<typeof import("@rho-workspace/plugin-console")>;
     kernel: () => Promise<typeof import("@rho-workspace/plugin-kernel")>;
+    figures: () => Promise<typeof import("@rho-workspace/plugin-figures")>;
     skills: () => Promise<typeof import("@rho-workspace/plugin-skills")>;
 };
 export type PluginId = keyof typeof entries;
@@ -74,7 +75,7 @@ export declare class Plugins {
             timeoutSeconds?: number;
         }[];
     };
-    ids(): ("media" | "r" | "agent" | "files" | "skills" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel")[];
+    ids(): ("media" | "r" | "files" | "agent" | "figures" | "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];
@@ -85,6 +86,14 @@ export declare class Plugins {
             modelLoop: string;
             contextDelivery: string;
             proactivePush: string;
+            mcp: {
+                entry: string;
+                transport: string;
+                tools: {
+                    name: string;
+                    description: string;
+                }[];
+            };
         } | undefined;
         version: string;
         plugins: any[];
@@ -125,6 +134,8 @@ export declare class Plugins {
             presentation?: import("@rho-workspace/plugin-contracts").EntryPresentation;
         }[];
         components: ({
+            uiPackage?: string | undefined;
+            uiPackageVersion?: string | undefined;
             pluginId: string;
             id: string;
             version: string;
@@ -161,10 +172,10 @@ export declare class Plugins {
         reason?: undefined;
     };
     descriptors(): PluginDescriptor[];
-    availableIds(): ("media" | "r" | "agent" | "files" | "skills" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel")[];
+    availableIds(): ("media" | "r" | "files" | "agent" | "figures" | "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" | "skills" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel" | undefined;
+    operationOwner(method: string): "media" | "r" | "files" | "agent" | "figures" | "skills" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel" | undefined;
     operationDeclarations(): {
         owner: string;
         method: string;

package/dist/plugins.js

@@ -2,6 +2,7 @@ import * as fs from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { confined, readJson, requireThat } from '@rho-workspace/plugin-contracts';
 import { ownerContracts } from './contracts/owners.generated.js';
+import { packageFacts, pluginListing } from './plugin-inventory.js';
 import { validateUiExtension, uiExtensionLimits } from './ui-extension.js';
 const executionInputSchema = ownerContracts.selected.execution.input;
 // A finite application selection, not a discovery service or an arbitrary code
@@ -18,9 +19,10 @@ const entries = {
     agent: () => import('@rho-workspace/plugin-agent'),
     console: () => import('@rho-workspace/plugin-console'),
     kernel: () => import('@rho-workspace/plugin-kernel'),
+    figures: () => import('@rho-workspace/plugin-figures'),
     skills: () => import('@rho-workspace/plugin-skills')
 };
-export const selectedPluginVersions = { documents: '0.4.7', files: '0.5.0', r: '0.4.1', requirements: '0.4.0', tables: '0.5.0', media: '0.4.0', charts: '0.4.0', annotations: '0.5.2', agent: '0.4.19', console: '0.3.0', kernel: '0.5.1', skills: '0.1.0' };
+export const selectedPluginVersions = { documents: '0.4.7', files: '0.5.0', r: '0.4.1', requirements: '0.4.0', tables: '0.5.2', media: '0.4.0', charts: '0.4.0', annotations: '0.5.2', agent: '0.4.33', console: '0.3.0', kernel: '0.5.1', figures: '0.5.1', skills: '0.1.0' };
 export const pluginIds = Object.keys(entries);
 const only = (defaults, values = {}) => Object.fromEntries(Object.entries(values).filter(([k, v]) => k in defaults && v !== undefined));
 export class Plugins {
@@ -75,9 +77,10 @@ export class Plugins {
                     if (timeline && module.plugin.operations.some(o => o.method === timeline && o.effect === 'read'))
                         status.timeline = timeline;
                     status.requires = [...module.plugin.requires];
-                    status.listing = {
-                        skills: module.plugin.skills.map(({ content, ...skill }) => skill),
-                    };
+                    const facts = await packageFacts(status.package);
+                    if (facts.version)
+                        status.packageVersion = facts.version;
+                    status.listing = pluginListing(module.plugin, facts);
                     status.packagePresent = true;
                     status.state = 'available';
                     delete status.reason;
@@ -143,7 +146,10 @@ export class Plugins {
                 packagePresent: p.packagePresent === true,
                 dependenciesSatisfied: p.packagePresent === true && p.state === 'available' && !(p.missing?.length),
                 uiRenderable: p.state === 'available' && this.installedUi.some(entry => entry.plugin === p.id && (entry.extension || entry.packageVersion === p.version))
-            })), operations: this.operationDeclarations(), actions, unavailableActions, components: [...descriptors.flatMap(p => (p.components ?? []).map(component => ({ ...component, pluginId: p.id }))),
+            })), operations: this.operationDeclarations(), actions, unavailableActions, components: [...descriptors.flatMap(p => (p.components ?? []).map(component => {
+                    const installed = this.installedUi.find(e => e.component === component.id && e.version === component.version && e.plugin === p.id);
+                    return { ...component, pluginId: p.id, ...(installed ? { uiPackage: installed.package, uiPackageVersion: installed.packageVersion } : {}) };
+                })),
                 ...this.installedUi.filter(e => e.extension && this.modules[e.plugin]).map(e => ({ id: e.component, version: e.version, owner: e.package, pluginId: e.plugin, ui: e.entrySha256, bindings: e.extension.bindings, propsSchema: e.extension.propsSchema,
                     presentation: { displayName: e.extension.displayName, description: e.extension.description }, uiPackage: e.package, uiPackageVersion: e.packageVersion }))], capabilities: [...descriptors.flatMap(p => p.capabilities), ...actions.flatMap(a => a.capabilities ?? [])], skills: descriptors.flatMap(p => p.skills ?? []), ...(this.modules.agent ? { agent: this.modules.agent.plugin.agent } : {}) };
     }
@@ -164,7 +170,7 @@ export class Plugins {
         const descriptor = this.descriptors().find(p => p.operations?.some(o => o.method === method));
         if (descriptor)
             return descriptor.id;
-        const owner = method.startsWith('annotation.') ? 'annotations' : method.startsWith('console.') ? 'console' : method.startsWith('kernel.') ? 'kernel' : method.startsWith('skills.') ? 'skills' : method.startsWith('document.') ? 'documents' : method.startsWith('requirements.') ? 'requirements' : method === 'action.submit' || method === 'object.read' ? 'r' : method === 'data.plot' ? 'charts' : method.startsWith('data.') || method === 'selection.set' ? 'tables' : method.startsWith('media.') ? 'media' : method.startsWith('feedback.') || method.startsWith('context.') || method.startsWith('binding.') || method === 'session.grant' ? 'agent' : method.startsWith('resource.') || method === 'artifact.check' || method === 'action.export' ? 'files' : undefined;
+        const owner = method.startsWith('annotation.') ? 'annotations' : method.startsWith('console.') ? 'console' : method.startsWith('kernel.') ? 'kernel' : method.startsWith('figure.') ? 'figures' : method.startsWith('skills.') ? 'skills' : method.startsWith('document.') ? 'documents' : method.startsWith('requirements.') ? 'requirements' : method === 'action.submit' || method === 'object.read' ? 'r' : method === 'data.plot' ? 'charts' : method.startsWith('data.') || method === 'selection.set' ? 'tables' : method.startsWith('media.') ? 'media' : method.startsWith('feedback.') || method.startsWith('context.') || method.startsWith('binding.') || method === 'session.grant' ? 'agent' : method.startsWith('resource.') || method === 'artifact.check' || method === 'action.export' ? 'files' : undefined;
         return owner;
     }
     operationDeclarations() { return this.descriptors().flatMap(p => (p.operations ?? []).map(operation => ({ ...operation, owner: p.id }))); }

package/dist/project-notes.js

@@ -33,7 +33,7 @@ export function notesInstructions(conversationId, options = {}) {
             '- Run exploratory code there instead of Rscript -e, python3 -c or a throwaway script: find kernel.run with rho_index and rho_resolve once, then call it with rho_call, giving language "r" or "python", the code, a short purpose that says what the cell is for, and waitMs (for example 120000) to wait for it to finish.',
             '- What a cell defines stays for your next cells, so load data once and build on it. kernel.read shows the cells, including any the person ran, and the variables.',
             '- To look at a value without adding a cell, call kernel.inspect with its language and name: it gives a page of a table, a model\'s fit and coefficients, or a list\'s parts, with the code that reaches each part.',
-            '- Keep the code your results rest on in script files as well, so they can be run again without the session.',
+            '- Keep the code your results rest on in script files as well, so the results can be rebuilt without the session. Run such a script in the session with kernel.run (source("analysis.R") in R, exec(open("analysis.py").read()) in Python), not with Rscript or python3 from a shell: a saved figure is readable mark by mark only while its file holds the bytes a Notebook cell saved, so a shell run that writes it again leaves a picture.',
             '- Before a multi-step analysis, read the Skill "rho.analysis-run" with skill.list and skill.read: it holds the practice that keeps a long analysis from losing work when a turn stops, written after five real reproductions ran here.',
         ] : []),
     ].join('\n');

package/dist/protocol.d.ts

@@ -122,6 +122,7 @@ export declare const runSchema: {
 export declare const responses: Record<string, any>;
 export declare const descriptions: {
     'document.read': string;
+    'composition.delete': string;
     'document.edit': string;
     'feedback.submit': string;
     'feedback.read': string;
@@ -166,13 +167,18 @@ export declare const descriptions: {
     'kernel.events': string;
     'kernel.inspect': string;
     'kernel.plot': string;
+    'figure.read': string;
+    'figure.select': string;
     'kernel.interrupt': string;
     'kernel.stop': string;
     'conversation.delete': string;
     'conversation.settings.read': string;
     'conversation.settings.update': string;
     'conversation.settings.check': string;
+    'conversation.agents.add': string;
+    'conversation.agents.remove': string;
     'session.connect': string;
+    'session.instructions': string;
     'conversation.read': string;
     'project.work.read': string;
     'resource.register': string;
@@ -193,6 +199,7 @@ export declare const descriptions: {
     'capability.index': string;
     'capability.resolve': string;
     'extension.list': string;
+    'extension.market.change': string;
     'extension.describe': string;
     'extension.content': string;
     'extension.call': string;

package/dist/protocol.js

@@ -9,6 +9,7 @@ import { objectSchema as obj, text, refSchema as ref } from '@rho-workspace/plug
 import { routeSchemas } from './task-routing-contract.js';
 import { baseProtocol } from './protocol-base.js';
 import { projectWorkSchema } from './work-contract.js';
+import { uiLocationSchema, uiContextSchema } from './ui-context.js';
 const base = structuredClone(baseProtocol);
 const ownerSchema = (id, name) => ownerContracts.selected[id][name];
 const ownerSchemaRecord = (id, name) => ownerContracts.selected[id][name];
@@ -21,9 +22,10 @@ const array = (items) => ({ type: 'array', items });
 const response = (properties, required = Object.keys(properties)) => ({ type: 'object', properties, required, additionalProperties: true });
 const changeId = { type: 'string', pattern: '^[A-Za-z0-9._:@-]{1,128}$' };
 const identity = changeId;
-// 'acp' is a generic ACP agent: the operator names its command (--acp-command), so Rho
-// supports any ACP v1 implementation without a per-agent adapter.
-const agentBackend = { enum: ['claude-acp', 'codex-acp', 'acp'] };
+// Claude Code and Codex through their adapters, and any other ACP v1 Agent without a per-agent
+// adapter: 'acp' is the command named when the service started (--acp-command), 'acp:' and a name
+// an Agent the person added in Rho (conversation.agents.add).
+const agentBackend = { type: 'string', pattern: '^(claude-acp|codex-acp|acp|acp:[a-z0-9][a-z0-9-]{0,39})$' };
 const outsideAgent = { enum: ['claude-code', 'codex'] };
 const addedTo = response({ agent: outsideAgent, name: text, scope: { enum: ['folder', 'user'] }, at: text });
 const choiceText = { type: 'string', minLength: 1, maxLength: 512 }, choiceValue = { anyOf: [choiceText, { type: 'boolean' }] };
@@ -38,7 +40,7 @@ function scoped(input) {
     return { ...input, properties: { ...project, ...properties }, required: ['projectId', ...required.filter(name => name !== 'projectId')] };
 }
 const ownerOperations = {};
-for (const owner of ['documents', 'files', 'r', 'requirements', 'tables', 'media', 'charts', 'agent', 'console', 'kernel', 'skills']) {
+for (const owner of ['documents', 'files', 'r', 'requirements', 'tables', 'media', 'charts', 'agent', 'console', 'kernel', 'figures', 'skills']) {
     for (const [method, contract] of Object.entries(ownerSchemaRecord(owner, 'operationContracts'))) {
         ownerOperations[method] = contract;
     }
@@ -71,8 +73,9 @@ 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.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.start': obj({ ...project, changeId, text: { type: 'string', minLength: 1, maxLength: 16384 }, backend: agentBackend, config: choices, contexts: { ...array(digest), maxItems: 8 }, uiContext: uiLocationSchema,
+        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 }, uiContext: uiLocationSchema, 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 }),
     'conversation.decide': obj({ ...project, conversationId: changeId, turnId: changeId, changeId, decision: { enum: ['accepted', 'needs-changes'] }, note: { type: 'string', maxLength: 4096 } }, ['projectId', 'conversationId', 'turnId', 'changeId', 'decision']),
@@ -84,10 +87,14 @@ export const operations = { ...base.operations, ...extensionOperations,
     // The person's Agent and its settings (model, effort, mode…) among those the Agent offers.
     'conversation.configure': obj({ ...project, conversationId: changeId, configId: choiceText, value: choiceValue }),
     'conversation.settings.read': obj(project),
-    '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.update': obj({ ...project, expectedVersion: integer, backend: { anyOf: [agentBackend, { type: 'null' }] }, choices: { type: 'object', maxProperties: 20, propertyNames: agentBackend, additionalProperties: choices }, describe: obj({ enabled: { type: 'boolean' } }, ['enabled']) }, ['projectId', 'expectedVersion']),
     'conversation.settings.check': obj({ ...project, backend: agentBackend }),
+    // An ACP Agent the person adds or removes for new conversations: the program (on PATH or a path) and its arguments.
+    'conversation.agents.add': obj({ ...project, command: { type: 'array', minItems: 1, maxItems: 32, items: { type: 'string', minLength: 1, maxLength: 4096 } } }),
+    'conversation.agents.remove': obj({ ...project, backend: { type: 'string', pattern: '^acp:[a-z0-9][a-z0-9-]{0,39}$' } }),
     // 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))
@@ -110,6 +117,7 @@ const applyOperation = { oneOf: [
     ] };
 operations['composition.apply'] = obj({ ...condition, operations: { ...array(applyOperation), minItems: 1, maxItems: 256 } });
 operations['composition.undo'] = obj(condition);
+operations['composition.delete'] = obj(condition);
 operations['view.protection.set'] = obj({ ...condition, viewId: changeId, protected: { type: 'boolean' } });
 operations['view.close'] = obj({ ...operations['view.close'].properties, changeId }, operations['view.close'].required);
 const selectionScope = { oneOf: [obj({ kind: { const: 'caller' } }), obj({ kind: { enum: ['view', 'shared'] }, id: changeId })] };
@@ -200,14 +208,20 @@ 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),
+    choices: { type: 'object', propertyNames: agentBackend, additionalProperties: choices }, offered: { type: 'object', propertyNames: agentBackend, additionalProperties: 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: { type: 'object', propertyNames: agentBackend, additionalProperties: response({ found: { type: 'boolean' }, problem: text, name: { anyOf: [text, { type: 'null' }] } }, ['found']) },
+    // The ACP Agents the person added, and those Rho knows that are installed here and not added yet.
+    added: array(response({ backend: agentBackend, name: text, command: array(text), addedAt: text })),
+    installed: array(response({ id: text, name: text, command: array(text) })) }, ['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
@@ -219,7 +233,7 @@ const conversationStep = response({ kind: { enum: ['text', 'tool', 'error'] }, a
     output: response({ text: { type: 'string' }, lines: integer, bytes: integer, cut: { type: 'boolean' } }, ['text', 'lines', 'bytes', 'cut']) }, ['kind', 'at']);
 const conversationTurn = response({ id: text, by: text, text: { type: 'string' }, sentAt: text, state: { enum: ['running', 'completed', 'failed', 'stopped', 'unknown'] }, startedAt: { anyOf: [text, { type: 'null' }] }, endedAt: { anyOf: [text, { type: 'null' }] }, model: { anyOf: [text, { type: 'null' }] },
     stop: { anyOf: [response({ requestedAt: text, by: text, reason: { enum: ['person', 'closing', 'wall-limit', 'output-limit', 'line-limit', 'identity'] } }), { type: 'null' }] },
-    steps: array(conversationStep), omitted: integer, evidence: evidenceSchema, contexts: array(digest),
+    steps: array(conversationStep), omitted: integer, evidence: evidenceSchema, contexts: array(digest), uiContext: uiContextSchema,
     // What the files it wrote hold: facts read from each file, then a model's sentence naming the
     // version it read, the model, how it was given the file (its first lines, the image, or what
     // made it), and what the call cost and on what basis (Rho's describeLimits). The spend sums
@@ -261,6 +275,8 @@ const observationSnapshot = response({
             conversationId: { anyOf: [text, { type: 'null' }] },
             // The Agent outside Rho this grant was added to, when the person added it from Rho.
             added: { anyOf: [addedTo, { type: 'null' }] },
+            // The MCP client that used this grant, as it named itself (its initialize clientInfo).
+            client: { anyOf: [{ type: 'null' }, response({ name: text, version: text }, ['name'])] },
             last: { anyOf: [{ type: 'null' }, response({ at: text, method: text, outcome: { enum: ['returned', 'rejected'] }, operationId: text }, ['at', 'method', 'outcome'])] } }, ['principal', 'label', 'profile', 'methods', 'expiresAt', 'ended', 'last']) },
     // Conversations started in Rho, for the person at this machine; empty for anyone else.
     conversations: { type: 'array', maxItems: 64, items: conversationSummary },
@@ -332,7 +348,10 @@ export const responses = { ...base.responses, ...ownerResponses, ...extensionRes
     'conversation.settings.read': agentSettings,
     'conversation.settings.update': agentSettings,
     'conversation.settings.check': agentSettings,
+    'conversation.agents.add': agentSettings,
+    'conversation.agents.remove': 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 }) }),
@@ -353,7 +372,7 @@ export const responses = { ...base.responses, ...ownerResponses, ...extensionRes
     'workspace.save': contract.workspaceSaveSchema,
     'workspace.restore': contract.workspaceRestoreSchema,
     'observation.snapshot': observationSnapshot,
-    'composition.apply': structuredComposition, 'composition.undo': structuredComposition, 'view.protection.set': structuredComposition,
+    'composition.apply': structuredComposition, 'composition.undo': structuredComposition, 'composition.delete': structuredComposition, 'view.protection.set': structuredComposition,
     'composition.read': composition, 'view.close': composition,
     'project.openFile': response({ document: ownerResponses['document.open'], viewId: text, composition: structuredComposition }),
     'interaction.selection.read': contract.selectionChannelSchema,
@@ -381,6 +400,7 @@ export const descriptions = {
     'capability.index': 'Read a small role-narrowed index of currently authorized, enabled operations and immutable Skill/contract references.',
     'capability.resolve': 'Fetch selected relevant Skills with complete owner contracts, whole objects only. Pages pin catalog/bundle/caller; knownRefs only reuse currently available immutable bodies.', ...base.descriptions,
     'document.read': 'Read the shared acknowledged buffer, including unsaved text and its version.',
+    'composition.delete': 'Delete an empty Studio workspace layout only, never the project directory, documents, resources, conversations or running sessions. Requires its observed expectedVersion and a stable changeId. The same request returns its original receipt without deleting a recreated workspace. Nonempty, conversation and active-task layouts are refused. The deleted layout and its history remain readable with composition.read and recoverable with composition.undo; it is omitted from active workspace lists. Recreating it uses a conditional composition.apply replacement at its retained version.',
     'document.edit': 'Apply conditional UTF-16 text edits to the shared buffer; keep the returned version.',
     'feedback.submit': 'Teacher browser only: freeze the original draft/anchor, prepare the committed message and retain one original-session delivery. Preserve submissionId across missing acknowledgements; stages are separate durable facts.',
     'feedback.read': 'Original business binding only: fetch one complete frozen feedback object using its original delivery/context and a stable fetchId. relatedDocumentId is a pointer: read its CURRENT version before conditional edit/save and preserve human changes. This owner-served receipt does not prove client return or understanding.',
@@ -395,7 +415,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.',
@@ -425,13 +445,18 @@ export const descriptions = {
     'kernel.events': 'Who ran each cell of the live sessions and when, newest first, for the timeline: its language and place, how it ended and its purpose or first line. No code or output.',
     'kernel.inspect': 'One value of a live session, as its session describes it: what kind of thing it is (a table, a model, a vector, a list, a function or a value), short facts, and one page of its rows, elements or parts, each part with the code that reaches it. Never starts a session or waits for a cell: while a cell runs or waits the answer is busy. A reading that takes too long is interrupted.',
     'kernel.plot': 'One plot a cell kept, as PNG bytes.',
+    'figure.read': 'What a plot a cell drew shows: its layers, mappings, panels and data, the rows behind marks, and the marks people and Agents selected.',
+    'figure.select': 'Keeps a set of a figure\'s marks with a note, shown highlighted in the plot; the plot and its data do not change.',
     'kernel.interrupt': 'Interrupt one cell: a running cell stops and its session and values stay; a waiting cell is not run. A cell that has ended is returned unchanged.',
     'kernel.stop': 'Person at this machine only: end one live session. Its values are gone, the running cell ends with an error and waiting cells are not run. A session that has ended is returned unchanged.',
     'conversation.delete': 'Person at this machine only: delete Rho\'s record of a conversation in the trash. The Agent\'s own session files are not touched. Repeating the request that started it is then refused.',
     'conversation.settings.read': 'Person at this machine only: read the Agent and settings chosen for new conversations and what each Agent last offered. Reading starts nothing.',
     '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.',
+    'conversation.agents.add': 'Person at this machine only: add an ACP Agent for new conversations in every project, given its program (on PATH or a path) and arguments, such as ["hermes", "acp"]. Rho starts it once in this project to read what it offers, then removes that session and ends the process; no message is sent. It is kept only when it answered. Adding the same command again checks it again.',
+    'conversation.agents.remove': 'Person at this machine only: remove an added ACP Agent from the Agents new conversations can use. Its conversations stay and continue with the command they started with.',
     '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.',
@@ -456,4 +481,4 @@ export const errorKinds = base.errorKinds;
 export const errorSchema = base.definitions.error;
 export const errorEnvelope = obj({ apiVersion: { const: '2.0' }, ok: { const: false }, error: errorSchema });
 export const responseEnvelope = (method) => obj({ apiVersion: { const: '2.0' }, ok: { const: true }, value: responses[method] });
-export const protocol = { ...base, apiVersion: '2.0', schemaVersion: 2, transport: 'HTTP JSON POST /api/v2/{operation}; GET /api/v2/events', eventTypes: [...new Set([...base.eventTypes, 'project.sources.changed', 'capability.changed', 'view.closed', 'interaction.selection.changed', 'annotation.changed', 'context.changed', 'workspace.restored', 'task.routing.changed', 'binding.native.changed', 'feedback.changed', 'task.map.changed', 'feedback.changed', 'activity.changed', 'resource.changed', 'conversation.changed', 'console.changed', 'kernel.changed', 'skills.changed'])], operations, responses, descriptions: orderedDescriptions, definitions, errorEnvelope, status: 'One versioned contract. Retained operations stay observable through the current API; requests this contract does not accept receive a typed refusal rather than a second dialect.' };
+export const protocol = { ...base, apiVersion: '2.0', schemaVersion: 2, transport: 'HTTP JSON POST /api/v2/{operation}; GET /api/v2/events', eventTypes: [...new Set([...base.eventTypes, 'project.sources.changed', 'capability.changed', 'view.closed', 'interaction.selection.changed', 'annotation.changed', 'context.changed', 'workspace.restored', 'task.routing.changed', 'binding.native.changed', 'feedback.changed', 'task.map.changed', 'feedback.changed', 'activity.changed', 'resource.changed', 'conversation.changed', 'console.changed', 'kernel.changed', 'figure.changed', 'skills.changed'])], operations, responses, descriptions: orderedDescriptions, definitions, errorEnvelope, status: 'One versioned contract. Retained operations stay observable through the current API; requests this contract does not accept receive a typed refusal rather than a second dialect.' };

package/dist/replay.js

@@ -12,6 +12,10 @@ export function turnAt(turn, at) {
         const began = time(step.startedAt ?? step.at), last = time(step.at);
         if (!(began <= at))
             return [];
+        if (step.kind === 'tool' && step.outcomeAt && time(step.outcomeAt) > at && step.outcome !== 'requested') {
+            const { exitCode: _, output: __, failed: ___, ...rest } = step;
+            return [{ ...rest, outcome: 'unknown' }];
+        }
         if (last <= at)
             return [step];
         // A tool reported before the moment and finished after it was still going.