@rho-workspace/rho 0.5.5 → 0.5.7

package/node_modules/@rho-workspace/plugin-agent/dist/acp-command.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 export function acpCommand(agent) {
@@ -14,19 +15,25 @@ const clientName = { claude: 'Claude Code', codex: 'Codex' };
  * executable, else the one already named in the environment, else the client on PATH. */
 export function acpEnvironment(agent, env, executable) {
     const name = executableVariable[agent];
-    return { ...env, [name]: executable || env[name] || agent };
+    return { ...withoutSessionMarkers(env), [name]: executable || env[name] || agent };
 }
-/** Why the adapter could not start the person's client, or null when its executable is
- * there. The adapters report a missing client only as a closed connection. */
-export function missingClient(agent, env) {
-    const executable = env[executableVariable[agent]] || agent;
-    // On Windows a copied environment keeps the variable's own case (Path), and a client is a
-    // file with an extension PATHEXT names (claude.exe, an npm codex.cmd), as the shell finds it.
+// When Rho itself was started from inside a Claude Code session (an Agent ran the setup), the
+// environment carries that session's markers. A Claude Code started with them takes itself for
+// its child: it saves no transcript (so its session cannot be continued anywhere) and reports to
+// the parent's socket. Rho's sessions are the person's own, so those markers are not passed on.
+const sessionMarkers = /^(CLAUDECODE|CLAUDE_CODE_(CHILD_SESSION|ENTRYPOINT|SESSION_ID|SESSION_ATTENDED|MESSAGING_SOCKET|MESSAGING_TOKEN|EXECPATH|SSE_PORT)|CLAUDE_PID)$/;
+export function withoutSessionMarkers(env) {
+    return Object.fromEntries(Object.entries(env).filter(([key]) => !sessionMarkers.test(key)));
+}
+/** The file a shell runs for `program`: the program itself when it names a path, else the first
+ * runnable match on PATH. On Windows a copied environment keeps the variable's own case (Path),
+ * and a program is a file with an extension PATHEXT names (claude.exe, an npm codex.cmd). */
+export function locate(program, env) {
     const windows = process.platform === 'win32';
     const variable = (name) => windows ? Object.entries(env).find(([key]) => key.toUpperCase() === name)?.[1] : env[name];
-    const named = executable.includes('/') || (windows && executable.includes('\\'));
-    const extensions = windows && !path.extname(executable) ? (variable('PATHEXT') ?? '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean) : [''];
-    const candidates = (named ? [executable] : (variable('PATH') ?? '').split(path.delimiter).filter(Boolean).map(directory => path.join(directory, executable))).flatMap(file => extensions.map(extension => file + extension));
+    const named = program.includes('/') || (windows && program.includes('\\'));
+    const extensions = windows && !path.extname(program) ? (variable('PATHEXT') ?? '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean) : [''];
+    const candidates = (named ? [program] : (variable('PATH') ?? '').split(path.delimiter).filter(Boolean).map(directory => path.join(directory, program))).flatMap(file => extensions.map(extension => file + extension));
     const runnable = (file) => { try {
         fs.accessSync(file, fs.constants.X_OK);
         return fs.statSync(file).isFile();
@@ -34,7 +41,43 @@ export function missingClient(agent, env) {
     catch {
         return false;
     } };
-    if (candidates.some(runnable))
+    return candidates.find(runnable) ?? null;
+}
+/** Why the adapter could not start the person's client, or null when its executable is
+ * there. The adapters report a missing client only as a closed connection. */
+export function missingClient(agent, env) {
+    const executable = env[executableVariable[agent]] || agent;
+    if (locate(executable, env))
         return null;
+    const named = executable.includes('/') || (process.platform === 'win32' && executable.includes('\\'));
     return `${clientName[agent]} was not found ${named ? 'at ' + executable : 'on PATH (' + executable + ')'}. Install it, or select its executable.`;
 }
+export const knownAcpAgents = [
+    // DeepSeek Harness serves ACP from its `acp` profile, installed apart from the launcher.
+    { id: 'dsh', name: 'DeepSeek Harness', program: 'dsh', args: ['acp'] },
+    { id: 'hermes', name: 'Hermes Agent', program: 'hermes', args: ['acp'] },
+    { id: 'kimi', name: 'Kimi Code', program: 'kimi', args: ['acp'] },
+    { id: 'opencode', name: 'OpenCode', program: 'opencode', args: ['acp'] },
+    { id: 'gemini', name: 'Gemini CLI', program: 'gemini', args: ['--acp'] },
+    { id: 'qwen', name: 'Qwen Code', program: 'qwen', args: ['--acp'] },
+    { id: 'goose', name: 'goose', program: 'goose', args: ['acp'] },
+    { id: 'cursor', name: 'Cursor Agent', program: 'cursor-agent', args: ['acp'] },
+    { id: 'auggie', name: 'Auggie CLI', program: 'auggie', args: ['--acp'] },
+    { id: 'codebuddy', name: 'CodeBuddy Code', program: 'codebuddy', args: ['--acp'] },
+    { id: 'droid', name: 'Factory Droid', program: 'droid', args: ['exec', '--output-format', 'acp-daemon'] },
+];
+const harnessProfile = (env) => fs.existsSync(path.join(env.DSH_HOME || path.join(os.homedir(), '.dsh'), 'profiles', 'acp', 'package.json'));
+/** The known Agents installed on this computer, each with the file its command starts. Finding
+ * them reads PATH (and Harness's profile folder) and starts nothing: whether one answers as an
+ * ACP Agent is known only once it is started. */
+export function installedAcpAgents(env = process.env) {
+    return knownAcpAgents.flatMap(agent => {
+        const file = locate(agent.program, env);
+        return file && (agent.id !== 'dsh' || harnessProfile(env)) ? [{ id: agent.id, name: agent.name, command: { file, args: agent.args } }] : [];
+    });
+}
+/** The known Agent a command starts, when it starts one with its ACP arguments. */
+export function knownAcpAgent(command) {
+    const program = path.basename(command.file).replace(/\.(exe|cmd|bat)$/i, '').toLowerCase();
+    return knownAcpAgents.find(agent => agent.program === program && agent.args.length === command.args.length && agent.args.every((arg, i) => arg === command.args[i])) ?? null;
+}

package/node_modules/@rho-workspace/plugin-agent/dist/acp-conversation.d.ts

@@ -8,6 +8,7 @@ export interface AcpConversationOptions {
     mcpServers: AgentMcpServer[];
     limits: AgentProcessLimits;
     sessionId?: string;
+    forkFrom?: string;
     command: {
         file: string;
         args: string[];

package/node_modules/@rho-workspace/plugin-agent/dist/acp-conversation.js

@@ -148,9 +148,16 @@ export class AcpConversation {
             } });
         bounded.on('error', () => { });
         child.stdout.pipe(bounded);
-        // Drain diagnostics without storing credentials, URLs or native reasoning.
-        child.stderr.on('data', (chunk) => { this.outputBytes += chunk.length; if (this.outputBytes > o.limits.maxOutputBytes)
-            overflow('output-limit'); });
+        // Drain diagnostics without storing credentials, URLs or native reasoning. Its last few
+        // kilobytes stay in memory only, to say why an Agent that exits before it answers did not
+        // start (an unknown argument, a missing sign-in); only its last line is shown, redacted.
+        let printed = '';
+        child.stderr.on('data', (chunk) => {
+            this.outputBytes += chunk.length;
+            if (this.outputBytes > o.limits.maxOutputBytes)
+                overflow('output-limit');
+            printed = (printed + chunk.toString('utf8')).slice(-4096);
+        });
         this.connection = acp.client({ name: 'rho-agent' })
             .onNotification(acp.methods.client.session.update, ({ params }) => {
             try {
@@ -211,6 +218,16 @@ export class AcpConversation {
                     throw new Error('This Agent cannot load the original session. Nothing was resent.');
                 }
             }
+            else if (o.forkFrom) {
+                const caps = initialized.agentCapabilities;
+                if (!caps?.sessionCapabilities?.fork)
+                    throw new Error('This Agent cannot continue a copy of a session. Nothing was sent.');
+                const forked = await connection.agent.request('session/fork', { ...params, sessionId: o.forkFrom });
+                if (typeof forked?.sessionId !== 'string' || forked.sessionId === o.forkFrom)
+                    throw new Error('The Agent did not create a separate copy of the session. Nothing was sent.');
+                this.sessionId = forked.sessionId;
+                this.settings = forked.configOptions ?? [];
+            }
             else {
                 const created = await connection.agent.request(acp.methods.agent.session.new, params);
                 this.sessionId = created.sessionId;
@@ -229,6 +246,15 @@ export class AcpConversation {
                 ...(initialized.agentInfo ? { adapter: { name: initialized.agentInfo.name, version: initialized.agentInfo.version } } : {}), ...(model ? { model } : {}) };
             this.observationOrigin = 'live';
         }
+        catch (error) {
+            await Promise.race([this.childEnded, new Promise(resolve => setTimeout(resolve, 300))]);
+            const last = printed.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '').split(/\r?\n/).map(line => line.trim()).filter(Boolean).at(-1);
+            // The process may have ended while this waited, which the type of exit does not follow.
+            const exit = this.exit;
+            if (exit && last && !this.fault)
+                throw new Error(`The Agent exited before it answered${exit.code !== null ? ' (exit ' + exit.code + ')' : ''}. It printed: ${last.slice(0, 300)}`);
+            throw error;
+        }
         finally {
             clearTimeout(timer);
         }

package/node_modules/@rho-workspace/plugin-agent/dist/external-session-contract.js

@@ -1,4 +1,5 @@
-// A retained observation of another client's conversation. It has no input operation.
+// A conversation an Agent holds in its own record: a retained observation of another client's
+// conversation, or a session the Agent keeps in its own files. Reading it starts nothing.
 const text = { type: 'string' }, count = { type: 'integer', minimum: 0 };
 const obj = (properties, required = Object.keys(properties)) => ({ type: 'object', properties, required, additionalProperties: false });
 const array = (items, maxItems) => ({ type: 'array', items, maxItems });
@@ -6,10 +7,15 @@ export const externalSessionLimits = { maxSessions: 64, maxTurns: 200, maxTools:
 const state = { enum: ['running', 'completed', 'failed', 'stopped', 'unknown'] };
 export const externalResultSchema = obj({ path: text, id: text, version: text, projectId: text, toolId: text }, ['path', 'toolId']);
 export const externalToolSchema = obj({ id: text, at: text, name: text, detail: text, output: text, outcome: { enum: ['requested', 'returned', 'failed', 'unknown'] }, exitCode: { type: 'integer' }, paths: array(text, 32) }, ['id', 'at', 'name', 'detail', 'output', 'outcome', 'paths']);
-export const externalTurnSchema = obj({ id: text, at: text, endedAt: text, state, prompt: text, reply: text, messages: array(obj({ at: text, text }), 200), tools: array(externalToolSchema, externalSessionLimits.maxTools), results: array(externalResultSchema, 64), omittedTools: count, omittedChars: count }, ['id', 'at', 'state', 'prompt', 'reply', 'messages', 'tools', 'results', 'omittedTools', 'omittedChars']);
-export const externalSessionSummarySchema = obj({ id: { type: 'string', pattern: '^x-[a-f0-9]{64}$' }, producer: text, sessionId: text, title: text, lastAt: text, observedAt: text, state, turns: count, sourceCursor: count, omittedTurns: count, problem: text, inputOwner: { const: 'external' } }, ['id', 'producer', 'sessionId', 'title', 'lastAt', 'observedAt', 'state', 'turns', 'sourceCursor', 'omittedTurns', 'inputOwner']);
+export const externalTurnSchema = obj({ id: text, at: text, endedAt: text, state, prompt: text, reply: text, messages: array(obj({ at: text, text }), 200), tools: array(externalToolSchema, externalSessionLimits.maxTools), results: array(externalResultSchema, 64), omittedTools: count, omittedChars: count, where: text }, ['id', 'at', 'state', 'prompt', 'reply', 'messages', 'tools', 'results', 'omittedTools', 'omittedChars']);
+export const externalSessionSummarySchema = obj({ id: { type: 'string', pattern: '^x-[a-f0-9]{64}$' }, producer: text, sessionId: text, title: text, lastAt: text, observedAt: text, state, turns: count, sourceCursor: count, omittedTurns: count, problem: text, inputOwner: { const: 'external' },
+    // Native sessions: where it was started, a live process holding it, the command that continues it in a terminal
+    // and its size. The application adds the Agent it continues with in Rho (acp:… is an ACP Agent the person
+    // added there) and the Rho conversation that continued it.
+    where: text, open: { anyOf: [{ type: 'null' }, obj({ where: text, since: text, pid: count }, ['where'])] }, resume: text, bytes: count,
+    continueWith: { anyOf: [{ enum: ['claude-acp', 'codex-acp', 'acp', null] }, { type: 'string', pattern: '^acp:[a-z0-9][a-z0-9-]{0,39}$' }] }, conversationId: text }, ['id', 'producer', 'sessionId', 'title', 'lastAt', 'observedAt', 'state', 'turns', 'sourceCursor', 'omittedTurns']);
 export const externalSessionSchemas = { summary: externalSessionSummarySchema, turn: externalTurnSchema };
 export const externalSessionOperations = {
-    'agent.sessions.list': { inputSchema: obj({}), outputSchema: obj({ sessions: array(externalSessionSummarySchema, 64), omitted: count }), requires: [], effect: 'read' },
-    'agent.sessions.read': { inputSchema: obj({ session: { type: 'string', pattern: '^x-[a-f0-9]{64}$' }, before: count, limit: { type: 'integer', minimum: 1, maximum: 20 } }, ['session']), outputSchema: obj({ session: externalSessionSummarySchema, first: count, turns: array(externalTurnSchema, 20) }), requires: [], effect: 'read' },
+    'agent.sessions.list': { inputSchema: obj({}), outputSchema: obj({ sessions: array(externalSessionSummarySchema, 128), omitted: count }), requires: [], effect: 'read' },
+    'agent.sessions.read': { inputSchema: obj({ session: { type: 'string', pattern: '^x-[a-f0-9]{64}$' }, before: count, limit: { type: 'integer', minimum: 1, maximum: 50 } }, ['session']), outputSchema: obj({ session: externalSessionSummarySchema, first: count, turns: array(externalTurnSchema, 50) }), requires: [], effect: 'read' },
 };

package/node_modules/@rho-workspace/plugin-agent/dist/external-session.d.ts

@@ -31,6 +31,7 @@ export interface ExternalTurn {
     results: ExternalResult[];
     omittedTools: number;
     omittedChars: number;
+    where?: string;
 }
 export interface ExternalSessionSummary {
     id: string;
@@ -44,7 +45,17 @@ export interface ExternalSessionSummary {
     sourceCursor: number;
     omittedTurns: number;
     problem?: string;
-    inputOwner: 'external';
+    inputOwner?: 'external';
+    where?: string;
+    open?: {
+        where: string;
+        since?: string;
+        pid?: number;
+    } | null;
+    resume?: string;
+    bytes?: number;
+    continueWith?: 'claude-acp' | 'codex-acp' | 'acp' | `acp:${string}` | null;
+    conversationId?: string;
 }
 export interface ExternalSessionRecord {
     format: 1;

package/node_modules/@rho-workspace/plugin-agent/dist/index.d.ts

@@ -1971,6 +1971,14 @@ export declare const plugin: {
         modelLoop: string;
         contextDelivery: string;
         proactivePush: string;
+        mcp: {
+            entry: string;
+            transport: string;
+            tools: {
+                name: string;
+                description: string;
+            }[];
+        };
     };
 };
 export { listExternalSessions, readExternalSession } from './external-session.js';

package/node_modules/@rho-workspace/plugin-agent/dist/index.js

@@ -1,4 +1,5 @@
 import { layeredSchemas } from './layered-contract.js';
+import { mcpEntry } from './mcp-entry.js';
 import { skillPresentation, presentation, operationPresentation } from './presentation.js';
 import { operationContracts } from './operations.js';
 import * as fs from 'node:fs/promises';
@@ -302,9 +303,9 @@ const presentationSkill = {
     ],
     verify: { command: 'npm run test:presenter', description: 'Presentation enhances display within its witness and role, and refuses business feedback or document access.' }
 };
-export const plugin = { entryVersion: '1.0', id: 'agent', package: '@rho-workspace/plugin-agent', version: '0.4.19', requires: [], capabilities: ['agent-context'], presentation,
+export const plugin = { entryVersion: '1.0', id: 'agent', package: '@rho-workspace/plugin-agent', version: '0.4.33', requires: [], capabilities: ['agent-context'], presentation,
     operations: Object.entries(operationContracts).map(([method, contract]) => ({ method, presentation: operationPresentation[method], version: '2.0', ...structuredClone(contract), requires: [...contract.requires] })),
     components: [{ id: 'rho.agent-note', version: '0.2.0', owner: 'rho-plugins.agent', bindings: {}, propsSchema: layeredSchemas.AgentNoteProps, ui: './ui', presentation: { displayName: 'Agent note', description: 'A plain presentation explanation with authenticated author and binding basis.', readOnly: true, runsCode: false } }],
     skills: [{ ...agentSkill, presentation: skillPresentation }, { ...feedbackSkill, presentation: { displayName: 'Business feedback', description: 'Reads original feedback, preserves current human edits and links an explicit reply.' } }, { ...presentationSkill, presentation: { displayName: 'Presentation', description: 'Enhances the assigned visible layout without business feedback or document access.' } }],
-    agent: { id: 'claude-code-mcp', transport: 'stdio', modelLoop: 'external-client', contextDelivery: 'pull-tool-result', proactivePush: 'unsupported' } };
+    agent: { id: 'claude-code-mcp', transport: 'stdio', modelLoop: 'external-client', contextDelivery: 'pull-tool-result', proactivePush: 'unsupported', mcp: mcpEntry } };
 export { listExternalSessions, readExternalSession } from './external-session.js';

package/node_modules/@rho-workspace/plugin-agent/dist/mcp-entry.d.ts

@@ -0,0 +1,13 @@
+export declare const mcpTools: {
+    name: string;
+    description: string;
+    inputSchema: any;
+}[];
+export declare const mcpEntry: {
+    entry: string;
+    transport: string;
+    tools: {
+        name: string;
+        description: string;
+    }[];
+};

package/node_modules/@rho-workspace/plugin-agent/dist/mcp-entry.js

@@ -0,0 +1,13 @@
+import { layeredSchemas } from './layered-contract.js';
+// The public MCP entry and its actual tool list share one declaration. Reading
+// this metadata imports no server, connection file or Agent process.
+export const mcpTools = [
+    { name: 'rho_index', description: 'Discover optional Rho workspace capabilities alongside your native tools. Core managed execution is chosen only when needed. Select owner or search to page authorized operations. No full schemas are loaded.', inputSchema: layeredSchemas.McpIndexInput },
+    { name: 'rho_resolve', description: 'Fetch complete guidance and contracts only for selected operations. Follow whole-object pages; knownRefs reuse bodies you still hold.', inputSchema: layeredSchemas.McpResolveInput },
+    { name: 'rho_call', description: 'Call one resolved authorized operation. Large replies return an immutable result reference for rho_read; never repeat a write to retrieve its output.', inputSchema: layeredSchemas.McpCallInput },
+    { name: 'rho_read', description: 'Inspect a retained result by JSON pointer, page containers or text, or explicitly release it. Text offsets count UTF-16 units. Reading never invokes the original operation.', inputSchema: layeredSchemas.McpReadInput }
+];
+export const mcpEntry = {
+    entry: './mcp', transport: 'stdio',
+    tools: mcpTools.map(({ name, description }) => ({ name, description }))
+};

package/node_modules/@rho-workspace/plugin-agent/dist/mcp.js

@@ -3,7 +3,7 @@ import * as fs from 'node:fs/promises';
 import http from 'node:http';
 import path from 'node:path';
 import { retainAgentIntent } from './agent-intents.js';
-import { layeredSchemas } from './layered-contract.js';
+import { mcpTools as tools } from './mcp-entry.js';
 import { LayeredMcp } from './layered.js';
 import { ResultPages, resultLimits } from './result-pages.js';
 import { Ajv } from 'ajv';
@@ -31,11 +31,25 @@ requireThat(Number.isSafeInteger(transportMs) && transportMs > 0, 'invalid', 'In
 const allowance = (input) => transportMs + (Number.isSafeInteger(input.waitMs) && input.waitMs > 0 ? Math.min(input.waitMs, 600000) : 0);
 // node:http rather than fetch: fetch stops waiting for a response's headers after 300 s whatever
 // the signal allows, and the service answers a waited cell only when the cell ends (P3, run 2).
+// The client that started this server, as it named itself in MCP initialize, so the person's
+// screen can show whose window the connection is. A name and version only, each bounded.
+function clientHeader() {
+    let info;
+    try {
+        info = server.getClientVersion();
+    }
+    catch {
+        return {};
+    }
+    if (!info?.name)
+        return {};
+    return { 'x-rho-client': [info.name, info.version].filter(Boolean).map(x => encodeURIComponent(String(x).slice(0, 128))).join('/') };
+}
 async function invoke(method, input = {}, contractRef) {
     const body = JSON.stringify({ ...input, projectId: c.projectId });
     const response = await new Promise((resolve, reject) => {
         const request = http.request(new URL('/api/v2/' + method, endpoint), { method: 'POST', signal: AbortSignal.timeout(allowance(input)),
-            headers: { authorization: 'Bearer ' + c.token, 'content-type': 'application/json', 'content-length': Buffer.byteLength(body), ...(contractRef ? { 'x-rho-contract-ref': contractRef } : {}) } }, resolve);
+            headers: { authorization: 'Bearer ' + c.token, 'content-type': 'application/json', 'content-length': Buffer.byteLength(body), ...clientHeader(), ...(contractRef ? { 'x-rho-contract-ref': contractRef } : {}) } }, resolve);
         // A refused connection is the one failure whose outcome is known: nothing reached the
         // service, so nothing ran. It is usually Rho not running, and the person can start it.
         request.once('error', error => reject(error.code === 'ECONNREFUSED'
@@ -125,12 +139,6 @@ const results = new ResultPages(path.dirname(descriptor), digest(c.projectId + '
     const index = await layer.index({ search: operation });
     requireThat(index.ok && index.value.entries.some((e) => e.id === operation), 'scope', 'The operation that produced this result is no longer available to this connection.');
 }, limits);
-const tools = [
-    { name: 'rho_index', description: 'Discover optional Rho workspace capabilities alongside your native tools. Core managed execution is chosen only when needed. Select owner or search to page authorized operations. No full schemas are loaded.', inputSchema: layeredSchemas.McpIndexInput },
-    { name: 'rho_resolve', description: 'Fetch complete guidance and contracts only for selected operations. Follow whole-object pages; knownRefs reuse bodies you still hold.', inputSchema: layeredSchemas.McpResolveInput },
-    { name: 'rho_call', description: 'Call one resolved authorized operation. Large replies return an immutable result reference for rho_read; never repeat a write to retrieve its output.', inputSchema: layeredSchemas.McpCallInput },
-    { name: 'rho_read', description: 'Inspect a retained result by JSON pointer, page containers or text, or explicitly release it. Text offsets count UTF-16 units. Reading never invokes the original operation.', inputSchema: layeredSchemas.McpReadInput }
-];
 const ajv = new Ajv({ strict: false });
 const validators = Object.fromEntries(tools.map(t => [t.name, ajv.compile(t.inputSchema)]));
 const server = new Server({ name: 'rho-project', version: '0.4.0' }, { capabilities: { tools: {} } });

package/node_modules/@rho-workspace/plugin-agent/dist/native-sessions.d.ts

@@ -0,0 +1,70 @@
+import { type ExternalSessionSummary, type ExternalTurn } from './external-session.js';
+export declare const nativeSessionLimits: {
+    maxSessions: number;
+    maxScanFiles: number;
+    maxHeadBytes: number;
+    maxTailBytes: number;
+    maxReadBytes: number;
+    maxTurns: number;
+    maxTools: number;
+    maxTextChars: number;
+    maxDetailChars: number;
+    activeMs: number;
+};
+export type NativeProducer = 'claude-code' | 'codex';
+export interface NativeSessionSources {
+    claudeConfigDir?: string;
+    codexHome?: string;
+}
+export interface NativeSessionSummary extends ExternalSessionSummary {
+    producer: NativeProducer;
+    where: string;
+    open: {
+        where: string;
+        since?: string;
+        pid?: number;
+    } | null;
+    resume: string;
+    bytes: number;
+}
+export declare function nativeSources(env?: NodeJS.ProcessEnv): Required<NativeSessionSources>;
+/** The Agents' own sessions whose working folder is `root`, newest first. Reads files only. */
+export declare function listNativeSessions(root: string, sources?: NativeSessionSources): {
+    sessions: NativeSessionSummary[];
+    omitted: number;
+};
+/** One session's turns, read through its file (its last maxReadBytes when larger). */
+export declare function readNativeSession(root: string, input: {
+    session: string;
+    before?: number;
+    limit?: number;
+}, sources?: NativeSessionSources): Promise<{
+    session: {
+        turns: number;
+        omittedTurns: number;
+        producer: NativeProducer;
+        where: string;
+        open: {
+            where: string;
+            since?: string;
+            pid?: number;
+        } | null;
+        resume: string;
+        bytes: number;
+        id: string;
+        sessionId: string;
+        title: string;
+        lastAt: string;
+        observedAt: string;
+        state: ExternalTurn["state"];
+        sourceCursor: number;
+        problem?: string;
+        inputOwner?: "external";
+        continueWith?: "claude-acp" | "codex-acp" | "acp" | `acp:${string}` | null;
+        conversationId?: string;
+    };
+    first: number;
+    turns: ExternalTurn[];
+} | null>;
+/** Whether `sessionId` names a session of this Agent in `root`, and its summary. */
+export declare function nativeSession(root: string, producer: NativeProducer, sessionId: string, sources?: NativeSessionSources): NativeSessionSummary | null;