backeer-opencode 0.2.1 → 0.2.3

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to `backeer-opencode` are documented here.
 
+## 0.2.3 - 2026-09-01
+
+- Keep conversation feedback queued while OpenCode permission or question UI is
+  active, even if OpenCode emits an intermediate `session.idle` event.
+- Wait for the interaction reply and the following real idle transition before
+  injecting an ignored Backeer status message into the conversation.
+- Add regression coverage for permission and question UI lifecycles.
+
+## 0.2.2 - 2026-09-01
+
+- Show user-facing Backeer delivery and decision results in the OpenCode
+  conversation instead of writing them into the TUI input area.
+- Queue conversation feedback until the session is idle and mark it as ignored
+  so it cannot trigger another agent response or enter model context.
+- Send technical diagnostics through OpenCode's structured application log API
+  instead of stdout.
+
 ## 0.2.1 - 2026-09-01
 
 - Add `/backeer doctor` for read-only local configuration, protected token,

package/README.md

@@ -150,25 +150,29 @@ Supported options are `origin`, `tokenFile`, `permissions`, `questions`,
 `todos`, `lifecycle`, and `logLevel`. Use `"lifecycle": false` to disable the
 entire lifecycle group. The token itself is deliberately not a plugin option.
 
-## Console feedback
+## Conversation feedback
 
-The plugin writes compact, single-line status messages instead of raw HTTP logs:
+User-facing status messages appear as compact Backeer entries in the OpenCode
+conversation:
 
 ```text
-◆ Backeer  Permission request sent
-◆ Backeer  Question sent
-◆ Backeer  Todo completion sent
-◆ Backeer  Task completion sent
-◆ Backeer  Retry warning sent
-◆ Backeer  Task failure sent
-✓ Backeer  Decision applied: Always allow
-! Backeer  Connection interrupted — retrying
+Backeer ✓ Permission request sent
+Backeer ✓ Question sent
+Backeer ✓ Todo completion sent
+Backeer ✓ Task completion sent
+Backeer ✓ Decision applied: Always allow
 ```
 
-TTY output uses restrained status colors and respects `NO_COLOR`. Repeated
-connection errors are suppressed for 30 seconds. Normal `info` output omits HTTP
-status codes and internal errors; set `BACKEER_LOG_LEVEL=debug` when technical
-details are needed. Set it to `error` for failures only or `silent` for no output.
+These entries are marked `noReply` and `ignored`, so they are visible without
+starting another agent turn or entering model context. Feedback generated while
+an agent is active, a permission prompt is open, or a question is awaiting an
+answer remains queued until the interaction closes and the session becomes idle.
+It never writes to the user's input field or replaces interactive OpenCode UI.
+
+Technical diagnostics use OpenCode's structured application log API instead of
+stdout. Normal `info` logging omits HTTP details; set
+`BACKEER_LOG_LEVEL=debug` when technical details are needed. Set it to `error`
+for failures only or `silent` to disable structured logs.
 
 ## OpenCode command
 
@@ -263,10 +267,11 @@ npm run publish:check
 
 ## Development architecture
 
-The npm plugin runs from the modular source in `src`. Configuration, console
-reporting, HTTP transport, SSE consumption, event publishing, permission command
-handling, and OpenCode event routing are kept in separate modules. The package
-root continues to expose only the default OpenCode plugin entrypoint.
+The npm plugin runs from the modular source in `src`. Configuration, structured
+logging, conversation feedback, HTTP transport, SSE consumption, event
+publishing, permission command handling, and OpenCode event routing are kept in
+separate modules. The package root continues to expose only the default OpenCode
+plugin entrypoint.
 
 The legacy side-loaded installer still deploys one dependency-free file. Build
 that generated artifact before running the installer directly from a source

package/dist/backeer-permission.js

@@ -33,37 +33,31 @@ function normalizeLogLevel(value) {
   const level = String(value ?? "info").trim().toLowerCase();
   return LOG_LEVELS.has(level) ? level : "info";
 }
-function createConsoleReporter(levelValue) {
+function createOpenCodeReporter(client, levelValue) {
   const level = normalizeLogLevel(levelValue);
-  const useColor = Boolean(process.stdout?.isTTY) && !("NO_COLOR" in process.env) && process.env.TERM !== "dumb";
   const recentlyEmitted = /* @__PURE__ */ new Map();
-  const decorate = (code, text) => useColor ? `\x1B[${code}m${text}\x1B[0m` : text;
-  const symbols = {
-    info: decorate("36", "\u25C6"),
-    success: decorate("32", "\u25C6"),
-    applied: decorate("32", "\u2713"),
-    warning: decorate("33", "!"),
-    error: decorate("31", "\xD7"),
-    debug: decorate("2", "\xB7")
-  };
-  const brand = decorate("1", "Backeer");
+  const method = client?.app?.log;
   function emit(requiredLevel, kind, message, detail, deduplicate = false) {
-    if (LOG_RANK[level] < LOG_RANK[requiredLevel]) return;
+    if (LOG_RANK[level] < LOG_RANK[requiredLevel] || typeof method !== "function") return;
     const key = `${kind}:${message}`;
     const now = Date.now();
     if (deduplicate) {
       const previous = recentlyEmitted.get(key);
       if (previous && now - previous < LOG_DEDUPLICATION_MS) return;
-      recentlyEmitted.delete(key);
-      recentlyEmitted.set(key, now);
-      while (recentlyEmitted.size > 100) {
-        recentlyEmitted.delete(recentlyEmitted.keys().next().value);
-      }
+      rememberRecent(recentlyEmitted, key, now);
+    }
+    const body = {
+      service: "backeer-opencode",
+      level: kind === "warning" ? "warn" : kind === "applied" || kind === "success" ? "info" : kind,
+      message: limit(message, 500)
+    };
+    if (level === "debug" && detail) {
+      body.extra = { detail: limit(detail?.message ?? detail, 500) };
     }
-    const technical = level === "debug" && detail ? decorate("2", ` \xB7 ${limit(detail, 500)}`) : "";
-    const line = `${symbols[kind]} ${brand}  ${message}${technical}`;
-    if (kind === "error" || kind === "warning") console.error(line);
-    else console.log(line);
+    setTimeout(() => {
+      void Promise.resolve(method.call(client.app, { body })).catch(() => {
+      });
+    }, 0);
   }
   return {
     info: (message, detail) => emit("info", "info", message, detail),
@@ -74,6 +68,11 @@ function createConsoleReporter(levelValue) {
     debug: (message, detail) => emit("debug", "debug", message, detail)
   };
 }
+function rememberRecent(map, key, value) {
+  map.delete(key);
+  map.set(key, value);
+  while (map.size > 100) map.delete(map.keys().next().value);
+}
 
 // src/config.js
 var DEFAULT_ORIGIN = "https://external-gateway.backeer.com";
@@ -245,7 +244,7 @@ function permissionIdentity(request) {
     externalId: `opencode:${sessionID}:${requestID}`
   };
 }
-async function publishPermission(config, reporter, request, directory, identity) {
+async function publishPermission(config, reporter, request, directory, identity, conversation) {
   const permissionType = request.permission ?? request.action ?? "unknown";
   const resources = Array.isArray(request.patterns) ? request.patterns.join(", ") : Array.isArray(request.resources) ? request.resources.join(", ") : "";
   const payload = [
@@ -269,6 +268,7 @@ async function publishPermission(config, reporter, request, directory, identity)
     direction: "in"
   });
   reporter.success("Permission request sent", `HTTP ${result.status}`);
+  conversation?.success(identity.sessionID, "Permission request sent");
 }
 function questionIdentity(request) {
   const requestID = request.id ?? request.requestID;
@@ -303,7 +303,7 @@ async function resolveSessionTitle(client, directory, sessionID, reporter) {
     return "";
   }
 }
-async function publishQuestion(config, reporter, request, identity, client, directory) {
+async function publishQuestion(config, reporter, request, identity, client, directory, conversation) {
   const questions = Array.isArray(request.questions) ? request.questions : [];
   if (questions.length === 0) return;
   const sessionTitle = await resolveSessionTitle(
@@ -345,8 +345,9 @@ async function publishQuestion(config, reporter, request, identity, client, dire
     direction: "in"
   });
   reporter.success("Question sent", `HTTP ${result.status}`);
+  conversation?.success(identity.sessionID, "Question sent");
 }
-async function publishTodoCompletion(config, reporter, request, eventID, client, directory) {
+async function publishTodoCompletion(config, reporter, request, eventID, client, directory, conversation) {
   const todos = request.todos;
   const sessionTitle = await resolveSessionTitle(
     client,
@@ -384,6 +385,7 @@ async function publishTodoCompletion(config, reporter, request, eventID, client,
     direction: "in"
   });
   reporter.success("Todo completion sent", `HTTP ${result.status}`);
+  conversation?.success(request.sessionID, "Todo completion sent");
 }
 
 // src/management.js
@@ -402,7 +404,7 @@ import { randomUUID } from "node:crypto";
 import { statSync } from "node:fs";
 
 // src/updates.js
-var PLUGIN_VERSION = "0.2.1";
+var PLUGIN_VERSION = "0.2.3";
 var PACKAGE_NAME = "backeer-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var CHECK_TIMEOUT_MS = 3e3;
@@ -640,6 +642,154 @@ async function publishTestNotification(config, reporter) {
   return testID;
 }
 
+// src/session-messages.js
+var FEEDBACK_SYMBOLS = {
+  info: "\u2022",
+  success: "\u2713",
+  applied: "\u2713",
+  warning: "!",
+  error: "\xD7"
+};
+var QUESTION_ASKED_EVENTS = /* @__PURE__ */ new Set(["question.asked", "question.v2.asked"]);
+var QUESTION_REPLIED_EVENTS = /* @__PURE__ */ new Set([
+  "question.replied",
+  "question.v2.replied",
+  "question.answered",
+  "question.v2.answered"
+]);
+async function sendSessionMessage(client, sessionID, text) {
+  if (typeof client?.session?.prompt !== "function") {
+    throw new Error("OpenCode session messaging is unavailable");
+  }
+  await client.session.prompt({
+    path: { id: sessionID },
+    body: {
+      noReply: true,
+      parts: [{ type: "text", text, ignored: true }]
+    }
+  });
+}
+function formatBackeerFeedback(kind, message) {
+  const symbol = FEEDBACK_SYMBOLS[kind] ?? FEEDBACK_SYMBOLS.info;
+  return `> **Backeer** ${symbol} ${limit(message, 300)}`;
+}
+function createConversationFeedback({ client, reporter }) {
+  const sessions = /* @__PURE__ */ new Map();
+  let disposed = false;
+  function sessionState(sessionID) {
+    let state = sessions.get(sessionID);
+    if (!state) {
+      state = {
+        idle: false,
+        flushing: false,
+        blockers: /* @__PURE__ */ new Set(),
+        queue: [],
+        queued: /* @__PURE__ */ new Set()
+      };
+      rememberBounded(sessions, sessionID, state);
+    }
+    return state;
+  }
+  async function flush(sessionID, state) {
+    if (disposed || state.flushing || !state.idle || state.blockers.size > 0 || state.queue.length === 0) return;
+    state.flushing = true;
+    try {
+      while (!disposed && state.idle && state.blockers.size === 0 && state.queue.length > 0) {
+        const item = state.queue[0];
+        try {
+          await sendSessionMessage(
+            client,
+            sessionID,
+            formatBackeerFeedback(item.kind, item.message)
+          );
+          state.queue.shift();
+          state.queued.delete(item.key);
+        } catch (error) {
+          state.idle = false;
+          reporter.debug("Conversation feedback could not be displayed", error);
+        }
+      }
+    } finally {
+      state.flushing = false;
+    }
+  }
+  function enqueue(kind, sessionID, message) {
+    if (disposed || typeof sessionID !== "string" || !sessionID || !message) return;
+    const state = sessionState(sessionID);
+    const key = `${sessionID}:${kind}:${message}`;
+    if (state.queued.has(key)) return;
+    state.queue.push({ kind, message: limit(message, 300), key });
+    state.queued.add(key);
+    while (state.queue.length > 20) {
+      const removed = state.queue.shift();
+      state.queued.delete(removed.key);
+    }
+    if (state.idle && state.blockers.size === 0) void flush(sessionID, state);
+  }
+  function setIdle(sessionID, idle) {
+    if (typeof sessionID !== "string" || !sessionID) return;
+    const state = sessionState(sessionID);
+    state.idle = idle;
+    if (idle) void flush(sessionID, state);
+  }
+  function interactionKey(kind, event) {
+    const value = event.properties?.requestID ?? event.properties?.id;
+    return `${kind}:${typeof value === "string" && value ? value : "pending"}`;
+  }
+  function beginInteraction(sessionID, kind, event) {
+    const state = sessionState(sessionID);
+    state.idle = false;
+    state.blockers.add(interactionKey(kind, event));
+  }
+  function endInteraction(sessionID, kind, event) {
+    const state = sessionState(sessionID);
+    const key = interactionKey(kind, event);
+    if (!state.blockers.delete(key)) {
+      const fallback = [...state.blockers].find((blocker) => blocker.startsWith(`${kind}:`));
+      if (fallback) state.blockers.delete(fallback);
+    }
+    state.idle = false;
+  }
+  return {
+    info: (sessionID, message) => enqueue("info", sessionID, message),
+    success: (sessionID, message) => enqueue("success", sessionID, message),
+    applied: (sessionID, message) => enqueue("applied", sessionID, message),
+    warning: (sessionID, message) => enqueue("warning", sessionID, message),
+    error: (sessionID, message) => enqueue("error", sessionID, message),
+    handle(event) {
+      const sessionID = event?.properties?.sessionID;
+      if (typeof sessionID !== "string") return;
+      if (event.type === "session.status") {
+        const status = event.properties?.status?.type;
+        if (status === "idle") setIdle(sessionID, true);
+        else if (status === "busy" || status === "retry") setIdle(sessionID, false);
+      } else if (event.type === "session.idle") {
+        setIdle(sessionID, true);
+      } else if (event.type === "permission.asked") {
+        beginInteraction(sessionID, "permission", event);
+      } else if (QUESTION_ASKED_EVENTS.has(event.type)) {
+        beginInteraction(sessionID, "question", event);
+      } else if (event.type === "permission.replied") {
+        endInteraction(sessionID, "permission", event);
+      } else if (QUESTION_REPLIED_EVENTS.has(event.type)) {
+        endInteraction(sessionID, "question", event);
+      } else if (event.type === "todo.updated") {
+        setIdle(sessionID, false);
+      } else if (event.type === "session.error") {
+        const state = sessionState(sessionID);
+        state.blockers.clear();
+        state.idle = false;
+      } else if (event.type === "session.deleted") {
+        sessions.delete(sessionID);
+      }
+    },
+    dispose() {
+      disposed = true;
+      sessions.clear();
+    }
+  };
+}
+
 // src/management.js
 var COMMAND_DESCRIPTION = "Check, test, update, or manage Backeer: /backeer [status|doctor|test|update-check|update|token|token-file PATH]";
 function tokenFileState(path) {
@@ -766,18 +916,6 @@ function tokenInstructions() {
     "`token-file` activates the new token immediately; no OpenCode restart is required."
   ].join("\n");
 }
-async function sendCommandMessage(client, sessionID, text) {
-  if (typeof client?.session?.prompt !== "function") {
-    throw new Error("OpenCode session messaging is unavailable");
-  }
-  await client.session.prompt({
-    path: { id: sessionID },
-    body: {
-      noReply: true,
-      parts: [{ type: "text", text, ignored: true }]
-    }
-  });
-}
 function registerBackeerCommand(opencodeConfig) {
   opencodeConfig.command ??= {};
   opencodeConfig.command.backeer = {
@@ -859,7 +997,7 @@ Backeer is already current at version ${update.currentVersion}.` : "## Backeer u
         "Use `/backeer token` for secure token-change instructions."
       ].join("\n");
     }
-    await sendCommandMessage(client, input.sessionID, message);
+    await sendSessionMessage(client, input.sessionID, message);
   };
 }
 
@@ -900,7 +1038,7 @@ async function resolveSessionTitle2(client, directory, sessionID, reporter) {
     return "";
   }
 }
-async function publish(config, reporter, event, feedback) {
+async function publish(config, reporter, conversation, sessionID, event, feedback) {
   const result = await postJsonWithRetry(config, config.eventsEndpoint, {
     type: "application",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -909,6 +1047,7 @@ async function publish(config, reporter, event, feedback) {
     ...event
   });
   reporter.success(feedback, `HTTP ${result.status}`);
+  conversation?.success(sessionID, feedback);
 }
 function secondsLabel(durationMs) {
   const seconds = Math.max(0, Math.round(durationMs / 1e3));
@@ -924,7 +1063,8 @@ async function publishSessionCompleted({
   directory,
   sessionID,
   messageID,
-  durationMs
+  durationMs,
+  conversation
 }) {
   const sessionTitle = await resolveSessionTitle2(
     client,
@@ -934,7 +1074,7 @@ async function publishSessionCompleted({
   );
   const duration = secondsLabel(durationMs);
   const location = sessionTitle ? ` \u201C${sessionTitle}\u201D` : "";
-  await publish(config, reporter, {
+  await publish(config, reporter, conversation, sessionID, {
     severity: "info",
     title: "OpenCode task completed",
     body: `OpenCode finished${location} in ${duration}.`,
@@ -954,7 +1094,8 @@ async function publishSessionRetry({
   sessionID,
   correlation,
   attempt,
-  next
+  next,
+  conversation
 }) {
   const sessionTitle = await resolveSessionTitle2(
     client,
@@ -963,7 +1104,7 @@ async function publishSessionRetry({
     reporter
   );
   const retryAt = Number.isFinite(next) ? new Date(next).toISOString() : "";
-  await publish(config, reporter, {
+  await publish(config, reporter, conversation, sessionID, {
     severity: "warning",
     title: "OpenCode is retrying",
     body: `OpenCode reached retry attempt ${attempt}. The operation is still running.`,
@@ -982,7 +1123,8 @@ async function publishSessionError({
   directory,
   sessionID,
   correlation,
-  error
+  error,
+  conversation
 }) {
   const sessionTitle = await resolveSessionTitle2(
     client,
@@ -993,7 +1135,7 @@ async function publishSessionError({
   const details = safeErrorDetails(error);
   const location = sessionTitle ? ` in \u201C${sessionTitle}\u201D` : "";
   const body = details.message ? `OpenCode failed${location}: ${details.message}` : `OpenCode failed${location}.`;
-  await publish(config, reporter, {
+  await publish(config, reporter, conversation, sessionID, {
     // Backeer/iOS currently support info, warning and critical severities.
     severity: "critical",
     title: "OpenCode task failed",
@@ -1010,7 +1152,7 @@ async function publishSessionError({
 }
 async function publishOpenCodeUpdate({ config, reporter, version }) {
   const safeVersion = limit(version, 100);
-  await publish(config, reporter, {
+  await publish(config, reporter, void 0, void 0, {
     severity: "info",
     title: "OpenCode update available",
     body: `OpenCode ${safeVersion} is available.`,
@@ -1038,6 +1180,7 @@ function createLifecycleController({
   reporter,
   client,
   directory,
+  conversation,
   now = () => Date.now(),
   publishers = {}
 }) {
@@ -1063,8 +1206,11 @@ function createLifecycleController({
     }
     return state;
   }
-  function dispatch(label, operation) {
-    void Promise.resolve(operation).catch((error) => reporter.error(label, error));
+  function dispatch(label, operation, sessionID) {
+    void Promise.resolve(operation).catch((error) => {
+      reporter.error(label, error);
+      conversation?.error(sessionID, label);
+    });
   }
   function beginCycle(state) {
     if (state.busy) return;
@@ -1092,8 +1238,10 @@ function createLifecycleController({
         directory,
         sessionID,
         messageID: limit(assistant.id, 200),
-        durationMs
-      })
+        durationMs,
+        conversation
+      }),
+      sessionID
     );
   }
   function handleMessage(event) {
@@ -1138,8 +1286,10 @@ function createLifecycleController({
         sessionID,
         correlation: limit(correlation, 200),
         attempt: status.attempt,
-        next: status.next
-      })
+        next: status.next,
+        conversation
+      }),
+      sessionID
     );
   }
   function handleError(event) {
@@ -1156,8 +1306,10 @@ function createLifecycleController({
         directory,
         sessionID,
         correlation: errorCorrelation(event, state),
-        error: event.properties?.error
-      })
+        error: event.properties?.error,
+        conversation
+      }),
+      sessionID
     );
   }
   function handleWaiting(event, waiting) {
@@ -1343,7 +1495,8 @@ function createPermissionController({
   config,
   reporter,
   client,
-  directory
+  directory,
+  conversation
 }) {
   const pendingByExternalID = /* @__PURE__ */ new Map();
   const externalIDByRequestID = /* @__PURE__ */ new Map();
@@ -1404,6 +1557,7 @@ function createPermissionController({
       };
       if (stale) removePendingByRequestID(pending.requestID);
       reporter.error("Decision could not be applied", error);
+      conversation?.error(pending.sessionID, "Decision could not be applied");
     } finally {
       processingCommands.delete(command.id);
     }
@@ -1418,12 +1572,19 @@ function createPermissionController({
       reporter.applied(
         `Decision applied: ${DECISION_LABELS[acknowledgement.decision]}`
       );
+      conversation?.applied(
+        pending.sessionID,
+        `Decision applied: ${DECISION_LABELS[acknowledgement.decision]}`
+      );
     } else if (acknowledgement.status === "expired") {
       reporter.warning("Decision expired before it could be applied");
+      conversation?.warning(pending.sessionID, "Decision expired before it could be applied");
     } else if (acknowledgement.status === "stale") {
       reporter.warning("Permission was already answered locally");
+      conversation?.warning(pending.sessionID, "Permission was already answered locally");
     } else if (acknowledgement.status === "rejected") {
       reporter.warning("Decision was rejected by validation");
+      conversation?.warning(pending.sessionID, "Decision was rejected by validation");
     }
     await acknowledgeCommand(config, command.id, acknowledgement).catch((error) => {
       reporter.warning("Decision receipt could not be sent", error);
@@ -1486,7 +1647,8 @@ function createPermissionController({
 
 // src/plugin.js
 async function BackeerPlugin({ client, directory }, options = {}) {
-  const bootstrapReporter = createConsoleReporter(
+  const bootstrapReporter = createOpenCodeReporter(
+    client,
     options.logLevel ?? process.env.BACKEER_LOG_LEVEL
   );
   let config;
@@ -1496,18 +1658,21 @@ async function BackeerPlugin({ client, directory }, options = {}) {
     bootstrapReporter.error("Plugin disabled \u2014 invalid configuration", error);
     return {};
   }
-  const reporter = createConsoleReporter(config.logLevel);
+  const reporter = createOpenCodeReporter(client, config.logLevel);
+  const conversation = createConversationFeedback({ client, reporter });
   const permissionController = createPermissionController({
     config,
     reporter,
     client,
-    directory
+    directory,
+    conversation
   });
   const lifecycleController = createLifecycleController({
     config,
     reporter,
     client,
-    directory
+    directory,
+    conversation
   });
   const todoCompletionBySessionID = /* @__PURE__ */ new Map();
   const publishedQuestions = /* @__PURE__ */ new Map();
@@ -1538,8 +1703,12 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       reporter,
       event.properties,
       directory,
-      identity
-    ).catch((error) => reporter.error("Permission request could not be sent", error));
+      identity,
+      conversation
+    ).catch((error) => {
+      reporter.error("Permission request could not be sent", error);
+      conversation.error(identity.sessionID, "Permission request could not be sent");
+    });
   }
   async function handleTodoUpdated(event) {
     const { sessionID, todos } = event.properties;
@@ -1557,8 +1726,12 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       event.properties,
       event.id,
       client,
-      directory
-    ).catch((error) => reporter.error("Todo completion could not be sent", error));
+      directory,
+      conversation
+    ).catch((error) => {
+      reporter.error("Todo completion could not be sent", error);
+      conversation.error(sessionID, "Todo completion could not be sent");
+    });
   }
   async function handleQuestionAsked(event) {
     const identity = questionIdentity(event.properties);
@@ -1574,8 +1747,12 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       event.properties,
       identity,
       client,
-      directory
-    ).catch((error) => reporter.error("Question could not be sent", error));
+      directory,
+      conversation
+    ).catch((error) => {
+      reporter.error("Question could not be sent", error);
+      conversation.error(identity.sessionID, "Question could not be sent");
+    });
   }
   return {
     config: async (opencodeConfig) => {
@@ -1585,6 +1762,7 @@ async function BackeerPlugin({ client, directory }, options = {}) {
     "chat.message": handleUpdateNotice,
     event: async ({ event }) => {
       if (!config.token) return;
+      conversation.handle(event);
       lifecycleController.handle(event);
       if (config.permissions && event.type === "permission.asked") {
         await handlePermissionAsked(event);
@@ -1609,6 +1787,7 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       lifecycleController.dispose();
       todoCompletionBySessionID.clear();
       publishedQuestions.clear();
+      conversation.dispose();
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backeer-opencode",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Backeer lifecycle notifications and remote permission decisions for OpenCode",
   "type": "module",
   "main": "./src/index.js",

package/src/event-publishers.js

@@ -21,6 +21,7 @@ export async function publishPermission(
   request,
   directory,
   identity,
+  conversation,
 ) {
   const permissionType = request.permission ?? request.action ?? "unknown"
   const resources = Array.isArray(request.patterns)
@@ -53,6 +54,7 @@ export async function publishPermission(
     direction: "in",
   })
   reporter.success("Permission request sent", `HTTP ${result.status}`)
+  conversation?.success(identity.sessionID, "Permission request sent")
 }
 
 export function questionIdentity(request) {
@@ -104,6 +106,7 @@ export async function publishQuestion(
   identity,
   client,
   directory,
+  conversation,
 ) {
   const questions = Array.isArray(request.questions) ? request.questions : []
   if (questions.length === 0) return
@@ -153,6 +156,7 @@ export async function publishQuestion(
     direction: "in",
   })
   reporter.success("Question sent", `HTTP ${result.status}`)
+  conversation?.success(identity.sessionID, "Question sent")
 }
 
 export async function publishTodoCompletion(
@@ -162,6 +166,7 @@ export async function publishTodoCompletion(
   eventID,
   client,
   directory,
+  conversation,
 ) {
   const todos = request.todos
   const sessionTitle = await resolveSessionTitle(
@@ -211,4 +216,5 @@ export async function publishTodoCompletion(
     direction: "in",
   })
   reporter.success("Todo completion sent", `HTTP ${result.status}`)
+  conversation?.success(request.sessionID, "Todo completion sent")
 }

package/src/lifecycle-controller.js

@@ -20,6 +20,7 @@ export function createLifecycleController({
   reporter,
   client,
   directory,
+  conversation,
   now = () => Date.now(),
   publishers = {},
 }) {
@@ -47,8 +48,11 @@ export function createLifecycleController({
     return state
   }
 
-  function dispatch(label, operation) {
-    void Promise.resolve(operation).catch((error) => reporter.error(label, error))
+  function dispatch(label, operation, sessionID) {
+    void Promise.resolve(operation).catch((error) => {
+      reporter.error(label, error)
+      conversation?.error(sessionID, label)
+    })
   }
 
   function beginCycle(state) {
@@ -83,7 +87,9 @@ export function createLifecycleController({
         sessionID,
         messageID: limit(assistant.id, 200),
         durationMs,
+        conversation,
       }),
+      sessionID,
     )
   }
 
@@ -135,7 +141,9 @@ export function createLifecycleController({
         correlation: limit(correlation, 200),
         attempt: status.attempt,
         next: status.next,
+        conversation,
       }),
+      sessionID,
     )
   }
 
@@ -157,7 +165,9 @@ export function createLifecycleController({
         sessionID,
         correlation: errorCorrelation(event, state),
         error: event.properties?.error,
+        conversation,
       }),
+      sessionID,
     )
   }
 

package/src/lifecycle-publishers.js

@@ -53,7 +53,7 @@ async function resolveSessionTitle(client, directory, sessionID, reporter) {
   }
 }
 
-async function publish(config, reporter, event, feedback) {
+async function publish(config, reporter, conversation, sessionID, event, feedback) {
   const result = await postJsonWithRetry(config, config.eventsEndpoint, {
     type: "application",
     timestamp: new Date().toISOString(),
@@ -62,6 +62,7 @@ async function publish(config, reporter, event, feedback) {
     ...event,
   })
   reporter.success(feedback, `HTTP ${result.status}`)
+  conversation?.success(sessionID, feedback)
 }
 
 function secondsLabel(durationMs) {
@@ -80,6 +81,7 @@ export async function publishSessionCompleted({
   sessionID,
   messageID,
   durationMs,
+  conversation,
 }) {
   const sessionTitle = await resolveSessionTitle(
     client,
@@ -89,7 +91,7 @@ export async function publishSessionCompleted({
   )
   const duration = secondsLabel(durationMs)
   const location = sessionTitle ? ` “${sessionTitle}”` : ""
-  await publish(config, reporter, {
+  await publish(config, reporter, conversation, sessionID, {
     severity: "info",
     title: "OpenCode task completed",
     body: `OpenCode finished${location} in ${duration}.`,
@@ -111,6 +113,7 @@ export async function publishSessionRetry({
   correlation,
   attempt,
   next,
+  conversation,
 }) {
   const sessionTitle = await resolveSessionTitle(
     client,
@@ -119,7 +122,7 @@ export async function publishSessionRetry({
     reporter,
   )
   const retryAt = Number.isFinite(next) ? new Date(next).toISOString() : ""
-  await publish(config, reporter, {
+  await publish(config, reporter, conversation, sessionID, {
     severity: "warning",
     title: "OpenCode is retrying",
     body: `OpenCode reached retry attempt ${attempt}. The operation is still running.`,
@@ -140,6 +143,7 @@ export async function publishSessionError({
   sessionID,
   correlation,
   error,
+  conversation,
 }) {
   const sessionTitle = await resolveSessionTitle(
     client,
@@ -152,7 +156,7 @@ export async function publishSessionError({
   const body = details.message
     ? `OpenCode failed${location}: ${details.message}`
     : `OpenCode failed${location}.`
-  await publish(config, reporter, {
+  await publish(config, reporter, conversation, sessionID, {
     // Backeer/iOS currently support info, warning and critical severities.
     severity: "critical",
     title: "OpenCode task failed",
@@ -170,7 +174,7 @@ export async function publishSessionError({
 
 export async function publishOpenCodeUpdate({ config, reporter, version }) {
   const safeVersion = limit(version, 100)
-  await publish(config, reporter, {
+  await publish(config, reporter, undefined, undefined, {
     severity: "info",
     title: "OpenCode update available",
     body: `OpenCode ${safeVersion} is available.`,

package/src/management.js

@@ -9,6 +9,7 @@ import {
 import { dirname, resolve } from "node:path"
 
 import { buildDoctorReport, publishTestNotification } from "./diagnostics.js"
+import { sendSessionMessage } from "./session-messages.js"
 import {
   formatAgentUpdateInstruction,
   PLUGIN_VERSION,
@@ -156,19 +157,6 @@ function tokenInstructions() {
   ].join("\n")
 }
 
-async function sendCommandMessage(client, sessionID, text) {
-  if (typeof client?.session?.prompt !== "function") {
-    throw new Error("OpenCode session messaging is unavailable")
-  }
-  await client.session.prompt({
-    path: { id: sessionID },
-    body: {
-      noReply: true,
-      parts: [{ type: "text", text, ignored: true }],
-    },
-  })
-}
-
 export function registerBackeerCommand(opencodeConfig) {
   opencodeConfig.command ??= {}
   opencodeConfig.command.backeer = {
@@ -262,6 +250,6 @@ export function createBackeerCommandHandler({
       ].join("\n")
     }
 
-    await sendCommandMessage(client, input.sessionID, message)
+    await sendSessionMessage(client, input.sessionID, message)
   }
 }

package/src/permission-controller.js

@@ -35,6 +35,7 @@ export function createPermissionController({
   reporter,
   client,
   directory,
+  conversation,
 }) {
   const pendingByExternalID = new Map()
   const externalIDByRequestID = new Map()
@@ -104,6 +105,7 @@ export function createPermissionController({
       }
       if (stale) removePendingByRequestID(pending.requestID)
       reporter.error("Decision could not be applied", error)
+      conversation?.error(pending.sessionID, "Decision could not be applied")
     } finally {
       processingCommands.delete(command.id)
     }
@@ -120,12 +122,19 @@ export function createPermissionController({
       reporter.applied(
         `Decision applied: ${DECISION_LABELS[acknowledgement.decision]}`,
       )
+      conversation?.applied(
+        pending.sessionID,
+        `Decision applied: ${DECISION_LABELS[acknowledgement.decision]}`,
+      )
     } else if (acknowledgement.status === "expired") {
       reporter.warning("Decision expired before it could be applied")
+      conversation?.warning(pending.sessionID, "Decision expired before it could be applied")
     } else if (acknowledgement.status === "stale") {
       reporter.warning("Permission was already answered locally")
+      conversation?.warning(pending.sessionID, "Permission was already answered locally")
     } else if (acknowledgement.status === "rejected") {
       reporter.warning("Decision was rejected by validation")
+      conversation?.warning(pending.sessionID, "Decision was rejected by validation")
     }
 
     await acknowledgeCommand(config, command.id, acknowledgement).catch((error) => {

package/src/plugin.js

@@ -12,7 +12,8 @@ import {
 } from "./management.js"
 import { createLifecycleController } from "./lifecycle-controller.js"
 import { createPermissionController } from "./permission-controller.js"
-import { createConsoleReporter } from "./reporter.js"
+import { createOpenCodeReporter } from "./reporter.js"
+import { createConversationFeedback } from "./session-messages.js"
 import {
   createUpdateChecker,
   createUpdateNoticeHook,
@@ -28,7 +29,8 @@ import { rememberBounded } from "./utilities.js"
  * protected file so it cannot accidentally be committed in opencode.json.
  */
 export default async function BackeerPlugin({ client, directory }, options = {}) {
-  const bootstrapReporter = createConsoleReporter(
+  const bootstrapReporter = createOpenCodeReporter(
+    client,
     options.logLevel ?? process.env.BACKEER_LOG_LEVEL,
   )
   let config
@@ -39,19 +41,22 @@ export default async function BackeerPlugin({ client, directory }, options = {})
     return {}
   }
 
-  const reporter = createConsoleReporter(config.logLevel)
+  const reporter = createOpenCodeReporter(client, config.logLevel)
+  const conversation = createConversationFeedback({ client, reporter })
 
   const permissionController = createPermissionController({
     config,
     reporter,
     client,
     directory,
+    conversation,
   })
   const lifecycleController = createLifecycleController({
     config,
     reporter,
     client,
     directory,
+    conversation,
   })
   const todoCompletionBySessionID = new Map()
   const publishedQuestions = new Map()
@@ -86,7 +91,11 @@ export default async function BackeerPlugin({ client, directory }, options = {})
       event.properties,
       directory,
       identity,
-    ).catch((error) => reporter.error("Permission request could not be sent", error))
+      conversation,
+    ).catch((error) => {
+      reporter.error("Permission request could not be sent", error)
+      conversation.error(identity.sessionID, "Permission request could not be sent")
+    })
   }
 
   async function handleTodoUpdated(event) {
@@ -109,7 +118,11 @@ export default async function BackeerPlugin({ client, directory }, options = {})
       event.id,
       client,
       directory,
-    ).catch((error) => reporter.error("Todo completion could not be sent", error))
+      conversation,
+    ).catch((error) => {
+      reporter.error("Todo completion could not be sent", error)
+      conversation.error(sessionID, "Todo completion could not be sent")
+    })
   }
 
   async function handleQuestionAsked(event) {
@@ -128,7 +141,11 @@ export default async function BackeerPlugin({ client, directory }, options = {})
       identity,
       client,
       directory,
-    ).catch((error) => reporter.error("Question could not be sent", error))
+      conversation,
+    ).catch((error) => {
+      reporter.error("Question could not be sent", error)
+      conversation.error(identity.sessionID, "Question could not be sent")
+    })
   }
 
   return {
@@ -143,6 +160,7 @@ export default async function BackeerPlugin({ client, directory }, options = {})
     event: async ({ event }) => {
       if (!config.token) return
 
+      conversation.handle(event)
       lifecycleController.handle(event)
 
       if (config.permissions && event.type === "permission.asked") {
@@ -175,6 +193,7 @@ export default async function BackeerPlugin({ client, directory }, options = {})
       lifecycleController.dispose()
       todoCompletionBySessionID.clear()
       publishedQuestions.clear()
+      conversation.dispose()
     },
   }
 }

package/src/reporter.js

@@ -58,3 +58,53 @@ export function createConsoleReporter(levelValue) {
     debug: (message, detail) => emit("debug", "debug", message, detail),
   }
 }
+
+export function createOpenCodeReporter(client, levelValue) {
+  const level = normalizeLogLevel(levelValue)
+  const recentlyEmitted = new Map()
+  const method = client?.app?.log
+
+  function emit(requiredLevel, kind, message, detail, deduplicate = false) {
+    if (LOG_RANK[level] < LOG_RANK[requiredLevel] || typeof method !== "function") return
+
+    const key = `${kind}:${message}`
+    const now = Date.now()
+    if (deduplicate) {
+      const previous = recentlyEmitted.get(key)
+      if (previous && now - previous < LOG_DEDUPLICATION_MS) return
+      rememberRecent(recentlyEmitted, key, now)
+    }
+
+    const body = {
+      service: "backeer-opencode",
+      level: kind === "warning" ? "warn" : kind === "applied" || kind === "success"
+        ? "info"
+        : kind,
+      message: limit(message, 500),
+    }
+    if (level === "debug" && detail) {
+      body.extra = { detail: limit(detail?.message ?? detail, 500) }
+    }
+
+    // Logging during plugin initialization can deadlock older OpenCode builds.
+    // Defer it and never fall back to stdout, because stdout corrupts the TUI prompt.
+    setTimeout(() => {
+      void Promise.resolve(method.call(client.app, { body })).catch(() => {})
+    }, 0)
+  }
+
+  return {
+    info: (message, detail) => emit("info", "info", message, detail),
+    success: (message, detail) => emit("info", "success", message, detail),
+    applied: (message, detail) => emit("info", "applied", message, detail),
+    warning: (message, detail) => emit("error", "warning", message, detail, true),
+    error: (message, detail) => emit("error", "error", message, detail, true),
+    debug: (message, detail) => emit("debug", "debug", message, detail),
+  }
+}
+
+function rememberRecent(map, key, value) {
+  map.delete(key)
+  map.set(key, value)
+  while (map.size > 100) map.delete(map.keys().next().value)
+}

package/src/session-messages.js

@@ -0,0 +1,173 @@
+import { limit, rememberBounded } from "./utilities.js"
+
+const FEEDBACK_SYMBOLS = {
+  info: "•",
+  success: "✓",
+  applied: "✓",
+  warning: "!",
+  error: "×",
+}
+
+const QUESTION_ASKED_EVENTS = new Set(["question.asked", "question.v2.asked"])
+const QUESTION_REPLIED_EVENTS = new Set([
+  "question.replied",
+  "question.v2.replied",
+  "question.answered",
+  "question.v2.answered",
+])
+
+export async function sendSessionMessage(client, sessionID, text) {
+  if (typeof client?.session?.prompt !== "function") {
+    throw new Error("OpenCode session messaging is unavailable")
+  }
+  await client.session.prompt({
+    path: { id: sessionID },
+    body: {
+      noReply: true,
+      parts: [{ type: "text", text, ignored: true }],
+    },
+  })
+}
+
+export function formatBackeerFeedback(kind, message) {
+  const symbol = FEEDBACK_SYMBOLS[kind] ?? FEEDBACK_SYMBOLS.info
+  return `> **Backeer** ${symbol} ${limit(message, 300)}`
+}
+
+export function createConversationFeedback({ client, reporter }) {
+  const sessions = new Map()
+  let disposed = false
+
+  function sessionState(sessionID) {
+    let state = sessions.get(sessionID)
+    if (!state) {
+      state = {
+        idle: false,
+        flushing: false,
+        blockers: new Set(),
+        queue: [],
+        queued: new Set(),
+      }
+      rememberBounded(sessions, sessionID, state)
+    }
+    return state
+  }
+
+  async function flush(sessionID, state) {
+    if (
+      disposed || state.flushing || !state.idle ||
+      state.blockers.size > 0 || state.queue.length === 0
+    ) return
+    state.flushing = true
+    try {
+      while (
+        !disposed && state.idle && state.blockers.size === 0 &&
+        state.queue.length > 0
+      ) {
+        const item = state.queue[0]
+        try {
+          await sendSessionMessage(
+            client,
+            sessionID,
+            formatBackeerFeedback(item.kind, item.message),
+          )
+          state.queue.shift()
+          state.queued.delete(item.key)
+        } catch (error) {
+          state.idle = false
+          reporter.debug("Conversation feedback could not be displayed", error)
+        }
+      }
+    } finally {
+      state.flushing = false
+    }
+  }
+
+  function enqueue(kind, sessionID, message) {
+    if (disposed || typeof sessionID !== "string" || !sessionID || !message) return
+    const state = sessionState(sessionID)
+    const key = `${sessionID}:${kind}:${message}`
+    if (state.queued.has(key)) return
+
+    state.queue.push({ kind, message: limit(message, 300), key })
+    state.queued.add(key)
+    while (state.queue.length > 20) {
+      const removed = state.queue.shift()
+      state.queued.delete(removed.key)
+    }
+    if (state.idle && state.blockers.size === 0) void flush(sessionID, state)
+  }
+
+  function setIdle(sessionID, idle) {
+    if (typeof sessionID !== "string" || !sessionID) return
+    const state = sessionState(sessionID)
+    state.idle = idle
+    if (idle) void flush(sessionID, state)
+  }
+
+  function interactionKey(kind, event) {
+    const value = event.properties?.requestID ?? event.properties?.id
+    return `${kind}:${typeof value === "string" && value ? value : "pending"}`
+  }
+
+  function beginInteraction(sessionID, kind, event) {
+    const state = sessionState(sessionID)
+    state.idle = false
+    state.blockers.add(interactionKey(kind, event))
+  }
+
+  function endInteraction(sessionID, kind, event) {
+    const state = sessionState(sessionID)
+    const key = interactionKey(kind, event)
+    if (!state.blockers.delete(key)) {
+      const fallback = [...state.blockers]
+        .find((blocker) => blocker.startsWith(`${kind}:`))
+      if (fallback) state.blockers.delete(fallback)
+    }
+    // The reply event can arrive before OpenCode has removed its permission UI
+    // or resumed the agent. Wait for the next idle event before injecting text.
+    state.idle = false
+  }
+
+  return {
+    info: (sessionID, message) => enqueue("info", sessionID, message),
+    success: (sessionID, message) => enqueue("success", sessionID, message),
+    applied: (sessionID, message) => enqueue("applied", sessionID, message),
+    warning: (sessionID, message) => enqueue("warning", sessionID, message),
+    error: (sessionID, message) => enqueue("error", sessionID, message),
+
+    handle(event) {
+      const sessionID = event?.properties?.sessionID
+      if (typeof sessionID !== "string") return
+
+      if (event.type === "session.status") {
+        const status = event.properties?.status?.type
+        if (status === "idle") setIdle(sessionID, true)
+        else if (status === "busy" || status === "retry") setIdle(sessionID, false)
+      } else if (event.type === "session.idle") {
+        setIdle(sessionID, true)
+      } else if (event.type === "permission.asked") {
+        beginInteraction(sessionID, "permission", event)
+      } else if (QUESTION_ASKED_EVENTS.has(event.type)) {
+        beginInteraction(sessionID, "question", event)
+      } else if (event.type === "permission.replied") {
+        endInteraction(sessionID, "permission", event)
+      } else if (QUESTION_REPLIED_EVENTS.has(event.type)) {
+        endInteraction(sessionID, "question", event)
+      } else if (event.type === "todo.updated") {
+        setIdle(sessionID, false)
+      } else if (event.type === "session.error") {
+        const state = sessionState(sessionID)
+        state.blockers.clear()
+        state.idle = false
+      } else if (event.type === "session.deleted") {
+        sessions.delete(sessionID)
+      }
+    },
+
+    dispose() {
+      disposed = true
+      sessions.clear()
+    },
+  }
+}

package/src/updates.js

@@ -1,4 +1,4 @@
-export const PLUGIN_VERSION = "0.2.1"
+export const PLUGIN_VERSION = "0.2.3"
 
 const PACKAGE_NAME = "backeer-opencode"
 const NPM_REGISTRY_URL = "https://registry.npmjs.org"