@forwardimpact/libbridge 0.1.3 → 0.1.5

package/README.md

@@ -13,7 +13,6 @@ Threaded-channel bridge primitives — relay messages between human channels
 import {
   createBridgeServer,
   CallbackRegistry,
-  DiscussionContextStore,
   RateLimiter,
   ProgressTicker,
   appendHistory,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/libbridge",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Threaded-channel bridge primitives — relay messages between human channels (GitHub Discussions, Microsoft Teams) and the Kata agent team.",
   "keywords": [
     "bridge",
@@ -40,13 +40,12 @@
     "test": "bun test test/*.test.js"
   },
   "dependencies": {
-    "@forwardimpact/libindex": "^0.1.38",
-    "@forwardimpact/libstorage": "^0.1.78",
+    "@forwardimpact/libtype": "^0.1.0",
     "@hono/node-server": "^2.0.4",
     "hono": "^4.12.23"
   },
   "devDependencies": {
-    "@forwardimpact/libharness": "^0.1.21"
+    "@forwardimpact/libmock": "^0.1.0"
   },
   "engines": {
     "bun": ">=1.2.0",

package/src/callback-handler.js

@@ -37,7 +37,7 @@ export class CallbackHandlerError extends Error {
  * @param {string} options.channel
  * @param {import("./callback-registry.js").CallbackRegistry} options.callbacks
  * @param {import("./acknowledgement.js").Acknowledgement} options.ack
- * @param {import("./discussion-context.js").DiscussionContextStore} options.store
+ * @param {import("./index.js").DiscussionAdapter} options.store
  * @param {{debug?: Function, error?: Function}} options.logger
  * @param {{startSpan: Function}} options.tracer
  * @param {string} options.spanName

package/src/callback-registry.js

@@ -4,7 +4,7 @@ const DEFAULT_TTL_MS = 2 * 60 * 60 * 1000;
 
 /**
  * In-memory registry of pending bridge → workflow callbacks. Hosts persist
- * the (token, correlationId) pairs via DiscussionContextStore so the registry
+ * the (token, correlationId) pairs via the discussion store so the registry
  * can be rehydrated after a restart; this class only owns the live token →
  * metadata mapping and TTL sweep.
  */

package/src/dispatcher.js

@@ -3,27 +3,7 @@ import { randomUUID } from "node:crypto";
 import { dispatchWorkflow } from "./dispatch.js";
 import { appendHistory } from "./history.js";
 
-/**
- * The standard "dispatch dance" both bridges perform: generate a
- * correlation ID, register the callback token, start the acknowledgement
- * (if `ackTarget` is supplied), fire the kata-dispatch workflow, append
- * history, push the dispatch timestamp, and flush the store. On failure
- * the acknowledgement is finished and the callback registration is rolled
- * back before the error rethrows.
- *
- * The caller still owns: loading/creating the context, checking the rate
- * limiter, and deciding the user-facing action when `dispatch()` throws.
- *
- * @example
- *   const { token, correlationId } = await dispatcher.dispatch({
- *     ctx,
- *     prompt,
- *     ackTarget: { subjectId: nodeId },
- *     historyText: text,
- *     callbackMeta: { discussionId },
- *     workflowInputs: { discussionId },
- *   });
- */
+/** Dispatch dance: resolve per-user token, register callback, ack, fire workflow, flush. */
 export class Dispatcher {
   #callbacks;
   #ack;
@@ -31,17 +11,17 @@ export class Dispatcher {
   #callbackBaseUrl;
   #workflowFile;
   #githubRepo;
-  #getGithubToken;
+  #tokenResolver;
 
   /**
    * @param {object} options
    * @param {import("./callback-registry.js").CallbackRegistry} options.callbacks
    * @param {import("./acknowledgement.js").Acknowledgement} options.ack
-   * @param {import("./discussion-context.js").DiscussionContextStore} options.store
+   * @param {import("./index.js").DiscussionAdapter} options.store
    * @param {string} options.callbackBaseUrl - Already normalised
    * @param {string} options.workflowFile
    * @param {string} options.githubRepo
-   * @param {() => Promise<string> | string} options.getGithubToken
+   * @param {import("./token-resolver.js").TokenResolver} options.tokenResolver
    */
   constructor({
     callbacks,
@@ -50,7 +30,7 @@ export class Dispatcher {
     callbackBaseUrl,
     workflowFile,
     githubRepo,
-    getGithubToken,
+    tokenResolver,
   }) {
     if (!callbacks) throw new Error("callbacks is required");
     if (!ack) throw new Error("ack is required");
@@ -60,31 +40,31 @@ export class Dispatcher {
     }
     if (!workflowFile) throw new Error("workflowFile is required");
     if (!githubRepo) throw new Error("githubRepo is required");
-    if (typeof getGithubToken !== "function") {
-      throw new Error("getGithubToken is required");
-    }
+    if (!tokenResolver) throw new Error("tokenResolver is required");
     this.#callbacks = callbacks;
     this.#ack = ack;
     this.#store = store;
     this.#callbackBaseUrl = callbackBaseUrl;
     this.#workflowFile = workflowFile;
     this.#githubRepo = githubRepo;
-    this.#getGithubToken = getGithubToken;
+    this.#tokenResolver = tokenResolver;
   }
 
   /**
    * @param {object} args
    * @param {object} args.ctx - Discussion context record (mutated)
    * @param {string} args.prompt
+   * @param {string} args.requester - Surface user id of the triggering human
    * @param {object} args.callbackMeta - Stored on the callback token
    * @param {unknown} [args.ackTarget] - If omitted, no acknowledgement is started
    * @param {string} [args.historyText] - Appended to ctx.history as the user turn on success
    * @param {object} [args.workflowInputs] - Extra fields for `dispatchWorkflow`
-   * @returns {Promise<{token: string, correlationId: string}>}
+   * @returns {Promise<{kind: "dispatched", token: string, correlationId: string} | {kind: "link_required", authorizeUrl: string} | {kind: "reauth_required"} | {kind: "transient", error: Error}>}
    */
   async dispatch({
     ctx,
     prompt,
+    requester,
     callbackMeta,
     ackTarget,
     historyText,
@@ -92,19 +72,23 @@ export class Dispatcher {
   }) {
     if (!ctx) throw new Error("ctx is required");
     if (typeof prompt !== "string") throw new Error("prompt is required");
+    if (typeof requester !== "string") throw new Error("requester is required");
+
+    const auth = await this.#tokenResolver.resolve(ctx.channel, requester);
+    if (auth.kind !== "token") return auth;
 
     const correlationId = randomUUID();
-    const token = this.#callbacks.register(correlationId, callbackMeta ?? {});
+    const mergedMeta = { ...(callbackMeta ?? {}), requester };
+    const token = this.#callbacks.register(correlationId, mergedMeta);
     ctx.pending_callbacks[token] = correlationId;
     const callbackUrl = `${this.#callbackBaseUrl}/api/callback/${token}`;
 
     if (ackTarget !== undefined) await this.#ack.start(token, ackTarget);
     try {
-      const ghToken = await this.#getGithubToken();
       await dispatchWorkflow({
         workflowFile: this.#workflowFile,
         repo: this.#githubRepo,
-        token: ghToken,
+        token: auth.token,
         prompt,
         callbackUrl,
         correlationId,
@@ -117,7 +101,7 @@ export class Dispatcher {
       ctx.last_active_at = Date.now();
       await this.#store.add(ctx);
       await this.#store.flush();
-      return { token, correlationId };
+      return { kind: "dispatched", token, correlationId };
     } catch (err) {
       if (ackTarget !== undefined) await this.#ack.finish(token, ackTarget);
       this.#callbacks.consume(token);

package/src/index.js

@@ -10,20 +10,29 @@
  * @property {string} github_repo - "owner/repo" hosting the kata-dispatch workflow
  */
 
+/**
+ * @typedef {object} DiscussionAdapter
+ * @property {(channel: string, discussionId: string) => Promise<object|null>} loadByChannel
+ * @property {(correlationId: string) => Promise<object|null>} loadByCorrelation
+ * @property {() => Promise<Array<{correlationId: string, dueAt: number}>>} listOpenRecesses
+ * @property {(ctx: object) => Promise<void>} add
+ * @property {() => Promise<void>} flush
+ * @property {() => Promise<void>} shutdown
+ */
+
 export { createBridgeServer } from "./server.js";
 export { CallbackRegistry } from "./callback-registry.js";
 export { buildPrompt } from "./prompt.js";
 export { appendHistory } from "./history.js";
 export { RateLimiter } from "./rate-limit.js";
 export { dispatchWorkflow } from "./dispatch.js";
-export { DiscussionContextStore } from "./discussion-context.js";
-export { OriginIndex } from "./origin-index.js";
 export { ProgressTicker } from "./progress-ticker.js";
 export {
   Acknowledgement,
   DEFAULT_TYPING_VERBS,
 } from "./acknowledgement.js";
 export { Dispatcher } from "./dispatcher.js";
+export { TokenResolver } from "./token-resolver.js";
 export {
   CallbackHandlerError,
   createCallbackHandler,

package/src/resume-scheduler.js

@@ -3,46 +3,7 @@ import { evaluateTrigger, parseIsoDuration } from "./triggers.js";
 
 const DEFAULT_PROMPT = "Resume requested.";
 
-/**
- * Channel-agnostic suspend/resume lifecycle for the discuss-mode trace.
- * When the workflow returns a `"recessed"` verdict, the bridge calls
- * `enterRecess(...)` to persist the trigger on
- * `ctx.open_rfcs[correlationId]`. The scheduler watches inbound activity
- * via `processInbound(ctx)` and ticking elapsed timers via the embedded
- * `ElapsedScheduler`; when a trigger fires, it redispatches the workflow
- * through the shared `Dispatcher` with a `resume_context` payload
- * linking back to the original correlation id.
- *
- * Channel-specific extras are supplied by two small constructor
- * callbacks:
- *
- *   buildCallbackMeta(ctx) -> { ... }   // matches the bridge's loadDiscussionId
- *   buildResumeInputs(ctx) -> { ... }   // extra workflow_dispatch inputs
- *
- * Both default to ghbridge's convention; msbridge overrides
- * `buildCallbackMeta` to `{ threadId: ctx.discussion_id }` when it
- * adopts resume.
- *
- * @example
- *   const scheduler = new ResumeScheduler({
- *     dispatcher,
- *     store,
- *     logger,
- *     buildCallbackMeta: (ctx) => ({ discussionId: ctx.discussion_id }),
- *     buildResumeInputs: (ctx) => ({ discussionId: ctx.discussion_id }),
- *   });
- *   // service start:
- *   await scheduler.rearm();
- *   // inbound activity:
- *   const { freshDispatchAllowed } = await scheduler.processInbound(ctx);
- *   if (freshDispatchAllowed) { ... dispatch fresh ... }
- *   // on "recessed" verdict:
- *   scheduler.enterRecess(ctx, correlationId, payload.trigger);
- *   // on "adjourned" / "failed":
- *   scheduler.cancelRecess(ctx, correlationId);
- *   // service stop:
- *   scheduler.clear();
- */
+/** Channel-agnostic suspend/resume lifecycle for the discuss-mode trace. */
 export class ResumeScheduler {
   #dispatcher;
   #store;
@@ -51,15 +12,17 @@ export class ResumeScheduler {
   #prompt;
   #buildResumeInputs;
   #buildCallbackMeta;
+  #onDeclined;
 
   /**
    * @param {object} options
    * @param {import("./dispatcher.js").Dispatcher} options.dispatcher
-   * @param {import("./discussion-context.js").DiscussionContextStore} options.store
+   * @param {import("./index.js").DiscussionAdapter} options.store
    * @param {{error?: Function, info?: Function}} [options.logger]
    * @param {string} [options.prompt] - Default "Resume requested."
    * @param {(ctx: object) => object} [options.buildCallbackMeta]
    * @param {(ctx: object) => object} [options.buildResumeInputs]
+   * @param {((ctx: object, outcome: object) => Promise<void>) | null} [options.onDeclined]
    */
   constructor({
     dispatcher,
@@ -68,6 +31,7 @@ export class ResumeScheduler {
     prompt = DEFAULT_PROMPT,
     buildCallbackMeta = (ctx) => ({ discussionId: ctx.discussion_id }),
     buildResumeInputs = () => ({}),
+    onDeclined = null,
   }) {
     if (!dispatcher) throw new Error("dispatcher is required");
     if (!store) throw new Error("store is required");
@@ -77,12 +41,16 @@ export class ResumeScheduler {
     if (typeof buildResumeInputs !== "function") {
       throw new Error("buildResumeInputs must be a function");
     }
+    if (onDeclined != null && typeof onDeclined !== "function") {
+      throw new Error("onDeclined must be a function");
+    }
     this.#dispatcher = dispatcher;
     this.#store = store;
     this.#logger = logger ?? null;
     this.#prompt = prompt;
     this.#buildCallbackMeta = buildCallbackMeta;
     this.#buildResumeInputs = buildResumeInputs;
+    this.#onDeclined = onDeclined;
     this.#elapsed = new ElapsedScheduler({
       onFire: (cid) => this.#fireElapsed(cid),
       onError: (err, cid) =>
@@ -99,10 +67,9 @@ export class ResumeScheduler {
 
   /**
    * Begin watching `correlationId` for trigger resolution. Persists the
-   * trigger and the history index at recess time onto
-   * `ctx.open_rfcs[correlationId]`. If the trigger has an elapsed
-   * component, schedules an in-memory timer that will fire even when no
-   * inbound activity arrives. No-op if `trigger` is falsy.
+   * trigger, the history index at recess time, and the triggering
+   * requester onto `ctx.open_rfcs[correlationId]`. If the trigger has an
+   * elapsed component, schedules an in-memory timer.
    *
    * The caller is responsible for flushing the store after this call —
    * `enterRecess` mutates ctx but does not write.
@@ -110,14 +77,16 @@ export class ResumeScheduler {
    * @param {object} ctx
    * @param {string} correlationId
    * @param {import("./triggers.js").ResumeTrigger} trigger
+   * @param {string} requester - Surface user id of the triggering human
    */
-  enterRecess(ctx, correlationId, trigger) {
+  enterRecess(ctx, correlationId, trigger, requester) {
     if (!trigger) return;
     const openedAt = Date.now();
     ctx.open_rfcs[correlationId] = {
       trigger,
       opened_at: openedAt,
       history_index_at_open: ctx.history.length,
+      requester,
     };
     if (trigger.kind === "elapsed" && typeof trigger.elapsed === "string") {
       const dueAt = openedAt + parseIsoDuration(trigger.elapsed);
@@ -128,8 +97,7 @@ export class ResumeScheduler {
 
   /**
    * Stop watching `correlationId`. Removes the rfc from `ctx.open_rfcs`
-   * and cancels any associated elapsed timer. Idempotent — safe to call
-   * for verdicts that didn't actually recess.
+   * and cancels any associated elapsed timer. Idempotent.
    *
    * @param {object} ctx
    * @param {string} correlationId
@@ -140,29 +108,21 @@ export class ResumeScheduler {
   }
 
   /**
-   * Walk `ctx.open_rfcs`. For each rfc whose trigger has fired given the
-   * current history length and clock, redispatch the workflow with
-   * `resume_context` linking back to the original correlation id, then
-   * cancel the rfc. Returns a summary so the host can decide whether to
-   * additionally fire a fresh lead session on this inbound activity.
-   *
-   * If a redispatch fails the rfc remains armed — the host's failure
-   * recovery (next inbound activity, or the next elapsed tick) will
-   * retry.
+   * Walk `ctx.open_rfcs`. For each rfc whose trigger has fired,
+   * redispatch the workflow. Returns a summary so the host can decide
+   * whether to additionally fire a fresh lead session.
    *
    * @param {object} ctx
-   * @returns {Promise<{
-   *   fired: number,
-   *   hasOpenRfc: boolean,
-   *   freshDispatchAllowed: boolean,
-   * }>}
+   * @returns {Promise<{fired: number, hasOpenRfc: boolean, freshDispatchAllowed: boolean}>}
    */
   async processInbound(ctx) {
     const fired = this.#evaluate(ctx);
     for (const { correlationId, rfc } of fired) {
       const historySince = ctx.history.slice(rfc.history_index_at_open);
-      await this.#redispatch(ctx, correlationId, historySince);
-      this.cancelRecess(ctx, correlationId);
+      const result = await this.#redispatch(ctx, correlationId, historySince);
+      if (result.kind === "dispatched") {
+        this.cancelRecess(ctx, correlationId);
+      }
     }
     const hasOpenRfc = Object.keys(ctx.open_rfcs ?? {}).length > 0;
     return {
@@ -173,21 +133,13 @@ export class ResumeScheduler {
   }
 
   /**
-   * Rehydrate persistent elapsed timers from the store. Call once after
-   * the bridge server starts so deadlines set before a restart still
-   * fire.
+   * Rehydrate persistent elapsed timers from the store.
    * @returns {Promise<void>}
    */
   async rearm() {
-    if (!this.#store.loaded) await this.#store.loadData();
-    for (const record of this.#store.index.values()) {
-      const open = record?.open_rfcs;
-      if (!open) continue;
-      for (const [correlationId, rfc] of Object.entries(open)) {
-        if (typeof rfc.due_at === "number") {
-          this.#elapsed.schedule(correlationId, rfc.due_at);
-        }
-      }
+    const refs = await this.#store.listOpenRecesses();
+    for (const { correlationId, dueAt } of refs) {
+      this.#elapsed.schedule(correlationId, dueAt);
     }
   }
 
@@ -213,19 +165,38 @@ export class ResumeScheduler {
   }
 
   async #redispatch(ctx, correlationId, historySince) {
+    const rfc = ctx.open_rfcs[correlationId];
+    if (!rfc.requester) {
+      this.cancelRecess(ctx, correlationId);
+      this.#logger?.info?.("resume.skip", "rfc missing requester", {
+        correlation_id: correlationId,
+      });
+      return {
+        kind: "transient",
+        error: new Error("rfc missing requester"),
+      };
+    }
     const resumeContext = JSON.stringify({
       correlation_id: correlationId,
       history_since: historySince,
     });
-    await this.#dispatcher.dispatch({
+    const result = await this.#dispatcher.dispatch({
       ctx,
       prompt: this.#prompt,
+      requester: rfc.requester,
       callbackMeta: this.#buildCallbackMeta(ctx),
       workflowInputs: {
         ...this.#buildResumeInputs(ctx),
         resumeContext,
       },
     });
+    if (result.kind !== "dispatched") {
+      this.cancelRecess(ctx, correlationId);
+      await this.#store.add(ctx);
+      await this.#store.flush();
+      if (this.#onDeclined) await this.#onDeclined(ctx, result);
+    }
+    return result;
   }
 
   async #fireElapsed(correlationId) {
@@ -233,20 +204,18 @@ export class ResumeScheduler {
     if (!found) return;
     const { ctx, rfc } = found;
     const historySince = ctx.history.slice(rfc.history_index_at_open);
-    await this.#redispatch(ctx, correlationId, historySince);
-    this.cancelRecess(ctx, correlationId);
-    ctx.last_active_at = Date.now();
-    await this.#store.add(ctx);
-    await this.#store.flush();
+    const result = await this.#redispatch(ctx, correlationId, historySince);
+    if (result.kind === "dispatched") {
+      this.cancelRecess(ctx, correlationId);
+      ctx.last_active_at = Date.now();
+      await this.#store.add(ctx);
+      await this.#store.flush();
+    }
   }
 
   async #findContextWithRfc(correlationId) {
-    if (!this.#store.loaded) await this.#store.loadData();
-    for (const record of this.#store.index.values()) {
-      if (record?.open_rfcs?.[correlationId]) {
-        return { ctx: record, rfc: record.open_rfcs[correlationId] };
-      }
-    }
-    return null;
+    const ctx = await this.#store.loadByCorrelation(correlationId);
+    if (!ctx) return null;
+    return { ctx, rfc: ctx.open_rfcs[correlationId] };
   }
 }

package/src/token-resolver.js

@@ -0,0 +1,41 @@
+import { ghauth } from "@forwardimpact/libtype";
+
+/** Maps ghauth GetToken oneof + gRPC transport into a discriminated DispatchAuth result. */
+export class TokenResolver {
+  #client;
+
+  /** @param {object} client - ghauth gRPC client */
+  constructor(client) {
+    if (!client) throw new Error("ghauth client is required");
+    this.#client = client;
+  }
+
+  /** @returns {Promise<{kind: string, token?: string, authorizeUrl?: string, error?: Error}>} */
+  async resolve(surface, surfaceUserId) {
+    try {
+      const req = new ghauth.GetTokenRequest({
+        surface,
+        surface_user_id: surfaceUserId,
+      });
+      const res = await this.#client.GetToken(req);
+      switch (res.result) {
+        case "token":
+          return { kind: "token", token: res.token };
+        case "link_required":
+          return {
+            kind: "link_required",
+            authorizeUrl: res.link_required.authorize_url,
+          };
+        case "re_auth_required":
+          return { kind: "reauth_required" };
+        default:
+          return {
+            kind: "transient",
+            error: new Error("unexpected GetToken result"),
+          };
+      }
+    } catch (err) {
+      return { kind: "transient", error: err };
+    }
+  }
+}

package/src/discussion-context.js

@@ -1,126 +0,0 @@
-import { BufferedIndex } from "@forwardimpact/libindex";
-
-const DEFAULT_FLUSH_INTERVAL_MS = 5_000;
-const DEFAULT_MAX_BUFFER_SIZE = 1_000;
-const DEFAULT_CONVERSATION_TTL_MS = 24 * 60 * 60 * 1000;
-const DEFAULT_SWEEP_INTERVAL_MS = 60_000;
-
-/**
- * Persisted thread state keyed by `(channel, discussion_id)`. Both
- * `services/ghbridge` and `services/msbridge` write into the same store so
- * the channel-agnostic `kata-dispatch.yml` workflow can resume conversations
- * from either side.
- *
- * Record shape:
- *   {
- *     id: "<channel>:<discussion_id>",
- *     channel: "github-discussions" | "msteams",
- *     discussion_id: string,
- *     history: Array<{role: "user"|"assistant", text: string}>,
- *     participants: Array<{name, kind: "agent"|"human", external_id?, metadata?}>,
- *     open_rfcs: Record<correlationId, {trigger, opened_at, history_index_at_open}>,
- *     lead: string,
- *     pending_callbacks: Record<token, correlationId>,
- *     last_active_at: number,
- *   }
- *
- * @augments BufferedIndex
- */
-export class DiscussionContextStore extends BufferedIndex {
-  #conversationTtlMs;
-  #sweepTimer;
-
-  /**
-   * @param {import("@forwardimpact/libstorage").StorageInterface} storage
-   * @param {object} [options]
-   * @param {string} [options.indexKey] - JSONL file name (default `discussions.jsonl`)
-   * @param {number} [options.flushIntervalMs]
-   * @param {number} [options.maxBufferSize]
-   * @param {number} [options.conversationTtlMs] - Eviction window (default 24h)
-   * @param {number} [options.sweepIntervalMs] - Sweep cadence (default 60s)
-   */
-  constructor(
-    storage,
-    {
-      indexKey = "discussions.jsonl",
-      flushIntervalMs = DEFAULT_FLUSH_INTERVAL_MS,
-      maxBufferSize = DEFAULT_MAX_BUFFER_SIZE,
-      conversationTtlMs = DEFAULT_CONVERSATION_TTL_MS,
-      sweepIntervalMs = DEFAULT_SWEEP_INTERVAL_MS,
-    } = {},
-  ) {
-    super(storage, indexKey, {
-      flush_interval: flushIntervalMs,
-      max_buffer_size: maxBufferSize,
-    });
-    this.#conversationTtlMs = conversationTtlMs;
-    this.#sweepTimer = setInterval(
-      () => this.#sweep(Date.now()),
-      sweepIntervalMs,
-    );
-    this.#sweepTimer.unref();
-  }
-
-  /**
-   * Compose the `id` field for a `(channel, discussion_id)` pair.
-   * @param {string} channel
-   * @param {string} discussionId
-   * @returns {string}
-   */
-  static keyOf(channel, discussionId) {
-    return `${channel}:${discussionId}`;
-  }
-
-  /**
-   * @param {string} channel
-   * @param {string} discussionId
-   * @returns {Promise<object | null>}
-   */
-  async loadByChannel(channel, discussionId) {
-    if (!this.loaded) await this.loadData();
-    const id = DiscussionContextStore.keyOf(channel, discussionId);
-    return this.index.get(id) ?? null;
-  }
-
-  /**
-   * Stop the periodic sweep timer. Called on host shutdown alongside
-   * `shutdown()` to release the interval.
-   */
-  stopSweep() {
-    if (this.#sweepTimer) {
-      clearInterval(this.#sweepTimer);
-      this.#sweepTimer = null;
-    }
-  }
-
-  /**
-   * Flush buffered writes and stop the sweep timer.
-   * @returns {Promise<void>}
-   */
-  async shutdown() {
-    this.stopSweep();
-    await super.shutdown();
-  }
-
-  /**
-   * Evict records whose `last_active_at` is older than `conversationTtlMs`.
-   * Caller-driven `now` keeps unit tests deterministic.
-   * @param {number} now
-   * @returns {number}
-   */
-  sweepNow(now) {
-    return this.#sweep(now);
-  }
-
-  #sweep(now) {
-    let evicted = 0;
-    for (const [id, record] of this.index) {
-      const lastActive = record?.last_active_at ?? 0;
-      if (now - lastActive > this.#conversationTtlMs) {
-        this.index.delete(id);
-        evicted++;
-      }
-    }
-    return evicted;
-  }
-}

package/src/origin-index.js

@@ -1,49 +0,0 @@
-import { BufferedIndex } from "@forwardimpact/libindex";
-
-const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
-
-/**
- * Tracks comment IDs posted by the bridge so webhook handlers can skip
- * dispatching for self-originated events. Wraps `BufferedIndex` with
- * caller-injected `StorageInterface` per the libbridge invariant.
- *
- * Record shape: `{ id: "<comment_node_id>", discussion_id, posted_at }`
- *
- * @augments BufferedIndex
- */
-export class OriginIndex extends BufferedIndex {
-  #ttlMs;
-
-  /**
-   * @param {import("@forwardimpact/libstorage").StorageInterface} storage
-   * @param {object} [options]
-   * @param {string} [options.indexKey]
-   * @param {number} [options.ttlMs] - Eviction window (default 24h)
-   */
-  constructor(
-    storage,
-    { indexKey = "origins.jsonl", ttlMs = DEFAULT_TTL_MS } = {},
-  ) {
-    super(storage, indexKey, {
-      flush_interval: 1_000,
-      max_buffer_size: 100,
-    });
-    this.#ttlMs = ttlMs;
-  }
-
-  /**
-   * Evict records older than `ttlMs`.
-   * @param {number} now
-   * @returns {number} count evicted
-   */
-  sweep(now) {
-    let evicted = 0;
-    for (const [id, record] of this.index) {
-      if (now - (record?.posted_at ?? 0) > this.#ttlMs) {
-        this.index.delete(id);
-        evicted++;
-      }
-    }
-    return evicted;
-  }
-}