takt 0.49.0 → 0.51.0

package/dist/infra/opencode/client.js

@@ -9,16 +9,37 @@ import { createServer } from 'node:net';
 import { loadTemplate } from '../../shared/prompts/index.js';
 import { mapsToOpenCodeEditPermission } from './allowedTools.js';
 import { AskUserQuestionDeniedError } from '../../core/workflow/ask-user-question-error.js';
+import { parseLastJsonBlock } from '../../agents/structured-caller/shared.js';
 import { createLogger, getErrorMessage, createStreamDiagnostics } from '../../shared/utils/index.js';
 import { getNestedObservabilityEnvFingerprint, runWithNestedObservabilityProcessEnv, } from '../../shared/telemetry/index.js';
 import { parseProviderModel } from '../../shared/utils/providerModel.js';
-import { buildOpenCodePermissionRuleset, resolveOpenCodePermissionReply, } from './types.js';
+import { buildOpenCodePermissionRuleset, buildOpenCodePromptTools, buildOpenCodeSessionPermission, resolveOpenCodePermissionReply, } from './types.js';
 import { createStreamTrackingState, emitInit, emitText, emitPermissionAsked, emitPermissionSummary, emitResult, handlePartUpdated, } from './OpenCodeStreamHandler.js';
-import { UnavailableToolLoopDetector } from './unavailable-tool-loop.js';
+import { InvalidToolArgumentLoopDetector, ToolErrorBudgetDetector, UnavailableToolLoopDetector } from './unavailable-tool-loop.js';
 import { buildRateLimitedResponseFields, containsRateLimitError } from '../rate-limit/detection.js';
 const TAKT_AGENT = 'takt';
 const TAKT_AGENT_REVIEW = 'takt-review';
 const TAKT_AGENT_REPORT = 'takt-report';
+/**
+ * イベントが属するセッション ID を取り出す。イベントバスはサーバ全体で
+ * 共有されるため、無音検出のリセットは「自セッションの進捗」だけに
+ * 反応させる必要がある（LSP・ファイルウォッチャ・兄弟セッションの
+ * イベントでリセットすると、生成が死んでいても永遠にハングする）。
+ */
+function extractEventSessionId(event) {
+    const props = event.properties;
+    if (!props)
+        return undefined;
+    if (typeof props.sessionID === 'string')
+        return props.sessionID;
+    const part = props.part;
+    if (part !== undefined && typeof part.sessionID === 'string')
+        return part.sessionID;
+    const info = props.info;
+    if (info !== undefined && typeof info.sessionID === 'string')
+        return info.sessionID;
+    return undefined;
+}
 function selectTaktAgent(allowedTools) {
     if (allowedTools !== undefined && allowedTools.length === 0) {
         return TAKT_AGENT_REPORT;
@@ -33,7 +54,16 @@ function selectTaktAgent(allowedTools) {
     return TAKT_AGENT_REVIEW;
 }
 const log = createLogger('opencode-sdk');
-const OPENCODE_STREAM_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+/** 呼び出し時に評価する（テストや実験で env から上書きできるようにする） */
+function resolveMessageCycleBudget() {
+    const fromEnv = Number(process.env.TAKT_OPENCODE_MESSAGE_CYCLE_BUDGET);
+    return fromEnv > 0 ? fromEnv : 120;
+}
+/** 呼び出し時に評価する（テストや実験で env から上書きできるようにする） */
+function resolveStreamIdleTimeoutMs() {
+    const fromEnv = Number(process.env.TAKT_OPENCODE_STREAM_IDLE_TIMEOUT_MS);
+    return fromEnv > 0 ? fromEnv : 10 * 60 * 1000;
+}
 const OPENCODE_STREAM_ABORTED_MESSAGE = 'OpenCode execution aborted';
 const OPENCODE_RETRY_MAX_ATTEMPTS = 3;
 const OPENCODE_RETRY_BASE_DELAY_MS = 250;
@@ -95,6 +125,14 @@ async function createSharedServer(model, apiKey, childProcessEnv) {
         config: {
             model,
             small_model: model,
+            // Session-level permission rules are rewritten whenever a prompt
+            // carries a tools map (OpenCode materializes the map into
+            // session.permission), so session-scoped denies do not survive the
+            // first prompt. Server-config permission is outside that rewrite and
+            // is the only layer that reliably keeps out-of-workspace access a
+            // soft tool error instead of an ask (which would depend on the
+            // user's global OpenCode config).
+            permission: { external_directory: 'deny' },
             ...(apiKey ? { provider: { opencode: { options: { apiKey } } } } : {}),
             agent: {
                 [TAKT_AGENT]: {
@@ -163,6 +201,93 @@ export async function getOpenCodeSessionSnapshot(model, sessionID, directory, ap
         release();
     }
 }
+/** レート制限を示す HTTP ステータス。プロバイダは 429 を返す。 */
+const RATE_LIMIT_STATUS_CODE = 429;
+/**
+ * 検死 RPC の上限。検死自体がハングして再度の無限待ちを招かないようにする。
+ * 呼び出し時に評価する（テストで env から上書きできるようにする）。
+ */
+function resolvePostmortemTimeoutMs() {
+    const fromEnv = Number(process.env.TAKT_OPENCODE_POSTMORTEM_TIMEOUT_MS);
+    return fromEnv > 0 ? fromEnv : 5000;
+}
+/** statusCode は数値でも文字列でも来うるため正規化する。 */
+function extractStatusCode(error) {
+    if (!error || typeof error !== 'object') {
+        return undefined;
+    }
+    const data = error.data;
+    const raw = data?.statusCode;
+    if (typeof raw === 'number') {
+        return raw;
+    }
+    if (typeof raw === 'string') {
+        const parsed = Number(raw);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+/**
+ * 直近の assistant メッセージのエラーを検死し、レート制限ならその内容を返す。
+ *
+ * OpenCode サーバはプロバイダの 429 を内部リトライで握り、イベントバスへ
+ * session.error を流さない。takt からは「無音のまま停止したセッション」に
+ * 見えるため、無音ウォッチドッグのタイムアウト後にここで死因を確かめる。
+ *
+ * 判定するのは「最新の assistant メッセージ」だけに限る。sessionId は phase や
+ * resume で再利用されるため、過去の assistant に残る古い 429 を今回の死因と
+ * 誤認しないようにする。
+ */
+async function postmortemRateLimitError(client, sessionID, directory) {
+    let messages;
+    try {
+        const result = await withTimeout((signal) => client.session.messages({ sessionID, directory }, { signal }), resolvePostmortemTimeoutMs(), 'OpenCode rate limit postmortem timed out');
+        if (!result.data) {
+            return undefined;
+        }
+        messages = result.data;
+    }
+    catch (error) {
+        // 検死そのものの失敗（RPC エラー・ハング）で本来のエラーを覆い隠さない。
+        log.debug('Rate limit postmortem could not read session messages', {
+            sessionID,
+            error: getErrorMessage(error),
+        });
+        return undefined;
+    }
+    // 末尾が assistant でないなら、今回のターンの応答はまだ作られていない。
+    // ここで過去へ遡ると、セッション再利用時に前回ターンの 429 を今回の死因と
+    // 誤認する（[前回 assistant 429, 今回 user prompt] のまま無音停止する形）。
+    const latestInfo = messages[messages.length - 1]?.info;
+    if (latestInfo?.role !== 'assistant') {
+        return undefined;
+    }
+    const error = latestInfo.error;
+    if (error === undefined) {
+        return undefined;
+    }
+    const message = extractOpenCodeErrorMessage(error);
+    if (extractStatusCode(error) === RATE_LIMIT_STATUS_CODE) {
+        return message ?? `HTTP ${RATE_LIMIT_STATUS_CODE} Too Many Requests`;
+    }
+    if (message !== undefined && containsRateLimitError(message)) {
+        return message;
+    }
+    return undefined;
+}
+export async function getOpenCodeSessionMessages(model, sessionID, directory, apiKey) {
+    const { client, release } = await acquireClient(model, apiKey, undefined);
+    try {
+        const result = await client.session.messages({ sessionID, directory });
+        if (!result.data) {
+            throw new Error(`OpenCode session messages not found: ${sessionID}`);
+        }
+        return result.data;
+    }
+    finally {
+        release();
+    }
+}
 function releaseClient(server) {
     const next = server.queue.shift();
     if (next) {
@@ -185,6 +310,25 @@ function throwIfAborted(signal) {
         throw new Error(OPENCODE_STREAM_ABORTED_MESSAGE);
     }
 }
+function createExternalAbortPromise(controller, externalAbortSignal) {
+    if (externalAbortSignal === undefined) {
+        return {};
+    }
+    let removeListener;
+    const promise = new Promise((_, reject) => {
+        const onExternalAbort = () => {
+            reject(new Error(OPENCODE_STREAM_ABORTED_MESSAGE));
+            controller.abort();
+        };
+        if (externalAbortSignal.aborted) {
+            onExternalAbort();
+            return;
+        }
+        externalAbortSignal.addEventListener('abort', onExternalAbort, { once: true });
+        removeListener = () => externalAbortSignal.removeEventListener('abort', onExternalAbort);
+    });
+    return { promise, removeListener };
+}
 function createReleaseHandle(server) {
     let released = false;
     return () => {
@@ -200,25 +344,37 @@ export function resetSharedServer() {
     }
     sharedServers.clear();
 }
-async function withTimeout(operation, timeoutMs, timeoutErrorMessage) {
+async function withTimeout(operation, timeoutMs, timeoutErrorMessage, externalAbortSignal) {
     const controller = new AbortController();
+    let timedOut = false;
     let timeoutId;
     const timeoutPromise = new Promise((_, reject) => {
         timeoutId = setTimeout(() => {
+            timedOut = true;
             controller.abort();
             reject(new Error(timeoutErrorMessage));
         }, timeoutMs);
     });
+    const externalAbort = createExternalAbortPromise(controller, externalAbortSignal);
     try {
-        return await Promise.race([
-            operation(controller.signal),
-            timeoutPromise,
-        ]);
+        const operationPromise = operation(controller.signal).catch((error) => {
+            if (timedOut) {
+                return new Promise(() => {
+                    // The timeout promise owns the rejection after aborting the SDK call.
+                });
+            }
+            throw error;
+        });
+        const racePromises = externalAbort.promise !== undefined
+            ? [operationPromise, timeoutPromise, externalAbort.promise]
+            : [operationPromise, timeoutPromise];
+        return await Promise.race(racePromises);
     }
     finally {
         if (timeoutId !== undefined) {
             clearTimeout(timeoutId);
         }
+        externalAbort.removeListener?.();
     }
 }
 function extractOpenCodeErrorMessage(error) {
@@ -371,10 +527,19 @@ export class OpenCodeClient {
     }
     /** Call OpenCode with an agent prompt */
     async call(agentType, prompt, options) {
-        for (let attempt = 1; attempt <= OPENCODE_RETRY_MAX_ATTEMPTS; attempt++) {
+        // native format（StructuredOutput ツール）をモデルが呼ばない個体が
+        // あるため、その失敗を検出したら format なし（手書き JSON + 下流の
+        // 是正リトライ）へフォールバックする。
+        let disableNativeStructuredOutput = false;
+        // フォールバック（format なし再試行）は transient 再試行の予算とは別枠で
+        // 1回だけ確保する: 先行の transient エラーで予算を使い切っていても、
+        // 最終試行の format 失敗から救済できるようにする。
+        let maxAttempts = OPENCODE_RETRY_MAX_ATTEMPTS;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
             let idleTimeoutId;
             const streamAbortController = new AbortController();
-            const timeoutMessage = `OpenCode stream timed out after ${Math.floor(OPENCODE_STREAM_IDLE_TIMEOUT_MS / 60000)} minutes of inactivity`;
+            const streamIdleTimeoutMs = resolveStreamIdleTimeoutMs();
+            const timeoutMessage = `OpenCode stream timed out after ${Math.round(streamIdleTimeoutMs / 60000)} minutes of inactivity`;
             let abortCause;
             let diagRef;
             let release;
@@ -418,9 +583,10 @@ export class OpenCodeClient {
                 }
                 idleTimeoutId = setTimeout(() => {
                     diagRef?.onIdleTimeoutFired();
+                    log.warn(timeoutMessage, { sessionId, model: options.model });
                     abortCause = 'timeout';
                     streamAbortController.abort();
-                }, OPENCODE_STREAM_IDLE_TIMEOUT_MS);
+                }, streamIdleTimeoutMs);
             };
             const onExternalAbort = () => {
                 abortCause = 'external';
@@ -455,23 +621,17 @@ export class OpenCodeClient {
                     throw new Error(OPENCODE_STREAM_ABORTED_MESSAGE);
                 }
                 const permissionRuleset = buildOpenCodePermissionRuleset(options.permissionMode, options.networkAccess, options.allowedTools);
-                const shouldCreateSession = sessionId === undefined || options.allowedTools !== undefined;
-                const appliedPermissionRuleset = shouldCreateSession;
+                // The session is created once per step and reused across phases: a
+                // session-scoped deny can never be escalated later, and recreating the
+                // session drops the conversation history the report/judgment phases
+                // depend on. Per-phase tool restriction rides on the explicit prompt
+                // tools map below instead.
+                const appliedPermissionRuleset = sessionId === undefined;
+                const sessionPermission = buildOpenCodeSessionPermission(options.permissionMode, options.networkAccess, options.allowedTools);
                 if (sessionId === undefined) {
                     const sessionResult = await opencodeApiClient.session.create({
                         directory: options.cwd,
-                        permission: permissionRuleset,
-                    });
-                    sessionId = sessionResult.data?.id;
-                    if (!sessionId) {
-                        throw new Error('Failed to create OpenCode session');
-                    }
-                }
-                else if (options.allowedTools !== undefined) {
-                    const sessionResult = await opencodeApiClient.session.create({
-                        directory: options.cwd,
-                        parentID: sessionId,
-                        permission: permissionRuleset,
+                        permission: sessionPermission,
                     });
                     sessionId = sessionResult.data?.id;
                     if (!sessionId) {
@@ -491,21 +651,32 @@ export class OpenCodeClient {
                         ...(options.permissionMode !== undefined ? { permissionMode: options.permissionMode } : {}),
                         ...(options.allowedTools !== undefined ? { allowedTools: options.allowedTools } : {}),
                         ...(options.networkAccess !== undefined ? { networkAccess: options.networkAccess } : {}),
-                        resolvedPermissions: permissionRuleset,
+                        resolvedPermissions: sessionPermission,
                     });
                 }
                 const agentName = selectTaktAgent(options.allowedTools);
+                // OpenCode persists the last explicit tools map on the session, so
+                // every prompt sends the full map for its own phase (see
+                // buildOpenCodePromptTools).
+                const promptTools = buildOpenCodePromptTools(options.permissionMode, options.networkAccess, options.allowedTools);
                 log.debug('Selecting OpenCode agent', {
                     agentName,
                     allowedTools: options.allowedTools,
+                    promptTools,
                 });
                 const promptPayload = {
                     sessionID: activeSessionId,
                     directory: options.cwd,
                     model: parsedModel,
+                    tools: promptTools,
                     ...(agentName !== undefined ? { agent: agentName } : {}),
                     ...(options.variant !== undefined ? { variant: options.variant } : {}),
                     ...(options.systemPrompt !== undefined ? { system: options.systemPrompt } : {}),
+                    // ネイティブ構造化出力: OpenCode がスキーマのキー構造を強制する
+                    // （enum 等の値制約までは保証されないため、下流のスキーマ検証は維持）。
+                    ...(options.outputSchema !== undefined && !disableNativeStructuredOutput
+                        ? { format: { type: 'json_schema', schema: options.outputSchema, retryCount: 2 } }
+                        : {}),
                     parts: [{ type: 'text', text: prompt }],
                 };
                 const promptPayloadForSdk = promptPayload;
@@ -521,9 +692,12 @@ export class OpenCodeClient {
                 emitInit(options.onStream, options.model, activeSessionId);
                 let content = '';
                 let success = true;
+                let capturedStructuredOutput;
                 let failureMessage = '';
                 const state = createStreamTrackingState();
                 const unavailableToolLoopDetector = new UnavailableToolLoopDetector();
+                const invalidArgumentLoopDetector = new InvalidToolArgumentLoopDetector();
+                const toolErrorBudgetDetector = new ToolErrorBudgetDetector();
                 const echoState = { remainingPrompts: buildPromptEchoCandidates(prompt, options.systemPrompt) };
                 const textOffsets = new Map();
                 const textContentParts = new Map();
@@ -544,198 +718,283 @@ export class OpenCodeClient {
                     const prevOffset = textOffsets.get(partId) ?? 0;
                     textOffsets.set(partId, prevOffset + rawDelta.length);
                 };
-                for await (const event of stream) {
-                    if (streamAbortController.signal.aborted)
-                        break;
-                    resetIdleTimeout();
-                    const sseEvent = event;
-                    diag.onFirstEvent(sseEvent.type);
-                    diag.onEvent(sseEvent.type);
-                    if (sseEvent.type === 'message.part.updated') {
-                        const props = sseEvent.properties;
-                        const part = props.part;
-                        const delta = props.delta;
-                        if (part.type === 'text') {
-                            unavailableToolLoopDetector.reset();
-                            const textPart = part;
-                            const prev = textOffsets.get(textPart.id) ?? 0;
-                            const rawDelta = delta
-                                ?? (textPart.text.length > prev ? textPart.text.slice(prev) : '');
-                            consumeTextDelta(textPart.id, rawDelta);
-                            continue;
+                // for-await 単体だと、タイマーが abort してもイベントが来るまで
+                // 待ちから戻らない（SDK が signal を尊重しない場合は永久待機）。
+                // イテレータと abort をレースさせ、タイマー発火で必ず脱出する。
+                const streamIterator = stream[Symbol.asyncIterator]();
+                const streamAborted = new Promise((_, reject) => {
+                    streamAbortController.signal.addEventListener('abort', () => {
+                        reject(new Error(timeoutMessage));
+                    }, { once: true });
+                });
+                streamAborted.catch(() => { });
+                // 劣化した生成は「ごく短いアシスタント応答サイクル」を数百回繰り返す
+                // （実測: 524〜1211 ループ）。テキスト断片だけの空転はツールエラー
+                // 予算にも無音検出にも掛からないため、応答サイクル数で打ち切る。
+                // 健全なステップはツール往復込みでも数十サイクルに収まる。
+                let assistantMessageCycles = 0;
+                const messageCycleBudget = resolveMessageCycleBudget();
+                try {
+                    while (true) {
+                        if (streamAbortController.signal.aborted)
+                            break;
+                        let iteration;
+                        try {
+                            iteration = await Promise.race([streamIterator.next(), streamAborted]);
                         }
-                        if (part.type === 'tool') {
-                            const toolPart = part;
-                            const loopError = toolPart.state.status === 'error'
-                                ? unavailableToolLoopDetector.observe(toolPart.callID || toolPart.id, toolPart.tool, toolPart.state.error)
-                                : undefined;
-                            if (toolPart.state.status === 'completed') {
-                                unavailableToolLoopDetector.reset();
-                            }
-                            handlePartUpdated(part, delta, options.onStream, state);
-                            if (loopError !== undefined) {
-                                success = false;
-                                failureMessage = loopError;
-                                diag.onStreamError('message.part.updated', loopError);
+                        catch (raceError) {
+                            if (streamAbortController.signal.aborted)
                                 break;
-                            }
+                            throw raceError;
+                        }
+                        if (iteration.done)
+                            break;
+                        const event = iteration.value;
+                        const sseEvent = event;
+                        // セッション帰属が判明していて自分でないイベントは処理しない。
+                        // サーバプールは同一モデルで共有されるため（並列レビュー等）、
+                        // 兄弟セッションの text/tool 更新を通すと content と検出器が
+                        // 汚染される。帰属不明のイベントは種別ごとの処理に委ねるが、
+                        // 無音検出のリセット（延命）は自セッションのイベントに限る。
+                        const eventSessionId = extractEventSessionId(sseEvent);
+                        if (eventSessionId !== undefined && eventSessionId !== activeSessionId) {
                             continue;
                         }
-                        handlePartUpdated(part, delta, options.onStream, state);
-                        continue;
-                    }
-                    if (sseEvent.type === 'message.part.delta') {
-                        const deltaProps = sseEvent.properties;
-                        if (deltaProps.field === 'text' && deltaProps.delta) {
-                            unavailableToolLoopDetector.reset();
-                            consumeTextDelta(deltaProps.partID, deltaProps.delta);
+                        if (eventSessionId === activeSessionId) {
+                            resetIdleTimeout();
                         }
-                        continue;
-                    }
-                    if (sseEvent.type === 'permission.asked') {
-                        const permProps = sseEvent.properties;
-                        if (permProps.sessionID === activeSessionId) {
-                            try {
-                                const reply = resolveOpenCodePermissionReply(options.permissionMode, permProps.permission, options.allowedTools !== undefined ? permissionRuleset : undefined);
-                                emitPermissionAsked(options.onStream, {
-                                    requestId: permProps.id,
-                                    sessionId: permProps.sessionID,
-                                    permission: permProps.permission ?? '',
-                                    patterns: Array.isArray(permProps.patterns) ? permProps.patterns : [],
-                                    always: Array.isArray(permProps.always) ? permProps.always : [],
-                                    reply,
-                                });
-                                await withTimeout((signal) => opencodeApiClient.permission.reply({
-                                    requestID: permProps.id,
-                                    directory: options.cwd,
-                                    reply,
-                                }, { signal }), interactionTimeoutMs, 'OpenCode permission reply timed out');
-                                if (reply === 'reject') {
+                        diag.onFirstEvent(sseEvent.type);
+                        diag.onEvent(sseEvent.type);
+                        if (sseEvent.type === 'message.part.updated') {
+                            const props = sseEvent.properties;
+                            const part = props.part;
+                            const delta = props.delta;
+                            if (part.type === 'text') {
+                                unavailableToolLoopDetector.reset();
+                                const textPart = part;
+                                const prev = textOffsets.get(textPart.id) ?? 0;
+                                const rawDelta = delta
+                                    ?? (textPart.text.length > prev ? textPart.text.slice(prev) : '');
+                                consumeTextDelta(textPart.id, rawDelta);
+                                continue;
+                            }
+                            if (part.type === 'tool') {
+                                const toolPart = part;
+                                let loopError;
+                                if (toolPart.state.status === 'error') {
+                                    // 両検出器に必ず観測させる（?? 短絡だと invalid 側が
+                                    // unavailable エラーを見逃し、連続性の判定が狂う）
+                                    const unavailableError = unavailableToolLoopDetector.observe(toolPart.callID || toolPart.id, toolPart.tool, toolPart.state.error);
+                                    const invalidArgumentError = invalidArgumentLoopDetector.observe(toolPart.callID || toolPart.id, toolPart.tool, toolPart.state.error);
+                                    const budgetError = toolErrorBudgetDetector.observe(toolPart.callID || toolPart.id, toolPart.tool, toolPart.state.error);
+                                    loopError = unavailableError ?? invalidArgumentError ?? budgetError;
+                                }
+                                if (toolPart.state.status === 'completed') {
+                                    unavailableToolLoopDetector.reset();
+                                    invalidArgumentLoopDetector.reset();
+                                }
+                                handlePartUpdated(part, delta, options.onStream, state);
+                                if (loopError !== undefined) {
                                     success = false;
-                                    failureMessage = buildPermissionRejectedMessage(permProps.permission);
+                                    failureMessage = loopError;
+                                    diag.onStreamError('message.part.updated', loopError);
                                     break;
                                 }
+                                continue;
                             }
-                            catch (e) {
-                                success = false;
-                                failureMessage = getErrorMessage(e);
-                                break;
+                            handlePartUpdated(part, delta, options.onStream, state);
+                            continue;
+                        }
+                        if (sseEvent.type === 'message.part.delta') {
+                            const deltaProps = sseEvent.properties;
+                            if (deltaProps.field === 'text' && deltaProps.delta) {
+                                unavailableToolLoopDetector.reset();
+                                consumeTextDelta(deltaProps.partID, deltaProps.delta);
                             }
+                            continue;
                         }
-                        continue;
-                    }
-                    if (sseEvent.type === 'question.asked') {
-                        const questionProps = sseEvent.properties;
-                        if (questionProps.sessionID === activeSessionId) {
-                            const rejectQuestion = () => withTimeout((signal) => opencodeApiClient.question.reject({
-                                requestID: questionProps.id,
-                                directory: options.cwd,
-                            }, { signal }), interactionTimeoutMs, 'OpenCode question reject timed out');
-                            if (!options.onAskUserQuestion) {
+                        if (sseEvent.type === 'permission.asked') {
+                            const permProps = sseEvent.properties;
+                            if (permProps.sessionID === activeSessionId) {
                                 try {
-                                    await rejectQuestion();
+                                    const reply = resolveOpenCodePermissionReply(options.permissionMode, permProps.permission, options.allowedTools !== undefined ? permissionRuleset : undefined);
+                                    emitPermissionAsked(options.onStream, {
+                                        requestId: permProps.id,
+                                        sessionId: permProps.sessionID,
+                                        permission: permProps.permission ?? '',
+                                        patterns: Array.isArray(permProps.patterns) ? permProps.patterns : [],
+                                        always: Array.isArray(permProps.always) ? permProps.always : [],
+                                        reply,
+                                    });
+                                    await withTimeout((signal) => opencodeApiClient.permission.reply({
+                                        requestID: permProps.id,
+                                        directory: options.cwd,
+                                        reply,
+                                    }, { signal }), interactionTimeoutMs, 'OpenCode permission reply timed out');
+                                    if (reply === 'reject') {
+                                        // A rejected permission is a per-tool failure, not a fatal
+                                        // one: OpenCode returns the rejection to the model as a tool
+                                        // error and generation continues (verified against a live
+                                        // server). Aborting here used to turn a single stray
+                                        // out-of-workspace access into a whole-step failure.
+                                        log.info(buildPermissionRejectedMessage(permProps.permission), {
+                                            permission: permProps.permission,
+                                            patterns: permProps.patterns,
+                                        });
+                                    }
                                 }
                                 catch (e) {
                                     success = false;
                                     failureMessage = getErrorMessage(e);
                                     break;
                                 }
-                                continue;
                             }
-                            try {
-                                const answers = await options.onAskUserQuestion(toQuestionInput(questionProps));
-                                await withTimeout((signal) => opencodeApiClient.question.reply({
+                            continue;
+                        }
+                        if (sseEvent.type === 'question.asked') {
+                            const questionProps = sseEvent.properties;
+                            if (questionProps.sessionID === activeSessionId) {
+                                const rejectQuestion = () => withTimeout((signal) => opencodeApiClient.question.reject({
                                     requestID: questionProps.id,
                                     directory: options.cwd,
-                                    answers: toQuestionAnswers(questionProps, answers),
-                                }, { signal }), interactionTimeoutMs, 'OpenCode question reply timed out');
-                            }
-                            catch (e) {
-                                if (e instanceof AskUserQuestionDeniedError) {
+                                }, { signal }), interactionTimeoutMs, 'OpenCode question reject timed out');
+                                if (!options.onAskUserQuestion) {
                                     try {
                                         await rejectQuestion();
                                     }
-                                    catch (rejectErr) {
+                                    catch (e) {
                                         success = false;
-                                        failureMessage = getErrorMessage(rejectErr);
+                                        failureMessage = getErrorMessage(e);
                                         break;
                                     }
+                                    continue;
+                                }
+                                try {
+                                    const answers = await options.onAskUserQuestion(toQuestionInput(questionProps));
+                                    await withTimeout((signal) => opencodeApiClient.question.reply({
+                                        requestID: questionProps.id,
+                                        directory: options.cwd,
+                                        answers: toQuestionAnswers(questionProps, answers),
+                                    }, { signal }), interactionTimeoutMs, 'OpenCode question reply timed out');
                                 }
-                                else {
+                                catch (e) {
+                                    if (e instanceof AskUserQuestionDeniedError) {
+                                        try {
+                                            await rejectQuestion();
+                                        }
+                                        catch (rejectErr) {
+                                            success = false;
+                                            failureMessage = getErrorMessage(rejectErr);
+                                            break;
+                                        }
+                                    }
+                                    else {
+                                        success = false;
+                                        failureMessage = getErrorMessage(e);
+                                        break;
+                                    }
+                                }
+                            }
+                            continue;
+                        }
+                        if (sseEvent.type === 'message.updated') {
+                            const messageProps = sseEvent.properties;
+                            const info = messageProps.info;
+                            const isCurrentAssistantMessage = info?.sessionID === activeSessionId && info?.role === 'assistant';
+                            if (isCurrentAssistantMessage) {
+                                if (info?.structured !== undefined && info.structured !== null && typeof info.structured === 'object' && !Array.isArray(info.structured)) {
+                                    capturedStructuredOutput = info.structured;
+                                }
+                                const streamError = extractOpenCodeErrorMessage(info?.error);
+                                if (streamError) {
                                     success = false;
-                                    failureMessage = getErrorMessage(e);
+                                    failureMessage = streamError;
+                                    diag.onStreamError('message.updated', streamError);
                                     break;
                                 }
+                                if (info?.time?.completed !== undefined) {
+                                    assistantMessageCycles += 1;
+                                    if (assistantMessageCycles >= messageCycleBudget) {
+                                        success = false;
+                                        failureMessage = `OpenCode assistant message cycle budget exceeded (${assistantMessageCycles} cycles in one call)`;
+                                        diag.onStreamError('message.updated', failureMessage);
+                                        break;
+                                    }
+                                }
                             }
+                            continue;
                         }
-                        continue;
-                    }
-                    if (sseEvent.type === 'message.updated') {
-                        const messageProps = sseEvent.properties;
-                        const info = messageProps.info;
-                        const isCurrentAssistantMessage = info?.sessionID === activeSessionId && info?.role === 'assistant';
-                        if (isCurrentAssistantMessage) {
-                            const streamError = extractOpenCodeErrorMessage(info?.error);
-                            if (streamError) {
-                                success = false;
-                                failureMessage = streamError;
-                                diag.onStreamError('message.updated', streamError);
-                                break;
+                        if (sseEvent.type === 'message.completed') {
+                            const completedProps = sseEvent.properties;
+                            const info = completedProps.info;
+                            const isCurrentAssistantMessage = info?.sessionID === activeSessionId && info?.role === 'assistant';
+                            if (isCurrentAssistantMessage) {
+                                if (info?.structured !== undefined && info.structured !== null && typeof info.structured === 'object' && !Array.isArray(info.structured)) {
+                                    capturedStructuredOutput = info.structured;
+                                }
+                                const streamError = extractOpenCodeErrorMessage(info?.error);
+                                if (streamError) {
+                                    success = false;
+                                    failureMessage = streamError;
+                                    diag.onStreamError('message.completed', streamError);
+                                    break;
+                                }
                             }
+                            continue;
                         }
-                        continue;
-                    }
-                    if (sseEvent.type === 'message.completed') {
-                        const completedProps = sseEvent.properties;
-                        const info = completedProps.info;
-                        const isCurrentAssistantMessage = info?.sessionID === activeSessionId && info?.role === 'assistant';
-                        if (isCurrentAssistantMessage) {
-                            const streamError = extractOpenCodeErrorMessage(info?.error);
-                            if (streamError) {
+                        if (sseEvent.type === 'message.failed') {
+                            const failedProps = sseEvent.properties;
+                            const info = failedProps.info;
+                            const isCurrentAssistantMessage = info?.sessionID === activeSessionId && info?.role === 'assistant';
+                            if (isCurrentAssistantMessage) {
                                 success = false;
-                                failureMessage = streamError;
-                                diag.onStreamError('message.completed', streamError);
+                                failureMessage = extractOpenCodeErrorMessage(info?.error) ?? 'OpenCode message failed';
+                                diag.onStreamError('message.failed', failureMessage);
                                 break;
                             }
+                            continue;
                         }
-                        continue;
-                    }
-                    if (sseEvent.type === 'message.failed') {
-                        const failedProps = sseEvent.properties;
-                        const info = failedProps.info;
-                        const isCurrentAssistantMessage = info?.sessionID === activeSessionId && info?.role === 'assistant';
-                        if (isCurrentAssistantMessage) {
-                            success = false;
-                            failureMessage = extractOpenCodeErrorMessage(info?.error) ?? 'OpenCode message failed';
-                            diag.onStreamError('message.failed', failureMessage);
-                            break;
+                        if (sseEvent.type === 'session.status') {
+                            const statusProps = sseEvent.properties;
+                            if (statusProps.sessionID === activeSessionId && statusProps.status?.type === 'idle') {
+                                break;
+                            }
+                            continue;
                         }
-                        continue;
-                    }
-                    if (sseEvent.type === 'session.status') {
-                        const statusProps = sseEvent.properties;
-                        if (statusProps.sessionID === activeSessionId && statusProps.status?.type === 'idle') {
-                            break;
+                        if (sseEvent.type === 'session.idle') {
+                            const idleProps = sseEvent.properties;
+                            if (idleProps.sessionID === activeSessionId) {
+                                break;
+                            }
+                            continue;
                         }
-                        continue;
-                    }
-                    if (sseEvent.type === 'session.idle') {
-                        const idleProps = sseEvent.properties;
-                        if (idleProps.sessionID === activeSessionId) {
-                            break;
+                        if (sseEvent.type === 'session.error') {
+                            const errorProps = sseEvent.properties;
+                            if (!errorProps.sessionID || errorProps.sessionID === activeSessionId) {
+                                success = false;
+                                failureMessage = extractOpenCodeErrorMessage(errorProps.error) ?? 'OpenCode session error';
+                                diag.onStreamError('session.error', failureMessage);
+                                break;
+                            }
+                            continue;
                         }
-                        continue;
                     }
-                    if (sseEvent.type === 'session.error') {
-                        const errorProps = sseEvent.properties;
-                        if (!errorProps.sessionID || errorProps.sessionID === activeSessionId) {
-                            success = false;
-                            failureMessage = extractOpenCodeErrorMessage(errorProps.error) ?? 'OpenCode session error';
-                            diag.onStreamError('session.error', failureMessage);
-                            break;
-                        }
-                        continue;
+                }
+                finally {
+                    // for-await が break 時に行っていた後始末（SSE クローズ）を再現する
+                    try {
+                        await streamIterator.return?.(undefined);
                     }
+                    catch { /* クローズ失敗は結果に影響させない */ }
+                }
+                // The idle watchdog and external aborts cancel the stream. If the
+                // iterator ends without throwing, the loop falls through with
+                // success still true - do not let a timed-out or aborted stream
+                // pass as a completed call (a stalled stream after a rejected
+                // permission would otherwise be reported as done).
+                if (success && streamAbortController.signal.aborted && (abortCause === 'timeout' || abortCause === 'external')) {
+                    success = false;
+                    failureMessage = abortCause === 'timeout' ? timeoutMessage : OPENCODE_STREAM_ABORTED_MESSAGE;
                 }
                 content = [...textContentParts.values()].join('\n');
                 if (!success && !streamAbortController.signal.aborted) {
@@ -754,11 +1013,53 @@ export class OpenCodeClient {
                 diag.onCompleted(success ? 'normal' : 'error', success ? undefined : failureMessage);
                 if (!success) {
                     const message = failureMessage || 'OpenCode execution failed';
+                    // 無音タイムアウトで止めた場合、死因はサーバが握った 429 かもしれない。
+                    // メッセージ文字列だけでは判別できないため、セッションを検死する。
+                    if (abortCause === 'timeout'
+                        && !containsRateLimitError(message)
+                        && opencodeApiClient !== undefined
+                        && activeSessionId !== undefined) {
+                        const rateLimitMessage = await postmortemRateLimitError(opencodeApiClient, activeSessionId, options.cwd);
+                        if (rateLimitMessage !== undefined) {
+                            // プロバイダ由来の生エラー文はリクエスト内容やアカウント情報を
+                            // 含みうるため、分類済みの事実だけを永続化する。
+                            log.warn('OpenCode stream stalled on a provider rate limit', {
+                                sessionId: activeSessionId,
+                                model: options.model,
+                            });
+                            // 検死で 429 と確定済み。message 文字列に 429 の語が含まれるとは
+                            // 限らない（statusCode だけで判定した場合）ため再判定はしない。
+                            const rateLimitedResponse = this.buildRateLimitedResponse(agentType, activeSessionId, rateLimitMessage);
+                            emitResult(options.onStream, false, rateLimitedResponse.error ?? rateLimitedResponse.content, activeSessionId);
+                            return rateLimitedResponse;
+                        }
+                    }
                     if (containsRateLimitError(message)) {
                         const rateLimitedResponse = this.buildRateLimitedResponse(agentType, activeSessionId, message);
                         emitResult(options.onStream, false, rateLimitedResponse.error ?? rateLimitedResponse.content, activeSessionId);
                         return rateLimitedResponse;
                     }
+                    const lowerMessage = message.toLowerCase();
+                    // Failures that point at the native json_schema request itself: a
+                    // model that never emits the StructuredOutput tool ("did not produce
+                    // structured output"), or a gateway/model that rejects the json_schema
+                    // response format outright (surfaced as an upstream request error).
+                    // These fall back to formatless structured output; generic transient
+                    // errors (transport/network) must not, or they would burn the one-shot
+                    // fallback budget before a real format failure arrives.
+                    const isNativeStructuredOutputFailure = lowerMessage.includes('did not produce structured output')
+                        || lowerMessage.includes('upstream request failed');
+                    if (options.outputSchema !== undefined
+                        && !disableNativeStructuredOutput
+                        && isNativeStructuredOutputFailure) {
+                        // Fall back to formatless structured output once — hand-written JSON
+                        // validated by the downstream correction retry — before giving up.
+                        disableNativeStructuredOutput = true;
+                        maxAttempts = Math.max(maxAttempts, attempt + 1);
+                        log.info('Native structured output failed; retrying without json_schema format', { agentType, attempt, message });
+                        await this.waitForRetryDelay(attempt, options.abortSignal);
+                        continue;
+                    }
                     const retriable = this.isRetriableError(message, streamAbortController.signal.aborted, abortCause);
                     if (retriable && attempt < OPENCODE_RETRY_MAX_ATTEMPTS) {
                         log.info('Retrying OpenCode call after transient failure', { agentType, attempt, message });
@@ -770,18 +1071,41 @@ export class OpenCodeClient {
                         persona: agentType,
                         status: 'error',
                         content: message,
+                        error: message,
                         timestamp: new Date(),
                         sessionId: activeSessionId,
                     };
                 }
                 const trimmed = content.trim();
                 emitResult(options.onStream, true, trimmed, activeSessionId);
+                // format 要求時に structured がイベントで捕捉できなかった場合は、
+                // 本文の末尾 JSON をフォールバックとして採取する（検証は下流で行う）。
+                if (capturedStructuredOutput === undefined && options.outputSchema !== undefined) {
+                    try {
+                        const parsed = parseLastJsonBlock(trimmed);
+                        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                            capturedStructuredOutput = parsed;
+                        }
+                        else {
+                            log.debug('Structured output fallback found non-object JSON', { agentType });
+                        }
+                    }
+                    catch (fallbackError) {
+                        // フォールバック採取の失敗は握りつぶすが、調査用に痕跡は残す
+                        // （下流の検証と是正リトライに委ねる）。
+                        log.debug('Structured output fallback extraction failed', {
+                            agentType,
+                            error: getErrorMessage(fallbackError),
+                        });
+                    }
+                }
                 return {
                     persona: agentType,
                     status: 'done',
                     content: trimmed,
                     timestamp: new Date(),
                     sessionId: activeSessionId,
+                    ...(capturedStructuredOutput !== undefined ? { structuredOutput: capturedStructuredOutput } : {}),
                 };
             }
             catch (error) {
@@ -814,6 +1138,7 @@ export class OpenCodeClient {
                     persona: agentType,
                     status: 'error',
                     content: errorMessage,
+                    error: errorMessage,
                     timestamp: new Date(),
                     sessionId,
                 };
@@ -834,6 +1159,23 @@ export class OpenCodeClient {
         }
         throw new Error('Unreachable: OpenCode retry loop exhausted without returning');
     }
+    async compactSession(options) {
+        const parsedModel = parseProviderModel(options.model, 'OpenCode model');
+        const fullModel = `${parsedModel.providerID}/${parsedModel.modelID}`;
+        const acquired = await acquireClient(fullModel, options.opencodeApiKey, options.childProcessEnv, options.abortSignal);
+        try {
+            await withTimeout((signal) => acquired.client.session.summarize({
+                sessionID: options.sessionId,
+                directory: options.cwd,
+                providerID: parsedModel.providerID,
+                modelID: parsedModel.modelID,
+                auto: false,
+            }, { signal }), OPENCODE_INTERACTION_TIMEOUT_MS, 'OpenCode session summarize timed out', options.abortSignal);
+        }
+        finally {
+            acquired.release();
+        }
+    }
     /** Call OpenCode with a custom agent configuration (system prompt + prompt) */
     async callCustom(agentName, prompt, systemPrompt, options) {
         return this.call(agentName, prompt, {
@@ -849,4 +1191,7 @@ export async function callOpenCode(agentType, prompt, options) {
 export async function callOpenCodeCustom(agentName, prompt, systemPrompt, options) {
     return defaultClient.callCustom(agentName, prompt, systemPrompt, options);
 }
+export async function compactOpenCodeSession(options) {
+    return defaultClient.compactSession(options);
+}
 //# sourceMappingURL=client.js.map