@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/agents/providers/codex-sdk.js

@@ -1,11 +1,27 @@
 import { z } from "zod";
-import { Codex } from "@openai/codex-sdk";
+import { Codex, } from "@openai/codex-sdk";
 import { CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY } from "../../keiyaku.js";
 import { appendDebugBlock, appendDebugLog } from "../../telemetry/debug-log.js";
 import { SUBAGENT_SESSION_VERSION } from "../session.js";
 import { createProjectionDriver } from "../harness/execution-handle.js";
+import { boundActivityExcerpt } from "../harness/activity-values.js";
 import { buildSubagentEnv, emitProviderEvidence, sha256Utf8 } from "../harness/runtime.js";
-import { coerceString } from "../../agents/index.js";
+import { coerceString } from "../harness/runtime.js";
+import { AGENT_PLAN_ITEM_TEXT_MAX_CHARS, AGENT_PLAN_MAX_ITEMS, AGENT_THOUGHT_TEXT_MAX_CHARS, } from "../harness/events.js";
+import { appendEventType, renderEventTypeSummary } from "./event-type-tail.js";
+/** Identity-only opacity boundary for Codex SDK ThreadOptions modelReasoningEffort. */
+function toCodexSdkModelReasoningEffort(effort) {
+    return effort;
+}
+function withCodexSdkModelReasoningEffort(threadOptions) {
+    const raw = threadOptions.modelReasoningEffort;
+    if (typeof raw !== "string")
+        return threadOptions;
+    return {
+        ...threadOptions,
+        modelReasoningEffort: toCodexSdkModelReasoningEffort(raw),
+    };
+}
 let codexConstructor = Codex;
 export function setCodexSdkConstructorForTests(constructor) {
     codexConstructor = constructor;
@@ -18,30 +34,128 @@ const CODEX_EVENT_THREAD_STARTED = "thread.started";
 const CODEX_EVENT_TURN_STARTED = "turn.started";
 const CODEX_EVENT_TURN_FAILED = "turn.failed";
 const CODEX_EVENT_ERROR = "error";
+const CODEX_EVENT_ITEM_STARTED = "item.started";
 const CODEX_EVENT_ITEM_COMPLETED = "item.completed";
 const CODEX_EVENT_ITEM_UPDATED = "item.updated";
+const CODEX_EVENT_TURN_COMPLETED = "turn.completed";
 const CODEX_SDK_PROVIDER = "codex-sdk";
-const MAX_RECORDED_EVENT_TYPES = 100;
+const CODEX_SDK_ACKNOWLEDGED_UNPERSISTED = new Set([CODEX_EVENT_THREAD_STARTED]);
+const CODEX_SDK_MAPPED = new Set([
+    CODEX_EVENT_TURN_STARTED,
+    CODEX_EVENT_TURN_COMPLETED,
+    CODEX_EVENT_TURN_FAILED,
+    CODEX_EVENT_ERROR,
+    CODEX_EVENT_ITEM_STARTED,
+    CODEX_EVENT_ITEM_UPDATED,
+    CODEX_EVENT_ITEM_COMPLETED,
+]);
+function codexSdkIngressDisposition(type) {
+    if (CODEX_SDK_ACKNOWLEDGED_UNPERSISTED.has(type))
+        return "acknowledged-unpersisted";
+    if (CODEX_SDK_MAPPED.has(type))
+        return "mapped";
+    return "unknown";
+}
 function extractAgentMessage(event) {
     if (event.type !== CODEX_EVENT_ITEM_COMPLETED && event.type !== CODEX_EVENT_ITEM_UPDATED) {
         return undefined;
     }
     return event.item.type === "agent_message" ? coerceString(event.item.text) : undefined;
 }
-function appendEventType(recordedTypes, eventType) {
-    if (recordedTypes.length === MAX_RECORDED_EVENT_TYPES) {
-        recordedTypes.shift();
+function codexActivityCall(item) {
+    switch (item.type) {
+        case "command_execution": return { kind: "run", command: item.command };
+        case "file_change": return {
+            kind: "fileChange",
+            changes: item.changes.map((change) => ({ op: change.kind, path: change.path })),
+        };
+        case "mcp_tool_call": return { kind: "other", display: `${item.server}.${item.tool}` };
+        case "web_search": return { kind: "search", query: item.query };
     }
-    recordedTypes.push(eventType);
 }
-function renderEventTypeSummary(eventTypes, totalEventCount) {
-    if (eventTypes.length === 0)
-        return "(no streamed events)";
-    const startIndex = Math.max(totalEventCount - eventTypes.length, 0);
-    const summary = eventTypes.map((eventType, index) => `${startIndex + index + 1}. ${eventType}`).join("\n");
-    if (totalEventCount <= eventTypes.length)
-        return summary;
-    return `...[showing last ${eventTypes.length} of ${totalEventCount} events]...\n${summary}`;
+function codexMcpResultMessage(item) {
+    if (item.error?.message)
+        return boundActivityExcerpt(item.error.message);
+    const text = item.result?.content.flatMap((block) => (block.type === "text" && typeof block.text === "string" ? [block.text] : [])).join("\n");
+    return text ? boundActivityExcerpt(text) : undefined;
+}
+function codexActivityResult(item) {
+    switch (item.type) {
+        case "command_execution": return {
+            status: item.status === "failed" || (item.exit_code !== undefined && item.exit_code !== 0) ? "error" : "ok",
+            ...(item.aggregated_output ? { message: boundActivityExcerpt(item.aggregated_output) } : {}),
+            ...(item.exit_code === undefined ? {} : { exitCode: item.exit_code }),
+        };
+        case "file_change": return { status: item.status === "failed" ? "error" : "ok" };
+        case "mcp_tool_call": {
+            const message = codexMcpResultMessage(item);
+            return { status: item.status === "failed" ? "error" : "ok", ...(message ? { message } : {}) };
+        }
+        case "web_search": return { status: "ok" };
+    }
+}
+function emitCodexSemanticEvent(builder, event) {
+    if (event.type === CODEX_EVENT_TURN_STARTED) {
+        builder.emit({ type: "turn", phase: "started" });
+        return;
+    }
+    if (event.type === CODEX_EVENT_TURN_COMPLETED) {
+        builder.emit({
+            type: "usage",
+            inputTokens: event.usage.input_tokens,
+            outputTokens: event.usage.output_tokens,
+            cachedInputTokens: event.usage.cached_input_tokens,
+        });
+        builder.emit({ type: "turn", phase: "completed" });
+        return;
+    }
+    if (event.type !== CODEX_EVENT_ITEM_STARTED &&
+        event.type !== CODEX_EVENT_ITEM_UPDATED &&
+        event.type !== CODEX_EVENT_ITEM_COMPLETED) {
+        return;
+    }
+    if (event.item.type === "reasoning" &&
+        (event.type === CODEX_EVENT_ITEM_UPDATED || event.type === CODEX_EVENT_ITEM_COMPLETED)) {
+        const truncated = event.item.text.length > AGENT_THOUGHT_TEXT_MAX_CHARS;
+        builder.emit({
+            type: "thought",
+            id: event.item.id,
+            text: event.item.text.slice(0, AGENT_THOUGHT_TEXT_MAX_CHARS),
+            final: event.type === CODEX_EVENT_ITEM_COMPLETED,
+            ...(truncated ? { truncated: true } : {}),
+        });
+        return;
+    }
+    if (event.item.type === "todo_list") {
+        builder.emit({
+            type: "plan",
+            id: event.item.id,
+            items: event.item.items.slice(0, AGENT_PLAN_MAX_ITEMS).map((item) => ({
+                text: item.text.slice(0, AGENT_PLAN_ITEM_TEXT_MAX_CHARS),
+                done: item.completed,
+            })),
+        });
+        return;
+    }
+    if (event.item.type !== "command_execution" &&
+        event.item.type !== "file_change" &&
+        event.item.type !== "mcp_tool_call" &&
+        event.item.type !== "web_search") {
+        return;
+    }
+    const phase = event.type === CODEX_EVENT_ITEM_STARTED
+        ? "started"
+        : event.type === CODEX_EVENT_ITEM_UPDATED
+            ? "updated"
+            : "completed";
+    builder.emit({
+        type: "activity",
+        phase,
+        id: event.item.id,
+        tool: event.item.type,
+        call: codexActivityCall(event.item),
+        ...(phase === "started" ? {} : { result: codexActivityResult(event.item) }),
+    });
 }
 export async function startCodexSdk(prompt, cwd, options) {
     const threadId = options.threadId?.trim();
@@ -51,6 +165,8 @@ export async function startCodexSdk(prompt, cwd, options) {
     appendDebugLog(`startCodexSdk: executable=${options.executable ?? "codex"} model=${options.model ?? "default"} ${CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY}=${String(options.config?.[CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY] ?? "default")} mode=${threadId ? "resume" : "fresh"}`, { cwd, section: CODEX_SDK_PROVIDER });
     return createProjectionDriver({
         steerMode: "replay",
+        initialTurn: options.initialTurn,
+        onIngress: options.onIngress,
         async abort() {
             activeAbort?.abort();
         },
@@ -71,7 +187,7 @@ export async function startCodexSdk(prompt, cwd, options) {
                     env,
                 };
                 const sdk = new codexConstructor(codexOptions);
-                const threadOptions = options.threadOptions;
+                const threadOptions = withCodexSdkModelReasoningEffort(options.threadOptions);
                 const thread = threadId ? sdk.resumeThread(threadId, threadOptions) : sdk.startThread(threadOptions);
                 const streamed = await thread.runStreamed(prompt, { signal: activeAbort.signal });
                 const eventIterator = streamed.events[Symbol.asyncIterator]();
@@ -116,31 +232,33 @@ export async function startCodexSdk(prompt, cwd, options) {
                     }
                     totalEventCount += 1;
                     appendEventType(recordedEventTypes, event.type);
-                    builder.emit({ type: "output", value: event });
-                    if (event.type === CODEX_EVENT_THREAD_STARTED) {
-                        resumeToken = event.thread_id;
-                        if (options.onEvidence)
-                            emitProviderEvidence(options.onEvidence, { type: "session", provider: CODEX_SDK_PROVIDER, threadId: resumeToken }, (text) => builder.emit({ type: "diagnostic", text }));
-                    }
-                    else if (event.type === CODEX_EVENT_TURN_STARTED && !resumeToken) {
-                        builder.emit({
-                            type: "fail",
-                            message: `${CODEX_SDK_PROVIDER} exec emitted turn.started before thread.started with thread_id`,
-                        });
-                        throw new Error(`${CODEX_SDK_PROVIDER} exec emitted turn.started before thread.started with thread_id`);
-                    }
-                    else if (event.type === CODEX_EVENT_TURN_FAILED) {
-                        turnFailedMessage = coerceString(event.error.message) ?? `${CODEX_SDK_PROVIDER} turn failed`;
-                    }
-                    else if (event.type === CODEX_EVENT_ERROR) {
-                        streamErrorMessage = coerceString(event.message) ?? `${CODEX_SDK_PROVIDER} stream error`;
-                        builder.emit({ type: "diagnostic", text: `${streamErrorMessage}\n` });
-                    }
-                    const message = extractAgentMessage(event);
-                    if (message) {
-                        lastAgentMessage = message;
-                        builder.emit({ type: "message", text: message });
-                    }
+                    builder.ingress(CODEX_SDK_PROVIDER, event.type, event, codexSdkIngressDisposition(event.type), () => {
+                        if (event.type === CODEX_EVENT_THREAD_STARTED) {
+                            resumeToken = event.thread_id;
+                            if (options.onEvidence)
+                                emitProviderEvidence(options.onEvidence, { type: "session", provider: CODEX_SDK_PROVIDER, threadId: resumeToken }, (text) => builder.emit({ type: "diagnostic", text }));
+                        }
+                        else if (event.type === CODEX_EVENT_TURN_STARTED && !resumeToken) {
+                            builder.emit({
+                                type: "fail",
+                                message: `${CODEX_SDK_PROVIDER} exec emitted turn.started before thread.started with thread_id`,
+                            });
+                            throw new Error(`${CODEX_SDK_PROVIDER} exec emitted turn.started before thread.started with thread_id`);
+                        }
+                        else if (event.type === CODEX_EVENT_TURN_FAILED) {
+                            turnFailedMessage = coerceString(event.error.message) ?? `${CODEX_SDK_PROVIDER} turn failed`;
+                        }
+                        else if (event.type === CODEX_EVENT_ERROR) {
+                            streamErrorMessage = coerceString(event.message) ?? `${CODEX_SDK_PROVIDER} stream error`;
+                            builder.emit({ type: "diagnostic", text: `${streamErrorMessage}\n` });
+                        }
+                        emitCodexSemanticEvent(builder, event);
+                        const message = extractAgentMessage(event);
+                        if (message) {
+                            lastAgentMessage = message;
+                            builder.emit({ type: "message", text: message });
+                        }
+                    });
                 }
                 if (turnFailedMessage) {
                     builder.emit({ type: "diagnostic", text: turnFailedMessage });

package/build/agents/providers/event-type-tail.js

@@ -0,0 +1,16 @@
+export const MAX_RECORDED_EVENT_TYPES = 100;
+export function appendEventType(recordedTypes, eventType) {
+    if (recordedTypes.length === MAX_RECORDED_EVENT_TYPES) {
+        recordedTypes.shift();
+    }
+    recordedTypes.push(eventType);
+}
+export function renderEventTypeSummary(eventTypes, totalEventCount) {
+    if (eventTypes.length === 0)
+        return "(no streamed events)";
+    const startIndex = Math.max(totalEventCount - eventTypes.length, 0);
+    const summary = eventTypes.map((eventType, index) => `${startIndex + index + 1}. ${eventType}`).join("\n");
+    if (totalEventCount <= eventTypes.length)
+        return summary;
+    return `...[showing last ${eventTypes.length} of ${totalEventCount} events]...\n${summary}`;
+}

package/build/agents/providers/opencode-sdk.js

@@ -1,43 +1,54 @@
 import { z } from "zod";
+import { FlowError } from "../../flow-error.js";
 import { appendDebugBlock, appendDebugLog } from "../../telemetry/debug-log.js";
 import { createOpencode } from "../opencode-sdk.js";
 import { SUBAGENT_SESSION_VERSION } from "../session.js";
 import { createProjectionDriver } from "../harness/execution-handle.js";
-import { buildSubagentEnv, createAbortError } from "../harness/runtime.js";
-import { emitProviderEvidence, sha256Utf8 } from "../harness/runtime.js";
-import { coerceString } from "../index.js";
+import { buildSubagentEnv, coerceString, createAbortError, emitProviderEvidence, sha256Utf8 } from "../harness/runtime.js";
+import { activityCallFromNamedTool } from "../harness/activity-values.js";
+import { appendEventType, renderEventTypeSummary } from "./event-type-tail.js";
+/** Identity-only opacity boundary for OpenCode session.prompt variant. */
+function toOpencodeSdkVariant(effort) {
+    return effort;
+}
 export const opencodeSessionSchema = z.object({ sessionId: z.string().trim().min(1) });
 const OPENCODE_EVENT_SESSION_IDLE = "session.idle";
 const OPENCODE_EVENT_SESSION_ERROR = "session.error";
-const OPENCODE_EVENT_MESSAGE_UPDATED = "message.updated";
-const OPENCODE_EVENT_MESSAGE_PART_UPDATED = "message.part.updated";
-const OPENCODE_EVENT_MESSAGE_PART_ADDED = "message.part.added";
 const OPENCODE_SDK_PROVIDER = "opencode-sdk";
+function opencodeIngressDisposition(event) {
+    if (event.type === OPENCODE_EVENT_SESSION_IDLE)
+        return "acknowledged-unpersisted";
+    if (event.type === OPENCODE_EVENT_SESSION_ERROR)
+        return "mapped";
+    if (event.type === "message.part.updated" && event.properties.part.type === "tool") {
+        return event.properties.part.state.status === "pending" ? "acknowledged-unpersisted" : "mapped";
+    }
+    return "unknown";
+}
 const OPENCODE_DEFAULT_EXECUTABLE = "opencode";
-const OPENCODE_MAX_RECORDED_EVENT_TYPES = 100;
 const OPENCODE_ASSISTANT_ROLE = "assistant";
 const OPENCODE_TEXT_PART_TYPE = "text";
 let opencodeSdkLoader;
-function appendEventType(recordedTypes, eventType) {
-    if (recordedTypes.length === OPENCODE_MAX_RECORDED_EVENT_TYPES) {
-        recordedTypes.shift();
+/**
+ * Convert configured opaque OpenCode model string at the first slash into the
+ * 1.17.20 prompt model object. No string compatibility path remains.
+ */
+export function parseOpencodeModelRef(model) {
+    const trimmed = model.trim();
+    const slash = trimmed.indexOf("/");
+    if (slash <= 0 || slash === trimmed.length - 1) {
+        throw new FlowError("INVALID_SETTINGS", `Invalid opencode model '${model}'. Expected opaque shape '<provider>/<model>' with non-empty segments split at the first slash.`);
     }
-    recordedTypes.push(eventType);
-}
-function renderEventTypeSummary(eventTypes, totalEventCount) {
-    if (eventTypes.length === 0)
-        return "(no streamed events)";
-    const startIndex = Math.max(totalEventCount - eventTypes.length, 0);
-    const summary = eventTypes.map((eventType, index) => `${startIndex + index + 1}. ${eventType}`).join("\n");
-    if (totalEventCount <= eventTypes.length)
-        return summary;
-    return `...[showing last ${eventTypes.length} of ${totalEventCount} events]...\n${summary}`;
+    return {
+        providerID: trimmed.slice(0, slash),
+        modelID: trimmed.slice(slash + 1),
+    };
 }
 function extractTextFromMessage(message) {
     if (!message?.parts)
         return undefined;
     const text = message.parts
-        .filter((part) => !part.type || part.type === OPENCODE_TEXT_PART_TYPE)
+        .filter((part) => part.type === OPENCODE_TEXT_PART_TYPE)
         .map((part) => coerceString(part.text))
         .filter((part) => Boolean(part))
         .join("");
@@ -57,6 +68,64 @@ function extractFinalAssistantMessage(messages) {
     }
     return lastAssistantText ?? lastText;
 }
+function eventSessionId(event) {
+    const properties = event.properties;
+    if (!properties || typeof properties !== "object" || !("sessionID" in properties))
+        return undefined;
+    return typeof properties.sessionID === "string" ? properties.sessionID : undefined;
+}
+function extractToolCall(part) {
+    const input = part.state.input;
+    const stringFact = (primary, fallback) => {
+        const first = input[primary];
+        if (typeof first === "string" && first.length > 0)
+            return first;
+        const second = fallback === undefined ? undefined : input[fallback];
+        return typeof second === "string" && second.length > 0 ? second : undefined;
+    };
+    const integerFact = (key) => {
+        const value = input[key];
+        return typeof value === "number" && Number.isInteger(value) ? value : undefined;
+    };
+    const tool = part.tool.toLowerCase();
+    let facts = {};
+    if (tool === "bash" || tool === "shell") {
+        facts = { command: stringFact("command") };
+    }
+    else if (tool === "read") {
+        facts = {
+            path: stringFact("filePath", "path"),
+            offset: integerFact("offset"),
+            limit: integerFact("limit"),
+        };
+    }
+    else if (tool === "write" || tool === "edit") {
+        facts = { path: stringFact("filePath", "path") };
+    }
+    else if (tool === "grep" || tool === "search" || tool === "glob") {
+        facts = { query: stringFact("pattern", "query") };
+    }
+    const classifierTool = tool === "grep" || tool === "glob" ? "search" : part.tool;
+    return activityCallFromNamedTool(classifierTool, facts);
+}
+function completedResult(state) {
+    const exit = state.metadata.exit;
+    const exitCode = typeof exit === "number" && Number.isInteger(exit) ? exit : undefined;
+    const message = coerceString(state.output);
+    return {
+        status: exitCode !== undefined && exitCode !== 0 ? "error" : "ok",
+        ...(message ? { message } : {}),
+        ...(exitCode === undefined ? {} : { exitCode }),
+    };
+}
+function isToolPartUpdated(event) {
+    return event.type === "message.part.updated" && event.properties.part.type === "tool";
+}
+function sessionErrorMessage(event) {
+    const data = event.properties.error?.data;
+    const message = data && "message" in data ? coerceString(data.message) : undefined;
+    return message ?? `${OPENCODE_SDK_PROVIDER} session error`;
+}
 async function withAbort(promise, signal, message) {
     if (signal.aborted) {
         throw createAbortError(message);
@@ -81,7 +150,7 @@ async function withAbort(promise, signal, message) {
 }
 async function loadOpencodeSdk(executable, cwd, env, signal) {
     if (opencodeSdkLoader) {
-        return opencodeSdkLoader();
+        return opencodeSdkLoader(cwd);
     }
     const sdk = await createOpencode({
         executable,
@@ -95,33 +164,65 @@ async function loadOpencodeSdk(executable, cwd, env, signal) {
     };
 }
 async function awaitSessionIdle(input) {
-    const subscribed = await input.client.event.subscribe();
+    const firstRunning = new Map();
+    const running = new Set();
+    const subscribed = await input.client.event.subscribe({ directory: input.directory });
     for await (const event of subscribed.stream) {
-        input.emit({ type: "output", value: event });
-        input.incrementEventCount();
-        appendEventType(input.recordedEventTypes, event.type);
-        if (event.properties?.sessionID !== input.sessionId) {
+        if (eventSessionId(event) !== input.sessionId) {
             continue;
         }
-        if (event.type === OPENCODE_EVENT_SESSION_ERROR) {
-            const errorMessage = coerceString(event.error?.message) ??
-                coerceString(event.properties?.message) ??
-                `${OPENCODE_SDK_PROVIDER} session error`;
-            input.emit({ type: "diagnostic", text: errorMessage });
-            input.emit({ type: "fail", message: errorMessage });
-            throw new Error(errorMessage);
-        }
-        if (event.type === OPENCODE_EVENT_SESSION_IDLE ||
-            event.type === OPENCODE_EVENT_MESSAGE_UPDATED ||
-            event.type === OPENCODE_EVENT_MESSAGE_PART_UPDATED ||
-            event.type === OPENCODE_EVENT_MESSAGE_PART_ADDED) {
-            if (event.type === OPENCODE_EVENT_SESSION_IDLE) {
+        input.incrementEventCount();
+        appendEventType(input.recordedEventTypes, event.type);
+        let sessionError;
+        input.builder.ingress(OPENCODE_SDK_PROVIDER, event.type, event, opencodeIngressDisposition(event), () => {
+            if (event.type === OPENCODE_EVENT_SESSION_ERROR) {
+                sessionError = sessionErrorMessage(event);
+                input.builder.emit({ type: "diagnostic", text: sessionError });
+                input.builder.emit({ type: "fail", message: sessionError });
                 return;
             }
+            if (isToolPartUpdated(event)) {
+                const part = event.properties.part;
+                if (part.state.status === "pending")
+                    return;
+                if (part.state.status === "running") {
+                    const activity = firstRunning.get(part.id) ?? { tool: part.tool, call: extractToolCall(part) };
+                    if (!firstRunning.has(part.id))
+                        firstRunning.set(part.id, activity);
+                    const phase = running.has(part.id) ? "updated" : "started";
+                    running.add(part.id);
+                    input.builder.emit({ type: "activity", phase, id: part.id, ...activity });
+                }
+                else if (part.state.status === "completed") {
+                    const activity = firstRunning.get(part.id) ?? { tool: part.tool, call: extractToolCall(part) };
+                    input.builder.emit({
+                        type: "activity",
+                        phase: "completed",
+                        id: part.id,
+                        ...activity,
+                        result: completedResult(part.state),
+                    });
+                }
+                else if (part.state.status === "error") {
+                    const activity = firstRunning.get(part.id) ?? { tool: part.tool, call: extractToolCall(part) };
+                    input.builder.emit({
+                        type: "activity",
+                        phase: "completed",
+                        id: part.id,
+                        ...activity,
+                        result: { status: "error", message: part.state.error },
+                    });
+                }
+            }
+        });
+        if (sessionError !== undefined)
+            throw new Error(sessionError);
+        if (event.type === OPENCODE_EVENT_SESSION_IDLE) {
+            return;
         }
     }
     const message = `${OPENCODE_SDK_PROVIDER} event stream ended before ${OPENCODE_EVENT_SESSION_IDLE}`;
-    input.emit({ type: "fail", message });
+    input.builder.emit({ type: "fail", message });
     throw new Error(message);
 }
 export function setOpencodeSdkLoaderForTests(loader) {
@@ -133,6 +234,9 @@ export function resetOpencodeSdkLoaderForTests() {
 export async function startOpencode(prompt, cwd, options = {}) {
     const sessionId = options.sessionId?.trim();
     const executable = options.executable ?? OPENCODE_DEFAULT_EXECUTABLE;
+    // A configured value is always intentional. Validate even empty/blank input
+    // before loading the SDK so it cannot silently become the provider default.
+    const modelRef = options.model === undefined ? undefined : parseOpencodeModelRef(options.model);
     const recordedEventTypes = [];
     let totalEventCount = 0;
     let resumedSessionId;
@@ -141,6 +245,8 @@ export async function startOpencode(prompt, cwd, options = {}) {
     appendDebugLog(`startOpencode: executable=${executable} model=${options.model ?? "default"} mode=${sessionId ? "resume" : "fresh"}`, { cwd, section: OPENCODE_SDK_PROVIDER });
     return createProjectionDriver({
         steerMode: "replay",
+        initialTurn: options.initialTurn,
+        onIngress: options.onIngress,
         async abort() {
             activeAbort?.abort();
         },
@@ -157,15 +263,11 @@ export async function startOpencode(prompt, cwd, options = {}) {
             try {
                 const env = buildSubagentEnv();
                 sdk = await withAbort(loadOpencodeSdk(executable, cwd, env, combined.signal), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
+                // OpenCode 1.17.20 session.create has no model field; keep cwd only.
                 const session = sessionId
-                    ? await withAbort(sdk.client.session.get({ path: { id: sessionId } }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`)
-                    : await withAbort(sdk.client.session.create({
-                        body: {
-                            ...(options.model ? { model: options.model } : {}),
-                            cwd,
-                        },
-                    }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
-                resumedSessionId = session.id || sessionId;
+                    ? await withAbort(sdk.client.session.get({ sessionID: sessionId, directory: cwd }, { throwOnError: true }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`)
+                    : await withAbort(sdk.client.session.create({ directory: cwd }, { throwOnError: true }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
+                resumedSessionId = session.data.id || sessionId;
                 if (!resumedSessionId) {
                     const message = `${OPENCODE_SDK_PROVIDER} exec could not determine session id`;
                     builder.emit({ type: "fail", message });
@@ -176,8 +278,9 @@ export async function startOpencode(prompt, cwd, options = {}) {
                     emitProviderEvidence(options.onEvidence, { type: "session", provider: OPENCODE_SDK_PROVIDER, sessionId: activeSessionId }, (text) => builder.emit({ type: "diagnostic", text }));
                 const idlePromise = awaitSessionIdle({
                     client: sdk.client,
-                    emit: builder.emit,
+                    builder,
                     sessionId: activeSessionId,
+                    directory: cwd,
                     recordedEventTypes,
                     incrementEventCount: () => {
                         totalEventCount += 1;
@@ -195,13 +298,15 @@ export async function startOpencode(prompt, cwd, options = {}) {
                         ...sha256Utf8(prompt),
                     }, (text) => builder.emit({ type: "diagnostic", text }));
                 }
+                const textPart = { type: OPENCODE_TEXT_PART_TYPE, text: prompt };
+                builder.emit({ type: "turn", phase: "started" });
                 const promptPromise = sdk.client.session.prompt({
-                    path: { id: activeSessionId },
-                    body: {
-                        ...(options.model ? { model: options.model } : {}),
-                        parts: [{ type: OPENCODE_TEXT_PART_TYPE, text: prompt }],
-                    },
-                });
+                    sessionID: activeSessionId,
+                    directory: cwd,
+                    ...(modelRef ? { model: modelRef } : {}),
+                    ...(options.effort ? { variant: toOpencodeSdkVariant(options.effort) } : {}),
+                    parts: [textPart],
+                }, { throwOnError: true });
                 if (options.onEvidence) {
                     emitProviderEvidence(options.onEvidence, {
                         type: "ack",
@@ -211,10 +316,10 @@ export async function startOpencode(prompt, cwd, options = {}) {
                     }, (text) => builder.emit({ type: "diagnostic", text }));
                 }
                 const [promptResult] = await withAbort(Promise.all([promptPromise, idlePromise]), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
-                let finalMessage = extractTextFromMessage(promptResult);
+                let finalMessage = extractTextFromMessage(promptResult.data);
                 if (!finalMessage) {
-                    const messages = await withAbort(sdk.client.session.messages({ path: { id: activeSessionId } }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
-                    finalMessage = extractFinalAssistantMessage(messages);
+                    const messages = await withAbort(sdk.client.session.messages({ sessionID: activeSessionId, directory: cwd }, { throwOnError: true }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
+                    finalMessage = extractFinalAssistantMessage(messages.data);
                 }
                 if (finalMessage) {
                     builder.emit({ type: "message", text: finalMessage });
@@ -233,6 +338,7 @@ export async function startOpencode(prompt, cwd, options = {}) {
                         source: "response",
                     }, (text) => builder.emit({ type: "diagnostic", text }));
                 }
+                builder.emit({ type: "turn", phase: "completed" });
                 builder.emit({
                     type: "done",
                     finalMessage: resolvedFinal,