backeer-opencode 0.2.0 → 0.2.2

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 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);
+    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) };
+    }
+    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";
@@ -140,6 +139,7 @@ function loadConfig(options = {}) {
   return {
     origin,
     eventsEndpoint: new URL("/v1/events", origin),
+    sourceHealthEndpoint: new URL("/v1/source/health", origin),
     commandStreamEndpoint: new URL("/v1/commands/stream", origin),
     token: loadedToken.token,
     tokenSource: loadedToken.source,
@@ -244,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 = [
@@ -268,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;
@@ -302,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(
@@ -344,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,
@@ -383,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
@@ -391,13 +394,17 @@ import {
   mkdirSync,
   readFileSync as readFileSync2,
   renameSync,
-  statSync,
+  statSync as statSync2,
   writeFileSync
 } from "node:fs";
 import { dirname, resolve } from "node:path";
 
+// src/diagnostics.js
+import { randomUUID } from "node:crypto";
+import { statSync } from "node:fs";
+
 // src/updates.js
-var PLUGIN_VERSION = "0.2.0";
+var PLUGIN_VERSION = "0.2.2";
 var PACKAGE_NAME = "backeer-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var CHECK_TIMEOUT_MS = 3e3;
@@ -517,11 +524,234 @@ function createUpdateNoticeHook(updateChecker) {
   };
 }
 
+// src/diagnostics.js
+var PASS = "\u2713";
+var FAIL = "\xD7";
+var INFO = "\u2022";
+function tokenFileCheck(config) {
+  if (config.tokenSource === "environment") {
+    return { ok: true, text: "Token loaded from the environment; token file not required" };
+  }
+  try {
+    const stats = statSync(config.tokenFile);
+    const mode = stats.mode & 511;
+    if (!stats.isFile()) return { ok: false, text: "Token path is not a regular file" };
+    if ((mode & 63) !== 0) {
+      return {
+        ok: false,
+        text: `Token file mode ${mode.toString(8).padStart(3, "0")} is too permissive; expected 600`
+      };
+    }
+    return {
+      ok: true,
+      text: `Token file is protected (mode ${mode.toString(8).padStart(3, "0")})`
+    };
+  } catch {
+    return { ok: false, text: "Token file is missing or unreadable" };
+  }
+}
+async function probeSource(config, fetchImplementation = globalThis.fetch) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 5e3);
+  try {
+    const response = await fetchImplementation(config.sourceHealthEndpoint, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${config.token}` },
+      signal: controller.signal
+    });
+    const responseBody = limit(await response.text(), 2e3);
+    if (!response.ok) {
+      throw new HttpError(
+        `Gateway source check failed with status ${response.status}`,
+        response.status,
+        responseBody
+      );
+    }
+    try {
+      return JSON.parse(responseBody);
+    } catch {
+      throw new Error("Gateway source check returned malformed JSON");
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function buildDoctorReport(config, { fetchImplementation = globalThis.fetch } = {}) {
+  const checks = [];
+  checks.push({ ok: true, text: `Plugin version ${PLUGIN_VERSION}` });
+  checks.push({
+    ok: config.origin.protocol === "https:",
+    text: `Gateway uses ${config.origin.protocol === "https:" ? "HTTPS" : "an insecure protocol"}: ${config.origin.origin}`
+  });
+  checks.push({
+    ok: Boolean(config.token),
+    text: config.token ? `Source token loaded from ${config.tokenSource}` : "Source token is missing"
+  });
+  checks.push(tokenFileCheck(config));
+  let source;
+  if (config.token) {
+    try {
+      const result = await probeSource(config, fetchImplementation);
+      source = result?.source;
+      checks.push({
+        ok: result?.ok === true && typeof source?.id === "string",
+        text: source?.id ? `Source authentication accepted: ${source.name || source.id} (${source.id})` : "Gateway did not return a source identity"
+      });
+      checks.push({
+        ok: result?.capabilities?.events === true && result?.capabilities?.commands === true,
+        text: result?.capabilities?.events === true && result?.capabilities?.commands === true ? "Event ingest and command stream are available" : "Event ingest or command stream is unavailable"
+      });
+      checks.push({
+        ok: result?.capabilities?.apns === true,
+        text: result?.capabilities?.apns === true ? "Gateway APNs delivery is enabled" : "Gateway APNs delivery is disabled"
+      });
+    } catch (error) {
+      const detail = error instanceof HttpError && error.status === 401 ? "Source authentication rejected (HTTP 401)" : error?.name === "AbortError" ? "Gateway source check timed out" : `Gateway source check failed: ${limit(error?.message || error, 300)}`;
+      checks.push({ ok: false, text: detail });
+    }
+  }
+  const healthy = checks.every((check) => check.ok);
+  return [
+    "## Backeer doctor",
+    "",
+    ...checks.map((check) => `${check.ok ? PASS : FAIL} ${check.text}`),
+    "",
+    healthy ? `${PASS} Result: healthy. Use \`/backeer test\` to verify phone delivery.` : `${FAIL} Result: issues found. Resolve failed checks and run \`/backeer doctor\` again.`,
+    "",
+    `${INFO} No event was created and the token value was not displayed.`
+  ].join("\n");
+}
+async function publishTestNotification(config, reporter) {
+  if (!config.token) throw new Error("Backeer source token is missing");
+  const testID = randomUUID();
+  const result = await postJsonWithRetry(config, config.eventsEndpoint, {
+    type: "application",
+    severity: "info",
+    title: "Backeer test notification",
+    body: "OpenCode integration is connected and push delivery is working.",
+    payload: [
+      { key: "Plugin version", value: PLUGIN_VERSION },
+      { key: "Test ID", value: testID }
+    ],
+    externalId: `opencode:test:${testID}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    notify: true,
+    direction: "in"
+  });
+  reporter.success("Test notification sent", `HTTP ${result.status}`);
+  return testID;
+}
+
+// src/session-messages.js
+var FEEDBACK_SYMBOLS = {
+  info: "\u2022",
+  success: "\u2713",
+  applied: "\u2713",
+  warning: "!",
+  error: "\xD7"
+};
+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, queue: [], queued: /* @__PURE__ */ new Set() };
+      rememberBounded(sessions, sessionID, state);
+    }
+    return state;
+  }
+  async function flush(sessionID, state) {
+    if (disposed || state.flushing || !state.idle || state.queue.length === 0) return;
+    state.flushing = true;
+    try {
+      while (!disposed && state.idle && 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) 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);
+  }
+  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" || event.type === "question.asked" || event.type === "question.v2.asked" || event.type === "todo.updated") {
+        setIdle(sessionID, false);
+      } else if (event.type === "session.deleted") {
+        sessions.delete(sessionID);
+      }
+    },
+    dispose() {
+      disposed = true;
+      sessions.clear();
+    }
+  };
+}
+
 // src/management.js
-var COMMAND_DESCRIPTION = "Show Backeer status, update it, or manage its token: /backeer [status|update-check|update|token|token-file PATH]";
+var COMMAND_DESCRIPTION = "Check, test, update, or manage Backeer: /backeer [status|doctor|test|update-check|update|token|token-file PATH]";
 function tokenFileState(path) {
   try {
-    const stats = statSync(path);
+    const stats = statSync2(path);
     const mode = (stats.mode & 511).toString(8).padStart(3, "0");
     return stats.isFile() ? `present (mode ${mode})` : "not a regular file";
   } catch {
@@ -546,7 +776,7 @@ function writeTokenAtomically(path, token) {
 function rotateTokenFromFile(config, sourcePathValue) {
   if (!sourcePathValue.trim()) throw new Error("A token file path is required");
   const sourcePath = resolve(cleanPathArgument(sourcePathValue));
-  const sourceStats = statSync(sourcePath);
+  const sourceStats = statSync2(sourcePath);
   if (!sourceStats.isFile()) throw new Error("The token source is not a regular file");
   if ((sourceStats.mode & 63) !== 0) {
     throw new Error("The token source must not be readable by group or other users");
@@ -619,6 +849,8 @@ function helpMessage() {
     "## Backeer commands",
     "",
     "- `/backeer` or `/backeer status` \u2014 show integration status",
+    "- `/backeer doctor` \u2014 diagnose config, credentials, gateway, and APNs without creating an event",
+    "- `/backeer test` \u2014 send a real test notification to the Backeer application",
     "- `/backeer update-check` \u2014 check NPM for a newer version",
     "- `/backeer update` \u2014 ask the OpenCode agent to install and verify it",
     "- `/backeer token` \u2014 show secure token-change instructions",
@@ -641,18 +873,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 = {
@@ -678,6 +898,17 @@ function createBackeerCommandHandler({
     try {
       if (!subcommand || subcommand === "status") {
         message = await buildStatus(config, permissionController, updateChecker);
+      } else if (subcommand === "doctor") {
+        message = await buildDoctorReport(config);
+      } else if (subcommand === "test") {
+        const testID = await publishTestNotification(config, reporter);
+        message = [
+          "## Backeer test notification",
+          "",
+          "\u2713 The gateway accepted the test event.",
+          `- Test ID: ${testID}`,
+          "- Check the Backeer application for the notification."
+        ].join("\n");
       } else if (subcommand === "update-check") {
         const update = await updateChecker.check({ force: true });
         message = [
@@ -714,7 +945,7 @@ Backeer is already current at version ${update.currentVersion}.` : "## Backeer u
         message = helpMessage();
       }
     } catch (error) {
-      reporter.error("Access token could not be updated", error);
+      reporter.error("Backeer command failed", error);
       message = [
         "## Backeer command failed",
         "",
@@ -723,7 +954,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);
   };
 }
 
@@ -764,7 +995,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(),
@@ -773,6 +1004,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));
@@ -788,7 +1020,8 @@ async function publishSessionCompleted({
   directory,
   sessionID,
   messageID,
-  durationMs
+  durationMs,
+  conversation
 }) {
   const sessionTitle = await resolveSessionTitle2(
     client,
@@ -798,7 +1031,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}.`,
@@ -818,7 +1051,8 @@ async function publishSessionRetry({
   sessionID,
   correlation,
   attempt,
-  next
+  next,
+  conversation
 }) {
   const sessionTitle = await resolveSessionTitle2(
     client,
@@ -827,7 +1061,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.`,
@@ -846,7 +1080,8 @@ async function publishSessionError({
   directory,
   sessionID,
   correlation,
-  error
+  error,
+  conversation
 }) {
   const sessionTitle = await resolveSessionTitle2(
     client,
@@ -857,7 +1092,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",
@@ -874,7 +1109,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.`,
@@ -902,6 +1137,7 @@ function createLifecycleController({
   reporter,
   client,
   directory,
+  conversation,
   now = () => Date.now(),
   publishers = {}
 }) {
@@ -927,8 +1163,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;
@@ -956,8 +1195,10 @@ function createLifecycleController({
         directory,
         sessionID,
         messageID: limit(assistant.id, 200),
-        durationMs
-      })
+        durationMs,
+        conversation
+      }),
+      sessionID
     );
   }
   function handleMessage(event) {
@@ -1002,8 +1243,10 @@ function createLifecycleController({
         sessionID,
         correlation: limit(correlation, 200),
         attempt: status.attempt,
-        next: status.next
-      })
+        next: status.next,
+        conversation
+      }),
+      sessionID
     );
   }
   function handleError(event) {
@@ -1020,8 +1263,10 @@ function createLifecycleController({
         directory,
         sessionID,
         correlation: errorCorrelation(event, state),
-        error: event.properties?.error
-      })
+        error: event.properties?.error,
+        conversation
+      }),
+      sessionID
     );
   }
   function handleWaiting(event, waiting) {
@@ -1207,7 +1452,8 @@ function createPermissionController({
   config,
   reporter,
   client,
-  directory
+  directory,
+  conversation
 }) {
   const pendingByExternalID = /* @__PURE__ */ new Map();
   const externalIDByRequestID = /* @__PURE__ */ new Map();
@@ -1268,6 +1514,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);
     }
@@ -1282,12 +1529,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);
@@ -1350,7 +1604,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;
@@ -1360,18 +1615,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();
@@ -1402,8 +1660,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;
@@ -1421,8 +1683,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);
@@ -1438,8 +1704,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) => {
@@ -1449,6 +1719,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);
@@ -1473,6 +1744,7 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       lifecycleController.dispose();
       todoCompletionBySessionID.clear();
       publishedQuestions.clear();
+      conversation.dispose();
     }
   };
 }