@fdcn/sourcefed 0.3.6 → 0.3.8

package/dist/data/core/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: core
-description: Core sourcefed usage guide. Read this before creating monitors. Covers monitor creation per source (Jira issue, GitHub PR, Slack thread), event delivery and acknowledgement semantics, daemon modes, CLI usage, and troubleshooting. Use when the user asks to watch or monitor a Jira ticket, GitHub PR, Slack thread, or when sourcefed monitor events arrive in the session.
+description: Core sourcefed usage guide. Read this before creating monitors. Covers monitor creation per source (Jira issue, GitHub PR, Slack thread, Yab feed), event delivery and acknowledgement semantics, daemon modes, CLI usage, and troubleshooting. Use when the user asks to watch or monitor a Jira ticket, GitHub PR, Slack thread, a feed or inbox they are signed in to in Yab, or when sourcefed monitor events arrive in the session.
 ---
 
 # Sourcefed core
 
-Sourcefed lets you create **monitors** that watch a Jira issue, GitHub PR, or
-Slack thread or direct-message conversation and route NEW events into the session you're currently working in,
+Sourcefed lets you create **monitors** that watch a Jira issue, GitHub PR,
+Slack thread or direct-message conversation, or a feed read through Yab, and route NEW events into the session you're currently working in,
 so you can react to them as they happen.
 
 Every monitor is detect-only: it routes events into the session and never
@@ -21,6 +21,7 @@ affect that session's monitors.
 - **GitHub PR**: `monitor_create({ name: "PR #42", sourceType: "github", repo: "owner/repo", prNumber: 42 })`
 - **Slack thread**: `monitor_create({ name: "thread", sourceType: "slack", threadUrl: "<thread-url>" })`
 - **Whole Slack DM**: `monitor_create({ name: "DM with Alex", sourceType: "slack", channelId: "D0123456789" })`
+- **Yab feed**: `monitor_create({ name: "inbox", sourceType: "yab", url: "https://mail.google.com/mail/u/0/feed/atom", space: "Personal", match: "interview|offer", exclude: "newsletter" })`
 
 You will be notified of:
 
@@ -30,9 +31,13 @@ You will be notified of:
 - **Slack thread**: new replies in the thread.
 - **Slack DM**: new top-level messages in the DM. Slack monitors are always detect-only
   and never reply.
+- **Yab feed**: each new entry of an Atom, RSS or JSON feed, read through the user's Yab
+  browser with their sign-ins (so private feeds like Gmail's unread-inbox feed work).
+  `space` picks the Yab space; `match`/`exclude` are case-insensitive regexes over the
+  entry's title, summary and author. Yab must be running.
 
 GitHub and Slack use webhook delivery when configured and fall back to polling
-when unavailable. Jira always uses polling. You can lower `pollIntervalSec`
+when unavailable. Jira and Yab always use polling. You can lower `pollIntervalSec`
 (min 15) for time-sensitive work, but prefer the default to avoid hammering
 APIs.
 

package/dist/data/core/references/commands.md

@@ -26,13 +26,17 @@ sourcefed skills path [name]                Print skill directory path
 
 ```text
 --name NAME           Human-readable monitor name (defaults to the source type)
---source-type TYPE    jira | github | slack
+--source-type TYPE    jira | github | slack | yab
 --issue-key KEY       Jira issue key (jira)
 --repo OWNER/NAME     GitHub repository (github)
 --pr-number N         GitHub PR number (github)
 --channel-id ID       Slack channel or DM ID; a D… ID alone monitors the whole DM
 --thread-ts TS        Slack parent message timestamp; omit for a whole-DM monitor
 --thread-url URL      Slack thread URL (slack)
+--url URL             Atom, RSS or JSON feed URL read through Yab (yab)
+--space NAME          Yab space whose sign-ins to use (yab)
+--match REGEX         Only deliver entries matching this case-insensitive regex (yab)
+--exclude REGEX       Skip entries matching this case-insensitive regex (yab)
 --poll-interval-sec N Poll interval in seconds (min 15)
 --target-kind KIND    Target kind for ownership scoping (default: cli)
 --target-id ID        Target id for ownership scoping (default: hostname)
@@ -54,6 +58,7 @@ SOURCEFED_JIRA_TERMINAL_STATUS  Jira status that auto-removes monitors
 GH_TOKEN / GITHUB_TOKEN         GitHub token for direct API polling
 SOURCEFED_GITHUB_WEBHOOK_SECRET GitHub webhook secret (enables webhooks)
 SOURCEFED_SLACK_SIGNING_SECRET  Slack signing secret (enables webhooks)
+SOURCEFED_YAB_COMMAND           Yab binary for yab monitors (default /Applications/yab.app/Contents/MacOS/yab)
 SOURCEFED_SKILLS_DIR            Override the bundled skills directory
 ```
 

package/dist/data/sourcefed/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: sourcefed
-description: Live Jira, GitHub, and Slack monitoring for agent hosts. Create monitors that route new issue comments, PR reviews, CI failures, and Slack thread or DM messages into the current session as they happen.
+description: Live Jira, GitHub, Slack, and Yab feed monitoring for agent hosts. Create monitors that route new issue comments, PR reviews, CI failures, Slack thread or DM messages, and new entries of feeds read through Yab into the current session as they happen.
 hidden: true
 ---
 
 # Sourcefed
 
 Sourcefed turns external collaboration threads into live agent input: create a
-monitor for a Jira issue, GitHub PR, Slack thread, or Slack DM and NEW events are routed
+monitor for a Jira issue, GitHub PR, Slack thread, Slack DM, or a feed read through Yab and NEW events are routed
 into the session you are working in, so you can react to them as they happen.
 
 This file is a discovery stub, not the usage guide. Before running any
@@ -25,6 +25,7 @@ releases, which is why it just points at `skills get core`.
 ## When to load this skill
 
 - A user asks to monitor a Jira ticket, GitHub PR, Slack thread, or Slack DM.
+- A user wants to hear about new entries in a feed or inbox they are signed in to in Yab.
 - You found or are working on a Jira ticket, PR, thread, or DM and want new
   activity routed into your session.
 - You opened a PR and want to be notified of reviews, comments, CI failures,

package/dist/guidance.md

@@ -1,6 +1,7 @@
 # sourcefed monitors
 
-Monitors watch a Jira issue, GitHub PR, or Slack thread and bring new events into this session.
+Monitors watch a Jira issue, GitHub PR, Slack thread, or a feed read through Yab and bring new events
+into this session.
 
 Create one with `monitor_create` when:
 
@@ -9,7 +10,10 @@ Create one with `monitor_create` when:
 - your branch has a PR: `{ name: "<pr>", sourceType: "github", repo: "owner/name", prNumber: 42 }`
   (reviews, comments, CI failures, conflicts, merge or close);
 - you were given a Slack thread: `{ name: "<thread>", sourceType: "slack", threadUrl: "<url>" }`
-  (new messages; read-only, never replies).
+  (new messages; read-only, never replies);
+- the user wants new entries of a feed they are signed in to in Yab (unread Gmail, a job board's RSS):
+  `{ name: "<feed>", sourceType: "yab", url: "https://mail.google.com/mail/u/0/feed/atom", space: "Personal", match: "interview|offer" }`
+  (each new entry; `match`/`exclude` are case-insensitive regexes; Yab must be running).
 
 Keep the default `pollIntervalSec` unless the work is time-sensitive (min 15).
 `monitor_list`, `monitor_status { id }` and `monitor_stop { id }` act on this session's monitors.

package/dist/mcp.js

@@ -1,7 +1,7 @@
 import {
   decodeTarget,
   encodeTarget
-} from "./chunk-X3BZSHKZ.js";
+} from "./chunk-5JL3UV72.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
@@ -4680,6 +4680,10 @@ function buildServer(daemon) {
     channelId: string2().optional(),
     threadTs: string2().optional(),
     threadUrl: string2().optional(),
+    url: string2().optional(),
+    space: string2().optional(),
+    match: string2().optional(),
+    exclude: string2().optional(),
     pollIntervalSec: number2().min(15).optional(),
     target: targetSchema
   });
@@ -4693,7 +4697,7 @@ function buildServer(daemon) {
   server.registerTool(
     "monitor_create",
     {
-      description: "Create or reuse a monitor for a Jira issue, GitHub pull request, Slack thread, or Slack DM.",
+      description: "Create or reuse a monitor for a Jira issue, GitHub pull request, Slack thread, Slack DM, or a feed read through Yab.",
       inputSchema: createSchema,
       annotations: { idempotentHint: true, readOnlyHint: false }
     },

package/dist/opencode.js

@@ -7,7 +7,7 @@ import {
   daemonCommand,
   daemonEnvironment,
   spawnLocalDaemon
-} from "./chunk-X3BZSHKZ.js";
+} from "./chunk-5JL3UV72.js";
 import "./chunk-MLKGABMK.js";
 
 // packages/sourcefed/src/server.ts
@@ -22,9 +22,193 @@ import { Plugin } from "@opencode/plugin";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { Rpc } from "@opencode/plugin";
+
+// adapters/opencode/subscriptions.ts
+var REFRESH_MS = 15e3;
+var OpenCodeSubscriptions = class {
+  constructor(connect) {
+    this.connect = connect;
+  }
+  owners = /* @__PURE__ */ new Set();
+  subscriptions = /* @__PURE__ */ new Map();
+  lifetime = new AbortController();
+  daemon;
+  connecting;
+  refreshing;
+  dirty = false;
+  lastAttemptAt = -Infinity;
+  timer;
+  get closed() {
+    return this.lifetime.signal.aborted;
+  }
+  async add(owner) {
+    if (this.closed) throw new Error("sourcefed subscription hub is closed");
+    this.owners.add(owner);
+    if (!this.timer) {
+      this.timer = setInterval(() => void this.refresh(), REFRESH_MS);
+      this.timer.unref?.();
+    }
+    await this.refresh();
+  }
+  async remove(owner) {
+    this.owners.delete(owner);
+    const closing = [];
+    for (const [id, subscription] of this.subscriptions) {
+      if (this.ownerFor(subscription.info)) continue;
+      this.subscriptions.delete(id);
+      closing.push(this.closeSubscription(subscription));
+    }
+    if (this.owners.size > 0) {
+      await Promise.all(closing);
+      await this.refresh();
+      return;
+    }
+    this.lifetime.abort();
+    clearInterval(this.timer);
+    this.timer = void 0;
+    await Promise.all(closing);
+    await this.daemon?.close();
+    this.daemon = void 0;
+    await this.connecting;
+    await this.refreshing;
+  }
+  async request(method, params) {
+    const daemon = await this.ensureDaemon();
+    if (!daemon || this.closed) throw new Error("sourcefed daemon unavailable or bridge closed");
+    return daemon.request(method, params);
+  }
+  refresh() {
+    if (this.closed) return Promise.resolve();
+    this.dirty = true;
+    if (!this.refreshing) {
+      this.refreshing = this.refreshLoop();
+    }
+    return this.refreshing;
+  }
+  async refreshLoop() {
+    try {
+      do {
+        this.dirty = false;
+        try {
+          const daemon = await this.ensureDaemon();
+          if (daemon && !this.closed) await this.reconcile(daemon);
+        } catch (error) {
+          if (!this.closed) console.error(`[sourcefed] refresh failed: ${String(error)}`);
+        }
+      } while (this.dirty && !this.closed);
+    } finally {
+      this.refreshing = void 0;
+    }
+  }
+  async ensureDaemon() {
+    if (this.closed) return void 0;
+    if (this.daemon) return this.daemon;
+    if (this.connecting) return this.connecting;
+    if (Date.now() - this.lastAttemptAt < REFRESH_MS) return void 0;
+    this.lastAttemptAt = Date.now();
+    this.connecting = this.connect().then(async (daemon) => {
+      if (this.closed) {
+        await daemon.close();
+        return void 0;
+      }
+      this.daemon = daemon;
+      return daemon;
+    }).catch((error) => {
+      console.error(`[sourcefed] daemon unavailable: ${String(error)}`);
+      return void 0;
+    }).finally(() => {
+      this.connecting = void 0;
+    });
+    return this.connecting;
+  }
+  async reconcile(daemon) {
+    const result = await daemon.request("monitor.targets", { kind: "opencode-session" });
+    const targets = enabledSessions(result);
+    for (const [id, subscription] of this.subscriptions) {
+      if (targets.has(id)) continue;
+      this.subscriptions.delete(id);
+      await this.closeSubscription(subscription);
+    }
+    for (const id of targets) {
+      if (this.closed) return;
+      const reader = this.owners.values().next().value;
+      if (!reader) return;
+      let info;
+      try {
+        info = await reader.getSession(id, this.lifetime.signal);
+      } catch (error) {
+        if (!error || typeof error !== "object" || !("_tag" in error) || error._tag !== "SessionNotFoundError") {
+          if (!this.closed) console.error(`[sourcefed] session ${id} lookup failed: ${String(error)}`);
+          continue;
+        }
+      }
+      if (this.closed) return;
+      const owner = info && this.ownerFor(info);
+      const existing = this.subscriptions.get(id);
+      if (!owner || !info) {
+        if (existing) {
+          this.subscriptions.delete(id);
+          await this.closeSubscription(existing);
+        }
+      } else if (existing) {
+        existing.info = info;
+      } else {
+        await this.subscribe(daemon, id, info);
+      }
+    }
+  }
+  ownerFor(info) {
+    const candidates = [...this.owners].filter((owner) => owner.location.project.id === info.projectID);
+    return candidates.find((owner) => owner.location.directory === info.location.directory) ?? candidates[0];
+  }
+  async subscribe(daemon, id, info) {
+    const controller = new AbortController();
+    const subscription = {
+      info,
+      controller,
+      listener: daemon.subscribe({ kind: "opencode-session", id }, async (events) => {
+        await this.route(id, subscription, events);
+      }, { signal: controller.signal })
+    };
+    this.subscriptions.set(id, subscription);
+    try {
+      await subscription.listener;
+    } catch (error) {
+      if (this.subscriptions.get(id) === subscription) this.subscriptions.delete(id);
+      if (!controller.signal.aborted) console.error(`[sourcefed] subscribe ${id} failed: ${String(error)}`);
+    }
+  }
+  async route(id, subscription, events) {
+    const reader = this.owners.values().next().value;
+    if (!reader) throw new Error("sourcefed session owner unloaded");
+    const info = await reader.getSession(id, this.lifetime.signal);
+    const owner = this.ownerFor(info);
+    if (!owner) throw new Error("sourcefed session has no loaded project owner");
+    subscription.info = info;
+    await owner.routeEvents(events);
+  }
+  async closeSubscription(subscription) {
+    subscription.controller.abort();
+    await subscription.listener.then((listener) => listener.close(), () => void 0);
+  }
+};
+function enabledSessions(result) {
+  if (!result || typeof result !== "object" || !("targets" in result) || !Array.isArray(result.targets)) {
+    throw new Error("invalid monitor.targets response");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const target of result.targets) {
+    if (!target || target.kind !== "opencode-session" || typeof target.id !== "string") {
+      throw new Error("invalid opencode-session target");
+    }
+    ids.add(target.id);
+  }
+  return ids;
+}
+
+// adapters/opencode/bridge.ts
 var TARGET_KIND = "opencode-session";
 var GATE_TIMEOUT_MS = 3e3;
-var RESUBSCRIBE_MS = 15e3;
 var ChauffeurGate = Rpc.define({
   id: "chauffeur",
   methods: {
@@ -52,97 +236,53 @@ var ChauffeurGate = Rpc.define({
   },
   events: {}
 });
-var activeBridge;
+var HUB = Symbol.for("sourcefed.opencode.subscriptions.v1");
+var shared = globalThis;
+function subscriptions() {
+  if (!shared[HUB] || shared[HUB].closed) shared[HUB] = new OpenCodeSubscriptions(connectDaemon);
+  return shared[HUB];
+}
 var OpenCodeBridge = class {
-  constructor(session, rpc) {
+  constructor(session, rpc, location, hub = subscriptions()) {
     this.session = session;
     this.rpc = rpc;
+    this.location = location;
+    this.hub = hub;
   }
-  daemon;
-  listeners = /* @__PURE__ */ new Map();
-  lastAttemptAt = 0;
-  lastError;
-  timer;
+  started;
+  closed = false;
+  closing;
   /**
    * Chauffeur or the CLI can create a monitor for a session here at any time,
    * without this bridge's tools, so check for new targets periodically too.
    */
   async start() {
-    await this.ensureDaemon();
-    this.timer = setInterval(() => void this.refresh(), RESUBSCRIBE_MS);
-    this.timer.unref?.();
+    if (this.closed) throw new Error("sourcefed bridge is closed");
+    this.started ??= this.hub.add(this);
+    await this.started;
   }
-  async ensureTarget(sessionID) {
-    await this.ensureDaemon();
-    const existing = this.listeners.get(sessionID);
-    if (existing) {
-      await existing;
-      return;
-    }
-    const pending = this.daemon.subscribe(this.target(sessionID), async (events) => {
-      await this.routeEvents(events);
-    });
-    this.listeners.set(sessionID, pending);
+  async callTool(name, arguments_, sessionID) {
     try {
-      await pending;
+      await this.start();
+      const method = name.replace(/_/g, ".");
+      const result = await this.hub.request(method, { ...arguments_, target: this.target(sessionID) });
+      if (["monitor.create", "monitor.start", "monitor.stop", "monitor.remove"].includes(method)) await this.hub.refresh();
+      return result;
     } catch (error) {
-      this.listeners.delete(sessionID);
-      throw error;
-    }
-  }
-  async callTool(name, arguments_, sessionID) {
-    await this.ensureDaemon();
-    if (!this.daemon) {
-      return { ok: false, error: `sourcefed daemon unavailable: ${this.lastError ?? "not started"}` };
+      return { ok: false, error: String(error) };
     }
-    await this.ensureTarget(sessionID);
-    return this.daemon.request(name.replace(/_/g, "."), { ...arguments_, target: this.target(sessionID) });
   }
-  async close() {
-    clearInterval(this.timer);
-    this.timer = void 0;
-    for (const pending of this.listeners.values()) await pending.then((listener) => listener.close(), () => void 0);
-    this.listeners.clear();
-    await this.daemon?.close();
-    this.daemon = void 0;
+  close() {
+    if (this.closing) return this.closing;
+    this.closed = true;
+    this.closing = this.started ? this.hub.remove(this) : Promise.resolve();
+    return this.closing;
   }
   async refresh() {
-    if (!this.daemon) return this.ensureDaemon();
-    await this.resubscribe();
+    if (!this.closed) await this.hub.refresh();
   }
-  async ensureDaemon() {
-    if (this.daemon) return;
-    if (Date.now() - this.lastAttemptAt < 15e3) return;
-    this.lastAttemptAt = Date.now();
-    try {
-      this.daemon = await connectDaemon();
-      void this.resubscribe();
-    } catch (error) {
-      this.lastError = error instanceof Error ? error.message : String(error);
-      console.error(`[sourcefed] daemon unavailable: ${this.lastError}`);
-    }
-  }
-  /**
-   * Monitors outlive this process, so after a restart nothing listens for their
-   * sessions until something subscribes. Subscribe every session that has an
-   * enabled monitor and still exists here; a deleted session is skipped, since
-   * delivering to it would fail and retry forever.
-   */
-  async resubscribe() {
-    try {
-      const { targets } = await this.daemon.request("monitor.targets", { kind: TARGET_KIND });
-      await Promise.all(targets.map((target) => this.resubscribeTarget(target.id)));
-    } catch (error) {
-      console.error(`[sourcefed] resubscribe failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async resubscribeTarget(sessionID) {
-    if (this.listeners.has(sessionID)) return;
-    const exists = await this.session.get({ sessionID }).then(() => true, () => false);
-    if (!exists) return;
-    await this.ensureTarget(sessionID).catch((error) => {
-      console.error(`[sourcefed] subscribe ${sessionID} failed: ${error instanceof Error ? error.message : String(error)}`);
-    });
+  getSession(sessionID, signal) {
+    return this.session.get({ sessionID }, { signal: AbortSignal.any([signal, AbortSignal.timeout(3e3)]) });
   }
   // Every event arrives as a synthetic message, never as a user prompt, so it is
   // not mistaken for the user's own words. Actionable events resume an idle
@@ -182,7 +322,7 @@ var OpenCodeBridge = class {
         },
         { signal: AbortSignal.timeout(GATE_TIMEOUT_MS) }
       );
-      return reply.deliver !== false;
+      return !(reply && typeof reply === "object" && "deliver" in reply && reply.deliver === false);
     } catch {
       return true;
     }
@@ -207,24 +347,17 @@ function cliEntry() {
   if (existsSync(bundled)) return bundled;
   return fileURLToPath(import.meta.resolve("@sourcefed/cli"));
 }
-function setOpenCodeBridge(bridge) {
-  activeBridge = bridge;
-}
-function getOpenCodeBridge() {
-  if (!activeBridge) throw new Error("Sourcefed OpenCode bridge is not initialized");
-  return activeBridge;
-}
 
 // adapters/opencode/tool-result.ts
-async function callMonitorTool(name, arguments_, sessionID) {
-  const result = await getOpenCodeBridge().callTool(name, arguments_, sessionID);
+async function callMonitorTool(bridge, name, arguments_, sessionID) {
+  const result = await bridge.callTool(name, arguments_, sessionID);
   return JSON.stringify(result);
 }
 
 // adapters/opencode/tools/monitor_create.ts
-var definition = {
+var monitor_create_default = (bridge) => ({
   name: "monitor_create",
-  description: "Create a detect-only monitor that watches a Jira issue, GitHub PR, Slack thread, or Slack DM and routes NEW events into the current session. Slack monitors only read and notify; they never reply. GitHub and Slack use webhooks when configured and polling otherwise; Jira uses polling.",
+  description: "Create a detect-only monitor that watches a Jira issue, GitHub PR, Slack thread, Slack DM, or a feed read through Yab (the user's browser, with their sign-ins) and routes NEW events into the current session. Slack monitors only read and notify; they never reply. GitHub and Slack use webhooks when configured and polling otherwise; Jira and Yab use polling.",
   input: {
     type: "object",
     properties: {
@@ -236,19 +369,22 @@ var definition = {
       channelId: { type: "string", description: "Slack channel or DM ID. A DM ID without threadTs monitors the whole DM conversation." },
       threadTs: { type: "string", description: "Slack parent message timestamp. Omit it with a DM ID to monitor the whole DM conversation." },
       threadUrl: { type: "string", description: "Slack thread URL (alternative to channelId + threadTs)" },
+      url: { type: "string", description: "Atom, RSS or JSON feed URL read through Yab with the user's sign-ins, e.g. https://mail.google.com/mail/u/0/feed/atom (required if sourceType=yab)" },
+      space: { type: "string", description: "Yab space whose sign-ins to use (yab); omit to use wherever the site is signed in" },
+      match: { type: "string", description: "Case-insensitive regex; only entries whose title, summary or author match are delivered (yab)" },
+      exclude: { type: "string", description: "Case-insensitive regex; entries that match are skipped (yab)" },
       pollIntervalSec: { type: "number", description: "Optional polling interval in seconds (min 15, default 60)" }
     },
     required: ["name", "sourceType"],
     additionalProperties: false
   },
   async execute(input, context) {
-    return { content: await callMonitorTool("monitor_create", input ?? {}, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_create", input ?? {}, context.sessionID) };
   }
-};
-var monitor_create_default = definition;
+});
 
 // adapters/opencode/tools/monitor_list.ts
-var definition2 = {
+var monitor_list_default = (bridge) => ({
   name: "monitor_list",
   description: "List monitors created by the current session (id, name, source, delivery, enabled).",
   input: {
@@ -257,13 +393,12 @@ var definition2 = {
     additionalProperties: false
   },
   async execute(_input, context) {
-    return { content: await callMonitorTool("monitor_list", {}, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_list", {}, context.sessionID) };
   }
-};
-var monitor_list_default = definition2;
+});
 
 // adapters/opencode/tools/monitor_status.ts
-var definition3 = {
+var monitor_status_default = (bridge) => ({
   name: "monitor_status",
   description: "Get the status of a monitor created by the current session.",
   input: {
@@ -276,13 +411,12 @@ var definition3 = {
   },
   async execute(input, context) {
     const args = input ?? {};
-    return { content: await callMonitorTool("monitor_status", { id: args.id }, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_status", { id: args.id }, context.sessionID) };
   }
-};
-var monitor_status_default = definition3;
+});
 
 // adapters/opencode/tools/monitor_start.ts
-var definition4 = {
+var monitor_start_default = (bridge) => ({
   name: "monitor_start",
   description: "Start (re-enable) a stopped monitor created by the current session.",
   input: {
@@ -295,13 +429,12 @@ var definition4 = {
   },
   async execute(input, context) {
     const args = input ?? {};
-    return { content: await callMonitorTool("monitor_start", { id: args.id }, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_start", { id: args.id }, context.sessionID) };
   }
-};
-var monitor_start_default = definition4;
+});
 
 // adapters/opencode/tools/monitor_stop.ts
-var definition5 = {
+var monitor_stop_default = (bridge) => ({
   name: "monitor_stop",
   description: "Stop a monitor created by the current session.",
   input: {
@@ -314,23 +447,26 @@ var definition5 = {
   },
   async execute(input, context) {
     const args = input ?? {};
-    return { content: await callMonitorTool("monitor_stop", { id: args.id }, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_stop", { id: args.id }, context.sessionID) };
   }
-};
-var monitor_stop_default = definition5;
+});
 
 // adapters/opencode/index.ts
 async function setupSourcefed(ctx) {
-  const bridge = new OpenCodeBridge(ctx.session, ctx.rpc);
-  setOpenCodeBridge(bridge);
-  await bridge.start();
-  await ctx.tool.transform((editor) => {
-    editor.add(monitor_create_default);
-    editor.add(monitor_list_default);
-    editor.add(monitor_status_default);
-    editor.add(monitor_start_default);
-    editor.add(monitor_stop_default);
-  });
+  const bridge = new OpenCodeBridge(ctx.session, ctx.rpc, ctx.location);
+  try {
+    await bridge.start();
+    await ctx.tool.transform((editor) => {
+      editor.add(monitor_create_default(bridge));
+      editor.add(monitor_list_default(bridge));
+      editor.add(monitor_status_default(bridge));
+      editor.add(monitor_start_default(bridge));
+      editor.add(monitor_stop_default(bridge));
+    });
+  } catch (error) {
+    await bridge.close();
+    throw error;
+  }
   return () => bridge.close();
 }
 var opencode_default = Plugin.define({
@@ -345,11 +481,16 @@ var server_default = Plugin2.define({
   id: "sourcefed",
   async setup(ctx) {
     const cleanup = await setupSourcefed(ctx);
-    await ctx.session.hook("context", (event) => {
-      if (!event.system.some((part) => part.type === "text" && part.text.includes(heading))) {
-        event.system.push({ type: "text", text: guidance });
-      }
-    });
+    try {
+      await ctx.session.hook("context", (event) => {
+        if (!event.system.some((part) => part.type === "text" && part.text.includes(heading))) {
+          event.system.push({ type: "text", text: guidance });
+        }
+      });
+    } catch (error) {
+      await cleanup?.();
+      throw error;
+    }
     return cleanup;
   }
 });