@rho-workspace/rho 0.5.5 → 0.5.6

package/node_modules/@rho-workspace/plugin-agent/README.md

@@ -429,3 +429,32 @@ local storage and observation work; they do not limit the native Agent.
 `test/external-session.test.mjs` checks identity, prefix conflicts, omissions,
 missing outcomes, redaction, project containment, retained failure and pagination.
 The Rho application records its separate real Harness/browser acceptance.
+
+### Native Claude Code and Codex sessions
+
+Agent 0.4.30 exports `native-sessions`. `listNativeSessions(root, nativeSources(env))`
+lists the Claude Code and Codex sessions whose recorded working folder is `root`,
+read from the Agents' own records: `CLAUDE_CONFIG_DIR` (or `~/.claude`)
+`/projects/<folder>/<id>.jsonl` and `CODEX_HOME` (or `~/.codex`)
+`/sessions/**/rollout-*.jsonl`. Each summary keeps the native session ID, title,
+times, turn counts, where it started (Claude Code's `entrypoint`, Codex's
+`originator`), whether another process holds it now (Claude Code's live
+`sessions/<pid>.json` with a running PID, Codex's `thread-writer-locks/<id>.lock`)
+and the terminal resume command. `readNativeSession` streams one record into the
+same turn shape as `readExternalSession`, with each turn's tools, results and
+reply. Reading starts no Agent, takes no lock and writes nothing.
+`nativeSessionLimits` names the budgets: 64 sessions per listing, 4,096 files
+scanned per Claude Code folder and across Codex's sessions, 256 KiB read from each end of a file for a summary, at most 256 MiB
+streamed from the end for a read, 200 turns, 256 tools per turn, and the text and
+tool field limits above. Sidechains, injected reminders and local command output
+are excluded. A recorded interruption is stopped. A last turn without an end record
+is running while its file was written in the last minute; after that it is completed
+when it has a reply and no unanswered tool, and unknown otherwise.
+
+To continue such a session, the application passes its ID as `sessionId` (ACP
+`session/load`). `forkFrom` instead asks the Agent for a separate copy through
+`session/fork`; the connection is refused before sending when the Agent does not
+advertise fork, or returns the same ID. `acpEnvironment` drops inherited Claude Code
+session markers (`CLAUDECODE`, `CLAUDE_CODE_CHILD_SESSION` and related variables):
+a Claude Code started under them saves no transcript, so its session could not be
+listed or continued anywhere else.

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

@@ -7,6 +7,7 @@ export declare function acpCommand(agent: AcpAgent): {
  * optional dependencies that an application need not install, so name the selected
  * executable, else the one already named in the environment, else the client on PATH. */
 export declare function acpEnvironment(agent: AcpAgent, env: NodeJS.ProcessEnv, executable?: string): NodeJS.ProcessEnv;
+export declare function withoutSessionMarkers(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /** 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 declare function missingClient(agent: AcpAgent, env: NodeJS.ProcessEnv): string | null;

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

@@ -14,7 +14,15 @@ 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 };
+}
+// 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)));
 }
 /** 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. */

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

@@ -211,6 +211,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;

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,14 @@ 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 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: { enum: ['claude-acp', 'codex-acp', 'acp', null] }, 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' | null;
+    conversationId?: string;
 }
 export interface ExternalSessionRecord {
     format: 1;

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" | 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;