rl-workspaces 0.0.0-stage → 0.5.0

package/dist/task.js

@@ -0,0 +1,192 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { args, arity, canonical, json, now, object, timestamp, } from "./common.js";
+import { agentAdapter } from "./agent-registry.js";
+import { resumeAgent } from "./agent-resume.js";
+import { currentSessionId } from "./session.js";
+import { commandContext, contextOptions, resolveWorkspace, writeWorkspaceOutput, } from "./command-context.js";
+import { HANDOFF_FIELDS, handoffNotes, handoffText, } from "./task-state.js";
+export const PAUSE_FIELDS = [...HANDOFF_FIELDS, "agent", "sessionId"];
+export async function pauseTask(store, input, cwd = process.cwd()) {
+    if (!object(input) ||
+        Object.keys(input).some((key) => !PAUSE_FIELDS.includes(key)))
+        throw new Error("Unexpected task handoff argument");
+    const notes = handoffNotes(input);
+    if (input.agent !== undefined && typeof input.agent !== "string")
+        throw new Error("agent must be codex or claude");
+    const agent = agentAdapter(input.agent ?? "codex").name;
+    const sid = currentSessionId(agent, input.sessionId);
+    return store.locked(() => {
+        const [file, data] = store.current(cwd);
+        const stamp = now();
+        const handoff = {
+            ...notes,
+            id: randomUUID(),
+            agent,
+            sessionId: sid,
+            savedAt: stamp,
+        };
+        store.associateSession(file, data, agent, sid, stamp);
+        const task = data.task ?? { state: "paused", handoffs: [] };
+        task.handoffs.push(handoff);
+        task.state = "paused";
+        delete task.continuedAt;
+        data.task = task;
+        store.touch(file, data, stamp);
+        return handoff;
+    });
+}
+function selectTask(context, selector) {
+    let records = context.store
+        .records()
+        .filter(([, data]) => data.status === "active" && data.task);
+    if (selector !== undefined) {
+        records = records.filter(([, data]) => data.id === selector ||
+            data.branch === selector ||
+            path.relative(context.managedDir, data.worktree) === selector ||
+            (path.isAbsolute(selector) && canonical(selector) === data.worktree));
+        if (records.length !== 1)
+            throw new Error(records.length
+                ? "Ambiguous task; use the full branch or workspace path"
+                : `No saved handoff for workspace ${selector}`);
+    }
+    else {
+        records.sort(([, a], [, b]) => {
+            const paused = Number(b.task.state === "paused") - Number(a.task.state === "paused");
+            if (paused)
+                return paused;
+            const at = timestamp(a.task.continuedAt ?? a.task.handoffs.at(-1).savedAt);
+            const bt = timestamp(b.task.continuedAt ?? b.task.handoffs.at(-1).savedAt);
+            return at > bt ? -1 : at < bt ? 1 : a.key.localeCompare(b.key);
+        });
+    }
+    const selected = records[0];
+    if (!selected)
+        throw new Error("No saved task handoffs in this repository. Ask your agent to pause the task first");
+    // Fail visibly on a missing or switched workspace instead of silently choosing another task.
+    const current = context.store.current(selected[1].worktree);
+    if (current[0] !== selected[0])
+        throw new Error("Task workspace instance changed");
+    return current;
+}
+export async function continueTask(context, options = {}) {
+    const [file, data, handoff, previousState, previousTime, stamp] = await context.store.locked(() => {
+        const [file, data] = selectTask(context, options.workspace);
+        const handoff = data.task.handoffs.at(-1);
+        if (!data.sessions[handoff.agent].some((item) => item.id === handoff.sessionId))
+            throw new Error("Handoff session is missing from workspace history");
+        const stamp = now();
+        const previousState = data.task.state;
+        const previousTime = data.task.continuedAt;
+        // Validate shell output before changing task state.
+        writeWorkspaceOutput(data.worktree, options.output);
+        data.task.state = "active";
+        data.task.continuedAt = stamp;
+        context.store.touch(file, data, stamp);
+        return [file, data, handoff, previousState, previousTime, stamp];
+    });
+    const prompt = [
+        `Continue RL task ${data.id} on branch ${data.branch}.`,
+        handoffText(handoff),
+        `Read the full shared task documents before continuing:\n${path.join(path.dirname(file), "context.md")}\n${path.join(path.dirname(file), "progress.md")}`,
+        "Recheck the current code and Git state. The handoff records what the previous agent reported; it does not establish that checks still pass. Follow the next steps and record new milestones. When asked to pause again, save a new handoff with rl_task_pause or rl pause.",
+    ].join("\n\n");
+    console.error(handoffText(handoff));
+    if (options.noAgent)
+        return 0;
+    const restore = () => context.store.locked(() => {
+        const [currentFile, current] = context.store.current(data.worktree);
+        const task = current.task;
+        if (currentFile !== file ||
+            task?.handoffs.at(-1)?.id !== handoff.id ||
+            task.state !== "active" ||
+            task.continuedAt !== stamp)
+            return;
+        task.state = previousState;
+        if (previousTime === undefined)
+            delete task.continuedAt;
+        else
+            task.continuedAt = previousTime;
+        context.store.save(file, current);
+    });
+    try {
+        const code = await resumeAgent(context.store, handoff.agent, {
+            cwd: data.worktree,
+            sessionId: handoff.sessionId,
+            prompt,
+            expectedKey: data.key,
+        });
+        if (code !== 0)
+            await restore();
+        return code;
+    }
+    catch (error) {
+        // Retain a newer pause written by the running agent or another process.
+        try {
+            await restore();
+        }
+        catch {
+            /* Preserve the original launch error. */
+        }
+        throw error;
+    }
+}
+export async function main(argv) {
+    const { values, positionals } = args(argv, [
+        ...contextOptions,
+        ...HANDOFF_FIELDS,
+        "agent",
+        "session",
+        "workspace",
+        "file",
+        "output-path",
+    ], ["json", "no-agent"]);
+    const context = commandContext(values);
+    const [command, ...rest] = positionals;
+    const supplied = Object.keys(values).filter((key) => !contextOptions.includes(key));
+    if (command === "pause") {
+        arity(rest, 0);
+        if (supplied.some((key) => ![
+            ...HANDOFF_FIELDS,
+            "agent",
+            "session",
+            "workspace",
+            "file",
+            "json",
+        ].includes(key)))
+            throw new Error("Unsupported pause option");
+        if (values.file !== undefined &&
+            supplied.some((key) => [...HANDOFF_FIELDS, "agent", "session"].includes(key)))
+            throw new Error("Use --file or handoff fields, not both");
+        const target = resolveWorkspace(context, typeof values.workspace === "string" ? values.workspace : undefined);
+        const input = typeof values.file === "string"
+            ? JSON.parse(fs.readFileSync(values.file === "-" ? 0 : values.file, "utf8"))
+            : Object.fromEntries([...HANDOFF_FIELDS, "agent", "session"]
+                .filter((key) => values[key] !== undefined)
+                .map((key) => [
+                key === "session" ? "sessionId" : key,
+                values[key],
+            ]));
+        const handoff = await pauseTask(context.store, input, target.path);
+        if (values.json)
+            json(handoff);
+        else
+            console.log(`Paused ${target.branch}. Handoff saved; return with rl continue.`);
+        return 0;
+    }
+    if (command !== "continue")
+        throw new Error("Usage: rl pause | rl continue [workspace] [--no-agent]");
+    arity(rest, 0, 1);
+    if (supplied.some((key) => !["workspace", "no-agent", "output-path"].includes(key)) ||
+        (rest.length && values.workspace !== undefined))
+        throw new Error("Usage: rl continue [workspace] [--no-agent]");
+    return continueTask(context, {
+        workspace: rest[0] ??
+            (typeof values.workspace === "string" ? values.workspace : undefined),
+        noAgent: !!values["no-agent"],
+        output: typeof values["output-path"] === "string"
+            ? values["output-path"]
+            : undefined,
+    });
+}

package/dist/templates.js

@@ -0,0 +1,4 @@
+export const NOTE_TEMPLATES = {
+    "context.md": "# Feature and domain documentation\n\n## Purpose and scope\nDescribe the user problem, intended behavior, and what is outside this feature.\n\n## Domain rules and acceptance criteria\nRecord terminology, constraints, examples, and observable completion criteria.\n\n## Design decisions\nRecord decisions and their rationale, including alternatives when relevant.\n\n## References\nLink specifications, issues, relevant code, and related documentation.\n",
+    "progress.md": "# Implementation documentation\n\n## Completed\nRecord implemented behavior with concrete file or symbol references.\n\n## Remaining work\nKeep an actionable checklist; distinguish planned work from completed work.\n\n## Implementation details\nExplain the flow, important modules, APIs/data structures, and integration points.\n\n## Validation\nRecord checks actually run, their results, and gaps that remain unverified.\n\n## Blockers and open questions\nRecord unresolved decisions, known issues, and dependencies.\n\n## Next steps\nDescribe where the next agent or developer should continue.\n\n## Progress log\nAppend dated milestone updates here when several agents are working concurrently.\n",
+};

package/dist/workflow-config.js

@@ -0,0 +1,177 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { execute, git, gitEnv, inside } from "./common.js";
+import { isJsonObject, readJsonObject } from "./json.js";
+import { validateCleanupPath } from "./cleanup-path.js";
+export const WORKFLOW_FILE = ".rl/workflows.json";
+const RESERVED_DIRECTORIES = new Set([".git", ".rl", ".codex", ".claude"]);
+const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const ENV_PREFIX = /^(APP_|PUBLIC_|VITE_|NEXT_PUBLIC_|REACT_APP_)/;
+const ENV_NAMES = new Set(["PORT", "NODE_ENV", "DATABASE_URL", "REDIS_URL"]);
+const PORT_START = 10000;
+const PORT_COUNT = 40000;
+const CONFIG_KEYS = new Set(["copy", "clean", "env", "onCreate", "onOpen"]);
+export const EMPTY_WORKFLOW = {
+    copy: [],
+    clean: [],
+    env: {},
+    onCreate: [],
+    onOpen: [],
+};
+export function readWorkflowConfig(repo) {
+    const file = path.join(repo, WORKFLOW_FILE);
+    if (fs
+        .lstatSync(path.dirname(file), { throwIfNoEntry: false })
+        ?.isSymbolicLink() ||
+        fs.lstatSync(file, { throwIfNoEntry: false })?.isSymbolicLink())
+        throw new Error("Workflow configuration must not be a symlink");
+    if (!fs.existsSync(file))
+        return { ...EMPTY_WORKFLOW };
+    const data = readJsonObject(file);
+    for (const key of Object.keys(data))
+        if (!CONFIG_KEYS.has(key))
+            throw new Error(`Unknown workflow setting: ${key}`);
+    const copy = data.copy ?? [];
+    if (!Array.isArray(copy) ||
+        !copy.every((item) => typeof item === "string" && item.length > 0))
+        throw new Error("Workflow copy must be an array of relative paths");
+    const env = {};
+    if (data.env !== undefined) {
+        if (!isJsonObject(data.env))
+            throw new Error("Workflow env must be an object of strings");
+        for (const [key, value] of Object.entries(data.env)) {
+            if (!ENV_NAME.test(key) ||
+                (!ENV_PREFIX.test(key) && !ENV_NAMES.has(key)) ||
+                typeof value !== "string" ||
+                value.includes("\0"))
+                throw new Error(`Unsupported workflow environment variable: ${key}. Use APP_, PUBLIC_, VITE_, NEXT_PUBLIC_, REACT_APP_ prefixes or PORT, NODE_ENV, DATABASE_URL, REDIS_URL`);
+            env[key] = value;
+        }
+    }
+    const cleanup = data.clean ?? [];
+    if (!Array.isArray(cleanup))
+        throw new Error("Workflow clean must be an array of relative directory paths");
+    const clean = cleanup.map((item) => {
+        validateCleanupPath(item);
+        return item;
+    });
+    const result = { copy, clean, env, onCreate: [], onOpen: [] };
+    for (const event of ["onCreate", "onOpen"]) {
+        const commands = data[event] ?? [];
+        if (!Array.isArray(commands))
+            throw new Error(`Workflow ${event} must be an array of argv arrays`);
+        for (const command of commands) {
+            if (!Array.isArray(command) ||
+                !command.length ||
+                !command.every((argument) => typeof argument === "string" && !argument.includes("\0")) ||
+                !command[0])
+                throw new Error(`Workflow ${event} commands must be nonempty argv arrays`);
+            result[event].push(command);
+        }
+    }
+    return result;
+}
+export function workflowEnvironment(repo, workspace, config) {
+    const hash = createHash("sha256")
+        .update(repo)
+        .update("\0")
+        .update(workspace)
+        .digest();
+    const inherited = gitEnv();
+    delete inherited.RL_SHELL_OUTPUT;
+    delete inherited.RL_INTERNAL_SHELL;
+    return {
+        ...inherited,
+        ...config.env,
+        RL_REPO: "",
+        RL_REPO_ROOT: repo,
+        RL_WORKSPACE: workspace,
+        RL_PORT: String(PORT_START + (hash.readUInt32BE(0) % PORT_COUNT)),
+    };
+}
+export function containedPath(root, relative) {
+    const components = relative.split(/[\\/]/);
+    if (path.isAbsolute(relative) ||
+        components.some((part) => !part ||
+            part === "." ||
+            part === ".." ||
+            RESERVED_DIRECTORIES.has(part.toLowerCase())) ||
+        relative.includes("\0"))
+        throw new Error(`Unsafe workflow copy path: ${relative}`);
+    const target = path.resolve(root, relative);
+    if (!inside(target, root))
+        throw new Error(`Copy path escapes workspace: ${relative}`);
+    let current = root;
+    for (const component of components) {
+        current = path.join(current, component);
+        if (fs.lstatSync(current, { throwIfNoEntry: false })?.isSymbolicLink())
+            throw new Error(`Workflow copy does not support symlinks: ${current}`);
+    }
+    return target;
+}
+function collectCopies(repo, workspace, relative, files, stateDir) {
+    const source = containedPath(repo, relative);
+    const destination = containedPath(workspace, relative);
+    if (stateDir &&
+        [source, destination].some((file) => file === stateDir || inside(file, stateDir)))
+        throw new Error(`Workflow copy cannot include RL state: ${relative}`);
+    const stat = fs.lstatSync(source);
+    if (stat.isDirectory()) {
+        if (fs.existsSync(destination) && !fs.lstatSync(destination).isDirectory())
+            throw new Error(`Copy destination is not a directory: ${destination}`);
+        for (const child of fs.readdirSync(source).sort())
+            collectCopies(repo, workspace, path.join(relative, child), files, stateDir);
+        return;
+    }
+    if (!stat.isFile())
+        throw new Error(`Copy supports only regular files and directories: ${relative}`);
+    for (const root of [repo, workspace]) {
+        if (git(root, "--literal-pathspecs", "ls-files", "--", relative))
+            throw new Error(`Workflow copy path is tracked: ${relative}`);
+        try {
+            git(root, "check-ignore", "--no-index", "--", relative);
+        }
+        catch {
+            throw new Error(`Workflow copy path must be ignored in source and destination: ${relative}`);
+        }
+    }
+    if (fs.existsSync(destination)) {
+        if (!fs.lstatSync(destination).isFile())
+            throw new Error(`Copy destination is not a regular file: ${destination}`);
+        return;
+    }
+    if (!files.some((file) => file.destination === destination))
+        files.push({ source, destination, relative });
+}
+export async function setupWorkspace(repo, workspace, options = {}) {
+    const config = readWorkflowConfig(repo);
+    const files = [];
+    for (const relative of new Set(config.copy))
+        collectCopies(repo, workspace, relative, files, options.stateDir);
+    const commands = [
+        ...(options.create ? config.onCreate : []),
+        ...(options.open ? config.onOpen : []),
+    ];
+    for (const file of files)
+        console.error(`${options.dryRun ? "Would copy" : "Copy"} ${file.relative}`);
+    for (const command of commands)
+        console.error(`${options.dryRun ? "Would run" : "Run"} ${JSON.stringify(command)}`);
+    if (options.dryRun)
+        return 0;
+    for (const file of files) {
+        containedPath(repo, file.relative);
+        containedPath(workspace, file.relative);
+        fs.mkdirSync(path.dirname(file.destination), { recursive: true });
+        fs.copyFileSync(file.source, file.destination, fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE);
+    }
+    for (const command of commands) {
+        const result = await execute(command, workspace, {
+            interactive: true,
+            env: workflowEnvironment(repo, workspace, config),
+        });
+        if (result.code !== 0)
+            return result.code;
+    }
+    return 0;
+}

package/dist/workflow.js

@@ -0,0 +1,211 @@
+import fs from "node:fs";
+import path from "node:path";
+import { args, arity, canonical, execute, git, inside, json, locked, } from "./common.js";
+import { commandContext, contextOptions, resolveWorkspace, writeWorkspaceOutput, } from "./command-context.js";
+import { resolveBase } from "./base.js";
+import { worktrees } from "./repos.js";
+import { launchAgent } from "./agent-launch.js";
+import { EMPTY_WORKFLOW, WORKFLOW_FILE, readWorkflowConfig, setupWorkspace, workflowEnvironment, } from "./workflow-config.js";
+const CREATE_LOCK = ".workspace-create";
+const SETUP_LOCK = ".workspace-setup";
+const LOCK_FILE = ".lock";
+const SUPPORTED_AGENTS = new Set(["codex", "claude"]);
+const COMMAND_OPTIONS = {
+    path: [],
+    config: [],
+    exec: ["workspace"],
+    setup: ["workspace", "dry-run"],
+    switch: ["create", "base", "no-fetch", "setup", "agent", "output-path"],
+    new: ["base", "no-fetch", "setup", "output-path"],
+    open: ["branch", "base", "no-fetch", "setup", "output-path"],
+};
+async function createWorkspace(context, name, base, noFetch, options = {}) {
+    if (name.startsWith("-") ||
+        name.startsWith("@") ||
+        name
+            .split(/[\\/]/)
+            .some((part) => !part || part === "." || part === "..") ||
+        path.isAbsolute(name))
+        throw new Error(`Invalid workspace name: ${name}`);
+    git(context.repo, "check-ref-format", "--branch", name);
+    return locked(path.join(context.store.root, CREATE_LOCK), LOCK_FILE, async () => {
+        const directoryName = options.directoryName ?? name;
+        const destination = path.resolve(context.managedDir, directoryName);
+        if (!inside(destination, context.managedDir) ||
+            canonical(destination) !== destination)
+            throw new Error("Workspace path must stay inside the managed directory without symlinks");
+        const registered = worktrees(context.repo).find((item) => item.branch === `refs/heads/${name}`);
+        if (registered) {
+            if (!options.reuseExisting)
+                throw new Error(`Branch already checked out at ${registered.worktree}; use rl switch without --create`);
+            const [root, branch] = context.store.worktree(registered.worktree);
+            if (branch !== name)
+                throw new Error("Workspace branch changed during selection; retry");
+            return { path: root, name: directoryName, branch, created: false };
+        }
+        if (fs.existsSync(destination))
+            throw new Error(`Workspace path already exists: ${destination}`);
+        if (!noFetch) {
+            const remotes = git(context.repo, "remote").split("\n");
+            if (remotes.includes("origin")) {
+                const result = await execute(["git", "fetch", "origin"], context.repo, { terminalError: true });
+                if (result.code !== 0)
+                    throw new Error("Fetch failed; retry or use --no-fetch");
+            }
+        }
+        const exists = git(context.repo, "for-each-ref", "--format=%(refname)", `refs/heads/${name}`)
+            .split("\n")
+            .includes(`refs/heads/${name}`);
+        const remoteBranch = `refs/remotes/origin/${name}`;
+        const remoteExists = options.requireBranch &&
+            git(context.repo, "for-each-ref", "--format=%(refname)", remoteBranch)
+                .split("\n")
+                .includes(remoteBranch);
+        if (options.requireBranch && !exists && !remoteExists)
+            throw new Error(`Branch does not exist locally or on origin: ${name}`);
+        const resolved = exists
+            ? null
+            : resolveBase(context.repo, options.requireBranch ? `origin/${name}` : base);
+        if (!exists && !resolved)
+            throw new Error(`Base branch does not exist: ${base}`);
+        fs.mkdirSync(path.dirname(destination), { recursive: true });
+        const creationArgs = exists
+            ? [destination, name]
+            : resolved
+                ? [
+                    ...(options.requireBranch ? ["--track"] : []),
+                    "-b",
+                    name,
+                    destination,
+                    options.requireBranch ? `origin/${name}` : resolved.oid,
+                ]
+                : [];
+        git(context.repo, "worktree", "add", ...creationArgs);
+        return {
+            path: destination,
+            name: directoryName,
+            branch: name,
+            created: true,
+        };
+    });
+}
+export async function main(argv) {
+    const separator = argv.indexOf("--");
+    const forwarded = separator < 0 ? [] : argv.slice(separator + 1);
+    const { values, positionals } = args(separator < 0 ? argv : argv.slice(0, separator), [...contextOptions, "base", "branch", "workspace", "agent", "output-path"], ["create", "no-fetch", "setup", "dry-run"], { create: "c", base: "b" });
+    const context = commandContext(values);
+    const [command, ...names] = positionals;
+    const allowedOptions = COMMAND_OPTIONS[command];
+    if (!allowedOptions)
+        throw new Error("Unknown workspace workflow command");
+    for (const option of Object.keys(values))
+        if (!contextOptions.includes(option) && !allowedOptions.includes(option))
+            throw new Error(`--${option} is not supported by rl ${command}`);
+    if (command === "switch" &&
+        !values.create &&
+        (values.base || values["no-fetch"]))
+        throw new Error("--base and --no-fetch require --create with rl switch");
+    const selector = typeof values.workspace === "string" ? values.workspace : undefined;
+    if (forwarded.length &&
+        command !== "exec" &&
+        !(command === "switch" && values.agent))
+        throw new Error("Arguments after -- require rl exec or rl switch --agent");
+    if (command === "path") {
+        arity(names, 0, 1);
+        console.log(resolveWorkspace(context, names[0]).path);
+        return 0;
+    }
+    if (command === "config") {
+        arity(names, 1);
+        if (names[0] === "show")
+            json(readWorkflowConfig(context.repo));
+        else if (names[0] === "init") {
+            const file = path.join(context.repo, WORKFLOW_FILE);
+            if (fs
+                .lstatSync(path.dirname(file), { throwIfNoEntry: false })
+                ?.isSymbolicLink())
+                throw new Error("Workflow config directory must not be a symlink");
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, JSON.stringify(EMPTY_WORKFLOW, null, 2) + "\n", {
+                flag: "wx",
+            });
+            console.log(file);
+        }
+        else
+            throw new Error("Usage: rl config show|init");
+        return 0;
+    }
+    if (command === "exec") {
+        arity(names, 0);
+        if (!forwarded.length)
+            throw new Error("Usage: rl exec [--workspace name] -- <command> [args...]");
+        const target = resolveWorkspace(context, selector);
+        return (await execute(forwarded, target.path, {
+            interactive: true,
+            env: workflowEnvironment(context.repo, target.path, readWorkflowConfig(context.repo)),
+        })).code;
+    }
+    if (command === "setup") {
+        arity(names, 0);
+        const target = resolveWorkspace(context, selector);
+        return locked(path.join(context.store.root, SETUP_LOCK), LOCK_FILE, () => {
+            if (context.store.worktree(target.path)[1] !== target.branch)
+                throw new Error("Workspace branch changed before setup; retry");
+            return setupWorkspace(context.repo, target.path, {
+                dryRun: !!values["dry-run"],
+                create: true,
+                open: true,
+                stateDir: context.stateDir,
+            });
+        });
+    }
+    if (!["switch", "new", "open"].includes(command))
+        throw new Error("Unknown workspace workflow command");
+    arity(names, command === "open" ? 0 : 1);
+    const selectedBranch = values.branch ?? (command === "open" ? values.base : undefined);
+    if (command === "open" && typeof selectedBranch !== "string")
+        throw new Error("Usage: rl open --branch <branch>");
+    const agent = typeof values.agent === "string" ? values.agent : undefined;
+    if (agent && !SUPPORTED_AGENTS.has(agent))
+        throw new Error("Agent must be codex or claude");
+    const base = command !== "open" && typeof values.base === "string"
+        ? values.base
+        : context.defaultBase;
+    const creating = !!values.create || command === "new" || command === "open";
+    const branch = typeof selectedBranch === "string"
+        ? selectedBranch.replace(/^origin\//, "")
+        : names[0];
+    const target = creating
+        ? await createWorkspace(context, branch, base, !!values["no-fetch"], command === "switch"
+            ? {}
+            : {
+                reuseExisting: true,
+                ...(command === "open"
+                    ? {
+                        directoryName: branch.replaceAll("/", "-"),
+                        requireBranch: true,
+                    }
+                    : {}),
+            })
+        : resolveWorkspace(context, names[0]);
+    await context.store.adopt(target.path, base);
+    if (values.setup) {
+        const code = await locked(path.join(context.store.root, SETUP_LOCK), LOCK_FILE, () => {
+            if (context.store.worktree(target.path)[1] !== target.branch)
+                throw new Error("Workspace branch changed before setup; retry");
+            return setupWorkspace(context.repo, target.path, {
+                create: "created" in target && target.created === true,
+                open: true,
+                stateDir: context.stateDir,
+            });
+        });
+        if (code !== 0)
+            return code;
+    }
+    writeWorkspaceOutput(target.path, typeof values["output-path"] === "string"
+        ? values["output-path"]
+        : undefined);
+    return agent
+        ? launchAgent(context.store, agent, forwarded, { cwd: target.path })
+        : 0;
+}