@rho-workspace/rho 0.5.3 → 0.5.4

package/node_modules/@hono/node-server/dist/index.js

@@ -52,6 +52,15 @@ var RequestError = class extends Error {
     this.name = "RequestError";
   }
 };
+var validateRequestTarget = (target) => {
+  const backslash = target.indexOf("\\");
+  if (backslash !== -1) {
+    const query = target.indexOf("?");
+    if (query === -1 || backslash < query) {
+      throw new RequestError("Backslash in request path");
+    }
+  }
+};
 var toRequestError = (e) => {
   if (e instanceof RequestError) {
     return e;
@@ -212,6 +221,7 @@ var newRequest = (incoming, defaultHostname) => {
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
     }
     try {
+      validateRequestTarget(incomingUrl);
       const url2 = new URL(incomingUrl);
       req[urlKey] = url2.href;
     } catch (e) {
@@ -232,6 +242,7 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
+  validateRequestTarget(incomingUrl);
   const url = new URL(`${scheme}://${host}${incomingUrl}`);
   if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");

package/node_modules/@hono/node-server/dist/index.mjs

@@ -13,6 +13,15 @@ var RequestError = class extends Error {
     this.name = "RequestError";
   }
 };
+var validateRequestTarget = (target) => {
+  const backslash = target.indexOf("\\");
+  if (backslash !== -1) {
+    const query = target.indexOf("?");
+    if (query === -1 || backslash < query) {
+      throw new RequestError("Backslash in request path");
+    }
+  }
+};
 var toRequestError = (e) => {
   if (e instanceof RequestError) {
     return e;
@@ -173,6 +182,7 @@ var newRequest = (incoming, defaultHostname) => {
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
     }
     try {
+      validateRequestTarget(incomingUrl);
       const url2 = new URL(incomingUrl);
       req[urlKey] = url2.href;
     } catch (e) {
@@ -193,6 +203,7 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
+  validateRequestTarget(incomingUrl);
   const url = new URL(`${scheme}://${host}${incomingUrl}`);
   if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");

package/node_modules/@hono/node-server/dist/listener.js

@@ -44,6 +44,15 @@ var RequestError = class extends Error {
     this.name = "RequestError";
   }
 };
+var validateRequestTarget = (target) => {
+  const backslash = target.indexOf("\\");
+  if (backslash !== -1) {
+    const query = target.indexOf("?");
+    if (query === -1 || backslash < query) {
+      throw new RequestError("Backslash in request path");
+    }
+  }
+};
 var toRequestError = (e) => {
   if (e instanceof RequestError) {
     return e;
@@ -204,6 +213,7 @@ var newRequest = (incoming, defaultHostname) => {
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
     }
     try {
+      validateRequestTarget(incomingUrl);
       const url2 = new URL(incomingUrl);
       req[urlKey] = url2.href;
     } catch (e) {
@@ -224,6 +234,7 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
+  validateRequestTarget(incomingUrl);
   const url = new URL(`${scheme}://${host}${incomingUrl}`);
   if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");

package/node_modules/@hono/node-server/dist/listener.mjs

@@ -10,6 +10,15 @@ var RequestError = class extends Error {
     this.name = "RequestError";
   }
 };
+var validateRequestTarget = (target) => {
+  const backslash = target.indexOf("\\");
+  if (backslash !== -1) {
+    const query = target.indexOf("?");
+    if (query === -1 || backslash < query) {
+      throw new RequestError("Backslash in request path");
+    }
+  }
+};
 var toRequestError = (e) => {
   if (e instanceof RequestError) {
     return e;
@@ -170,6 +179,7 @@ var newRequest = (incoming, defaultHostname) => {
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
     }
     try {
+      validateRequestTarget(incomingUrl);
       const url2 = new URL(incomingUrl);
       req[urlKey] = url2.href;
     } catch (e) {
@@ -190,6 +200,7 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
+  validateRequestTarget(incomingUrl);
   const url = new URL(`${scheme}://${host}${incomingUrl}`);
   if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");

package/node_modules/@hono/node-server/dist/request.js

@@ -38,6 +38,15 @@ var RequestError = class extends Error {
     this.name = "RequestError";
   }
 };
+var validateRequestTarget = (target) => {
+  const backslash = target.indexOf("\\");
+  if (backslash !== -1) {
+    const query = target.indexOf("?");
+    if (query === -1 || backslash < query) {
+      throw new RequestError("Backslash in request path");
+    }
+  }
+};
 var toRequestError = (e) => {
   if (e instanceof RequestError) {
     return e;
@@ -198,6 +207,7 @@ var newRequest = (incoming, defaultHostname) => {
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
     }
     try {
+      validateRequestTarget(incomingUrl);
       const url2 = new URL(incomingUrl);
       req[urlKey] = url2.href;
     } catch (e) {
@@ -218,6 +228,7 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
+  validateRequestTarget(incomingUrl);
   const url = new URL(`${scheme}://${host}${incomingUrl}`);
   if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");

package/node_modules/@hono/node-server/dist/request.mjs

@@ -7,6 +7,15 @@ var RequestError = class extends Error {
     this.name = "RequestError";
   }
 };
+var validateRequestTarget = (target) => {
+  const backslash = target.indexOf("\\");
+  if (backslash !== -1) {
+    const query = target.indexOf("?");
+    if (query === -1 || backslash < query) {
+      throw new RequestError("Backslash in request path");
+    }
+  }
+};
 var toRequestError = (e) => {
   if (e instanceof RequestError) {
     return e;
@@ -167,6 +176,7 @@ var newRequest = (incoming, defaultHostname) => {
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
     }
     try {
+      validateRequestTarget(incomingUrl);
       const url2 = new URL(incomingUrl);
       req[urlKey] = url2.href;
     } catch (e) {
@@ -187,6 +197,7 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
+  validateRequestTarget(incomingUrl);
   const url = new URL(`${scheme}://${host}${incomingUrl}`);
   if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");

package/node_modules/@hono/node-server/dist/server.js

@@ -48,6 +48,15 @@ var RequestError = class extends Error {
     this.name = "RequestError";
   }
 };
+var validateRequestTarget = (target) => {
+  const backslash = target.indexOf("\\");
+  if (backslash !== -1) {
+    const query = target.indexOf("?");
+    if (query === -1 || backslash < query) {
+      throw new RequestError("Backslash in request path");
+    }
+  }
+};
 var toRequestError = (e) => {
   if (e instanceof RequestError) {
     return e;
@@ -208,6 +217,7 @@ var newRequest = (incoming, defaultHostname) => {
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
     }
     try {
+      validateRequestTarget(incomingUrl);
       const url2 = new URL(incomingUrl);
       req[urlKey] = url2.href;
     } catch (e) {
@@ -228,6 +238,7 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
+  validateRequestTarget(incomingUrl);
   const url = new URL(`${scheme}://${host}${incomingUrl}`);
   if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");

package/node_modules/@hono/node-server/dist/server.mjs

@@ -13,6 +13,15 @@ var RequestError = class extends Error {
     this.name = "RequestError";
   }
 };
+var validateRequestTarget = (target) => {
+  const backslash = target.indexOf("\\");
+  if (backslash !== -1) {
+    const query = target.indexOf("?");
+    if (query === -1 || backslash < query) {
+      throw new RequestError("Backslash in request path");
+    }
+  }
+};
 var toRequestError = (e) => {
   if (e instanceof RequestError) {
     return e;
@@ -173,6 +182,7 @@ var newRequest = (incoming, defaultHostname) => {
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
     }
     try {
+      validateRequestTarget(incomingUrl);
       const url2 = new URL(incomingUrl);
       req[urlKey] = url2.href;
     } catch (e) {
@@ -193,6 +203,7 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
+  validateRequestTarget(incomingUrl);
   const url = new URL(`${scheme}://${host}${incomingUrl}`);
   if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");

package/node_modules/@hono/node-server/dist/vercel.js

@@ -46,6 +46,15 @@ var RequestError = class extends Error {
     this.name = "RequestError";
   }
 };
+var validateRequestTarget = (target) => {
+  const backslash = target.indexOf("\\");
+  if (backslash !== -1) {
+    const query = target.indexOf("?");
+    if (query === -1 || backslash < query) {
+      throw new RequestError("Backslash in request path");
+    }
+  }
+};
 var toRequestError = (e) => {
   if (e instanceof RequestError) {
     return e;
@@ -206,6 +215,7 @@ var newRequest = (incoming, defaultHostname) => {
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
     }
     try {
+      validateRequestTarget(incomingUrl);
       const url2 = new URL(incomingUrl);
       req[urlKey] = url2.href;
     } catch (e) {
@@ -226,6 +236,7 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
+  validateRequestTarget(incomingUrl);
   const url = new URL(`${scheme}://${host}${incomingUrl}`);
   if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");

package/node_modules/@hono/node-server/dist/vercel.mjs

@@ -10,6 +10,15 @@ var RequestError = class extends Error {
     this.name = "RequestError";
   }
 };
+var validateRequestTarget = (target) => {
+  const backslash = target.indexOf("\\");
+  if (backslash !== -1) {
+    const query = target.indexOf("?");
+    if (query === -1 || backslash < query) {
+      throw new RequestError("Backslash in request path");
+    }
+  }
+};
 var toRequestError = (e) => {
   if (e instanceof RequestError) {
     return e;
@@ -170,6 +179,7 @@ var newRequest = (incoming, defaultHostname) => {
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
     }
     try {
+      validateRequestTarget(incomingUrl);
       const url2 = new URL(incomingUrl);
       req[urlKey] = url2.href;
     } catch (e) {
@@ -190,6 +200,7 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
+  validateRequestTarget(incomingUrl);
   const url = new URL(`${scheme}://${host}${incomingUrl}`);
   if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");

package/node_modules/@hono/node-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/node-server",
-  "version": "1.19.17",
+  "version": "1.19.18",
   "description": "Node.js Adapter for Hono",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -343,7 +343,9 @@ results. Results survive MCP restart. One call to the service may take
 `RHO_TRANSPORT_MS` (30 s), plus the `waitMs` it asks the service to wait (at most ten
 minutes, as for a Notebook cell); the call uses `node:http`, whose wait for a reply has
 no limit of its own. A transport overrun keeps the outcome uncertain and directs
-observation of the original identity, never replacement work.
+observation of the original identity, never replacement work. A refused connection is the one
+transport failure whose outcome is known: nothing reached the service, so the call
+returns `unavailable` naming the address and saying nothing ran (`delivered: false`).
 
 The pure `./layered-contract` entry defines the four tool inputs and Agent note
 props. `./layered` provides the bounded complete-object cache and caller checks;

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

@@ -195,10 +195,21 @@ export class AcpConversation {
             let model;
             this.observationOrigin = this.sessionId ? 'history' : 'initial';
             if (this.sessionId) {
-                if (!initialized.agentCapabilities?.loadSession)
+                const caps = initialized.agentCapabilities;
+                if (caps?.loadSession) {
+                    const loaded = await connection.agent.request(acp.methods.agent.session.load, { ...params, sessionId: this.sessionId });
+                    this.settings = loaded.configOptions ?? [];
+                }
+                else if (caps?.sessionCapabilities?.resume) {
+                    // ACP session/resume (e.g. dsh): restore the persisted session on a fresh process. It composes
+                    // the request's MCP connections and validates only the workspace, so the non-standard
+                    // systemPrompt is omitted; history is restored from the Agent's own persistence, not replayed.
+                    const resumed = await connection.agent.request(acp.methods.agent.session.resume, { cwd: o.cwd, mcpServers: o.mcpServers, sessionId: this.sessionId });
+                    this.settings = resumed?.configOptions ?? [];
+                }
+                else {
                     throw new Error('This Agent cannot load the original session. Nothing was resent.');
-                const loaded = await connection.agent.request(acp.methods.agent.session.load, { ...params, sessionId: this.sessionId });
-                this.settings = loaded.configOptions ?? [];
+                }
             }
             else {
                 const created = await connection.agent.request(acp.methods.agent.session.new, params);

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

@@ -123,5 +123,6 @@ export declare function visibleError(error: unknown, env?: NodeJS.ProcessEnv): s
 export { ClaudeAcpConversation, type ClaudeAcpOptions } from './claude-acp.js';
 export { writeClaudePlugin, claudePluginLimits, type ClaudePlugin, type ClaudePluginSkill, type ClaudePluginHook } from './claude-plugin.js';
 export { CodexAcpConversation, type CodexAcpOptions } from './codex-acp.js';
+export { GenericAcpConversation, type GenericAcpOptions } from './generic-acp.js';
 export { ClaudeCliConversation } from './claude-cli.js';
 export type { SessionObservation, SessionTool, ConfigOption, ConfigValue } from './session-observation.js';

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

@@ -25,4 +25,5 @@ export function visibleError(error, env = process.env) {
 export { ClaudeAcpConversation } from './claude-acp.js';
 export { writeClaudePlugin, claudePluginLimits } from './claude-plugin.js';
 export { CodexAcpConversation } from './codex-acp.js';
+export { GenericAcpConversation } from './generic-acp.js';
 export { ClaudeCliConversation } from './claude-cli.js';

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

@@ -0,0 +1,11 @@
+import { AcpConversation, type AcpConversationOptions } from './acp-conversation.js';
+/** A generic ACP agent: any program that speaks ACP v1 over stdio. Rho starts the
+ * operator-selected command and drives it exactly as it drives Claude Code or Codex, so
+ * supporting another agent is configuration (`--acp-command`), not a new adapter. The
+ * command is a file plus its arguments and needs no per-agent environment. */
+export interface GenericAcpOptions extends Omit<AcpConversationOptions, 'command' | 'sessionMeta'> {
+    command: AcpConversationOptions['command'];
+}
+export declare class GenericAcpConversation extends AcpConversation {
+    constructor(o: GenericAcpOptions);
+}

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

@@ -0,0 +1,7 @@
+import { AcpConversation } from './acp-conversation.js';
+export class GenericAcpConversation extends AcpConversation {
+    constructor(o) {
+        // A supplied command skips the missing-client check: the operator named the program.
+        super({ ...o, command: o.command });
+    }
+}

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

@@ -36,7 +36,11 @@ async function invoke(method, input = {}, contractRef) {
     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);
-        request.once('error', reject);
+        // 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'
+            ? new Fault('unavailable', `Rho is not running at ${c.url}, so this call did not reach it and nothing ran. Ask the person to start Rho, then call again.`, { url: c.url, delivered: false })
+            : error));
         request.end(body);
     });
     const chunks = [];

package/node_modules/@rho-workspace/plugin-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rho-workspace/plugin-agent",
-  "version": "0.4.27",
+  "version": "0.4.28",
   "type": "module",
   "description": "Rho agent plugin",
   "license": "AGPL-3.0-only",

package/node_modules/@rho-workspace/plugin-annotations/package.json

@@ -23,7 +23,7 @@
     "@rho-workspace/plugin-contracts": "0.4.0"
   },
   "peerDependencies": {
-    "@rho-workspace/plugin-documents": "0.4.1 || 0.4.2 || 0.4.3 || 0.4.4 || 0.4.5 || 0.4.6 || 0.4.7 || 0.4.8 || 0.4.9 || 0.4.10",
+    "@rho-workspace/plugin-documents": "0.4.1 || 0.4.2 || 0.4.3 || 0.4.4 || 0.4.5 || 0.4.6 || 0.4.7 || 0.4.8 || 0.4.9 || 0.4.10 || 0.4.11",
     "react": "19.3.1",
     "react-dom": "19.3.1"
   },

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

@@ -157,3 +157,7 @@ Documents 0.4.7 adds a confirmed-text selection callback for Review and an optio
 excerpt, reads at most 1 MiB per version and previews at most 64 KiB without cutting
 a Unicode sequence. Buffer snapshots continue to identify their version/dirty
 state separately from disk captures. No comparison rewrites a buffer or its undo.
+
+Documents 0.4.11 lets the editor view (`rho.editor`) keep a boolean `flow` beside its
+`title`: an application that shows a script's data flow beside the editor saves the person's
+switch with the page. The buffer, its undo and its saves are unchanged by it.

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

@@ -1095,6 +1095,9 @@ export declare const plugin: {
                     type: string;
                     minLength: number;
                 };
+                flow: {
+                    type: string;
+                };
             };
             required: string[];
         };

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

@@ -499,5 +499,5 @@ export const plugin = {
                 description: 'Change a project file that is open in Rho through its shared buffer (document.read, document.edit, document.save), so a person\'s unsaved text, undo and saves stay intact.' }],
         hooks: [{ id: 'documents.unsaved-text', event: 'PreToolUse', matcher: 'Edit|Write|MultiEdit', entry: './claude-hook', timeoutSeconds: 10 }]
     },
-    components: [{ id: 'rho.editor', version: '0.2.0', owner: 'rho-plugins.documents', bindings: { document: 'document' }, ui: './ui', presentation: viewPresentation, propsSchema: { type: 'object', additionalProperties: false, properties: { title: { type: 'string', minLength: 1 } }, required: ['title'] } }]
+    components: [{ id: 'rho.editor', version: '0.2.0', owner: 'rho-plugins.documents', bindings: { document: 'document' }, ui: './ui', presentation: viewPresentation, propsSchema: { type: 'object', additionalProperties: false, properties: { title: { type: 'string', minLength: 1 }, flow: { type: 'boolean' } }, required: ['title'] } }]
 };

package/node_modules/@rho-workspace/plugin-documents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rho-workspace/plugin-documents",
-  "version": "0.4.10",
+  "version": "0.4.11",
   "type": "module",
   "description": "Rho documents plugin",
   "license": "AGPL-3.0-only",

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

@@ -1,6 +1,6 @@
 # Notebook
 
-`@rho-workspace/plugin-kernel` 0.5.2 keeps a live R session and a live Python
+`@rho-workspace/plugin-kernel` 0.5.4 keeps a live R session and a live Python
 session for a project, which an Agent and the person share, on this machine or on a
 server: one the person manages with serverctl, reached through it, or one reached with
 ssh.
@@ -71,6 +71,24 @@ once; Stop raises Ctrl+Break and then ends the process tree. R there cannot open
 so its answers come on a named pipe the host serves and names in `RHO_KERNEL_ANSWERS`. R and
 Python end printed lines with `\r\n` there; a cell keeps them as `\n`, as elsewhere.
 
+A session on this machine runs `Rscript` or `python3` from PATH until the project names
+another program. `kernel.run` takes `interpreter`, a program in a folder of the project
+such as the python of a virtual environment made there (`.venv/bin/python`): its folder
+must resolve inside the project, while the file may be the link a virtual environment makes
+to the Python it was made from, and it is started by that name so the environment is the
+one that runs. A path outside the project is refused (`scope`), as is one that is not a
+program (`not_found`) and one named for a session on a server. The project keeps the last
+program named for each language, so later sessions, the person's too, start with it; one
+that is gone is forgotten and the default runs. A cell naming another program than the live
+session's is refused while anyone else ran cells in that session; a session in which only
+the caller ran cells, none of them running, is stopped (recorded as stopped by that caller)
+and started again with the program named. Each session records the program it ran as it
+reported it (`sys.executable`, R's `Rscript`), relative to the project when it is in it, and
+each cell keeps the program and version that ran it, since a cell outlasts its session's
+record. The Notebook and the Overview name such a session by its environment's folder
+(`Python 3.13.5 · .venv`). Where one session ends as the next starts, at the same instant,
+the Notebook lists the end first.
+
 A session can run on a server. A place names the server, a folder there (absolute
 or `~/…`) and setup lines run in that folder before a session starts (`module load R`,
 `conda activate env`). Setup lines that make the folder (`mkdir -p`) run in the home folder
@@ -135,7 +153,9 @@ Limits (`kernelLimits`, each configurable): one session per language, at most 16
 cells waiting in each, cells of at most 64 KiB of code, the first 256 KiB of each
 cell's output (the rest is counted and the cell marked cut), at most 8 plots of at
 most 4 MiB per cell, 500 kept cells (the oldest finished ones go first, with their
-plots), 200 listed variables, 32 files named per cell (`lineageLimits`) and a 10 minute wait for a cell. A session that is not
+plots), 200 listed variables, 32 strings looked at as paths per cell (those that look like a
+file's path first, so a script's labels do not crowd out the file it writes last), 24 files
+named per cell (`lineageLimits`) and a 10 minute wait for a cell. A session that is not
 ready within 30 seconds (90 on a server) is ended. At most 16 places are named; a check
 ends after 60 seconds, a listing after 30 with at most 500 entries from 1 MiB, a signal
 after 15, and a read of serverctl's registry after 15; files larger than 64 MiB are not copied and a copy ends after 10 minutes; the
@@ -172,14 +192,55 @@ highlighting and Markdown; without them code stays plain and a server's skill sh
 written. The views add their own styles once, in the page's color and type variables, and
 use its base controls (`text-button`, `primary`, `secondary`, `inline-error`).
 
-`NotebookPage` is the Notebook as a page, `NotebookWorkSection` the newest cells for an
-overview, `useLiveValues` the sessions' values, and `askCell` and `showOnServer` bring the
-Notebook to a cell and Servers to a file. The pure `./code` entry finds the statement a
-script line belongs to (`statementAt`, `statements`, `unfinished`), writes the code that
-loads a project table or runs a script (`loadCode`, `sourceCode`), and makes Data flow's
-steps and lanes from each cell's `defined`, `used` and `files` (`lineage`, `lanes`).
-The views read at most 300 cells, show 14 lines of code and 12 of output before a click,
-keep 64 plots read, and list the 24 newest plots in Plots.
+The Notebook names, under each cell, the values it read with the cell that made the version it
+read ("Read co from R 3"), and for each value it made the later cells that read that version
+("ratio read in R 6", at most three, the rest counted); a cell named there goes to that cell and
+marks it for a moment. Variables names the cell that made each value as it is now and the cells
+that read it; on the Notebook's page these go to the cells too.
+
+Data flow draws how each result came about as a graph of values, one node per value or file: the
+files read at the top, the results at the bottom (the files written and the plots drawn, else the
+values nothing reads), the values between in rows. A node is titled with the meaning its `# means:`
+comment gives, with its name beneath; a value without one shows its name alone. Functions and
+constants are not drawn; each value names those it uses, and so does a value that changes another
+through a helper made from it (a row mask). A bar above names the results. Choosing one draws only
+what leads to it, and when every result at once would put more than six values in a row, the first
+is chosen to begin with. What leads to no result is named below the graph; choosing one draws what
+leads to it. Choosing a value shows what it comes from and what comes of it in two colors, and names
+how it was made, where, what it comes from, uses, leads to and which results it reaches; a session's
+value can be looked at, a file opened, and the cell that made a value shown in the Notebook. In a
+view of its own, or narrower than 640 px, the chosen value sits above the graph and stays in view;
+wider, it sits beside it. A narrow view titles each node in up to three lines of its meaning, a wide
+one in two. A cell that makes at least three values offers how they came about, in the same drawing.
+`ScriptFlowView` draws a script's graph for a page that follows the chosen value (`selected`,
+`onSelect`) and goes to where a value is made (`onGo`), as a script's editor does. At most 80 values
+are drawn at once, those nearest the results first, and the bar names 8 results until asked for the
+rest (`lineageViewLimits`).
+
+`NotebookPage` is the Notebook as a page, `NotebookWorkSection` the newest cells for an overview,
+`useLiveValues` the sessions' values, and `askCell` and `showOnServer` bring the Notebook to a cell
+and Servers to a file. The pure `./code` entry finds the statement a script line belongs to
+(`statementAt`, `statements`, `unfinished`), writes the code that loads a project table or runs a
+script (`loadCode`, `sourceCode`), follows each cell's `defined`, `used` and `files` to the cell
+that made each value it read (`lineage`, `cellRelations`), and makes Data flow's graph from a
+session's cells (`sessionGraph`) or a script read as text (`scriptGraph`; `scriptFlow` gives a
+script's values, files and their `# means:` comments, and `markersAbove` the comments above one
+statement), with a value's path (`graphPath`), its rows (`graphRows`), the lines behind and in front
+of it (`graphMarks`) and the value made at a line (`graphNodeAt`). In a session, a cell that makes
+its values over several statements is read statement by statement, so each value comes from what its
+own statements read, and a plot from what the statement that drew it read. A value made only from
+literals and calls that put literals together (`c()`, `paste0()`, `dict()`, not a `read.csv()` of a
+URL) is a constant. `scriptFlow` reads a script's values from its text alone, R or Python, in the
+same shape: each top-level statement makes the values it assigns outside its functions, reads the
+script's values it mentions (not what a function keeps for itself, a field after `$` or `.`, an
+argument's name, the columns in `aes()`, `vars()` or a formula, or an import) and reads or writes
+the files its strings name as the call they are given to does (`read.csv`, `write.csv`, `ggsave`,
+`to_csv`, `open(…, "w")`, or a value holding the path). A statement that changes only what the step
+before made, or makes something from nothing after a step that did, joins that step; one that makes
+and writes nothing is counted, with the values it reads, and not drawn. Nothing runs, so names built
+at run time and paths pasted from parts are not seen. A script over 512 KiB is not read and at most
+150 steps are drawn (`scriptFlowLimits`). The views read at most 300 cells, show 14 lines of code
+and 12 of output before a click, keep 64 plots read, and list the 24 newest plots in Plots.
 
 ```sh
 npm run build

package/node_modules/@rho-workspace/plugin-kernel/dist/code.d.ts

@@ -1,3 +1,5 @@
 export * from './statements.js';
 export * from './explore-code.js';
 export * from './lineage.js';
+export * from './script-flow.js';
+export * from './value-graph.js';

package/node_modules/@rho-workspace/plugin-kernel/dist/code.js

@@ -1,6 +1,9 @@
 // What the sessions know about code, for any page that hands code to them: the whole statement a
 // line belongs to, the code that loads a project table or runs a script, and how the values of a
-// session were made. Pure functions; nothing here runs code or reads the project.
+// session, or of a script read as text, were made. Pure functions; nothing here runs code or reads
+// the project.
 export * from './statements.js';
 export * from './explore-code.js';
 export * from './lineage.js';
+export * from './script-flow.js';
+export * from './value-graph.js';

package/node_modules/@rho-workspace/plugin-kernel/dist/contract.js

@@ -68,6 +68,9 @@ export const sessionSchema = obj({
     cells: { type: 'integer', minimum: 0 },
     // Where it ran (null: this machine) and the machine's own name. Sessions recorded before have neither.
     place: maybe(sessionPlaceSchema), host: maybe({ type: 'string' }),
+    // The program it ran, as the session reported it: relative to the project when it is in it
+    // (.venv/bin/python). Sessions recorded before have none.
+    program: maybe({ type: 'string' }),
 }, ['sessionId', 'language', 'state', 'version', 'pid', 'startedAt', 'startedBy', 'endedAt', 'ending', 'stop', 'problem', 'variables', 'variablesOmitted', 'variablesAt', 'cells']);
 export const outputSchema = obj({ kind: { enum: ['stdout', 'stderr', 'warning', 'error', 'plot'] }, text: { type: 'string' }, plot: { type: 'integer', minimum: 1 }, width: { type: 'integer' }, height: { type: 'integer' } }, ['kind']);
 export const cellSchema = obj({
@@ -87,6 +90,8 @@ export const cellSchema = obj({
     // the project files and folders (ending in /) its strings name, as read or written. Cells
     // recorded before have neither.
     used: { type: 'array', items: text }, files: { type: 'array', items: obj({ path: text, how: { enum: ['read', 'wrote'] } }) },
+    // The program and version that ran it. Cells recorded before have neither.
+    program: maybe({ type: 'string' }), version: maybe({ type: 'string' }),
 }, ['cellId', 'changeId', 'by', 'sessionId', 'language', 'code', 'purpose', 'queuedAt', 'startedAt', 'endedAt', 'state', 'number', 'outputs', 'bytes', 'kept', 'cut', 'interrupt', 'problem']);
 // One value of a live session as its session describes it: the kind of thing it is, short facts,
 // and one page of its rows, its elements or its parts, each part with the code that reaches it.