@rho-workspace/rho 0.5.3 → 0.5.5

package/dist/conversation-presentation.js

@@ -1,3 +1,4 @@
+import { installText, readInstall } from './installs.js';
 // Only an explicit Agent limit report qualifies; an unknown outcome never does.
 export function agentTurnLimit(turn) {
     return turn.state === 'failed' && (turn.result?.kind === 'error_max_turns' || turn.result?.reason === 'max_turn_requests' || /^(?:Internal error: )?Reached maximum number of turns \(\d+\)\.?$/i.test(turn.problem ?? ''));
@@ -181,6 +182,10 @@ export function toolActivity(step, location, root, key) {
         targetKind = detail || location ? 'path' : 'text';
     }
     else if (action === 'execute') {
+        // A command that installs packages reads as what it installed; its command stays in the details.
+        const installed = detail ? readInstall(detail, step.output?.text) : null;
+        if (installed)
+            return { key: key ?? step.id ?? tool + '-' + step.at, step, action, verb: outcome === 'returned' ? 'Installed' : outcome === 'requested' ? 'Installing' : 'Tried to install', target: installText(installed), targetKind: 'packages', installed, title, location, outcome };
         target = detail ? displayCommand(detail) : (title && title.toLowerCase() !== tool.toLowerCase() ? title : null);
         targetKind = detail ? 'command' : 'text';
     }
@@ -199,17 +204,22 @@ export function toolActivity(step, location, root, key) {
     return { key: key ?? step.id ?? tool + '-' + step.at, step, action, verb, target, targetKind, title, location, outcome };
 }
 // Files are counted once however often the Agent touched them: nine edits of one script
-// are "Edited 1 file". Other actions count each time they happened.
+// are "Edited 1 file". Other actions count each time they happened. Installs are named by
+// their packages, "Installed pandas, statsmodels", and are not counted as commands.
 const onFiles = new Set(['read', 'edit', 'write', 'delete', 'move']);
 export function activitySummary(activities) {
     const seen = new Map();
     activities.forEach((activity, i) => {
-        const file = onFiles.has(activity.action) ? activity.location ?? activity.step.detail ?? activity.target : null;
-        const named = seen.get(activity.action) ?? new Set();
-        named.add(file ?? '#' + i);
-        seen.set(activity.action, named);
+        const group = activity.installed ? activity.verb : activity.action;
+        const file = activity.installed ? activity.installed.packages.map(p => p.name).join('\n') || 'packages from ' + activity.installed.from
+            : onFiles.has(activity.action) ? activity.location ?? activity.step.detail ?? activity.target : null;
+        const named = seen.get(group) ?? new Set();
+        for (const name of activity.installed ? file.split('\n') : [file ?? '#' + i])
+            named.add(name);
+        seen.set(group, named);
     });
-    const parts = [...seen].map(([action, named]) => summaries[action][named.size === 1 ? 0 : 1].replace('{n}', String(named.size)));
+    const listed = (names) => names.length > 3 ? names.slice(0, 3).join(', ') + ` and ${names.length - 3} more` : names.join(', ');
+    const parts = [...seen].map(([group, named]) => group in summaries ? summaries[group][named.size === 1 ? 0 : 1].replace('{n}', String(named.size)) : group + ' ' + listed([...named]));
     const count = (outcome) => activities.filter(a => a.outcome === outcome).length;
     const failed = count('failed'), refused = count('rejected'), unknown = count('unknown');
     if (failed)

package/dist/conversations.d.ts

@@ -41,7 +41,11 @@ interface Permission extends AgentPermission {
 }
 export interface ConversationConfig {
     settingsFile?: string;
-    backend?: 'claude-acp' | 'codex-acp' | 'claude-cli';
+    backend?: 'claude-acp' | 'codex-acp' | 'claude-cli' | 'acp';
+    acpCommand?: {
+        file: string;
+        args: string[];
+    };
     codex?: string;
     codexAcp?: Omit<CodexAcpOptions, 'cwd' | 'mcpServers' | 'limits' | 'sessionId' | 'codex' | 'observation' | 'observe'>;
     claudeAcp?: Omit<ClaudeAcpOptions, 'cwd' | 'mcpServers' | 'limits' | 'sessionId' | 'claude' | 'observation' | 'observe'>;
@@ -125,7 +129,7 @@ interface FileChange {
     modifiedAt: string | null;
     bytes: number | null;
 }
-type Backend = 'claude-acp' | 'codex-acp';
+type Backend = 'claude-acp' | 'codex-acp' | 'acp';
 type Choices = Record<string, string | boolean>;
 interface Offered {
     at: string;
@@ -406,7 +410,7 @@ export declare class Conversations {
     private sessionObservation;
     work(project: Project, limit?: number): Promise<{
         sessions: {
-            backend: "claude-acp" | "codex-acp" | "claude-cli";
+            backend: "acp" | "claude-acp" | "codex-acp" | "claude-cli";
             sessionId: string | null;
             observation: SessionObservation | null;
             state: string;
@@ -574,7 +578,7 @@ export declare class Conversations {
         version: number;
         updatedAt: string | null;
         backend: Backend | null;
-        serviceBackend: "claude-acp" | "codex-acp" | "claude-cli";
+        serviceBackend: "acp" | "claude-acp" | "codex-acp" | "claude-cli";
         choices: Partial<Record<Backend, Choices>>;
         offered: Partial<Record<Backend, Offered>>;
         checking: Backend[];
@@ -593,7 +597,7 @@ export declare class Conversations {
         version: number;
         updatedAt: string | null;
         backend: Backend | null;
-        serviceBackend: "claude-acp" | "codex-acp" | "claude-cli";
+        serviceBackend: "acp" | "claude-acp" | "codex-acp" | "claude-cli";
         choices: Partial<Record<Backend, Choices>>;
         offered: Partial<Record<Backend, Offered>>;
         checking: Backend[];
@@ -607,7 +611,7 @@ export declare class Conversations {
         version: number;
         updatedAt: string | null;
         backend: Backend | null;
-        serviceBackend: "claude-acp" | "codex-acp" | "claude-cli";
+        serviceBackend: "acp" | "claude-acp" | "codex-acp" | "claude-cli";
         choices: Partial<Record<Backend, Choices>>;
         offered: Partial<Record<Backend, Offered>>;
         checking: Backend[];

package/dist/conversations.js

@@ -1,7 +1,7 @@
 import { projectPath, commandFiles, buildWorkGraph } from './work-graph.js';
 import { notesInstructions, projectNotesPath } from './project-notes.js';
 import { addSpend, describeLimits, describable, fileFacts, figureContext, raster } from './file-describer.js';
-import { agentTurnLimit, toolActivity } from './conversation-presentation.js';
+import { agentTurnLimit, displayCommand, toolActivity } from './conversation-presentation.js';
 import { privateEvidencePath } from './evidence-capture.js';
 import * as fs from 'node:fs/promises';
 import path from 'node:path';
@@ -127,7 +127,7 @@ function compare(before, after, limit) {
     changed.sort((a, b) => (a.modifiedAt ?? '\uffff').localeCompare(b.modifiedAt ?? '\uffff') || a.path.localeCompare(b.path));
     return { changed: changed.slice(0, limit), omitted: Math.max(0, changed.length - limit), partial };
 }
-const backends = ['claude-acp', 'codex-acp'];
+const backends = ['claude-acp', 'codex-acp', 'acp'];
 const blankSettings = () => ({ format: 1, version: 0, updatedAt: null, backend: null, choices: {}, offered: {} });
 const acpDriver = (driver) => !!driver && 'configure' in driver;
 const identity = /^c-[a-f0-9]{16}$/;
@@ -196,7 +196,7 @@ export class Conversations {
         this.limits = { ...conversationLimits, ...limits };
         for (const key of ['maxCaptureFiles', 'maxCaptureBytes', 'maxSnapshotBytes', 'maxCaptureConcurrent'])
             requireThat(Number.isSafeInteger(this.limits[key]) && this.limits[key] > 0 && this.limits[key] <= conversationLimits[key], 'invalid', 'Capture budgets must be positive integers no greater than the supported defaults.', { limit: key, maximum: conversationLimits[key] });
-        requireThat(!config.backend || ['claude-acp', 'codex-acp', 'claude-cli'].includes(config.backend), 'invalid', 'Choose claude-acp, codex-acp or claude-cli.');
+        requireThat(!config.backend || ['claude-acp', 'codex-acp', 'claude-cli', 'acp'].includes(config.backend), 'invalid', 'Choose claude-acp, codex-acp, claude-cli or acp.');
     }
     serial(key, run) {
         const task = (this.queues.get(key) ?? Promise.resolve()).catch(() => { }).then(run);
@@ -408,7 +408,7 @@ export class Conversations {
             const saved = await this.readSettings();
             const backend = input.backend ?? saved.backend ?? this.config.backend ?? 'claude-acp';
             const config = backend === 'claude-cli' ? undefined : input.config ?? saved.choices[backend];
-            const at = now(), c = { format: 2, backend, id: 'c-' + randomBytes(8).toString('hex'), changeId: input.changeId, requestDigest, createdAt: at, createdBy: by, updatedAt: at, version: 0, client: backend === 'codex-acp' ? 'codex' : 'claude-code', nativeSessionId: backend === 'claude-cli' ? randomUUID() : null, confirmed: false, principal: null, title: titleOf(text), turns: [], ...(config && Object.keys(config).length ? { config } : {}) };
+            const at = now(), c = { format: 2, backend, id: 'c-' + randomBytes(8).toString('hex'), changeId: input.changeId, requestDigest, createdAt: at, createdBy: by, updatedAt: at, version: 0, client: backend === 'codex-acp' ? 'codex' : backend === 'acp' ? 'acp' : 'claude-code', nativeSessionId: backend === 'claude-cli' ? randomUUID() : null, confirmed: false, principal: null, title: titleOf(text), turns: [], ...(config && Object.keys(config).length ? { config } : {}) };
             for (const id of input.contexts ?? [])
                 await this.ports.context?.(project, id);
             const turn = this.turn(input.changeId, requestDigest, by, text, 1);
@@ -468,7 +468,7 @@ export class Conversations {
         this.choices({ [input.configId]: input.value });
         return this.serial(project.id, async () => {
             const c = await this.load(project, input.conversationId), last = c.turns.at(-1);
-            requireThat(c.backend === 'claude-acp' || c.backend === 'codex-acp', 'unavailable', 'This conversation\'s Agent has no settings Rho can change.');
+            requireThat(c.backend === 'claude-acp' || c.backend === 'codex-acp' || c.backend === 'acp', 'unavailable', 'This conversation\'s Agent has no settings Rho can change.');
             requireThat(!c.trashedAt, 'conflict', 'This conversation is in the trash. Restore it to change its settings.');
             requireThat(!last || last.state !== 'running' || !this.liveTurn(project, c, last), 'conflict', 'The Agent is answering. Change its settings after this message.');
             const driver = this.drivers.get(project.id + '/' + c.id)?.driver;
@@ -558,9 +558,9 @@ export class Conversations {
         return this.settings();
     }
     async inspect(project, backend) {
-        const { ClaudeAcpConversation, CodexAcpConversation } = await import('@rho-workspace/plugin-agent/conversation');
+        const { ClaudeAcpConversation, CodexAcpConversation, GenericAcpConversation } = await import('@rho-workspace/plugin-agent/conversation');
         const common = { cwd: project.root, mcpServers: [], limits: this.limits };
-        const driver = backend === 'codex-acp' ? new CodexAcpConversation({ ...this.config.codexAcp, ...common, codex: this.config.codex }) : new ClaudeAcpConversation({ preferred: claudePreferred, ...this.config.claudeAcp, ...common, claude: this.binary });
+        const driver = backend === 'codex-acp' ? new CodexAcpConversation({ ...this.config.codexAcp, ...common, codex: this.config.codex }) : backend === 'acp' ? new GenericAcpConversation({ ...common, command: this.config.acpCommand }) : new ClaudeAcpConversation({ preferred: claudePreferred, ...this.config.claudeAcp, ...common, claude: this.binary });
         let found;
         try {
             found = await driver.inspect();
@@ -750,11 +750,11 @@ export class Conversations {
             const grant = await this.ports.grant(project, c);
             c.principal = grant.principal;
             const mcpServers = [{ name: 'rho', command: process.execPath, args: [fileURLToPath(import.meta.resolve('@rho-workspace/plugin-agent/mcp'))], env: [{ name: 'RHO_AGENT_CONNECTION', value: grant.file }] }];
-            const { ClaudeAcpConversation, CodexAcpConversation, ClaudeCliConversation } = await import('@rho-workspace/plugin-agent/conversation');
+            const { ClaudeAcpConversation, CodexAcpConversation, ClaudeCliConversation, GenericAcpConversation } = await import('@rho-workspace/plugin-agent/conversation');
             const observed = { observation: c.observation, observe: (observation) => {
                     requireThat(observation.sessionId === c.acpSessionId, 'conflict', 'The observed Agent session differs from the retained identity.');
                     requireThat(Buffer.byteLength(JSON.stringify(observation)) <= this.limits.maxObservationBytes, 'limit', 'The session projection exceeded maxObservationBytes; prior observations were kept.');
-                    const config = observation.config, learned = config && config.at !== c.observation?.config?.at && config.origin === 'initial' && !c.config && (c.backend === 'claude-acp' || c.backend === 'codex-acp');
+                    const config = observation.config, learned = config && config.at !== c.observation?.config?.at && config.origin === 'initial' && !c.config && (c.backend === 'claude-acp' || c.backend === 'codex-acp' || c.backend === 'acp');
                     c.observation = observation;
                     this.schedule(project, c);
                     for (const live of this.live.values())
@@ -775,7 +775,9 @@ export class Conversations {
                 ? new CodexAcpConversation({ ...this.config.codexAcp, ...common, codex: this.config.codex })
                 : c.backend === 'claude-acp'
                     ? new ClaudeAcpConversation({ preferred: claudePreferred, ...this.config.claudeAcp, ...common, claude: this.binary, plugins: [...this.config.claudeAcp?.plugins ?? [], ...await this.ports.claudePlugins?.(project) ?? []] })
-                    : new ClaudeCliConversation({ cwd: project.root, binary: this.binary, sessionId: c.nativeSessionId, confirmed: c.confirmed, projectName: project.name ?? path.basename(project.root), mcpServers, limits: this.limits, instructions });
+                    : c.backend === 'acp'
+                        ? new GenericAcpConversation({ ...common, command: this.config.acpCommand })
+                        : new ClaudeCliConversation({ cwd: project.root, binary: this.binary, sessionId: c.nativeSessionId, confirmed: c.confirmed, projectName: project.name ?? path.basename(project.root), mcpServers, limits: this.limits, instructions });
             this.drivers.set(key, { driver, project, conversation: c });
             return driver;
         });
@@ -895,8 +897,9 @@ export class Conversations {
                 const action = toolActivity(incoming, null, project.root);
                 if (action.targetKind === 'path' && (action.location || incoming.detail))
                     this.capture(live, action.location ?? incoming.detail, 'step:' + incoming.id + ':' + incoming.outcome);
-                if (action.targetKind === 'command' && action.target)
-                    for (const file of commandFiles(action.target, project))
+                // A command's files are captured however its row reads (an install names its packages).
+                if (action.action === 'execute' && incoming.detail)
+                    for (const file of commandFiles(displayCommand(incoming.detail), project))
                         this.capture(live, file, 'command:' + incoming.id + ':' + incoming.outcome);
             }
             if (!kept)
@@ -1068,7 +1071,8 @@ export class Conversations {
         const given = shown.get(file);
         const reason = !enabled ? 'Descriptions by a model are switched off; the facts are kept.'
             : c.backend === 'codex-acp' ? 'Descriptions are written with Claude Code; this session\'s Agent is Codex.'
-                : !this.ports.describe ? 'No model is set up to describe files.' : null;
+                : c.backend === 'acp' ? 'Descriptions are written with Claude Code; this session\'s Agent is a configured ACP agent.'
+                    : !this.ports.describe ? 'No model is set up to describe files.' : null;
         const keep = (why) => { if (record.reason !== why) {
             record.state = record.sentence ? 'described' : 'facts';
             record.reason = why;

package/dist/discovery.d.ts

@@ -1,5 +1,6 @@
 import type { Principal, Project } from './state.js';
 import type { Plugins } from './plugins.js';
+export declare const applicationEffects: Record<string, string>;
 export declare class Discovery {
     plugins: Plugins;
     project: Project;

package/dist/discovery.js

@@ -3,11 +3,11 @@ import { Capabilities, rhoWorkspaceSkill } from './capabilities.js';
 import { protocol } from './protocol.js';
 import { schemaClosure } from './protocol-discovery.js';
 const size = (v) => Buffer.byteLength(JSON.stringify(v)) + 64;
-const applicationEffects = Object.fromEntries([
-    ...['protocol.describe', 'protocol.validate', 'project.entries', 'capability.list', 'skill.list', 'skill.read', 'action.lookup', 'action.observe', 'action.output', 'action.list', 'composition.read', 'observation.snapshot', 'interaction.selection.read', 'workspace.observe', 'task.map.read'].map(m => [m, 'read']),
+export const applicationEffects = Object.fromEntries([
+    ...['extension.list', 'extension.describe', 'extension.content', 'extension.read', 'protocol.describe', 'protocol.validate', 'project.entries', 'capability.list', 'skill.list', 'skill.read', 'action.lookup', 'action.observe', 'action.output', 'action.list', 'composition.read', 'observation.snapshot', 'interaction.selection.read', 'workspace.observe', 'task.map.read'].map(m => [m, 'read']),
     ...['composition.put', 'view.close', 'capability.configure', 'composition.apply', 'composition.undo', 'view.protection.set', 'interaction.selection.set', 'selection.set', 'workspace.enhance', 'task.map.declare', 'task.map.present', 'task.map.respond'].map(m => [m, 'metadata']),
     ...['workspace.save', 'workspace.export', 'workspace.restore', 'action.export'].map(m => [m, 'file']),
-    ...['action.retry', 'action.cancel'].map(m => [m, 'native']),
+    ...['extension.call', 'extension.install', 'extension.manage', 'action.retry', 'action.cancel'].map(m => [m, 'native']),
 ]);
 const rhoSummary = 'The project in Rho: its folder\'s entries, managed runs, the views on the person\'s screen and what is selected in them, the task map, and which plugins are on.';
 const metadata = new Set(['capability.index', 'capability.resolve', 'binding.activity.append', 'task.routing.put', 'feedback.submit', 'view.observe', 'view.observations.read']);

package/dist/extension-contract.d.ts

@@ -0,0 +1,99 @@
+export declare const extensionOperations: {
+    'extension.list': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.describe': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.content': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.call': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.read': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.install': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.manage': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+export declare const extensionResponses: {
+    'extension.list': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.describe': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.install': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.content': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.call': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.read': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+    'extension.manage': {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+export declare const extensionDescriptions: {
+    'extension.list': string;
+    'extension.describe': string;
+    'extension.content': string;
+    'extension.call': string;
+    'extension.read': string;
+    'extension.install': string;
+    'extension.manage': string;
+};
+export declare const extensionManagement: string[];
+export declare const extensionMethods: string[];

package/dist/extension-contract.js

@@ -0,0 +1,52 @@
+// Installed third-party packages are application assembly, independent of the
+// functional owners compiled into Rho. This protocol never imports their code.
+const str = { type: 'string', minLength: 1, maxLength: 1024 };
+const id = { type: 'string', pattern: '^[a-z0-9][a-z0-9._-]{0,95}$' };
+const sha = { type: 'string', pattern: '^[a-f0-9]{64}$' };
+const object = (properties, required = Object.keys(properties)) => ({ type: 'object', properties, required, additionalProperties: false });
+const json = { type: 'object', additionalProperties: true };
+const project = { projectId: str };
+const selected = { ...project, pluginId: id, expectedDigest: sha };
+export const extensionOperations = {
+    'extension.list': object(project, []),
+    'extension.describe': object({ ...project, pluginId: id }),
+    'extension.content': object({ ...selected, kind: { enum: ['skill', 'view'] }, entryId: id }),
+    'extension.call': object({ ...selected, operation: id, input: json, changeId: { type: 'string', pattern: '^[A-Za-z0-9._:@-]{1,128}$' } }),
+    'extension.read': object({ ...project, invocationId: sha }),
+    'extension.install': object({ source: str, replace: id, expectedDigest: sha }, ['source']),
+    'extension.manage': object({ pluginId: id, expectedDigest: sha, action: { enum: ['enable', 'disable', 'remove'] } }),
+};
+const array = (items) => ({ type: 'array', items });
+const text = { type: 'string' };
+const entry = { ...object({ id, title: text, file: text }), additionalProperties: true };
+const manifest = { ...object({ apiVersion: { const: 1 }, id, title: text, description: text, host: text,
+        operations: array({ ...object({ id, title: text, description: text, effect: { enum: ['read', 'native'] }, methods: array(text), inputSchema: json }), additionalProperties: true }),
+        skills: array(entry), views: array(entry),
+    }, ['apiVersion', 'id', 'title', 'description', 'operations', 'skills', 'views']), additionalProperties: true };
+const installed = { id, name: text, version: text, title: text, description: text, digest: sha, source: text, sourceCommit: text, enabled: { type: 'boolean' }, installedAt: text };
+const installedRequired = Object.keys(installed).filter(key => key !== 'sourceCommit');
+const descriptor = object({ ...installed, manifest }, [...installedRequired, 'manifest']);
+const receipt = object({ invocationId: sha, caller: text, projectId: text, pluginId: id, packageDigest: sha, operation: id, requestDigest: sha,
+    state: { enum: ['pending', 'completed', 'unknown'] }, startedAt: text, endedAt: text, value: {}, error: text,
+    delegations: array(object({ method: text, request: {}, state: { enum: ['pending', 'completed', 'unknown'] }, value: {}, error: text }, ['method', 'request', 'state'])),
+}, ['invocationId', 'caller', 'projectId', 'pluginId', 'packageDigest', 'operation', 'requestDigest', 'state', 'startedAt']);
+export const extensionResponses = {
+    'extension.list': object({ plugins: array(object(installed, installedRequired)), directory: array(object({ id, title: text, version: text, description: text, source: text, repository: text, needs: text })), limits: json }),
+    'extension.describe': descriptor,
+    'extension.install': descriptor,
+    'extension.content': object({ pluginId: id, packageDigest: sha, entryId: id, kind: { enum: ['skill', 'view'] }, title: text, text }),
+    'extension.call': receipt,
+    'extension.read': receipt,
+    'extension.manage': object({ pluginId: id, action: { enum: ['enable', 'disable', 'remove'] }, retained: text }),
+};
+export const extensionDescriptions = {
+    'extension.list': 'List independently installed third-party packages and their enabled state, source and immutable digest. Reads start no plugin or runtime. Use extension.describe to discover operation schemas and Skills.',
+    'extension.describe': 'Read an installed third-party package manifest, operation input schemas, required Rho methods, Skills and views. Read its Skill with extension.content before use. Disabled packages cannot run.',
+    'extension.content': 'Read one installed plugin Skill or standalone HTML view at its selected package digest. Reading starts no plugin or runtime.',
+    'extension.call': 'Call an enabled third-party operation at the described package digest, under the caller and project. The package runs trusted native code. Non-read calls retain the original changeId: repeat observes that invocation, including unknown outcomes, without re-execution. Completion is not scientific validity.',
+    'extension.read': 'Observe an original plugin invocation, including pending or unknown outcomes. Never reruns code. Only its original caller can read it.',
+    'extension.install': 'Local person/operator: install a trusted prebuilt npm package, local folder, tarball, or Git source. Lifecycle scripts are disabled. Replacement stages and checks the new package before switching; use replace and expectedDigest for updates.',
+    'extension.manage': 'Local person/operator: enable, disable or remove an installed third-party package at the expected digest. Existing native tasks, R sessions, project files and retained receipts are preserved.',
+};
+export const extensionManagement = ['extension.install', 'extension.manage'];
+export const extensionMethods = Object.keys(extensionOperations);

package/dist/extension-directory.d.ts

@@ -0,0 +1,9 @@
+export declare const extensionDirectory: {
+    id: string;
+    title: string;
+    version: string;
+    description: string;
+    source: string;
+    repository: string;
+    needs: string;
+}[];

package/dist/extension-directory.js

@@ -0,0 +1,11 @@
+// Optional discovery, not a registration requirement. Packages keep their own
+// repositories/releases; an entry records the source a maintainer actually checked.
+export const extensionDirectory = [
+    {
+        id: 'yulab.sclet', title: 'sclet', version: '0.1.0',
+        description: 'State-aware single-cell analysis using sclet in your shared R Notebook.',
+        source: 'git+https://github.com/YuLab-SMU/Rho-plugins.git#82df99f8cbab868c30949692172c6cf11db2f5c0:examples/sclet-plugin',
+        repository: 'https://github.com/YuLab-SMU/Rho-plugins/tree/82df99f8cbab868c30949692172c6cf11db2f5c0/examples/sclet-plugin',
+        needs: 'R, sclet, SingleCellExperiment and jsonlite in the selected R environment.',
+    },
+];

package/dist/extension-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/extension-worker.js

@@ -0,0 +1,36 @@
+// A process boundary for crashes/timeouts, NOT an OS sandbox. An installed host
+// has this user's native permissions. Never send it service credentials.
+import { pathToFileURL } from 'node:url';
+const pending = new Map();
+let next = 0;
+process.on('message', async (message) => {
+    if (message.type === 'reply') {
+        const waiter = pending.get(message.id);
+        pending.delete(message.id);
+        if (message.error)
+            waiter?.reject(new Error(message.error));
+        else
+            waiter?.resolve(message.value);
+    }
+    if (message.type !== 'start')
+        return;
+    try {
+        const plugin = await import(pathToFileURL(message.entry).href);
+        if (typeof plugin.run !== 'function')
+            throw new Error('The plugin host must export run(operation, input, context).');
+        const value = await plugin.run(message.operation, message.input, {
+            projectRoot: message.projectRoot,
+            invocationId: message.invocationId,
+            changeId: (label) => 'ext:' + message.invocationId + ':' + String(label).slice(0, 40),
+            call: (method, body) => new Promise((resolve, reject) => {
+                const id = ++next;
+                pending.set(id, { resolve, reject });
+                process.send?.({ type: 'call', id, method, body });
+            }),
+        });
+        process.send?.({ type: 'result', value }, () => process.exit(0));
+    }
+    catch (error) {
+        process.send?.({ type: 'error', error: error instanceof Error ? error.message : String(error) }, () => process.exit(1));
+    }
+});

package/dist/extensions.d.ts

@@ -0,0 +1,157 @@
+export declare const extensionLimits: {
+    maxPlugins: number;
+    maxVersions: number;
+    maxFiles: number;
+    maxPackageBytes: number;
+    maxContentBytes: number;
+    maxReceipts: number;
+    maxResultBytes: number;
+    maxRunning: number;
+    maxDelegations: number;
+    timeoutMs: number;
+    installTimeoutMs: number;
+};
+export interface ExtensionManifest {
+    apiVersion: 1;
+    id: string;
+    title: string;
+    description: string;
+    host?: string;
+    operations: {
+        id: string;
+        title: string;
+        description: string;
+        effect: 'read' | 'native';
+        methods: string[];
+        inputSchema: Record<string, any>;
+    }[];
+    skills: {
+        id: string;
+        title: string;
+        file: string;
+    }[];
+    views: {
+        id: string;
+        title: string;
+        file: string;
+    }[];
+}
+export interface InstalledExtension {
+    id: string;
+    name: string;
+    version: string;
+    title: string;
+    description: string;
+    digest: string;
+    source: string;
+    sourceCommit?: string;
+    enabled: boolean;
+    installedAt: string;
+    manifest: ExtensionManifest;
+}
+interface Receipt {
+    invocationId: string;
+    caller: string;
+    projectId: string;
+    pluginId: string;
+    packageDigest: string;
+    operation: string;
+    requestDigest: string;
+    state: 'pending' | 'completed' | 'unknown';
+    startedAt: string;
+    endedAt?: string;
+    value?: unknown;
+    error?: string;
+    delegations?: {
+        method: string;
+        request: unknown;
+        state: 'pending' | 'completed' | 'unknown';
+        value?: unknown;
+        error?: string;
+    }[];
+}
+export declare class Extensions {
+    readonly directory: string;
+    readonly limits: typeof extensionLimits;
+    private installed;
+    private running;
+    private workers;
+    private receiptCount;
+    private mutation;
+    constructor(directory: string, limits?: Partial<typeof extensionLimits>);
+    init(): Promise<void>;
+    close(): void;
+    private serial;
+    list(): {
+        directory: {
+            id: string;
+            title: string;
+            version: string;
+            description: string;
+            source: string;
+            repository: string;
+            needs: string;
+        }[];
+        plugins: {
+            id: string;
+            name: string;
+            version: string;
+            title: string;
+            description: string;
+            digest: string;
+            source: string;
+            sourceCommit?: string;
+            enabled: boolean;
+            installedAt: string;
+        }[];
+        limits: {
+            maxPlugins: number;
+            maxVersions: number;
+            maxFiles: number;
+            maxPackageBytes: number;
+            maxContentBytes: number;
+            maxReceipts: number;
+            maxResultBytes: number;
+            maxRunning: number;
+            maxDelegations: number;
+            timeoutMs: number;
+            installTimeoutMs: number;
+        };
+    };
+    describe(id: string): InstalledExtension;
+    private selected;
+    private root;
+    private file;
+    private hash;
+    check(root: string): Promise<{
+        name: string;
+        version: string;
+        manifest: ExtensionManifest;
+    }>;
+    private verify;
+    content(id: string, expected: string, kind: 'skill' | 'view', entryId: string): Promise<{
+        pluginId: string;
+        packageDigest: string;
+        entryId: string;
+        kind: "skill" | "view";
+        title: string;
+        text: string;
+    }>;
+    install(source: string, replace?: string, expected?: string): Promise<InstalledExtension>;
+    manage(id: string, expected: string, action: 'enable' | 'disable' | 'remove'): Promise<{
+        pluginId: string;
+        action: "remove" | "enable" | "disable";
+        retained: string;
+    }>;
+    read(invocationId: string, caller: string, projectId: string): Promise<Receipt>;
+    call(b: {
+        pluginId: string;
+        expectedDigest: string;
+        operation: string;
+        input: any;
+        changeId: string;
+        projectId: string;
+    }, caller: string, projectRoot: string, dispatch: (method: string, body: any, effect: 'read' | 'native') => Promise<unknown>): Promise<Receipt>;
+    private execute;
+}
+export {};