@rho-workspace/rho 0.5.4 → 0.5.5

package/dist/plugin-inventory.json

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

package/dist/plugins.d.ts

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

package/dist/project-work.d.ts

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

package/dist/project-work.js

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

package/dist/protocol.d.ts

@@ -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';
@@ -42,7 +43,7 @@ for (const owner of ['documents', 'files', 'r', 'requirements', 'tables', 'media
         ownerOperations[method] = contract;
     }
 }
-export const operations = { ...base.operations,
+export const operations = { ...base.operations, ...extensionOperations,
     'protocol.describe': obj({ ...project, method: text, cursor: { type: ['string', 'null'], maxLength: 128 }, limit: { type: 'integer', minimum: 1, maximum: 100 }, maxBytes: { type: 'integer', minimum: 1024, maximum: 65536 } }, []),
     'project.pick': obj({}),
     'project.source.pick': obj({}),
@@ -274,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' }] } }),
@@ -374,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.',

package/dist/server.d.ts

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

package/dist/server.js

@@ -1,5 +1,7 @@
+import { Extensions } from './extensions.js';
+import { extensionManagement } from './extension-contract.js';
 import { EvidenceExporter, evidenceExportLimits } from './evidence-export.js';
-import { Discovery } from './discovery.js';
+import { Discovery, applicationEffects } from './discovery.js';
 import * as http from 'node:http';
 import * as fs from 'node:fs/promises';
 import path from 'node:path';
@@ -20,7 +22,7 @@ import { BrowserAccess, localBrowserId, localBrowserPrincipal } from './browser-
 import { addToAgent, connectLimits, mcpCommand, mcpName, outsideLabel } from './agent-connect.js';
 import { NativeFolderPicker, nativeFolderLimits } from './native-folders.js';
 import { homedir } from 'node:os';
-import { serveWeb, servePageFrame, pageFramePath, webRoot, installedWebEntries } from './web-assets.js';
+import { serveWeb, servePageFrame, pageFramePath, extensionFramePath, webRoot, installedWebEntries } from './web-assets.js';
 import { Presentation } from './presentation.js';
 import { presentationSchemas } from './presentation-contracts.js';
 import { isNativeTime } from './native-time.js';
@@ -178,6 +180,7 @@ function explainFailure(e) {
 }
 export class RhoService {
     config;
+    extensions;
     plugins;
     state;
     bridge;
@@ -377,6 +380,7 @@ export class RhoService {
             if (typeof value === 'number')
                 requireThat(Number.isSafeInteger(value) && (key === 'port' ? value >= 0 && value <= 65535 : value > 0), 'invalid', 'Invalid service budget.', { field: key });
         }
+        this.extensions = new Extensions(path.join(config.stateDir, 'plugins'), config.extensions);
         this.plugins = new Plugins(config);
         this.state = new State(config.root, config.stateDir);
         this.bridge = new CoreBridge(config.coreBinary, config.rscript);
@@ -484,6 +488,7 @@ export class RhoService {
             await this.plugins.load();
             this.plugins.installUi(await installedWebEntries(this.config.webRoot), Object.keys(operations));
             await this.state.init();
+            await this.extensions.init();
             // A person who starts Rho on a fresh state sees one finished study beside their own work.
             // It is copied into the projects folder once and is otherwise an ordinary project.
             this.example = await seedExampleProject(this.state, { enabled: this.config.example === true }).catch(() => null);
@@ -558,11 +563,11 @@ export class RhoService {
         const capabilities = new Capabilities(this.plugins, project);
         const state = await capabilities.state();
         // The shared project listing remains available alongside an Agent's native tools.
-        const available = Object.keys(operations).filter(m => !m.startsWith('agent.activity.') && !m.startsWith('session.') && !m.startsWith('conversation.') && (!m.startsWith('project.') || m === 'project.entries') && !m.startsWith('requirements.prepare') && !m.startsWith('workspace.restore') && !['task.routing.put', 'binding.activity.append', 'feedback.submit', 'view.observe', 'view.observations.read', 'task.map.respond', 'annotation.decide', 'evidence.export', 'evidence.preview', 'console.run', 'console.stop', 'kernel.stop'].includes(m));
+        const available = Object.keys(operations).filter(m => !extensionManagement.includes(m) && !m.startsWith('agent.activity.') && !m.startsWith('agent.sessions.') && !m.startsWith('session.') && !m.startsWith('conversation.') && (!m.startsWith('project.') || m === 'project.entries') && !m.startsWith('requirements.prepare') && !m.startsWith('workspace.restore') && !['task.routing.put', 'binding.activity.append', 'feedback.submit', 'view.observe', 'view.observations.read', 'task.map.respond', 'annotation.decide', 'evidence.export', 'evidence.preview', 'console.run', 'console.stop', 'kernel.stop'].includes(m));
         const profileMethods = profile === 'layered-presentation' ? ['binding.open', 'capability.index', 'capability.resolve', 'workspace.observe', 'workspace.enhance'] : available.filter(m => !['workspace.observe', 'workspace.enhance', ...(profile ? ['skill.list', 'skill.read', 'protocol.describe'] : [])].includes(m));
         const selected = methods ?? (profile === 'layered-presentation' ? profileMethods : (await Promise.all(profileMethods.map(async (method) => [method, await capabilities.isAvailable(method, state)]))).filter(([, enabled]) => enabled).map(([method]) => method));
         requireThat(profile !== 'layered-presentation' || selected.every(m => profileMethods.includes(m)), 'scope', 'The selected role cannot receive broader methods.');
-        requireThat(selected.every(m => !!operations[m] && !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(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');
@@ -656,8 +661,8 @@ export class RhoService {
             }
             if (!url.pathname.startsWith('/api/')) {
                 requireThat((req.method === 'GET' || req.method === 'HEAD') && !url.search, 'not_found', 'Use the same-origin browser entry without query credentials.');
-                if (url.pathname === pageFramePath) {
-                    servePageFrame(res, req.method === 'HEAD');
+                if (url.pathname === pageFramePath || url.pathname === extensionFramePath) {
+                    servePageFrame(res, req.method === 'HEAD', url.pathname === extensionFramePath);
                     return;
                 }
                 await serveWeb(url.pathname, res, this.config.webRoot, req.method === 'HEAD');
@@ -688,7 +693,7 @@ export class RhoService {
             requireThat(read.ok, read.ok ? 'invalid' : read.kind, read.ok ? '' : (read.problems[0]?.fix ? `Request does not match the versioned schema: ${read.problems[0].fix}` : 'Request does not match the versioned schema.'), read.ok ? {} : { problems: read.problems, remedy: 'Fix the named fields and resend the same request identity.' });
             const request = read.request, contractRef = typeof req.headers['x-rho-contract-ref'] === 'string' ? req.headers['x-rho-contract-ref'] : undefined;
             let value;
-            if (body.projectId && method.startsWith('kernel.')) {
+            if (body.projectId && (method.startsWith('kernel.') || method === 'extension.call')) {
                 // A cell may run for minutes and a run may wait for it. The live sessions keep their own
                 // order, so waiting holds no other request of the project, an interrupt among them.
                 const projectId = body.projectId;
@@ -862,6 +867,14 @@ export class RhoService {
         requireThat(this.state.principals.some(current => current.id === principal.id && current.tokenHash === principal.tokenHash && current.methods.includes(method) && (!current.expiresAt || Date.parse(current.expiresAt) > Date.now())), 'unauthorized', 'Session authorization expired or was revoked before this operation.');
         if (method === 'protocol.describe')
             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.list' && !b.projectId) {
+            requireThat(principal.id === 'operator' || principal.id === localBrowserId, 'scope', 'A project-scoped caller must supply its project.');
+            return this.extensions.list();
+        }
         // A dry run of any operation body: the same schema the server enforces, with the
         // edit each problem needs. Nothing is executed and no project is touched.
         if (method === 'protocol.validate') {
@@ -936,6 +949,32 @@ export class RhoService {
         const workspace = new Workspace(p, owners, this.config.workspace, this.config.interactions);
         const interactions = new Interactions(p, owners, this.config.interactions);
         const routing = new TaskRouting(p, this.config.capabilityLimits?.maxReceipts, this.config.maxRetainedMetadataBytes);
+        if (method.startsWith('extension.')) {
+            if (contractRef) {
+                const reader = new Discovery(this.plugins, p, principal, await routing.read(), await readJson(path.join(await this.dataDir(p), 'bindings.json'), []));
+                await reader.assertContract(method, contractRef);
+            }
+            if (method === 'extension.list')
+                return this.extensions.list();
+            if (method === 'extension.describe')
+                return this.extensions.describe(b.pluginId);
+            if (method === 'extension.content')
+                return this.extensions.content(b.pluginId, b.expectedDigest, b.kind, b.entryId);
+            if (method === 'extension.read')
+                return this.extensions.read(b.invocationId, principal.id, p.id);
+            if (method === 'extension.call')
+                return this.extensions.call(b, principal.id, p.root, async (target, body, effect) => {
+                    requireThat(principal.methods.includes(target), 'scope', 'The caller has not been granted this Rho method.');
+                    requireThat(!body?.projectId || body.projectId === p.id, 'scope', 'A plugin cannot delegate into another project.');
+                    const request = readOperation(target, { ...body, projectId: p.id });
+                    requireThat(request.ok, 'invalid', 'Plugin delegated an invalid Rho request.');
+                    const capabilities = new Capabilities(this.plugins, p);
+                    const status = (await capabilities.operationStatus(principal, await capabilities.state())).find(op => op.method === target);
+                    requireThat(effect !== 'read' || (status?.effect ?? applicationEffects[target]) === 'read', 'scope', 'A read operation cannot delegate a mutating Rho method.');
+                    const run = () => this.dispatch(request.request, principal);
+                    return target.startsWith('kernel.') ? run() : this.serial(p.id, run);
+                });
+        }
         // A person's own view of the folder they selected. The tab is confined to this one
         // project, so it may list that folder and open a text file from it; registering
         // resources and execution stay Agent/operator work.
@@ -1150,6 +1189,13 @@ 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');
+            if (method === 'agent.sessions.list')
+                return agent.listExternalSessions(p.root);
+            return agent.readExternalSession(p.root, b);
+        }
         if (method === 'project.work.read') {
             requireThat(principal.id === localBrowserId, 'scope', 'Project work is available to the person at this machine.');
             const agent = (await new Capabilities(this.plugins, p).state()).enabled.includes('agent') ? this.plugins.optional('agent') : null;
@@ -1166,7 +1212,7 @@ export class RhoService {
             }
             return projectWork({ project: p, cursor: (await this.events(p)).cursor, conversations: await this.conversations.work(p, b.limit),
                 documents: await owners.documentSummaries(), activity: (await this.projectActivity(p)).entries,
-                native, external: agent?.readExternalAcp(p.root), inspect: agent?.observeSessionFiles });
+                native, external: agent?.readExternalAcp(p.root), observed: agent?.listExternalSessions(p.root), readObserved: agent?.readExternalSession, inspect: agent?.observeSessionFiles });
         }
         if (method.startsWith('conversation.')) {
             requireThat(principal.id === localBrowserId, 'unauthorized', 'Conversations started in Rho belong to the person at this machine. Open Rho in a browser on this machine.');
@@ -1715,6 +1761,7 @@ export class RhoService {
         return this.state.principals.some(p => p.id === id && p.tokenHash === tokenHash && p.methods.includes('observation.snapshot') && (!p.expiresAt || Date.parse(p.expiresAt) > Date.now()));
     }
     async close() {
+        this.extensions.close();
         this.closing = true;
         this.folderPicker.close();
         for (const s of this.subscribers)