backeer-opencode 0.2.5 → 0.3.1

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to `backeer-opencode` are documented here.
 
+## 0.3.1 - 2026-09-01
+
+- Apply remote question replies on OpenCode 1.18.x even when the plugin-provided
+  client does not expose the legacy or v2 question helpers, by falling back to
+  OpenCode's underlying authenticated HTTP transport.
+- Normalize native API failures so Backeer receives an accurate terminal ACK
+  instead of reporting success for an error response.
+- Add regression coverage for legacy, v2, and error question reply paths.
+
+## 0.3.0 - 2026-09-01
+
+- Publish structured `question.asked` and `question.v2.asked` action metadata.
+- Apply single-choice, multi-choice, custom, skipped, and rejected question
+  responses from the Backeer iOS application through OpenCode's native APIs.
+- Share the source-authenticated SSE connection with permission commands and
+  use stable, idempotent question acknowledgements.
+- Renew five-minute question leases while OpenCode is waiting and resolve the
+  Backeer event when a question is answered locally.
+
 ## 0.2.5 - 2026-09-01
 
 - Group consecutive OpenCode conversation feedback into one ignored Backeer

package/README.md

@@ -3,9 +3,10 @@
 `backeer-opencode` connects OpenCode to Backeer. It sends mobile notifications
 for permission requests, questions, completed todo lists, completed assistant
 runs, session failures, prolonged retries, and OpenCode updates. While a
-permission is pending, it also consumes an authenticated Backeer command stream
-so an authorized user can answer **Allow once**, **Always allow**, or **Reject**
-from the Backeer iOS application.
+permission or question is pending, it also consumes an authenticated Backeer
+command stream. An authorized user can choose **Allow once**, **Always allow**,
+or **Reject** for permissions and can answer or reject AI questions from the
+Backeer iOS application.
 
 The plugin uses outbound HTTPS only. It does not start a server or require an
 inbound firewall rule.
@@ -108,7 +109,7 @@ environment variables are supported:
 | `BACKEER_TOKEN_FILE` | Absolute path to a protected token file |
 | `BACKEER_ORIGIN` | Gateway origin; HTTPS is required |
 | `BACKEER_NOTIFY_PERMISSIONS` | Set to `false` to disable permission notifications and remote replies |
-| `BACKEER_NOTIFY_QUESTIONS` | Set to `false` to disable question notifications |
+| `BACKEER_NOTIFY_QUESTIONS` | Set to `false` to disable question notifications and remote answers |
 | `BACKEER_NOTIFY_TODOS` | Set to `false` to disable todo-completion notifications |
 | `BACKEER_NOTIFY_LIFECYCLE` | Set to `false` to disable every lifecycle notification |
 | `BACKEER_NOTIFY_SESSION_COMPLETED` | Set to `false` to disable successful-run notifications |
@@ -232,8 +233,8 @@ The plugin publishes:
 | OpenCode event | Backeer behavior |
 |---|---|
 | `permission.asked` | Notification plus remote decision support |
-| `question.asked` | Notification-only question card |
-| `question.v2.asked` | Notification-only question card, including plan-mode questions |
+| `question.asked` | Interactive question card with remote answer/reject support |
+| `question.v2.asked` | Interactive question card with remote answer/reject support, including plan-mode questions |
 | `todo.updated` | One notification when a non-empty list transitions to fully completed |
 | `message.updated` + `session.status`/`session.idle` | One notification for each successfully completed assistant run |
 | `session.error` | Critical failure notification with a redacted error summary |

package/dist/backeer-permission.js

@@ -298,6 +298,7 @@ async function postJsonWithRetry(config, url, body, options = {}) {
 
 // src/event-publishers.js
 var ACTION_PROTOCOL = "opencode-permission/v1";
+var QUESTION_ACTION_PROTOCOL = "opencode-question/v1";
 function permissionIdentity(request) {
   const requestID = request.id ?? request.requestID;
   const sessionID = request.sessionID;
@@ -367,7 +368,7 @@ async function resolveSessionTitle(client, directory, sessionID, reporter) {
     return "";
   }
 }
-async function publishQuestion(config, reporter, request, identity, client, directory, conversation) {
+async function publishQuestion(config, reporter, request, identity, client, directory, conversation, sourceEvent) {
   const questions = Array.isArray(request.questions) ? request.questions : [];
   if (questions.length === 0) return;
   const sessionTitle = await resolveSessionTitle(
@@ -378,6 +379,9 @@ async function publishQuestion(config, reporter, request, identity, client, dire
   );
   const payload = [
     { key: "OpenCode session", value: sessionTitle },
+    { key: "Session", value: limit(identity.sessionID) },
+    { key: "Request ID", value: limit(identity.requestID) },
+    { key: "Action protocol", value: QUESTION_ACTION_PROTOCOL },
     ...questions.flatMap((question, index) => {
       const suffix = questions.length > 1 ? ` ${index + 1}` : "";
       return [
@@ -391,6 +395,16 @@ async function publishQuestion(config, reporter, request, identity, client, dire
     })
   ].filter((item) => item.value.length > 0);
   const firstQuestion = questions[0];
+  const actionQuestions = questions.map((question) => ({
+    header: limit(question?.header, 200),
+    question: limit(question?.question, 2e3),
+    options: Array.isArray(question?.options) ? question.options.slice(0, 20).map((option) => ({
+      label: limit(option?.label, 200),
+      description: limit(option?.description, 500)
+    })).filter((option) => option.label) : [],
+    multiple: question?.multiple === true,
+    custom: question?.custom !== false
+  }));
   const body = questions.map((question) => {
     const header = limit(question?.header, 200);
     const text = limit(question?.question, 500);
@@ -406,10 +420,21 @@ async function publishQuestion(config, reporter, request, identity, client, dire
     externalId: identity.externalId,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     notify: true,
-    direction: "in"
+    direction: "in",
+    action: {
+      protocol: QUESTION_ACTION_PROTOCOL,
+      sourceEvent,
+      questions: actionQuestions
+    }
   });
   reporter.success("Question sent", `HTTP ${result.status}`);
   conversation?.success(identity.sessionID, "Question sent");
+  try {
+    const response = JSON.parse(result.responseBody);
+    return typeof response?.id === "string" ? response.id : void 0;
+  } catch {
+    return void 0;
+  }
 }
 async function publishTodoCompletion(config, reporter, request, eventID, client, directory, conversation) {
   const todos = request.todos;
@@ -1538,6 +1563,64 @@ function reportAcknowledgement(acknowledgement, pending, reporter, conversation)
   conversation?.warning(pending.sessionID, message);
 }
 
+// src/question-command.js
+var QUESTION_ACTIONS = /* @__PURE__ */ new Set(["answer", "reject"]);
+function validateQuestionCommand(command, pending, now = Date.now()) {
+  const response = command?.response;
+  if (!response || !QUESTION_ACTIONS.has(response.action)) {
+    return { status: "rejected", action: response?.action, errorCode: "invalid_action" };
+  }
+  const expiresAt = Date.parse(command.expiresAt);
+  if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+    return { status: "expired", action: response.action };
+  }
+  if (response.action === "reject") return;
+  if (!Array.isArray(response.answers) || response.answers.length !== pending.questions.length) {
+    return { status: "rejected", action: response.action, errorCode: "invalid_answers" };
+  }
+  for (let index = 0; index < pending.questions.length; index++) {
+    const question = pending.questions[index];
+    const answers = response.answers[index];
+    if (!Array.isArray(answers) || !question.multiple && answers.length > 1) {
+      return { status: "rejected", action: response.action, errorCode: "invalid_answers" };
+    }
+    for (const answer of answers) {
+      if (typeof answer !== "string" || answer.trim().length === 0) {
+        return { status: "rejected", action: response.action, errorCode: "invalid_answers" };
+      }
+      const known = question.options.some((option) => option.label === answer);
+      if (!known && !question.custom) {
+        return { status: "rejected", action: response.action, errorCode: "custom_not_allowed" };
+      }
+    }
+  }
+}
+function questionFailureAcknowledgement(command, error) {
+  const stale = error instanceof HttpError && error.status === 404;
+  return {
+    status: stale ? "stale" : "failed",
+    action: command?.response?.action,
+    errorCode: stale ? "question_not_found" : "opencode_question_reply_failed"
+  };
+}
+function reportQuestionAcknowledgement(acknowledgement, pending, reporter, conversation) {
+  const messages = {
+    applied: acknowledgement.action === "reject" ? "Question rejected from Backeer" : "Question answered from Backeer",
+    expired: "Question response expired before it could be applied",
+    stale: "Question was already answered locally",
+    rejected: "Question response was rejected by validation"
+  };
+  const message = messages[acknowledgement.status];
+  if (!message) return;
+  if (acknowledgement.status === "applied") {
+    reporter.applied(message);
+    conversation?.applied(pending.sessionID, message);
+  } else {
+    reporter.warning(message);
+    conversation?.warning(pending.sessionID, message);
+  }
+}
+
 // src/sse.js
 function parseSseFrame(frame) {
   const data = [];
@@ -1724,6 +1807,72 @@ async function acknowledgeCommand(config, commandID, acknowledgement) {
   );
   await postJsonWithRetry(config, url, acknowledgement);
 }
+function questionResponseError(result) {
+  if (!result?.error) return;
+  const status = Number(result?.response?.status) || 502;
+  const detail = result.error?.data?.message ?? result.error?.message ?? "OpenCode rejected the question response";
+  return new HttpError(String(detail), status);
+}
+function normalizeQuestionError(error) {
+  if (error instanceof HttpError) return error;
+  const status = Number(error?.status ?? error?.statusCode ?? error?.cause?.status);
+  if (!Number.isFinite(status)) return error;
+  return new HttpError(error?.message || "OpenCode rejected the question response", status);
+}
+function rawQuestionRequest(client, pending, response, isV2) {
+  const transport = client?._client;
+  if (typeof transport?.post !== "function") {
+    throw new HttpError("This OpenCode version cannot apply remote question replies", 501);
+  }
+  const rejecting = response.action === "reject";
+  if (isV2) {
+    return transport.post({
+      url: `/api/session/{sessionID}/question/{requestID}/${rejecting ? "reject" : "reply"}`,
+      path: { sessionID: pending.sessionID, requestID: pending.requestID },
+      ...rejecting ? {} : { body: { answers: response.answers } },
+      ...rejecting ? {} : { headers: { "Content-Type": "application/json" } },
+      throwOnError: true
+    });
+  }
+  return transport.post({
+    url: `/question/{requestID}/${rejecting ? "reject" : "reply"}`,
+    path: { requestID: pending.requestID },
+    query: { directory: pending.directory },
+    ...rejecting ? {} : { body: { answers: response.answers } },
+    ...rejecting ? {} : { headers: { "Content-Type": "application/json" } },
+    throwOnError: true
+  });
+}
+async function replyToQuestion(client, pending, response) {
+  const isV2 = pending.sourceEvent === "question.v2.asked";
+  const api = isV2 ? client?.v2?.session?.question : client?.question;
+  const method = response.action === "reject" ? api?.reject : api?.reply;
+  const input = isV2 ? {
+    sessionID: pending.sessionID,
+    requestID: pending.requestID,
+    directory: pending.directory,
+    ...response.action === "answer" ? { questionV2Reply: { answers: response.answers } } : {}
+  } : {
+    requestID: pending.requestID,
+    directory: pending.directory,
+    ...response.action === "answer" ? { answers: response.answers } : {}
+  };
+  let result;
+  try {
+    result = typeof method === "function" ? await method.call(api, input, { throwOnError: true }) : await rawQuestionRequest(client, pending, response, isV2);
+  } catch (error) {
+    throw normalizeQuestionError(error);
+  }
+  const responseError = questionResponseError(result);
+  if (responseError) throw responseError;
+  if (result?.data === false || result === false) {
+    throw new HttpError("OpenCode did not apply the question response", 409);
+  }
+}
+async function postQuestionState(config, eventID, path, body = {}) {
+  const url = new URL(`/v1/events/${encodeURIComponent(eventID)}/${path}`, config.origin);
+  await postJsonWithRetry(config, url, body, { retryDelays: [0, 500] });
+}
 function createPermissionController({
   config,
   reporter,
@@ -1733,9 +1882,13 @@ function createPermissionController({
 }) {
   const pendingByExternalID = /* @__PURE__ */ new Map();
   const externalIDByRequestID = /* @__PURE__ */ new Map();
+  const questionsByExternalID = /* @__PURE__ */ new Map();
+  const questionExternalIDByRequestID = /* @__PURE__ */ new Map();
+  const remotelyResolvingQuestions = /* @__PURE__ */ new Set();
   const processingCommands = /* @__PURE__ */ new Set();
   const completedCommands = /* @__PURE__ */ new Map();
   let commandStream;
+  let leaseTimer;
   let disposed = false;
   function removePendingByRequestID(requestID) {
     const externalId = externalIDByRequestID.get(requestID);
@@ -1744,11 +1897,36 @@ function createPermissionController({
     pendingByExternalID.delete(externalId);
   }
   function stopCommandStreamIfIdle() {
-    if (pendingByExternalID.size === 0) commandStream?.controller.abort();
+    if (pendingByExternalID.size === 0 && questionsByExternalID.size === 0) {
+      commandStream?.controller.abort();
+    }
+  }
+  function removeQuestionByRequestID(requestID) {
+    const externalId = questionExternalIDByRequestID.get(requestID);
+    if (!externalId) return;
+    questionExternalIDByRequestID.delete(requestID);
+    questionsByExternalID.delete(externalId);
+    if (questionsByExternalID.size === 0 && leaseTimer) {
+      clearInterval(leaseTimer);
+      leaseTimer = void 0;
+    }
+  }
+  async function renewQuestionLeases() {
+    for (const pending of questionsByExternalID.values()) {
+      if (!pending.eventID) continue;
+      await postQuestionState(config, pending.eventID, "lease").catch((error) => {
+        reporter.warning("Question lease could not be renewed", error);
+      });
+    }
+  }
+  function ensureLeaseTimer() {
+    if (leaseTimer || questionsByExternalID.size === 0) return;
+    leaseTimer = setInterval(() => void renewQuestionLeases(), 6e4);
+    leaseTimer.unref?.();
   }
   async function handleCommand(command) {
     if (!command || typeof command !== "object") return;
-    if (command.type !== "opencode_permission_reply") return;
+    if (!["opencode_permission_reply", "opencode_question_reply"].includes(command.type)) return;
     if (typeof command.id !== "string" || command.id.length > 200) return;
     const previousAcknowledgement = completedCommands.get(command.id);
     if (previousAcknowledgement) {
@@ -1757,54 +1935,75 @@ function createPermissionController({
     }
     if (processingCommands.has(command.id)) return;
     if (typeof command.externalId !== "string") return;
-    const pending = pendingByExternalID.get(command.externalId);
+    const isQuestion = command.type === "opencode_question_reply";
+    const pending = isQuestion ? questionsByExternalID.get(command.externalId) : pendingByExternalID.get(command.externalId);
     if (!pending) return;
     processingCommands.add(command.id);
-    let acknowledgement = validatePermissionCommand(command);
+    let acknowledgement = isQuestion ? validateQuestionCommand(command, pending) : validatePermissionCommand(command);
     try {
       if (!acknowledgement) {
-        await replyToOpenCode(client, pending, command.decision);
-        acknowledgement = { status: "applied", decision: command.decision };
-        removePendingByRequestID(pending.requestID);
+        if (isQuestion) {
+          remotelyResolvingQuestions.add(pending.requestID);
+          await replyToQuestion(client, pending, command.response);
+          acknowledgement = { status: "applied", action: command.response.action };
+          removeQuestionByRequestID(pending.requestID);
+          const cleanup = setTimeout(
+            () => remotelyResolvingQuestions.delete(pending.requestID),
+            3e4
+          );
+          cleanup.unref?.();
+        } else {
+          await replyToOpenCode(client, pending, command.decision);
+          acknowledgement = { status: "applied", decision: command.decision };
+          removePendingByRequestID(pending.requestID);
+        }
       }
     } catch (error) {
-      acknowledgement = failureAcknowledgement(command, error);
+      if (isQuestion) remotelyResolvingQuestions.delete(pending.requestID);
+      acknowledgement = isQuestion ? questionFailureAcknowledgement(command, error) : failureAcknowledgement(command, error);
       if (acknowledgement.status === "stale") {
-        removePendingByRequestID(pending.requestID);
+        if (isQuestion) removeQuestionByRequestID(pending.requestID);
+        else removePendingByRequestID(pending.requestID);
       }
-      reporter.error("Decision could not be applied", error);
-      conversation?.error(pending.sessionID, "Decision could not be applied");
+      const message = isQuestion ? "Question response could not be applied" : "Decision could not be applied";
+      reporter.error(message, error);
+      conversation?.error(pending.sessionID, message);
     } finally {
       processingCommands.delete(command.id);
     }
     acknowledgement = {
       ...acknowledgement,
-      type: "opencode_permission_reply_ack",
+      type: isQuestion ? "opencode_question_reply_ack" : "opencode_permission_reply_ack",
       externalId: command.externalId,
       processedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     rememberBounded(completedCommands, command.id, acknowledgement);
-    reportAcknowledgement(acknowledgement, pending, reporter, conversation);
+    if (isQuestion) {
+      reportQuestionAcknowledgement(acknowledgement, pending, reporter, conversation);
+    } else {
+      reportAcknowledgement(acknowledgement, pending, reporter, conversation);
+    }
     await acknowledgeCommand(config, command.id, acknowledgement).catch((error) => {
       reporter.warning("Decision receipt could not be sent", error);
     });
     stopCommandStreamIfIdle();
   }
   function ensureCommandStream() {
-    if (disposed || commandStream || pendingByExternalID.size === 0) return;
+    const hasPending = () => pendingByExternalID.size > 0 || questionsByExternalID.size > 0;
+    if (disposed || commandStream || !hasPending()) return;
     const controller = new AbortController();
     const current = {
       controller,
       task: runCommandStream(config, reporter, {
         signal: controller.signal,
-        hasPending: () => pendingByExternalID.size > 0,
+        hasPending,
         onCommand: handleCommand
       })
     };
     commandStream = current;
     void current.task.finally(() => {
       if (commandStream === current) commandStream = void 0;
-      if (!disposed && pendingByExternalID.size > 0) ensureCommandStream();
+      if (!disposed && hasPending()) ensureCommandStream();
     });
   }
   return {
@@ -1817,6 +2016,31 @@ function createPermissionController({
       removePendingByRequestID(requestID);
       stopCommandStreamIfIdle();
     },
+    registerQuestion(identity, details) {
+      questionsByExternalID.set(identity.externalId, {
+        ...identity,
+        ...details,
+        directory
+      });
+      questionExternalIDByRequestID.set(identity.requestID, identity.externalId);
+      ensureLeaseTimer();
+      ensureCommandStream();
+    },
+    resolveQuestionLocally(requestID, outcome) {
+      if (remotelyResolvingQuestions.delete(requestID)) {
+        removeQuestionByRequestID(requestID);
+        stopCommandStreamIfIdle();
+        return;
+      }
+      const externalId = questionExternalIDByRequestID.get(requestID);
+      const pending = externalId ? questionsByExternalID.get(externalId) : void 0;
+      if (!pending) return;
+      removeQuestionByRequestID(requestID);
+      if (pending.eventID) {
+        void postQuestionState(config, pending.eventID, "source-resolution", { outcome }).catch((error) => reporter.warning("Local question state could not be sent", error));
+      }
+      stopCommandStreamIfIdle();
+    },
     refreshCredentials() {
       commandStream?.controller.abort();
       if (!commandStream) ensureCommandStream();
@@ -1824,18 +2048,23 @@ function createPermissionController({
     status() {
       return {
         pending: pendingByExternalID.size,
+        pendingQuestions: questionsByExternalID.size,
         stream: commandStream ? "active" : "idle"
       };
     },
     async dispose() {
       disposed = true;
       commandStream?.controller.abort();
+      if (leaseTimer) clearInterval(leaseTimer);
       await commandStream?.task.catch(() => {
       });
       pendingByExternalID.clear();
       externalIDByRequestID.clear();
       processingCommands.clear();
       completedCommands.clear();
+      questionsByExternalID.clear();
+      questionExternalIDByRequestID.clear();
+      remotelyResolvingQuestions.clear();
     }
   };
 }
@@ -1945,8 +2174,18 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       identity,
       client,
       directory,
-      conversation
-    ).then(() => questionPublications.succeed(identity.externalId)).catch((error) => {
+      conversation,
+      event.type
+    ).then((eventID) => {
+      questionPublications.succeed(identity.externalId);
+      if (eventID) {
+        permissionController.registerQuestion(identity, {
+          eventID,
+          sourceEvent: event.type,
+          questions: event.properties.questions
+        });
+      }
+    }).catch((error) => {
       questionPublications.fail(identity.externalId);
       reporter.error("Question could not be sent", error);
       conversation.error(identity.sessionID, "Question could not be sent");
@@ -1978,6 +2217,16 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       }
       if (config.questions && (event.type === "question.asked" || event.type === "question.v2.asked")) {
         await handleQuestionAsked(event);
+        return;
+      }
+      if (config.questions && ["question.replied", "question.v2.replied", "question.rejected", "question.v2.rejected"].includes(event.type)) {
+        const requestID = event.properties.requestID ?? event.properties.id;
+        if (typeof requestID === "string") {
+          permissionController.resolveQuestionLocally(
+            requestID,
+            event.type.endsWith("rejected") ? "rejected" : "answered"
+          );
+        }
       }
     },
     dispose: async () => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "backeer-opencode",
-  "version": "0.2.5",
-  "description": "Backeer lifecycle notifications and remote permission decisions for OpenCode",
+  "version": "0.3.1",
+  "description": "Backeer lifecycle notifications and remote permission and question replies for OpenCode",
   "type": "module",
   "main": "./src/index.js",
   "exports": {

package/src/event-publishers.js

@@ -2,6 +2,7 @@ import { postJsonWithRetry } from "./http.js"
 import { limit, stableHash } from "./utilities.js"
 
 const ACTION_PROTOCOL = "opencode-permission/v1"
+const QUESTION_ACTION_PROTOCOL = "opencode-question/v1"
 
 export function permissionIdentity(request) {
   const requestID = request.id ?? request.requestID
@@ -107,6 +108,7 @@ export async function publishQuestion(
   client,
   directory,
   conversation,
+  sourceEvent,
 ) {
   const questions = Array.isArray(request.questions) ? request.questions : []
   if (questions.length === 0) return
@@ -119,6 +121,9 @@ export async function publishQuestion(
   )
   const payload = [
     { key: "OpenCode session", value: sessionTitle },
+    { key: "Session", value: limit(identity.sessionID) },
+    { key: "Request ID", value: limit(identity.requestID) },
+    { key: "Action protocol", value: QUESTION_ACTION_PROTOCOL },
     ...questions.flatMap((question, index) => {
       const suffix = questions.length > 1 ? ` ${index + 1}` : ""
       return [
@@ -133,6 +138,18 @@ export async function publishQuestion(
   ].filter((item) => item.value.length > 0)
 
   const firstQuestion = questions[0]
+  const actionQuestions = questions.map((question) => ({
+    header: limit(question?.header, 200),
+    question: limit(question?.question, 2000),
+    options: Array.isArray(question?.options)
+      ? question.options.slice(0, 20).map((option) => ({
+          label: limit(option?.label, 200),
+          description: limit(option?.description, 500),
+        })).filter((option) => option.label)
+      : [],
+    multiple: question?.multiple === true,
+    custom: question?.custom !== false,
+  }))
   const body = questions
     .map((question) => {
       const header = limit(question?.header, 200)
@@ -154,9 +171,20 @@ export async function publishQuestion(
     timestamp: new Date().toISOString(),
     notify: true,
     direction: "in",
+    action: {
+      protocol: QUESTION_ACTION_PROTOCOL,
+      sourceEvent,
+      questions: actionQuestions,
+    },
   })
   reporter.success("Question sent", `HTTP ${result.status}`)
   conversation?.success(identity.sessionID, "Question sent")
+  try {
+    const response = JSON.parse(result.responseBody)
+    return typeof response?.id === "string" ? response.id : undefined
+  } catch {
+    return undefined
+  }
 }
 
 export async function publishTodoCompletion(

package/src/permission-controller.js

@@ -4,6 +4,11 @@ import {
   reportAcknowledgement,
   validatePermissionCommand,
 } from "./permission-command.js"
+import {
+  questionFailureAcknowledgement,
+  reportQuestionAcknowledgement,
+  validateQuestionCommand,
+} from "./question-command.js"
 import { runCommandStream } from "./sse.js"
 import { rememberBounded } from "./utilities.js"
 
@@ -28,6 +33,86 @@ async function acknowledgeCommand(config, commandID, acknowledgement) {
   await postJsonWithRetry(config, url, acknowledgement)
 }
 
+function questionResponseError(result) {
+  if (!result?.error) return
+  const status = Number(result?.response?.status) || 502
+  const detail = result.error?.data?.message
+    ?? result.error?.message
+    ?? "OpenCode rejected the question response"
+  return new HttpError(String(detail), status)
+}
+
+function normalizeQuestionError(error) {
+  if (error instanceof HttpError) return error
+  const status = Number(error?.status ?? error?.statusCode ?? error?.cause?.status)
+  if (!Number.isFinite(status)) return error
+  return new HttpError(error?.message || "OpenCode rejected the question response", status)
+}
+
+function rawQuestionRequest(client, pending, response, isV2) {
+  const transport = client?._client
+  if (typeof transport?.post !== "function") {
+    throw new HttpError("This OpenCode version cannot apply remote question replies", 501)
+  }
+
+  const rejecting = response.action === "reject"
+  if (isV2) {
+    return transport.post({
+      url: `/api/session/{sessionID}/question/{requestID}/${rejecting ? "reject" : "reply"}`,
+      path: { sessionID: pending.sessionID, requestID: pending.requestID },
+      ...(rejecting ? {} : { body: { answers: response.answers } }),
+      ...(rejecting ? {} : { headers: { "Content-Type": "application/json" } }),
+      throwOnError: true,
+    })
+  }
+  return transport.post({
+    url: `/question/{requestID}/${rejecting ? "reject" : "reply"}`,
+    path: { requestID: pending.requestID },
+    query: { directory: pending.directory },
+    ...(rejecting ? {} : { body: { answers: response.answers } }),
+    ...(rejecting ? {} : { headers: { "Content-Type": "application/json" } }),
+    throwOnError: true,
+  })
+}
+
+export async function replyToQuestion(client, pending, response) {
+  const isV2 = pending.sourceEvent === "question.v2.asked"
+  const api = isV2 ? client?.v2?.session?.question : client?.question
+  const method = response.action === "reject" ? api?.reject : api?.reply
+  const input = isV2
+    ? {
+        sessionID: pending.sessionID,
+        requestID: pending.requestID,
+        directory: pending.directory,
+        ...(response.action === "answer"
+          ? { questionV2Reply: { answers: response.answers } }
+          : {}),
+      }
+    : {
+        requestID: pending.requestID,
+        directory: pending.directory,
+        ...(response.action === "answer" ? { answers: response.answers } : {}),
+      }
+  let result
+  try {
+    result = typeof method === "function"
+      ? await method.call(api, input, { throwOnError: true })
+      : await rawQuestionRequest(client, pending, response, isV2)
+  } catch (error) {
+    throw normalizeQuestionError(error)
+  }
+  const responseError = questionResponseError(result)
+  if (responseError) throw responseError
+  if (result?.data === false || result === false) {
+    throw new HttpError("OpenCode did not apply the question response", 409)
+  }
+}
+
+async function postQuestionState(config, eventID, path, body = {}) {
+  const url = new URL(`/v1/events/${encodeURIComponent(eventID)}/${path}`, config.origin)
+  await postJsonWithRetry(config, url, body, { retryDelays: [0, 500] })
+}
+
 export function createPermissionController({
   config,
   reporter,
@@ -37,9 +122,13 @@ export function createPermissionController({
 }) {
   const pendingByExternalID = new Map()
   const externalIDByRequestID = new Map()
+  const questionsByExternalID = new Map()
+  const questionExternalIDByRequestID = new Map()
+  const remotelyResolvingQuestions = new Set()
   const processingCommands = new Set()
   const completedCommands = new Map()
   let commandStream
+  let leaseTimer
   let disposed = false
 
   function removePendingByRequestID(requestID) {
@@ -50,12 +139,40 @@ export function createPermissionController({
   }
 
   function stopCommandStreamIfIdle() {
-    if (pendingByExternalID.size === 0) commandStream?.controller.abort()
+    if (pendingByExternalID.size === 0 && questionsByExternalID.size === 0) {
+      commandStream?.controller.abort()
+    }
+  }
+
+  function removeQuestionByRequestID(requestID) {
+    const externalId = questionExternalIDByRequestID.get(requestID)
+    if (!externalId) return
+    questionExternalIDByRequestID.delete(requestID)
+    questionsByExternalID.delete(externalId)
+    if (questionsByExternalID.size === 0 && leaseTimer) {
+      clearInterval(leaseTimer)
+      leaseTimer = undefined
+    }
+  }
+
+  async function renewQuestionLeases() {
+    for (const pending of questionsByExternalID.values()) {
+      if (!pending.eventID) continue
+      await postQuestionState(config, pending.eventID, "lease").catch((error) => {
+        reporter.warning("Question lease could not be renewed", error)
+      })
+    }
+  }
+
+  function ensureLeaseTimer() {
+    if (leaseTimer || questionsByExternalID.size === 0) return
+    leaseTimer = setInterval(() => void renewQuestionLeases(), 60_000)
+    leaseTimer.unref?.()
   }
 
   async function handleCommand(command) {
     if (!command || typeof command !== "object") return
-    if (command.type !== "opencode_permission_reply") return
+    if (!["opencode_permission_reply", "opencode_question_reply"].includes(command.type)) return
     if (typeof command.id !== "string" || command.id.length > 200) return
 
     const previousAcknowledgement = completedCommands.get(command.id)
@@ -67,37 +184,67 @@ export function createPermissionController({
     if (processingCommands.has(command.id)) return
     if (typeof command.externalId !== "string") return
 
-    const pending = pendingByExternalID.get(command.externalId)
+    const isQuestion = command.type === "opencode_question_reply"
+    const pending = isQuestion
+      ? questionsByExternalID.get(command.externalId)
+      : pendingByExternalID.get(command.externalId)
     if (!pending) return
 
     processingCommands.add(command.id)
-    let acknowledgement = validatePermissionCommand(command)
+    let acknowledgement = isQuestion
+      ? validateQuestionCommand(command, pending)
+      : validatePermissionCommand(command)
     try {
       if (!acknowledgement) {
-        await replyToOpenCode(client, pending, command.decision)
-        acknowledgement = { status: "applied", decision: command.decision }
-        removePendingByRequestID(pending.requestID)
+        if (isQuestion) {
+          remotelyResolvingQuestions.add(pending.requestID)
+          await replyToQuestion(client, pending, command.response)
+          acknowledgement = { status: "applied", action: command.response.action }
+          removeQuestionByRequestID(pending.requestID)
+          const cleanup = setTimeout(
+            () => remotelyResolvingQuestions.delete(pending.requestID),
+            30_000,
+          )
+          cleanup.unref?.()
+        } else {
+          await replyToOpenCode(client, pending, command.decision)
+          acknowledgement = { status: "applied", decision: command.decision }
+          removePendingByRequestID(pending.requestID)
+        }
       }
     } catch (error) {
-      acknowledgement = failureAcknowledgement(command, error)
+      if (isQuestion) remotelyResolvingQuestions.delete(pending.requestID)
+      acknowledgement = isQuestion
+        ? questionFailureAcknowledgement(command, error)
+        : failureAcknowledgement(command, error)
       if (acknowledgement.status === "stale") {
-        removePendingByRequestID(pending.requestID)
+        if (isQuestion) removeQuestionByRequestID(pending.requestID)
+        else removePendingByRequestID(pending.requestID)
       }
-      reporter.error("Decision could not be applied", error)
-      conversation?.error(pending.sessionID, "Decision could not be applied")
+      const message = isQuestion
+        ? "Question response could not be applied"
+        : "Decision could not be applied"
+      reporter.error(message, error)
+      conversation?.error(pending.sessionID, message)
     } finally {
       processingCommands.delete(command.id)
     }
 
     acknowledgement = {
       ...acknowledgement,
-      type: "opencode_permission_reply_ack",
+      type: isQuestion
+        ? "opencode_question_reply_ack"
+        : "opencode_permission_reply_ack",
       externalId: command.externalId,
       processedAt: new Date().toISOString(),
     }
     rememberBounded(completedCommands, command.id, acknowledgement)
 
-    reportAcknowledgement(acknowledgement, pending, reporter, conversation)
+    if (isQuestion) {
+      reportQuestionAcknowledgement(acknowledgement, pending, reporter, conversation)
+    } else {
+      reportAcknowledgement(acknowledgement, pending, reporter, conversation)
+    }
 
     await acknowledgeCommand(config, command.id, acknowledgement).catch((error) => {
       reporter.warning("Decision receipt could not be sent", error)
@@ -106,21 +253,22 @@ export function createPermissionController({
   }
 
   function ensureCommandStream() {
-    if (disposed || commandStream || pendingByExternalID.size === 0) return
+    const hasPending = () => pendingByExternalID.size > 0 || questionsByExternalID.size > 0
+    if (disposed || commandStream || !hasPending()) return
 
     const controller = new AbortController()
     const current = {
       controller,
       task: runCommandStream(config, reporter, {
         signal: controller.signal,
-        hasPending: () => pendingByExternalID.size > 0,
+        hasPending,
         onCommand: handleCommand,
       }),
     }
     commandStream = current
     void current.task.finally(() => {
       if (commandStream === current) commandStream = undefined
-      if (!disposed && pendingByExternalID.size > 0) ensureCommandStream()
+      if (!disposed && hasPending()) ensureCommandStream()
     })
   }
 
@@ -136,6 +284,34 @@ export function createPermissionController({
       stopCommandStreamIfIdle()
     },
 
+    registerQuestion(identity, details) {
+      questionsByExternalID.set(identity.externalId, {
+        ...identity,
+        ...details,
+        directory,
+      })
+      questionExternalIDByRequestID.set(identity.requestID, identity.externalId)
+      ensureLeaseTimer()
+      ensureCommandStream()
+    },
+
+    resolveQuestionLocally(requestID, outcome) {
+      if (remotelyResolvingQuestions.delete(requestID)) {
+        removeQuestionByRequestID(requestID)
+        stopCommandStreamIfIdle()
+        return
+      }
+      const externalId = questionExternalIDByRequestID.get(requestID)
+      const pending = externalId ? questionsByExternalID.get(externalId) : undefined
+      if (!pending) return
+      removeQuestionByRequestID(requestID)
+      if (pending.eventID) {
+        void postQuestionState(config, pending.eventID, "source-resolution", { outcome })
+          .catch((error) => reporter.warning("Local question state could not be sent", error))
+      }
+      stopCommandStreamIfIdle()
+    },
+
     refreshCredentials() {
       commandStream?.controller.abort()
       if (!commandStream) ensureCommandStream()
@@ -144,6 +320,7 @@ export function createPermissionController({
     status() {
       return {
         pending: pendingByExternalID.size,
+        pendingQuestions: questionsByExternalID.size,
         stream: commandStream ? "active" : "idle",
       }
     },
@@ -151,11 +328,15 @@ export function createPermissionController({
     async dispose() {
       disposed = true
       commandStream?.controller.abort()
+      if (leaseTimer) clearInterval(leaseTimer)
       await commandStream?.task.catch(() => {})
       pendingByExternalID.clear()
       externalIDByRequestID.clear()
       processingCommands.clear()
       completedCommands.clear()
+      questionsByExternalID.clear()
+      questionExternalIDByRequestID.clear()
+      remotelyResolvingQuestions.clear()
     },
   }
 }

package/src/plugin.js

@@ -149,7 +149,17 @@ export default async function BackeerPlugin({ client, directory }, options = {})
       client,
       directory,
       conversation,
-    ).then(() => questionPublications.succeed(identity.externalId))
+      event.type,
+    ).then((eventID) => {
+      questionPublications.succeed(identity.externalId)
+      if (eventID) {
+        permissionController.registerQuestion(identity, {
+          eventID,
+          sourceEvent: event.type,
+          questions: event.properties.questions,
+        })
+      }
+    })
       .catch((error) => {
         questionPublications.fail(identity.externalId)
         reporter.error("Question could not be sent", error)
@@ -194,6 +204,21 @@ export default async function BackeerPlugin({ client, directory }, options = {})
         (event.type === "question.asked" || event.type === "question.v2.asked")
       ) {
         await handleQuestionAsked(event)
+        return
+      }
+
+      if (
+        config.questions &&
+        ["question.replied", "question.v2.replied", "question.rejected", "question.v2.rejected"]
+          .includes(event.type)
+      ) {
+        const requestID = event.properties.requestID ?? event.properties.id
+        if (typeof requestID === "string") {
+          permissionController.resolveQuestionLocally(
+            requestID,
+            event.type.endsWith("rejected") ? "rejected" : "answered",
+          )
+        }
       }
     },
 

package/src/question-command.js

@@ -0,0 +1,65 @@
+import { HttpError } from "./http.js"
+
+export const QUESTION_ACTIONS = new Set(["answer", "reject"])
+
+export function validateQuestionCommand(command, pending, now = Date.now()) {
+  const response = command?.response
+  if (!response || !QUESTION_ACTIONS.has(response.action)) {
+    return { status: "rejected", action: response?.action, errorCode: "invalid_action" }
+  }
+
+  const expiresAt = Date.parse(command.expiresAt)
+  if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+    return { status: "expired", action: response.action }
+  }
+  if (response.action === "reject") return
+
+  if (!Array.isArray(response.answers) || response.answers.length !== pending.questions.length) {
+    return { status: "rejected", action: response.action, errorCode: "invalid_answers" }
+  }
+  for (let index = 0; index < pending.questions.length; index++) {
+    const question = pending.questions[index]
+    const answers = response.answers[index]
+    if (!Array.isArray(answers) || (!question.multiple && answers.length > 1)) {
+      return { status: "rejected", action: response.action, errorCode: "invalid_answers" }
+    }
+    for (const answer of answers) {
+      if (typeof answer !== "string" || answer.trim().length === 0) {
+        return { status: "rejected", action: response.action, errorCode: "invalid_answers" }
+      }
+      const known = question.options.some((option) => option.label === answer)
+      if (!known && !question.custom) {
+        return { status: "rejected", action: response.action, errorCode: "custom_not_allowed" }
+      }
+    }
+  }
+}
+
+export function questionFailureAcknowledgement(command, error) {
+  const stale = error instanceof HttpError && error.status === 404
+  return {
+    status: stale ? "stale" : "failed",
+    action: command?.response?.action,
+    errorCode: stale ? "question_not_found" : "opencode_question_reply_failed",
+  }
+}
+
+export function reportQuestionAcknowledgement(acknowledgement, pending, reporter, conversation) {
+  const messages = {
+    applied: acknowledgement.action === "reject"
+      ? "Question rejected from Backeer"
+      : "Question answered from Backeer",
+    expired: "Question response expired before it could be applied",
+    stale: "Question was already answered locally",
+    rejected: "Question response was rejected by validation",
+  }
+  const message = messages[acknowledgement.status]
+  if (!message) return
+  if (acknowledgement.status === "applied") {
+    reporter.applied(message)
+    conversation?.applied(pending.sessionID, message)
+  } else {
+    reporter.warning(message)
+    conversation?.warning(pending.sessionID, message)
+  }
+}