@drisp/cli 0.5.10 → 0.5.13

package/dist/athena-gateway.js

@@ -24,6 +24,159 @@ import {
 // src/gateway/daemon.ts
 import fs4 from "fs";
 
+// src/gateway/channelManager.ts
+var DEFAULT_DEDUP_WINDOW = 1024;
+var DuplicateChannelError = class extends Error {
+  constructor(id) {
+    super(`channel ${id} already registered`);
+    this.name = "DuplicateChannelError";
+  }
+};
+var UnknownChannelError = class extends Error {
+  constructor(id) {
+    super(`channel ${id} not registered`);
+    this.name = "UnknownChannelError";
+  }
+};
+var ChannelManager = class {
+  entries = /* @__PURE__ */ new Map();
+  dedup = [];
+  dedupSet = /* @__PURE__ */ new Set();
+  dedupMax;
+  log;
+  inboundSink = null;
+  healthSink = null;
+  stopped = false;
+  constructor(opts = {}) {
+    this.dedupMax = opts.dedupWindow ?? DEFAULT_DEDUP_WINDOW;
+    this.log = opts.log;
+  }
+  /** Register the single inbound dispatch target. M5 wires the router here. */
+  setInboundSink(sink) {
+    this.inboundSink = sink;
+  }
+  /**
+   * Returns the attachmentId associated with `channelId` at registration
+   * time, or undefined if the channel is unknown or registered without one.
+   */
+  getAttachmentId(channelId) {
+    return this.entries.get(channelId)?.attachmentId;
+  }
+  setHealthSink(sink) {
+    this.healthSink = sink;
+  }
+  listChannels() {
+    return [...this.entries.values()].map((e) => ({
+      id: e.adapter.id,
+      health: e.lastHealth
+    }));
+  }
+  /** Snapshot of currently registered adapters; used by the relay coordinator. */
+  listAdapters() {
+    return [...this.entries.values()].map((e) => e.adapter);
+  }
+  async register(adapter, opts = {}) {
+    if (this.stopped) {
+      throw new Error("channel manager already stopped");
+    }
+    if (this.entries.has(adapter.id)) {
+      throw new DuplicateChannelError(adapter.id);
+    }
+    const abort = new AbortController();
+    const inboundListener = (msg) => this.handleInbound(adapter.id, msg);
+    const healthListener = (sample) => {
+      const entry2 = this.entries.get(adapter.id);
+      if (entry2) entry2.lastHealth = sample;
+      this.healthSink?.(sample);
+    };
+    const startPromise = adapter.start({
+      log: (level, msg) => this.log?.(level, `[${adapter.id}] ${msg}`),
+      signal: abort.signal,
+      emitInbound: inboundListener,
+      emitHealth: healthListener
+    });
+    const entry = {
+      adapter,
+      abort,
+      startPromise
+    };
+    if (opts.attachmentId !== void 0) entry.attachmentId = opts.attachmentId;
+    this.entries.set(adapter.id, entry);
+    try {
+      await startPromise;
+    } catch (err) {
+      this.entries.delete(adapter.id);
+      throw err;
+    }
+  }
+  async unregister(id, reason) {
+    const entry = this.entries.get(id);
+    if (!entry) {
+      throw new UnknownChannelError(id);
+    }
+    this.entries.delete(id);
+    entry.abort.abort();
+    await entry.adapter.stop(reason);
+  }
+  async send(channelId, msg) {
+    const entry = this.entries.get(channelId);
+    if (!entry) {
+      throw new UnknownChannelError(channelId);
+    }
+    return entry.adapter.send(msg);
+  }
+  async probe(channelId) {
+    const entry = this.entries.get(channelId);
+    if (!entry) {
+      throw new UnknownChannelError(channelId);
+    }
+    return entry.adapter.probe();
+  }
+  async stop(reason = "shutdown") {
+    if (this.stopped) return;
+    this.stopped = true;
+    const ids = [...this.entries.keys()];
+    for (const id of ids.reverse()) {
+      try {
+        await this.unregister(id, reason);
+      } catch (err) {
+        this.log?.(
+          "warn",
+          `channel ${id} stop failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  handleInbound(channelId, msg) {
+    if (this.dedupSet.has(msg.idempotencyKey)) {
+      this.log?.("debug", `dropping duplicate inbound ${msg.idempotencyKey}`);
+      return;
+    }
+    this.dedupSet.add(msg.idempotencyKey);
+    this.dedup.push(msg.idempotencyKey);
+    while (this.dedup.length > this.dedupMax) {
+      const evicted = this.dedup.shift();
+      if (evicted !== void 0) this.dedupSet.delete(evicted);
+    }
+    const sink = this.inboundSink;
+    if (!sink) {
+      this.log?.(
+        "debug",
+        `no inbound sink registered; dropping ${msg.idempotencyKey}`
+      );
+      return;
+    }
+    try {
+      sink(msg, { attachmentId: this.entries.get(channelId)?.attachmentId });
+    } catch (err) {
+      this.log?.(
+        "warn",
+        `inbound sink threw: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+};
+
 // src/infra/config/channels.ts
 import fs from "fs";
 import os from "os";
@@ -1886,158 +2039,173 @@ function instantiateAdapter(sidecar) {
   return { ok: true, adapter: module.create(parsed.config, sidecar.instanceId) };
 }
 
-// src/gateway/channelManager.ts
-var DEFAULT_DEDUP_WINDOW = 1024;
-var DuplicateChannelError = class extends Error {
-  constructor(id) {
-    super(`channel ${id} already registered`);
-    this.name = "DuplicateChannelError";
-  }
-};
-var UnknownChannelError = class extends Error {
-  constructor(id) {
-    super(`channel ${id} not registered`);
-    this.name = "UnknownChannelError";
-  }
-};
-var ChannelManager = class {
-  entries = /* @__PURE__ */ new Map();
-  dedup = [];
-  dedupSet = /* @__PURE__ */ new Set();
-  dedupMax;
-  log;
-  inboundSink = null;
-  healthSink = null;
-  stopped = false;
-  constructor(opts = {}) {
-    this.dedupMax = opts.dedupWindow ?? DEFAULT_DEDUP_WINDOW;
-    this.log = opts.log;
-  }
-  /** Register the single inbound dispatch target. M5 wires the router here. */
-  setInboundSink(sink) {
-    this.inboundSink = sink;
-  }
-  /**
-   * Returns the attachmentId associated with `channelId` at registration
-   * time, or undefined if the channel is unknown or registered without one.
-   */
-  getAttachmentId(channelId) {
-    return this.entries.get(channelId)?.attachmentId;
-  }
-  setHealthSink(sink) {
-    this.healthSink = sink;
-  }
-  listChannels() {
-    return [...this.entries.values()].map((e) => ({
-      id: e.adapter.id,
-      health: e.lastHealth
-    }));
-  }
-  /** Snapshot of currently registered adapters; used by the relay coordinator. */
-  listAdapters() {
-    return [...this.entries.values()].map((e) => e.adapter);
-  }
-  async register(adapter, opts = {}) {
-    if (this.stopped) {
-      throw new Error("channel manager already stopped");
-    }
-    if (this.entries.has(adapter.id)) {
-      throw new DuplicateChannelError(adapter.id);
-    }
-    const abort = new AbortController();
-    const inboundListener = (msg) => this.handleInbound(adapter.id, msg);
-    const healthListener = (sample) => {
-      const entry2 = this.entries.get(adapter.id);
-      if (entry2) entry2.lastHealth = sample;
-      this.healthSink?.(sample);
-    };
-    const startPromise = adapter.start({
-      log: (level, msg) => this.log?.(level, `[${adapter.id}] ${msg}`),
-      signal: abort.signal,
-      emitInbound: inboundListener,
-      emitHealth: healthListener
+// src/gateway/channelReconcilePlan.ts
+function planChannelReconciliation(input) {
+  const actions = [];
+  for (const error2 of input.loadErrors) {
+    actions.push({
+      kind: "load-error",
+      id: pathIdFromSidecarPath(error2.path),
+      path: error2.path,
+      reason: error2.reason
     });
-    const entry = {
-      adapter,
-      abort,
-      startPromise
-    };
-    if (opts.attachmentId !== void 0) entry.attachmentId = opts.attachmentId;
-    this.entries.set(adapter.id, entry);
-    try {
-      await startPromise;
-    } catch (err) {
-      this.entries.delete(adapter.id);
-      throw err;
-    }
   }
-  async unregister(id, reason) {
-    const entry = this.entries.get(id);
-    if (!entry) {
-      throw new UnknownChannelError(id);
+  if (input.unregisterStale) {
+    const desiredIds = new Set(
+      input.desired.map((sidecar) => sidecar.instanceId)
+    );
+    for (const id of input.currentChannelIds) {
+      if (desiredIds.has(id)) continue;
+      actions.push({ kind: "unregister-stale", id });
     }
-    this.entries.delete(id);
-    entry.abort.abort();
-    await entry.adapter.stop(reason);
   }
-  async send(channelId, msg) {
-    const entry = this.entries.get(channelId);
-    if (!entry) {
-      throw new UnknownChannelError(channelId);
+  const currentIds = new Set(input.currentChannelIds);
+  for (const sidecar of input.desired) {
+    actions.push(
+      currentIds.has(sidecar.instanceId) ? { kind: "replace", sidecar } : { kind: "register", sidecar }
+    );
+  }
+  return { actions };
+}
+function pathIdFromSidecarPath(filePath) {
+  const base = filePath.split(/[\\/]/).pop() ?? filePath;
+  return base.endsWith(".json") ? base.slice(0, -".json".length) : base;
+}
+
+// src/gateway/channelSidecarReconciler.ts
+var ChannelSidecarReconciler = class {
+  channelManager;
+  home;
+  loadSidecars;
+  instantiateAdapter;
+  stdout;
+  stderr;
+  constructor(opts) {
+    this.channelManager = opts.channelManager;
+    this.home = opts.home;
+    this.loadSidecars = opts.loadSidecars ?? loadChannelSidecars;
+    this.instantiateAdapter = opts.instantiateAdapter ?? instantiateAdapter;
+    this.stdout = opts.stdout ?? ((message) => process.stdout.write(message));
+    this.stderr = opts.stderr ?? ((message) => process.stderr.write(message));
+  }
+  async reconcile(opts) {
+    const { sidecars, errors } = this.loadSidecars(this.home);
+    const plan = planChannelReconciliation({
+      desired: sidecars,
+      currentChannelIds: this.channelManager.listChannels().map((channel) => channel.id),
+      loadErrors: errors,
+      unregisterStale: opts.unregisterStale
+    });
+    const outcomes = [];
+    for (const action of plan.actions) {
+      outcomes.push(await this.executeAction(action));
+    }
+    for (const outcome of outcomes) {
+      if (!outcome.log) continue;
+      const enabled = outcome.log.stream === "err" ? opts.logFailures : opts.logRegistrations;
+      if (!enabled) continue;
+      const write = outcome.log.stream === "err" ? this.stderr : this.stdout;
+      write(outcome.log.message);
+    }
+    return { results: outcomes.map((outcome) => outcome.result) };
+  }
+  async executeAction(action) {
+    switch (action.kind) {
+      case "load-error":
+        return {
+          result: {
+            id: action.id,
+            ok: false,
+            action: "failed",
+            reason: action.reason
+          },
+          log: {
+            stream: "err",
+            message: `athena-gateway: skipping ${action.path}: ${action.reason}
+`
+          }
+        };
+      case "unregister-stale":
+        return this.executeUnregisterStale(action.id);
+      case "replace":
+        return this.executeApply(action.sidecar, true);
+      case "register":
+        return this.executeApply(action.sidecar, false);
     }
-    return entry.adapter.send(msg);
   }
-  async probe(channelId) {
-    const entry = this.entries.get(channelId);
-    if (!entry) {
-      throw new UnknownChannelError(channelId);
+  async executeUnregisterStale(id) {
+    try {
+      await this.channelManager.unregister(id, "shutdown");
+      return { result: { id, ok: true, action: "unregistered" } };
+    } catch (err) {
+      const reason = errorReason(err);
+      return {
+        result: { id, ok: false, action: "failed", reason },
+        log: {
+          stream: "err",
+          message: `athena-gateway: unregister ${id} failed: ${reason}
+`
+        }
+      };
     }
-    return entry.adapter.probe();
   }
-  async stop(reason = "shutdown") {
-    if (this.stopped) return;
-    this.stopped = true;
-    const ids = [...this.entries.keys()];
-    for (const id of ids.reverse()) {
+  async executeApply(sidecar, existed) {
+    const id = sidecar.instanceId;
+    if (existed) {
       try {
-        await this.unregister(id, reason);
+        await this.channelManager.unregister(id, "shutdown");
       } catch (err) {
-        this.log?.(
-          "warn",
-          `channel ${id} stop failed: ${err instanceof Error ? err.message : String(err)}`
-        );
+        const reason = errorReason(err);
+        return {
+          result: { id, ok: false, action: "failed", reason },
+          log: {
+            stream: "err",
+            message: `athena-gateway: unregister ${id} failed: ${reason}
+`
+          }
+        };
       }
     }
-  }
-  handleInbound(channelId, msg) {
-    if (this.dedupSet.has(msg.idempotencyKey)) {
-      this.log?.("debug", `dropping duplicate inbound ${msg.idempotencyKey}`);
-      return;
-    }
-    this.dedupSet.add(msg.idempotencyKey);
-    this.dedup.push(msg.idempotencyKey);
-    while (this.dedup.length > this.dedupMax) {
-      const evicted = this.dedup.shift();
-      if (evicted !== void 0) this.dedupSet.delete(evicted);
-    }
-    const sink = this.inboundSink;
-    if (!sink) {
-      this.log?.(
-        "debug",
-        `no inbound sink registered; dropping ${msg.idempotencyKey}`
-      );
-      return;
+    const built = this.instantiateAdapter(sidecar);
+    if (!built.ok) {
+      return {
+        result: { id, ok: false, action: "failed", reason: built.reason },
+        log: {
+          stream: "err",
+          message: `athena-gateway: ${id}: ${built.reason}
+`
+        }
+      };
     }
     try {
-      sink(msg, { attachmentId: this.entries.get(channelId)?.attachmentId });
-    } catch (err) {
-      this.log?.(
-        "warn",
-        `inbound sink threw: ${err instanceof Error ? err.message : String(err)}`
+      await this.channelManager.register(
+        built.adapter,
+        sidecar.attachmentId !== void 0 ? { attachmentId: sidecar.attachmentId } : {}
       );
+      return {
+        result: { id, ok: true, action: existed ? "replaced" : "registered" },
+        log: {
+          stream: "out",
+          message: `athena-gateway: registered ${id}
+`
+        }
+      };
+    } catch (err) {
+      const reason = errorReason(err);
+      return {
+        result: { id, ok: false, action: "failed", reason },
+        log: {
+          stream: "err",
+          message: `athena-gateway: register ${id} failed: ${reason}
+`
+        }
+      };
     }
   }
 };
+function errorReason(err) {
+  return err instanceof Error ? err.message : String(err);
+}
 
 // src/gateway/control/handlers.ts
 import { createRequire } from "module";
@@ -2109,7 +2277,14 @@ var RuntimeBindingStore = class {
       epoch,
       ...maybeLastRebindAt(lastRebindAt)
     };
-    const slot = existing ? { ...existing, runtime, binding: newBinding } : { runtime, binding: newBinding, staleTimer: null, staleSince: null };
+    const push = input.push ?? existing?.push ?? null;
+    const slot = existing ? { ...existing, runtime, binding: newBinding, push } : {
+      runtime,
+      binding: newBinding,
+      push,
+      staleTimer: null,
+      staleSince: null
+    };
     this.clearStaleTimerForSlot(slot);
     this.slots.set(key, slot);
     if (wasStale && staleSince !== null) {
@@ -2132,9 +2307,10 @@ var RuntimeBindingStore = class {
     this.observers.onRuntimeConnectionLost?.({ runtimeId, graceful: true });
   }
   /**
-   * Called when the transport connection closes.
-   * Returns the runtimeId if the close was for a current binding (caller should
-   * clear the push handle); returns null if the connectionId was not recognised.
+   * Called when the transport connection closes. Drops the slot's push handle
+   * (immediately deleting the slot when no grace period is configured, otherwise
+   * marking it stale). Returns the runtimeId if the close matched a current
+   * binding; returns null if the connectionId was not recognised.
    */
   notifyConnectionClosed(connectionId) {
     const entry = this.findSlotByConnectionId(connectionId);
@@ -2155,6 +2331,7 @@ var RuntimeBindingStore = class {
       this.observers.onRuntimeConnectionLost?.({ runtimeId, graceful: false });
       return runtimeId;
     }
+    slot.push = null;
     slot.staleSince = now;
     slot.staleTimer = setTimeout(() => {
       this.expireStaleBinding(key, runtimeId);
@@ -2189,6 +2366,28 @@ var RuntimeBindingStore = class {
     const entry = this.findSlotByConnectionId(connectionId);
     return entry ? entry.slot.runtime.runtimeId : null;
   }
+  /**
+   * Deliver a control-push envelope to the runtime occupying `key`. Returns
+   * false (and pushes nothing) when the slot is empty or its connection has
+   * already been lost.
+   */
+  pushTo(key, env) {
+    const slot = this.slots.get(key);
+    if (!slot || !slot.push) return false;
+    slot.push(env);
+    return true;
+  }
+  /**
+   * Reportable state for every slot — both attachment-keyed and the legacy
+   * fallback — so status reporting sees all registered runtimes.
+   */
+  snapshot() {
+    const entries = [];
+    for (const [key, slot] of this.slots) {
+      entries.push({ key, runtime: slot.runtime, binding: slot.binding });
+    }
+    return entries;
+  }
   /**
    * Returns the attachment slot key (or `undefined` for the legacy slot) that
    * holds the given runtime, or `null` if no slot does. Lets callers
@@ -2241,7 +2440,7 @@ var cachedVersion = null;
 function readVersion() {
   if (cachedVersion !== null) return cachedVersion;
   try {
-    const injected = "0.5.10";
+    const injected = "0.5.13";
     if (typeof injected === "string" && injected.length > 0) {
       cachedVersion = injected;
       return cachedVersion;
@@ -2516,29 +2715,25 @@ function createDispatcher(deps) {
   return handle;
 }
 function runtimeStatusEntries(pipeline) {
-  const runtime = pipeline?.getCurrentRuntime();
-  if (!runtime || !pipeline) return [];
-  const binding = pipeline.getBinding();
-  return [
-    {
-      runtimeId: runtime.runtimeId,
-      defaultAgentId: runtime.defaultAgentId,
-      pid: runtime.pid,
-      registeredAt: runtime.registeredAt,
-      binding: binding?.state === "active" ? {
-        state: "active",
-        boundAt: binding.boundAt,
-        epoch: binding.epoch,
-        ...maybeLastRebindAt(binding.lastRebindAt)
-      } : binding?.state === "stale" ? {
-        state: "stale",
-        staleSince: binding.staleSince,
-        epoch: binding.epoch,
-        ...maybeLastRebindAt(binding.lastRebindAt)
-      } : { state: "none" },
-      pendingDispatchCount: pipeline.pendingDispatchCount()
-    }
-  ];
+  if (!pipeline) return [];
+  return pipeline.snapshotRuntimes().map(({ runtime, binding }) => ({
+    runtimeId: runtime.runtimeId,
+    defaultAgentId: runtime.defaultAgentId,
+    pid: runtime.pid,
+    registeredAt: runtime.registeredAt,
+    binding: binding?.state === "active" ? {
+      state: "active",
+      boundAt: binding.boundAt,
+      epoch: binding.epoch,
+      ...maybeLastRebindAt(binding.lastRebindAt)
+    } : binding?.state === "stale" ? {
+      state: "stale",
+      staleSince: binding.staleSince,
+      epoch: binding.epoch,
+      ...maybeLastRebindAt(binding.lastRebindAt)
+    } : { state: "none" },
+    pendingDispatchCount: pipeline.pendingDispatchCountFor(runtime.runtimeId)
+  }));
 }
 function ok(envelope, ts, payload) {
   return { request_id: envelope.request_id, ts, ok: true, payload };
@@ -2820,13 +3015,6 @@ function deriveSessionKey(loc) {
 
 // src/gateway/sessionRegistry.ts
 import { randomUUID } from "crypto";
-var UnknownDispatchError = class extends Error {
-  code = "unknown_dispatch";
-  constructor(id) {
-    super(`unknown dispatchId: ${id}`);
-    this.name = "UnknownDispatchError";
-  }
-};
 var SessionRegistry = class {
   dispatches = /* @__PURE__ */ new Map();
   idFactory;
@@ -2841,25 +3029,54 @@ var SessionRegistry = class {
       dispatchId,
       sessionKey: input.sessionKey,
       agentId: input.agentId,
+      runtimeId: input.runtimeId,
+      ...input.attachmentKey !== void 0 ? { attachmentKey: input.attachmentKey } : {},
       location: input.location,
       createdAt: this.now()
     };
     this.dispatches.set(dispatchId, entry);
     return entry;
   }
-  completeDispatch(dispatchId) {
+  /**
+   * Resolve a parked turn for the runtime claiming to complete it. The entry is
+   * consumed only when the claiming runtime matches the one the turn was
+   * dispatched to — a mismatched runtime cannot cancel or steal another
+   * runtime's turn, and an unknown id is reported rather than thrown.
+   */
+  completeDispatch(dispatchId, by) {
     const entry = this.dispatches.get(dispatchId);
     if (!entry) {
-      throw new UnknownDispatchError(dispatchId);
+      return { kind: "unknown" };
+    }
+    if (entry.runtimeId !== by.runtimeId) {
+      return { kind: "runtime_mismatch", entry };
     }
     this.dispatches.delete(dispatchId);
-    return entry;
+    return { kind: "completed", entry };
   }
   pendingDispatchCount() {
     return this.dispatches.size;
   }
-  clearDispatches() {
-    this.dispatches.clear();
+  /** Number of parked turns owned by the given runtime. */
+  pendingDispatchCountFor(runtimeId) {
+    let count = 0;
+    for (const entry of this.dispatches.values()) {
+      if (entry.runtimeId === runtimeId) count += 1;
+    }
+    return count;
+  }
+  /**
+   * Remove only the parked turns owned by the given runtime, leaving every other
+   * runtime's in-flight dispatches intact. Used when a single Registered runtime
+   * unregisters or its connection is lost — clearing the correct slot's turns
+   * without a global wipe.
+   */
+  clearDispatchesFor(runtimeId) {
+    for (const [dispatchId, entry] of this.dispatches) {
+      if (entry.runtimeId === runtimeId) {
+        this.dispatches.delete(dispatchId);
+      }
+    }
   }
 };
 
@@ -2986,8 +3203,6 @@ var DispatchPipeline = class {
   log;
   now;
   idFactory;
-  pushes = /* @__PURE__ */ new Map();
-  connectionToKey = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.bindingStore = new RuntimeBindingStore({
       gracePeriodMs: opts.gracePeriodMs,
@@ -3068,6 +3283,8 @@ var DispatchPipeline = class {
     const entry = this.registry.beginDispatch({
       sessionKey,
       agentId,
+      runtimeId: current.runtimeId,
+      ...key !== void 0 ? { attachmentKey: key } : {},
       location: inbound.location
     });
     this.pushDispatch(key, {
@@ -3079,9 +3296,7 @@ var DispatchPipeline = class {
     return { kind: "dispatched", dispatchId: entry.dispatchId, sessionKey };
   }
   pushDispatch(key, payload) {
-    const handle = this.pushes.get(key);
-    if (!handle) return;
-    handle.push({
+    this.bindingStore.pushTo(key, {
       push_id: this.idFactory(),
       ts: this.now(),
       kind: "session.dispatch.turn",
@@ -3096,17 +3311,9 @@ var DispatchPipeline = class {
       defaultAgentId: input.defaultAgentId,
       pid: input.pid,
       connectionId: input.connectionId,
+      push: input.push,
       ...input.attachmentId !== void 0 ? { attachmentId: input.attachmentId } : {}
     });
-    const previous = this.pushes.get(key);
-    if (previous && previous.connectionId !== input.connectionId) {
-      this.connectionToKey.delete(previous.connectionId);
-    }
-    this.pushes.set(key, {
-      connectionId: input.connectionId,
-      push: input.push
-    });
-    this.connectionToKey.set(input.connectionId, key);
     writeGatewayTrace(
       `pipeline registered runtime runtimeId=${input.runtimeId} connectionId=${input.connectionId}`
     );
@@ -3114,27 +3321,16 @@ var DispatchPipeline = class {
     return { registeredAt: result.registeredAt };
   }
   unregisterRuntime(runtimeId) {
-    const slot = this.findSlotByRuntimeId(runtimeId);
     this.bindingStore.unbind(runtimeId);
-    this.registry.clearDispatches();
-    if (slot) {
-      const handle = this.pushes.get(slot.key);
-      this.pushes.delete(slot.key);
-      if (handle) this.connectionToKey.delete(handle.connectionId);
-    }
+    this.registry.clearDispatchesFor(runtimeId);
     writeGatewayTrace(`pipeline unregistered runtime runtimeId=${runtimeId}`);
   }
   notifyConnectionClosed(connectionId) {
-    const key = this.connectionToKey.get(connectionId);
     const runtimeId = this.bindingStore.notifyConnectionClosed(connectionId);
     if (runtimeId === null) return;
     writeGatewayTrace(
       `pipeline runtime connection closed runtimeId=${runtimeId} connectionId=${connectionId}`
     );
-    if (key !== void 0 || this.pushes.has(key)) {
-      this.pushes.delete(key);
-      this.connectionToKey.delete(connectionId);
-    }
   }
   /**
    * Streaming run-event from a registered runtime to its outbound channel
@@ -3174,32 +3370,35 @@ var DispatchPipeline = class {
     if (!slot) {
       throw new Error("runtime mismatch on session.turn.complete");
     }
-    let entry;
-    try {
-      entry = this.registry.completeDispatch(payload.dispatchId);
-    } catch (err) {
-      if (err instanceof UnknownDispatchError) {
-        writeGatewayTrace(
-          `pipeline turn.complete unknown dispatchId=${payload.dispatchId}`
-        );
-        return { delivered: false };
-      }
-      throw err;
+    const completion = this.registry.completeDispatch(payload.dispatchId, {
+      runtimeId: payload.runtimeId
+    });
+    if (completion.kind === "unknown") {
+      writeGatewayTrace(
+        `pipeline turn.complete unknown dispatchId=${payload.dispatchId}`
+      );
+      return { delivered: false };
+    }
+    if (completion.kind === "runtime_mismatch") {
+      writeGatewayTrace(
+        `pipeline turn.complete runtime mismatch dispatchId=${payload.dispatchId} authorized=${completion.entry.runtimeId} claimed=${payload.runtimeId}`
+      );
+      return { delivered: false };
     }
-    const result = await this.sendOutbound(entry.location, payload);
+    const result = await this.sendOutbound(completion.entry.location, payload);
     writeGatewayTrace(
       `pipeline sendOutbound delivered dispatchId=${payload.dispatchId} providerMessageId=${result.providerMessageId}`
     );
     return { delivered: true, providerMessageId: result.providerMessageId };
   }
-  async sendOutbound(_parkedLocation, payload) {
+  async sendOutbound(parkedLocation, payload) {
     const out = {
-      location: payload.location,
+      location: parkedLocation,
       text: payload.text,
       idempotencyKey: payload.idempotencyKey
     };
     const result = await this.outboundDispatcher.dispatch(
-      payload.location.channelId,
+      parkedLocation.channelId,
       out
     );
     if (result.kind === "sent") return result.result;
@@ -3234,6 +3433,10 @@ var DispatchPipeline = class {
   getCurrentRuntime() {
     return this.bindingStore.getCurrent();
   }
+  /** Reportable state for every registered-runtime slot (legacy + attachment-keyed). */
+  snapshotRuntimes() {
+    return this.bindingStore.snapshot();
+  }
   getCurrentRuntimeByAttachment(attachmentId) {
     return this.bindingStore.getCurrentByAttachment(attachmentId);
   }
@@ -3249,6 +3452,9 @@ var DispatchPipeline = class {
   pendingDispatchCount() {
     return this.registry.pendingDispatchCount();
   }
+  pendingDispatchCountFor(runtimeId) {
+    return this.registry.pendingDispatchCountFor(runtimeId);
+  }
   pendingInboundCount() {
     return this.inboundQueue.size();
   }
@@ -3848,10 +4054,6 @@ function buildListenerStatus(spec, resolvedPort) {
     loopback: isLoopbackHost(spec.host)
   };
 }
-function pathIdFromSidecarPath(filePath) {
-  const base = filePath.split(/[\\/]/).pop() ?? filePath;
-  return base.endsWith(".json") ? base.slice(0, -".json".length) : base;
-}
 async function startDaemon(opts) {
   const startedAt = Date.now();
   const pid = process.pid;
@@ -3905,125 +4107,20 @@ async function startDaemon(opts) {
   channelManager.setInboundSink((inbound, ctx) => {
     pipeline.handleInbound(inbound, ctx);
   });
-  const channelConfigHome = opts.env?.HOME;
-  const reloadChannels = async () => {
-    const results = [];
-    const { sidecars, errors } = loadChannelSidecars(channelConfigHome);
-    for (const err of errors) {
-      const id = pathIdFromSidecarPath(err.path);
-      results.push({
-        id,
-        ok: false,
-        action: "failed",
-        reason: err.reason
-      });
-    }
-    const sidecarIds = new Set(sidecars.map((s) => s.instanceId));
-    for (const channel of channelManager.listChannels()) {
-      if (sidecarIds.has(channel.id)) continue;
-      try {
-        await channelManager.unregister(channel.id, "shutdown");
-        results.push({
-          id: channel.id,
-          ok: true,
-          action: "unregistered"
-        });
-      } catch (err) {
-        results.push({
-          id: channel.id,
-          ok: false,
-          action: "failed",
-          reason: err instanceof Error ? err.message : String(err)
-        });
-      }
-    }
-    for (const sidecar of sidecars) {
-      const existed = channelManager.listChannels().some((channel) => channel.id === sidecar.instanceId);
-      if (existed) {
-        try {
-          await channelManager.unregister(sidecar.instanceId, "shutdown");
-        } catch (err) {
-          results.push({
-            id: sidecar.instanceId,
-            ok: false,
-            action: "failed",
-            reason: err instanceof Error ? err.message : String(err)
-          });
-          continue;
-        }
-      }
-      const built = instantiateAdapter(sidecar);
-      if (!built.ok) {
-        results.push({
-          id: sidecar.instanceId,
-          ok: false,
-          action: "failed",
-          reason: built.reason
-        });
-        continue;
-      }
-      try {
-        await channelManager.register(
-          built.adapter,
-          sidecar.attachmentId !== void 0 ? { attachmentId: sidecar.attachmentId } : {}
-        );
-        results.push({
-          id: sidecar.instanceId,
-          ok: true,
-          action: existed ? "replaced" : "registered"
-        });
-        if (!opts.silent) {
-          process.stdout.write(
-            `athena-gateway: registered ${sidecar.instanceId}
-`
-          );
-        }
-      } catch (err) {
-        results.push({
-          id: sidecar.instanceId,
-          ok: false,
-          action: "failed",
-          reason: err instanceof Error ? err.message : String(err)
-        });
-      }
-    }
-    return { results };
-  };
+  const channelSidecarReconciler = new ChannelSidecarReconciler({
+    channelManager,
+    home: opts.env?.HOME
+  });
+  const reloadChannels = async () => channelSidecarReconciler.reconcile({
+    unregisterStale: true,
+    logRegistrations: !opts.silent
+  });
   if (!opts.skipChannelLoad) {
-    const { sidecars, errors } = loadChannelSidecars(channelConfigHome);
-    for (const err of errors) {
-      process.stderr.write(
-        `athena-gateway: skipping ${err.path}: ${err.reason}
-`
-      );
-    }
-    for (const sidecar of sidecars) {
-      const built = instantiateAdapter(sidecar);
-      if (!built.ok) {
-        process.stderr.write(
-          `athena-gateway: ${sidecar.instanceId}: ${built.reason}
-`
-        );
-        continue;
-      }
-      try {
-        await channelManager.register(
-          built.adapter,
-          sidecar.attachmentId !== void 0 ? { attachmentId: sidecar.attachmentId } : {}
-        );
-        if (!opts.silent) {
-          process.stdout.write(
-            `athena-gateway: registered ${sidecar.instanceId}
-`
-          );
-        }
-      } catch (err) {
-        process.stderr.write(
-          `athena-gateway: register ${sidecar.instanceId} failed: ${err instanceof Error ? err.message : String(err)}
-`
-        );
-      }
-    }
+    await channelSidecarReconciler.reconcile({
+      unregisterStale: false,
+      logFailures: true,
+      logRegistrations: !opts.silent
+    });
   }
   const handler = createDispatcher({
     startedAt,