cursor-opencode-provider 0.8.0 → 0.8.1

package/dist/model-config.d.ts

@@ -8,6 +8,15 @@ import { type ModelInfo, type ModelVariant } from "./models.js";
  * tagged redundantly.
  */
 export declare function thinkingSuffixBaseNames(models: ModelInfo[]): Set<string>;
+/**
+ * models.dev-style family for a Cursor model id: the id without its version
+ * segments and context/speed suffixes (`claude-haiku-4-5` → `claude-haiku`,
+ * `gemini-3.8-flash` → `gemini-flash`, `gpt-5.6-luna` → `gpt-luna`).
+ * Kimi keeps its major generation (`kimi-k2.7-code` → `kimi-k2`). OpenCode
+ * picks its small title model by family and falls back to the session model when
+ * no entry has one. Cursor Auto (`default`) is not a model family.
+ */
+export declare function cursorModelFamily(id: string): string | undefined;
 export declare function modelInfoToConfig(mi: ModelInfo, options?: {
     thinkingSuffix?: boolean;
     contextTier?: "base" | "long";

package/dist/model-config.js

@@ -91,7 +91,7 @@ function modelInfoVariants(mi, variants) {
         // variant entry indistinguishable from the model entry in pickers that
         // collapse them.
         if (key === baseName && !usedKeys.has(key)) {
-            key = `${baseName}${tagDims(v.parameterValues)}` || `${baseName} default`;
+            key = `${baseName}${tagDims(v.parameterValues) || " default"}`;
         }
         else if (usedKeys.has(key)) {
             key = `${sanitized}${tagDims(v.parameterValues)}`;
@@ -140,6 +140,27 @@ export function thinkingSuffixBaseNames(models) {
             ambiguous.add(base);
     return ambiguous;
 }
+/**
+ * models.dev-style family for a Cursor model id: the id without its version
+ * segments and context/speed suffixes (`claude-haiku-4-5` → `claude-haiku`,
+ * `gemini-3.8-flash` → `gemini-flash`, `gpt-5.6-luna` → `gpt-luna`).
+ * Kimi keeps its major generation (`kimi-k2.7-code` → `kimi-k2`). OpenCode
+ * picks its small title model by family and falls back to the session model when
+ * no entry has one. Cursor Auto (`default`) is not a model family.
+ */
+export function cursorModelFamily(id) {
+    if (id === "default")
+        return undefined;
+    const base = id.replace(/(?:-(?:1m|fast))+$/, "");
+    const kimi = /^kimi-(k\d+)(?:[.p]\d+)*(?:-code(?:-highspeed)?)?$/.exec(base);
+    if (kimi)
+        return `kimi-${kimi[1]}`;
+    const family = base
+        .split("-")
+        .filter((part) => !/^\d+(?:[.p]\d+)*$/.test(part))
+        .join("-");
+    return family || undefined;
+}
 export function modelInfoToConfig(mi, options = {}) {
     const contextTier = options.contextTier ?? "base";
     const variants = options.variants ?? variantsForTier(mi, contextTier);
@@ -182,6 +203,12 @@ export function modelInfoToConfig(mi, options = {}) {
             output,
         },
     };
+    // Optional cache metadata may supply a family; the live AvailableModels
+    // schema has no family field. Empty metadata must not block derivation.
+    const reported = typeof mi.family === "string" ? mi.family.trim() : "";
+    const family = reported || cursorModelFamily(mi.id);
+    if (family)
+        config.family = family;
     const variantConfig = modelInfoVariants(mi, variants);
     if (variantConfig)
         config.variants = variantConfig;

package/dist/opencode2/catalog.d.ts

@@ -36,6 +36,7 @@ export type CatalogModelInfo = {
     modelID: string;
     providerID: string;
     name: string;
+    family?: string;
     capabilities: {
         tools: boolean;
         input: string[];

package/dist/opencode2/catalog.js

@@ -69,6 +69,8 @@ export function modelConfigEntryToInfo(id, entry) {
         time: { released: 0 },
         cost: toOpenCode2Costs(entry.cost),
     };
+    if (typeof entry.family === "string" && entry.family.trim())
+        info.family = entry.family.trim();
     if (options)
         info.settings = { ...options };
     return info;

package/dist/opencode2/image-save-tool.d.ts

@@ -0,0 +1,8 @@
+import type { PluginContext, ToolDraft } from "./types.js";
+/**
+ * Register the handle-only image commit tool on the OpenCode 2.0 direct
+ * catalog. Catalog `permission: "edit"` hides it when the host agent denies
+ * edits. Per-call `ask` is used when the runtime context provides it;
+ * otherwise containment still gates the write (opaque `image_id` only).
+ */
+export declare function registerCursorImageSaveTool(draft: ToolDraft, ctx: PluginContext): void;

package/dist/opencode2/image-save-tool.js

@@ -0,0 +1,84 @@
+import { executeCursorImageSave } from "../image-save.js";
+import { cursorImageSaveTool } from "../image-save-tool.js";
+import { CURSOR_IMAGE_SAVE_TOOL } from "../protocol/generate-image.js";
+import { getSessionDirectory } from "../session-directory.js";
+import { hostHasTool, OPENCODE2_DIRECT_TOOL_OPTIONS } from "./todo-tools.js";
+const IMAGE_SAVE_INPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        image_id: {
+            type: "string",
+            description: "Id of the pending Cursor-generated image to save",
+        },
+    },
+    required: ["image_id"],
+};
+const IMAGE_SAVE_OUTPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        path: { type: "string" },
+        bytes: { type: "number" },
+        message: { type: "string" },
+    },
+    required: ["path", "bytes", "message"],
+};
+function toolAsk(context) {
+    if (!context || typeof context !== "object")
+        return undefined;
+    const ask = context.ask;
+    return typeof ask === "function"
+        ? ask
+        : undefined;
+}
+async function workspaceForSession(ctx, sessionID) {
+    const marked = getSessionDirectory(sessionID);
+    if (marked)
+        return marked;
+    try {
+        return (await ctx.session.get({ sessionID })).location.directory;
+    }
+    catch {
+        return ctx.location?.directory || process.cwd();
+    }
+}
+/**
+ * Register the handle-only image commit tool on the OpenCode 2.0 direct
+ * catalog. Catalog `permission: "edit"` hides it when the host agent denies
+ * edits. Per-call `ask` is used when the runtime context provides it;
+ * otherwise containment still gates the write (opaque `image_id` only).
+ */
+export function registerCursorImageSaveTool(draft, ctx) {
+    if (hostHasTool(draft, CURSOR_IMAGE_SAVE_TOOL))
+        return;
+    draft.add({
+        name: CURSOR_IMAGE_SAVE_TOOL,
+        description: cursorImageSaveTool.description,
+        input: IMAGE_SAVE_INPUT_SCHEMA,
+        output: IMAGE_SAVE_OUTPUT_SCHEMA,
+        options: { ...OPENCODE2_DIRECT_TOOL_OPTIONS, permission: "edit" },
+        execute: async (input, context) => {
+            const sessionID = context.sessionID;
+            if (typeof sessionID !== "string" || !sessionID) {
+                throw new Error("OpenCode 2.0 image-save context did not provide a sessionID");
+            }
+            const directory = await workspaceForSession(ctx, sessionID);
+            const result = await executeCursorImageSave({ image_id: input?.image_id }, {
+                worktree: directory,
+                directory,
+                // The public 2.0 ToolContext has no permission prompt; catalog
+                // `permission: "edit"` and containment gate the write instead.
+                ask: toolAsk(context) ?? null,
+            });
+            return {
+                output: {
+                    path: result.title,
+                    bytes: result.bytes,
+                    message: result.output,
+                },
+                content: result.output,
+            };
+        },
+    });
+}

package/dist/opencode2/types.d.ts

@@ -43,6 +43,7 @@ export type ModelInfo2 = {
     modelID: string;
     providerID: string;
     name: string;
+    family?: string;
     capabilities: {
         tools: boolean;
         input: readonly string[];
@@ -415,6 +416,19 @@ export type McpEditor = {
 export type McpDomain = {
     readonly transform: Transform<McpEditor>;
 };
+/** Only the fields this plugin reads from a registered skill. */
+export type SkillInfo = {
+    readonly id: string;
+    readonly path: string;
+};
+export type SkillDomain = {
+    readonly list: () => Promise<{
+        readonly location: {
+            readonly directory: string;
+        };
+        readonly data: readonly SkillInfo[];
+    }>;
+};
 export type PluginLocation = {
     readonly directory: string;
 };
@@ -429,6 +443,7 @@ export type PluginContext = {
     readonly shell?: ShellDomain;
     readonly websearch?: WebSearchDomain;
     readonly mcp?: McpDomain;
+    readonly skill?: SkillDomain;
 };
 export type Cleanup = () => Promise<void> | void;
 export type Plugin2 = {

package/dist/parallel-step.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Parallel tool-call step boundary for OpenCode's AI SDK step model.
+ *
+ * Cursor fires execs as they are generated; CLI demuxes them concurrently and
+ * has no step boundary. OpenCode needs one `finish: tool-calls` after every
+ * call of the generation. Cursor's `tool_requests_listed` (InteractionUpdate
+ * field 27) carries that count. See tasks/plans/parallel-tool-calls-cli-parity.md.
+ */
+/** Idle without a progress frame while holding → close the step (ms). */
+export declare const PARALLEL_STEP_IDLE_MS = 1500;
+export type ParallelStepState = {
+    /** From field 27; undefined until Cursor lists the count for this step. */
+    listedCount?: number;
+    /** Model tool_call_ids seen this step. */
+    callIds: Set<string>;
+    /** Ids with a final client disposition this step. */
+    resolved: Set<string>;
+    /** Host tool-call parts emitted this step. */
+    emitted: number;
+    /** Wall time of the last progress frame (for the liveness guard). */
+    lastProgressAt: number;
+};
+export declare function noteToolRequestsListedSeen(): void;
+export declare function hasSeenToolRequestsListed(): boolean;
+/** Test-only: reset the process capability gate. */
+export declare function resetToolRequestsListedSeenForTests(): void;
+export declare function createParallelStep(now?: number): ParallelStepState;
+export declare function noteParallelStepProgress(step: ParallelStepState, now?: number): void;
+export declare function noteListedCallCount(step: ParallelStepState, callCount: number, now?: number): void;
+/**
+ * Record a final disposition for `callId`. Returns true when newly resolved.
+ * Empty ids are ignored. Prior-step ids in `prior` are ignored.
+ */
+export declare function resolveParallelStepCall(step: ParallelStepState, callId: string | undefined, prior?: ReadonlySet<string>, now?: number): boolean;
+export declare function recordParallelStepEmission(step: ParallelStepState, now?: number): void;
+/** True when the listed count is known and every listed call is resolved. */
+export declare function parallelStepCountMet(step: ParallelStepState): boolean;
+/**
+ * Whether to keep pumping for more calls of this step instead of finishing.
+ *
+ * - Gate off and no count yet → do not hold (today's one-call finish).
+ * - Human-gated interaction with unknown count → do not hold (prompt must show).
+ * - Otherwise hold until the count is met (or the liveness guard fires).
+ */
+export declare function shouldHoldParallelStep(step: ParallelStepState, options?: {
+    fieldSeen?: boolean;
+    humanGatedWithoutCount?: boolean;
+}): boolean;
+/** True when the hold has made no progress for `idleMs`. */
+export declare function shouldGuardCloseParallelStep(step: ParallelStepState, now?: number, idleMs?: number): boolean;
+/**
+ * Frames that reset the liveness guard while holding. Heartbeat, KV, and
+ * checkpoint are not progress — they say nothing about further tool calls.
+ */
+export declare function isParallelStepProgressFrame(kinds: {
+    toolRequestsListed?: boolean;
+    partialToolCall?: boolean;
+    toolCallDelta?: boolean;
+    toolCallStarted?: boolean;
+    toolCallCompleted?: boolean;
+    exec?: boolean;
+    interactionQuery?: boolean;
+    textDelta?: boolean;
+    thinkingDelta?: boolean;
+}): boolean;

package/dist/parallel-step.js

@@ -0,0 +1,102 @@
+/**
+ * Parallel tool-call step boundary for OpenCode's AI SDK step model.
+ *
+ * Cursor fires execs as they are generated; CLI demuxes them concurrently and
+ * has no step boundary. OpenCode needs one `finish: tool-calls` after every
+ * call of the generation. Cursor's `tool_requests_listed` (InteractionUpdate
+ * field 27) carries that count. See tasks/plans/parallel-tool-calls-cli-parity.md.
+ */
+/** Idle without a progress frame while holding → close the step (ms). */
+export const PARALLEL_STEP_IDLE_MS = 1_500;
+/** Process-level: Cursor has sent field 27 on any Run in this process. */
+let toolRequestsListedSeen = false;
+export function noteToolRequestsListedSeen() {
+    toolRequestsListedSeen = true;
+}
+export function hasSeenToolRequestsListed() {
+    return toolRequestsListedSeen;
+}
+/** Test-only: reset the process capability gate. */
+export function resetToolRequestsListedSeenForTests() {
+    toolRequestsListedSeen = false;
+}
+export function createParallelStep(now = Date.now()) {
+    return {
+        callIds: new Set(),
+        resolved: new Set(),
+        emitted: 0,
+        lastProgressAt: now,
+    };
+}
+export function noteParallelStepProgress(step, now = Date.now()) {
+    step.lastProgressAt = now;
+}
+export function noteListedCallCount(step, callCount, now = Date.now()) {
+    noteToolRequestsListedSeen();
+    if (Number.isFinite(callCount) && callCount >= 0) {
+        step.listedCount = callCount;
+    }
+    noteParallelStepProgress(step, now);
+}
+/**
+ * Record a final disposition for `callId`. Returns true when newly resolved.
+ * Empty ids are ignored. Prior-step ids in `prior` are ignored.
+ */
+export function resolveParallelStepCall(step, callId, prior, now = Date.now()) {
+    if (!callId)
+        return false;
+    if (prior?.has(callId))
+        return false;
+    step.callIds.add(callId);
+    if (step.resolved.has(callId))
+        return false;
+    step.resolved.add(callId);
+    noteParallelStepProgress(step, now);
+    return true;
+}
+export function recordParallelStepEmission(step, now = Date.now()) {
+    step.emitted++;
+    noteParallelStepProgress(step, now);
+}
+/** True when the listed count is known and every listed call is resolved. */
+export function parallelStepCountMet(step) {
+    return step.listedCount !== undefined && step.resolved.size >= step.listedCount;
+}
+/**
+ * Whether to keep pumping for more calls of this step instead of finishing.
+ *
+ * - Gate off and no count yet → do not hold (today's one-call finish).
+ * - Human-gated interaction with unknown count → do not hold (prompt must show).
+ * - Otherwise hold until the count is met (or the liveness guard fires).
+ */
+export function shouldHoldParallelStep(step, options = {}) {
+    if (options.humanGatedWithoutCount && step.listedCount === undefined)
+        return false;
+    const fieldSeen = options.fieldSeen ?? hasSeenToolRequestsListed();
+    if (!fieldSeen && step.listedCount === undefined)
+        return false;
+    if (parallelStepCountMet(step))
+        return false;
+    return true;
+}
+/** True when the hold has made no progress for `idleMs`. */
+export function shouldGuardCloseParallelStep(step, now = Date.now(), idleMs = PARALLEL_STEP_IDLE_MS) {
+    if (parallelStepCountMet(step))
+        return false;
+    return now - step.lastProgressAt >= idleMs;
+}
+/**
+ * Frames that reset the liveness guard while holding. Heartbeat, KV, and
+ * checkpoint are not progress — they say nothing about further tool calls.
+ */
+export function isParallelStepProgressFrame(kinds) {
+    return !!(kinds.toolRequestsListed
+        || kinds.partialToolCall
+        || kinds.toolCallDelta
+        || kinds.toolCallStarted
+        || kinds.toolCallCompleted
+        || kinds.exec
+        || kinds.interactionQuery
+        || kinds.textDelta
+        || kinds.thinkingDelta);
+}

package/dist/plugin-opencode2.js

@@ -1,6 +1,6 @@
 import { CURSOR_PROVIDER_ID, CURSOR_COMPACTION_OPTION, CURSOR_HOST_AGENT_OPTION, } from "./shared.js";
 import { createSdk, cursorApiBaseURL, cursorGetServerConfigTelemetryEnabled, isCursorPackage } from "./plugin-core.js";
-import { opencodeGlobalCacheDir } from "./context/paths.js";
+import { opencode2PlanDir, opencodeGlobalCacheDir, setNativePlansDir } from "./context/paths.js";
 import { discoverModels, isCacheFresh, readCache } from "./models.js";
 import { resolveAgentUrl } from "./agent-url.js";
 import { sessionActivity } from "./activity.js";
@@ -10,13 +10,14 @@ import { applyCursorProviderInventory, CURSOR_INTEGRATION_ID } from "./opencode2
 import { applyCursorIntegration, requireCursorAccessToken, resolveCursorAccessToken, } from "./opencode2/integration.js";
 import { exposeDirectMcpTools, rememberDirectMcpNamespaces } from "./opencode2/mcp-direct.js";
 import { registerTodoTools } from "./opencode2/todo-tools.js";
+import { registerCursorImageSaveTool } from "./opencode2/image-save-tool.js";
 import { OPENCODE_2_TOOL_DIALECT } from "./protocol/tools.js";
 import { clearSessionTodos } from "./todo-store.js";
 import { markCompactionSession } from "./compaction-marker.js";
 import { getSessionDirectory, markSessionDirectory } from "./session-directory.js";
+import { rememberHostSkillFiles } from "./context/skills.js";
 import { trace } from "./debug.js";
-import { cancelPlanExecutionKickoff, createPlanExecutionKickoffText, setPlanExecutionKickoff, } from "./plan-execution-kickoff.js";
-import { cancelHostAgentModeSwitch, setHostAgentModeSwitch, } from "./host-agent-mode.js";
+import { cancelHostAgentModeSwitch, hostAgentSwitchPromptText, setHostAgentModeSwitch, } from "./host-agent-mode.js";
 import { clearActiveCursorMode, getActiveCursorMode, normalizeSwitchModeId, setActiveCursorMode, } from "./protocol/switch-mode.js";
 import { CursorPlugin } from "./plugin.js";
 /**
@@ -92,45 +93,36 @@ const plugin = {
     setup: async (ctx) => {
         const cacheDir = opencodeGlobalCacheDir();
         const workspaceRoot = ctx.location?.directory || process.cwd();
+        // CreatePlan writes where OpenCode 2.0's Plan agent keeps plan files.
+        // OpenCode 2.0 sets a plugin up once per location instance and again on a
+        // plugin reload, then disposes older setups: each cleanup removes only
+        // what its own setup installed.
+        const disposeNativePlansDir = setNativePlansDir(opencode2PlanDir());
+        let disposeHostAgentModeSwitch;
+        trace(`opencode2 plugin: setup directory=${workspaceRoot}`);
         const hasShellEnvHook = typeof ctx.shell?.hook === "function";
-        const admitPlanKickoff = typeof ctx.session.synthetic === "function"
-            ? ctx.session.synthetic
-            : ctx.session.prompt;
-        if (typeof ctx.session.switchAgent === "function" && typeof admitPlanKickoff === "function") {
+        if (typeof ctx.session.switchAgent === "function") {
             const switchAgent = ctx.session.switchAgent;
-            setPlanExecutionKickoff(async ({ sessionID, planPath }) => {
-                await switchAgent({ sessionID, agent: "build" });
-                try {
-                    await admitPlanKickoff({
+            const continueTurn = typeof ctx.session.synthetic === "function"
+                ? ctx.session.synthetic
+                : typeof ctx.session.prompt === "function"
+                    ? ctx.session.prompt
+                    : undefined;
+            disposeHostAgentModeSwitch = setHostAgentModeSwitch(async ({ sessionID, targetModeID }) => {
+                const agent = normalizeSwitchModeId(targetModeID) === "plan"
+                    || normalizeSwitchModeId(targetModeID) === "spec"
+                    ? "plan"
+                    : "build";
+                await switchAgent({ sessionID, agent });
+                // switchAgent only publishes AgentSelected and leaves the session idle.
+                // Continue under the new agent the same way OpenCode 1.x promptAsync does.
+                if (continueTurn) {
+                    await continueTurn({
                         sessionID,
-                        text: createPlanExecutionKickoffText(planPath),
+                        text: hostAgentSwitchPromptText(agent),
                     });
                 }
-                catch (error) {
-                    // Switching and admitting input are separate public APIs. Restore the
-                    // plan agent if admission fails so the shared retry state is honest:
-                    // the plan remains active rather than silently leaving the session in
-                    // build mode with no execution turn.
-                    await switchAgent({ sessionID, agent: "plan" }).catch(() => { });
-                    throw error;
-                }
-            });
-        }
-        else {
-            setPlanExecutionKickoff(undefined);
-        }
-        if (typeof ctx.session.switchAgent === "function") {
-            const switchAgent = ctx.session.switchAgent;
-            setHostAgentModeSwitch(async ({ sessionID, targetModeID }) => {
-                const mode = normalizeSwitchModeId(targetModeID);
-                await switchAgent({
-                    sessionID,
-                    agent: mode === "plan" || mode === "spec" ? "plan" : "build",
-                });
-            });
-        }
-        else {
-            setHostAgentModeSwitch(undefined);
+            }, continueTurn ? { resumesTurn: true } : {});
         }
         const registrations = [];
         const track = async (p) => {
@@ -262,6 +254,7 @@ const plugin = {
             // them as direct catalog tools (`codemode: false` + output schema) if
             // the host does not already own those names. When off, register none.
             registerTodoTools(draft);
+            registerCursorImageSaveTool(draft, ctx);
             // MCP tools default into Code Mode. Move every server that did not
             // explicitly opt in onto the direct catalog so this provider can
             // advertise them to Cursor (issue #29 still routes via CallDynamicTool).
@@ -375,6 +368,20 @@ const plugin = {
         // last known session directory ahead of this Location's static root.
         // Scoped by the host to this provider: other providers' requests never
         // reach the callback, so the header cannot leak to their endpoints.
+        // Skill files for RequestContext path-desc `agent_skills` (see context/skills.ts).
+        const rememberSkillFiles = async () => {
+            if (!ctx.skill)
+                return;
+            try {
+                const listed = await ctx.skill.list();
+                // skill.list is bound to this plugin Location. A session may have
+                // moved; never relabel this catalog with the session's new directory.
+                rememberHostSkillFiles(listed.location.directory, listed.data);
+            }
+            catch (error) {
+                trace(`model.request: skill.list failed: ${String(error)}`);
+            }
+        };
         await track(ctx.session.hook("model.request", async (event) => {
             const current = await ctx.session
                 .get({ sessionID: event.sessionID })
@@ -387,6 +394,7 @@ const plugin = {
             const directory = current ?? getSessionDirectory(event.sessionID) ?? ctx.location?.directory;
             if (!directory)
                 return;
+            await rememberSkillFiles();
             event.headers = {
                 ...event.headers,
                 "x-opencode-directory": encodeURIComponent(directory),
@@ -469,8 +477,9 @@ const plugin = {
         return async () => {
             clearInterval(retry);
             unsubscribe?.();
-            setPlanExecutionKickoff(undefined);
-            setHostAgentModeSwitch(undefined);
+            disposeHostAgentModeSwitch?.();
+            disposeNativePlansDir();
+            trace(`opencode2 plugin: cleanup directory=${workspaceRoot}`);
             for (const registration of registrations.reverse()) {
                 await registration.dispose().catch(() => { });
             }
@@ -529,7 +538,6 @@ function applySessionActivity(event, onCredentialSwitch) {
                 sessionActivity.removeSession(id);
                 clearSessionTodos(id);
                 clearActiveCursorMode(id);
-                cancelPlanExecutionKickoff(id);
                 cancelHostAgentModeSwitch(id);
             }
             break;

package/dist/plugin.js

@@ -12,8 +12,9 @@ import { readStoredAuth } from "./context/auth-store.js";
 import { resolveAgentUrl } from "./agent-url.js";
 import { captureCursorShellResult, cursorShellEnvForCall, cursorShellOriginalCommand, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, setCursorShellPath, } from "./shell-timeout.js";
 import { sessionActivity } from "./activity.js";
-import { createPlanExecutionKickoffText, setPlanExecutionKickoff, } from "./plan-execution-kickoff.js";
 import { dispatchHostEventBridge } from "./host-event-bridge.js";
+import { createPromptHostAgentModeSwitch, setHostAgentModeSwitch } from "./host-agent-mode.js";
+import { isHostPlanFileResolved, resolveHostPlanFile } from "./host-plan-file.js";
 const MODULE_URL = new URL("./index.js", import.meta.url).href;
 /**
  * Raw `crsr_` key behind an API-key login: under `metadata.apiKey` (saved at
@@ -41,29 +42,63 @@ function isSameCredential(latest, started) {
     }
     return false;
 }
+/** Names of the host's own user-selectable primary agents, from `app.agents()`. */
+function primaryAgentNames(response) {
+    const list = Array.isArray(response)
+        ? response
+        : Array.isArray(response?.data)
+            ? response.data
+            : undefined;
+    if (!list)
+        return undefined;
+    const names = new Set();
+    for (const item of list) {
+        if (typeof item?.name !== "string" || item.mode === "subagent" || item.hidden === true)
+            continue;
+        names.add(item.name);
+    }
+    return names;
+}
+/**
+ * Install the OpenCode 1.x host-agent switch. Returns the agent-list refresh,
+ * which the caller runs once the host serves requests: the list is read from
+ * the host's own API, and a failed read leaves SwitchMode provider-owned.
+ */
+function installPromptHostAgentModeSwitch(input, sessionClient, promptAsync) {
+    const app = input.client?.app;
+    const agents = app?.agents;
+    // Nothing to install; a switch another entrypoint installed stays in place.
+    if (typeof promptAsync !== "function" || typeof agents !== "function")
+        return undefined;
+    let primary;
+    const refresh = () => agents.call(app)
+        .then((response) => { primary = primaryAgentNames(response) ?? primary; })
+        .catch((error) => trace(`host-agent-mode: agent list unavailable: ${errorMessage(error)}`));
+    const { apply, accepts } = createPromptHostAgentModeSwitch(async ({ sessionID, agent, text }) => {
+        await promptAsync.call(sessionClient, {
+            path: { id: sessionID },
+            body: { agent, parts: [{ type: "text", text, synthetic: true }] },
+        });
+        void refresh();
+    }, () => primary);
+    setHostAgentModeSwitch(apply, { resumesTurn: true, accepts });
+    return refresh;
+}
 export async function CursorPlugin(input) {
     const cacheDir = opencodeGlobalCacheDir();
     const apiBaseURL = cursorApiBaseURL();
     const classicTools = await loadClassicTools();
-    // Install the OpenCode plan-exit-shaped kickoff only when the OpenCode client
-    // exposes that structural API. Without it, no synthetic kickoff is registered.
     const sessionClient = input.client?.session;
     const promptAsync = sessionClient?.promptAsync;
-    setPlanExecutionKickoff(typeof promptAsync === "function"
-        ? async ({ sessionID, planPath }) => {
-            await promptAsync.call(sessionClient, {
-                path: { id: sessionID },
-                body: {
-                    agent: "build",
-                    parts: [{
-                            type: "text",
-                            text: createPlanExecutionKickoffText(planPath),
-                            synthetic: true,
-                        }],
-                },
-            });
-        }
-        : undefined);
+    // Cursor SwitchMode without an advertised plan_enter selects the host's
+    // primary agent the OpenCode 1.x way once its Run has ended. The OpenCode 2.0
+    // entrypoint replaces this with `session.switchAgent` in its own setup().
+    const refreshHostAgents = installPromptHostAgentModeSwitch(input, sessionClient, promptAsync);
+    let hostAgentsLoaded;
+    const sessionGet = sessionClient?.get;
+    const getSession = typeof sessionGet === "function"
+        ? (sessionID) => sessionGet.call(sessionClient, { path: { id: sessionID } })
+        : undefined;
     let lastPersistAttempt;
     async function persistAuth(body) {
         await input.client.auth.set({
@@ -280,6 +315,22 @@ export async function CursorPlugin(input) {
             // Carry the canonical OpenCode id so an incompatible Cursor checkpoint
             // is rotated instead of resuming the prior agent's prompt.
             output.options[CURSOR_HOST_AGENT_OPTION] = hookInput.agent;
+            // First Cursor request: the host now serves its API, so read its agents
+            // before any Run can raise SwitchMode. Concurrent first requests share
+            // the one read; later requests find it settled.
+            hostAgentsLoaded ??= refreshHostAgents?.();
+            await hostAgentsLoaded;
+            // Know the session's own plan file (OpenCode's `Session.plan`) before the
+            // Run starts, so CreatePlan records the plan where the plan agent and
+            // plan_exit read it. It is fixed per session, so resolve it once.
+            if (hookInput.agent !== "compaction" && getSession && !isHostPlanFileResolved(hookInput.sessionID)) {
+                await resolveHostPlanFile({
+                    sessionID: hookInput.sessionID,
+                    getSession,
+                    worktree: input.worktree || input.project?.worktree,
+                    vcs: !!input.project?.vcs,
+                });
+            }
             // OpenCode's compaction pipeline invokes the LLM with agent="compaction".
             // Carry that stable runtime fact into LanguageModelV3 providerOptions so
             // the provider never has to guess from an empty tool list.