@rho-workspace/rho 0.5.5 → 0.5.7

package/dist/response-contracts.js

@@ -164,29 +164,44 @@ export const pluginPresentationSchema = { ...entryPresentationSchema, properties
         examplePrompts: { type: 'array', items: text, maxItems: 16 }, viewNote: text, developer: text, license: text,
         links: { type: 'array', maxItems: 16, items: obj({ label: text, url: text }, ['label', 'url']) },
         dependencies: { type: 'array', maxItems: 16, items: obj({ pluginId: text, purpose: text }, ['pluginId', 'purpose']) }, uses: text } };
+const skillListingSchema = { ...obj({
+        id: text, version: text, digest, presentation: entryPresentationSchema, intent: text,
+        requires: { type: 'array', items: text, maxItems: 64 },
+        example: obj({ method: text, input: { type: 'object' } }),
+        failureRecipes: { type: 'array', maxItems: 32, items: obj({ kind: text, message: text, next: text }) },
+        verify: obj({ command: text, description: text })
+    }, ['id', 'version', 'digest']), additionalProperties: true };
 export const capabilityCatalogSchema = { ...obj({
         version: text,
         configuration: obj({ version: integer, enabled: { type: 'array', items: text, maxItems: 32 }, retainedReceipts: integer, retainedFromVersion: positive, maxReceipts: integer }, ['version', 'enabled']),
-        plugins: { type: 'array', maxItems: 16, items: { ...obj({ id: text, package: text, version: text, requires: { type: 'array', items: text }, selected: { type: 'boolean' }, packagePresent: { type: 'boolean' }, projectEnabled: { type: 'boolean' }, dependenciesSatisfied: { type: 'boolean' }, uiRenderable: { type: 'boolean' }, state: { enum: ['available', 'unavailable'] }, reason: text, missing: { type: 'array', items: text },
+        plugins: { type: 'array', maxItems: 16, items: { ...obj({ id: text, package: text, version: text, packageVersion: text, requires: { type: 'array', items: text }, selected: { type: 'boolean' }, packagePresent: { type: 'boolean' }, projectEnabled: { type: 'boolean' }, dependenciesSatisfied: { type: 'boolean' }, uiRenderable: { type: 'boolean' }, state: { enum: ['available', 'unavailable'] }, reason: text, missing: { type: 'array', items: text },
                     // The plugin's read whose events (who did what, when) the timeline draws.
                     timeline: text,
                     // The catalog also carries the owner's own presentation/listing hints and its
                     // bounded native availability; those are owner vocabulary, so they stay open.
                     // A reduced installation lists fewer entries, so each listing section is optional.
                     listing: obj({
-                        skills: { type: 'array', maxItems: 64, items: { ...obj({ id: text, version: text, digest: digest, presentation: entryPresentationSchema }, ['id', 'version', 'digest']), additionalProperties: true } },
-                        actions: { type: 'array', maxItems: 64, items: { ...obj({ presentation: entryPresentationSchema }), additionalProperties: true } },
-                        views: { type: 'array', maxItems: 64, items: { ...obj({ id: text, version: text, ui: text, presentation: entryPresentationSchema }, ['id', 'version', 'ui']), additionalProperties: true } }
+                        skills: { type: 'array', maxItems: 64, items: skillListingSchema },
+                        operations: { type: 'array', maxItems: 64, items: obj({ method: text, version: text, effect: { enum: ['read', 'metadata', 'document', 'file', 'native'] }, requires: { type: 'array', items: text }, presentation: entryPresentationSchema }, ['method', 'version', 'effect', 'requires']) },
+                        actions: { type: 'array', maxItems: 64, items: { ...obj({ id: text, version: text, requires: { type: 'array', items: text }, presentation: entryPresentationSchema }, []), additionalProperties: true } },
+                        views: { type: 'array', maxItems: 64, items: { ...obj({ id: text, version: text, ui: text, bindings: { type: 'object', additionalProperties: text }, presentation: entryPresentationSchema }, ['id', 'version', 'ui']), additionalProperties: true } },
+                        // Command-line entries the installed package links, read from its own manifest.
+                        cli: { type: 'array', maxItems: 16, items: text },
+                        mcp: obj({ entry: text, transport: text, tools: { type: 'array', maxItems: 32, items: obj({ name: text, description: text }) } }),
+                        claudeCode: obj({
+                            skills: { type: 'array', maxItems: 64, items: obj({ skill: text, name: text, description: text }) },
+                            hooks: { type: 'array', maxItems: 64, items: obj({ id: text, event: text, matcher: text, entry: text, timeoutSeconds: positive }, ['event', 'matcher', 'entry']) }
+                        }, [])
                     }, []),
                     presentation: pluginPresentationSchema,
                     nativeAvailability: nativeAvailabilitySchema,
                 }, ['id', 'package', 'selected', 'packagePresent', 'state']), additionalProperties: true } },
-        operations: { type: 'array', maxItems: 256, items: { ...obj({ method: text, owner: text, packagePresent: { type: 'boolean' }, projectEnabled: { type: 'boolean' }, dependenciesSatisfied: { type: 'boolean' }, authorized: { type: 'boolean' }, state: { enum: ['available', 'unavailable'] }, presentation: entryPresentationSchema }, ['method', 'authorized', 'state']), additionalProperties: true } },
+        operations: { type: 'array', maxItems: 256, items: { ...obj({ method: text, owner: text, effect: text, inputSchema: { type: 'object' }, outputSchema: { type: 'object' }, packagePresent: { type: 'boolean' }, projectEnabled: { type: 'boolean' }, dependenciesSatisfied: { type: 'boolean' }, authorized: { type: 'boolean' }, state: { enum: ['available', 'unavailable'] }, presentation: entryPresentationSchema }, ['method', 'authorized', 'state']), additionalProperties: true } },
         actions: { type: 'array', maxItems: 64, items: { ...obj({ id: text, version: text, owner: text, pluginId: text, requires: { type: 'array', items: text }, inputSchema: { type: 'object' }, presentation: entryPresentationSchema }, ['id', 'version']), additionalProperties: true } },
         unavailableActions: { type: 'array', maxItems: 64, items: { ...obj({ id: text, version: text, owner: text, pluginId: text, requires: { type: 'array', items: text }, inputSchema: { type: 'object' }, presentation: entryPresentationSchema, state: { const: 'unavailable' }, missing: { type: 'array', items: text } }, ['id', 'version', 'missing']), additionalProperties: true } },
-        components: { type: 'array', maxItems: 64, items: { ...obj({ id: text, version: text, owner: text, pluginId: text, ui: text, bindings: { type: 'object', additionalProperties: text }, propsSchema: { type: 'object' }, presentation: entryPresentationSchema }, ['id', 'version', 'ui', 'bindings']), additionalProperties: true } },
+        components: { type: 'array', maxItems: 64, items: { ...obj({ id: text, version: text, owner: text, pluginId: text, ui: text, uiPackage: text, uiPackageVersion: text, bindings: { type: 'object', additionalProperties: text }, propsSchema: { type: 'object' }, presentation: entryPresentationSchema }, ['id', 'version', 'ui', 'bindings']), additionalProperties: true } },
         capabilities: { type: 'array', items: text },
-        skills: { type: 'array', maxItems: 64, items: { ...obj({ id: text, version: text, digest: digest, content: { type: 'string' }, presentation: entryPresentationSchema }, ['id', 'version', 'digest']), additionalProperties: true } },
+        skills: { type: 'array', maxItems: 64, items: { ...skillListingSchema, properties: { ...skillListingSchema.properties, owner: text, content: { type: 'string' } } } },
         // The Agent owner contributes its own context description only when it is loaded.
         agent: { type: 'object' }
     }, ['version', 'configuration', 'plugins', 'operations', 'actions', 'components']), additionalProperties: true };
@@ -198,8 +213,8 @@ export const nodeSchema = { oneOf: [
         obj({ id: identity, kind: { const: 'group' }, children: { type: 'array', items: identity, maxItems: 256 }, presentation: groupPresentation }, ['id', 'kind', 'children']),
         { ...viewSchema, properties: { ...viewSchema.properties, kind: { const: 'view' } }, required: [...viewSchema.required, 'kind'] }
     ] };
-export const compositionReceiptSchema = obj({ changeId: identity, author: text, version: positive, requestDigest: digest, at: timestamp, kind: { enum: ['apply', 'undo', 'protect'] } });
-const historyEntry = obj({ version: positive, snapshot: obj({ rootId: identity, nodes: { type: 'array', items: nodeSchema, maxItems: 256 } }) }, ['version', 'snapshot']);
+export const compositionReceiptSchema = obj({ changeId: identity, author: text, version: positive, requestDigest: digest, at: timestamp, kind: { enum: ['apply', 'undo', 'protect', 'delete'] } });
+const historyEntry = obj({ version: positive, snapshot: obj({ rootId: identity, nodes: { type: 'array', items: nodeSchema, maxItems: 256 }, deleted: { type: 'boolean' } }, ['rootId', 'nodes']) }, ['version', 'snapshot']);
 export const witnessSchema = { ...obj({
         witnessId: digest, projectId: identity, taskId: identity, compositionId: identity, compositionVersion: positive,
         sourceEvent: { type: 'object', additionalProperties: true }, policyRef: digest,
@@ -208,13 +223,13 @@ export const witnessSchema = { ...obj({
         at: timestamp
     }, ['witnessId', 'projectId', 'taskId', 'compositionId', 'compositionVersion', 'views']) };
 export const structuredCompositionSchema = { ...obj({
-        format: { const: 'rho.composition/1' }, compositionId: identity, rootId: identity,
+        format: { const: 'rho.composition/1' }, compositionId: identity, rootId: identity, deleted: { type: 'boolean' },
         nodes: { type: 'array', items: nodeSchema, maxItems: 256 },
         views: { type: 'array', items: viewSchema, maxItems: 32 },
         availability: { type: 'object', additionalProperties: availabilitySchema },
         version: positive, author: text, acknowledgedAt: timestamp,
         history: { type: 'array', items: historyEntry, maxItems: 256 },
-        receipts: { type: 'array', items: { ...obj({ changeId: identity, requestDigest: digest, version: positive, author: text, at: timestamp, kind: { enum: ['apply', 'undo', 'protect', 'close'] } }, ['changeId', 'author', 'version', 'at']) }, maxItems: 256 },
+        receipts: { type: 'array', items: { ...obj({ changeId: identity, requestDigest: digest, version: positive, author: text, at: timestamp, kind: { enum: ['apply', 'undo', 'protect', 'close', 'delete'] } }, ['changeId', 'author', 'version', 'at']) }, maxItems: 256 },
         retainedFromVersion: positive, undoRetainedFromVersion: positive,
         receipt: compositionReceiptSchema,
         witness: { anyOf: [witnessSchema, { type: 'null' }] }, witnessState: { enum: ['retained', 'expired', 'pending'] },

package/dist/running.d.ts

@@ -0,0 +1,10 @@
+export type Running = {
+    stateDirectory: string;
+    url: string;
+    pid: number;
+};
+export declare const runningDirectory: (env?: NodeJS.ProcessEnv) => string;
+export declare function announce(note: Running, directory?: string): Promise<void>;
+export declare function withdraw(stateDirectory: string, pid?: number, directory?: string): Promise<void>;
+export declare function running(directory?: string): Promise<Running[]>;
+export declare function announced(stateDirectory: string, directory?: string): Promise<boolean>;

package/dist/running.js

@@ -0,0 +1,45 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+export const runningDirectory = (env = process.env) => env.RHO_RUNNING_DIR || path.join(os.homedir(), 'Rho', 'running');
+const noteFile = (stateDirectory, directory) => path.join(directory, createHash('sha256').update(path.resolve(stateDirectory)).digest('hex').slice(0, 16) + '.json');
+async function read(file) {
+    try {
+        const note = JSON.parse(await fs.readFile(file, 'utf8'));
+        return typeof note?.stateDirectory === 'string' && typeof note?.url === 'string' && Number.isInteger(note?.pid) ? note : null;
+    }
+    catch {
+        return null;
+    }
+}
+const alive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+};
+export async function announce(note, directory = runningDirectory()) {
+    await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+    const file = noteFile(note.stateDirectory, directory), partial = `${file}.${process.pid}.tmp`;
+    await fs.writeFile(partial, JSON.stringify({ ...note, stateDirectory: path.resolve(note.stateDirectory) }) + '\n', { mode: 0o600 });
+    await fs.rename(partial, file);
+}
+// Only the Rho that wrote a note removes it, so a later start on the same state keeps its own.
+export async function withdraw(stateDirectory, pid = process.pid, directory = runningDirectory()) {
+    const file = noteFile(stateDirectory, directory);
+    if ((await read(file))?.pid === pid)
+        await fs.rm(file, { force: true });
+}
+export async function running(directory = runningDirectory()) {
+    const names = (await fs.readdir(directory).catch(() => [])).filter(name => name.endsWith('.json'));
+    const notes = await Promise.all(names.map(name => read(path.join(directory, name))));
+    return notes.filter((note) => !!note && alive(note.pid));
+}
+export async function announced(stateDirectory, directory = runningDirectory()) {
+    const note = await read(noteFile(stateDirectory, directory));
+    return !!note && note.stateDirectory === path.resolve(stateDirectory) && alive(note.pid);
+}

package/dist/server.d.ts

@@ -116,6 +116,7 @@ export declare class RhoService {
     conversations: Conversations;
     private consoles;
     private kernels;
+    private figures;
     private skillHosts;
     private feedback;
     configureFeedback(projectId: string, options?: {
@@ -168,27 +169,20 @@ export declare class RhoService {
     agentConnection(projectId: string, externalSessionId: string, file: string, methods?: string[], pluginFilter?: string[], profile?: 'layered-business' | 'layered-presentation', who?: {
         label?: string;
         conversationId?: string;
-    }): Promise<{
-        apiVersion: "2.0";
-        pluginFilter?: ("media" | "r" | "agent" | "files" | "skills" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel")[] | undefined;
-        profile?: "layered-business" | "layered-presentation" | undefined;
-        url: string;
-        token: string;
-        projectId: string;
-        externalSessionId: string;
-        methods: string[];
-    }>;
+    }): Promise<any>;
     private authenticate;
     private handle;
     private readBody;
     private json;
     private serial;
     private recordActivity;
+    private agentSessions;
     private projectActivity;
     private agentSummaries;
     private dataDir;
     private consoleFor;
     private kernelFor;
+    private figuresFor;
     private skillsFor;
     dispatch(request: OperationRequest, principal: Principal, contractRef?: string): Promise<unknown>;
     private events;

package/dist/server.js

@@ -19,7 +19,7 @@ import { Interactions } from './interactions.js';
 import { TaskMap } from './task-map.js';
 import { Capabilities } from './capabilities.js';
 import { BrowserAccess, localBrowserId, localBrowserPrincipal } from './browser-access.js';
-import { addToAgent, connectLimits, mcpCommand, mcpName, outsideLabel } from './agent-connect.js';
+import { addToAgent, connectionInstructions, connectLimits, mcpCommand, mcpName, outsideLabel } from './agent-connect.js';
 import { NativeFolderPicker, nativeFolderLimits } from './native-folders.js';
 import { homedir } from 'node:os';
 import { serveWeb, servePageFrame, pageFramePath, extensionFramePath, webRoot, installedWebEntries } from './web-assets.js';
@@ -34,6 +34,7 @@ import { exitWords, stopState } from './execution-facts.js';
 import { exportRun } from './run-export.js';
 import { ownerContracts } from './contracts/owners.generated.js';
 import { Conversations } from './conversations.js';
+import { captureUiContext } from './ui-context.js';
 import { describeLimits } from './file-describer.js';
 import { projectWork } from './project-work.js';
 export const serviceLimits = { maxRequestBytes: 1024 * 1024, maxEventBytes: 65536, eventRetention: 256, maxSubscriptions: 8, maxQueue: 32, maxContexts: 128, maxBindings: 64, maxActivities: 256, maxContextBytes: 1024 * 1024, maxRetainedMetadataBytes: 32 * 1024 * 1024 };
@@ -178,6 +179,20 @@ function explainFailure(e) {
         default: return ['storage', 'The operation could not be confirmed; retain the original identity and inspect its state.', { code }];
     }
 }
+// `x-rho-client: name/version`, each part URI-encoded: the MCP client's own name for itself.
+// Printable text only, bounded; anything else is ignored rather than shown.
+function clientOf(header) {
+    if (typeof header !== 'string' || header.length > 300)
+        return null;
+    try {
+        const [name, version] = header.split('/').map(decodeURIComponent);
+        const ok = (value, max) => value !== undefined && value.length > 0 && value.length <= max && /^[\x20-\x7e]+$/.test(value);
+        return ok(name, 128) ? { name, ...(ok(version, 64) ? { version } : {}) } : null;
+    }
+    catch {
+        return null;
+    }
+}
 export class RhoService {
     config;
     extensions;
@@ -203,6 +218,7 @@ export class RhoService {
     conversations;
     consoles = new Map();
     kernels = new Map();
+    figures = new Map();
     skillHosts = new Map();
     feedback(project, owners = this.plugins.project(project.root, project.id)) {
         const agent = owners.need('agent');
@@ -394,6 +410,9 @@ export class RhoService {
             },
             directory: project => this.dataDir(project),
             notebook: () => this.plugins.availableIds().includes('kernel'),
+            // start/send already holds the service's project serializer while this
+            // observation is frozen, before the conversation is recorded or launched.
+            uiContext: (project, location, limits) => captureUiContext(project, location, id => new Workspace(project, this.plugins.project(project.root, project.id), this.config.workspace).read(id), limits, this.plugins.optional('figures') ? (ref, selectionId, rows) => this.figuresFor(project).brief(ref, selectionId, rows) : undefined),
             context: async (project, id) => {
                 const context = await this.plugins.project(project.root, project.id).need('agent').peekContext(id);
                 requireThat(context.projectId === project.id, 'scope', 'The context belongs to another project.');
@@ -452,6 +471,7 @@ export class RhoService {
                 return [await writeClaudePlugin(path.join(this.state.directory, 'claude-plugins'), { name: 'rho', version: selectedPluginVersions.agent, description: 'Skills and hooks of the plugins selected in Rho.', ...declared })];
             },
             changed: async (project, conversationId) => { void this.serial(project.id, () => this.emit(project, 'conversation.changed', conversationId, localBrowserId)).catch(() => { }); },
+            nativeSession: async (project, producer, sessionId) => (await import('@rho-workspace/plugin-agent/native-sessions')).nativeSession(project.root, producer, sessionId),
             // The person's own Claude Code when one is named, with no tools and in an empty folder of
             // Rho's state, so it reads only what it is given and loads no project instructions. What
             // a call cost comes from Claude Code when it knows the model's price, else from models.dev.
@@ -527,7 +547,8 @@ export class RhoService {
                 await listen(0);
             }
             this.url = 'http://127.0.0.1:' + this.server.address().port;
-            await atomicJson(connectionFile, { url: this.url, token: this.adminToken, apiVersion: '2.0' });
+            // The process that serves it, so rho --stop can say when it has ended and not only closed.
+            await atomicJson(connectionFile, { url: this.url, token: this.adminToken, apiVersion: '2.0', pid: process.pid });
             // An Agent's connection holds the address it was given. When the address changed, each one
             // that named the earlier address follows, so the Agent's next session reaches this service
             // with the grant it already has. Its token and methods are unchanged.
@@ -570,11 +591,22 @@ export class RhoService {
         requireThat(selected.every(m => !extensionManagement.includes(m) && !!operations[m] && !m.startsWith('agent.sessions.') && !m.startsWith('session.') && !m.startsWith('conversation.') && (!m.startsWith('project.') || m === 'project.entries') && !['task.routing.put', 'console.run', 'console.stop', 'kernel.stop'].includes(m)), 'invalid', 'Unknown or operator-only Agent capability.');
         requireThat(await Promise.all(selected.map(method => capabilities.isAvailable(method, state))).then(values => values.every(Boolean)), 'unavailable', 'A requested Agent operation has no selected provider.');
         requireThat(!profile || new Set(['capability.index', 'capability.resolve', ...selected]).size <= layeredGrantLimits.maxMethods, 'limit', `Layered connection methods exceed the ${layeredGrantLimits.maxMethods}-method profile; choose an explicit narrower grant.`, { limit: 'maxMethods', maximum: layeredGrantLimits.maxMethods });
-        const token = randomBytes(32).toString('hex');
         const id = 'agent:' + digest(projectId + ':' + externalSessionId).slice(0, 32);
+        const grantedMethods = [...new Set([...(profile ? ['capability.index', 'capability.resolve'] : ['protocol.describe', 'capability.list']), ...selected])];
+        const existing = this.state.principals.find(p => p.id === id);
+        const kept = await fs.readFile(file, 'utf8').then(text => JSON.parse(text), () => null);
+        // Repeating the same setup must not disconnect a client already using its grant.
+        // Changed scope, expired access or a stale address still requires a fresh credential.
+        if (existing && !(existing.expiresAt && Date.parse(existing.expiresAt) <= Date.now())
+            && kept?.url === this.url && kept.projectId === projectId && kept.externalSessionId === externalSessionId
+            && typeof kept.token === 'string' && digest(kept.token) === existing.tokenHash
+            && canonical([...existing.methods].sort()) === canonical([...grantedMethods].sort())
+            && kept.profile === profile && canonical(existing.pluginFilter ?? []) === canonical(pluginFilter ?? []))
+            return kept;
+        const token = randomBytes(32).toString('hex');
         this.state.principals = this.state.principals.filter(p => p.id !== id);
         requireThat(!pluginFilter || pluginFilter.every(id => this.plugins.isKnown(id)), 'invalid', 'Unknown MCP plugin filter.');
-        await this.state.addPrincipal({ id, tokenHash: digest(token), projectId, label: who.label ?? externalSessionId, ...(who.conversationId ? { conversationId: who.conversationId } : {}), methods: [...new Set([...(profile ? ['capability.index', 'capability.resolve'] : ['protocol.describe', 'capability.list']), ...selected])], ...(profile ? { profile } : {}), ...(pluginFilter ? { pluginFilter } : {}) });
+        await this.state.addPrincipal({ id, tokenHash: digest(token), projectId, label: who.label ?? externalSessionId, ...(who.conversationId ? { conversationId: who.conversationId } : {}), methods: grantedMethods, ...(profile ? { profile } : {}), ...(pluginFilter ? { pluginFilter } : {}) });
         const connection = { url: this.url, token, projectId, externalSessionId, methods: [...new Set([...(profile ? ['capability.index', 'capability.resolve'] : []), ...selected])], ...(profile ? { profile } : {}), ...(pluginFilter ? { pluginFilter } : {}), apiVersion: '2.0' };
         await atomicJson(file, connection);
         return connection;
@@ -671,6 +703,10 @@ export class RhoService {
             const method = url.pathname.startsWith('/api/v2/') ? url.pathname.slice(8) : '';
             requireThat(method === 'events' || !!operations[method], 'not_found', 'Unknown API operation.');
             const principal = this.authenticate(req, method);
+            // An Agent's MCP bridge names the client that started it; the person's screen shows it.
+            const named = principal.projectId && principal.kind !== 'browser' ? clientOf(req.headers['x-rho-client']) : null;
+            if (named)
+                void this.state.markClient(principal.id, named).catch(() => { });
             if (method === 'events') {
                 requireThat(req.method === 'GET', 'invalid', 'Events use GET.');
                 await this.subscribe(url, principal, res);
@@ -785,6 +821,33 @@ export class RhoService {
     // What the project's Agents did, for the person's screen:
     // only principals whose grant names this project, only the fields the activity record
     // keeps. A grant is the scope; an Agent need not have opened a binding.
+    // Every Agent session in the project folder, wherever it was started: Harness conversations Rho
+    // observes and the sessions Claude Code and Codex keep in their own files. Each names the Agent
+    // Rho continues it with and the Rho conversation that already continues it. Reads files only.
+    async agentSessions(p) {
+        const agent = this.plugins.optional('agent');
+        const external = agent ? agent.listExternalSessions(p.root) : { sessions: [], omitted: 0 };
+        const native = (await import('@rho-workspace/plugin-agent/native-sessions')).listNativeSessions(p.root);
+        const conversations = [...await this.conversations.list(p, {}), ...await this.conversations.list(p, { trashed: true })];
+        const bySession = new Map(conversations.filter(c => c.sessionId).map(c => [c.sessionId, c]));
+        const harness = await this.conversations.harness();
+        const sessions = [...external.sessions, ...native.sessions].flatMap(s => {
+            const conversation = bySession.get(s.sessionId);
+            if (conversation?.trashedAt)
+                return [];
+            const continueWith = s.producer === 'claude-code' ? 'claude-acp' : s.producer === 'codex' ? 'codex-acp' : s.producer === 'dsh' ? harness : null;
+            // Harness reports a turn in progress, not whether a window holds the session idle; a turn
+            // Rho itself is running is Rho's.
+            const open = s.producer === 'dsh' && s.state === 'running' && conversation?.state !== 'running' ? { where: 'DeepSeek Harness' } : s.open;
+            return [{ ...s, continueWith, ...(open !== undefined ? { open } : {}), ...(conversation ? { conversationId: conversation.conversationId } : {}) }];
+        });
+        // A session held only by Rho's own connection is not open elsewhere.
+        for (const s of sessions)
+            if (s.open && s.conversationId && await this.conversations.owns(p, s.conversationId, s.open.pid))
+                s.open = null;
+        sessions.sort((a, b) => b.lastAt.localeCompare(a.lastAt));
+        return { sessions: sessions.slice(0, 128), omitted: external.omitted + native.omitted + Math.max(0, sessions.length - 128) };
+    }
     async projectActivity(p) {
         const agent = this.plugins.project(p.root, p.id).agent;
         if (!agent)
@@ -799,7 +862,7 @@ export class RhoService {
         const activity = await this.projectActivity(p);
         return this.state.principals.filter(x => x.projectId === p.id && x.kind !== 'browser' && x.id !== 'operator').map(x => {
             const last = activity.entries.filter((e) => e.principal === x.id).at(-1);
-            return { principal: x.id, label: x.label ?? null, profile: x.profile ?? null, methods: x.methods, expiresAt: x.expiresAt ?? null, ended: !!x.expiresAt && Date.parse(x.expiresAt) <= Date.now(), conversationId: x.conversationId ?? null, added: x.added ?? null,
+            return { principal: x.id, label: x.label ?? null, profile: x.profile ?? null, methods: x.methods, expiresAt: x.expiresAt ?? null, ended: !!x.expiresAt && Date.parse(x.expiresAt) <= Date.now(), conversationId: x.conversationId ?? null, client: x.client ?? null, added: x.added ?? null,
                 last: last ? { at: String(last.at), method: String(last.method), outcome: last.outcome === 'rejected' ? 'rejected' : 'returned', ...(last.operationId ? { operationId: String(last.operationId) } : {}) } : null };
         });
     }
@@ -833,11 +896,24 @@ export class RhoService {
                     return;
                 pending = setTimeout(() => { pending = undefined; void this.serial(p.id, () => this.emit(p, 'kernel.changed', p.id, localBrowserId)).catch(() => { }); }, 250);
             };
-            host = new KernelHost(p.root, { limits: this.config.kernel, rscript: this.bridge.rscript, python: this.config.python, ssh: this.config.ssh, serverctl: this.config.serverctl, onChange: changed });
+            // With the figures plugin, each local R and Python session describes the plots it draws.
+            const figures = this.plugins.optional('figures');
+            host = new KernelHost(p.root, { limits: this.config.kernel, rscript: this.bridge.rscript, python: this.config.python, ssh: this.config.ssh, serverctl: this.config.serverctl, onChange: changed,
+                ...(figures ? { extensions: { r: [figures.rExtension], python: [figures.pythonExtension] } } : {}) });
             this.kernels.set(p.id, host);
         }
         return host;
     }
+    // The figures the project's live R session drew, read from the records its cells kept.
+    figuresFor(p) {
+        let host = this.figures.get(p.id);
+        if (!host) {
+            const { Figures } = this.plugins.need('figures');
+            host = new Figures(p.root, { record: (cellId, plot) => this.kernelFor(p).figureRecord(cellId, plot), saved: sha256 => this.kernelFor(p).savedFigure(sha256) });
+            this.figures.set(p.id, host);
+        }
+        return host;
+    }
     // The project's skills, written by the person and their Agent. A change reaches open pages
     // once the request that made it has finished.
     skillsFor(p) {
@@ -869,7 +945,9 @@ export class RhoService {
             return describeProtocol(protocol, principal.methods, b);
         if (extensionManagement.includes(method)) {
             requireThat(principal.id === 'operator' || principal.id === localBrowserId, 'scope', 'Plugin installation and management belong to the person at this machine.');
-            return method === 'extension.install' ? this.extensions.install(b.source, b.replace, b.expectedDigest) : this.extensions.manage(b.pluginId, b.expectedDigest, b.action);
+            if (method === 'extension.market.change')
+                return this.extensions.changeMarket(b);
+            return method === 'extension.install' ? this.extensions.install(b.source, b.replace, b.expectedDigest, b.market) : this.extensions.manage(b.pluginId, b.expectedDigest, b.action);
         }
         if (method === 'extension.list' && !b.projectId) {
             requireThat(principal.id === 'operator' || principal.id === localBrowserId, 'scope', 'A project-scoped caller must supply its project.');
@@ -1156,10 +1234,15 @@ export class RhoService {
             await this.emit(p, 'composition.changed', b.compositionId);
             return { document, viewId, composition };
         }
+        if (method === 'session.instructions') {
+            requireThat(principal.id === localBrowserId || principal.id === 'operator', 'unauthorized', 'Only the person at this machine can read Agent setup instructions.');
+            return connectionInstructions(p, this.state.directory);
+        }
         if (method === 'session.grant') {
             requireThat(principal.id === 'operator', 'unauthorized', 'Only the local operator may provision a project-scoped session.');
             const file = path.join(this.state.directory, 'agent-' + digest(p.id + ':' + b.externalSessionId) + '.json');
             const connection = await this.agentConnection(p.id, b.externalSessionId, file, b.methods, undefined, b.profile);
+            await this.emit(p, 'activity.changed', method);
             return { profile: connection.profile, connectionFile: file, projectId: p.id, methods: connection.methods, transport: 'stdio-mcp', externalSessionId: b.externalSessionId };
         }
         // The person's own Claude Code or Codex, outside Rho: the same grant the operator gives, kept
@@ -1190,11 +1273,16 @@ export class RhoService {
         // The person at this machine talks to a conversation Rho started; Agents and narrower links
         // cannot start one, and an Agent started this way cannot start another.
         if (method.startsWith('agent.sessions.')) {
-            requireThat(principal.id === localBrowserId, 'unauthorized', 'External conversation history belongs to the person at this machine.');
-            const agent = this.plugins.need('agent');
+            requireThat(principal.id === localBrowserId, 'unauthorized', 'Agent session history belongs to the person at this machine.');
             if (method === 'agent.sessions.list')
-                return agent.listExternalSessions(p.root);
-            return agent.readExternalSession(p.root, b);
+                return this.agentSessions(p);
+            const listed = (await this.agentSessions(p)).sessions.find(s => s.id === b.session);
+            requireThat(listed, 'not_found', 'That Agent session is not in this project.');
+            const read = listed.producer === 'claude-code' || listed.producer === 'codex'
+                ? await (await import('@rho-workspace/plugin-agent/native-sessions')).readNativeSession(p.root, b)
+                : this.plugins.need('agent').readExternalSession(p.root, b);
+            requireThat(read, 'not_found', 'That Agent session is no longer in this project.');
+            return { ...read, session: { ...read.session, ...listed } };
         }
         if (method === 'project.work.read') {
             requireThat(principal.id === localBrowserId, 'scope', 'Project work is available to the person at this machine.');
@@ -1235,16 +1323,35 @@ export class RhoService {
             if (method === 'conversation.settings.read')
                 return this.conversations.settings();
             this.plugins.need('agent');
+            if (method === 'conversation.start' && b.continue) {
+                const listed = (await this.agentSessions(p)).sessions.find(s => s.id === b.continue.session);
+                requireThat(listed, 'not_found', 'That Agent session is not in this project. Nothing was sent.');
+                requireThat(listed.continueWith, 'condition', listed.producer === 'dsh'
+                    ? 'Rho continues DeepSeek Harness sessions through Harness\'s ACP command. Add DeepSeek Harness under Agents in Rho, or continue in Harness. Nothing was sent.'
+                    : 'Rho cannot continue this Agent\'s sessions. Nothing was sent.');
+                requireThat(!listed.conversationId, 'conflict', 'This session already continues as a conversation here. Open it to send your message.');
+                requireThat(!b.continue.copy || listed.producer !== 'dsh', 'condition', 'DeepSeek Harness cannot copy a session. Continue it in place once it is not answering. Nothing was sent.');
+                requireThat(!listed.open || listed.producer !== 'dsh', 'condition', 'DeepSeek Harness is answering in this session now. Continue it once that turn ends. Nothing was sent.', { heldBy: 'DeepSeek Harness' });
+                return this.conversations.start(p, principal.id, { ...b, continue: { producer: listed.producer, sessionId: listed.sessionId, title: listed.title, where: listed.where ?? (listed.producer === 'dsh' ? 'DeepSeek Harness' : 'another window'), copy: !!b.continue.copy, backend: listed.continueWith } });
+            }
             if (method === 'conversation.start')
                 return this.conversations.start(p, principal.id, b);
-            if (method === 'conversation.send')
+            if (method === 'conversation.send') {
+                // A Harness session reports its own turns through its adapter; Rho does not write into one it is answering.
+                const listed = (await this.agentSessions(p)).sessions.find(s => s.conversationId === b.conversationId && s.producer === 'dsh');
+                requireThat(!listed?.open, 'condition', 'DeepSeek Harness is answering in this session now. Send once that turn ends. Nothing was sent.', { heldBy: 'DeepSeek Harness' });
                 return this.conversations.send(p, principal.id, b);
+            }
             if (method === 'conversation.configure')
                 return this.conversations.configure(p, principal.id, b);
             if (method === 'conversation.settings.update')
                 return this.conversations.updateSettings(b);
             if (method === 'conversation.settings.check')
                 return this.conversations.check(p, b);
+            if (method === 'conversation.agents.add')
+                return this.conversations.addAgent(p, b);
+            if (method === 'conversation.agents.remove')
+                return this.conversations.removeAgent(b);
         }
         const capabilities = new Capabilities(this.plugins, p);
         // The person runs and stops Console commands with their own shell; anyone holding the read
@@ -1304,6 +1411,21 @@ export class RhoService {
             if (method === 'kernel.server.skill')
                 return host.serverSkill(b.server, b.name);
         }
+        // A plot the live R session drew, with its marks bound to their rows. The person and their
+        // Agent read it and keep the marks they point to; a kept selection reaches open pages.
+        if (method.startsWith('figure.')) {
+            await capabilities.assertAvailable(method, principal);
+            const figures = this.figuresFor(p);
+            const ref = { cellId: b.cellId, plot: b.plot, path: b.path, sha256: b.sha256 };
+            if (method === 'figure.read')
+                return figures.read({ ...ref, form: b.form, marks: b.marks, selection: b.selection, where: b.where, limit: b.limit });
+            if (method === 'figure.select') {
+                const result = await figures.select({ ...ref, marks: b.marks, note: b.note, changeId: b.changeId }, principal.id);
+                const kept = result.selection;
+                await this.emit(p, 'figure.changed', kept.sha256 ? 'file:' + kept.sha256 : kept.cellId + ':' + kept.plot, principal.id);
+                return result;
+            }
+        }
         // How work is done in the project: the person and their Agent read its skills, and record and
         // undo changes to them, each kept with who made it, why and from what.
         if (method.startsWith('skills.')) {
@@ -1487,8 +1609,12 @@ export class RhoService {
             return owners.need('charts').plot(b.resource, b.x, b.y, b.maxPoints);
         if (method === 'data.compare')
             return owners.need('tables').compare(b.left, b.right, b.options);
-        if (['composition.apply', 'composition.undo', 'view.protection.set'].includes(method)) {
-            const result = await workspace.apply(b, principal.id, method === 'composition.undo' ? 'undo' : method === 'view.protection.set' ? 'protect' : 'apply');
+        if (['composition.apply', 'composition.undo', 'composition.delete', 'view.protection.set'].includes(method)) {
+            if (method === 'composition.delete' && (await routing.read())?.compositionId === b.compositionId) {
+                const retained = await workspace.read(b.compositionId);
+                requireThat(retained.receipts?.some((r) => r.changeId === b.changeId), 'condition', 'An active task uses this layout.');
+            }
+            const result = await workspace.apply(b, principal.id, method === 'composition.undo' ? 'undo' : method === 'composition.delete' ? 'delete' : method === 'view.protection.set' ? 'protect' : 'apply');
             const route = await routing.read();
             if (route) {
                 try {

package/dist/state.d.ts

@@ -40,6 +40,10 @@ export interface Principal {
     label?: string;
     conversationId?: string;
     added?: AddedTo;
+    client?: {
+        name: string;
+        version?: string;
+    };
 }
 export declare function lease(directory: string): Promise<() => Promise<void>>;
 export declare class State {
@@ -55,6 +59,10 @@ export declare class State {
     private persistPrincipals;
     addPrincipal(principal: Principal): Promise<void>;
     removePrincipal(id: string): Promise<void>;
+    markClient(id: string, client: {
+        name: string;
+        version?: string;
+    }): Promise<void>;
     markAdded(id: string, added: AddedTo): Promise<void>;
     revokeBrowser(id: string): Promise<{
         sessionId: string;

package/dist/state.js

@@ -90,6 +90,14 @@ export class State {
     async addPrincipal(principal) { this.principals.push(principal); await this.persistPrincipals(); }
     async removePrincipal(id) { this.principals = this.principals.filter(p => p.id !== id); await this.persistPrincipals(); }
     // Which Agent outside Rho a grant was added to, kept with the grant it serves.
+    // The MCP client that last used a grant, as it named itself; kept with the grant it used.
+    async markClient(id, client) {
+        const principal = this.principals.find(p => p.id === id);
+        if (!principal || (principal.client?.name === client.name && principal.client?.version === client.version))
+            return;
+        principal.client = client;
+        await this.persistPrincipals();
+    }
     async markAdded(id, added) { const principal = this.principals.find(p => p.id === id); if (principal) {
         principal.added = added;
         await this.persistPrincipals();

package/dist/studio-layout.js

@@ -49,7 +49,7 @@ export function studioFiles(graph) {
                 take(item.node, role, item.role === 'primary');
         }
     }
-    return [...found.values()].sort((a, b) => rank[a.role] - rank[b.role] || Number(b.lead) - Number(a.lead) || a.first - b.first || a.path.localeCompare(b.path));
+    return [...found.values()].sort((a, b) => rank[a.role] - rank[b.role] || (a.role === 'input' && b.role === 'input' ? Number(b.category === 'data') - Number(a.category === 'data') : 0) || Number(b.lead) - Number(a.lead) || a.first - b.first || a.path.localeCompare(b.path));
 }
 // The files as they stood at a moment: those the work had by then, each with the versions kept
 // by then. Null is now.
@@ -76,10 +76,10 @@ export function studioTree(views, commands, session = null) {
         return id;
     };
     const input = region(studioIds.input, of('input').map(v => v.node)), code = region(studioIds.code, of('code').map(v => v.node));
-    const run = region(studioIds.commands, [commands, session].filter((n) => !!n));
+    const run = region(studioIds.commands, [session, commands].filter((n) => !!n));
     const made = [...of('result'), ...of('report')];
     const figures = region(studioIds.figures, made.filter(v => v.figure).map(v => v.node)), result = region(studioIds.result, made.filter(v => !v.figure).map(v => v.node));
-    const leftId = column(studioIds.left, [input ? { id: input, weight: 1 } : null, code ? { id: code, weight: 1.8 } : null, run ? { id: run, weight: 1.2 } : null]);
+    const leftId = column(studioIds.left, [input ? { id: input, weight: 1.4 } : null, code ? { id: code, weight: 1.2 } : null, run ? { id: run, weight: 1.4 } : null]);
     const rightId = column(studioIds.right, [figures ? { id: figures, weight: 1.25 } : null, result ? { id: result, weight: 1 } : null]);
     if (leftId && rightId) {
         nodes.push(split(studioIds.root, 'horizontal', [{ id: leftId, weight: 1 }, { id: rightId, weight: 1.3 }]));

package/dist/task-frame.d.ts

@@ -98,4 +98,4 @@ export declare function counts(map: TaskMapState): {
     waiting: number;
     done: number;
 };
-export declare function authorLabel(author: string, principalId?: string): "You" | "Someone in another tab" | "Rho" | "The Agent";
+export declare function authorLabel(author: string, principalId?: string): "Rho" | "You" | "Someone in another tab" | "The Agent";

package/dist/timeline-events.d.ts

@@ -8,6 +8,7 @@ export interface LaneOwner {
     principal: string | null;
     title: string;
     agent: string;
+    eventKeys?: string[];
 }
 export type Who = 'person' | 'conversation' | 'other';
 export interface EventMark {

package/dist/timeline-events.js

@@ -6,13 +6,20 @@ export const personPrincipal = 'browser:local';
 export const personLane = 'person', otherLane = 'other';
 export function eventMarks(events, owners, now) {
     const byPrincipal = new Map(owners.flatMap(o => o.principal ? [[o.principal, o]] : []));
+    const byEvent = new Map();
+    for (const owner of owners)
+        for (const key of owner.eventKeys ?? []) {
+            const previous = byEvent.get(key);
+            byEvent.set(key, previous === undefined || previous?.conversationId === owner.conversationId ? owner : null);
+        }
     return events.flatMap(e => {
         const at = Date.parse(e.startedAt);
         if (!Number.isFinite(at))
             return [];
         const ended = e.endedAt ? Date.parse(e.endedAt) : NaN;
         const end = Math.max(at, Number.isFinite(ended) ? ended : e.outcome === 'running' ? now : at);
-        const owner = e.by === personPrincipal ? null : byPrincipal.get(e.by);
+        const key = e.source + ':' + e.id;
+        const owner = e.by === personPrincipal ? null : byEvent.has(key) ? byEvent.get(key) : byPrincipal.get(e.by);
         const who = e.by === personPrincipal ? 'person' : owner ? 'conversation' : 'other';
         return [{ key: e.source + ':' + e.id, at, end, lane: who === 'person' ? personLane : owner ? owner.conversationId : otherLane,
                 laneTitle: who === 'person' ? 'You' : owner ? owner.title : 'Outside Rho', who, ...(owner ? { agent: owner.agent } : {}),