fix(chat): handle question and todo state

src/runtime/opencode.ts

@@ -32,6 +32,7 @@ type RuntimeModelOverride = {
 };
 
 export type PermissionReply = "once" | "always" | "reject";
+export type QuestionAnswers = string[][];
 
 type RuntimeMessage = {
   info: {
@@ -135,6 +136,13 @@ export class OpencodeRuntimeAdapter {
     const targetUserMessage = userMessages[options.userOrdinal - 1];
 
     if (!targetUserMessage) {
+      if (messages.length === 0 && options.userOrdinal === 1) {
+        logger.warn(
+          { sessionId, userOrdinal: options.userOrdinal },
+          "skipping opencode revert because runtime session has no messages",
+        );
+        return;
+      }
       throw new Error("target user message not found to revert");
     }
 
@@ -221,6 +229,96 @@ export class OpencodeRuntimeAdapter {
     throw new Error("opencode permission reply API is unavailable");
   }
 
+  async replyQuestion(options: {
+    requestId: string;
+    sessionId?: string;
+    answers: QuestionAnswers;
+  }) {
+    const client = await this.ensureClient();
+    if ("question" in client && client.question?.reply) {
+      try {
+        const response = await client.question.reply({
+          requestID: options.requestId,
+          answers: options.answers,
+        });
+        return response.data;
+      } catch (error) {
+        if (!options.sessionId) {
+          throw error;
+        }
+      }
+    }
+
+    const v2Question = (client as unknown as {
+      v2?: {
+        session?: {
+          question?: {
+            reply?: (parameters: {
+              sessionID: string;
+              requestID: string;
+              questionV2Reply: { answers: QuestionAnswers };
+            }) => Promise<{ data: unknown }>;
+          };
+        };
+      };
+    }).v2?.session?.question;
+
+    if (v2Question?.reply && options.sessionId) {
+      const response = await v2Question.reply({
+        sessionID: options.sessionId,
+        requestID: options.requestId,
+        questionV2Reply: {
+          answers: options.answers,
+        },
+      });
+      return response.data;
+    }
+
+    throw new Error("opencode question reply API is unavailable");
+  }
+
+  async rejectQuestion(options: {
+    requestId: string;
+    sessionId?: string;
+  }) {
+    const client = await this.ensureClient();
+    if ("question" in client && client.question?.reject) {
+      try {
+        const response = await client.question.reject({
+          requestID: options.requestId,
+        });
+        return response.data;
+      } catch (error) {
+        if (!options.sessionId) {
+          throw error;
+        }
+      }
+    }
+
+    const v2Question = (client as unknown as {
+      v2?: {
+        session?: {
+          question?: {
+            reject?: (parameters: {
+              sessionID: string;
+              requestID: string;
+            }) => Promise<{ data: unknown }>;
+          };
+        };
+      };
+    }).v2?.session?.question;
+
+    if (v2Question?.reject && options.sessionId) {
+      const response = await v2Question.reject({
+        sessionID: options.sessionId,
+        requestID: options.requestId,
+      });
+      return response.data;
+    }
+
+    throw new Error("opencode question reject API is unavailable");
+  }
+
   async dispose(): Promise<void> {
     this.closeServer?.();
     this.closeServer = null;