@rho-workspace/rho 0.5.4 → 0.5.6

package/dist/conversations.d.ts

@@ -165,6 +165,22 @@ export interface ConversationPorts {
         listed: string;
     } | null>;
     notebook?(): boolean;
+    nativeSession?(project: Project, producer: 'claude-code' | 'codex', sessionId: string): Promise<{
+        open: {
+            where: string;
+            since?: string;
+            pid?: number;
+        } | null;
+        lastAt: string;
+    } | null>;
+}
+export interface ContinueSession {
+    producer: 'claude-code' | 'codex' | 'dsh';
+    sessionId: string;
+    title: string;
+    where: string;
+    copy: boolean;
+    backend: 'claude-acp' | 'codex-acp' | 'acp';
 }
 export interface DescribeRequest {
     path: string;
@@ -256,6 +272,11 @@ export declare class Conversations {
         costUsd?: number | null;
         sessionId?: string | null;
         trashedAt?: string | null;
+        origin?: {
+            producer: string;
+            where: string;
+            copyOf?: string;
+        } | null;
     }[]>;
     private relist;
     reviewEvidence(project: Project, annotationId: string): Promise<{
@@ -319,6 +340,11 @@ export declare class Conversations {
             costUsd?: number | null;
             sessionId?: string | null;
             trashedAt?: string | null;
+            origin?: {
+                producer: string;
+                where: string;
+                copyOf?: string;
+            } | null;
         };
     }>;
     restore(project: Project, input: {
@@ -356,6 +382,11 @@ export declare class Conversations {
             costUsd?: number | null;
             sessionId?: string | null;
             trashedAt?: string | null;
+            origin?: {
+                producer: string;
+                where: string;
+                copyOf?: string;
+            } | null;
         };
     }>;
     delete(project: Project, by: string, input: {
@@ -401,6 +432,11 @@ export declare class Conversations {
             costUsd?: number | null;
             sessionId?: string | null;
             trashedAt?: string | null;
+            origin?: {
+                producer: string;
+                where: string;
+                copyOf?: string;
+            } | null;
         };
         observation: SessionObservation | null;
         config: Choices;
@@ -410,7 +446,7 @@ export declare class Conversations {
     private sessionObservation;
     work(project: Project, limit?: number): Promise<{
         sessions: {
-            backend: "acp" | "claude-acp" | "codex-acp" | "claude-cli";
+            backend: "claude-acp" | "codex-acp" | "acp" | "claude-cli";
             sessionId: string | null;
             observation: SessionObservation | null;
             state: string;
@@ -442,6 +478,11 @@ export declare class Conversations {
             } | null;
             costUsd?: number | null;
             trashedAt?: string | null;
+            origin?: {
+                producer: string;
+                where: string;
+                copyOf?: string;
+            } | null;
         }[];
         omitted: number;
     }>;
@@ -451,6 +492,7 @@ export declare class Conversations {
         contexts?: string[];
         backend?: Backend;
         config?: Choices;
+        continue?: ContinueSession;
     }): Promise<{
         conversation: {
             state: string;
@@ -484,9 +526,18 @@ export declare class Conversations {
             costUsd?: number | null;
             sessionId?: string | null;
             trashedAt?: string | null;
+            origin?: {
+                producer: string;
+                where: string;
+                copyOf?: string;
+            } | null;
         };
         turn: Turn;
     }>;
+    /** Whether a process holding a session open is Rho's own connection to this conversation: the
+     * Agent its adapter started. */
+    owns(project: Project, conversationId: string, pid: number | undefined): Promise<boolean>;
+    private notHeld;
     send(project: Project, by: string, input: {
         conversationId: string;
         changeId: string;
@@ -526,6 +577,11 @@ export declare class Conversations {
             costUsd?: number | null;
             sessionId?: string | null;
             trashedAt?: string | null;
+            origin?: {
+                producer: string;
+                where: string;
+                copyOf?: string;
+            } | null;
         };
         turn: Turn;
     }>;
@@ -566,6 +622,11 @@ export declare class Conversations {
             costUsd?: number | null;
             sessionId?: string | null;
             trashedAt?: string | null;
+            origin?: {
+                producer: string;
+                where: string;
+                copyOf?: string;
+            } | null;
         };
         observation: SessionObservation | null;
         config: Choices;
@@ -574,17 +635,43 @@ export declare class Conversations {
     private offers;
     private readSettings;
     private settingsView;
+    private agents;
     settings(): Promise<{
         version: number;
         updatedAt: string | null;
         backend: Backend | null;
-        serviceBackend: "acp" | "claude-acp" | "codex-acp" | "claude-cli";
+        serviceBackend: "claude-acp" | "codex-acp" | "acp" | "claude-cli";
         choices: Partial<Record<Backend, Choices>>;
         offered: Partial<Record<Backend, Offered>>;
         checking: Backend[];
         describe: {
             enabled: boolean;
         };
+        agents: {
+            'claude-acp': {
+                found: boolean;
+                problem: string;
+            } | {
+                found: boolean;
+                problem?: undefined;
+            };
+            'codex-acp': {
+                found: boolean;
+                problem: string;
+            } | {
+                found: boolean;
+                problem?: undefined;
+            };
+            acp: {
+                found: boolean;
+                name: string | null;
+                problem?: undefined;
+            } | {
+                found: boolean;
+                problem: string;
+                name?: undefined;
+            };
+        };
     }>;
     updateSettings(input: {
         expectedVersion: number;
@@ -597,13 +684,38 @@ export declare class Conversations {
         version: number;
         updatedAt: string | null;
         backend: Backend | null;
-        serviceBackend: "acp" | "claude-acp" | "codex-acp" | "claude-cli";
+        serviceBackend: "claude-acp" | "codex-acp" | "acp" | "claude-cli";
         choices: Partial<Record<Backend, Choices>>;
         offered: Partial<Record<Backend, Offered>>;
         checking: Backend[];
         describe: {
             enabled: boolean;
         };
+        agents: {
+            'claude-acp': {
+                found: boolean;
+                problem: string;
+            } | {
+                found: boolean;
+                problem?: undefined;
+            };
+            'codex-acp': {
+                found: boolean;
+                problem: string;
+            } | {
+                found: boolean;
+                problem?: undefined;
+            };
+            acp: {
+                found: boolean;
+                name: string | null;
+                problem?: undefined;
+            } | {
+                found: boolean;
+                problem: string;
+                name?: undefined;
+            };
+        };
     }>;
     check(project: Project, input: {
         backend: Backend;
@@ -611,13 +723,38 @@ export declare class Conversations {
         version: number;
         updatedAt: string | null;
         backend: Backend | null;
-        serviceBackend: "acp" | "claude-acp" | "codex-acp" | "claude-cli";
+        serviceBackend: "claude-acp" | "codex-acp" | "acp" | "claude-cli";
         choices: Partial<Record<Backend, Choices>>;
         offered: Partial<Record<Backend, Offered>>;
         checking: Backend[];
         describe: {
             enabled: boolean;
         };
+        agents: {
+            'claude-acp': {
+                found: boolean;
+                problem: string;
+            } | {
+                found: boolean;
+                problem?: undefined;
+            };
+            'codex-acp': {
+                found: boolean;
+                problem: string;
+            } | {
+                found: boolean;
+                problem?: undefined;
+            };
+            acp: {
+                found: boolean;
+                name: string | null;
+                problem?: undefined;
+            } | {
+                found: boolean;
+                problem: string;
+                name?: undefined;
+            };
+        };
     }>;
     private inspect;
     private offer;
@@ -657,6 +794,11 @@ export declare class Conversations {
             costUsd?: number | null;
             sessionId?: string | null;
             trashedAt?: string | null;
+            origin?: {
+                producer: string;
+                where: string;
+                copyOf?: string;
+            } | null;
         };
         turn: Turn;
     }>;
@@ -699,6 +841,11 @@ export declare class Conversations {
             costUsd?: number | null;
             sessionId?: string | null;
             trashedAt?: string | null;
+            origin?: {
+                producer: string;
+                where: string;
+                copyOf?: string;
+            } | null;
         };
         turn: Turn;
     }>;
@@ -740,6 +887,11 @@ export declare class Conversations {
             costUsd?: number | null;
             sessionId?: string | null;
             trashedAt?: string | null;
+            origin?: {
+                producer: string;
+                where: string;
+                copyOf?: string;
+            } | null;
         };
         turn: Turn;
     }>;
@@ -747,6 +899,7 @@ export declare class Conversations {
     private retire;
     private cancelPermissions;
     private launch;
+    private changedElsewhere;
     private driver;
     private capture;
     private observe;

package/dist/conversations.js

@@ -8,6 +8,7 @@ import path from 'node:path';
 import { createHash, randomBytes, randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { atomicJson, canonical, digest, Fault, now, readJson, requireThat } from '@rho-workspace/plugin-contracts';
+import { acpEnvironment, missingClient } from '@rho-workspace/plugin-agent/acp-command';
 // Rho holds user messages and their original identities. The selected Agent plugin
 // owns the connection, native session and protocol. Reads never start a driver.
 // A new Claude Code session opens in Manual mode unless the person's Claude settings name another.
@@ -234,7 +235,8 @@ export class Conversations {
         return { conversationId: c.id, changeId: c.changeId, requestDigest: c.requestDigest, title: c.title, client: c.client, principal: c.principal, createdAt: c.createdAt, updatedAt: c.updatedAt, version: c.version, turns: c.turns.length, state: last?.state ?? 'idle', lastAt: last?.endedAt ?? last?.sentAt ?? c.createdAt,
             listed: 2, turnLimit: !!last && agentTurnLimit(last), waitingPermission: last?.state === 'running' && !!last.permissions?.some(p => p.state === 'pending'), backend: c.backend ?? 'claude-cli', agentTitle: c.observation?.info?.title ?? null, adapter: c.adapter ?? null, model: [...c.turns].reverse().find(t => t.model)?.model ?? null, config: c.config ?? {},
             usage: usage ? { used: usage.used, size: usage.size, cost: usage.cost ?? null } : null, costUsd: costs.length ? costs.reduce((a, b) => a + b, 0) : null,
-            sessionId: c.acpSessionId ?? c.nativeSessionId ?? null, trashedAt: c.trashedAt ?? null };
+            sessionId: c.acpSessionId ?? c.nativeSessionId ?? null, trashedAt: c.trashedAt ?? null,
+            origin: c.origin ? { producer: c.origin.producer, where: c.origin.where, ...(c.origin.copy ? { copyOf: c.origin.sessionId } : {}) } : null };
     }
     async write(project, c) {
         const directory = await this.folder(project);
@@ -394,7 +396,9 @@ export class Conversations {
         requireThat(!input.backend || backends.includes(input.backend), 'invalid', 'Choose Claude Code or Codex.');
         if (input.config)
             this.choices(input.config);
-        const text = this.message(input.text), requestDigest = digest(canonical({ text, ...(input.contexts?.length ? { contexts: input.contexts } : {}), ...(input.backend ? { backend: input.backend } : {}), ...(input.config ? { config: input.config } : {}) }));
+        const from = input.continue;
+        const text = this.message(input.text), requestDigest = digest(canonical({ text, ...(input.contexts?.length ? { contexts: input.contexts } : {}), ...(input.backend ? { backend: input.backend } : {}), ...(input.config ? { config: input.config } : {}),
+            ...(from ? { continue: { producer: from.producer, sessionId: from.sessionId, copy: from.copy } } : {}) }));
         return this.serial(project.id, async () => {
             const index = await this.index(project), existing = index.conversations.find(x => x.changeId === input.changeId);
             requireThat(!index.deleted?.some(x => x.changeId === input.changeId), 'conflict', 'That request started a conversation that was later deleted. It is not started again.');
@@ -404,13 +408,26 @@ export class Conversations {
                 return this.reply(project, c, c.turns[0]);
             }
             requireThat(index.conversations.filter(x => !x.trashedAt).length < this.limits.maxConversations, 'limit', `This project keeps at most ${this.limits.maxConversations} conversations started in Rho. Move one to the trash to start another.`, { limit: 'maxConversations', maximum: this.limits.maxConversations });
+            if (from && !from.copy) {
+                const already = index.conversations.find(x => x.sessionId === from.sessionId);
+                requireThat(!already, 'conflict', already?.trashedAt ? 'This session is a conversation in the trash. Restore it to continue.' : 'This session already continues as a conversation here. Open it to send your message.');
+                await this.notHeld(project, from.producer, from.sessionId, false);
+            }
             this.capacity();
             const saved = await this.readSettings();
-            const backend = input.backend ?? saved.backend ?? this.config.backend ?? 'claude-acp';
+            const backend = from?.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' : 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);
+            if (from) {
+                c.origin = { producer: from.producer, sessionId: from.sessionId, where: from.where, copy: from.copy };
+                if (from.copy)
+                    c.forkFrom = from.sessionId;
+                else
+                    c.acpSessionId = from.sessionId;
+                c.title = from.title;
+            }
             const turn = this.turn(input.changeId, requestDigest, by, text, 1);
             if (input.contexts?.length)
                 turn.contexts = [...input.contexts];
@@ -421,6 +438,29 @@ export class Conversations {
             return this.reply(project, c, turn);
         });
     }
+    /** Whether a process holding a session open is Rho's own connection to this conversation: the
+     * Agent its adapter started. */
+    async owns(project, conversationId, pid) {
+        const adapter = this.drivers.get(project.id + '/' + conversationId)?.driver?.pid;
+        if (!adapter || !pid || process.platform === 'win32')
+            return false;
+        const { execFile } = await import('node:child_process');
+        let current = pid;
+        for (let depth = 0; depth < 4 && current > 1; depth++) {
+            const parent = await new Promise(resolve => execFile('ps', ['-o', 'ppid=', '-p', String(current)], { timeout: 2000 }, (error, out) => resolve(error ? 0 : Number(String(out).trim()))));
+            if (parent === adapter)
+                return true;
+            current = parent;
+        }
+        return false;
+    }
+    async notHeld(project, producer, sessionId, existing, conversationId) {
+        if (producer !== 'claude-code' && producer !== 'codex')
+            return;
+        const found = await this.ports.nativeSession?.(project, producer, sessionId) ?? null;
+        const holder = found?.open && !(conversationId && await this.owns(project, conversationId, found.open.pid)) ? found.open : null;
+        requireThat(!holder, 'condition', `This session is open in ${holder?.where ?? 'another window'}. Close it there to continue here${existing ? '' : ', or continue a copy'}. Nothing was sent.`, { heldBy: holder?.where ?? null });
+    }
     async send(project, by, input) {
         const text = this.message(input.text), requestDigest = digest(canonical({ text, ...(input.contexts?.length ? { contexts: input.contexts } : {}), ...(input.continuationOf ? { continuationOf: input.continuationOf } : {}) }));
         return this.serial(project.id, async () => {
@@ -444,6 +484,9 @@ export class Conversations {
                 requireThat(!alive, 'conflict', `The Agent from before Rho restarted may still be answering (process ${last.pid}). End that process before sending another message.`);
             }
             requireThat(c.turns.length < this.limits.maxTurns, 'limit', `A conversation keeps at most ${this.limits.maxTurns} messages. Start a new conversation.`, { limit: 'maxTurns', maximum: this.limits.maxTurns });
+            // A session continued in a terminal or another app may be open there now.
+            if (c.acpSessionId && (c.client === 'claude-code' || c.client === 'codex'))
+                await this.notHeld(project, c.client, c.acpSessionId, true, c.id);
             requireThat(Buffer.byteLength(JSON.stringify({ ...c, observation: undefined })) + this.limits.maxObservationBytes + this.limits.maxTurnBytes + this.limits.maxMessageBytes <= this.limits.maxRecordBytes, 'limit', 'This conversation has reached the size Rho keeps. Start a new conversation.', { limit: 'maxRecordBytes', maximum: this.limits.maxRecordBytes });
             this.capacity();
             for (const old of c.turns)
@@ -510,7 +553,19 @@ export class Conversations {
     }
     settingsView(s) {
         const service = this.config.backend ?? 'claude-acp';
-        return { version: s.version, updatedAt: s.updatedAt, backend: s.backend, serviceBackend: service, choices: s.choices, offered: s.offered, checking: [...this.checks.keys()], describe: { enabled: s.describe?.enabled !== false } };
+        return { version: s.version, updatedAt: s.updatedAt, backend: s.backend, serviceBackend: service, choices: s.choices, offered: s.offered, checking: [...this.checks.keys()], describe: { enabled: s.describe?.enabled !== false }, agents: this.agents() };
+    }
+    // Which Agents this service can start: the person's installed clients, found as the adapters
+    // find them, and an ACP command the person named. Looking starts nothing.
+    agents() {
+        const found = (problem) => problem ? { found: false, problem } : { found: true };
+        const command = this.config.acpCommand;
+        return {
+            // A command the embedding names is its own choice and is not looked for, as the adapters do.
+            'claude-acp': found(this.config.claudeAcp?.command ? null : missingClient('claude', acpEnvironment('claude', { ...process.env }, this.binary))),
+            'codex-acp': found(this.config.codexAcp?.command ? null : missingClient('codex', acpEnvironment('codex', { ...process.env }, this.config.codex))),
+            acp: command ? { found: true, name: /(^|[\\/])dsh(\.[a-z]+)?$/i.test(command.file) || command.args.some(a => /(^|[\\/])dsh(\.[a-z]+)?$/i.test(a)) ? 'DeepSeek Harness' : null } : { found: false, problem: 'Start Rho with --agent-backend acp --acp-command to use another ACP Agent.' }
+        };
     }
     async settings() { return this.settingsView(await this.readSettings()); }
     // The person's Agent and settings for new conversations. Each Agent's choices are replaced as a
@@ -733,12 +788,20 @@ export class Conversations {
             }
         });
     }
+    async changedElsewhere(project, c) {
+        if (!c.acpSessionId || (c.client !== 'claude-code' && c.client !== 'codex'))
+            return false;
+        const previous = c.turns.at(-2), found = await this.ports.nativeSession?.(project, c.client, c.acpSessionId).catch(() => null);
+        return !!found && !!previous?.endedAt && Date.parse(found.lastAt) > Date.parse(previous.endedAt) + 5000;
+    }
     async driver(project, c) {
         return this.serial('driver-pool', async () => {
             const key = project.id + '/' + c.id, old = this.drivers.get(key);
             if (old?.timer)
                 clearTimeout(old.timer);
-            if (old?.driver.connected)
+            // An open connection keeps the session as it last saw it. When the session went on in
+            // another window since, it is opened again from the Agent's own record.
+            if (old?.driver.connected && !await this.changedElsewhere(project, c))
                 return old.driver;
             if (old)
                 await this.retire(key);
@@ -770,7 +833,7 @@ export class Conversations {
                 } };
             // Every session started here is told about the project's shared notes and its section.
             const instructions = notesInstructions(c.id, { notebook: !!this.ports.notebook?.() });
-            const common = { cwd: project.root, mcpServers, limits: this.limits, sessionId: c.acpSessionId, config: c.config, instructions, ...observed };
+            const common = { cwd: project.root, mcpServers, limits: this.limits, sessionId: c.acpSessionId, ...(!c.acpSessionId && c.forkFrom ? { forkFrom: c.forkFrom } : {}), config: c.config, instructions, ...observed };
             const driver = c.backend === 'codex-acp'
                 ? new CodexAcpConversation({ ...this.config.codexAcp, ...common, codex: this.config.codex })
                 : c.backend === 'claude-acp'

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([
+    ...['session.instructions', '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 {};