@getpaseo/server 0.1.97 → 0.1.98

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -21,8 +21,9 @@ import { CodexAppServerClient, parseCodexThreadForkResponse, parseCodexThreadRol
 import { revertCodexConversation } from "./codex/rewind.js";
 import { renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
 import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
+import { SETTING_APPLIES_NEXT_TURN_NOTICE } from "../provider-notices.js";
 function assertChildWithPipes(child) {
     if (!child.stdin || !child.stdout || !child.stderr) {
         throw new Error("Child process did not expose stdio pipes");
@@ -31,6 +32,10 @@ function assertChildWithPipes(child) {
 function isRecord(value) {
     return value != null && typeof value === "object" && !Array.isArray(value);
 }
+function isCodexAlreadyUnarchivedError(error, threadId) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes(`no archived rollout found for thread id ${threadId}`);
+}
 const TURN_START_TIMEOUT_MS = 90 * 1000;
 const INTERRUPT_TIMEOUT_MS = 2000;
 const CODEX_PROVIDER = "codex";
@@ -2759,6 +2764,9 @@ export class CodexAppServerAgentSession {
         validateCodexMode(modeId);
         this.currentMode = modeId;
         this.cachedRuntimeInfo = null;
+        if (this.activeForegroundTurnId) {
+            return SETTING_APPLIES_NEXT_TURN_NOTICE;
+        }
     }
     async setModel(modelId) {
         this.config.model = modelId ?? undefined;
@@ -2772,6 +2780,9 @@ export class CodexAppServerAgentSession {
         this.config.thinkingOptionId = normalizeCodexThinkingOptionId(thinkingOptionId);
         this.refreshResolvedCollaborationMode();
         this.cachedRuntimeInfo = null;
+        if (this.activeForegroundTurnId) {
+            return SETTING_APPLIES_NEXT_TURN_NOTICE;
+        }
     }
     async setFeature(featureId, value) {
         if (featureId === "fast_mode") {
@@ -4406,6 +4417,34 @@ export class CodexAppServerAgentClient {
             await client.dispose();
         }
     }
+    async unarchiveNativeSession(handle) {
+        const threadId = handle.nativeHandle ?? handle.sessionId;
+        if (!threadId)
+            return;
+        const child = await this.spawnAppServer();
+        const client = new CodexAppServerClient(child, this.logger);
+        try {
+            await client.request("initialize", buildCodexAppServerInitializeParams());
+            client.notify("initialized", {});
+            try {
+                await client.request("thread/unarchive", { threadId });
+            }
+            catch (error) {
+                if (!isCodexAlreadyUnarchivedError(error, threadId)) {
+                    throw error;
+                }
+                try {
+                    await client.request("thread/read", { threadId });
+                }
+                catch {
+                    throw error;
+                }
+            }
+        }
+        finally {
+            await client.dispose();
+        }
+    }
     async isAvailable() {
         const launch = await resolveCodexLaunch(this.runtimeSettings);
         const availability = await checkCodexLaunchAvailable(launch);
@@ -4417,6 +4456,9 @@ export class CodexAppServerAgentClient {
             const availability = await checkCodexLaunchAvailable(launch);
             const available = availability.available;
             const entries = [
+                ...(await buildCommandResolutionDiagnosticRows(launch, {
+                    knownBinaryNames: ["codex"],
+                })),
                 ...(await buildBinaryDiagnosticRows(launch, availability)),
             ];
             let status = formatDiagnosticStatus(available);

package/dist/server/server/agent/providers/copilot-acp-agent.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { checkProviderLaunchAvailable, resolveProviderLaunch, } from "../provider-launch-config.js";
 import { ACPAgentClient, } from "./acp-agent.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 const COPILOT_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -93,6 +93,9 @@ export class CopilotACPAgentClient extends ACPAgentClient {
             }
             return {
                 diagnostic: formatProviderDiagnostic("Copilot", [
+                    ...(await buildCommandResolutionDiagnosticRows(launch, {
+                        knownBinaryNames: ["copilot"],
+                    })),
                     ...(await buildBinaryDiagnosticRows(launch, availability)),
                     { label: "Models", value: modelsValue },
                     { label: "Status", value: status },

package/dist/server/server/agent/providers/diagnostic-utils.d.ts

@@ -21,6 +21,15 @@ export interface BinaryDiagnosticRowsOptions {
     binaryLabel?: string;
     versionCommand?: BinaryDiagnosticVersionCommand;
 }
+export interface CommandResolutionDiagnosticRowsOptions {
+    knownBinaryNames: readonly string[];
+    includeCommandProbes?: boolean;
+    pathValue?: string;
+    pathext?: string;
+    platform?: NodeJS.Platform;
+    shell?: string;
+}
+export declare function buildCommandResolutionDiagnosticRows(launch: ResolvedProviderLaunch, options: CommandResolutionDiagnosticRowsOptions): Promise<DiagnosticEntry[]>;
 export declare function buildBinaryDiagnosticRows(launch: ResolvedProviderLaunch, availability: ProviderLaunchAvailability, options?: BinaryDiagnosticRowsOptions): Promise<DiagnosticEntry[]>;
 export declare function formatConfiguredCommand(defaultArgv: readonly string[], runtimeSettings?: ProviderRuntimeSettings): string;
 //# sourceMappingURL=diagnostic-utils.d.ts.map

package/dist/server/server/agent/providers/diagnostic-utils.js

@@ -1,3 +1,6 @@
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import path from "node:path";
 import { createProviderEnvSpec, } from "../provider-launch-config.js";
 import { execCommand } from "../../../utils/spawn.js";
 export function formatProviderDiagnostic(providerName, entries) {
@@ -114,6 +117,191 @@ export async function resolveBinaryVersion(binaryPath) {
         return `error: ${toDiagnosticErrorMessage(error)}`;
     }
 }
+const COMMAND_PROBE_TIMEOUT_MS = 3000;
+const COMMAND_PROBE_MAX_BUFFER = 32 * 1024;
+function resolvePlatform(options) {
+    return options?.platform ?? process.platform;
+}
+function resolvePathValue(options) {
+    return options?.pathValue ?? process.env["PATH"] ?? process.env["Path"] ?? "";
+}
+function resolveShellValue(options) {
+    if (options?.shell) {
+        return options.shell;
+    }
+    if (resolvePlatform(options) === "win32") {
+        return process.env["ComSpec"] ?? "cmd.exe";
+    }
+    return process.env["SHELL"] ?? "/bin/sh";
+}
+async function isExecutableFile(filePath, platform) {
+    try {
+        const candidate = await stat(filePath);
+        if (!candidate.isFile()) {
+            return false;
+        }
+        if (platform === "win32") {
+            return true;
+        }
+        await access(filePath, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveSearchableNames(binaryNames) {
+    return binaryNames.filter((binaryName) => binaryName.trim().length > 0 && !binaryName.includes("/") && !binaryName.includes("\\"));
+}
+function resolveWindowsPathExt(options) {
+    const value = options.pathext ?? process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD";
+    return value
+        .split(";")
+        .map((extension) => extension.trim())
+        .filter(Boolean)
+        .map((extension) => (extension.startsWith(".") ? extension : `.${extension}`));
+}
+function resolveBinaryCandidateNames(binaryName, options) {
+    if (resolvePlatform(options) !== "win32" || path.win32.extname(binaryName)) {
+        return [binaryName];
+    }
+    return [binaryName, ...resolveWindowsPathExt(options).map((extension) => binaryName + extension)];
+}
+async function formatPathMatches(options) {
+    const binaryNames = options.knownBinaryNames;
+    const searchableNames = resolveSearchableNames(binaryNames);
+    if (searchableNames.length === 0) {
+        return "not checked";
+    }
+    const pathDelimiter = resolvePlatform(options) === "win32" ? ";" : path.delimiter;
+    const pathEntries = resolvePathValue(options).split(pathDelimiter).filter(Boolean);
+    const matches = [];
+    const seen = new Set();
+    const platform = resolvePlatform(options);
+    for (const directory of pathEntries) {
+        for (const binaryName of searchableNames) {
+            for (const candidateName of resolveBinaryCandidateNames(binaryName, options)) {
+                const candidate = path.join(directory, candidateName);
+                if (seen.has(candidate)) {
+                    continue;
+                }
+                seen.add(candidate);
+                if (await isExecutableFile(candidate, platform)) {
+                    matches.push(candidate);
+                }
+            }
+        }
+    }
+    return matches.length > 0 ? matches.join("\n    ") : "none";
+}
+function shellToken(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function formatCommandProbeOutput(stdout, stderr) {
+    const sections = [];
+    const trimmedStdout = truncateForDiagnostic(stdout);
+    const trimmedStderr = truncateForDiagnostic(stderr);
+    if (trimmedStdout.length > 0) {
+        sections.push(trimmedStdout);
+    }
+    if (trimmedStderr.length > 0) {
+        sections.push(`stderr: ${trimmedStderr}`);
+    }
+    return sections.length > 0 ? sections.join("\n") : "(no output)";
+}
+function formatCommandProbeError(error) {
+    return toDiagnosticErrorMessage(error);
+}
+async function runCommandProbe(command, args) {
+    try {
+        const { stdout, stderr } = await execCommand(command, args, {
+            timeout: COMMAND_PROBE_TIMEOUT_MS,
+            killSignal: "SIGKILL",
+            maxBuffer: COMMAND_PROBE_MAX_BUFFER,
+        });
+        return formatCommandProbeOutput(stdout, stderr);
+    }
+    catch (error) {
+        return formatCommandProbeError(error);
+    }
+}
+async function buildPosixCommandProbeRows(binaryName) {
+    const shell = resolveShellValue();
+    const typeCommand = `type -a ${shellToken(binaryName)}`;
+    return [
+        {
+            label: `which -a ${binaryName}`,
+            value: await runCommandProbe("/usr/bin/which", ["-a", binaryName]),
+        },
+        {
+            label: `${path.basename(shell)} -lc type -a ${binaryName}`,
+            value: await runCommandProbe(shell, ["-lc", typeCommand]),
+        },
+    ];
+}
+async function buildWindowsCommandProbeRows(binaryName) {
+    const powershellCommand = [
+        "$ErrorActionPreference = 'Continue';",
+        `Get-Command -All ${JSON.stringify(binaryName)} |`,
+        "Select-Object CommandType,Source,Name,Definition |",
+        "Format-List",
+    ].join(" ");
+    return [
+        {
+            label: `where.exe ${binaryName}`,
+            value: await runCommandProbe("where.exe", [binaryName]),
+        },
+        {
+            label: `powershell Get-Command -All ${binaryName}`,
+            value: await runCommandProbe("powershell.exe", [
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-Command",
+                powershellCommand,
+            ]),
+        },
+    ];
+}
+async function buildCommandProbeRows(binaryNames) {
+    const searchableNames = resolveSearchableNames(binaryNames);
+    if (searchableNames.length === 0) {
+        return [];
+    }
+    const rows = [];
+    for (const binaryName of searchableNames) {
+        rows.push(...(process.platform === "win32"
+            ? await buildWindowsCommandProbeRows(binaryName)
+            : await buildPosixCommandProbeRows(binaryName)));
+    }
+    return rows;
+}
+export async function buildCommandResolutionDiagnosticRows(launch, options) {
+    const includeCommandProbes = options.includeCommandProbes ?? true;
+    return [
+        {
+            label: "Command source",
+            value: launch.source,
+        },
+        {
+            label: "Configured command",
+            value: [launch.command, ...launch.args].join(" "),
+        },
+        {
+            label: "Daemon PATH",
+            value: truncateForDiagnostic(resolvePathValue(options)) || "(empty)",
+        },
+        {
+            label: "Daemon shell",
+            value: resolveShellValue(options),
+        },
+        {
+            label: "PATH matches",
+            value: await formatPathMatches(options),
+        },
+        ...(includeCommandProbes ? await buildCommandProbeRows(options.knownBinaryNames) : []),
+    ];
+}
 async function resolveCommandVersion(invocation) {
     try {
         const { stdout, stderr } = await execCommand(invocation.command, invocation.args, {

package/dist/server/server/agent/providers/mock-slow-provider.js

@@ -19,7 +19,7 @@ export class MockSlowProviderClient {
         this.capabilities = CAPABILITIES;
     }
     async isAvailable() {
-        return true;
+        return process.env.PASEO_ENABLE_MOCK_SLOW === "true";
     }
     listModels(_options) {
         return neverResolves();

package/dist/server/server/agent/providers/opencode/server-manager.d.ts

@@ -1,5 +1,8 @@
 import type { ChildProcess } from "node:child_process";
 import type { Logger } from "pino";
+import { type SpawnProcessOptions } from "../../../../utils/spawn.js";
+import { type ProcessTerminator } from "../../../../utils/tree-kill.js";
+import type { ManagedProcessRegistry } from "../../../managed-processes/managed-processes.js";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 export interface OpenCodeServerAcquisition {
     server: {
@@ -24,6 +27,22 @@ export interface OpenCodeServerGeneration {
     url: string;
     refCount: number;
     retired: boolean;
+    managedProcessId?: string;
+}
+export type OpenCodePortAllocator = () => Promise<number>;
+export type OpenCodeCommandPrefixResolver = () => Promise<{
+    command: string;
+    args: string[];
+}>;
+export type OpenCodeServerProcessSpawner = (command: string, args: string[], options: SpawnProcessOptions) => ChildProcess;
+export interface OpenCodeServerManagerOptions {
+    logger: Logger;
+    runtimeSettings?: ProviderRuntimeSettings;
+    managedProcesses?: ManagedProcessRegistry;
+    terminateProcess?: ProcessTerminator;
+    portAllocator?: OpenCodePortAllocator;
+    resolveCommandPrefix?: OpenCodeCommandPrefixResolver;
+    spawnServerProcess?: OpenCodeServerProcessSpawner;
 }
 export declare class OpenCodeServerManager implements OpenCodeServerManagerLike {
     private static instance;
@@ -35,8 +54,13 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
     private readonly logger;
     private readonly runtimeSettings?;
     private readonly runtimeSettingsKey;
-    private constructor();
-    static getInstance(logger: Logger, runtimeSettings?: ProviderRuntimeSettings): OpenCodeServerManager;
+    private readonly managedProcesses?;
+    private readonly terminateProcess;
+    private readonly portAllocator;
+    private readonly resolveCommandPrefix;
+    private readonly spawnServerProcess;
+    constructor(options: OpenCodeServerManagerOptions);
+    static getInstance(logger: Logger, runtimeSettings?: ProviderRuntimeSettings, options?: Omit<OpenCodeServerManagerOptions, "logger" | "runtimeSettings">): OpenCodeServerManager;
     private static registerExitHandler;
     ensureRunning(): Promise<{
         port: number;
@@ -55,5 +79,8 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
     shutdown(): Promise<void>;
     private cleanupRetiredServers;
     private killServer;
+    private recordManagedServerProcess;
+    private removeManagedProcessRecordWhenResolved;
+    private removeManagedProcessId;
 }
 //# sourceMappingURL=server-manager.d.ts.map

package/dist/server/server/agent/providers/opencode/server-manager.js

@@ -1,4 +1,5 @@
 import net from "node:net";
+import os from "node:os";
 import { findExecutable } from "../../../../executable-resolution/executable-resolution.js";
 import { spawnProcess } from "../../../../utils/spawn.js";
 import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
@@ -6,19 +7,30 @@ import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../../prov
 const OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5000;
 const OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
 export class OpenCodeServerManager {
-    constructor(logger, runtimeSettings) {
+    constructor(options) {
         this.currentServer = null;
         this.retiredServers = new Set();
         this.startPromise = null;
         this.forcedRefreshPromise = null;
-        this.logger = logger;
-        this.runtimeSettings = runtimeSettings;
-        this.runtimeSettingsKey = JSON.stringify(runtimeSettings ?? {});
+        this.logger = options.logger;
+        this.runtimeSettings = options.runtimeSettings;
+        this.runtimeSettingsKey = JSON.stringify(this.runtimeSettings ?? {});
+        this.managedProcesses = options.managedProcesses;
+        this.terminateProcess = options.terminateProcess ?? terminateWithTreeKill;
+        this.portAllocator = options.portAllocator ?? findAvailablePort;
+        this.resolveCommandPrefix =
+            options.resolveCommandPrefix ??
+                (() => resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary));
+        this.spawnServerProcess = options.spawnServerProcess ?? spawnProcess;
     }
-    static getInstance(logger, runtimeSettings) {
+    static getInstance(logger, runtimeSettings, options = {}) {
         const nextSettingsKey = JSON.stringify(runtimeSettings ?? {});
         if (!OpenCodeServerManager.instance) {
-            OpenCodeServerManager.instance = new OpenCodeServerManager(logger, runtimeSettings);
+            OpenCodeServerManager.instance = new OpenCodeServerManager({
+                logger,
+                runtimeSettings,
+                ...options,
+            });
             OpenCodeServerManager.registerExitHandler();
         }
         else if (OpenCodeServerManager.instance.runtimeSettingsKey !== nextSettingsKey) {
@@ -128,11 +140,14 @@ export class OpenCodeServerManager {
         return server;
     }
     async startServer(launchEnv) {
-        const port = await findAvailablePort();
+        const port = await this.portAllocator();
         const url = `http://127.0.0.1:${port}`;
-        const launchPrefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary);
+        const launchPrefix = await this.resolveCommandPrefix();
+        const serverArgs = [...launchPrefix.args, "serve", "--port", String(port)];
+        const serverCwd = os.homedir();
         return new Promise((resolve, reject) => {
-            const serverProcess = spawnProcess(launchPrefix.command, [...launchPrefix.args, "serve", "--port", String(port)], {
+            const serverProcess = this.spawnServerProcess(launchPrefix.command, serverArgs, {
+                cwd: serverCwd,
                 detached: process.platform !== "win32",
                 stdio: ["ignore", "pipe", "pipe"],
                 ...createProviderEnvSpec({
@@ -140,6 +155,12 @@ export class OpenCodeServerManager {
                     overlays: [launchEnv],
                 }),
             });
+            const managedProcessRecord = this.recordManagedServerProcess({
+                process: serverProcess,
+                command: launchPrefix.command,
+                args: serverArgs,
+                port,
+            });
             let started = false;
             let stderrBuffer = "";
             let stdoutBuffer = "";
@@ -174,13 +195,17 @@ export class OpenCodeServerManager {
                 if (output.includes("listening on") && !started) {
                     started = true;
                     clearTimeout(timeout);
-                    resolve({
-                        process: serverProcess,
-                        port,
-                        url,
-                        refCount: 0,
-                        retired: false,
-                    });
+                    void (async () => {
+                        const record = await managedProcessRecord;
+                        resolve({
+                            process: serverProcess,
+                            port,
+                            url,
+                            refCount: 0,
+                            retired: false,
+                            ...(record ? { managedProcessId: record.id } : {}),
+                        });
+                    })();
                 }
             });
             serverProcess.stderr?.on("data", (data) => {
@@ -190,10 +215,12 @@ export class OpenCodeServerManager {
             });
             serverProcess.on("error", (error) => {
                 clearTimeout(timeout);
+                this.removeManagedProcessRecordWhenResolved(managedProcessRecord);
                 const headline = error instanceof Error ? error.message : String(error);
                 reject(new Error(buildStartupErrorMessage(headline)));
             });
             serverProcess.on("exit", (code) => {
+                this.removeManagedProcessRecordWhenResolved(managedProcessRecord);
                 if (!started) {
                     clearTimeout(timeout);
                     reject(new Error(buildStartupErrorMessage(`OpenCode server exited with code ${code}`)));
@@ -231,7 +258,7 @@ export class OpenCodeServerManager {
             (server.process.signalCode !== null && server.process.signalCode !== undefined)) {
             return;
         }
-        const result = await terminateWithTreeKill(server.process, {
+        const result = await this.terminateProcess(server.process, {
             gracefulTimeoutMs: OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS,
             forceTimeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS,
             onForceSignal: () => {
@@ -241,6 +268,45 @@ export class OpenCodeServerManager {
         if (result === "kill-timeout") {
             this.logger.warn({ timeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS }, "OpenCode server did not report exit after SIGKILL");
         }
+        if (server.managedProcessId) {
+            await this.removeManagedProcessId(server.managedProcessId);
+            server.managedProcessId = undefined;
+        }
+    }
+    async recordManagedServerProcess(options) {
+        const pid = options.process.pid;
+        if (!this.managedProcesses || typeof pid !== "number" || pid <= 0) {
+            return null;
+        }
+        try {
+            return await this.managedProcesses.record({
+                owner: { provider: "opencode", kind: "helper-server" },
+                pid,
+                command: options.command,
+                args: options.args,
+                metadata: { port: options.port },
+            });
+        }
+        catch (error) {
+            this.logger.warn({ err: error, pid, port: options.port }, "Failed to record OpenCode helper process");
+            return null;
+        }
+    }
+    removeManagedProcessRecordWhenResolved(record) {
+        void record.then((resolved) => {
+            if (resolved) {
+                return this.removeManagedProcessId(resolved.id);
+            }
+            return undefined;
+        });
+    }
+    async removeManagedProcessId(id) {
+        try {
+            await this.managedProcesses?.remove(id);
+        }
+        catch (error) {
+            this.logger.warn({ err: error, id }, "Failed to remove OpenCode helper process record");
+        }
     }
 }
 OpenCodeServerManager.instance = null;

package/dist/server/server/agent/providers/opencode-agent.d.ts

@@ -4,6 +4,7 @@ import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOpt
 import { isDefaultAgentCreateConfigUnattended } from "../create-agent-mode.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 import { type OpenCodeRuntime } from "./opencode/runtime.js";
+import type { ManagedProcessRegistry } from "../../managed-processes/managed-processes.js";
 declare function resolveOpenCodeCreateConfig(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
 declare function isOpenCodeCreateConfigUnattended(input: Parameters<typeof isDefaultAgentCreateConfigUnattended>[0]): boolean;
 type OpenCodeAgentConfig = AgentSessionConfig & {
@@ -103,6 +104,7 @@ export declare const __openCodeInternals: {
 };
 interface OpenCodeAgentClientDeps {
     runtime?: OpenCodeRuntime;
+    managedProcesses?: ManagedProcessRegistry;
 }
 export declare class OpenCodeAgentClient implements AgentClient {
     readonly provider: "opencode";

package/dist/server/server/agent/providers/opencode-agent.js

@@ -11,7 +11,7 @@ import { execCommand } from "../../../utils/spawn.js";
 import { buildToolCallDisplayModel } from "@getpaseo/protocol/tool-call-display";
 import { mapOpencodeToolCall } from "./opencode/tool-call-mapper.js";
 import { OpenCodeServerManager } from "./opencode/server-manager.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { composeSystemPromptParts } from "../system-prompt.js";
@@ -398,14 +398,14 @@ function mapOpenCodeAgentToMode(agent) {
     };
 }
 function mergeOpenCodeModes(discoveredModes) {
-    const modesById = new Map(DEFAULT_MODES.map((mode) => [mode.id, mode]));
-    for (const mode of discoveredModes) {
-        if (mode.id === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID) {
-            continue;
-        }
-        modesById.set(mode.id, mode);
+    const filtered = discoveredModes.filter((mode) => mode.id !== OPENCODE_LEGACY_FULL_ACCESS_MODE_ID);
+    // When discovery returns results, trust them exactly — don't inject hardcoded
+    // defaults that the user may have intentionally disabled in their OpenCode config.
+    // Fall back to DEFAULT_MODES only when discovery produced nothing.
+    if (filtered.length > 0) {
+        return sortOpenCodeModes(filtered);
     }
-    return sortOpenCodeModes(Array.from(modesById.values()));
+    return sortOpenCodeModes([...DEFAULT_MODES]);
 }
 function sortOpenCodeModes(modes) {
     const order = new Map(DEFAULT_MODES.map((mode, index) => [mode.id, index]));
@@ -880,7 +880,9 @@ export class OpenCodeAgentClient {
         this.runtimeSettings = runtimeSettings;
         this.runtime =
             deps.runtime ??
-                new ProductionOpenCodeRuntime(OpenCodeServerManager.getInstance(this.logger, runtimeSettings));
+                new ProductionOpenCodeRuntime(OpenCodeServerManager.getInstance(this.logger, runtimeSettings, {
+                    managedProcesses: deps.managedProcesses,
+                }));
     }
     async createSession(config, launchContext, options) {
         const openCodeConfig = this.assertConfig(config);
@@ -1146,6 +1148,9 @@ export class OpenCodeAgentClient {
             }
             return {
                 diagnostic: formatProviderDiagnostic("OpenCode", [
+                    ...(await buildCommandResolutionDiagnosticRows(launch, {
+                        knownBinaryNames: ["opencode"],
+                    })),
                     ...(await buildBinaryDiagnosticRows(launch, availability)),
                     { label: "Server", value: serverStatus },
                     { label: "Auth", value: authValue },