@litfamily/litopencode 1.0.28 → 1.0.30

package/dist/activation.js

@@ -7,6 +7,7 @@ import { autoHandoffSettingText } from "./auto-handoff.js";
 import { isReadOnlyWorkflowFamilyPlan } from "./workflow-families.js";
 import { queryKnowledge } from "./knowledge.js";
 import { activationDiscipline } from "./activation-probe.js";
+import { decideReentry } from "./activation-reentry.js";
 import { micro, supportsMarkGlyphs } from "./lit-mark.js";
 // Prompt modules preserve minimum-first, single-task or few-task planning, avoidable custom code review,
 // and external-source safety; this module only coordinates their unchanged activation surfaces.
@@ -14,7 +15,7 @@ export { litHandoffPromptInjection, scientificVisualizationPromptInjection } fro
 export { litActivationBanner } from "./activation-prompt-utils.js";
 export { litLoopPromptInjection, litPlanPromptInjection } from "./activation-primary-prompts.js";
 export { containsStandaloneLitTrigger, detectChatActivationMode } from "./activation-routing.js";
-export { comprehendPromptInjection, debuggingPromptInjection, deepInterviewPromptInjection, gitMasterPromptInjection, litCruciblePromptInjection, initDeepPromptInjection, litGoalPromptInjection, litRecapPromptInjection, litResearchPromptInjection, lspPromptInjection, lspSetupPromptInjection, litCodePromptInjection, refactorPromptInjection, removeAiSlopsPromptInjection, browserDrivePromptInjection, structuralSearchPromptInjection, rulesPromptInjection, reviewWorkPromptInjection, startWorkChatPromptInjection, startWorkPromptInjection, litBurnoffFilePromptInjection, litFetchPromptInjection, litHumanizerPromptInjection } from "./activation-workflow-prompts.js";
+export { comprehendPromptInjection, debuggingPromptInjection, deepInterviewPromptInjection, gitMasterPromptInjection, litBrainstormPromptInjection, litCruciblePromptInjection, initDeepPromptInjection, litGoalPromptInjection, litRecapPromptInjection, litResearchPromptInjection, lspPromptInjection, lspSetupPromptInjection, litCodePromptInjection, refactorPromptInjection, removeAiSlopsPromptInjection, browserDrivePromptInjection, structuralSearchPromptInjection, rulesPromptInjection, reviewModeForcedNote, reviewWorkPromptInjection, startWorkChatPromptInjection, startWorkPromptInjection, litBurnoffFilePromptInjection, litFetchPromptInjection, litHumanizerPromptInjection } from "./activation-workflow-prompts.js";
 export function showActivationToast(client, skillId, env = process.env) {
     const label = `🔥 LIT IGNITED · ${activationDiscipline(skillId)} 🔥`;
     const message = supportsMarkGlyphs(env)
@@ -134,7 +135,8 @@ export function createChatMessageActivationHook(projectRoot, options = {}) {
         if (mode === undefined || childSession)
             return;
         const trigger = mode === "lit-handoff" ? "handoff" : mode === "lit-scientific-visualization" ? mode : "lit";
-        let activationText = promptForChatActivationMode(mode, nonEmptyTextParts.find((part) => detectChatActivationMode(part.text, agent) === mode)?.text);
+        const triggerText = nonEmptyTextParts.find((part) => detectChatActivationMode(part.text, agent) === mode)?.text;
+        let activationText = promptForChatActivationMode(mode, triggerText);
         if (mode === "start-work" && agent !== "lit-plan" && nonEmptyTextParts.length === 1) {
             const directive = parseStartWorkLifecycleDirective(nonEmptyTextParts[0].text, { chat: true });
             if (directive?.action === "resume") {
@@ -147,25 +149,50 @@ export function createChatMessageActivationHook(projectRoot, options = {}) {
                 }
             }
         }
+        const reentry = options.activationMemory === undefined
+            ? { kind: "full" }
+            : await decideReentry({
+                memory: options.activationMemory,
+                projectRoot,
+                sessionID: input.sessionID,
+                mode,
+                text: triggerText ?? ""
+            });
+        const markMode = reentry.kind === "continue" ? reentry.mode : mode;
+        if (reentry.kind === "continue")
+            activationText = reentry.text;
+        else if (reentry.kind === "resume")
+            activationText = `${reentry.line}\n${activationText}`;
+        else if (reentry.kind === "confirm")
+            activationText = `${activationText}\n${reentry.line}`;
         output.parts.push({
-            id: `prt_litopencode_${mode.replace("-", "_")}_${idSuffix(input.messageID ?? output.message.id)}`,
+            id: `prt_litopencode_${markMode.replace("-", "_")}_${idSuffix(input.messageID ?? output.message.id)}`,
             sessionID: input.sessionID,
             messageID: input.messageID ?? output.message.id,
             type: "text",
             text: activationText,
             metadata: {
                 litopencode: {
-                    mode,
+                    mode: markMode,
                     trigger,
-                    source: "chat.message"
+                    source: "chat.message",
+                    ...(reentry.kind === "full" ? {} : { reentry: reentry.kind })
                 }
             }
         });
-        await options.onSkillActivation?.(input.sessionID, mode, nonEmptyTextParts.some((part) => endsWithStandaloneLitInvocation(part.text)));
+        const appendedLit = nonEmptyTextParts.some((part) => endsWithStandaloneLitInvocation(part.text));
+        if (reentry.kind === "continue") {
+            await options.onSkillContinue?.(input.sessionID, markMode, appendedLit);
+            return;
+        }
+        await options.onSkillActivation?.(input.sessionID, mode, appendedLit);
+        if (reentry.kind !== "confirm" && mode !== "lit-handoff" && mode !== "lit-scientific-visualization") {
+            options.activationMemory?.remember(input.sessionID, mode);
+        }
         if (mode === "lit-scientific-visualization") {
             options.onScientificVisualizationActivation?.(input.sessionID);
         }
-        if (mode === "lit-task" || mode === "lit-recap" || isReadOnlyWorkflowFamilyPlan(mode))
+        if (mode === "lit-task" || mode === "lit-recap" || mode === "lit-brainstorm" || isReadOnlyWorkflowFamilyPlan(mode))
             return;
         try {
             await operations.init();

package/dist/cli/args.js

@@ -1,5 +1,6 @@
 import os from "node:os";
 import path from "node:path";
+import { hostChoices, isHostChoice } from "./host-detect.js";
 import { installModelEfforts, isInstallModelEffort, resolveModelRoute } from "./model-catalog.js";
 export const loopCommands = [
     "create-goals",
@@ -54,6 +55,7 @@ export function parseArgs(argv) {
     let summary;
     let directive;
     let resolve;
+    let host = "auto";
     if (command === "--help" || command === "-h") {
         command = "help";
     }
@@ -244,6 +246,17 @@ export function parseArgs(argv) {
             index += 1;
             continue;
         }
+        if (arg === "--host") {
+            const value = argv[index + 1];
+            if (!value)
+                throw new Error("--host requires a value");
+            const cleaned = cleanOption(value, "--host") ?? "";
+            if (!isHostChoice(cleaned))
+                throw new Error("--host must be one of " + hostChoices.join(", "));
+            host = cleaned;
+            index += 1;
+            continue;
+        }
         if (arg === "--yes") {
             yes = true;
             continue;
@@ -302,6 +315,7 @@ export function parseArgs(argv) {
         modelPrompt: yes ? "never" : modelPrompt,
         outputStylePrompt: yes ? "never" : "auto",
         ...(tuiAction === undefined ? {} : { tuiAction }),
+        host,
         loop: {
             projectRoot,
             json: loopJson,

package/dist/cli/auto-update.js

@@ -1,11 +1,10 @@
-import { execFile } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { promisify } from "node:util";
 import { defaultOpenCodeConfigRoot } from "../state.js";
 import { compareStableVersions, parseStableVersion, requestRegistryLatestVersion } from "./update-notifier.js";
+import { execCommand } from "./command-plan.js";
 import { readPackageMetadata } from "./json.js";
 export const autoUpdatePackageName = "@litfamily/litopencode";
 export const autoUpdateTimeoutMs = 30_000;
@@ -23,7 +22,6 @@ const journalFileName = "auto-update-journal.jsonl";
 const installLockFileName = "auto-update-install.lock";
 const checkFileName = "auto-update-check.json";
 const maxCommandOutputBytes = 4 * 1024 * 1024;
-const execFileAsync = promisify(execFile);
 /**
  * The staged CLI needs Node. Inside OpenCode the plugin runs on a Bun-compiled
  * host binary, and process.execPath names that binary rather than a Node
@@ -127,7 +125,7 @@ function failureKind(step, error) {
     };
 }
 async function defaultRunCommand(command, args, options) {
-    return await execFileAsync(command, [...args], options);
+    return await execCommand(command, args, options);
 }
 async function bounded(operation, timeoutMs) {
     let timer;

package/dist/cli/command-plan.d.ts

@@ -0,0 +1,40 @@
+/**
+ * How to start a command so Windows accepts it. Node refuses to spawn a `.cmd` or `.bat` file
+ * without a shell (CVE-2024-27980, `spawn EINVAL`), and a bare `npm` or `opencode` is not found
+ * there because only the `.cmd` shim exists. POSIX runs the command as given.
+ */
+export type CommandPlan = {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly shell: boolean;
+};
+export type CommandPlanContext = {
+    readonly platform?: NodeJS.Platform;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly execPath?: string;
+    readonly versions?: Readonly<Record<string, string | undefined>>;
+    /** The path of a command on PATH, PATHEXT included. */
+    readonly find?: (command: string) => string | undefined;
+    readonly exists?: (file: string) => boolean;
+};
+/** One cmd.exe argument in double quotes. Refuses what quotes cannot protect, so a value never becomes shell syntax. */
+export declare function quoteForCmd(value: string): string;
+export declare function commandPlan(command: string, args: readonly string[], context?: CommandPlanContext): CommandPlan;
+/**
+ * npm without a `.cmd` shim in the way. Inside OpenCode the plugin runs on a Bun host binary, so
+ * `process.execPath` is not Node: npm is found through its shim's own directory instead, and only
+ * then through a quoted shell.
+ */
+export declare function npmPlan(args: readonly string[], context?: CommandPlanContext): CommandPlan;
+type ExecOptions = {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly cwd?: string;
+    readonly timeout?: number;
+    readonly maxBuffer?: number;
+};
+/** `execFile` through a CommandPlan; `npm` is resolved by `npmPlan`. A failure keeps the child's stderr and exit code. */
+export declare function execCommand(command: string, args: readonly string[], options?: ExecOptions): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export {};

package/dist/cli/command-plan.js

@@ -0,0 +1,62 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import { findCommandOnPath } from "./host-detect.js";
+const shimPattern = /\.(?:cmd|bat)$/iu;
+const unquotableCharacters = /["%\r\n\0]/u;
+/** One cmd.exe argument in double quotes. Refuses what quotes cannot protect, so a value never becomes shell syntax. */
+export function quoteForCmd(value) {
+    if (unquotableCharacters.test(value))
+        throw new Error("A Windows command argument may not contain a quote, a percent sign or a line break.");
+    return `"${value.replace(/(\\+)$/u, "$1$1")}"`;
+}
+function resolveCommand(command, context) {
+    if (command.includes("/") || command.includes("\\"))
+        return command;
+    const find = context.find ?? ((name) => findCommandOnPath(name, context.env ?? process.env, "win32"));
+    return find(command) ?? command;
+}
+export function commandPlan(command, args, context = {}) {
+    if ((context.platform ?? process.platform) !== "win32")
+        return { command, args, shell: false };
+    const resolved = resolveCommand(command, context);
+    if (!shimPattern.test(resolved))
+        return { command: resolved, args, shell: false };
+    return { command: quoteForCmd(resolved), args: args.map(quoteForCmd), shell: true };
+}
+/**
+ * npm without a `.cmd` shim in the way. Inside OpenCode the plugin runs on a Bun host binary, so
+ * `process.execPath` is not Node: npm is found through its shim's own directory instead, and only
+ * then through a quoted shell.
+ */
+export function npmPlan(args, context = {}) {
+    if ((context.platform ?? process.platform) !== "win32")
+        return { command: "npm", args, shell: false };
+    const env = context.env ?? process.env;
+    const execPath = context.execPath ?? process.execPath;
+    const versions = context.versions ?? process.versions;
+    const exists = context.exists ?? ((file) => fs.existsSync(file));
+    const npmCli = env.npm_execpath;
+    if (npmCli !== undefined && /\.[cm]?js$/iu.test(npmCli) && versions.bun === undefined && /^node(?:\.exe)?$/iu.test(path.win32.basename(execPath))) {
+        return { command: execPath, args: [npmCli, ...args], shell: false };
+    }
+    const shim = resolveCommand("npm", context);
+    if (shimPattern.test(shim)) {
+        const directory = path.win32.dirname(shim);
+        const cli = path.win32.join(directory, "node_modules", "npm", "bin", "npm-cli.js");
+        if (exists(cli)) {
+            const sibling = path.win32.join(directory, "node.exe");
+            const node = exists(sibling) ? sibling : resolveCommand("node", context);
+            return { command: node, args: [cli, ...args], shell: false };
+        }
+    }
+    return commandPlan("npm", args, { ...context, platform: "win32" });
+}
+const execFileAsync = promisify(execFile);
+/** `execFile` through a CommandPlan; `npm` is resolved by `npmPlan`. A failure keeps the child's stderr and exit code. */
+export async function execCommand(command, args, options = {}) {
+    const context = { env: options.env ?? process.env };
+    const plan = command === "npm" ? npmPlan(args, context) : commandPlan(command, args, context);
+    return await execFileAsync(plan.command, [...plan.args], { ...options, encoding: "utf8", shell: plan.shell, windowsHide: true });
+}

package/dist/cli/doctor.d.ts

@@ -1,4 +1,5 @@
 import type { CliResult } from "./types.ts";
+import { type HostChoice } from "./host-detect.ts";
 /**
  * Doctor reads the receipt and the record each OpenCode start leaves behind. It
  * cannot see inside a running OpenCode, so "running" means the last start seen.
@@ -13,4 +14,6 @@ export declare function inspectAutoUpdate(input: {
  * directory, and without one the directory itself.
  */
 export declare function doctorProjectRoot(cwd?: string): string;
-export declare function doctor(root: string): Promise<CliResult>;
+/** OpenCode 2's update policy for plugins, read from the shared `autoupdate` setting and its opt-out variable. */
+export declare function openCode2UpdatePolicy(config: Record<string, unknown> | null, env?: NodeJS.ProcessEnv): "auto" | "notify" | "off";
+export declare function doctor(root: string, hostChoice?: HostChoice): Promise<CliResult>;

package/dist/cli/doctor.js

@@ -15,7 +15,9 @@ import { autoHandoffEnvEnabled, autoHandoffEnvPercent, createAutoHandoffSettings
 import { inspectLspCapability } from "./lsp-capability.js";
 import { probeMotionRuntime } from "./motion-runtime.js";
 import { isLitOpenCodeEntry } from "./plugin-mutation.js";
-import { inspectTuiPlugin } from "./tui-config.js";
+import { inspectTuiPlugin, planCliJsonCleanup } from "./tui-config.js";
+import { detectOpenCodeHosts, targetsV1, targetsV2 } from "./host-detect.js";
+import { defaultOpenCodeConfigRoot } from "../state.js";
 import { autoUpdateCheckPath, autoUpdateInstallLockPath, autoUpdateJournalPath, autoUpdateReceiptPath, isAutoUpdateDisabled, readAutoUpdateCheck, readAutoUpdateReceipt } from "./auto-update.js";
 const updateNow = "npx @litfamily/litopencode@latest install";
 /** Each row says what a cause means and the one thing to do about it. */
@@ -162,7 +164,32 @@ export function doctorProjectRoot(cwd = process.cwd()) {
             return start;
     }
 }
-export async function doctor(root) {
+/** OpenCode 2's update policy for plugins, read from the shared `autoupdate` setting and its opt-out variable. */
+export function openCode2UpdatePolicy(config, env = process.env) {
+    const disabled = env.OPENCODE_DISABLE_AUTOUPDATE;
+    if (disabled !== undefined && disabled !== "" && disabled !== "0" && disabled.toLowerCase() !== "false")
+        return "off";
+    const value = config?.autoupdate;
+    if (value === false)
+        return "off";
+    if (value === "notify")
+        return "notify";
+    return "auto";
+}
+async function litEntryCount(root, config, packageName) {
+    const entries = [
+        ...(Array.isArray(config?.plugin) ? config.plugin : []),
+        ...(Array.isArray(config?.plugins) ? config.plugins : [])
+    ];
+    let count = 0;
+    for (const entry of entries) {
+        const id = typeof entry === "object" && entry !== null && !Array.isArray(entry) ? entry.package : pluginEntryId(entry);
+        if (isLitOpenCodeEntry(id) || (typeof id === "string" && (await isLocalPackageEntry(root, id, packageName))))
+            count += 1;
+    }
+    return count;
+}
+export async function doctor(root, hostChoice = "auto") {
     const metadata = await readPackageMetadata();
     const loaded = await loadConfig(root);
     const openCodeLitConfigPath = litOpenCodeConfigFileForOpenCodeRoot(root);
@@ -206,6 +233,25 @@ export async function doctor(root) {
         config: autoHandoffConfig.autoHandoff
     }).resolve();
     const hostCompaction = inspectHostCompactionPoint(hostConfig.config);
+    // Doctor never starts a host: it reads the npm package behind each command, and on a custom root only
+    // that root's config files.
+    const defaultRoot = path.resolve(root) === path.resolve(defaultOpenCodeConfigRoot());
+    const host = await detectOpenCodeHosts({
+        root,
+        override: hostChoice,
+        ...(defaultRoot ? {} : { resolvePackage: async () => undefined })
+    });
+    const forV1 = targetsV1(host.mode);
+    const forV2 = targetsV2(host.mode);
+    const pluginEntries = await litEntryCount(root, hostConfig.config, metadata.name);
+    const cliJson = await planCliJsonCleanup(root).then((plan) => ({ path: plan.path, stale: plan.removed }), (error) => ({ path: path.join(path.resolve(root), "cli.json"), stale: 0, error: error instanceof Error ? error.message : String(error) }));
+    const hostOnlyPresent = ["permissions", "policies"].filter((key) => hostConfig.config !== null && key in hostConfig.config);
+    const hostOnlyKeys = {
+        present: hostOnlyPresent,
+        breaksOpenCode1: forV1 && hostOnlyPresent.includes("permissions"),
+        note: "OpenCode 1 refuses to start when the shared opencode.json holds the OpenCode 2 `permissions` key. LitOpenCode never writes `permissions` or `policies`."
+    };
+    const openCode2Ok = !forV2 || (pluginEntries === 1 && cliJson.stale === 0);
     const autoHandoffWarnings = [...autoHandoff.warnings];
     if (autoHandoff.enabled && autoHandoff.percent !== null && hostCompaction.percent !== null && autoHandoff.percent >= hostCompaction.percent) {
         autoHandoffWarnings.push(`OpenCode compacts on its own at about ${hostCompaction.percent}% of the context window. Your ${autoHandoff.percent}% is at or above that, so the host compacts first and the handoff has no time to run. Choose a percent below ${hostCompaction.percent}.`);
@@ -216,7 +262,19 @@ export async function doctor(root) {
             package: metadata,
             capabilities: openCodeHostCapabilities(),
             hostLimits: { path: hostConfig.path, ...inspectHostLimits(hostConfig.config) },
-            lsp: inspectLspCapability(hostConfig.config),
+            host: {
+                mode: host.mode,
+                binaries: host.binaries,
+                ...(host.unplaced === undefined ? {} : { unplaced: host.unplaced }),
+                evidence: host.evidence,
+                ...(host.override === undefined ? {} : { override: host.override }),
+                updatePolicy: forV2 ? openCode2UpdatePolicy(hostConfig.config) : null,
+                note: "OpenCode 1 runs as `opencode` and OpenCode 2 as `opencode2` when both are installed; they share this config folder."
+            },
+            lsp: {
+                ...inspectLspCapability(hostConfig.config),
+                ...(forV2 ? { openCode2: "OpenCode 2 accepts the lsp settings but does not run language servers, so it reports no diagnostics from them." } : {})
+            },
             autoHandoff: {
                 enabled: autoHandoff.enabled,
                 percent: autoHandoff.percent,
@@ -273,8 +331,11 @@ export async function doctor(root) {
                 pinnedVersion: installPlugin.configured?.startsWith(`${metadata.name}@`) === true ? installPlugin.configured.slice(metadata.name.length + 1) : null
             }),
             install: {
-                ok: installPlugin.ok && commandAliases.ok && nativeSkills.ok,
+                ok: installPlugin.ok && commandAliases.ok && nativeSkills.ok && openCode2Ok && !hostOnlyKeys.breaksOpenCode1,
                 plugin: installPlugin,
+                pluginEntries,
+                cliJson,
+                hostOnlyKeys,
                 commandAliases,
                 nativeSkills,
                 tui

package/dist/cli/host-detect.d.ts

@@ -0,0 +1,58 @@
+export declare const hostChoices: readonly ["auto", "v1", "v2", "both"];
+export type HostChoice = (typeof hostChoices)[number];
+export type HostMode = "v1" | "v2" | "both" | "none";
+export type HostMajor = 1 | 2;
+export type HostCommand = "opencode" | "opencode2";
+export type HostBinary = {
+    readonly command: HostCommand;
+    readonly major: HostMajor;
+    readonly version: string;
+};
+export type HostDetection = {
+    readonly mode: HostMode;
+    readonly binaries: readonly HostBinary[];
+    /** Commands on PATH with no npm package behind them, and the host each one was taken for. */
+    readonly unplaced?: readonly {
+        readonly command: HostCommand;
+        readonly major: HostMajor;
+    }[];
+    readonly evidence: {
+        readonly cliJson: boolean;
+        readonly tuiJson: boolean;
+    };
+    readonly v1Command?: string;
+    readonly v2Command?: string;
+    readonly override?: Exclude<HostChoice, "auto">;
+};
+export type PackageLike = {
+    readonly name: string;
+    readonly version: string;
+};
+export type HostDetectOptions = {
+    readonly root: string;
+    /** Injected package lookup; with it, PATH is only read through `findCommand`. */
+    readonly resolvePackage?: (command: string) => Promise<PackageLike | undefined>;
+    /** The real path of a command on PATH, or undefined. */
+    readonly findCommand?: (command: string) => string | undefined;
+    readonly override?: HostChoice;
+};
+type PathEnv = {
+    readonly PATH?: string;
+    readonly PATHEXT?: string;
+};
+export declare function isHostChoice(value: string): value is HostChoice;
+/** A command on PATH. On Windows the PATHEXT extensions are tried too, so an npm `opencode.cmd` is found. */
+export declare function findCommandOnPath(command: string, env?: PathEnv, platform?: NodeJS.Platform): string | undefined;
+/** The npm package that provides a command on PATH, found by following its link to the package folder. */
+export declare function resolveCommandPackage(command: string, env?: PathEnv, platform?: NodeJS.Platform): Promise<PackageLike | undefined>;
+export declare function detectOpenCodeHosts(options: HostDetectOptions): Promise<HostDetection>;
+/**
+ * Confirms an `opencode` that was only guessed to be OpenCode 1 (no npm package behind it) by asking its
+ * version, so `opencode plugin` never runs on OpenCode 2. A 2.x answer makes it OpenCode 2; no readable
+ * answer keeps the guess. Runs nothing when there is no guess to confirm.
+ */
+export declare function confirmUnplacedOpenCode(detection: HostDetection, readVersion: (command: string) => Promise<string | undefined>): Promise<HostDetection>;
+/** Whether a detection result means the OpenCode 1 or the OpenCode 2 surfaces must be installed. A host-less result keeps the OpenCode 1 behaviour. */
+export declare function targetsV1(mode: HostMode): boolean;
+export declare function targetsV2(mode: HostMode): boolean;
+export {};

package/dist/cli/host-detect.js

@@ -0,0 +1,199 @@
+// Which OpenCode hosts are installed. OpenCode 1 ships as the npm package `opencode-ai` with the
+// `opencode` command; OpenCode 2 ships as `@opencode/cli` with both `opencode` and `opencode2`. When both
+// are kept, OpenCode 1 stays `opencode` and OpenCode 2 is run as `opencode2`; they share
+// ~/.config/opencode. Detection never starts a host: it reads the npm package behind each command on
+// PATH. Only OpenCode 2 ships `opencode2`, so any `opencode2` on PATH is OpenCode 2. An `opencode` it
+// cannot place (the curl installer, Homebrew, mise, a Windows shim it cannot read) is taken for OpenCode 1,
+// because OpenCode 1 keeps its install however it was installed, unless it is the same file as
+// `opencode2`. That guess is confirmed by `confirmUnplacedOpenCode` (which runs `opencode --version`)
+// before the installer runs `opencode plugin` on it. With no command on PATH, config files are the
+// evidence: cli.json is written only by OpenCode 2, tui.json is OpenCode 1's TUI config. `--host`
+// overrides the result.
+import fs from "node:fs";
+import path from "node:path";
+export const hostChoices = ["auto", "v1", "v2", "both"];
+const commands = ["opencode", "opencode2"];
+const hostPackages = ["opencode-ai", "@opencode/cli"];
+const shimLimitBytes = 64 * 1024;
+export function isHostChoice(value) {
+    return hostChoices.includes(value);
+}
+function packageMajor(pkg) {
+    if (pkg.name === "opencode-ai")
+        return 1;
+    if (pkg.name === "@opencode/cli")
+        return 2;
+    return undefined;
+}
+/** A command on PATH. On Windows the PATHEXT extensions are tried too, so an npm `opencode.cmd` is found. */
+export function findCommandOnPath(command, env = process.env, platform = process.platform) {
+    const windows = platform === "win32";
+    const extensions = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((ext) => ext !== "").map((ext) => ext.toLowerCase());
+    // npm leaves an extensionless sh script next to `x.cmd`; Windows never runs it, so a bare name matches only with an extension.
+    const names = windows
+        ? [...(extensions.some((ext) => command.toLowerCase().endsWith(ext)) ? [command] : []), ...extensions.map((ext) => command + ext)]
+        : [command];
+    for (const directory of (env.PATH ?? "").split(windows ? ";" : path.delimiter)) {
+        if (directory === "")
+            continue;
+        for (const name of names) {
+            const candidate = path.join(directory, name);
+            try {
+                fs.accessSync(candidate, windows ? fs.constants.F_OK : fs.constants.X_OK);
+                if (fs.statSync(candidate).isFile())
+                    return candidate;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return undefined;
+}
+function readPackageJson(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (typeof parsed === "object" && parsed !== null && typeof parsed.name === "string") {
+            const { name, version } = parsed;
+            return { name, version: typeof version === "string" ? version : "" };
+        }
+    }
+    catch {
+        // No readable package.json here.
+    }
+    return undefined;
+}
+/**
+ * npm on Windows puts a small `.cmd`/`.ps1` shim next to its `node_modules` instead of a link. The shim is
+ * read as text, never run, for the host package path it names.
+ */
+function packageFromShim(file) {
+    let text;
+    try {
+        if (fs.statSync(file).size > shimLimitBytes)
+            return undefined;
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const normalized = text.replace(/\\/gu, "/");
+    for (const name of hostPackages) {
+        if (!normalized.includes(`node_modules/${name}/`))
+            continue;
+        return readPackageJson(path.join(path.dirname(file), "node_modules", ...name.split("/"), "package.json")) ?? { name, version: "" };
+    }
+    return undefined;
+}
+/** The npm package that provides a command on PATH, found by following its link to the package folder. */
+export async function resolveCommandPackage(command, env = process.env, platform = process.platform) {
+    const found = findCommandOnPath(command, env, platform);
+    if (found === undefined)
+        return undefined;
+    let directory;
+    try {
+        directory = path.dirname(fs.realpathSync(found));
+    }
+    catch {
+        return undefined;
+    }
+    for (let depth = 0; depth < 4; depth += 1) {
+        // Only a host package counts: on Windows the walk starts in the npm folder, where an unrelated
+        // package.json further up must not hide the package the shim names.
+        const pkg = readPackageJson(path.join(directory, "package.json"));
+        if (pkg !== undefined && hostPackages.includes(pkg.name))
+            return pkg;
+        const parent = path.dirname(directory);
+        if (parent === directory)
+            break;
+        directory = parent;
+    }
+    return packageFromShim(found);
+}
+function realCommandPath(command) {
+    const found = findCommandOnPath(command);
+    if (found === undefined)
+        return undefined;
+    try {
+        return fs.realpathSync(found);
+    }
+    catch {
+        return found;
+    }
+}
+async function probe(command, options) {
+    const pkg = await (options.resolvePackage ?? resolveCommandPackage)(command);
+    const major = pkg === undefined ? undefined : packageMajor(pkg);
+    return pkg === undefined || major === undefined ? undefined : { command, major, version: pkg.version };
+}
+function modeOf(v1, v2) {
+    if (v1 && v2)
+        return "both";
+    if (v1)
+        return "v1";
+    if (v2)
+        return "v2";
+    return "none";
+}
+function summarize(binaries, unplaced, evidence, override) {
+    const hosts = [...binaries, ...unplaced];
+    const v1Command = hosts.find((host) => host.major === 1)?.command;
+    const v2Command = hosts.find((host) => host.major === 2)?.command;
+    const detected = hosts.length > 0 ? modeOf(v1Command !== undefined, v2Command !== undefined) : modeOf(evidence.tuiJson, evidence.cliJson);
+    return {
+        mode: override ?? detected,
+        binaries,
+        ...(unplaced.length === 0 ? {} : { unplaced }),
+        evidence,
+        ...(v1Command === undefined ? {} : { v1Command }),
+        ...(v2Command === undefined ? {} : { v2Command }),
+        ...(override === undefined ? {} : { override })
+    };
+}
+export async function detectOpenCodeHosts(options) {
+    const binaries = [];
+    for (const command of commands) {
+        const binary = await probe(command, options);
+        if (binary !== undefined)
+            binaries.push(binary);
+    }
+    const findCommand = options.findCommand ?? (options.resolvePackage === undefined ? realCommandPath : () => undefined);
+    const placed = (command) => binaries.some((binary) => binary.command === command);
+    const opencodeFile = placed("opencode") ? undefined : findCommand("opencode");
+    const opencode2File = placed("opencode2") ? undefined : findCommand("opencode2");
+    const unplaced = [];
+    if (opencodeFile !== undefined) {
+        const sameAsOpenCode2 = findCommand("opencode2") === opencodeFile;
+        unplaced.push({ command: "opencode", major: sameAsOpenCode2 ? 2 : 1 });
+    }
+    if (opencode2File !== undefined)
+        unplaced.push({ command: "opencode2", major: 2 });
+    const evidence = {
+        cliJson: fs.existsSync(path.join(options.root, "cli.json")),
+        tuiJson: fs.existsSync(path.join(options.root, "tui.json")) || fs.existsSync(path.join(options.root, "tui.jsonc"))
+    };
+    const override = options.override === undefined || options.override === "auto" ? undefined : options.override;
+    return summarize(binaries, unplaced, evidence, override);
+}
+/**
+ * Confirms an `opencode` that was only guessed to be OpenCode 1 (no npm package behind it) by asking its
+ * version, so `opencode plugin` never runs on OpenCode 2. A 2.x answer makes it OpenCode 2; no readable
+ * answer keeps the guess. Runs nothing when there is no guess to confirm.
+ */
+export async function confirmUnplacedOpenCode(detection, readVersion) {
+    const guess = detection.unplaced?.find((entry) => entry.command === "opencode" && entry.major === 1);
+    if (guess === undefined)
+        return detection;
+    const major = /(\d+)\.\d+\.\d+/u.exec((await readVersion(guess.command)) ?? "")?.[1];
+    if (major !== "2")
+        return detection;
+    const unplaced = (detection.unplaced ?? []).map((entry) => (entry === guess ? { command: entry.command, major: 2 } : entry));
+    return summarize(detection.binaries, unplaced, detection.evidence, detection.override);
+}
+/** Whether a detection result means the OpenCode 1 or the OpenCode 2 surfaces must be installed. A host-less result keeps the OpenCode 1 behaviour. */
+export function targetsV1(mode) {
+    return mode === "v1" || mode === "both" || mode === "none";
+}
+export function targetsV2(mode) {
+    return mode === "v2" || mode === "both";
+}

package/dist/cli/install-report.js

@@ -1,3 +1,4 @@
+import { targetsV1 } from "./host-detect.js";
 import { shippedDefaultsSummary } from "./model-catalog.js";
 const reset = "\u001b[0m";
 const green = "\u001b[38;5;82m";
@@ -191,7 +192,8 @@ export function renderInstallReport(report) {
         line("Native skills", report.nativeSkills.write.length + " managed / " + report.nativeSkills.preserve.length + " preserved"),
         ...nativeSkillsLinkLines(report),
         line("Plugin entries", report.plugin.currentCount + " -> " + report.plugin.resultCount),
-        line("TUI config", report.tui.path),
+        // OpenCode 2 loads the TUI with the server plugin, so an OpenCode 2-only install has no TUI file.
+        ...(report.host === undefined || targetsV1(report.host.mode) ? [line("TUI config", report.tui.path)] : []),
         ...section("Progress"),
         progressLine("Resolve package"),
         progressLine("Read OpenCode config"),