cursor-opencode-provider 0.7.6 → 0.8.1

package/dist/pricing-data.d.ts

@@ -25,6 +25,12 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly cache_read: 0.1;
         readonly cache_write: 1.25;
     };
+    readonly "claude-haiku-5-5": {
+        readonly input: 0.1;
+        readonly output: 0.5;
+        readonly cache_read: 0.01;
+        readonly cache_write: 0.125;
+    };
     readonly "claude-opus-4-5": {
         readonly input: 5;
         readonly output: 25;
@@ -94,7 +100,7 @@ export declare const CURSOR_MODEL_COSTS: {
     readonly "claude-sonnet-5-5": {
         readonly input: 2;
         readonly output: 10;
-        readonly cache_read: 0.2;
+        readonly cache_read: 0.1;
         readonly cache_write: 2.5;
     };
     readonly "composer-2.5": {
@@ -311,6 +317,10 @@ export declare const CURSOR_MODEL_CONTEXTS: {
     readonly "claude-haiku-4-5": {
         readonly maxContext: 200000;
     };
+    readonly "claude-haiku-5-5": {
+        readonly maxContext: 300000;
+        readonly maxContextForMaxMode: 1000000;
+    };
     readonly "claude-opus-4-5": {
         readonly maxContext: 200000;
         readonly maxContextForMaxMode: 200000;
@@ -465,6 +475,9 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "claude-haiku-4-5": {
         readonly supportsImages: true;
     };
+    readonly "claude-haiku-5-5": {
+        readonly supportsImages: true;
+    };
     readonly "claude-opus-4-5": {
         readonly supportsImages: true;
     };

package/dist/pricing-data.js

@@ -25,6 +25,12 @@ export const CURSOR_MODEL_COSTS = {
         "cache_read": 0.1,
         "cache_write": 1.25
     },
+    "claude-haiku-5-5": {
+        "input": 0.1,
+        "output": 0.5,
+        "cache_read": 0.01,
+        "cache_write": 0.125
+    },
     "claude-opus-4-5": {
         "input": 5,
         "output": 25,
@@ -94,7 +100,7 @@ export const CURSOR_MODEL_COSTS = {
     "claude-sonnet-5-5": {
         "input": 2,
         "output": 10,
-        "cache_read": 0.2,
+        "cache_read": 0.1,
         "cache_write": 2.5
     },
     "composer-2.5": {
@@ -311,6 +317,10 @@ export const CURSOR_MODEL_CONTEXTS = {
     "claude-haiku-4-5": {
         "maxContext": 200000
     },
+    "claude-haiku-5-5": {
+        "maxContext": 300000,
+        "maxContextForMaxMode": 1000000
+    },
     "claude-opus-4-5": {
         "maxContext": 200000,
         "maxContextForMaxMode": 200000
@@ -465,6 +475,9 @@ export const CURSOR_MODEL_CAPABILITIES = {
     "claude-haiku-4-5": {
         "supportsImages": true
     },
+    "claude-haiku-5-5": {
+        "supportsImages": true
+    },
     "claude-opus-4-5": {
         "supportsImages": true
     },

package/dist/protocol/ask-question.d.ts

@@ -76,6 +76,13 @@ export declare function decodeAskQuestionQuery(queryBytes: Uint8Array): DecodedA
 export declare function isCatchAllOptionLabel(label: string): boolean;
 /** Options as Cursor would display them: trailing catch-all removed. */
 export declare function displayOptions(question: CursorAskQuestionItem): CursorAskQuestionOption[];
+/** OpenCode `Question.Prompt.header`: short label, max 30 chars. */
+export declare function questionHeader(title: string): string;
+/**
+ * Fill required OpenCode `question` fields when a model call omits them.
+ * Live OC1 failure: SchemaError Missing key at ["questions"][0]["header"].
+ */
+export declare function normalizeOpencodeQuestionArgs(args: Record<string, unknown>): Record<string, unknown>;
 export type OpencodeQuestionInput = {
     questions: Array<{
         question: string;
@@ -100,12 +107,16 @@ export declare function asyncResult(): AskQuestionResultMessage;
 /**
  * Pull each question's answer text out of a host `question` tool output.
  *
- * OpenCode returns prose (`metadata.answers` does not cross the AI SDK
+ * OpenCode 1.x returns prose (`metadata.answers` does not cross the AI SDK
  * boundary):
  *
  *   User has answered your questions: "<q1>"="<a, b>", "<q2>"="Unanswered". You
  *   can now continue with the user's answers in mind.
  *
+ * OpenCode 2.0 sends the tool's declared output as JSON
+ * (`{ "answers": [["Yes"], …] }`) and does not put that prose on the AI SDK
+ * tool-result. Answers are positional.
+ *
  * The prose is located by its `"<question>"="` anchor — robust
  * against commas, quotes and `"="` inside question or answer text, and against
  * duplicate questions. Returns undefined for a question whose anchor is

package/dist/protocol/ask-question.js

@@ -183,7 +183,8 @@ export function displayOptions(question) {
         return question.options.slice(0, -1);
     return question.options.slice();
 }
-function header(title) {
+/** OpenCode `Question.Prompt.header`: short label, max 30 chars. */
+export function questionHeader(title) {
     const trimmed = title.trim();
     if (!trimmed)
         return "Question";
@@ -191,6 +192,40 @@ function header(title) {
         ? trimmed.slice(0, HEADER_MAX_LENGTH - 1).trimEnd() + "…"
         : trimmed;
 }
+/**
+ * Fill required OpenCode `question` fields when a model call omits them.
+ * Live OC1 failure: SchemaError Missing key at ["questions"][0]["header"].
+ */
+export function normalizeOpencodeQuestionArgs(args) {
+    if (!Array.isArray(args.questions))
+        return args;
+    return {
+        ...args,
+        questions: args.questions.map((item) => {
+            if (!item || typeof item !== "object" || Array.isArray(item))
+                return item;
+            const q = item;
+            const prompt = typeof q.question === "string" ? q.question : "";
+            const existing = typeof q.header === "string" ? q.header : "";
+            const options = Array.isArray(q.options)
+                ? q.options.map((opt) => {
+                    if (!opt || typeof opt !== "object" || Array.isArray(opt))
+                        return opt;
+                    const o = opt;
+                    return {
+                        ...o,
+                        ...(o.description === undefined ? { description: "" } : {}),
+                    };
+                })
+                : q.options;
+            return {
+                ...q,
+                header: questionHeader(existing.trim() || prompt),
+                options,
+            };
+        }),
+    };
+}
 /**
  * Build the OpenCode `question` tool input. `Question.Prompt` requires
  * `question`, `header`, and `options[{label, description}]`; Cursor options
@@ -200,7 +235,7 @@ export function askQuestionToolInput(args) {
     return {
         questions: args.questions.map((question) => ({
             question: question.prompt,
-            header: header(args.title),
+            header: questionHeader(args.title),
             options: displayOptions(question).map((option) => ({
                 label: option.label,
                 description: "",
@@ -220,18 +255,25 @@ export function asyncResult() {
 /**
  * Pull each question's answer text out of a host `question` tool output.
  *
- * OpenCode returns prose (`metadata.answers` does not cross the AI SDK
+ * OpenCode 1.x returns prose (`metadata.answers` does not cross the AI SDK
  * boundary):
  *
  *   User has answered your questions: "<q1>"="<a, b>", "<q2>"="Unanswered". You
  *   can now continue with the user's answers in mind.
  *
+ * OpenCode 2.0 sends the tool's declared output as JSON
+ * (`{ "answers": [["Yes"], …] }`) and does not put that prose on the AI SDK
+ * tool-result. Answers are positional.
+ *
  * The prose is located by its `"<question>"="` anchor — robust
  * against commas, quotes and `"="` inside question or answer text, and against
  * duplicate questions. Returns undefined for a question whose anchor is
  * absent, which is treated as unanswered rather than guessed at.
  */
 export function parseAnswerSegments(questions, output) {
+    const fromJson = parseJsonAnswerSegments(output, questions.length);
+    if (fromJson)
+        return fromJson;
     const answers = [];
     let cursor = 0;
     for (const question of questions) {
@@ -260,6 +302,38 @@ export function parseAnswerSegments(questions, output) {
     }
     return answers;
 }
+function cellText(cell) {
+    if (typeof cell === "string")
+        return cell;
+    if (typeof cell === "number" || typeof cell === "boolean")
+        return String(cell);
+    if (Array.isArray(cell)) {
+        const parts = cell.map((item) => (typeof item === "string" ? item : "")).filter(Boolean);
+        return parts.length > 0 ? parts.join(", ") : undefined;
+    }
+    return undefined;
+}
+/** OpenCode 2 `question` output `{ answers: string[][] }`, or a JSON array of cells. */
+function parseJsonAnswerSegments(output, count) {
+    const trimmed = output.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+    const cells = Array.isArray(parsed)
+        ? parsed
+        : parsed && typeof parsed === "object" && Array.isArray(parsed.answers)
+            ? parsed.answers
+            : undefined;
+    if (!cells)
+        return undefined;
+    return Array.from({ length: count }, (_, index) => cellText(cells[index]));
+}
 /** OpenCode's placeholder for a question the user left blank. */
 const UNANSWERED = "Unanswered";
 /**

package/dist/protocol/blob-store.js

@@ -9,6 +9,7 @@
  * At a successful TurnEnded it is compacted to the graph reachable from the
  * latest checkpoint, matching Cursor CLI's conversation-export traversal.
  */
+import { errorMessage } from "../debug.js";
 import { collectReachableConversationBlobIds } from "./blob-reachability.js";
 function hex(b) {
     let s = "";
@@ -76,7 +77,7 @@ export function inspectConversationBlobGraph(conversationId, checkpoint) {
         return { count, bytes, complete: true };
     }
     catch (error) {
-        return retainedStats(error instanceof Error ? error.message : String(error));
+        return retainedStats(errorMessage(error));
     }
 }
 /** Copy all durable blobs so a completed turn can be persisted atomically. */
@@ -131,7 +132,7 @@ export function compactConversationBlobs(conversationId, checkpoint) {
         };
     }
     catch (error) {
-        return fallback(error instanceof Error ? error.message : String(error));
+        return fallback(errorMessage(error));
     }
 }
 /** Replace the in-memory blob bucket when restoring a persisted conversation. */

package/dist/protocol/conversation-bind.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { clearCheckpoint } from "./checkpoint.js";
 import { clearConversationBlobs } from "./blob-store.js";
-import { transferFrozenRequestContext, } from "../context/frozen.js";
+import { transferFrozenRequestContext } from "../context/frozen.js";
 /**
  * OpenCode session key → active Cursor conversation_id.
  *

package/dist/protocol/conversation-persistence.d.ts

@@ -11,6 +11,8 @@ export type PersistedConversation = {
     postCompactionRebase: boolean;
     hostAgent?: string;
     systemPromptHash?: string;
+    /** JSON-encoded TurnProvenance (what this provider emitted last). */
+    turnProvenance?: string;
 };
 export type ConversationLoadStatus = "restored" | "missing" | "invalid" | "expired";
 export type PersistedConversationLoad = {

package/dist/protocol/conversation-persistence.js

@@ -47,7 +47,8 @@ function cloneConversation(value) {
  *
  * ConversationCache: schema_version=1, session_key=2, conversation_id=3,
  * updated_at=4, checkpoint=5, blobs=6, request_context=7, tool_catalog=8,
- * post_compaction_rebase=9, host_agent=10, system_prompt_hash=11.
+ * post_compaction_rebase=9, host_agent=10, system_prompt_hash=11,
+ * turn_provenance_json=12.
  * Blob: id=1, data=2. Tool: name=1, description=2,
  * input_schema_json=3, source_name=4.
  *
@@ -176,6 +177,8 @@ function encodeCacheFile(value) {
         writer.uint32(fieldTag(10, 2)).string(value.hostAgent);
     if (value.systemPromptHash)
         writer.uint32(fieldTag(11, 2)).string(value.systemPromptHash);
+    if (value.turnProvenance)
+        writer.uint32(fieldTag(12, 2)).string(value.turnProvenance);
     return { protobufBytes: writer.finish(), requestContextBytes: requestContext.length };
 }
 function decodeProtobuf(data) {
@@ -191,6 +194,7 @@ function decodeProtobuf(data) {
     let postCompactionRebase = false;
     let hostAgent;
     let systemPromptHash;
+    let turnProvenance;
     while (reader.pos < reader.len) {
         const tag = reader.uint32();
         const wireType = tag & 7;
@@ -250,6 +254,11 @@ function decodeProtobuf(data) {
                     throw new Error("invalid system prompt hash");
                 systemPromptHash = reader.string();
                 break;
+            case 12:
+                if (wireType !== 2)
+                    throw new Error("invalid turn provenance");
+                turnProvenance = reader.string();
+                break;
             default:
                 reader.skipType(wireType);
         }
@@ -270,6 +279,7 @@ function decodeProtobuf(data) {
         postCompactionRebase,
         ...(hostAgent ? { hostAgent } : {}),
         ...(systemPromptHash ? { systemPromptHash } : {}),
+        ...(turnProvenance ? { turnProvenance } : {}),
     };
 }
 function decodeCacheFile(compressed, expectedSessionKey) {

package/dist/protocol/conversation-state.d.ts

@@ -7,6 +7,8 @@ export declare function hydrateConversationState(cacheDir: string, sessionKey: s
     hostAgent?: string;
     systemPromptHash?: string;
 } | undefined>;
+/** Restore only turn provenance when its in-memory entry was evicted. */
+export declare function hydrateTurnProvenance(cacheDir: string, sessionKey: string): Promise<void>;
 /** Persist the complete resumable state only after Cursor confirms TurnEnded. */
 export declare function persistConversationState(cacheDir: string, input: {
     sessionKey: string;

package/dist/protocol/conversation-state.js

@@ -3,6 +3,7 @@ import { getFrozenRequestContext, setFrozenRequestContext, } from "../context/fr
 import { hasConversationBinding, isActiveConversationBinding, restoreConversationBinding, } from "./conversation-bind.js";
 import { compactConversationBlobs, restoreConversationBlobs, } from "./blob-store.js";
 import { getCheckpoint, setCheckpoint } from "./checkpoint.js";
+import { getTurnProvenance, parseTurnProvenance, restoreTurnProvenance, serializeTurnProvenance, } from "./turn-provenance.js";
 import { deletePersistedConversation, loadPersistedConversation, persistConversation, } from "./conversation-persistence.js";
 /** Restore one OpenCode session before its conversation binding is resolved. */
 export async function hydrateConversationState(cacheDir, sessionKey) {
@@ -20,6 +21,9 @@ export async function hydrateConversationState(cacheDir, sessionKey) {
         setCheckpoint(persisted.conversationId, persisted.checkpoint);
     restoreConversationBlobs(persisted.conversationId, persisted.blobs);
     setFrozenRequestContext(persisted.conversationId, persisted.requestContext);
+    const provenance = persisted.turnProvenance ? parseTurnProvenance(persisted.turnProvenance) : undefined;
+    if (provenance?.conversationId === persisted.conversationId)
+        restoreTurnProvenance(sessionKey, provenance);
     trace(`conversation persistence: restored sessionKey=${sessionKey} ` +
         `conversationId=${persisted.conversationId} checkpoint=${persisted.checkpoint?.length ?? 0}B ` +
         `blobs=${persisted.blobs.length}`);
@@ -31,6 +35,17 @@ export async function hydrateConversationState(cacheDir, sessionKey) {
         ...(persisted.systemPromptHash ? { systemPromptHash: persisted.systemPromptHash } : {}),
     };
 }
+/** Restore only turn provenance when its in-memory entry was evicted. */
+export async function hydrateTurnProvenance(cacheDir, sessionKey) {
+    if (getTurnProvenance(sessionKey))
+        return;
+    const persisted = (await loadPersistedConversation(cacheDir, sessionKey)).value;
+    if (!persisted?.turnProvenance)
+        return;
+    const provenance = parseTurnProvenance(persisted.turnProvenance);
+    if (provenance?.conversationId === persisted.conversationId)
+        restoreTurnProvenance(sessionKey, provenance);
+}
 /** Persist the complete resumable state only after Cursor confirms TurnEnded. */
 export async function persistConversationState(cacheDir, input) {
     // A newer Run may have reset/superseded this conversation while its final
@@ -44,6 +59,7 @@ export async function persistConversationState(cacheDir, input) {
     const blobCompaction = compactConversationBlobs(input.conversationId, checkpoint);
     const blobs = blobCompaction.blobs;
     const requestContext = getFrozenRequestContext(input.conversationId) ?? input.requestContext;
+    const provenance = getTurnProvenance(input.sessionKey);
     await persistConversation(cacheDir, {
         sessionKey: input.sessionKey,
         conversationId: input.conversationId,
@@ -54,6 +70,9 @@ export async function persistConversationState(cacheDir, input) {
         postCompactionRebase: input.postCompactionRebase,
         hostAgent: input.hostAgent,
         systemPromptHash: input.systemPromptHash,
+        ...(provenance?.conversationId === input.conversationId
+            ? { turnProvenance: serializeTurnProvenance(provenance) }
+            : {}),
     });
     trace(`conversation persistence: saved sessionKey=${input.sessionKey} ` +
         `conversationId=${input.conversationId} checkpoint=${checkpoint?.length ?? 0}B ` +

package/dist/protocol/create-plan.d.ts

@@ -7,10 +7,10 @@
  * does **not** — plans must stay host-portable so switching models does not
  * strand users on Cursor-specific paths or frontmatter.
  *
- * Location mirrors OpenCode Session.plan shape, but the project-config segment
- * comes from {@link hostPlansDir} / {@link opencodeProjectConfigDirs}
- * (the active host's project config dir via the path bridge), never a
- * hardcoded OpenCode-only directory name.
+ * Location is the host's own: the session plan file when the host defines one
+ * (`hostPlanFilePath`, OpenCode 1.x `Session.plan`), otherwise a new
+ * `<created>-<slug>.md` under {@link hostPlansDir} (OpenCode 2.0's Plan
+ * directory, OpenCode 1.x `<data>/plans`, or an installed path bridge).
  *
  * Body is plain markdown (the same shape a plan-mode model would write with
  * `write`). Cursor YAML frontmatter is never emitted.
@@ -58,46 +58,66 @@ export type CursorPlanStageInput = {
  *             Its tool result is the approval outcome (success = approved,
  *             error = not approved). The result may name the host's own
  *             follow-up approval call. This provider does not invent that prompt.
- * - `approve` no such tool, but the host advertises `question`: the provider
- *             writes the plan itself and then asks the same thing with upstream
- *             `PlanExitTool`'s own prompt.
- * - `ack`     nothing to ask with (or a lifecycle turn): write, or for a
- *             lifecycle turn skip the write, and acknowledge the CLI way.
+ * - `ack`     nothing to ask with (or a lifecycle turn / CreatePlan outside
+ *             plan mode): write, or for a lifecycle turn skip the write, and
+ *             acknowledge the CLI way.
+ * - `approve` plan mode is active and the host advertises `question` but not
+ *             a plan review tool: write the plan, then ask with upstream
+ *             `PlanExitTool`'s own prompt (OpenCode 1.x / 2.0 without
+ *             `plan_exit`). Explicit "Yes" is execution approval.
+ * - `exit`    the host's `plan` agent is active, advertises `plan_exit`, and
+ *             its own plan file is known: write the plan there and run the
+ *             host `plan_exit` review. The host owns approval and execution;
+ *             the turn that carries the result leaves `plan` only on approval.
+ * - `defer`   the host's `plan` agent owns planning but CreatePlan cannot be
+ *             carried out yet: an approved switch into it is still pending (it
+ *             applies after this Run), or its plan file is unknown. Nothing is
+ *             written; the error tells the model which host workflow follows.
  *
- * The plan is always persisted before any prompt: writing needs no approval,
- * executing does.
+ * The plan is always persisted before any review: writing needs no approval,
+ * executing does, and only the host asks for it.
  */
 export type CreatePlanBridge = {
     kind: "stage";
+} | {
+    kind: "ack";
 } | {
     kind: "approve";
 } | {
-    kind: "ack";
+    kind: "defer";
+    reason: string;
+} | {
+    kind: "exit";
+    planPath: string;
 };
+/** CreatePlan raised before an approved switch into the host plan agent took effect. */
+export declare const CREATE_PLAN_HOST_PLAN_PENDING_REASON: string;
+/** CreatePlan raised while the host's own plan agent owns the plan file and its review. */
+export declare const CREATE_PLAN_HOST_PLAN_WORKFLOW_REASON: string;
+/** Cursor-visible reason when the user wants the plan revised instead of run. */
+export declare const CREATE_PLAN_NOT_APPROVED_REASON: string;
 /** Upstream `PlanExitTool` wording, with the plan the provider just wrote. */
 export declare function createPlanApprovalQuestion(planLabel: string): string;
 export declare const CREATE_PLAN_APPROVAL_HEADER = "Build Agent";
-/** Cursor-visible reason when the user wants the plan revised instead of run. */
-export declare const CREATE_PLAN_NOT_APPROVED_REASON: string;
-/**
- * Resolve how this CreatePlan is satisfied. `planModeActive` is the provider's
- * own record of an approved Cursor plan/spec mode: the approval prompt guards
- * the transition *out of* planning, so a CreatePlan raised outside plan mode is
- * written and acknowledged without one.
- */
+/** Resolve how this CreatePlan is satisfied (see {@link CreatePlanBridge}). */
 export declare function resolveCreatePlanBridge(options: {
     allowTools: boolean;
     canStage?: boolean;
-    planModeActive?: boolean;
     advertised: ReadonlySet<string> | Iterable<string>;
+    /** An approved switch into the host `plan` agent waits for this Run to end. */
+    hostPlanEntryPending?: boolean;
+    /** Host primary agent of this Run, when the host reported it. */
+    hostAgent?: string;
+    /** Provider-recorded Cursor plan/spec mode (the gate out of planning). */
+    planModeActive?: boolean;
+    /** The host's own plan file for this session, when the host defines one. */
+    hostPlanFile?: string;
 }): CreatePlanBridge;
 /** Host `question` input mirroring upstream `PlanExitTool`'s own prompt. */
 export declare function createPlanApprovalQuestionInput(planLabel: string): OpencodeQuestionInput;
 /**
  * True when the emulated approval prompt came back as an explicit "Yes".
- * An unanswered, dismissed, or failed prompt keeps the model planning rather
- * than silently starting execution. OpenCode prose is anchored on the exact
- * prompt text. Every other result shape fails closed.
+ * An unanswered, dismissed, or failed prompt keeps the model planning.
  */
 export declare function createPlanApproved(output: string, isError: boolean, question: string): boolean;
 /** Decode a `create_plan_request_query` body, or undefined when unusable. */
@@ -125,7 +145,9 @@ export declare function renderOpencodePlanMarkdown(args: CursorCreatePlanArgs):
  * Write the plan under {@link hostPlansDir} and return a `file://` URI.
  * Empty / missing content is the caller's responsibility (empty plan_uri ack).
  */
-export declare function writeOpencodePlanFile(args: CursorCreatePlanArgs, workspaceRoot: string, created?: number): CreatePlanWriteResult;
+export declare function writeOpencodePlanFile(args: CursorCreatePlanArgs, workspaceRoot: string, created?: number, 
+/** Exact host-owned plan file; default is a new file under {@link hostPlansDir}. */
+target?: string): CreatePlanWriteResult;
 /**
  * The plan as the user reads it before approving execution.
  *

package/dist/protocol/create-plan.js

@@ -7,10 +7,10 @@
  * does **not** — plans must stay host-portable so switching models does not
  * strand users on Cursor-specific paths or frontmatter.
  *
- * Location mirrors OpenCode Session.plan shape, but the project-config segment
- * comes from {@link hostPlansDir} / {@link opencodeProjectConfigDirs}
- * (the active host's project config dir via the path bridge), never a
- * hardcoded OpenCode-only directory name.
+ * Location is the host's own: the session plan file when the host defines one
+ * (`hostPlanFilePath`, OpenCode 1.x `Session.plan`), otherwise a new
+ * `<created>-<slug>.md` under {@link hostPlansDir} (OpenCode 2.0's Plan
+ * directory, OpenCode 1.x `<data>/plans`, or an installed path bridge).
  *
  * Body is plain markdown (the same shape a plan-mode model would write with
  * `write`). Cursor YAML frontmatter is never emitted.
@@ -19,8 +19,9 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { hostPlansDir } from "../context/paths.js";
-import { parseAnswerSegments, } from "./ask-question.js";
 import { decodeMessageSparse } from "./messages.js";
+import { errorMessage } from "../debug.js";
+import { parseAnswerSegments, } from "./ask-question.js";
 const PLAN_ADJECTIVES = [
     "brave",
     "calm",
@@ -89,6 +90,17 @@ const PLAN_NOUNS = [
 export const CURSOR_PLAN_STAGE_TOOL = "cursor_plan_stage";
 /** Held InteractionQuery continuation field for a native host plan stage. */
 export const CREATE_PLAN_RESULT_FIELD = "create_plan_request_response";
+/** CreatePlan raised before an approved switch into the host plan agent took effect. */
+export const CREATE_PLAN_HOST_PLAN_PENDING_REASON = "Plan mode starts in the host's plan agent after this turn. Do not record the plan " +
+    "now and make no further tool calls: end this turn. Planning continues in the next " +
+    "turn under the host's plan-mode instructions.";
+/** CreatePlan raised while the host's own plan agent owns the plan file and its review. */
+export const CREATE_PLAN_HOST_PLAN_WORKFLOW_REASON = "This host's plan agent owns the plan file and its approval. Write the plan where the " +
+    "plan-mode instructions say, then call `plan_exit` to ask the user to approve it. Do " +
+    "not implement until it is approved.";
+/** Cursor-visible reason when the user wants the plan revised instead of run. */
+export const CREATE_PLAN_NOT_APPROVED_REASON = "The user did not approve executing this plan. Keep planning: refine the plan and "
+    + "propose it again when it is ready.";
 /** Upstream `PlanExitTool` wording, with the plan the provider just wrote. */
 export function createPlanApprovalQuestion(planLabel) {
     const where = planLabel.trim();
@@ -99,28 +111,28 @@ export function createPlanApprovalQuestion(planLabel) {
 export const CREATE_PLAN_APPROVAL_HEADER = "Build Agent";
 const CREATE_PLAN_APPROVAL_YES = "Yes";
 const CREATE_PLAN_APPROVAL_NO = "No";
-/** Cursor-visible reason when the user wants the plan revised instead of run. */
-export const CREATE_PLAN_NOT_APPROVED_REASON = "The user did not approve executing this plan. Keep planning: refine the plan and "
-    + "propose it again when it is ready.";
-/**
- * Resolve how this CreatePlan is satisfied. `planModeActive` is the provider's
- * own record of an approved Cursor plan/spec mode: the approval prompt guards
- * the transition *out of* planning, so a CreatePlan raised outside plan mode is
- * written and acknowledged without one.
- */
+/** Resolve how this CreatePlan is satisfied (see {@link CreatePlanBridge}). */
 export function resolveCreatePlanBridge(options) {
     // A lifecycle turn (title generation, compaction) runs alongside the real one
     // and must not write a second plan file or raise a second prompt.
     if (!options.allowTools)
         return { kind: "ack" };
+    if (options.hostPlanEntryPending) {
+        return { kind: "defer", reason: CREATE_PLAN_HOST_PLAN_PENDING_REASON };
+    }
     if (options.canStage)
         return { kind: "stage" };
     const names = options.advertised instanceof Set ? options.advertised : new Set(options.advertised);
-    if (options.planModeActive && names.has("question"))
+    if (options.hostAgent === "plan" && names.has("plan_exit")) {
+        return options.hostPlanFile
+            ? { kind: "exit", planPath: options.hostPlanFile }
+            : { kind: "defer", reason: CREATE_PLAN_HOST_PLAN_WORKFLOW_REASON };
+    }
+    const planModeActive = options.planModeActive === true || options.hostAgent === "plan";
+    if (planModeActive && names.has("question"))
         return { kind: "approve" };
     return { kind: "ack" };
 }
-/** The synthetic AskQuestion item backing the emulated approval prompt. */
 function createPlanApprovalItem(question) {
     return {
         id: "create_plan_approval",
@@ -155,16 +167,13 @@ export function createPlanApprovalQuestionInput(planLabel) {
 }
 /**
  * True when the emulated approval prompt came back as an explicit "Yes".
- * An unanswered, dismissed, or failed prompt keeps the model planning rather
- * than silently starting execution. OpenCode prose is anchored on the exact
- * prompt text. Every other result shape fails closed.
+ * An unanswered, dismissed, or failed prompt keeps the model planning.
  */
 export function createPlanApproved(output, isError, question) {
     if (isError)
         return false;
     const [segment] = parseAnswerSegments([createPlanApprovalItem(question)], output);
-    const answer = (segment ?? "").trim().toLowerCase();
-    return answer === CREATE_PLAN_APPROVAL_YES.toLowerCase();
+    return (segment ?? "").trim().toLowerCase() === CREATE_PLAN_APPROVAL_YES.toLowerCase();
 }
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
@@ -333,18 +342,20 @@ export function renderOpencodePlanMarkdown(args) {
  * Write the plan under {@link hostPlansDir} and return a `file://` URI.
  * Empty / missing content is the caller's responsibility (empty plan_uri ack).
  */
-export function writeOpencodePlanFile(args, workspaceRoot, created = Date.now()) {
+export function writeOpencodePlanFile(args, workspaceRoot, created = Date.now(), 
+/** Exact host-owned plan file; default is a new file under {@link hostPlansDir}. */
+target) {
     const markdown = renderOpencodePlanMarkdown(args);
     if (!markdown.trim()) {
         return { ok: false, error: "CreatePlan produced no plan content to write" };
     }
-    const planPath = resolveHostPlanPath(workspaceRoot, args.name, created);
+    const planPath = target ?? resolveHostPlanPath(workspaceRoot, args.name, created);
     try {
         mkdirSync(path.dirname(planPath), { recursive: true });
         writeFileSync(planPath, markdown, "utf-8");
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
+        const message = errorMessage(err);
         return { ok: false, error: `Failed to write plan file: ${message}` };
     }
     return {