@4fu/arbor-workspace-ovnfs 0.0.0-stage → 2026.1107.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 4fuu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,196 @@
-# Temporary Holding Version
+# arbor
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+arbor is a framework for an agent without sessions: many context windows run
+at once over one shared record, so work moves in parallel, replies come fast,
+and every window can find everything that was ever done.
+
+A deployment composes the pieces it wants and registers plugins for the domains
+it serves. The framework guarantees what an agent cannot guarantee for itself -
+the record, isolation, exactly-once effects, the checks, dispatch - and leaves
+everything that takes judgment, such as git, merges and conflicts, to the agent.
+
+## Core ideas
+
+- **No sessions to manage.** Work runs in disposable context windows. Any
+  number run at the same time; none of them owns anything, and a window that
+  ends loses nothing. The model looks up what it needs instead of carrying it.
+- **One record, shared live.** Every input, tool call, result, send and note
+  revision goes into one journal and is visible to every window as
+  soon as it is written. Records never merge and are never lost.
+- **Dispatch by a judge.** A judge (Jev by default, replaceable) decides which
+  live window takes a new input, or opens a new one. There is no router session
+  and no main line.
+- **Current without locks.** Windows run in parallel. New events on a
+  conversation a window is in are steered into it as they arrive; only a note
+  write is checked against the revision the window read.
+- **Mechanisms in the framework, policy in the agent.** The framework
+  guarantees what an agent cannot guarantee for itself - the record, isolation,
+  exactly-once effects, the checks, dispatch. Everything that takes judgment,
+  such as git, merges and conflicts, is the agent's.
+- **A shared workspace with per-window checkouts.** The default workspace is
+  ovnfs: one shared folder every window reads, and a window opens its own
+  copy-on-write checkout of the project it needs, works there and merges back
+  with `apply`. It falls back to a plain directory per window when ovnfs is not
+  installed. It is not a sandbox: ovnfs isolates files, not processes.
+- **A self-changing environment.** The model adds and changes skills, MCP
+  servers and resident services itself; a `reload` validates the change and
+  broadcasts it to every live window as a delta of names and descriptions.
+- **Minimal limits.** The framework sets no policy. Permissions, privacy
+  review, budgets and approvals belong to deployments built on it, through
+  hooks.
+- **Direct tools plus code mode.** Decisions are direct tools; everything else
+  is a module called from `code_exec`. There is no CLI.
+- **Every module is replaceable.** The agent backend (pi by default), the
+  journal, notes, workspaces, the judge, channels and the rest are interfaces
+  ([docs/architecture.md](docs/architecture.md#interfaces)).
+
+## Install
+
+Node 24 or newer. Every package is published separately, so a deployment
+installs the core and the defaults it wants:
+
+```sh
+npm install @4fu/arbor-core @4fu/arbor-journal-sqlite @4fu/arbor-notes-sqlite \
+  @4fu/arbor-environment-dir @4fu/arbor-supervisor-process @4fu/arbor-agent-pi \
+  @4fu/arbor-workspace-dir
+```
+
+`@4fu/arbor-plugin-http` is optional; it is the example plugin below.
+`@4fu/arbor-segmenter-jieba` is an optional peer of the lexical package, and
+`@4fu/arbor-search-zvec` an optional peer of the journal: absent either one, the
+journal searches lexically and nothing else changes.
+
+## A minimal host
+
+The smallest host needs a journal and a backend. Adding the defaults and one
+plugin is what a deployment usually starts from:
+
+```js
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Arbor } from "@4fu/arbor-core";
+import { DirectoryEnvironment } from "@4fu/arbor-environment-dir";
+import { SqliteJournal } from "@4fu/arbor-journal-sqlite";
+import { SqliteNoteStore } from "@4fu/arbor-notes-sqlite";
+import { ProcessSupervisor } from "@4fu/arbor-supervisor-process";
+import { DirectoryWorkspace } from "@4fu/arbor-workspace-dir";
+import { PiAgentBackend } from "@4fu/arbor-agent-pi";
+import { HttpChannel, httpPlugin } from "@4fu/arbor-plugin-http";
+
+const root = await mkdtemp(join(tmpdir(), "arbor-"));
+
+// Every module below is a default implementation of an interface. Replace any
+// one by passing your own; the host does not change.
+const journal = new SqliteJournal({ path: join(root, "journal.sqlite") });
+const notes = new SqliteNoteStore({ path: join(root, "notes.sqlite"), journal });
+const supervisor = new ProcessSupervisor({ root: join(root, "services") });
+const environment = new DirectoryEnvironment({ root: join(root, "env"), supervisor });
+const workspace = new DirectoryWorkspace({ root: join(root, "workspaces") });
+
+// A plugin adds; it never patches the core. This one is a chat channel: a
+// webhook in, a window's sends out, and a page that drives the whole host.
+let arbor;
+const channel = new HttpChannel({ host: "127.0.0.1", port: 8787, board: () => arbor.boardLines() });
+arbor = new Arbor({
+  journal,
+  notes,
+  backend: new PiAgentBackend(),
+  workspace,
+  environment,
+  supervisor,
+  plugins: [httpPlugin({ channel })],
+});
+
+await arbor.start();
+await channel.listen();
+```
+
+`arbor.open(task)` dispatches one task, and the journal is where everything that
+happened can be read back ([docs/journal.md](docs/journal.md)). The workspace a
+window gets, and how a continuation keeps working in it, are in
+[docs/workspaces.md](docs/workspaces.md).
+
+## Packages
+
+| Package | What it is |
+| --- | --- |
+| [`@4fu/arbor-interfaces`](packages/interfaces) | every replaceable interface, plus the core's own shapes. Types only. |
+| [`@4fu/arbor-errors`](packages/errors) | the error shape every refusal uses: the rule and the next action |
+| [`@4fu/arbor-prompt`](packages/prompt) | typed blocks, the one deterministic renderer and the replaceable text table |
+| [`@4fu/arbor-tools`](packages/tools) | the entry points: direct tools, code mode modules, the host API |
+| [`@4fu/arbor-journal-sqlite`](packages/journal-sqlite) | the default `Journal` and `BlobStore` on SQLite |
+| [`@4fu/arbor-notes-sqlite`](packages/notes-sqlite) | the default `NoteStore` on SQLite, beside the journal |
+| [`@4fu/arbor-segmenter-jieba`](packages/segmenter-jieba) | the default `Segmenter`: jieba's dictionary segmentation for the word index, optional |
+| [`@4fu/arbor-lexical`](packages/lexical) | the lexical search the journal and notes share: word segmentation, the FTS5 helpers and the merge order |
+| [`@4fu/arbor-search-zvec`](packages/search-zvec) | the optional semantic channel: event text embedded and searched by meaning with zvec |
+| [`@4fu/arbor-workspace-dir`](packages/workspace-dir) | the fallback `Workspace`: one directory per window, with a continuation working in its predecessor's directory in place |
+| [`@4fu/arbor-workspace-ovnfs`](packages/workspace-ovnfs) | the default `Workspace` when ovnfs is installed: one shared folder, per-window copy-on-write checkouts the model opens and applies back |
+| [`@4fu/arbor-environment-dir`](packages/environment-dir) | the default `Environment`: one `/env` directory, a revision per item, validation and deltas |
+| [`@4fu/arbor-supervisor-process`](packages/supervisor-process) | the default `Supervisor`: one host process per service, restart with backoff, logs |
+| [`@4fu/arbor-judge-jev`](packages/judge-jev) | the default `Judge`: Jev, TypeSafe AI's System One classifier, answering the dispatch decisions |
+| [`@4fu/arbor-agent-pi`](packages/agent-pi) | the default `AgentBackend`: pi-agent-core in process |
+| [`@4fu/arbor-plugin-http`](packages/plugin-http) | the HTTP test channel: a webhook in, sends out, a page that drives the whole host |
+| [`@4fu/arbor-core`](packages/core) | the service layer: one implementation of every operation - the window lifecycle, dispatch, coordination, the board, notes access, workspaces, effects and schedules |
+
+### Defaults are examples
+
+Every default above is a reference implementation of its interface, written to
+be read and replaced. A real deployment is expected to swap out the ones that do
+not fit: the SQLite journal and notes, the directory workspace, the process
+supervisor, the environment directory, the HTTP test plugin and the Jev judge
+are all examples of what an interface can be satisfied by, not commitments.
+What a deployment keeps is its own choice, and the interfaces are the contract
+([docs/architecture.md](docs/architecture.md#interfaces)).
+
+Each package's own documentation holds the limits of that default, so a
+deployment can see what it would be taking on before it adopts one.
+
+## Documents
+
+| Page | Contents |
+| --- | --- |
+| [docs/overview.md](docs/overview.md) | goals, concepts, principles, routes considered |
+| [docs/architecture.md](docs/architecture.md) | layers, interfaces, stack, models, plugins, hooks, data placement |
+| [docs/journal.md](docs/journal.md) | events and their order, targets, watermarks, external ids, refs, tracing, media, redaction |
+| [docs/windows.md](docs/windows.md) | window lifecycle, prompt layout, reminders, continuation |
+| [docs/dispatch.md](docs/dispatch.md) | task sources, judge decisions, insertion timing, backpressure, scheduled tasks |
+| [docs/coordination.md](docs/coordination.md) | the board, expectations, deliveries and broadcasts, staying current, effects |
+| [docs/environment.md](docs/environment.md) | skills, MCP servers and services: using, changing, reload, built-in skills, deltas |
+| [docs/memory.md](docs/memory.md) | notes, the active set, anchors, links |
+| [docs/workspaces.md](docs/workspaces.md) | the shared folder and per-window checkouts: isolation, continuity, what the agent does |
+| [docs/tools.md](docs/tools.md) | direct tools and code mode modules |
+| [docs/prompting.md](docs/prompting.md) | how every model-facing text is written: layers, notes, deliveries, errors, judge questions, terms |
+| [docs/release.md](docs/release.md) | calendar versioning, the manual release steps, how a package is published |
+
+## Repository layout
+
+`pnpm check` typechecks and tests every package on its TypeScript sources.
+`pnpm build` emits the `dist` publishing needs, and `pnpm pack` shows what each
+tarball would contain ([docs/release.md](docs/release.md)).
+
+| Path | Layer |
+| --- | --- |
+| `packages/interfaces` | the interfaces layer: every replaceable interface, plus the core's own shapes. Types only. |
+| `packages/errors` | the error shape every refusal uses: the rule and the next action |
+| `packages/journal-sqlite` | the default `Journal` and `BlobStore` on SQLite |
+| `packages/segmenter-jieba` | the default `Segmenter`: jieba's dictionary segmentation for the word index, optional |
+| `packages/lexical` | the lexical search the journal and notes share: word segmentation, the FTS5 helpers and the merge order |
+| `packages/notes-sqlite` | the default `NoteStore` on SQLite, beside the journal |
+| `packages/judge-jev` | the default `Judge`: Jev, TypeSafe AI's System One classifier, answering the dispatch decisions |
+| `packages/workspace-dir` | the default `Workspace`: one directory per window, with a continuation working in its predecessor's directory in place, and the lookup of another window's directory it contributes to the catalog |
+| `packages/environment-dir` | the default `Environment`: one `/env` directory, a revision per item, validation and deltas |
+| `packages/supervisor-process` | the default `Supervisor`: one host process per service, restart with backoff, logs |
+| `packages/plugin-http` | the HTTP test channel: a webhook in, sends out, a page that drives the whole host |
+| `packages/prompt` | typed blocks, the one deterministic renderer and the replaceable text table |
+| `packages/agent-pi` | the default `AgentBackend`: pi-agent-core in process |
+| `packages/tools` | the entry points: direct tools, code mode modules, the host API |
+| `packages/core` | the service layer: one implementation of every operation - the window lifecycle, dispatch, coordination, the board, notes access, workspaces, effects, schedules and the snapshot epochs |
+
+`mise.toml` pins the toolchain - Node and pnpm - installed under
+`~/.local/share/mise`, and `.agents/setup` prepares a machine from it. A machine
+without mise is expected to carry Node 24 or newer and pnpm 12 already.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

package/cli.d.ts

@@ -0,0 +1,114 @@
+/**
+ * A thin wrapper over the `ovnfs` binary (docs/workspaces.md).
+ *
+ * Every operation is one `ovnfs ctl OP 'JSON'` call, which sends the admin
+ * request and prints the raw reply as JSON on stdout. A reply is parsed whether
+ * or not the process exits zero: `apply` reports conflicts in its reply, and a
+ * daemon error answers with a non-zero exit and empty stdout. The daemon is
+ * started once, by `start`, before anything else is asked of it.
+ *
+ * The binary is pinned at v0.1.1; `version` reads what is installed so the host
+ * can warn on a mismatch without failing.
+ */
+/** The running daemon, from `ovnfs --json start`. */
+export interface OvnfsStatus {
+    version: number;
+    pid: number;
+    proto: string;
+    port: number;
+    mount: string;
+    state: string;
+    socket: string;
+    checkouts: number;
+}
+/** One checkout, as `ovnfs ctl ls` lists it. */
+export interface OvnfsCheckoutInfo {
+    name: string;
+    path: string;
+    source: string;
+    base: string;
+    git: boolean;
+    dirty: boolean;
+}
+/** `ovnfs ctl ls` reply. */
+export interface OvnfsLsReply {
+    checkouts: OvnfsCheckoutInfo[];
+    snapshots: {
+        id: string;
+        checkout: string;
+    }[];
+}
+/** `ovnfs ctl new` arguments. */
+export interface OvnfsNewArgs {
+    dir?: string;
+    name?: string;
+}
+/** `ovnfs ctl new` reply. */
+export interface OvnfsNewReply {
+    checkout: OvnfsCheckoutInfo;
+    warnings: string[];
+}
+/** One changed path, as `diff` and `apply` report it. */
+export interface OvnfsChange {
+    path: string;
+    status: string;
+}
+/** `ovnfs ctl diff` reply. */
+export interface OvnfsDiffReply {
+    from: string;
+    changes: OvnfsChange[];
+    patch?: string;
+}
+/** `ovnfs ctl apply` arguments. */
+export interface OvnfsApplyArgs {
+    checkout: string;
+    branch?: string;
+    dry_run?: boolean;
+}
+/** One path apply could not settle. */
+export interface OvnfsConflict {
+    path: string;
+    reason: string;
+    markers: boolean;
+}
+/** `ovnfs ctl apply` reply. */
+export interface OvnfsApplyReply {
+    snapshot: {
+        id: string;
+        checkout: string;
+    };
+    source: string;
+    applied: OvnfsChange[];
+    merged: string[];
+    conflicts: OvnfsConflict[];
+    branch?: string;
+    commit?: string;
+}
+export declare class OvnfsCli {
+    private readonly bin;
+    private readonly state;
+    private readonly mount;
+    constructor(bin: string, state: string, mount: string);
+    /** The build this binary reports, for the pinned-version check. */
+    version(): Promise<string>;
+    /** Make sure the daemon runs and answer its status. */
+    start(): Promise<OvnfsStatus>;
+    /** Every live checkout, with its dirty flag. */
+    ls(): Promise<OvnfsLsReply>;
+    /** Open a checkout on a folder. */
+    open(args: OvnfsNewArgs): Promise<OvnfsNewReply>;
+    /** A checkout's changed source paths since its base. */
+    diff(checkout: string): Promise<OvnfsDiffReply>;
+    /** Merge a checkout's changes back into its folder. */
+    apply(args: OvnfsApplyArgs): Promise<OvnfsApplyReply>;
+    /** Remove a checkout; its snapshots stay. */
+    rm(checkout: string): Promise<void>;
+    private global;
+    private text;
+    /**
+     * One operation that answers with JSON. A reply is read from stdout whether
+     * or not the process exited zero, because `ctl` prints the reply and reports
+     * a daemon error on stderr with a non-zero exit and no stdout.
+     */
+    private json;
+}

package/cli.js

@@ -0,0 +1,89 @@
+/**
+ * A thin wrapper over the `ovnfs` binary (docs/workspaces.md).
+ *
+ * Every operation is one `ovnfs ctl OP 'JSON'` call, which sends the admin
+ * request and prints the raw reply as JSON on stdout. A reply is parsed whether
+ * or not the process exits zero: `apply` reports conflicts in its reply, and a
+ * daemon error answers with a non-zero exit and empty stdout. The daemon is
+ * started once, by `start`, before anything else is asked of it.
+ *
+ * The binary is pinned at v0.1.1; `version` reads what is installed so the host
+ * can warn on a mismatch without failing.
+ */
+import { execFile } from "node:child_process";
+/** How much one reply may hold before the wrapper refuses it. */
+const MAX_BUFFER = 64 * 1024 * 1024;
+export class OvnfsCli {
+    bin;
+    state;
+    mount;
+    constructor(bin, state, mount) {
+        this.bin = bin;
+        this.state = state;
+        this.mount = mount;
+    }
+    /** The build this binary reports, for the pinned-version check. */
+    version() {
+        return this.text(["version"]);
+    }
+    /** Make sure the daemon runs and answer its status. */
+    start() {
+        return this.json(["--json", "start"]);
+    }
+    /** Every live checkout, with its dirty flag. */
+    ls() {
+        return this.json(["ctl", "ls", "{}"]);
+    }
+    /** Open a checkout on a folder. */
+    open(args) {
+        return this.json(["ctl", "new", JSON.stringify(args)]);
+    }
+    /** A checkout's changed source paths since its base. */
+    diff(checkout) {
+        return this.json(["ctl", "diff", JSON.stringify({ checkout })]);
+    }
+    /** Merge a checkout's changes back into its folder. */
+    apply(args) {
+        return this.json(["ctl", "apply", JSON.stringify(args)]);
+    }
+    /** Remove a checkout; its snapshots stay. */
+    rm(checkout) {
+        return this.json(["ctl", "rm", JSON.stringify({ checkout })]).then(() => undefined);
+    }
+    global(args) {
+        return ["--state", this.state, "--mount", this.mount, ...args];
+    }
+    text(args) {
+        return new Promise((resolve, reject) => {
+            execFile(this.bin, this.global(args), { maxBuffer: MAX_BUFFER }, (error, stdout, stderr) => {
+                if (error !== null) {
+                    reject(new Error((stderr || error.message).trim()));
+                    return;
+                }
+                resolve(stdout.trim());
+            });
+        });
+    }
+    /**
+     * One operation that answers with JSON. A reply is read from stdout whether
+     * or not the process exited zero, because `ctl` prints the reply and reports
+     * a daemon error on stderr with a non-zero exit and no stdout.
+     */
+    json(args) {
+        return new Promise((resolve, reject) => {
+            execFile(this.bin, this.global(args), { maxBuffer: MAX_BUFFER }, (error, stdout, stderr) => {
+                const body = stdout.trim();
+                if (body === "") {
+                    reject(new Error((stderr || error?.message || "ovnfs: no reply").trim()));
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch {
+                    reject(new Error(`ovnfs: reply was not JSON: ${body.slice(0, 200)}`));
+                }
+            });
+        });
+    }
+}

package/groups.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The module functions the ovnfs workspace contributes (docs/workspaces.md).
+ *
+ * `checkout`, `list`, `diff`, `apply`, `rm` and `path` give the model the ovnfs
+ * method without the CLI: open a checkout of a project subfolder, see its
+ * changes, merge them back, remove it. The plain CLI works just as well - a
+ * command run in `bash` reaches the same daemon - and a checkout opened or
+ * applied through here is recorded in the journal, linked to the window.
+ *
+ * Every result and refusal is one text-table entry naming the rule and the next
+ * action. These functions live in the `workspace` module beside the core's
+ * `grep`, `find` and `ls`.
+ */
+import type { CallContext, ModuleSpec, TextTable, ToolCall, ToolGroup, ToolResult } from "@4fu/arbor-interfaces";
+import type { OvnfsWorkspace } from "./ovnfs.ts";
+export declare class OvnfsWorkspaceGroup implements ToolGroup {
+    readonly id = "workspace.ovnfs";
+    private readonly workspace;
+    private readonly table;
+    constructor(workspace: OvnfsWorkspace, table: TextTable);
+    tools(): readonly [];
+    modules(): readonly ModuleSpec[];
+    call(request: ToolCall, context: CallContext): Promise<ToolResult>;
+    private checkout;
+    private list;
+    private diff;
+    private apply;
+    private rm;
+    private path;
+    private ok;
+    private refusal;
+    private notOwned;
+}

package/groups.js

@@ -0,0 +1,211 @@
+/**
+ * The module functions the ovnfs workspace contributes (docs/workspaces.md).
+ *
+ * `checkout`, `list`, `diff`, `apply`, `rm` and `path` give the model the ovnfs
+ * method without the CLI: open a checkout of a project subfolder, see its
+ * changes, merge them back, remove it. The plain CLI works just as well - a
+ * command run in `bash` reaches the same daemon - and a checkout opened or
+ * applied through here is recorded in the journal, linked to the window.
+ *
+ * Every result and refusal is one text-table entry naming the rule and the next
+ * action. These functions live in the `workspace` module beside the core's
+ * `grep`, `find` and `ls`.
+ */
+import { textOf } from "@4fu/arbor-prompt";
+export class OvnfsWorkspaceGroup {
+    id = "workspace.ovnfs";
+    workspace;
+    table;
+    constructor(workspace, table) {
+        this.workspace = workspace;
+        this.table = table;
+    }
+    tools() {
+        return [];
+    }
+    modules() {
+        return [
+            {
+                name: "workspace",
+                description: textOf(this.table, "module.workspace"),
+                functions: [
+                    {
+                        name: "workspace.checkout",
+                        signature: "workspace.checkout(name, dir?)",
+                        description: textOf(this.table, "function.workspace.checkout"),
+                    },
+                    {
+                        name: "workspace.list",
+                        signature: "workspace.list(window?)",
+                        description: textOf(this.table, "function.workspace.list"),
+                    },
+                    {
+                        name: "workspace.diff",
+                        signature: "workspace.diff(name)",
+                        description: textOf(this.table, "function.workspace.diff"),
+                    },
+                    {
+                        name: "workspace.apply",
+                        signature: "workspace.apply(name, branch?)",
+                        description: textOf(this.table, "function.workspace.apply"),
+                    },
+                    {
+                        name: "workspace.rm",
+                        signature: "workspace.rm(name)",
+                        description: textOf(this.table, "function.workspace.rm"),
+                    },
+                    {
+                        name: "workspace.path",
+                        signature: "workspace.path(window)",
+                        description: textOf(this.table, "function.workspace.path"),
+                    },
+                ],
+            },
+        ];
+    }
+    async call(request, context) {
+        switch (request.name) {
+            case "workspace.checkout":
+                return this.checkout(request, context);
+            case "workspace.list":
+                return this.list(request, context);
+            case "workspace.diff":
+                return this.diff(request);
+            case "workspace.apply":
+                return this.apply(request, context);
+            case "workspace.rm":
+                return this.rm(request);
+            case "workspace.path":
+                return this.path(request);
+            default:
+                return this.notOwned(request);
+        }
+    }
+    async checkout(request, context) {
+        const name = stringArg(request.args, "name");
+        // ovnfs accepts only lowercase letters, digits, ".", "_" and "-" in a name.
+        if (!name.startsWith(`${context.window}-`) || !/^[a-z0-9._-]+$/.test(name)) {
+            return this.refusal(request, "refused.workspace.name", { name });
+        }
+        const dir = stringArg(request.args, "dir");
+        try {
+            const path = await this.workspace.openCheckout(context.window, name, dir);
+            return this.ok(request, textOf(this.table, "result.workspace.checkout", { name, path }));
+        }
+        catch (error) {
+            return this.refusal(request, "refused.workspace.cli", { message: messageOf(error) });
+        }
+    }
+    async list(request, context) {
+        const window = windowArg(request.args.window) ?? context.window;
+        const checkouts = await this.workspace.checkouts(window);
+        if (checkouts.length === 0) {
+            return this.ok(request, textOf(this.table, "result.workspace.list.empty", { window }));
+        }
+        const lines = checkouts
+            .map((one) => textOf(this.table, "result.workspace.list.line", {
+            name: one.name,
+            dirty: one.dirty ? textOf(this.table, "result.workspace.list.dirty") : "",
+            path: one.path,
+        }))
+            .join("\n");
+        return this.ok(request, textOf(this.table, "result.workspace.list", { window, lines }));
+    }
+    async diff(request) {
+        const name = stringArg(request.args, "name");
+        try {
+            const reply = await this.workspace.diffCheckout(name);
+            if (reply.changes.length === 0) {
+                return this.ok(request, textOf(this.table, "result.workspace.diff.empty", { name }));
+            }
+            const changes = reply.changes.map((change) => `${change.status} ${change.path}`).join("\n");
+            return this.ok(request, textOf(this.table, "result.workspace.diff", { name, changes }));
+        }
+        catch (error) {
+            return this.refusal(request, "refused.workspace.cli", { message: messageOf(error) });
+        }
+    }
+    async apply(request, context) {
+        const name = stringArg(request.args, "name");
+        const branch = stringArg(request.args, "branch") || undefined;
+        try {
+            const reply = await this.workspace.applyCheckout(context.window, name, branch);
+            if (reply.conflicts.length > 0) {
+                const conflicts = reply.conflicts
+                    .map((conflict) => `${conflict.path}（${conflict.reason}）`)
+                    .join("\n");
+                return this.ok(request, textOf(this.table, "result.workspace.conflict", { name, conflicts }));
+            }
+            if (branch !== undefined) {
+                return this.ok(request, textOf(this.table, "result.workspace.apply.branch", { name, branch, commit: reply.commit ?? "" }));
+            }
+            return this.ok(request, textOf(this.table, "result.workspace.apply", {
+                name,
+                applied: reply.applied.length,
+                merged: reply.merged.length,
+            }));
+        }
+        catch (error) {
+            return this.refusal(request, "refused.workspace.cli", { message: messageOf(error) });
+        }
+    }
+    async rm(request) {
+        const name = stringArg(request.args, "name");
+        try {
+            await this.workspace.removeCheckout(name);
+            return this.ok(request, textOf(this.table, "result.workspace.rm", { name }));
+        }
+        catch (error) {
+            return this.refusal(request, "refused.workspace.cli", { message: messageOf(error) });
+        }
+    }
+    async path(request) {
+        const window = windowArg(request.args.window) ?? "c0";
+        const checkouts = await this.workspace.checkouts(window);
+        if (checkouts.length === 0) {
+            return this.ok(request, textOf(this.table, "result.workspace.path.empty", { window }));
+        }
+        const lines = checkouts.map((one) => `${one.name} ${one.path}`).join("\n");
+        return this.ok(request, textOf(this.table, "result.workspace.path", { window, lines }));
+    }
+    ok(request, content) {
+        return { callId: request.callId, ok: true, content };
+    }
+    refusal(request, key, args) {
+        return {
+            callId: request.callId,
+            ok: false,
+            content: "",
+            error: {
+                rule: key,
+                message: textOf(this.table, key, args, key),
+                nextAction: textOf(this.table, key.replace("refused.", "next."), args) || undefined,
+            },
+        };
+    }
+    notOwned(request) {
+        return {
+            callId: request.callId,
+            ok: false,
+            content: "",
+            error: {
+                rule: "module.function.unknown",
+                message: textOf(this.table, "refused.unknown_function", {
+                    module: "workspace",
+                    name: request.name,
+                }),
+                nextAction: textOf(this.table, "next.unknown_function"),
+            },
+        };
+    }
+}
+function stringArg(args, name) {
+    const value = args[name];
+    return typeof value === "string" ? value : "";
+}
+function windowArg(value) {
+    return typeof value === "string" && /^c\d+$/.test(value) ? value : undefined;
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}