backeer-opencode 0.2.3 → 0.2.5

package/dist/backeer-permission.js

@@ -158,6 +158,70 @@ function loadConfig(options = {}) {
   };
 }
 
+// src/delivery-tracker.js
+function createDeliveryTracker() {
+  const states = /* @__PURE__ */ new Map();
+  return {
+    begin(key) {
+      if (states.has(key)) return false;
+      rememberBounded(states, key, "publishing");
+      return true;
+    },
+    succeed(key) {
+      if (states.get(key) === "publishing") {
+        rememberBounded(states, key, "published");
+      }
+    },
+    fail(key) {
+      if (states.get(key) === "publishing") states.delete(key);
+    },
+    clear() {
+      states.clear();
+    }
+  };
+}
+function createCompletionTracker() {
+  const states = /* @__PURE__ */ new Map();
+  function stateFor(key) {
+    let state = states.get(key);
+    if (!state) {
+      state = { complete: false, publishing: false, revision: 0 };
+      rememberBounded(states, key, state);
+    }
+    return state;
+  }
+  return {
+    update(key, complete) {
+      const state = stateFor(key);
+      if (!complete) {
+        state.complete = false;
+        state.publishing = false;
+        state.revision++;
+        return;
+      }
+      if (state.complete || state.publishing) return;
+      state.publishing = true;
+      state.revision++;
+      return { key, revision: state.revision };
+    },
+    succeed(attempt) {
+      const state = states.get(attempt?.key);
+      if (!state || state.revision !== attempt.revision) return;
+      state.complete = true;
+      state.publishing = false;
+    },
+    fail(attempt) {
+      const state = states.get(attempt?.key);
+      if (!state || state.revision !== attempt.revision) return;
+      state.complete = false;
+      state.publishing = false;
+    },
+    clear() {
+      states.clear();
+    }
+  };
+}
+
 // src/http.js
 var RETRY_DELAYS_MS = [0, 500, 1500];
 var HttpError = class extends Error {
@@ -404,7 +468,7 @@ import { randomUUID } from "node:crypto";
 import { statSync } from "node:fs";
 
 // src/updates.js
-var PLUGIN_VERSION = "0.2.3";
+var PLUGIN_VERSION = "0.2.5";
 var PACKAGE_NAME = "backeer-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var CHECK_TIMEOUT_MS = 3e3;
@@ -642,150 +706,220 @@ 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");
+// src/feedback-session-store.js
+var MAX_QUEUED_MESSAGES = 20;
+var FeedbackSessionStore = class {
+  constructor({ send, reporter, flushDelayMs = 150 }) {
+    this.send = send;
+    this.reporter = reporter;
+    this.flushDelayMs = flushDelayMs;
+    this.sessions = /* @__PURE__ */ new Map();
+    this.disposed = false;
   }
-  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);
+  stateFor(sessionID) {
+    let state = this.sessions.get(sessionID);
     if (!state) {
       state = {
         idle: false,
         flushing: false,
         blockers: /* @__PURE__ */ new Set(),
         queue: [],
-        queued: /* @__PURE__ */ new Set()
+        queued: /* @__PURE__ */ new Set(),
+        queueOverflowReported: false,
+        flushTimer: void 0
       };
-      rememberBounded(sessions, sessionID, state);
+      rememberBounded(this.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;
+  hasReadyMessage(state) {
+    return !this.disposed && state.idle && state.blockers.size === 0 && state.queue.length > 0;
+  }
+  scheduleFlush(sessionID, state) {
+    if (state.flushTimer || !this.hasReadyMessage(state)) return;
+    state.flushTimer = setTimeout(() => {
+      state.flushTimer = void 0;
+      void this.flush(sessionID, state);
+    }, this.flushDelayMs);
+  }
+  async flush(sessionID, state) {
+    if (state.flushing || !this.hasReadyMessage(state)) return;
     state.flushing = true;
+    const items = state.queue.slice();
     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);
-        }
-      }
+      await this.send(sessionID, items);
+      state.queue.splice(0, items.length);
+      for (const item of items) state.queued.delete(item.key);
+    } catch (error) {
+      state.idle = false;
+      this.reporter.debug("Conversation feedback could not be displayed", error);
     } finally {
       state.flushing = false;
+      this.scheduleFlush(sessionID, state);
     }
   }
-  function enqueue(kind, sessionID, message) {
-    if (disposed || typeof sessionID !== "string" || !sessionID || !message) return;
-    const state = sessionState(sessionID);
+  enqueue(kind, sessionID, message) {
+    if (this.disposed || typeof sessionID !== "string" || !sessionID || !message) return;
+    const state = this.stateFor(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) {
+    if (state.queue.length > MAX_QUEUED_MESSAGES) {
       const removed = state.queue.shift();
       state.queued.delete(removed.key);
+      if (!state.queueOverflowReported) {
+        state.queueOverflowReported = true;
+        this.reporter.warning("Conversation feedback queue full \u2014 oldest message discarded");
+      }
     }
-    if (state.idle && state.blockers.size === 0) void flush(sessionID, state);
+    this.scheduleFlush(sessionID, state);
   }
-  function setIdle(sessionID, idle) {
+  setIdle(sessionID, idle) {
     if (typeof sessionID !== "string" || !sessionID) return;
-    const state = sessionState(sessionID);
+    const state = this.stateFor(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"}`;
+    if (idle) this.scheduleFlush(sessionID, state);
   }
-  function beginInteraction(sessionID, kind, event) {
-    const state = sessionState(sessionID);
+  beginInteraction(sessionID, key) {
+    const state = this.stateFor(sessionID);
     state.idle = false;
-    state.blockers.add(interactionKey(kind, event));
+    state.blockers.add(key);
   }
-  function endInteraction(sessionID, kind, event) {
-    const state = sessionState(sessionID);
-    const key = interactionKey(kind, event);
+  endInteraction(sessionID, key, kind) {
+    const state = this.stateFor(sessionID);
     if (!state.blockers.delete(key)) {
       const fallback = [...state.blockers].find((blocker) => blocker.startsWith(`${kind}:`));
       if (fallback) state.blockers.delete(fallback);
     }
     state.idle = false;
   }
+  failSession(sessionID) {
+    const state = this.stateFor(sessionID);
+    state.blockers.clear();
+    state.idle = false;
+  }
+  delete(sessionID) {
+    const state = this.sessions.get(sessionID);
+    if (state?.flushTimer) clearTimeout(state.flushTimer);
+    this.sessions.delete(sessionID);
+  }
+  dispose() {
+    this.disposed = true;
+    for (const state of this.sessions.values()) {
+      if (state.flushTimer) clearTimeout(state.flushTimer);
+    }
+    this.sessions.clear();
+  }
+};
+
+// 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"
+]);
+function interactionKey(kind, event) {
+  const value = event.properties?.requestID ?? event.properties?.id;
+  return `${kind}:${typeof value === "string" && value ? value : "pending"}`;
+}
+var INTERACTION_EVENTS = new Map([
+  ["permission.asked", { kind: "permission", phase: "begin" }],
+  ["permission.replied", { kind: "permission", phase: "end" }],
+  ...[...QUESTION_ASKED_EVENTS].map((type) => [type, { kind: "question", phase: "begin" }]),
+  ...[...QUESTION_REPLIED_EVENTS].map((type) => [type, { kind: "question", phase: "end" }])
+]);
+var SESSION_EVENT_HANDLERS = {
+  "session.status": (sessions, event, sessionID) => {
+    const status = event.properties?.status?.type;
+    if (status === "idle") sessions.setIdle(sessionID, true);
+    else if (status === "busy" || status === "retry") {
+      sessions.setIdle(sessionID, false);
+    }
+  },
+  "session.idle": (sessions, _event, sessionID) => {
+    sessions.setIdle(sessionID, true);
+  },
+  "todo.updated": (sessions, _event, sessionID) => {
+    sessions.setIdle(sessionID, false);
+  },
+  "session.error": (sessions, _event, sessionID) => {
+    sessions.failSession(sessionID);
+  },
+  "session.deleted": (sessions, _event, sessionID) => {
+    sessions.delete(sessionID);
+  }
+};
+function handleFeedbackEvent(sessions, event) {
+  const sessionID = event?.properties?.sessionID;
+  if (typeof sessionID !== "string") return;
+  const interaction = INTERACTION_EVENTS.get(event.type);
+  if (interaction) {
+    const key = interactionKey(interaction.kind, event);
+    if (interaction.phase === "begin") sessions.beginInteraction(sessionID, key);
+    else sessions.endInteraction(sessionID, key, interaction.kind);
+    return;
+  }
+  SESSION_EVENT_HANDLERS[event.type]?.(sessions, event, sessionID);
+}
+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 `\u25A3 Backeer | ${symbol} ${limit(message, 300)}`;
+}
+function formatBackeerFeedbackBatch(items) {
+  if (items.length === 1) {
+    return formatBackeerFeedback(items[0].kind, items[0].message);
+  }
+  return [
+    "\u25A3 Backeer",
+    ...items.map((item) => {
+      const symbol = FEEDBACK_SYMBOLS[item.kind] ?? FEEDBACK_SYMBOLS.info;
+      return `${symbol} ${limit(item.message, 300)}`;
+    })
+  ].join("\n");
+}
+function createConversationFeedback({ client, reporter, flushDelayMs = 150 }) {
+  const sessions = new FeedbackSessionStore({
+    reporter,
+    flushDelayMs,
+    send: (sessionID, items) => sendSessionMessage(
+      client,
+      sessionID,
+      formatBackeerFeedbackBatch(items)
+    )
+  });
   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),
+    info: (sessionID, message) => sessions.enqueue("info", sessionID, message),
+    success: (sessionID, message) => sessions.enqueue("success", sessionID, message),
+    applied: (sessionID, message) => sessions.enqueue("applied", sessionID, message),
+    warning: (sessionID, message) => sessions.enqueue("warning", sessionID, message),
+    error: (sessionID, message) => sessions.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);
-      }
+      handleFeedbackEvent(sessions, event);
     },
     dispose() {
-      disposed = true;
-      sessions.clear();
+      sessions.dispose();
     }
   };
 }
@@ -1351,6 +1485,59 @@ function createLifecycleController({
   };
 }
 
+// src/permission-command.js
+var ALLOWED_DECISIONS = /* @__PURE__ */ new Set(["once", "always", "reject"]);
+var DECISION_LABELS = {
+  once: "Allow once",
+  always: "Always allow",
+  reject: "Reject"
+};
+function validatePermissionCommand(command, now = Date.now()) {
+  if (!ALLOWED_DECISIONS.has(command.decision)) {
+    return {
+      status: "rejected",
+      decision: command.decision,
+      errorCode: "invalid_decision"
+    };
+  }
+  const expiresAt = Date.parse(command.expiresAt);
+  if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+    return { status: "expired", decision: command.decision };
+  }
+  if (command.decision === "always" && command.confirmed !== true) {
+    return {
+      status: "rejected",
+      decision: command.decision,
+      errorCode: "confirmation_required"
+    };
+  }
+}
+function failureAcknowledgement(command, error) {
+  const stale = error instanceof HttpError && error.status === 404;
+  return {
+    status: stale ? "stale" : "failed",
+    decision: command.decision,
+    errorCode: stale ? "permission_not_found" : "opencode_reply_failed"
+  };
+}
+function reportAcknowledgement(acknowledgement, pending, reporter, conversation) {
+  const messages = {
+    applied: `Decision applied: ${DECISION_LABELS[acknowledgement.decision]}`,
+    expired: "Decision expired before it could be applied",
+    stale: "Permission was already answered locally",
+    rejected: "Decision was rejected by validation"
+  };
+  const message = messages[acknowledgement.status];
+  if (!message) return;
+  if (acknowledgement.status === "applied") {
+    reporter.applied(message);
+    conversation?.applied(pending.sessionID, message);
+    return;
+  }
+  reporter.warning(message);
+  conversation?.warning(pending.sessionID, message);
+}
+
 // src/sse.js
 function parseSseFrame(frame) {
   const data = [];
@@ -1395,6 +1582,7 @@ async function consumeSse(response, state, onCommand, signal, reporter) {
         const next = nextSseFrame(buffer);
         if (!next) break;
         buffer = next.rest;
+        state.framesReceived = (state.framesReceived ?? 0) + 1;
         const message = parseSseFrame(next.frame);
         if (!message) continue;
         if (message.id) state.lastEventID = message.id;
@@ -1415,64 +1603,109 @@ async function consumeSse(response, state, onCommand, signal, reporter) {
     });
   }
 }
-async function runCommandStream(config, reporter, { signal, hasPending, onCommand }) {
-  const state = { lastEventID: "" };
+async function openCommandStream(config, state, signal, fetchImplementation) {
+  const headers = {
+    Accept: "text/event-stream",
+    Authorization: `Bearer ${config.token}`
+  };
+  if (state.lastEventID) headers["Last-Event-ID"] = state.lastEventID;
+  const response = await fetchImplementation(config.commandStreamEndpoint, {
+    headers,
+    signal
+  });
+  if (!response.ok) {
+    const responseBody = limit(await response.text(), 500);
+    throw new HttpError(
+      `Backeer command stream failed with status ${response.status}`,
+      response.status,
+      responseBody
+    );
+  }
+  if (!response.headers.get("content-type")?.includes("text/event-stream")) {
+    throw new Error("Backeer command stream returned an invalid content type");
+  }
+  return response;
+}
+async function consumeConnection({
+  response,
+  state,
+  onCommand,
+  signal,
+  reporter,
+  now,
+  stableConnectionMs,
+  onStable
+}) {
+  const connectedAt = now();
+  const framesBeforeConnection = state.framesReceived;
+  try {
+    await consumeSse(response, state, onCommand, signal, reporter);
+  } finally {
+    const receivedFrame = state.framesReceived > framesBeforeConnection;
+    if (receivedFrame || now() - connectedAt >= stableConnectionMs) onStable();
+  }
+}
+function streamErrorState(error, lastLoggedError, reconnectDelay, reporter) {
+  const message = error instanceof HttpError ? `${error.message}: ${error.responseBody}` : limit(error, 500);
+  if (message !== lastLoggedError) {
+    const authenticationFailure = error instanceof HttpError && [401, 403].includes(error.status);
+    reporter.error(
+      authenticationFailure ? "Authentication failed \u2014 run: npx backeer-opencode@latest configure" : "Connection interrupted \u2014 retrying",
+      message
+    );
+  }
+  return {
+    lastLoggedError: message,
+    reconnectDelay: error instanceof HttpError && [401, 403, 404].includes(error.status) ? 6e4 : reconnectDelay
+  };
+}
+async function runCommandStream(config, reporter, {
+  signal,
+  hasPending,
+  onCommand,
+  fetchImplementation = fetch,
+  sleepImplementation = sleep,
+  now = Date.now,
+  stableConnectionMs = 5e3
+}) {
+  const state = { lastEventID: "", framesReceived: 0 };
   let reconnectDelay = 1e3;
   let lastLoggedError = "";
   while (!signal.aborted && hasPending()) {
     try {
-      const headers = {
-        Accept: "text/event-stream",
-        Authorization: `Bearer ${config.token}`
-      };
-      if (state.lastEventID) headers["Last-Event-ID"] = state.lastEventID;
-      const response = await fetch(config.commandStreamEndpoint, {
-        headers,
-        signal
+      const response = await openCommandStream(
+        config,
+        state,
+        signal,
+        fetchImplementation
+      );
+      await consumeConnection({
+        response,
+        state,
+        onCommand,
+        signal,
+        reporter,
+        now,
+        stableConnectionMs,
+        onStable: () => {
+          reconnectDelay = 1e3;
+          lastLoggedError = "";
+        }
       });
-      if (!response.ok) {
-        const responseBody = limit(await response.text(), 500);
-        throw new HttpError(
-          `Backeer command stream failed with status ${response.status}`,
-          response.status,
-          responseBody
-        );
-      }
-      if (!response.headers.get("content-type")?.includes("text/event-stream")) {
-        throw new Error("Backeer command stream returned an invalid content type");
-      }
-      reconnectDelay = 1e3;
-      lastLoggedError = "";
-      await consumeSse(response, state, onCommand, signal, reporter);
     } catch (error) {
       if (signal.aborted || isAbortError(error)) return;
-      const message = error instanceof HttpError ? `${error.message}: ${error.responseBody}` : limit(error, 500);
-      if (message !== lastLoggedError) {
-        const authenticationFailure = error instanceof HttpError && [401, 403].includes(error.status);
-        reporter.error(
-          authenticationFailure ? "Authentication failed \u2014 run: npx backeer-opencode@latest configure" : "Connection interrupted \u2014 retrying",
-          message
-        );
-        lastLoggedError = message;
-      }
-      if (error instanceof HttpError && [401, 403, 404].includes(error.status)) {
-        reconnectDelay = 6e4;
-      }
+      const next = streamErrorState(error, lastLoggedError, reconnectDelay, reporter);
+      reconnectDelay = next.reconnectDelay;
+      lastLoggedError = next.lastLoggedError;
     }
     if (!signal.aborted && hasPending()) {
-      await sleep(reconnectDelay, signal);
+      await sleepImplementation(reconnectDelay, signal);
       reconnectDelay = Math.min(reconnectDelay * 2, 6e4);
     }
   }
 }
 
 // src/permission-controller.js
-var ALLOWED_DECISIONS = /* @__PURE__ */ new Set(["once", "always", "reject"]);
-var DECISION_LABELS = {
-  once: "Allow once",
-  always: "Always allow",
-  reject: "Reject"
-};
 async function replyToOpenCode(client, pending, decision) {
   const result = await client.postSessionIdPermissionsPermissionId({
     path: { id: pending.sessionID, permissionID: pending.requestID },
@@ -1502,7 +1735,6 @@ function createPermissionController({
   const externalIDByRequestID = /* @__PURE__ */ new Map();
   const processingCommands = /* @__PURE__ */ new Set();
   const completedCommands = /* @__PURE__ */ new Map();
-  const publishedPermissions = /* @__PURE__ */ new Map();
   let commandStream;
   let disposed = false;
   function removePendingByRequestID(requestID) {
@@ -1528,34 +1760,18 @@ function createPermissionController({
     const pending = pendingByExternalID.get(command.externalId);
     if (!pending) return;
     processingCommands.add(command.id);
-    let acknowledgement;
+    let acknowledgement = validatePermissionCommand(command);
     try {
-      if (!ALLOWED_DECISIONS.has(command.decision)) {
-        acknowledgement = { status: "rejected", errorCode: "invalid_decision" };
-      } else {
-        const expiresAt = Date.parse(command.expiresAt);
-        if (!Number.isFinite(expiresAt) || expiresAt <= Date.now()) {
-          acknowledgement = { status: "expired", decision: command.decision };
-        } else if (command.decision === "always" && command.confirmed !== true) {
-          acknowledgement = {
-            status: "rejected",
-            decision: command.decision,
-            errorCode: "confirmation_required"
-          };
-        } else {
-          await replyToOpenCode(client, pending, command.decision);
-          acknowledgement = { status: "applied", decision: command.decision };
-          removePendingByRequestID(pending.requestID);
-        }
+      if (!acknowledgement) {
+        await replyToOpenCode(client, pending, command.decision);
+        acknowledgement = { status: "applied", decision: command.decision };
+        removePendingByRequestID(pending.requestID);
       }
     } catch (error) {
-      const stale = error instanceof HttpError && error.status === 404;
-      acknowledgement = {
-        status: stale ? "stale" : "failed",
-        decision: ALLOWED_DECISIONS.has(command.decision) ? command.decision : void 0,
-        errorCode: stale ? "permission_not_found" : "opencode_reply_failed"
-      };
-      if (stale) removePendingByRequestID(pending.requestID);
+      acknowledgement = failureAcknowledgement(command, error);
+      if (acknowledgement.status === "stale") {
+        removePendingByRequestID(pending.requestID);
+      }
       reporter.error("Decision could not be applied", error);
       conversation?.error(pending.sessionID, "Decision could not be applied");
     } finally {
@@ -1568,24 +1784,7 @@ function createPermissionController({
       processedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     rememberBounded(completedCommands, command.id, acknowledgement);
-    if (acknowledgement.status === "applied") {
-      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");
-    }
+    reportAcknowledgement(acknowledgement, pending, reporter, conversation);
     await acknowledgeCommand(config, command.id, acknowledgement).catch((error) => {
       reporter.warning("Decision receipt could not be sent", error);
     });
@@ -1613,9 +1812,6 @@ function createPermissionController({
       pendingByExternalID.set(identity.externalId, { ...identity, directory });
       externalIDByRequestID.set(identity.requestID, identity.externalId);
       ensureCommandStream();
-      if (publishedPermissions.has(identity.externalId)) return false;
-      rememberBounded(publishedPermissions, identity.externalId, true);
-      return true;
     },
     resolveLocally(requestID) {
       removePendingByRequestID(requestID);
@@ -1640,7 +1836,6 @@ function createPermissionController({
       externalIDByRequestID.clear();
       processingCommands.clear();
       completedCommands.clear();
-      publishedPermissions.clear();
     }
   };
 }
@@ -1674,8 +1869,9 @@ async function BackeerPlugin({ client, directory }, options = {}) {
     directory,
     conversation
   });
-  const todoCompletionBySessionID = /* @__PURE__ */ new Map();
-  const publishedQuestions = /* @__PURE__ */ new Map();
+  const permissionPublications = createDeliveryTracker();
+  const questionPublications = createDeliveryTracker();
+  const todoCompletions = createCompletionTracker();
   const updateChecker = createUpdateChecker();
   const handleBackeerCommand = createBackeerCommandHandler({
     client,
@@ -1697,7 +1893,8 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       reporter.error("Permission event is missing correlation IDs");
       return;
     }
-    if (!permissionController.register(identity)) return;
+    permissionController.register(identity);
+    if (!permissionPublications.begin(identity.externalId)) return;
     void publishPermission(
       config,
       reporter,
@@ -1705,7 +1902,8 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       directory,
       identity,
       conversation
-    ).catch((error) => {
+    ).then(() => permissionPublications.succeed(identity.externalId)).catch((error) => {
+      permissionPublications.fail(identity.externalId);
       reporter.error("Permission request could not be sent", error);
       conversation.error(identity.sessionID, "Permission request could not be sent");
     });
@@ -1717,9 +1915,8 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       return;
     }
     const isComplete = todos.length > 0 && todos.every((todo) => todo?.status === "completed");
-    const wasComplete = todoCompletionBySessionID.get(sessionID) === true;
-    rememberBounded(todoCompletionBySessionID, sessionID, isComplete);
-    if (!isComplete || wasComplete) return;
+    const attempt = todoCompletions.update(sessionID, isComplete);
+    if (!attempt) return;
     void publishTodoCompletion(
       config,
       reporter,
@@ -1728,7 +1925,8 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       client,
       directory,
       conversation
-    ).catch((error) => {
+    ).then(() => todoCompletions.succeed(attempt)).catch((error) => {
+      todoCompletions.fail(attempt);
       reporter.error("Todo completion could not be sent", error);
       conversation.error(sessionID, "Todo completion could not be sent");
     });
@@ -1739,8 +1937,7 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       reporter.error("Question event is missing correlation IDs");
       return;
     }
-    if (publishedQuestions.has(identity.externalId)) return;
-    rememberBounded(publishedQuestions, identity.externalId, true);
+    if (!questionPublications.begin(identity.externalId)) return;
     void publishQuestion(
       config,
       reporter,
@@ -1749,7 +1946,8 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       client,
       directory,
       conversation
-    ).catch((error) => {
+    ).then(() => questionPublications.succeed(identity.externalId)).catch((error) => {
+      questionPublications.fail(identity.externalId);
       reporter.error("Question could not be sent", error);
       conversation.error(identity.sessionID, "Question could not be sent");
     });
@@ -1785,8 +1983,9 @@ async function BackeerPlugin({ client, directory }, options = {}) {
     dispose: async () => {
       await permissionController.dispose();
       lifecycleController.dispose();
-      todoCompletionBySessionID.clear();
-      publishedQuestions.clear();
+      permissionPublications.clear();
+      questionPublications.clear();
+      todoCompletions.clear();
       conversation.dispose();
     }
   };