backeer-opencode 0.1.4 → 0.2.0

package/dist/backeer-permission.js

@@ -77,6 +77,43 @@ function createConsoleReporter(levelValue) {
 
 // src/config.js
 var DEFAULT_ORIGIN = "https://external-gateway.backeer.com";
+function integer(value, fallback, { minimum = 0, maximum = 86400 } = {}) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < minimum || parsed > maximum) {
+    throw new Error(`Expected an integer between ${minimum} and ${maximum}`);
+  }
+  return parsed;
+}
+function loadLifecycleConfig(option) {
+  const values = option && typeof option === "object" ? option : {};
+  const masterValue = typeof option === "boolean" ? option : values.enabled ?? process.env.BACKEER_NOTIFY_LIFECYCLE;
+  const masterEnabled = enabled(masterValue);
+  return {
+    enabled: masterEnabled,
+    completed: masterEnabled && enabled(
+      values.completed ?? process.env.BACKEER_NOTIFY_SESSION_COMPLETED
+    ),
+    errors: masterEnabled && enabled(
+      values.errors ?? process.env.BACKEER_NOTIFY_SESSION_ERRORS
+    ),
+    retries: masterEnabled && enabled(
+      values.retries ?? process.env.BACKEER_NOTIFY_SESSION_RETRIES
+    ),
+    updates: masterEnabled && enabled(
+      values.updates ?? process.env.BACKEER_NOTIFY_OPENCODE_UPDATES
+    ),
+    completionMinSeconds: integer(
+      values.completionMinSeconds ?? process.env.BACKEER_SESSION_COMPLETION_MIN_SECONDS,
+      0
+    ),
+    retryAttemptThreshold: integer(
+      values.retryAttemptThreshold ?? process.env.BACKEER_RETRY_ATTEMPT_THRESHOLD,
+      3,
+      { minimum: 1, maximum: 100 }
+    )
+  };
+}
 function defaultConfigDirectory() {
   const base = process.env.XDG_CONFIG_HOME?.trim();
   return base ? join(base, "opencode") : join(homedir(), ".config", "opencode");
@@ -114,6 +151,7 @@ function loadConfig(options = {}) {
       options.questions ?? process.env.BACKEER_NOTIFY_QUESTIONS
     ),
     todos: enabled(options.todos ?? process.env.BACKEER_NOTIFY_TODOS),
+    lifecycle: loadLifecycleConfig(options.lifecycle),
     logLevel: normalizeLogLevel(
       options.logLevel ?? process.env.BACKEER_LOG_LEVEL
     )
@@ -357,8 +395,130 @@ import {
   writeFileSync
 } from "node:fs";
 import { dirname, resolve } from "node:path";
-var PLUGIN_VERSION = "0.1.4";
-var COMMAND_DESCRIPTION = "Show Backeer status or manage its token: /backeer [status|token|token-file PATH]";
+
+// src/updates.js
+var PLUGIN_VERSION = "0.2.0";
+var PACKAGE_NAME = "backeer-opencode";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org";
+var CHECK_TIMEOUT_MS = 3e3;
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function parseVersion(value) {
+  const match = String(value).trim().match(
+    /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/
+  );
+  if (!match) return;
+  return {
+    parts: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4]
+  };
+}
+function isVersionNewer(latestValue, currentValue) {
+  const latest = parseVersion(latestValue);
+  const current = parseVersion(currentValue);
+  if (!latest || !current) return false;
+  for (let index = 0; index < 3; index++) {
+    if (latest.parts[index] > current.parts[index]) return true;
+    if (latest.parts[index] < current.parts[index]) return false;
+  }
+  if (!latest.prerelease && current.prerelease) return true;
+  if (latest.prerelease && !current.prerelease) return false;
+  return Boolean(
+    latest.prerelease && current.prerelease && latest.prerelease !== current.prerelease
+  );
+}
+function createUpdateChecker({
+  fetchImplementation = globalThis.fetch,
+  now = () => Date.now()
+} = {}) {
+  let checkedAt = 0;
+  let cachedResult;
+  let pendingCheck;
+  async function fetchLatest() {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
+    try {
+      const response = await fetchImplementation(
+        `${NPM_REGISTRY_URL}/${PACKAGE_NAME}/latest`,
+        { signal: controller.signal }
+      );
+      if (!response.ok) return { state: "unavailable", currentVersion: PLUGIN_VERSION };
+      const data = await response.json();
+      const latestVersion = typeof data?.version === "string" ? data.version.trim() : "";
+      if (!parseVersion(latestVersion)) {
+        return { state: "unavailable", currentVersion: PLUGIN_VERSION };
+      }
+      if (!isVersionNewer(latestVersion, PLUGIN_VERSION)) {
+        return {
+          state: "current",
+          currentVersion: PLUGIN_VERSION,
+          latestVersion
+        };
+      }
+      return {
+        state: "available",
+        currentVersion: PLUGIN_VERSION,
+        latestVersion,
+        updateCommand: `opencode plugin ${PACKAGE_NAME}@${latestVersion} -g --force`
+      };
+    } catch {
+      return { state: "unavailable", currentVersion: PLUGIN_VERSION };
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  return {
+    async check({ force = false } = {}) {
+      if (!force && checkedAt && now() - checkedAt < CHECK_INTERVAL_MS) {
+        return cachedResult;
+      }
+      if (pendingCheck) return pendingCheck;
+      pendingCheck = fetchLatest().then((result) => {
+        cachedResult = result;
+        checkedAt = now();
+        return result;
+      }).finally(() => {
+        pendingCheck = void 0;
+      });
+      return pendingCheck;
+    }
+  };
+}
+function formatAgentUpdateInstruction(info) {
+  return [
+    "[BACKEER UPDATE REQUESTED]",
+    `The user explicitly requested the Backeer OpenCode plugin update from v${info.currentVersion} to v${info.latestVersion}.`,
+    `Run exactly: ${info.updateCommand}`,
+    "Then verify that the global OpenCode config is pinned to the exact new version and that the matching package exists in the OpenCode cache.",
+    "Do not read, print, replace, or otherwise expose the Backeer token.",
+    "Do not use @latest and do not claim success until both installation and verification pass.",
+    "Do not terminate the active OpenCode process; tell the user to restart OpenCode after success."
+  ].join("\n");
+}
+function createUpdateNoticeHook(updateChecker) {
+  const notifiedSessions = /* @__PURE__ */ new Set();
+  return async (input, output) => {
+    if (notifiedSessions.has(input.sessionID)) return;
+    notifiedSessions.add(input.sessionID);
+    const info = await updateChecker.check();
+    if (info.state !== "available") return;
+    output.parts.push({
+      id: `prt_backeer-update-${Date.now()}`,
+      sessionID: input.sessionID,
+      messageID: output.message.id,
+      type: "text",
+      synthetic: true,
+      text: [
+        "[BACKEER UPDATE AVAILABLE]",
+        `Backeer OpenCode plugin v${info.latestVersion} is available; current version is v${info.currentVersion}.`,
+        "Inform the user that an update is available and suggest `/backeer update`.",
+        "Do not install it solely because of this notice."
+      ].join("\n")
+    });
+  };
+}
+
+// src/management.js
+var COMMAND_DESCRIPTION = "Show Backeer status, update it, or manage its token: /backeer [status|update-check|update|token|token-file PATH]";
 function tokenFileState(path) {
   try {
     const stats = statSync(path);
@@ -418,19 +578,35 @@ async function probeGateway(config) {
     clearTimeout(timeout);
   }
 }
-async function buildStatus(config, permissionController) {
-  const gateway = await probeGateway(config);
+function updateStatus(info) {
+  if (info.state === "available") {
+    return `v${info.latestVersion} available \u2014 use /backeer update`;
+  }
+  if (info.state === "current") return `current (v${info.currentVersion})`;
+  return "check unavailable";
+}
+async function buildStatus(config, permissionController, updateChecker) {
+  const [gateway, update] = await Promise.all([
+    probeGateway(config),
+    updateChecker.check()
+  ]);
   const permissionStatus = permissionController.status();
   return [
     "## Backeer status",
     "",
     `- Plugin version: ${PLUGIN_VERSION}`,
+    `- Update: ${updateStatus(update)}`,
     `- Gateway: ${config.origin.origin} \u2014 ${gateway}`,
     `- Token: ${config.token ? `configured via ${config.tokenSource}` : "missing"}`,
     `- Token file: ${config.tokenFile} \u2014 ${tokenFileState(config.tokenFile)}`,
     `- Permission notifications: ${config.permissions ? "enabled" : "disabled"}`,
     `- Question notifications: ${config.questions ? "enabled" : "disabled"}`,
     `- Todo notifications: ${config.todos ? "enabled" : "disabled"}`,
+    `- Lifecycle notifications: ${config.lifecycle.enabled ? "enabled" : "disabled"}`,
+    `  - Completed sessions: ${config.lifecycle.completed ? "enabled" : "disabled"} (minimum ${config.lifecycle.completionMinSeconds}s)`,
+    `  - Session errors: ${config.lifecycle.errors ? "enabled" : "disabled"}`,
+    `  - Retry warnings: ${config.lifecycle.retries ? "enabled" : "disabled"} (attempt ${config.lifecycle.retryAttemptThreshold}+)`,
+    `  - OpenCode updates: ${config.lifecycle.updates ? "enabled" : "disabled"}`,
     `- Command stream: ${permissionStatus.stream}`,
     `- Pending permissions: ${permissionStatus.pending}`,
     `- Log level: ${config.logLevel}`,
@@ -443,6 +619,8 @@ function helpMessage() {
     "## Backeer commands",
     "",
     "- `/backeer` or `/backeer status` \u2014 show integration status",
+    "- `/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",
     "- `/backeer token-file /absolute/protected/path` \u2014 import and activate a token",
     "",
@@ -486,7 +664,8 @@ function createBackeerCommandHandler({
   client,
   config,
   permissionController,
-  reporter
+  reporter,
+  updateChecker
 }) {
   return async (input, output) => {
     if (input.command !== "backeer") return;
@@ -498,7 +677,26 @@ function createBackeerCommandHandler({
     let message;
     try {
       if (!subcommand || subcommand === "status") {
-        message = await buildStatus(config, permissionController);
+        message = await buildStatus(config, permissionController, updateChecker);
+      } else if (subcommand === "update-check") {
+        const update = await updateChecker.check({ force: true });
+        message = [
+          "## Backeer update check",
+          "",
+          update.state === "available" ? `Version ${update.latestVersion} is available; current version is ${update.currentVersion}. Use \`/backeer update\` to let the OpenCode agent install and verify it.` : update.state === "current" ? `Backeer is current at version ${update.currentVersion}.` : "The NPM registry could not be reached. No update was attempted."
+        ].join("\n");
+      } else if (subcommand === "update") {
+        const update = await updateChecker.check({ force: true });
+        if (update.state === "available") {
+          output.parts.push({
+            type: "text",
+            text: formatAgentUpdateInstruction(update)
+          });
+          return;
+        }
+        message = update.state === "current" ? `## Backeer update
+
+Backeer is already current at version ${update.currentVersion}.` : "## Backeer update\n\nThe NPM registry could not be reached. No update was attempted.";
       } else if (subcommand === "token") {
         message = tokenInstructions();
       } else if (subcommand === "token-file") {
@@ -529,6 +727,342 @@ function createBackeerCommandHandler({
   };
 }
 
+// src/lifecycle-publishers.js
+var CONTROL_CHARACTERS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g;
+var SECRET_ASSIGNMENT = /\b(token|secret|password|api[-_ ]?key)\s*[:=]\s*[^\s,;]+/gi;
+var BEARER_TOKEN = /\bBearer\s+[^\s,;]+/gi;
+var URL_WITH_QUERY = /\bhttps?:\/\/[^\s?#]+(?:\?[^\s#]*)?(?:#[^\s]*)?/gi;
+var WINDOWS_PATH = /\b[A-Za-z]:\\(?:[^\\\s]+\\)+[^\s]*/g;
+var POSIX_PATH = /(^|\s)\/(?:[^/\s]+\/)+[^\s]*/g;
+function sanitizeErrorMessage(value) {
+  return limit(value, 2e3).replace(CONTROL_CHARACTERS, " ").replace(BEARER_TOKEN, "Bearer [redacted]").replace(SECRET_ASSIGNMENT, "$1=[redacted]").replace(URL_WITH_QUERY, (value2) => {
+    try {
+      const url = new URL(value2);
+      return `${url.origin}${url.pathname}`;
+    } catch {
+      return "[url redacted]";
+    }
+  }).replace(WINDOWS_PATH, "[path redacted]").replace(POSIX_PATH, "$1[path redacted]").replace(/\s+/g, " ").trim().slice(0, 500);
+}
+function safeErrorDetails(error) {
+  const name = limit(error?.name || "OpenCodeError", 100);
+  const message = sanitizeErrorMessage(error?.data?.message ?? error?.message);
+  const statusCode = Number.isInteger(error?.data?.statusCode) ? String(error.data.statusCode) : "";
+  return { name, message, statusCode };
+}
+async function resolveSessionTitle2(client, directory, sessionID, reporter) {
+  if (!sessionID || typeof client?.session?.get !== "function") return "";
+  try {
+    const result = await client.session.get({
+      path: { id: sessionID },
+      query: { directory },
+      throwOnError: true
+    });
+    return limit((result?.data ?? result)?.title);
+  } catch (error) {
+    reporter.debug("Session title unavailable", error);
+    return "";
+  }
+}
+async function publish(config, reporter, event, feedback) {
+  const result = await postJsonWithRetry(config, config.eventsEndpoint, {
+    type: "application",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    notify: true,
+    direction: "in",
+    ...event
+  });
+  reporter.success(feedback, `HTTP ${result.status}`);
+}
+function secondsLabel(durationMs) {
+  const seconds = Math.max(0, Math.round(durationMs / 1e3));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainder = seconds % 60;
+  return remainder ? `${minutes}m ${remainder}s` : `${minutes}m`;
+}
+async function publishSessionCompleted({
+  config,
+  reporter,
+  client,
+  directory,
+  sessionID,
+  messageID,
+  durationMs
+}) {
+  const sessionTitle = await resolveSessionTitle2(
+    client,
+    directory,
+    sessionID,
+    reporter
+  );
+  const duration = secondsLabel(durationMs);
+  const location = sessionTitle ? ` \u201C${sessionTitle}\u201D` : "";
+  await publish(config, reporter, {
+    severity: "info",
+    title: "OpenCode task completed",
+    body: `OpenCode finished${location} in ${duration}.`,
+    payload: [
+      { key: "OpenCode session", value: sessionTitle },
+      { key: "Outcome", value: "Completed" },
+      { key: "Duration", value: duration }
+    ].filter((item) => item.value),
+    externalId: `opencode:lifecycle:completed:${sessionID}:${messageID}`
+  }, "Task completion sent");
+}
+async function publishSessionRetry({
+  config,
+  reporter,
+  client,
+  directory,
+  sessionID,
+  correlation,
+  attempt,
+  next
+}) {
+  const sessionTitle = await resolveSessionTitle2(
+    client,
+    directory,
+    sessionID,
+    reporter
+  );
+  const retryAt = Number.isFinite(next) ? new Date(next).toISOString() : "";
+  await publish(config, reporter, {
+    severity: "warning",
+    title: "OpenCode is retrying",
+    body: `OpenCode reached retry attempt ${attempt}. The operation is still running.`,
+    payload: [
+      { key: "OpenCode session", value: sessionTitle },
+      { key: "Retry attempt", value: String(attempt) },
+      { key: "Next retry", value: retryAt }
+    ].filter((item) => item.value),
+    externalId: `opencode:lifecycle:retry:${sessionID}:${correlation}`
+  }, "Retry warning sent");
+}
+async function publishSessionError({
+  config,
+  reporter,
+  client,
+  directory,
+  sessionID,
+  correlation,
+  error
+}) {
+  const sessionTitle = await resolveSessionTitle2(
+    client,
+    directory,
+    sessionID,
+    reporter
+  );
+  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, {
+    // Backeer/iOS currently support info, warning and critical severities.
+    severity: "critical",
+    title: "OpenCode task failed",
+    body: limit(body, 1e3),
+    payload: [
+      { key: "OpenCode session", value: sessionTitle },
+      { key: "Outcome", value: "Failed" },
+      { key: "Error type", value: details.name },
+      { key: "HTTP status", value: details.statusCode },
+      { key: "Error", value: details.message }
+    ].filter((item) => item.value),
+    externalId: `opencode:lifecycle:error:${sessionID || "global"}:${correlation}`
+  }, "Task failure sent");
+}
+async function publishOpenCodeUpdate({ config, reporter, version }) {
+  const safeVersion = limit(version, 100);
+  await publish(config, reporter, {
+    severity: "info",
+    title: "OpenCode update available",
+    body: `OpenCode ${safeVersion} is available.`,
+    payload: [{ key: "Available version", value: safeVersion }],
+    externalId: `opencode:lifecycle:update:${safeVersion}`
+  }, "OpenCode update sent");
+}
+function errorCorrelation(event, sessionState) {
+  if (typeof event?.id === "string" && event.id) return limit(event.id, 200);
+  if (sessionState?.lastAssistant?.id) return limit(sessionState.lastAssistant.id, 200);
+  const details = safeErrorDetails(event?.properties?.error);
+  return stableHash(`${details.name}:${details.statusCode}:${details.message}`);
+}
+
+// src/lifecycle-controller.js
+var QUESTION_EVENTS = /* @__PURE__ */ new Set(["question.asked", "question.v2.asked"]);
+var QUESTION_REPLY_EVENTS = /* @__PURE__ */ new Set([
+  "question.replied",
+  "question.v2.replied",
+  "question.answered",
+  "question.v2.answered"
+]);
+function createLifecycleController({
+  config,
+  reporter,
+  client,
+  directory,
+  now = () => Date.now(),
+  publishers = {}
+}) {
+  const sendCompleted = publishers.completed ?? publishSessionCompleted;
+  const sendError = publishers.error ?? publishSessionError;
+  const sendRetry = publishers.retry ?? publishSessionRetry;
+  const sendUpdate = publishers.update ?? publishOpenCodeUpdate;
+  const sessions = /* @__PURE__ */ new Map();
+  const publishedUpdates = /* @__PURE__ */ new Map();
+  function sessionState(sessionID) {
+    let state = sessions.get(sessionID);
+    if (!state) {
+      state = {
+        busy: false,
+        busySince: 0,
+        failed: false,
+        retryNotified: false,
+        waiting: false,
+        lastAssistant: void 0,
+        completedMessageID: ""
+      };
+      rememberBounded(sessions, sessionID, state);
+    }
+    return state;
+  }
+  function dispatch(label, operation) {
+    void Promise.resolve(operation).catch((error) => reporter.error(label, error));
+  }
+  function beginCycle(state) {
+    if (state.busy) return;
+    state.busy = true;
+    state.busySince = now();
+    state.failed = false;
+    state.retryNotified = false;
+    state.waiting = false;
+    state.lastAssistant = void 0;
+  }
+  function finishCycle(sessionID, state) {
+    if (!state.busy) return;
+    state.busy = false;
+    const assistant = state.lastAssistant;
+    const durationMs = Math.max(0, now() - state.busySince);
+    const qualifies = assistant?.id && assistant.completed && !assistant.error && !state.failed && !state.waiting && durationMs >= config.lifecycle.completionMinSeconds * 1e3 && state.completedMessageID !== assistant.id;
+    if (!qualifies || !config.lifecycle.completed) return;
+    state.completedMessageID = assistant.id;
+    dispatch(
+      "Task completion could not be sent",
+      sendCompleted({
+        config,
+        reporter,
+        client,
+        directory,
+        sessionID,
+        messageID: limit(assistant.id, 200),
+        durationMs
+      })
+    );
+  }
+  function handleMessage(event) {
+    const info = event.properties?.info;
+    if (info?.role !== "assistant" || typeof info.sessionID !== "string") return;
+    const state = sessionState(info.sessionID);
+    state.lastAssistant = {
+      id: typeof info.id === "string" ? info.id : "",
+      completed: Number.isFinite(info.time?.completed),
+      error: Boolean(info.error)
+    };
+    if (info.error) state.failed = true;
+  }
+  function handleStatus(event) {
+    const sessionID = event.properties?.sessionID;
+    const status = event.properties?.status;
+    if (typeof sessionID !== "string" || typeof status?.type !== "string") return;
+    const state = sessionState(sessionID);
+    if (status.type === "busy") {
+      beginCycle(state);
+      return;
+    }
+    if (status.type === "idle") {
+      finishCycle(sessionID, state);
+      return;
+    }
+    if (status.type !== "retry") return;
+    beginCycle(state);
+    if (!config.lifecycle.retries || state.retryNotified) return;
+    if (!Number.isInteger(status.attempt) || status.attempt < config.lifecycle.retryAttemptThreshold) return;
+    state.retryNotified = true;
+    const correlation = state.lastAssistant?.id || stableHash(
+      `${status.attempt}:${Number.isFinite(status.next) ? status.next : "unknown"}`
+    );
+    dispatch(
+      "Retry warning could not be sent",
+      sendRetry({
+        config,
+        reporter,
+        client,
+        directory,
+        sessionID,
+        correlation: limit(correlation, 200),
+        attempt: status.attempt,
+        next: status.next
+      })
+    );
+  }
+  function handleError(event) {
+    const sessionID = typeof event.properties?.sessionID === "string" ? event.properties.sessionID : "";
+    const state = sessionID ? sessionState(sessionID) : void 0;
+    if (state) state.failed = true;
+    if (!config.lifecycle.errors) return;
+    dispatch(
+      "Task failure could not be sent",
+      sendError({
+        config,
+        reporter,
+        client,
+        directory,
+        sessionID,
+        correlation: errorCorrelation(event, state),
+        error: event.properties?.error
+      })
+    );
+  }
+  function handleWaiting(event, waiting) {
+    const sessionID = event.properties?.sessionID;
+    if (typeof sessionID !== "string") return;
+    sessionState(sessionID).waiting = waiting;
+  }
+  return {
+    handle(event) {
+      if (!config.lifecycle.enabled || !event?.type) return;
+      if (event.type === "message.updated") {
+        handleMessage(event);
+      } else if (event.type === "session.status") {
+        handleStatus(event);
+      } else if (event.type === "session.idle") {
+        const sessionID = event.properties?.sessionID;
+        if (typeof sessionID === "string") finishCycle(sessionID, sessionState(sessionID));
+      } else if (event.type === "session.error") {
+        handleError(event);
+      } else if (event.type === "permission.asked" || QUESTION_EVENTS.has(event.type)) {
+        handleWaiting(event, true);
+      } else if (event.type === "permission.replied" || QUESTION_REPLY_EVENTS.has(event.type)) {
+        handleWaiting(event, false);
+      } else if (event.type === "installation.update-available" && config.lifecycle.updates) {
+        const version = event.properties?.version;
+        if (typeof version !== "string" || !version.trim()) return;
+        if (publishedUpdates.has(version)) return;
+        rememberBounded(publishedUpdates, version, true);
+        dispatch(
+          "OpenCode update could not be sent",
+          sendUpdate({ config, reporter, version: version.trim() })
+        );
+      }
+    },
+    dispose() {
+      sessions.clear();
+      publishedUpdates.clear();
+    }
+  };
+}
+
 // src/sse.js
 function parseSseFrame(frame) {
   const data = [];
@@ -833,14 +1367,23 @@ async function BackeerPlugin({ client, directory }, options = {}) {
     client,
     directory
   });
+  const lifecycleController = createLifecycleController({
+    config,
+    reporter,
+    client,
+    directory
+  });
   const todoCompletionBySessionID = /* @__PURE__ */ new Map();
   const publishedQuestions = /* @__PURE__ */ new Map();
+  const updateChecker = createUpdateChecker();
   const handleBackeerCommand = createBackeerCommandHandler({
     client,
     config,
     permissionController,
-    reporter
+    reporter,
+    updateChecker
   });
+  const handleUpdateNotice = createUpdateNoticeHook(updateChecker);
   if (!config.token) {
     reporter.error(
       "Notifications disabled \u2014 use /backeer token",
@@ -903,8 +1446,10 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       registerBackeerCommand(opencodeConfig);
     },
     "command.execute.before": handleBackeerCommand,
+    "chat.message": handleUpdateNotice,
     event: async ({ event }) => {
       if (!config.token) return;
+      lifecycleController.handle(event);
       if (config.permissions && event.type === "permission.asked") {
         await handlePermissionAsked(event);
         return;
@@ -925,6 +1470,7 @@ async function BackeerPlugin({ client, directory }, options = {}) {
     },
     dispose: async () => {
       await permissionController.dispose();
+      lifecycleController.dispose();
       todoCompletionBySessionID.clear();
       publishedQuestions.clear();
     }

package/package.json

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