@rho-workspace/rho 0.5.3 → 0.5.5

package/dist/plugin-cli.js

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

package/dist/plugin-inventory.json

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

package/dist/plugins.d.ts

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

package/dist/project-notes.js

@@ -21,6 +21,7 @@ export function notesInstructions(conversationId, options = {}) {
         '- Data & method: one bullet for the data and one for each script, each linked, saying what it is and how it is used.',
         '- Key results: one bullet per finding, each linking the result files it rests on; embed a key figure on its own line as ![what it shows](path/to/figure.png).',
         '- Files: right after you write a result, table, figure or script, and before your next command, add a bullet as - [path](path) — what it holds; correct it when that changes. Do not leave this to the end.',
+        '- Scripts and cells: above each top-level statement that first makes a value you report, or writes a file, add a comment `# means: …` with one short sentence saying what it is, in the language the person writes in, under 200 characters. Where one statement makes or writes several things, name the one the comment is for: `# means NAME: …`, with a value name or a file path. Comments inside a function, and changes to a value after it is made, need none. Rho shows these sentences beside the code, so a reader who does not read R or Python can follow the steps.',
         '- Choices: when the analysis takes a choice that has a reasonable alternative (a test, a threshold, an exclusion, a model), go on with your choice and do not ask the person or wait. Where the alternative is cheap, compute it too. Write one bullet saying what you chose and what it gives, linking its results, with a nested bullet starting "Alternative:" that says what the other option gives, linking its results.',
         '- To do: a task list (- [ ] open, - [x] done).',
         '- Leave a subsection empty until you have something for it; do not write placeholders such as "to be filled".',
@@ -33,6 +34,7 @@ export function notesInstructions(conversationId, options = {}) {
             '- 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.',
+            '- 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/project-work.d.ts

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

package/dist/project-work.js

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

package/dist/protocol.d.ts

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

package/dist/protocol.js

@@ -1,3 +1,4 @@
+import { extensionOperations, extensionResponses, extensionDescriptions } from './extension-contract.js';
 import { evidenceSchema } from './evidence-capture.js';
 import { ownerContracts } from './contracts/owners.generated.js';
 import { enhancementSchemas } from './enhancement-contracts.js';
@@ -20,7 +21,9 @@ 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;
-const agentBackend = { enum: ['claude-acp', 'codex-acp'] };
+// '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'] };
 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' }] };
@@ -40,7 +43,7 @@ for (const owner of ['documents', 'files', 'r', 'requirements', 'tables', 'media
         ownerOperations[method] = contract;
     }
 }
-export const operations = { ...base.operations,
+export const operations = { ...base.operations, ...extensionOperations,
     'protocol.describe': obj({ ...project, method: text, cursor: { type: ['string', 'null'], maxLength: 128 }, limit: { type: 'integer', minimum: 1, maximum: 100 }, maxBytes: { type: 'integer', minimum: 1024, maximum: 65536 } }, []),
     'project.pick': obj({}),
     'project.source.pick': obj({}),
@@ -81,7 +84,7 @@ export const operations = { ...base.operations,
     // 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 }, []), describe: obj({ enabled: { type: 'boolean' } }, ['enabled']) }, ['projectId', 'expectedVersion']),
+    'conversation.settings.update': obj({ ...project, expectedVersion: integer, backend: { anyOf: [agentBackend, { type: 'null' }] }, choices: obj({ 'claude-acp': choices, 'codex-acp': choices, 'acp': choices }, []), describe: obj({ enabled: { type: 'boolean' } }, ['enabled']) }, ['projectId', 'expectedVersion']),
     'conversation.settings.check': obj({ ...project, backend: agentBackend }),
     // Claude Code or Codex running outside Rho, given this project and told how to start Rho's MCP server.
     'session.connect': obj({ ...project, agent: outsideAgent })
@@ -201,8 +204,8 @@ const conversationSummary = response({ conversationId: text, title: text, client
 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'] },
-    choices: response({ 'claude-acp': choices, 'codex-acp': choices }, []), offered: response({ 'claude-acp': offered, 'codex-acp': offered }, []), checking: array(agentBackend),
+const agentSettings = response({ version: integer, updatedAt: { anyOf: [text, { type: 'null' }] }, backend: { anyOf: [agentBackend, { type: 'null' }] }, serviceBackend: { enum: ['claude-acp', 'codex-acp', 'claude-cli', 'acp'] },
+    choices: response({ 'claude-acp': choices, 'codex-acp': choices, 'acp': choices }, []), offered: response({ 'claude-acp': offered, 'codex-acp': offered, 'acp': offered }, []), checking: array(agentBackend),
     // Whether a model describes the files a message writes; the facts are read either way.
     describe: response({ enabled: { type: 'boolean' } }) }, ['version', 'updatedAt', 'backend', 'serviceBackend', 'choices', 'offered', 'checking']);
 // A tool step keeps its original identity, the Agent's bounded human title, its ACP
@@ -272,7 +275,7 @@ observationSnapshot.required = observationSnapshot.required.filter(key => key !=
 const structuredComposition = contract.structuredCompositionSchema;
 const composition = { anyOf: [contract.legacyCompositionSchema, structuredComposition] };
 const taskMap = { ...contract.taskMapStateSchema, properties: { ...contract.taskMapStateSchema.properties, receipt: obj({ changeId: identity, requestDigest: digest, kind: { enum: ['declare', 'present', 'respond'] }, author: text, version: positive, at: { type: 'string', format: 'date-time' }, outcome: contract.taskMapReceiptField }, ['changeId', 'kind', 'author', 'version', 'at']) } };
-export const responses = { ...base.responses, ...ownerResponses,
+export const responses = { ...base.responses, ...ownerResponses, ...extensionResponses,
     'project.work.read': projectWorkSchema(sessionObservation),
     'project.open': { ...contract.projectRecordSchema, properties: { ...contract.projectRecordSchema.properties, host: contract.cliSchema }, required: [...contract.projectRecordSchema.required, 'host'] },
     'project.pick': response({ cancelled: { type: 'boolean' }, project: { anyOf: [contract.projectSummarySchema, { type: 'null' }] } }),
@@ -372,6 +375,7 @@ export const responses = { ...base.responses, ...ownerResponses,
 };
 responses['session.grant'].properties.profile = operations['session.grant'].properties.profile;
 export const descriptions = {
+    ...extensionDescriptions,
     'workspace.observe': 'Assigned presenter only: bounded layout/basis/owner summary/visibility projection. No feedback, full documents or native trace. Reading starts no model or renderer.',
     'workspace.enhance': 'Assigned presenter only: conditional display emphasis/title/plain Agent note using exact current generation, witness and observation. Does not modify business resources, feedback or protection.',
     'capability.index': 'Read a small role-narrowed index of currently authorized, enabled operations and immutable Skill/contract references.',
@@ -405,7 +409,7 @@ export const descriptions = {
     'console.events': 'Who ran each Console command and when, newest first, for the timeline: the folder, how it ended and its first line. No output.',
     'console.output': 'One bounded page of what a Console command printed. Output past the kept size is counted in a note, not silently dropped.',
     'console.stop': 'Person at this machine only: ask a running Console command and the processes it started to stop; they are killed after a short grace period.',
-    'kernel.run': 'Run a cell of R or Python in the project\'s live session of that language, which the Agent and the person share: what one cell defines stays for the next. Starts the session when none is live, on this machine or at a place on one of the person\'s servers (place, or where kernel.places says that language runs next). The same changeId from the same caller returns the same cell and never runs it twice. waitMs waits for the cell to end.',
+    'kernel.run': 'Run a cell of R or Python in the project\'s live session of that language, which the Agent and the person share: what one cell defines stays for the next. Starts the session when none is live, on this machine or at a place on one of the person\'s servers (place, or where kernel.places says that language runs next). interpreter names the program a session on this machine starts with, in a folder of the project such as .venv/bin/python; the project keeps it for that language\'s later sessions, and each cell records the program and version that ran it. The same changeId from the same caller returns the same cell and never runs it twice. waitMs waits for the cell to end.',
     'skills.list': 'The project\'s skills: how work is done here (the methods the person chose, the conventions they keep, the traps its work ran into), each a SKILL.md in .claude/skills that every Agent here reads, with what it is for and its newest change. Read before analysing.',
     'skills.read': 'One project skill\'s text and its changes, newest first: who made each, why, from what (cells, conversations, files) and the lines it added and removed, and what changed outside Rho since.',
     'skills.change': 'Record in a project skill when the person corrects a method or says how they work, or a failure\'s cause and fix are found: a new skill, a new text with a one-sentence reason and evidence, or its removal. Record how to work, never results. Made on the version read; the same changeId never writes twice.',

package/dist/screen-check-skill.d.ts

@@ -0,0 +1,2 @@
+import { SkillDeclaration } from '@rho-workspace/plugin-contracts';
+export declare const screenCheckSkill: SkillDeclaration;

package/dist/screen-check-skill.js

@@ -0,0 +1,39 @@
+import { digest } from '@rho-workspace/plugin-contracts';
+// The practice for checking a page's layout in a real browser, served as the Skill rho.screen-check.
+// skills/rho/references/screen-check.md carries this text verbatim, and
+// test/screen-check-skill.test.mjs fails when the two differ, so the text has one source.
+const screenCheckContent = [
+    'Check how a page lays out in a real browser before you say it works.',
+    '',
+    'Run `rho-screen-check <url or page.html>`. It opens the page at each viewport (by default 1440x900, 1024x768, 768x1024 and 390x844), waits for it to settle, writes one screenshot per viewport and prints a JSON report. Options: `--viewport WxH` (repeatable), `--out DIR` (default ./screen-check), `--overlap SELECTOR` (report the visible boxes of that selector that overlap one another), `--full-page`, `--settle MS` (default 800), `--browser auto|chrome|msedge|chromium|PATH` (default auto: Chrome, then Edge, then Playwright\'s Chromium).',
+    '',
+    'Read the exit status first. 0: the check ran, and its findings are in the report. 1: an argument was wrong. 2: the check did not run; `error.kind`, `error.message` and `error.next` say why and what to do. Do what `next` says, then run it again.',
+    '',
+    'For each viewport, read: `horizontalOverflow` with `scrollWidth` against `clientWidth` (the page is wider than the window); `elementsPastEdgeUnclipped` (what crosses the right edge and no box keeps in: read this count first), then `elementsPastEdge` (the first 50, unclipped first; `clippedBy` names the box that scrolls or hides what is beyond its own width); `unnamedButtons`; `overlaps` for your selector; `pageErrors` and `consoleErrors`; `httpErrors` (each response that failed, with its status and address); `requestsOutsideTarget` (what the page loads from elsewhere).',
+    '',
+    'Then open each `screenshot` with the Read tool and say what you see. The report says what the page does, not whether a person can follow it; the screenshot and the flow answer that. Check the states a person reaches as well as the first screen: an empty state, an error, a long name or number, a narrow window, the screen after a step. Run the check again after each change.',
+    '',
+    'Pitfalls seen in real runs:',
+    '- A selector can match hidden elements. The report counts visible boxes only; your own probes must filter by visibility too.',
+    '- The same attribute can appear in two views at once, such as a script editor\'s flow and a session\'s Data flow. Open a workspace that shows only the view you check.',
+    '- At 390 px the sidebar collapses and project labels are hidden. Reach the label through the page\'s own controls before you look for it.',
+    '- Text cut short inside a box of fixed height, such as a label that ends mid-word, is not in the report. Only the screenshot shows it.',
+    '- Restarting Rho ends the live R sessions, and the page then shows "Rho closed. Values defined before this are gone." Say so when a check follows a restart.',
+    '- Check a copy of the project, not the person\'s own project. A check must not change what the person has.',
+].join('\n');
+export const screenCheckSkill = {
+    id: 'rho.screen-check',
+    version: '1.0',
+    content: screenCheckContent,
+    digest: digest(screenCheckContent),
+    intent: 'Check how a Rho screen or a local page lays out at phone and desktop widths, in a real browser, and read the result rather than assume it.',
+    failureRecipes: [
+        { kind: 'browser_missing', message: 'No browser could be started.', next: 'Install Google Chrome or Microsoft Edge, or pass --browser with the path of an installed Chromium-based browser; then run the check again.' },
+        { kind: 'unreachable', message: 'The page did not load.', next: 'Check the address, that the service is running or the file exists, and that the page opens in a browser; then run the check again.' },
+        { kind: 'usage', message: 'An argument was not understood.', next: 'Run rho-screen-check --help and use one of the listed forms.' },
+    ],
+    verify: {
+        command: 'npm run test:screen-check',
+        description: 'Runs the screen-check tests: the findings on fixture pages in a real browser, the JSON report and the exit codes, and this Skill text against the shipped reference.',
+    },
+};

package/dist/server.d.ts

@@ -1,3 +1,4 @@
+import { Extensions, extensionLimits } from './extensions.js';
 import { evidenceExportLimits } from './evidence-export.js';
 import * as http from 'node:http';
 import { Plugins, type PluginConfig } from './plugins.js';
@@ -49,6 +50,7 @@ export declare const serviceLimits: {
 export interface ServiceConfig extends Partial<typeof serviceLimits>, Partial<typeof requestLimits>, PluginConfig {
     root: string;
     stateDir: string;
+    extensions?: Partial<typeof extensionLimits>;
     coreBinary?: string;
     rscript: string;
     python?: string;
@@ -70,6 +72,7 @@ export interface ServiceConfig extends Partial<typeof serviceLimits>, Partial<ty
     claude?: string;
     agentBackend?: ConversationConfig['backend'];
     claudeAcp?: ConversationConfig['claudeAcp'];
+    acpCommand?: ConversationConfig['acpCommand'];
     codex?: string;
     codexAcp?: ConversationConfig['codexAcp'];
     conversations?: Partial<typeof conversationLimits>;
@@ -92,6 +95,7 @@ export declare const layeredGrantLimits: {
 };
 export declare class RhoService {
     config: ServiceConfig;
+    extensions: Extensions;
     plugins: Plugins;
     state: State;
     bridge: CoreBridge;
@@ -160,12 +164,13 @@ export declare class RhoService {
     private catalog;
     private modelFacts;
     start(): Promise<this>;
+    private followAddress;
     agentConnection(projectId: string, externalSessionId: string, file: string, methods?: string[], pluginFilter?: string[], profile?: 'layered-business' | 'layered-presentation', who?: {
         label?: string;
         conversationId?: string;
     }): Promise<{
         apiVersion: "2.0";
-        pluginFilter?: ("media" | "r" | "agent" | "files" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel" | "skills")[] | undefined;
+        pluginFilter?: ("media" | "r" | "agent" | "files" | "skills" | "documents" | "requirements" | "tables" | "charts" | "annotations" | "console" | "kernel")[] | undefined;
         profile?: "layered-business" | "layered-presentation" | undefined;
         url: string;
         token: string;