codedeck 0.2.0 → 0.4.0

package/dist/cli/commands/open.js

@@ -1,106 +1,142 @@
-import { execFile, spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { promisify } from "node:util";
 import * as readline from "node:readline";
-import { constants } from "node:os";
 import { IpcClient } from "../../daemon/ipc.js";
-import { loadConfig, resolveModel } from "../../config/config.js";
+import { loadConfig, resolveRoleBinding, resolveOrchestratorMode, } from "../../config/config.js";
+import { parseAutocompact } from "../../core/autocompact.js";
+import { harnessInjection } from "../../open/injection.js";
+import { getGitInfo } from "../../git/repository.js";
+import { createWorktree } from "../../git/worktree.js";
+import { ptyShimPath } from "../../open/pty.js";
 import { isInteractiveTerminal } from "./setup.js";
-import { renderLogo } from "../ui.js";
-import { getRegistry } from "../../drivers/registry.js";
-import { detectBinary } from "../../drivers/helpers.js";
-import { findClosestModel, getCachedOrDiscoverModels, modelNames, } from "../../core/models.js";
+import { sessionsDir } from "../../open/pty.js";
 import { ROLES, parseRole, resolvePluginDir } from "../../core/roles.js";
+import { getCliName } from "../cli-name.js";
+import { effectiveModel, resolveOpenModel } from "../../open/contract.js";
+import { buildArgs as buildOpencodeArgs, buildInlineConfig, createEphemeralTuiDir, ensureOpencodeTheme, OPENCODE_NOT_FOUND, preflight as preflightOpencode, removeEphemeralTuiDir, resolveBinary as resolveOpencodeBinary, } from "../../open/launchers/opencode.js";
+import { assertSupport, buildOpenArgs, CLAUDE_NOT_FOUND, DEFAULT_EFFORT, DEFAULT_MODEL, entitlementError, preflightModel, resolveBinary, } from "../../open/launchers/claude.js";
+import { SESSION_ID_PATTERN, assertPluginDirectory, currentWorkingDirectory, finishOpenSession, playBoot, renderBanner, spawnHarness, } from "../../open/runtime.js";
 export { ROLES, parseRole, resolvePluginDir };
-const DEFAULT_MODEL = "claude-opus-4-8";
-const DEFAULT_EFFORT = "xhigh";
-const PLUGIN_NAME = "codedeck";
-const CLAUDE_NOT_FOUND = "Claude Code was not found on PATH. Install Claude Code and ensure `claude` is available.";
-const execFileAsync = promisify(execFile);
-/**
- * statusLine.command is handed to a shell, so an install directory carrying a
- * space, a `$`, a backtick or a quote would break the command or inject into
- * it. Single quotes take every one of those literally, and the only character
- * that can end them is a quote, which is why that one is spliced.
- *
- * plugin/settings.json quotes the same script with double quotes on purpose and
- * must keep doing so: it names the path through ${CLAUDE_PLUGIN_ROOT}, and
- * single quotes would stop the expansion instead of protecting it.
- */
-function shellQuote(value) {
-    return `'${value.replaceAll("'", `'\\''`)}'`;
-}
-function settingsArgument(pluginDir, flags) {
-    if (flags.theme !== false)
-        return path.join(pluginDir, "settings.json");
-    // Claude accepts an inline settings JSON value. Keep the status line while
-    // removing only the theme, without mutating the plugin's shared settings file.
-    return JSON.stringify({
-        statusLine: {
-            type: "command",
-            command: `bash ${shellQuote(path.join(pluginDir, "statusline.sh"))}`,
-        },
+export { effectiveModel };
+export { buildOpenArgs, buildSettings, entitlementError, judgeModel, sessionName } from "../../open/launchers/claude.js";
+export { CLAUDE_RESUME_ERASE, SESSION_ID_PATTERN, bootFrame, ensureCodedeckShim, exitCodeFor, finishOpenSession, installSigintGuard, renderBanner, renderExit, resumeHint, sanitizeEnv, spinnerTips, withCodedeckOnPath, writeStdoutSync, } from "../../open/runtime.js";
+const DEFAULT_ROLE = "orchestrator";
+export function launchClaude(claudeBin, model, args, cwd, sessionFile, onClose, spawnChild = spawn, signalHost = process, envExtra, pty, onSpawn) {
+    return spawnHarness(claudeBin, args, {
+        cwd,
+        sessionFile,
+        envExtra,
+        model,
+        notFoundMessage: CLAUDE_NOT_FOUND,
+        entitlementError,
+        onClose,
+        spawnChild,
+        signalHost,
+        pty,
+        onSpawn,
     });
 }
-export function buildOpenArgs(role, flags, pluginDir, passthrough) {
-    const args = [
-        "--model",
-        flags.model ?? DEFAULT_MODEL,
-        "--effort",
-        flags.effort ?? DEFAULT_EFFORT,
-        ...(flags.bypass !== false ? ["--dangerously-skip-permissions"] : []),
-        "--plugin-dir",
-        pluginDir,
-        "--append-system-prompt-file",
-        path.join(pluginDir, "ultra.md"),
-        "--settings",
-        settingsArgument(pluginDir, flags),
-        // `--agent` layers on top of Claude's own system prompt rather than
-        // replacing it, and an agent file with no `tools:` key inherits the whole
-        // toolset. So `general` carries its contract the same way the others do,
-        // with nothing taken away.
-        "--agent",
-        `${PLUGIN_NAME}:${role}`,
-        "-n",
-        `CodeDeck · ${role}`,
-        ...(flags.resume ? ["--resume", flags.resume] : []),
-        ...(flags.worktree ? ["-w"] : []),
-        ...passthrough,
-    ];
-    return args;
+/**
+ * What CodeDeck may type into this harness, or nothing when the harness has no
+ * command worth typing or the caller turned the pty off. Interactive only: a
+ * `--print` launch has no TUI to type into.
+ */
+export function ptyLaunchForHarness(harness, pluginDir, sessionFile, flags, config, interactive) {
+    if (!interactive)
+        return undefined;
+    if (flags.pty === false || config.pty === false)
+        return undefined;
+    const rename = harnessInjection(harness).rename;
+    if (!rename)
+        return undefined;
+    return { shim: ptyShimPath(pluginDir), sessionFile, keystrokesForName: rename };
 }
-const MODEL_PREFIX = "--model=";
 /**
- * Claude honours the last --model on the line and the passthrough is appended
- * last, so `open --model bad -- --model good` really launches "good". Checking
- * anything but the last one grounds a launch that would have worked.
- *
- * Only the passthrough is scanned, never the built vector. That vector always
- * opens with a --model pair, so scanning it could never answer "the passthrough
- * overrode nothing", and a bare "--model" swallowed as another flag's value (as
- * in `open --resume --model`) would be read as a model of its own.
+ * Width of each replacement verb in terminal columns. Keeping this fixed
+ * leaves Claude's elapsed-time and token-count fields aligned.
+ */
+export const SPINNER_VERB_WIDTH = 12;
+/**
+ * Why an agent bound to a harness without a launcher cannot be opened, or
+ * nothing. `open` launches claude and opencode sessions; anything else has no
+ * launcher, so refusing beats opening a session under a name whose
+ * configuration it does not follow.
  *
- * Known limit: a literal "--model" passed as the value of one of Claude's own
- * flags still reads as an override. Telling that apart needs Claude's option
- * arity, which CodeDeck does not have.
+ * The model is deliberately not part of the check. An explicit --model changes
+ * which binary runs, never whether it is the right harness.
+ */
+export function harnessMismatch(role, binding) {
+    if (!binding || binding.harness === "claude" || binding.harness === "opencode") {
+        return undefined;
+    }
+    return (`Agent "${role}" runs on ${binding.harness}, and ${getCliName()} open only launches claude and opencode sessions. ` +
+        `Use \`${getCliName()} run --role ${role} "<prompt>"\`, or move it with \`${getCliName()} setup\`.`);
+}
+/**
+ * Best-effort snapshot of `opencode session list`, or undefined. Capture
+ * is allowed to fail: no snapshot means no resume hint (OP-09), never a
+ * failed launch. No daemon, no config writes (OP-10, OP-19).
  */
-export function effectiveModel(passthrough) {
-    for (let i = passthrough.length - 1; i >= 0; i--) {
-        const token = passthrough[i];
-        if (token.startsWith(MODEL_PREFIX))
-            return token.slice(MODEL_PREFIX.length);
-        if (i > 0 && passthrough[i - 1] === "--model")
-            return token;
+export function readOpencodeSessions(bin, cwd) {
+    try {
+        const parsed = JSON.parse(execFileSync(bin, ["session", "list", "--format", "json", "-n", "50"], {
+            encoding: "utf8",
+            timeout: 10000,
+            maxBuffer: 1024 * 1024,
+            ...(cwd !== undefined ? { cwd } : {}),
+        }));
+        return Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
     }
 }
-export function sanitizeEnv(env) {
-    const sanitized = { ...env };
-    delete sanitized.CLAUDE_CODE_CHILD_SESSION;
-    return sanitized;
+/**
+ * The id of the session created or continued between snapshots, or
+ * undefined. A newly created session takes precedence; if no session was
+ * created, a single session whose updated timestamp moved forward is
+ * identified. Zero or ambiguous sessions mean "cannot tell", and a
+ * missing hint beats a wrong one.
+ */
+export function diffOpencodeSession(before, after) {
+    const known = new Set(before.map((row) => (typeof row.id === "string" ? row.id : "")));
+    const fresh = after.filter((row) => typeof row.id === "string" && !known.has(row.id));
+    if (fresh.length === 1)
+        return fresh[0].id;
+    if (fresh.length > 1)
+        return undefined;
+    const beforeUpdated = new Map();
+    for (const row of before) {
+        if (typeof row.id === "string" && typeof row.updated === "number") {
+            beforeUpdated.set(row.id, row.updated);
+        }
+    }
+    const touched = after.filter((row) => typeof row.id === "string" &&
+        typeof row.updated === "number" &&
+        beforeUpdated.has(row.id) &&
+        row.updated > (beforeUpdated.get(row.id) ?? 0));
+    if (touched.length === 1)
+        return touched[0].id;
+    if (touched.length > 1) {
+        touched.sort((a, b) => b.updated - a.updated);
+        if (touched[0].updated > touched[1].updated) {
+            return touched[0].id;
+        }
+    }
+    return undefined;
 }
-export function renderBanner(role, model, effort) {
-    return `${renderLogo(`${role} · ${model} · ${effort}`)}\n`;
+/**
+ * The one dispatch decision: the binding owns the harness, and an unbound
+ * role opens claude like it always did. Anything else throws instead of
+ * rounding down to the wrong session.
+ */
+export function launcherFor(role, binding) {
+    const harness = binding?.harness ?? "claude";
+    if (harness === "claude" || harness === "opencode")
+        return harness;
+    const mismatch = harnessMismatch(role, binding);
+    throw new Error(mismatch ?? `Agent "${role}" runs on ${harness}, which ${getCliName()} open does not launch.`);
 }
 function selectRole() {
     const rl = readline.createInterface({
@@ -128,8 +164,8 @@ function selectRole() {
             reject(new Error("Role selection was interrupted; nothing was launched."));
         });
         const ask = () => {
-            rl.question(`Role [general] (${ROLES.join("/")}): `, (answer) => {
-                const role = parseRole(answer || "general");
+            rl.question(`Role [${DEFAULT_ROLE}] (${ROLES.join("/")}): `, (answer) => {
+                const role = parseRole(answer || DEFAULT_ROLE);
                 if (role) {
                     finish(role);
                     return;
@@ -149,7 +185,7 @@ function selectRole() {
 export function isNonInteractiveLaunch(passthrough) {
     return passthrough.some((arg) => arg === "-p" || arg === "--print");
 }
-function resolveRole(input, interactive) {
+export function resolveRole(input, interactive) {
     if (input !== undefined) {
         const role = parseRole(input);
         if (!role) {
@@ -158,7 +194,7 @@ function resolveRole(input, interactive) {
         return Promise.resolve(role);
     }
     if (!interactive || !isInteractiveTerminal())
-        return Promise.resolve("general");
+        return Promise.resolve(DEFAULT_ROLE);
     return selectRole();
 }
 /**
@@ -204,13 +240,13 @@ export function scanOptions(tokens, command) {
         const name = separator >= 0 ? token.slice(0, separator) : token;
         const wantsValue = takesValue.get(name);
         if (wantsValue === undefined) {
-            throw new Error(`Unknown option "${name}" for codedeck open. Options for Claude go after "--".`);
+            throw new Error(`Unknown option "${name}" for ${getCliName()} open. Options for Claude go after "--".`);
         }
         // Commander honours "=" only on options declared with a value and drops the
         // whole token otherwise, so `--no-bypass=false` would read as accepted and
         // launch with the bypass still on.
         if (separator >= 0 && !wantsValue) {
-            throw new Error(`Option "${name}" for codedeck open takes no value.`);
+            throw new Error(`Option "${name}" for ${getCliName()} open takes no value.`);
         }
         // The next token belongs to this option even when it looks like a flag,
         // which is what keeps `--model -weird` from reading as an unknown option.
@@ -250,225 +286,23 @@ function getInvocation(command, roleArg) {
     }
     return { roleInput: roleArg, passthrough: [] };
 }
-function assertPluginDirectory(pluginDir) {
-    try {
-        if (fs.statSync(pluginDir).isDirectory())
-            return;
-    }
-    catch { }
-    throw new Error(`CodeDeck plugin directory not found at ${pluginDir}. Rebuild or reinstall CodeDeck before running open.`);
-}
-function currentWorkingDirectory() {
-    try {
-        const cwd = process.cwd();
-        if (fs.statSync(cwd).isDirectory())
-            return cwd;
-    }
-    catch { }
-    throw new Error("Cannot launch Claude Code: the current working directory no longer exists.");
-}
-function errorDetails(error) {
-    if (typeof error !== "object" || error === null)
-        return { text: String(error) };
-    const value = error;
-    const text = [value.stderr, value.stdout, value.message]
-        .filter((part) => typeof part === "string" && part.length > 0)
-        .join("\n");
-    return {
-        code: typeof value.code === "string" ? value.code : undefined,
-        text: text || String(error),
-    };
-}
-/**
- * What the catalog can say about a model. Reachable is not the same as allowed:
- * the catalog lists what Claude Code knows about, never what this account may
- * use, so an entitlement problem only surfaces at launch (see launchClaude).
- */
-const catalogWarning = (model, state) => `Warning: Claude model catalog is ${state}; continuing with "${model}".`;
-/**
- * Pure so all three outcomes are testable without touching the disk cache or
- * spawning a harness.
- */
-export function judgeModel(model, catalogs, fromConfig) {
-    const keepGoing = (reason) => ({
-        kind: "unknown-catalog",
-        warning: catalogWarning(model, `unavailable${reason}`),
-    });
-    const catalog = catalogs?.find((item) => item.agent === "claude");
-    if (!catalog || !catalog.available || catalog.error) {
-        return keepGoing(catalog?.error ? ` (${catalog.error})` : "");
-    }
-    const candidates = modelNames(catalog);
-    if (candidates.length === 0) {
-        return { kind: "unknown-catalog", warning: catalogWarning(model, "empty") };
-    }
-    if (candidates.includes(model))
-        return { kind: "ok" };
-    const suggestion = findClosestModel(model, candidates);
-    const hint = suggestion ? ` Did you mean "${suggestion}"?` : " No close model was found.";
-    // A model can leave the catalog on its own, with nobody having typed it
-    // wrong, and `needsModelSetup` never asks again, so the way out has to be
-    // spelled out.
-    const recovery = fromConfig ? " Run `codedeck setup` to pick another." : "";
-    return { kind: "rejected", error: `Model "${model}" is not in the Claude catalog.${hint}${recovery}` };
-}
-async function preflightModel(model, fromConfig) {
-    let catalogs;
-    try {
-        catalogs = await getCachedOrDiscoverModels(getRegistry(), { agent: "claude" });
-    }
-    catch (error) {
-        // A catalog that cannot be reached is not evidence against the model, so
-        // this warns and lets the launch decide.
-        const details = errorDetails(error);
-        console.warn(catalogWarning(model, `unavailable (${details.text})`));
-        return;
-    }
-    const verdict = judgeModel(model, catalogs, fromConfig);
-    if (verdict.kind === "ok")
-        return;
-    if (verdict.kind === "unknown-catalog") {
-        console.warn(verdict.warning);
-        return;
-    }
-    throw new Error(verdict.error);
-}
-/**
- * Returns the resolved path rather than a boolean so everything downstream
- * launches the exact binary that was checked, instead of asking PATH again and
- * hoping it answers the same way.
- */
-async function resolveClaudeBinary() {
-    // detectBinary reports failure in its result and never rejects, so there is
-    // nothing here to catch.
-    const installation = await detectBinary("claude");
-    if (!installation.installed || !installation.path) {
-        throw new Error(CLAUDE_NOT_FOUND);
-    }
-    return installation.path;
-}
-async function assertSystemPromptFlagSupported(claudeBin, cwd) {
-    try {
-        await execFileAsync(claudeBin, ["--append-system-prompt-file"], {
-            cwd,
-            env: sanitizeEnv(process.env),
-            timeout: 5000,
-            maxBuffer: 1024 * 1024,
-        });
-    }
-    catch (error) {
-        const details = errorDetails(error);
-        if (details.code === "ENOENT") {
-            throw new Error(CLAUDE_NOT_FOUND);
-        }
-        if (/unknown option|unknown argument|unrecognized option|invalid option/i.test(details.text)) {
-            throw new Error("This Claude Code version does not support --append-system-prompt-file. Upgrade Claude Code and retry.");
-        }
-        // A supported Commander option reports a missing argument for this probe.
-        // Other probe failures are left to the real launch, which can provide the
-        // harness-specific diagnostic without blocking a valid installation.
-    }
-}
-/**
- * Only stderr is piped, and only because Claude Code reports an unusable model
- * there as a tagged line rather than a distinct exit code. stdout stays
- * inherited so the TUI paints straight to the terminal, which also means
- * `child.stdout` is null and there is nothing to relay.
- */
-function relayStderr(child, output) {
-    const stream = child.stderr;
-    if (!stream)
-        return;
-    stream.setEncoding?.("utf8");
-    stream.on("data", (chunk) => {
-        output.value += typeof chunk === "string" ? chunk : chunk.toString();
-        process.stderr.write(chunk);
-    });
-}
-/**
- * A signalled death carries no exit code, and collapsing it to 1 tells a caller
- * the session failed rather than that it was killed. Shells report this as
- * 128 plus the signal number, so Ctrl+C stays 130 and a SIGKILL stays 137.
- */
-export function exitCodeFor(code, signal) {
-    if (code !== null)
-        return code;
-    if (!signal)
-        return 1;
-    const number = constants.signals[signal];
-    return typeof number === "number" ? 128 + number : 1;
-}
-/**
- * The catalog knows which models exist, not which ones this account may use, so
- * an entitlement problem can only be read off the launch itself. Claude Code
- * reports it as a tagged error rather than a distinct exit code.
- */
-export function entitlementError(model, output) {
-    const tag = /\[claude-code:unrecognized_model\]\s*(\{.*\})?/i.exec(output);
-    if (!tag)
-        return undefined;
-    // The passthrough can carry its own --model, which wins over the one CodeDeck
-    // resolved, so the name in the payload is the one that was actually rejected.
-    let rejected = model;
-    if (tag[1]) {
-        try {
-            const payload = JSON.parse(tag[1]);
-            if (typeof payload.model === "string" && payload.model)
-                rejected = payload.model;
-        }
-        catch { }
-    }
-    return `Claude Code rejected model "${rejected}" because this account is not entitled to it. Check the Claude plan or model access for the account.`;
-}
-function launchClaude(claudeBin, model, args, cwd) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const output = { value: "" };
-        const child = spawn(claudeBin, args, {
-            cwd,
-            env: sanitizeEnv(process.env),
-            stdio: ["inherit", "inherit", "pipe"],
-        });
-        relayStderr(child, output);
-        child.once("error", (error) => {
-            if (settled)
-                return;
-            settled = true;
-            const details = errorDetails(error);
-            if (details.code === "ENOENT") {
-                reject(new Error(CLAUDE_NOT_FOUND));
-            }
-            else {
-                reject(error);
-            }
-        });
-        child.once("close", (code, signal) => {
-            if (settled)
-                return;
-            settled = true;
-            const entitlement = entitlementError(model, output.value);
-            if (entitlement) {
-                reject(new Error(entitlement));
-                return;
-            }
-            process.exitCode = exitCodeFor(code, signal);
-            resolve();
-        });
-    });
-}
 export function registerOpenCommand(program) {
     program
         .command("open [role]")
-        .description("Open a configured Claude Code session")
+        .description(`Open a configured Claude Code session (roles: ${ROLES.join(" | ")}, default: ${DEFAULT_ROLE}, 3-letter prefixes accepted)`)
         .option("--model <model>", `model to use (default: ${DEFAULT_MODEL})`)
         .option("--effort <level>", `reasoning effort (default: ${DEFAULT_EFFORT})`)
-        .option("--resume <session>", "resume a Claude Code session")
+        .option("--autocompact [value]", "native auto-compact: Claude window size is auto or 100000-1000000 tokens; OpenCode toggles its native setting")
+        .option("--no-autocompact", "disable native auto-compaction in Claude and OpenCode")
+        .option("--resume <session>", "resume an interactive session")
         .option("--worktree", "ask Claude Code to create an isolated worktree")
         .option("--no-bypass", "do not skip Claude Code permission prompts")
-        .option("--no-theme", "keep the CodeDeck status line without applying its theme")
+        .option("--no-theme", "keep only the CodeDeck status line, without the theme or the renderer")
+        .option("--no-pty", "do not run the session under a pty, which also drops the automatic rename")
         .allowUnknownOption()
         .action(async (roleArg, opts, command) => {
         const invocation = getInvocation(command, roleArg);
+        const autocompact = parseAutocompact(opts.autocompact);
         const interactive = !isNonInteractiveLaunch(invocation.passthrough);
         const role = await resolveRole(invocation.roleInput, interactive);
         const pluginDir = resolvePluginDir();
@@ -480,19 +314,179 @@ export function registerOpenCommand(program) {
         // wrong question to greet someone with, and `codedeck setup` is the place
         // to answer it deliberately.
         const config = loadConfig();
-        const resolved = resolveModel("claude", opts.model, config) ?? DEFAULT_MODEL;
-        const args = buildOpenArgs(role, { ...opts, model: resolved }, pluginDir, invocation.passthrough);
-        const model = effectiveModel(invocation.passthrough) ?? resolved;
-        // It came from config only when nobody typed a model just now, neither by
-        // flag nor by passthrough, and the config actually had one.
-        const fromConfig = opts.model === undefined &&
-            effectiveModel(invocation.passthrough) === undefined &&
-            resolveModel("claude", undefined, config) !== undefined;
-        await preflightModel(model, fromConfig);
-        const claudeBin = await resolveClaudeBinary();
-        await assertSystemPromptFlagSupported(claudeBin, cwd);
-        process.stdout.write(renderBanner(role, model, opts.effort ?? DEFAULT_EFFORT));
-        await launchClaude(claudeBin, model, args, cwd);
+        const orchestratorMode = resolveOrchestratorMode(config);
+        const binding = resolveRoleBinding(role, config);
+        const launcher = launcherFor(role, binding);
+        const passthroughModel = effectiveModel(invocation.passthrough);
+        const { model: boundModel, fromConfig } = resolveOpenModel(role, { model: opts.model, passthroughModel }, config);
+        // Not the shared temp directory: `open` types the name it finds beside
+        // this file into a live session, and on Linux anyone on the box can put
+        // a file in /tmp under a name that is only a pid.
+        const sessionFile = path.join(sessionsDir(), `codedeck-session-${process.pid}`);
+        if (launcher === "opencode" && boundModel === undefined) {
+            throw new Error(`Agent "${role}" has no model bound. Run \`${getCliName()} setup\` to bind one.`);
+        }
+        const initialModel = passthroughModel ?? boundModel ?? (launcher === "opencode" ? undefined : DEFAULT_MODEL);
+        const adoptRes = await client.request("session.adopt", {
+            agent: launcher,
+            model: initialModel,
+            cwd,
+            name: role,
+        });
+        const runId = adoptRes.session.id;
+        let patchPromise;
+        try {
+            if (launcher === "opencode") {
+                let openCwd = cwd;
+                let wtInfo;
+                if (opts.worktree) {
+                    const gitInfo = await getGitInfo(cwd);
+                    if (!gitInfo) {
+                        throw new Error(`--worktree needs a git repository, and the current directory is outside one.`);
+                    }
+                    // A creation failure propagates before the spawn: OP-14 would
+                    // rather fail than open in the wrong cwd.
+                    const wt = await createWorktree({
+                        repoRoot: gitInfo.root,
+                        sessionId: runId,
+                        prompt: role,
+                        name: role,
+                    });
+                    wtInfo = wt;
+                    openCwd = wt.path;
+                }
+                const model = passthroughModel ?? boundModel;
+                await preflightOpencode(model, fromConfig);
+                const opencodeBin = await resolveOpencodeBinary();
+                // No opencode effort reader (probe-effort-2026-09-07): an explicit
+                // flag warns instead of dying silently, and the banner keeps
+                // naming "default" (OP-16, OP-23).
+                const effort = "default";
+                if (opts.effort !== undefined) {
+                    console.error('Warning: --effort has no effect on opencode (no mapped reader); continuing with "default".');
+                }
+                // --no-theme asks for no CodeDeck styling, and an animation is styling.
+                if (opts.theme === false) {
+                    process.stdout.write(renderBanner(role, model, effort));
+                }
+                else {
+                    await playBoot(role, model, effort);
+                }
+                // --no-theme leaves the user's own opencode theme alone. Otherwise the
+                // managed rage theme is ensured once and selected through an ephemeral
+                // config dir, so the user's tui.json is never rewritten.
+                const tuiDir = opts.theme === false || !ensureOpencodeTheme(pluginDir)
+                    ? undefined
+                    : createEphemeralTuiDir();
+                // Snapshot before the spawn so the close path can tell which
+                // session this launch created or continued (probe-session-id-2026-09-07).
+                const sessionsBefore = readOpencodeSessions(opencodeBin, openCwd);
+                const closeOpencode = async () => {
+                    if (tuiDir !== undefined)
+                        removeEphemeralTuiDir(tuiDir);
+                    const after = readOpencodeSessions(opencodeBin, openCwd);
+                    const diffedId = after === undefined || sessionsBefore === undefined
+                        ? undefined
+                        : diffOpencodeSession(sessionsBefore, after);
+                    const id = diffedId ?? (opts.resume && SESSION_ID_PATTERN.test(opts.resume) ? opts.resume : undefined);
+                    if (id !== undefined) {
+                        try {
+                            fs.writeFileSync(sessionFile, id);
+                        }
+                        catch { }
+                    }
+                    const nativeSessionId = finishOpenSession(role, sessionFile);
+                    try {
+                        if (patchPromise)
+                            await patchPromise;
+                    }
+                    catch { }
+                    try {
+                        await client.request("session.release", {
+                            id: runId,
+                            nativeSessionId,
+                        });
+                    }
+                    catch { }
+                };
+                await spawnHarness(opencodeBin, buildOpencodeArgs(role, { ...opts, model: boundModel }, invocation.passthrough), {
+                    cwd: openCwd,
+                    envExtra: {
+                        CODEDECK_RUN_ID: runId,
+                        OPENCODE_CONFIG_CONTENT: buildInlineConfig(pluginDir, role, orchestratorMode, { config, explicit: autocompact }),
+                        ...(tuiDir !== undefined ? { OPENCODE_CONFIG_DIR: tuiDir } : {}),
+                    },
+                    sessionFile,
+                    model,
+                    notFoundMessage: OPENCODE_NOT_FOUND,
+                    onClose: closeOpencode,
+                    onSpawn: (child) => {
+                        if (child.pid) {
+                            patchPromise = client.request("session.patch", {
+                                id: runId,
+                                pid: child.pid,
+                                ...(wtInfo ? { worktree: wtInfo.path, branch: wtInfo.branch, baseCommit: wtInfo.baseCommit ?? undefined, cwd: wtInfo.path } : {}),
+                            });
+                        }
+                    },
+                });
+                return;
+            }
+            const resolved = boundModel ?? DEFAULT_MODEL;
+            const args = buildOpenArgs(role, { ...opts, model: resolved, remoteControl: config.remoteControl, autocompact }, pluginDir, invocation.passthrough, cwd, orchestratorMode, config);
+            const model = passthroughModel ?? resolved;
+            await preflightModel(model, fromConfig);
+            const claudeBin = await resolveBinary();
+            await assertSupport(claudeBin, cwd);
+            const effort = opts.effort ?? DEFAULT_EFFORT;
+            // --no-theme asks for no CodeDeck styling, and an animation is styling.
+            if (opts.theme === false) {
+                process.stdout.write(renderBanner(role, model, effort));
+            }
+            else {
+                await playBoot(role, model, effort);
+            }
+            const closeClaude = async () => {
+                if (!fs.existsSync(sessionFile) && opts.resume && SESSION_ID_PATTERN.test(opts.resume)) {
+                    try {
+                        fs.writeFileSync(sessionFile, opts.resume);
+                    }
+                    catch { }
+                }
+                const nativeSessionId = finishOpenSession(role, sessionFile);
+                try {
+                    if (patchPromise)
+                        await patchPromise;
+                }
+                catch { }
+                try {
+                    await client.request("session.release", {
+                        id: runId,
+                        nativeSessionId,
+                    });
+                }
+                catch { }
+            };
+            await launchClaude(claudeBin, model, args, cwd, sessionFile, closeClaude, undefined, undefined, { CODEDECK_RUN_ID: runId }, ptyLaunchForHarness("claude", pluginDir, sessionFile, opts, config, interactive), (child) => {
+                if (child.pid) {
+                    patchPromise = client.request("session.patch", {
+                        id: runId,
+                        pid: child.pid,
+                    });
+                }
+            });
+        }
+        catch (err) {
+            try {
+                await client.request("session.release", {
+                    id: runId,
+                    status: "failed",
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            catch { }
+            throw err;
+        }
     });
 }
 //# sourceMappingURL=open.js.map