@4fu/arbor-tools 0.0.0-stage → 2026.1106.0

package/code-exec.js

@@ -0,0 +1,100 @@
+/**
+ * `code_exec`: everything that is not a decision runs from a script
+ * (docs/tools.md#rules).
+ *
+ * A script that names a direct tool is refused with the rule and never reaches
+ * the host. Calls from a script go through the same hooks as direct calls, so
+ * anchors, watermarks, quotas, validation and logging behave the same: every
+ * module function is the same service call the direct tool makes.
+ *
+ * Two lookups are script globals: `tool_search` takes keywords, an exact
+ * `module.function` name, or nothing for every module; `tool_describe` returns
+ * one signature. Both read the catalog frozen with the window plus the
+ * environment deltas since.
+ */
+import vm from "node:vm";
+import { textOf } from "@4fu/arbor-prompt";
+import { boundResult } from "./bound.js";
+/** How long one script may run before it is stopped. */
+const SCRIPT_TIMEOUT_MS = 60000;
+/** Run one script in its own context, with the modules as globals. */
+export async function runScript(script, catalog, services, context) {
+    const table = services.table;
+    const named = directToolIn(script, catalog.directTools());
+    if (named !== undefined) {
+        return {
+            callId: "",
+            ok: false,
+            content: "",
+            error: {
+                rule: "script.decision_tool",
+                message: textOf(table, "refused.decision_in_script", { name: named }),
+                nextAction: textOf(table, "next.decision_in_script"),
+            },
+        };
+    }
+    const globals = {
+        tool_search: (keywords) => catalog.search(keywords),
+        tool_describe: (name) => catalog.describe(name),
+        console: { log: () => { }, error: () => { } },
+    };
+    for (const module of catalog.modules()) {
+        globals[module.name] = moduleFunctions(module, catalog, context);
+    }
+    const sandbox = vm.createContext(globals);
+    const wrapped = `(async () => {\n${script}\n})()`;
+    let value;
+    try {
+        const compiled = new vm.Script(wrapped, { filename: "code_exec.js" });
+        value = await compiled.runInContext(sandbox, { timeout: SCRIPT_TIMEOUT_MS });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            callId: "",
+            ok: false,
+            content: "",
+            error: {
+                rule: "script.failed",
+                message: textOf(table, "refused.script_failed", { message }),
+                nextAction: textOf(table, "next.script_failed"),
+            },
+        };
+    }
+    const text = value === undefined ? "" : typeof value === "string" ? value : JSON.stringify(value);
+    return {
+        callId: "",
+        ok: true,
+        content: await boundResult(text ?? "", {
+            workspace: context.workspace,
+            callId: context.call,
+            table,
+        }),
+    };
+}
+/** One module's functions, as the globals a script calls. */
+function moduleFunctions(module, catalog, context) {
+    const functions = {};
+    for (const spec of module.functions) {
+        functions[spec.name.slice(module.name.length + 1)] = async (args = {}) => {
+            const result = await catalog.callModule(spec.name, args, context);
+            if (!result.ok)
+                throw new Error(result.error?.message ?? result.content);
+            return result.content;
+        };
+    }
+    return functions;
+}
+/**
+ * The direct tool a script names, if any. This is a guard, not a sandbox: it
+ * keeps a decision out of a script, and the host still enforces every rule.
+ */
+export function directToolIn(script, tools) {
+    for (const tool of tools) {
+        const pattern = new RegExp(`(^|[^\\w.$])${tool.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\(`);
+        if (pattern.test(script))
+            return tool;
+    }
+    return undefined;
+}
+export { SCRIPT_TIMEOUT_MS };

package/env-stage.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The environment as a command sees it (docs/environment.md#layout).
+ *
+ * A window reads the environment at `/env`, and it lives on the host. Where a
+ * command runs decides how the prefix reaches it:
+ *
+ * - A plain-directory workspace runs the command on the host, so the prefix is
+ *   rewritten onto the directory itself.
+ * - A workspace that owns its execution environment runs the command where the
+ *   host's directory is not visible, so the files are staged into that
+ *   environment through the mount's own capability and the prefix is rewritten
+ *   onto where they landed. It is read-only, so a change goes through the
+ *   environment's own draft and `reload`.
+ *
+ * Staging is per mount and per revision: a `reload` lands as a new revision,
+ * and the next command stages it again before it runs, so a live window always
+ * reads what the environment holds now.
+ */
+import type { WorkspaceMount } from "@4fu/arbor-interfaces";
+/** The environment as the file tools read it: the prefix and the host directory. */
+export interface EnvPaths {
+    prefix: string;
+    directory: string;
+}
+/**
+ * One command as the execution environment sees it: the environment staged
+ * where the command can read it, and the prefix rewritten onto where it landed.
+ */
+export declare function envCommand(workspace: WorkspaceMount, command: string, env: EnvPaths | undefined, revision: string | undefined): Promise<string>;

package/env-stage.js

@@ -0,0 +1,63 @@
+/**
+ * The environment as a command sees it (docs/environment.md#layout).
+ *
+ * A window reads the environment at `/env`, and it lives on the host. Where a
+ * command runs decides how the prefix reaches it:
+ *
+ * - A plain-directory workspace runs the command on the host, so the prefix is
+ *   rewritten onto the directory itself.
+ * - A workspace that owns its execution environment runs the command where the
+ *   host's directory is not visible, so the files are staged into that
+ *   environment through the mount's own capability and the prefix is rewritten
+ *   onto where they landed. It is read-only, so a change goes through the
+ *   environment's own draft and `reload`.
+ *
+ * Staging is per mount and per revision: a `reload` lands as a new revision,
+ * and the next command stages it again before it runs, so a live window always
+ * reads what the environment holds now.
+ */
+import { readFile, readdir } from "node:fs/promises";
+import { join, relative } from "node:path";
+/** What each mount has staged, and for which revision of the environment. */
+const staged = new WeakMap();
+/**
+ * One command as the execution environment sees it: the environment staged
+ * where the command can read it, and the prefix rewritten onto where it landed.
+ */
+export async function envCommand(workspace, command, env, revision) {
+    if (env === undefined || !command.includes(env.prefix))
+        return command;
+    const stage = workspace.stage;
+    // A mount whose `path` is a host path already reaches the directory.
+    if (stage === undefined)
+        return command.split(env.prefix).join(env.directory);
+    const previous = staged.get(workspace);
+    // No revision is no cache: a command then always reads what the environment
+    // holds, rather than what was staged for a revision nobody named.
+    const at = revision !== undefined && previous?.revision === revision
+        ? previous.at
+        : await stage(env.prefix, await envFiles(env.directory));
+    staged.set(workspace, { revision, at });
+    return command.split(env.prefix).join(at);
+}
+/** Every file under the environment's directory, as the text a command reads. */
+async function envFiles(directory) {
+    const files = [];
+    const walk = async (at) => {
+        for (const entry of await readdir(at, { withFileTypes: true }).catch(() => [])) {
+            const path = join(at, entry.name);
+            if (entry.isDirectory()) {
+                await walk(path);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const text = await readFile(path, "utf8").catch(() => null);
+            if (text === null)
+                continue;
+            files.push({ path: relative(directory, path), text });
+        }
+    };
+    await walk(directory);
+    return files;
+}

package/groups/core.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The decision tools: `send`, `end` and `search`
+ * (docs/tools.md#direct-tools, docs/prompting.md#rules-surface-where-they-bite).
+ *
+ * Anything that speaks, ends a window or writes memory is a direct call. The
+ * one guard rule stated up front is `end` with unfinished work, because the
+ * handoff is the cost of the decision to end; every other rule lives in the
+ * refusal the model meets.
+ */
+import type { CallContext, DirectToolSpec, Handoff, ToolCall, ToolGroup, ToolResult } from "@4fu/arbor-interfaces";
+import type { ToolServices } from "../host.ts";
+export declare class CoreToolGroup implements ToolGroup {
+    readonly id = "core";
+    private readonly services;
+    constructor(services: ToolServices);
+    tools(): readonly DirectToolSpec[];
+    modules(): readonly [];
+    call(request: ToolCall, context: CallContext): Promise<ToolResult>;
+    private send;
+    /**
+     * `end` with unfinished work needs a handoff: current topics, progress,
+     * pending items and agreements. The host knows whether work is open; the
+     * tool does not guess.
+     */
+    private end;
+    private search;
+    private notOwned;
+}
+/** The four parts of a handoff, each with its refs. */
+export declare function handoffOf(value: unknown): Handoff | undefined;

package/groups/core.js

@@ -0,0 +1,148 @@
+/**
+ * The decision tools: `send`, `end` and `search`
+ * (docs/tools.md#direct-tools, docs/prompting.md#rules-surface-where-they-bite).
+ *
+ * Anything that speaks, ends a window or writes memory is a direct call. The
+ * one guard rule stated up front is `end` with unfinished work, because the
+ * handoff is the cost of the decision to end; every other rule lives in the
+ * refusal the model meets.
+ */
+import { textOf } from "@4fu/arbor-prompt";
+import { refused, toolSpec } from "../host.js";
+export class CoreToolGroup {
+    id = "core";
+    services;
+    constructor(services) {
+        this.services = services;
+    }
+    tools() {
+        const table = this.services.table;
+        return [
+            toolSpec(table, "send", {
+                to: { type: "string", required: true },
+                content: { type: "string", required: true },
+                reply_to: { type: "ref" },
+                cites: { type: "refs" },
+            }),
+            toolSpec(table, "end", { handoff: { type: "object" } }),
+            toolSpec(table, "search", {
+                query: { type: "string", required: true },
+                scope: { type: "string" },
+            }),
+        ];
+    }
+    modules() {
+        return [];
+    }
+    async call(request, context) {
+        switch (request.name) {
+            case "send":
+                return this.send(request, context.window);
+            case "end":
+                return this.end(request, context.window);
+            case "search":
+                return this.search(request, context.window);
+            default:
+                return this.notOwned(request);
+        }
+    }
+    async send(request, window) {
+        const table = this.services.table;
+        const to = stringArg(request.args, "to");
+        const content = stringArg(request.args, "content");
+        if (to === "")
+            return refused("send.target.empty", table, "send.target");
+        if (content === "")
+            return refused("send.content.empty", table, "send.content");
+        const outcome = await this.services.send(window, {
+            to,
+            content,
+            ...(stringArg(request.args, "reply_to") === "" ? {} : { replyTo: stringArg(request.args, "reply_to") }),
+            ...(refsArg(request.args, "cites").length === 0 ? {} : { cites: refsArg(request.args, "cites") }),
+        });
+        const lines = [textOf(table, "result.sent", { ref: outcome.event })];
+        if (outcome.behind > 0) {
+            lines.push(textOf(table, "result.send.behind", { count: outcome.behind }));
+        }
+        return { callId: request.callId, ok: true, content: lines.join("\n") };
+    }
+    /**
+     * `end` with unfinished work needs a handoff: current topics, progress,
+     * pending items and agreements. The host knows whether work is open; the
+     * tool does not guess.
+     */
+    async end(request, window) {
+        const table = this.services.table;
+        const handoff = handoffOf(request.args.handoff);
+        if (handoff === undefined && (await this.services.hasOpenWork(window))) {
+            return refused("end.handoff.required", table, "end.no_handoff");
+        }
+        const result = await this.services.endWindow(window, handoff);
+        return {
+            ...result,
+            callId: request.callId,
+            content: textOf(table, "result.ended", { window }),
+        };
+    }
+    async search(request, window) {
+        const table = this.services.table;
+        const query = stringArg(request.args, "query");
+        const scope = stringArg(request.args, "scope");
+        const outcome = await this.services.search(window, query, scope === "" ? undefined : scope.split(",").map((part) => part.trim()));
+        const lines = [];
+        for (const hit of outcome.hits) {
+            lines.push(`${hit.ref} ${hit.kind} ${hit.summary}`);
+        }
+        for (const note of outcome.notes) {
+            lines.push(`${note.ref} ${note.title}：${note.summary}`);
+        }
+        for (const live of outcome.windows) {
+            lines.push(`${live.window} ${live.doing}`);
+        }
+        const body = lines.length === 0 ? textOf(table, "result.search.empty") : lines.join("\n");
+        const total = textOf(table, "result.search.total", { total: outcome.total });
+        return { callId: request.callId, ok: true, content: `${body}\n${total}\n${outcome.nextCall}` };
+    }
+    notOwned(request) {
+        return {
+            callId: request.callId,
+            ok: false,
+            content: "",
+            error: {
+                rule: "tool.not_owned",
+                message: textOf(this.services.table, "refused.unknown_tool", { name: request.name }),
+                nextAction: textOf(this.services.table, "next.unknown_tool"),
+            },
+        };
+    }
+}
+/** The four parts of a handoff, each with its refs. */
+export function handoffOf(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const raw = value;
+    const parts = (key) => Array.isArray(raw[key]) ? raw[key].filter((item) => typeof item === "string") : [];
+    const refs = Array.isArray(raw.refs) ? raw.refs.filter((item) => typeof item === "string") : [];
+    const handoff = {
+        topics: parts("topics"),
+        progress: parts("progress"),
+        pending: parts("pending"),
+        agreements: parts("agreements"),
+        refs,
+    };
+    const empty = handoff.topics.length === 0 &&
+        handoff.progress.length === 0 &&
+        handoff.pending.length === 0 &&
+        handoff.agreements.length === 0;
+    return empty ? undefined : handoff;
+}
+function stringArg(args, name) {
+    const value = args[name];
+    return typeof value === "string" ? value : "";
+}
+function refsArg(args, name) {
+    const value = args[name];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}

package/groups/env.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The environment tools: `reload` (docs/tools.md#direct-tools,
+ * docs/environment.md#changing-the-environment).
+ *
+ * Changing the environment is a decision, so it is one direct call. The three
+ * steps a model takes - copy, edit, `reload` - are the model's; the host's are
+ * validation, the revision check, replacing the item as a whole, recording an
+ * environment revision and broadcasting the delta to every live window.
+ *
+ * Every rule lives in the refusal the model meets, and every refusal names the
+ * section of the built-in skill that covers it, so the loop closes without a
+ * rule written into the prompt.
+ */
+import type { CallContext, DirectToolSpec, ToolCall, ToolGroup, ToolResult } from "@4fu/arbor-interfaces";
+import type { ToolServices } from "../host.ts";
+export declare class EnvToolGroup implements ToolGroup {
+    readonly id = "env";
+    private readonly services;
+    constructor(services: ToolServices);
+    tools(): readonly DirectToolSpec[];
+    modules(): readonly [];
+    call(request: ToolCall, context: CallContext): Promise<ToolResult>;
+    /**
+     * `reload(install?, remove?)`. `install` names drafts in the window's
+     * workspace; `remove` names items. Both are optional, but not both empty.
+     */
+    private reload;
+    /**
+     * One draft: its kind is read off the workspace - a directory with a SKILL.md
+     * is a skill, one with a `svc.json` a service, a `.json` file an MCP server
+     * or the settings - and its name is the directory's or the file's.
+     */
+    private draftOf;
+    /** One file of a draft, through the mount's own capability or the host path. */
+    private readDraft;
+    /** One refusal about the call itself, before the service layer saw it. */
+    private refusal;
+    /**
+     * One refusal the service layer returned, in the core's error shape. It names
+     * the rule and the section of the built-in skill that covers it.
+     */
+    private refusalOf;
+    private absent;
+    private notOwned;
+}

package/groups/env.js

@@ -0,0 +1,190 @@
+/**
+ * The environment tools: `reload` (docs/tools.md#direct-tools,
+ * docs/environment.md#changing-the-environment).
+ *
+ * Changing the environment is a decision, so it is one direct call. The three
+ * steps a model takes - copy, edit, `reload` - are the model's; the host's are
+ * validation, the revision check, replacing the item as a whole, recording an
+ * environment revision and broadcasting the delta to every live window.
+ *
+ * Every rule lives in the refusal the model meets, and every refusal names the
+ * section of the built-in skill that covers it, so the loop closes without a
+ * rule written into the prompt.
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { textOf } from "@4fu/arbor-prompt";
+import { refused, toolSpec } from "../host.js";
+export class EnvToolGroup {
+    id = "env";
+    services;
+    constructor(services) {
+        this.services = services;
+    }
+    tools() {
+        if (this.services.environment === undefined)
+            return [];
+        const table = this.services.table;
+        return [
+            toolSpec(table, "reload", {
+                install: { type: "array" },
+                remove: { type: "array" },
+            }),
+        ];
+    }
+    modules() {
+        return [];
+    }
+    async call(request, context) {
+        if (this.services.environment === undefined)
+            return this.absent();
+        switch (request.name) {
+            case "reload":
+                return this.reload(request, context.window, context.workspace);
+            default:
+                return this.notOwned(request);
+        }
+    }
+    /**
+     * `reload(install?, remove?)`. `install` names drafts in the window's
+     * workspace; `remove` names items. Both are optional, but not both empty.
+     */
+    async reload(request, window, workspace) {
+        const table = this.services.table;
+        const install = listArg(request.args, "install");
+        const remove = stringsArg(request.args, "remove");
+        if (install.length === 0 && remove.length === 0)
+            return this.refusal(request, "empty");
+        if (workspace === undefined && install.length > 0) {
+            return this.refusal(request, "workspace");
+        }
+        const drafts = [];
+        for (const entry of install) {
+            const draft = await this.draftOf(entry, workspace);
+            if (typeof draft === "string")
+                return this.refusal(request, "draft", { path: pathOf(entry) });
+            drafts.push(draft.draft);
+        }
+        let outcome;
+        try {
+            outcome = await this.services.reload(window, { drafts, remove: remove });
+        }
+        catch (error) {
+            return this.refusalOf(request, error);
+        }
+        const lines = [textOf(table, "result.env.revision", { revision: outcome.revision })];
+        for (const change of outcome.changes) {
+            lines.push(textOf(table, "result.env.change", {
+                change: change.change === "added" ? "+" : change.change === "removed" ? "-" : "~",
+                kind: change.item.kind,
+                name: change.item.name,
+                description: change.item.description,
+            }));
+        }
+        if (outcome.delivered > 0) {
+            lines.push(textOf(table, "result.env.delivered", { count: outcome.delivered }));
+        }
+        return { callId: request.callId, ok: true, content: lines.join("\n") };
+    }
+    /**
+     * One draft: its kind is read off the workspace - a directory with a SKILL.md
+     * is a skill, one with a `svc.json` a service, a `.json` file an MCP server
+     * or the settings - and its name is the directory's or the file's.
+     */
+    async draftOf(entry, workspace) {
+        const path = typeof entry === "string" ? entry : stringField(entry, "path");
+        if (path === "")
+            return "env.empty";
+        const copiedFrom = typeof entry === "string" ? undefined : numberField(entry, "copiedFrom");
+        const name = baseName(path);
+        const draft = { name, path, ...(copiedFrom === undefined ? {} : { copiedFrom }) };
+        // The kind is read off the workspace: a directory with a SKILL.md is a skill,
+        // one with a `svc.json` a service, one with `<name>.json` an MCP server that
+        // brought its own code, and a `.json` file an MCP server or the settings.
+        const skill = await this.readDraft(workspace, join(path, "SKILL.md"));
+        if (skill !== null)
+            return { draft: { ...draft, kind: "skill" } };
+        const service = await this.readDraft(workspace, join(path, "svc.json"));
+        if (service !== null)
+            return { draft: { ...draft, kind: "service" } };
+        if (path.endsWith(".json")) {
+            if (name === "settings" && (await this.readDraft(workspace, path)) === null)
+                return "env.draft";
+            const kind = name === "settings" ? "settings" : "mcp";
+            return { draft: { ...draft, kind } };
+        }
+        const server = await this.readDraft(workspace, join(path, `${name}.json`));
+        if (server !== null)
+            return { draft: { ...draft, kind: "mcp" } };
+        return "env.draft";
+    }
+    /** One file of a draft, through the mount's own capability or the host path. */
+    async readDraft(workspace, path) {
+        if (workspace.readFile !== undefined)
+            return workspace.readFile(path).catch(() => null);
+        return readFile(join(workspace.path, path), "utf8").catch(() => null);
+    }
+    /** One refusal about the call itself, before the service layer saw it. */
+    refusal(_request, key, args = {}) {
+        return refused(`env.${key}`, this.services.table, `env.${key}`, args);
+    }
+    /**
+     * One refusal the service layer returned, in the core's error shape. It names
+     * the rule and the section of the built-in skill that covers it.
+     */
+    refusalOf(request, error) {
+        const info = error;
+        const next = info.nextAction ?? textOf(this.services.table, "next.env.draft");
+        return {
+            callId: request.callId,
+            ok: false,
+            content: "",
+            error: {
+                rule: info.rule ?? "env.draft",
+                message: info.message ?? String(error),
+                nextAction: `${next}`,
+            },
+        };
+    }
+    absent() {
+        return refused("env.absent", this.services.table, "env.absent");
+    }
+    notOwned(request) {
+        return refused("tool.not_owned", this.services.table, "unknown_tool", { name: request.name });
+    }
+}
+/** The last segment of a draft's path, which is the item's name. */
+function baseName(path) {
+    const clean = path.replace(/\/+$/, "");
+    const name = clean.slice(clean.lastIndexOf("/") + 1);
+    return name.endsWith(".json") ? name.slice(0, -".json".length) : name;
+}
+/** What the model gave for one draft, as a path. */
+function pathOf(entry) {
+    if (typeof entry === "string")
+        return entry;
+    return stringField(entry, "path");
+}
+function listArg(args, name) {
+    const value = args[name];
+    return Array.isArray(value) ? value : value === undefined ? [] : [value];
+}
+/** One list of strings, as `remove` names items. */
+function stringsArg(args, name) {
+    const value = args[name];
+    if (!Array.isArray(value))
+        return value === undefined ? [] : [String(value)];
+    return value.filter((item) => typeof item === "string");
+}
+function stringField(value, key) {
+    if (typeof value !== "object" || value === null)
+        return "";
+    const found = value[key];
+    return typeof found === "string" ? found : "";
+}
+function numberField(value, key) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const found = value[key];
+    return typeof found === "number" && Number.isFinite(found) ? found : undefined;
+}

package/groups/files.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The window's workspace: `bash`, `bash_output`, `bash_stop`, `read`, `write`
+ * and `edit` (docs/tools.md#direct-tools, docs/workspaces.md).
+ *
+ * A plain command is a direct call, a chain is a script. One behaviour per
+ * tool: a command that outlives `bash`'s wait window is followed with
+ * `bash_output` and stopped with `bash_stop`.
+ *
+ * Everything reaches the workspace through the `Workspace` interface, never the
+ * host filesystem directly: a capability the implementation owns - `exec`,
+ * `readFile`, `writeFile` - is used when it is present, and the host path in
+ * `mount.path` when it is not. An implementation that owns its execution
+ * environment has a `path` that is not a host path and an `exec` that is the
+ * only way to run a command there; a plain-directory workspace owns no
+ * execution environment, so the caller runs the command itself. Either way a
+ * command that outlives `bash`'s wait window is followed with `bash_output` and
+ * stopped with `bash_stop`, through the host's own process path.
+ */
+import type { CallContext, DirectToolSpec, ToolCall, ToolGroup, ToolResult } from "@4fu/arbor-interfaces";
+export declare class FileToolGroup implements ToolGroup {
+    readonly id = "files";
+    private readonly services;
+    private readonly jobs;
+    private nextJob;
+    constructor(services: import("../host.ts").ToolServices);
+    tools(): readonly DirectToolSpec[];
+    modules(): readonly [];
+    call(request: ToolCall, context: CallContext): Promise<ToolResult>;
+    /** The window's own directory, created on first use. */
+    private mount;
+    /**
+     * The environment, at the path a window reads it at. It is mounted read-only,
+     * so a window without a workspace still reads `/env/skills/<name>/SKILL.md`
+     * (docs/environment.md#layout), and a write to it is refused.
+     */
+    private envPath;
+    /** Record which revision of an item a window read, for `reload`'s check. */
+    private noteEnvRead;
+    private bash;
+    /** One command that ran to its end: what it wrote, and whether it succeeded. */
+    private ran;
+    private bashOutput;
+    private bashStop;
+    private read;
+    private write;
+    private edit;
+    /**
+     * One file's text: the mount's own capability when it has one, the host path
+     * when it does not. `null` means the file is not there.
+     */
+    private readText;
+    /** Write one file, creating its directory. */
+    private writeText;
+    private start;
+    private absent;
+    private jobMissing;
+    private missing;
+    private noMatch;
+    /** The environment is mounted read-only, so nothing there is written. */
+    private readonly;
+    private refusal;
+    private notOwned;
+}