rl-workspaces 0.6.0 → 0.7.0

package/dist/help.js

@@ -21,7 +21,7 @@ const topics = {
         options: [
             "-c, --create          Create a new branch workspace",
             "-b, --base <ref>      Creation base (default: origin/test unless configured)",
-            "--no-fetch           Use cached refs when creating",
+            "--no-fetch           Use cached refs when opening or creating",
             "--setup              Run configured project setup",
             "--agent codex|claude  Start an agent after switching",
             "-- <agent args>      Forward options to the selected agent",
@@ -30,13 +30,13 @@ const topics = {
             "Use rl checkout [repository] to switch repositories in your shell.",
             "@ opens the main checkout; - returns to the previous workspace.",
             "Shell integration changes your terminal's directory.",
-            "Related creation helpers: new reopens existing workspaces; open requires an existing branch.",
+            "An existing branch without a checkout gets a managed workspace; origin branches are tracked.",
         ],
         examples: [
             "rl switch feature/login",
             "rl switch feature/login -c --base origin/test",
         ],
-        related: ["new", "open", "path"],
+        related: ["path"],
     },
     list: {
         group: "Workspaces",
@@ -64,9 +64,9 @@ const topics = {
         notes: [
             "Shows repository selection, checkout path, base, workspaces and saved session counts.",
             "--workspace includes Git changes, PR, sessions, task handoff and latest workflow.",
-            "Use rl list for workspace overviews; status --list and --all remain supported.",
+            "Use rl list for workspace overviews and --include-deleted for archived records.",
         ],
-        related: ["list", "instances"],
+        related: ["list"],
     },
     delete: {
         group: "Workspaces",
@@ -122,6 +122,9 @@ const topics = {
         description: "Configure native agent roles and saved sessions",
         usage: "rl agent <command>",
         related: ["resume", "workflow", "policy"],
+        notes: [
+            "Existing agent sessions discover their workflow with rl workflow context --json. A special launcher or MCP connection is not required.",
+        ],
     },
     "agent start": {
         description: "Start an interactive agent",
@@ -180,8 +183,11 @@ const topics = {
     },
     "agent mcp": {
         description: "Serve workspace context and notes through MCP",
-        usage: "rl agent mcp",
-        notes: ["Uses stdio. Start the server in the adopted workspace."],
+        usage: "rl agent mcp [--workspace <absolute-path>]",
+        notes: [
+            "Uses stdio. Start the server in the adopted workspace, or bind one explicitly with --workspace.",
+        ],
+        related: ["setup mcp"],
     },
     workflow: {
         group: "Agents and tasks",
@@ -239,6 +245,9 @@ const topics = {
     "workflow context": {
         description: "Discover profiles, policies, workflows and trigger rules",
         usage: "rl workflow context [--json]",
+        notes: [
+            "For an existing agent session: --json includes profiles, policies, workflows, and protocol.tools with every CLI command and input schema. Use your normal shell tool; MCP and rl agent start are optional.",
+        ],
     },
     "workflow pending": {
         description: "Read queued workflows for the parent session",
@@ -397,10 +406,6 @@ const topics = {
         description: "Refresh the saved PR snapshot",
         usage: "rl pr sync [number|URL] [--json]",
     },
-    "pr checks": {
-        description: "Show GitHub check results",
-        usage: "rl pr checks [--json]",
-    },
     "pr checkout": {
         description: "Create a workspace for a PR",
         usage: "rl pr checkout <number> [--name <branch>]",
@@ -513,6 +518,34 @@ const topics = {
         usage: "rl setup adopt [--extended-hooks]",
         notes: ["Preserves existing hooks. Review Codex hook trust with /hooks."],
     },
+    "setup mcp": {
+        description: "Connect this workspace's RL MCP server to your agent",
+        usage: "rl setup mcp [codex|claude] [--dry-run] [--json]",
+        notes: [
+            "Configures both clients by default: .codex/config.toml and .mcp.json in this adopted workspace.",
+            "Preserves other settings and servers. Existing unmanaged entries named rl require manual resolution.",
+            "Launches the installed Node/RL directly, with this workspace and its RL state bound explicitly. Rerun after moving the installation.",
+            "Reload your client and review its normal project trust/MCP approval. Your existing session creates native subagents.",
+        ],
+    },
+    "setup dependencies": {
+        description: "Install or check Git, zsh, fzf and GitHub CLI",
+        usage: "rl setup dependencies [--check | --dry-run] [--json]",
+        notes: [
+            "npm installation installs missing tools through an existing package manager. This command repairs skipped or failed dependency setup.",
+            "Uses Homebrew on macOS, and Homebrew, APT, DNF, Yum, Pacman or APK on Linux. Administrator access may be required on Linux.",
+            "Runs directly with Node, so it also works before zsh or a repository is available.",
+        ],
+    },
+    "setup install": {
+        description: "Complete or repair RL installation and shell integration",
+        usage: "rl setup install [--shell zsh|bash]",
+        notes: [
+            "Global npm installation runs this automatically: missing Git, zsh, fzf and gh are installed, then your shell startup file is updated.",
+            "Preserves your settings and updates one RL-owned block. New terminals load RL automatically; reload the installing terminal once.",
+            "Use this command after an install with lifecycle scripts disabled, or to repair setup.",
+        ],
+    },
     "setup shell": {
         description: "Print shell integration",
         usage: "rl setup shell <zsh|bash>",
@@ -527,16 +560,6 @@ const topics = {
             "--repair reinstalls this workspace's RL hooks.",
         ],
     },
-    new: {
-        description: "Create or reopen a branch workspace",
-        usage: "rl new <branch> [--base <ref>] [--no-fetch] [--setup]",
-        related: ["switch"],
-    },
-    open: {
-        description: "Open an existing local or origin branch",
-        usage: "rl open --branch <branch> [--setup] [--no-fetch]",
-        related: ["switch"],
-    },
     path: {
         description: "Print a workspace path",
         usage: "rl path [name|branch|@]",
@@ -547,52 +570,7 @@ const topics = {
         usage: "rl exec [--workspace <name>] -- <command> [args...]",
         related: ["setup run"],
     },
-    instances: {
-        description: "Inspect active and archived instance records",
-        usage: "rl instances",
-        related: ["status", "list"],
-    },
 };
-const aliases = [
-    [["merge"], ["git", "merge"]],
-    [["clean"], ["storage", "clean"]],
-    [["summary"], ["notes", "summary"]],
-    [["handoff"], ["agent", "handoff"]],
-    [["mcp"], ["agent", "mcp"]],
-    [
-        ["session", "list"],
-        ["agent", "sessions"],
-    ],
-    [
-        ["session", "save"],
-        ["agent", "save"],
-    ],
-    [
-        ["session", "add"],
-        ["agent", "save"],
-    ],
-    [["session"], ["agent"]],
-    [
-        ["config", "init"],
-        ["setup", "init"],
-    ],
-    [
-        ["config", "show"],
-        ["setup", "show"],
-    ],
-    [["config"], ["setup"]],
-    [["adopt"], ["setup", "adopt"]],
-    [["init"], ["setup", "shell"]],
-];
-function canonical(words) {
-    if (words[0] === "status" &&
-        words.some((word) => word === "--all" || word === "--list"))
-        return ["list", ...words.slice(1)];
-    if (["context", "progress"].includes(words[0]))
-        return ["notes", words[1] ?? "show", words[0], ...words.slice(2)];
-    const alias = aliases.find(([from]) => from.every((word, i) => words[i] === word));
-    return alias ? [...alias[1], ...words.slice(alias[0].length)] : words;
-}
 const children = (name) => Object.entries(topics).filter(([key]) => key.startsWith(name + " ") &&
     key.split(" ").length === name.split(" ").length + 1);
 const safe = (value) => stripVTControlCharacters(value).replace(/[\x00-\x1f\x7f-\x9f]/g, " ");
@@ -625,9 +603,8 @@ function match(words) {
 export function topicHelp(words) {
     if (!words.length)
         return mainHelp();
-    const normalized = canonical(words), name = match(normalized);
-    if (!name ||
-        (children(name).length && normalized.length > name.split(" ").length))
+    const name = match(words);
+    if (!name || (children(name).length && words.length > name.split(" ").length))
         throw new Error(`Unknown help topic: ${safe(words.join(" "))}`);
     const topic = topics[name];
     const lines = [topic.description, "", `Usage: ${topic.usage}`];
@@ -666,28 +643,48 @@ export function invocation(module, argv) {
     while (argv[index]?.startsWith("--") && CONTEXT.has(argv[index].slice(2)))
         index += 2;
     const rest = argv.slice(index);
-    const prefix = {
-        delete: ["delete"],
-        summary: ["summary"],
-        mcp: ["mcp"],
-        picker: [],
-    };
-    const words = Object.hasOwn(prefix, module)
-        ? [...prefix[module], ...rest]
-        : module === "agent" && rest[0] !== "handoff"
-            ? ["agent", ...rest]
-            : rest;
+    if (module === "summary")
+        return ["notes", "summary", ...rest];
+    if (module === "mcp")
+        return ["agent", "mcp", ...rest];
+    if (module === "mcp-setup")
+        return ["setup", "mcp", ...rest];
+    if (module === "delete")
+        return ["delete", ...rest];
+    if (module === "picker")
+        return [];
+    if (module === "agent")
+        return ["agent", ...rest];
+    if (module === "git")
+        return ["git", ...rest];
+    if (module === "storage")
+        return rest[0] === "clean" ? ["storage", ...rest] : rest;
+    if (module === "workflow" && rest[0] === "config")
+        return ["setup", ...rest.slice(1)];
+    if (module === "state") {
+        if (rest[0] === "session")
+            return [
+                "agent",
+                rest[1] === "list" ? "sessions" : "save",
+                ...rest.slice(2),
+            ];
+        if (rest[0] === "adopt")
+            return ["setup", ...rest];
+        if (["context", "progress"].includes(rest[0]))
+            return ["notes", rest[1] ?? "show", rest[0], ...rest.slice(2)];
+    }
+    if (module === "repos" &&
+        rest[0] === "status" &&
+        rest.some((word) => word === "--all" || word === "--list"))
+        return ["list", ...rest.slice(1)];
     const defaults = {
         state: "status",
         repos: "repo",
         workflow: "switch",
-        git: "git",
-        agent: "agent",
         automation: "workflow",
-        storage: "storage",
         "pr-update": "pr",
     };
-    return canonical(words.length ? words : defaults[module] ? [defaults[module]] : []);
+    return rest.length ? rest : defaults[module] ? [defaults[module]] : [];
 }
 export function usageHint(module, argv, details = false) {
     const words = invocation(module, argv), name = match(words);

package/dist/hooks.js

@@ -21,7 +21,7 @@ export async function handleHook(store, key, name) {
         // cannot change the original instance or the destination instance.
         const [file, data] = store.instanceForWorktree(root, git(root, "branch", "--show-current"));
         if (data.key !== key)
-            throw new Error("Hook belongs to a different RL instance; run 'rl adopt' to repair it");
+            throw new Error("Hook belongs to a different RL instance; run 'rl setup adopt' to repair it");
         try {
             const event = adapter.parse(payload);
             // Workflow workers are ephemeral. Supply task context without turning a

package/dist/install.js

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { atomicWrite, canonical, inside, shellQuote } from "./common.js";
+import { inspectDependencies, setupDependencies } from "./dependencies.js";
+const BEGIN = "# >>> rl shell integration >>>";
+const END = "# <<< rl shell integration <<<";
+const SHIM = "#!/bin/sh\n# Managed by RL installation\n";
+function profileChange(home, requested, after) {
+    const file = canonical(requested);
+    if (!inside(file, home))
+        throw new Error(`Shell setup path must stay in your home directory: ${requested}`);
+    const stat = fs.statSync(file, { throwIfNoEntry: false });
+    if (stat && (!stat.isFile() || stat.size > 1024 * 1024))
+        throw new Error(`Expected a shell setup file up to 1 MiB: ${requested}`);
+    const before = stat ? fs.readFileSync(file, "utf8") : undefined;
+    return {
+        file,
+        before,
+        after: after(before ?? ""),
+        ...(stat ? { mode: stat.mode & 0o777 } : {}),
+    };
+}
+function integration(text, block, shell) {
+    const lines = text.split(/\r?\n/);
+    const starts = lines.flatMap((line, index) => line === BEGIN ? [index] : []);
+    const ends = lines.flatMap((line, index) => (line === END ? [index] : []));
+    if (starts.length || ends.length) {
+        if (starts.length !== 1 || ends.length !== 1 || starts[0] >= ends[0])
+            throw new Error("Malformed RL shell integration block; preserve your settings and repair its markers before reinstalling");
+        const prefix = lines.slice(0, starts[0]).join("\n");
+        const suffix = lines.slice(ends[0] + 1).join("\n");
+        return (prefix ? prefix + "\n" : "") + block + "\n" + suffix;
+    }
+    const existing = lines.findIndex((line) => [
+        `eval "$(rl setup shell ${shell})"`,
+        `eval "$(command rl setup shell ${shell})"`,
+        `eval "$(rl init ${shell})"`,
+        `eval "$(command rl init ${shell})"`,
+    ].includes(line.trim()));
+    if (existing >= 0) {
+        lines[existing] = block;
+        return lines.join("\n");
+    }
+    return (text + (text ? (text.endsWith("\n") ? "\n" : "\n\n") : "") + block + "\n");
+}
+export function configureShell(host, requestedShell) {
+    const env = host.env ?? process.env;
+    const home = canonical(host.home ?? os.homedir());
+    const shell = requestedShell ??
+        path.basename(env.SHELL ??
+            ((host.platform ?? process.platform) === "darwin" ? "zsh" : "bash"));
+    if (shell !== "zsh" && shell !== "bash")
+        throw new Error(`Automatic RL shell setup supports zsh and bash. Run 'rl setup install --shell zsh' or '--shell bash' for the shell you use.`);
+    const root = host.packageRoot ?? fileURLToPath(new URL("..", import.meta.url));
+    const node = host.node ?? process.execPath;
+    const executable = path.join(root, "bin/rl");
+    const shimDirectory = path.join(home, ".local/share/rl/bin");
+    const shim = profileChange(home, path.join(shimDirectory, "rl"), (before) => {
+        if (before && !before.startsWith(SHIM))
+            throw new Error("The RL installation shim already contains an unmanaged command; it was not replaced");
+        return `${SHIM}exec ${shellQuote(node)} ${shellQuote(executable)} "$@"\n`;
+    });
+    shim.mode = 0o755;
+    const toolDirectories = [
+        ...new Set([
+            path.dirname(node),
+            ...inspectDependencies(env).flatMap((tool) => tool.path ? [path.dirname(tool.path)] : []),
+        ]),
+    ];
+    const block = [
+        BEGIN,
+        `export PATH=${shellQuote(shimDirectory)}:"$PATH":${toolDirectories.map(shellQuote).join(":")}`,
+        `eval "$(${shellQuote(node)} ${shellQuote(executable)} setup shell ${shell})"`,
+        END,
+    ].join("\n");
+    const targets = [
+        path.join(shell === "zsh" && env.ZDOTDIR ? path.resolve(home, env.ZDOTDIR) : home, shell === "zsh" ? ".zshrc" : ".bashrc"),
+    ];
+    if (shell === "bash") {
+        const login = [".bash_profile", ".bash_login", ".profile"]
+            .map((name) => path.join(home, name))
+            .find((file) => fs.existsSync(file));
+        targets.push(login ?? path.join(home, ".bash_profile"));
+    }
+    const profiles = targets.map((file) => profileChange(home, file, (text) => integration(text, block, shell)));
+    const changes = [
+        ...new Map([shim, ...profiles].map((change) => [change.file, change])).values(),
+    ];
+    for (const change of changes) {
+        const current = fs.existsSync(change.file)
+            ? fs.readFileSync(change.file, "utf8")
+            : undefined;
+        if (current !== change.before)
+            throw new Error("Shell configuration changed during installation; retry");
+    }
+    for (const change of changes) {
+        if (change.before !== change.after)
+            atomicWrite(change.file, change.after);
+        if (change.mode !== undefined)
+            fs.chmodSync(change.file, change.mode);
+    }
+    return {
+        shell,
+        profiles: profiles.map((change) => change.file),
+        shim: shim.file,
+    };
+}
+export async function installRl(argv, host = {}) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: { shell: { type: "string" } },
+        allowPositionals: true,
+    });
+    if (positionals.length)
+        throw new Error("Usage: rl setup install [--shell zsh|bash]");
+    const env = host.env ?? process.env;
+    if (env.npm_lifecycle_event === "postinstall" &&
+        env.npm_config_global !== "true") {
+        console.log("RL checkout installed. Run 'rl setup install' to install system tools and register shell integration.");
+        return 0;
+    }
+    const code = await setupDependencies([], host);
+    if (code)
+        return code;
+    const configured = configureShell(host, values.shell);
+    console.log(`RL shell integration installed in ${configured.profiles.join(", ")}.`);
+    console.log("New terminals can use rl directly. To activate directory switching in this terminal now, run:");
+    console.log(`  eval "$(${shellQuote(configured.shim)} setup shell ${configured.shell})"`);
+    return 0;
+}
+if (process.argv[1] &&
+    path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    try {
+        process.exitCode = await installRl(process.argv.slice(2));
+    }
+    catch (error) {
+        console.error(`RL installation: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+}

package/dist/mcp-setup.js

@@ -0,0 +1,171 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { args, arity, atomicWrite, canonical, inside, json, locked, object, } from "./common.js";
+import { commandContext, contextOptions } from "./command-context.js";
+import { parseJsonObject } from "./json.js";
+const BEGIN = "# BEGIN RL MCP - managed by rl setup mcp";
+const END = "# END RL MCP";
+const MARKER = "RL_MCP_MANAGED";
+function readConfig(workspace, relative) {
+    const file = path.join(workspace, relative);
+    if (fs
+        .lstatSync(path.dirname(file), { throwIfNoEntry: false })
+        ?.isSymbolicLink() ||
+        !inside(canonical(file), workspace))
+        throw new Error(`MCP configuration must stay in this workspace: ${relative}`);
+    const stat = fs.lstatSync(file, { throwIfNoEntry: false });
+    if (stat &&
+        (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024))
+        throw new Error(`Expected a regular MCP configuration file up to 1 MiB: ${relative}`);
+    return { file, ...(stat ? { text: fs.readFileSync(file, "utf8") } : {}) };
+}
+function serverEntry(previous, command, argv, file) {
+    if (previous !== undefined &&
+        (!object(previous) || !object(previous.env) || previous.env[MARKER] !== "1"))
+        throw new Error(`An existing server named rl in ${file} is not managed by RL. Keep it, or remove only that entry before running rl setup mcp.`);
+    if (object(previous) &&
+        (previous.url !== undefined ||
+            (previous.type !== undefined && previous.type !== "stdio")))
+        throw new Error(`The existing rl server in ${file} is not a local stdio server`);
+    const entry = object(previous) ? previous : {};
+    return {
+        ...entry,
+        command,
+        args: argv,
+        env: { ...(object(entry.env) ? entry.env : {}), [MARKER]: "1" },
+    };
+}
+function claudeConfig(before, command, argv, file) {
+    const config = before === undefined ? {} : parseJsonObject(before);
+    if (config.mcpServers !== undefined && !object(config.mcpServers))
+        throw new Error(`Expected an mcpServers object in ${file}`);
+    const servers = object(config.mcpServers) ? config.mcpServers : {};
+    const entry = {
+        ...serverEntry(servers.rl, command, argv, file),
+        type: "stdio",
+    };
+    return (JSON.stringify({ ...config, mcpServers: { ...servers, rl: entry } }, null, 2) + "\n");
+}
+function codexConfig(before, command, argv, workspace, file) {
+    const text = before ?? "";
+    const config = parseToml(text, { integersAsBigInt: "asNeeded" });
+    if (config.mcp_servers !== undefined && !object(config.mcp_servers))
+        throw new Error(`Expected an mcp_servers table in ${file}`);
+    const servers = object(config.mcp_servers) ? config.mcp_servers : {};
+    const entry = {
+        ...serverEntry(servers.rl, command, argv, file),
+        cwd: workspace,
+    };
+    const starts = [
+        ...text.matchAll(/^# BEGIN RL MCP - managed by rl setup mcp\r?$/gm),
+    ];
+    const ends = [...text.matchAll(/^# END RL MCP\r?$/gm)];
+    const marked = starts.length || ends.length;
+    if (marked &&
+        (starts.length !== 1 ||
+            ends.length !== 1 ||
+            starts[0].index >= ends[0].index ||
+            servers.rl === undefined))
+        throw new Error(`Invalid managed RL MCP block in ${file}`);
+    if (servers.rl !== undefined && !marked)
+        throw new Error(`The rl server in ${file} has no managed block; preserve or remove that entry before setup`);
+    const block = `${BEGIN}\n${stringifyToml({ mcp_servers: { rl: entry } })}${END}`;
+    const updated = marked
+        ? text.slice(0, starts[0].index) +
+            block +
+            text.slice(ends[0].index + ends[0][0].length)
+        : text + (text ? (text.endsWith("\n") ? "\n" : "\n\n") : "") + block + "\n";
+    // Validate the merged document as well: inline tables and dotted keys may
+    // prevent appending a new child table even when the existing TOML is valid.
+    const merged = parseToml(updated, { integersAsBigInt: "asNeeded" });
+    const [originalSettings, mergedSettings] = [config, merged].map((value) => {
+        const copy = { ...value };
+        if (object(copy.mcp_servers)) {
+            const servers = { ...copy.mcp_servers };
+            delete servers.rl;
+            if (Object.keys(servers).length)
+                copy.mcp_servers = servers;
+            else
+                delete copy.mcp_servers;
+        }
+        return copy;
+    });
+    if (!isDeepStrictEqual(originalSettings, mergedSettings))
+        throw new Error(`The managed RL MCP block in ${file} contains unrelated settings. Move them outside the block before setup.`);
+    return updated;
+}
+export async function main(argv) {
+    const { values, positionals } = args(argv, contextOptions, [
+        "dry-run",
+        "json",
+    ]);
+    arity(positionals, 0, 1);
+    const selected = positionals[0];
+    if (selected !== undefined && selected !== "codex" && selected !== "claude")
+        throw new Error("Expected codex or claude, or omit the client to configure both");
+    const context = commandContext(values);
+    const [, active] = context.store.current();
+    const updates = await locked(active.worktree, ".rl-mcp-setup.lock", () => {
+        const [, instance] = context.store.current();
+        if (instance.key !== active.key)
+            throw new Error("RL workspace changed during MCP setup; retry");
+        const workspace = instance.worktree;
+        const command = process.execPath;
+        const serverArgs = [
+            fileURLToPath(new URL("./cli.js", import.meta.url)),
+            "mcp",
+            "--repo",
+            context.repo,
+            "--state-dir",
+            context.stateDir,
+            "--workspace",
+            workspace,
+        ];
+        const clients = selected ? [selected] : ["codex", "claude"];
+        const plans = clients.map((client) => {
+            const { file, text } = readConfig(workspace, client === "codex" ? ".codex/config.toml" : ".mcp.json");
+            const after = client === "codex"
+                ? codexConfig(text, command, serverArgs, workspace, file)
+                : claudeConfig(text, command, serverArgs, file);
+            return {
+                client,
+                file,
+                before: text,
+                after,
+                action: text === after
+                    ? "unchanged"
+                    : text === undefined
+                        ? "created"
+                        : "updated",
+            };
+        });
+        if (!values["dry-run"]) {
+            // Validate every selected file before writing any, and refuse concurrent
+            // external edits rather than silently replacing another process's work.
+            for (const plan of plans) {
+                const current = readConfig(workspace, path.relative(workspace, plan.file));
+                if (current.text !== plan.before)
+                    throw new Error("MCP configuration changed during setup; retry");
+            }
+            for (const plan of plans)
+                if (plan.action !== "unchanged")
+                    atomicWrite(plan.file, plan.after);
+        }
+        return plans.map(({ client, file, action }) => ({ client, file, action }));
+    });
+    if (values.json)
+        json({
+            dryRun: !!values["dry-run"],
+            files: updates,
+            next: "Reload your client and review its normal project trust/MCP approval. Native subagents are created by the current session.",
+        });
+    else {
+        for (const update of updates)
+            console.log(`${values["dry-run"] ? "Would configure" : update.action === "unchanged" ? "Already configured" : "Configured"} ${update.client}: ${update.file}`);
+        console.log("Reload your client, then review its normal project trust/MCP approval. RL tools will be available to your existing session.");
+    }
+    return 0;
+}

package/dist/mcp.js

@@ -1,4 +1,5 @@
 import { fileURLToPath } from "node:url";
+import path from "node:path";
 import { args, arity, message, required } from "./common.js";
 import { activityView } from "./activity.js";
 import { contextText, Store } from "./store.js";
@@ -7,7 +8,7 @@ import { currentSessionId } from "./session.js";
 import { syncCodexSessions } from "./codex-sessions.js";
 import { pauseTask, PAUSE_FIELDS } from "./task.js";
 import { HANDOFF_FIELDS, MAX_HANDOFF_TEXT } from "./task-state.js";
-import { automationContext, callWorkflowTool, WORKFLOW_TOOLS, } from "./session-workflows.js";
+import { automationContext, callWorkflowTool, WORKFLOW_TOOLS, workflowToolSchema, } from "./session-workflows.js";
 import { isJsonObject, parseJson, readJsonObject, } from "./json.js";
 const PROTOCOL_VERSION = "2025-11-25";
 const RPC_VERSION = "2.0";
@@ -269,19 +270,7 @@ export async function serveMcp(store) {
                             ...WORKFLOW_TOOLS.map((tool) => ({
                                 name: tool.name,
                                 description: tool.description,
-                                inputSchema: {
-                                    type: "object",
-                                    properties: {
-                                        agent: { type: "string", enum: ["codex", "claude"] },
-                                        sessionId: {
-                                            type: "string",
-                                            description: "Current parent conversation ID. Claude requires a UUID; Codex also accepts observed thr_ IDs and may inherit it.",
-                                        },
-                                        ...tool.properties,
-                                    },
-                                    required: tool.required,
-                                    additionalProperties: false,
-                                },
+                                inputSchema: workflowToolSchema(tool),
                                 annotations: {
                                     readOnlyHint: tool.readOnly,
                                     destructiveHint: false,
@@ -330,7 +319,15 @@ export async function serveMcp(store) {
     return 0;
 }
 export async function main(argv) {
-    const { values, positionals } = args(argv, ["repo", "state-dir"], []);
+    const { values, positionals } = args(argv, ["repo", "state-dir", "workspace"], []);
     arity(positionals, 0);
-    return serveMcp(new Store(required(values, "repo"), required(values, "state-dir")));
+    const store = new Store(required(values, "repo"), required(values, "state-dir"));
+    if (values.workspace !== undefined) {
+        const workspace = required(values, "workspace");
+        if (!path.isAbsolute(workspace))
+            throw new Error("Expected an absolute MCP workspace path");
+        const [, instance] = store.current(workspace);
+        process.chdir(instance.worktree);
+    }
+    return serveMcp(store);
 }