niahere 0.5.11 → 0.5.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.5.11",
+  "version": "0.5.13",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {

package/src/channels/common/coalesce.ts

@@ -37,9 +37,51 @@ export interface CoalescerOptions {
   maxBatch?: number;
   /** Defaults to serializing internally, which suits a caller with no lock. */
   schedule?: Schedule;
+  /**
+   * Consecutive turns whose reply may be folded forward before one is sent
+   * regardless. A room that never goes quiet must still get an answer.
+   */
+  maxDeferrals?: number;
 }
 
 const DEFAULT_MAX_BATCH = 10;
+const DEFAULT_MAX_DEFERRALS = 2;
+
+/**
+ * What a running turn can ask about its own standing.
+ *
+ * Coalescing answers the question "which messages share a turn". It cannot
+ * answer "is this reply still worth sending", because the message that
+ * obsoletes a reply arrives while the turn that produces it is still running.
+ * Roughly one in eight messages to the Slack DM lands mid-turn, and the ones
+ * that do are corrections — "i meant browser" sat 49 seconds behind an answer
+ * to the question it replaced, and that answer went out first.
+ */
+export interface TurnControl {
+  /**
+   * True when a newer message for this room is already queued, so this reply
+   * answers a superseded question. Fold it forward instead of sending: the
+   * text stays in the session, so the next turn can restate whatever still
+   * matters and answer both in one reply.
+   *
+   * Decided on first call and stable thereafter — a message landing during
+   * delivery must not retroactively unsend a reply.
+   */
+  superseded(): boolean;
+
+  /**
+   * True when the turn before this one folded its reply forward. That text is
+   * in the session, so without being told otherwise the model reads its own
+   * undelivered answer and writes "as I said above" about something nobody
+   * saw. This turn's reply has to cover both.
+   */
+  readonly previousReplyWithheld: boolean;
+}
+
+interface TurnControlInternal extends TurnControl {
+  /** Whether `superseded()` was both asked and answered yes. */
+  readonly deferred: boolean;
+}
 
 export interface Coalescer {
   /** Offer a message. Runs now, or joins the next batch. */
@@ -49,12 +91,28 @@ export interface Coalescer {
 }
 
 export function createCoalescer(
-  process: (batch: Pending[]) => Promise<void>,
+  process: (batch: Pending[], turn: TurnControl) => Promise<void>,
   options: CoalescerOptions = {},
 ): Coalescer {
   const maxBatch = Math.max(1, options.maxBatch ?? DEFAULT_MAX_BATCH);
+  const maxDeferrals = Math.max(0, options.maxDeferrals ?? DEFAULT_MAX_DEFERRALS);
   const queue: Pending[] = [];
   let scheduled = false;
+  let deferrals = 0;
+
+  function control(canDefer: boolean, previousReplyWithheld: boolean): TurnControlInternal {
+    let decided: boolean | null = null;
+    return {
+      previousReplyWithheld,
+      superseded() {
+        if (decided === null) decided = canDefer && queue.length > 0;
+        return decided;
+      },
+      get deferred() {
+        return decided === true;
+      },
+    };
+  }
 
   // Two chains, deliberately separate. `lockChain` is the fallback scheduler for
   // a caller with no lock of its own; `idleChain` only tracks completion so
@@ -78,8 +136,14 @@ export function createCoalescer(
         scheduled = false;
         const batch = queue.splice(0, maxBatch);
         if (batch.length === 0) return;
+        // `deferrals` resets whenever a turn replies, so a non-zero count means
+        // the turn immediately before this one withheld its reply.
+        const turn = control(deferrals < maxDeferrals, deferrals > 0);
         // A turn that throws must not strand the messages queued behind it.
-        await process(batch).catch(() => {});
+        await process(batch, turn).catch(() => {});
+        // A turn that replied clears the run; only folded-forward ones count
+        // toward the cap.
+        deferrals = turn.deferred ? deferrals + 1 : 0;
         if (queue.length > 0) kick();
       } finally {
         settle();
@@ -108,18 +172,27 @@ export function createCoalescer(
  * three redundant replies into one *incomplete* reply would be worse than the
  * behaviour it replaces.
  */
-export function mergeMessages(items: Pending[]): Pending {
+export function mergeMessages(items: Pending[], previousReplyWithheld = false): Pending {
   const attachments = items.flatMap((i) => i.attachments ?? []);
   const parts = items.map((i) => i.text.trim()).filter((t) => t.length > 0);
 
-  if (items.length === 1) return { text: items[0]!.text, attachments };
-  if (parts.length === 0) return { text: "", attachments };
-  if (parts.length === 1) return { text: parts[0]!, attachments };
+  const notes: string[] = [];
+  if (previousReplyWithheld) notes.push(WITHHELD_NOTE);
+  if (parts.length > 1) {
+    notes.push(`[${parts.length} messages arrived together while you were working. Answer all of them.]`);
+  }
+
+  const body =
+    items.length === 1 ? items[0]!.text : parts.length === 0 ? "" : parts.length === 1 ? parts[0]! : parts.join("\n\n");
 
-  const header = `[${parts.length} messages arrived together while you were working. Answer all of them.]`;
-  return { text: `${header}\n\n${parts.join("\n\n")}`, attachments };
+  if (notes.length === 0) return { text: body, attachments };
+  return { text: `${notes.join("\n")}\n\n${body}`, attachments };
 }
 
+const WITHHELD_NOTE =
+  "[Your last reply was not sent — this arrived before it went out, so the user has never seen it. " +
+  "Cover anything from it that still matters.]";
+
 /** An inbound message plus whatever the channel needs to answer it. */
 export interface Inbound<C> extends Pending {
   ctx: C;
@@ -145,7 +218,7 @@ export interface TurnPump<K, C> {
  */
 export function createTurnPump<K, C>(
   lockFor: (key: K) => Schedule,
-  run: (key: K, batch: Inbound<C>[], merged: Pending) => Promise<void>,
+  run: (key: K, batch: Inbound<C>[], merged: Pending, turn: TurnControl) => Promise<void>,
   options: CoalescerOptions = {},
 ): TurnPump<K, C> {
   const queues = new Map<K, Coalescer>();
@@ -154,8 +227,8 @@ export function createTurnPump<K, C>(
     let q = queues.get(key);
     if (!q) {
       q = createCoalescer(
-        async (batch) => {
-          await run(key, batch as Inbound<C>[], mergeMessages(batch));
+        async (batch, turn) => {
+          await run(key, batch as Inbound<C>[], mergeMessages(batch, turn.previousReplyWithheld), turn);
         },
         { ...options, schedule: lockFor(key) },
       );

package/src/channels/common/reply.ts

@@ -1,3 +1,5 @@
+import type { TurnControl } from "./coalesce";
+
 /**
  * What counts as a reply, and what is just the model talking to itself.
  *
@@ -77,3 +79,39 @@ export function decideWatchReply(structured: unknown, raw: string): WatchDecisio
   }
   return { send: true, text: trimmed, source: "sentinel" };
 }
+
+export interface Delivery {
+  /** Whether to put the text in front of the reader now. */
+  post: boolean;
+  /** The reply text. Kept even when held back, so the caller can log it. */
+  text: string;
+  /** Which path judged the reply. */
+  source: WatchDecision["source"];
+  /** Why it is not being posted. */
+  reason?: "silent" | "ambiguous" | "superseded";
+}
+
+/**
+ * The whole judgement on a finished turn's reply: is there anything to say,
+ * and is it still worth saying.
+ *
+ * Order matters. A turn that chose silence is never asked whether it was
+ * superseded — it withheld nothing, and most watch-channel turns are silent,
+ * so charging them a deferral would exhaust the cap on rooms that never
+ * deferred anything.
+ */
+export function decideDelivery(structured: unknown, raw: string, turn: Pick<TurnControl, "superseded">): Delivery {
+  const decision = decideWatchReply(structured, raw);
+  if (!decision.send) {
+    return {
+      post: false,
+      text: decision.text,
+      source: decision.source,
+      reason: decision.ambiguous ? "ambiguous" : "silent",
+    };
+  }
+  if (turn.superseded()) {
+    return { post: false, text: decision.text, source: decision.source, reason: "superseded" };
+  }
+  return { post: true, text: decision.text, source: decision.source };
+}

package/src/channels/index.ts

@@ -1,6 +1,7 @@
 import type { Channel } from "../types";
-import { registerChannel, getFactories, trackStarted, clearStarted, getStarted } from "./registry";
+import { registerChannel, getFactories, trackStarted, clearStarted, getStarted, untrackStarted } from "./registry";
 import { log } from "../utils/log";
+import { ignore } from "../utils/errors";
 import { getConfig } from "../utils/config";
 import { createTelegramChannel } from "./telegram";
 import { createSlackChannel } from "./slack";
@@ -20,6 +21,8 @@ export function registerAllChannels(): void {
   registerChannel(() => createWhatsAppChannel());
 }
 
+let reconciling = false;
+
 export interface StartResult {
   started: Channel[];
   failed: string[];
@@ -72,8 +75,26 @@ export async function startChannels(only?: readonly string[]): Promise<StartResu
  * `startChannels` abandons the failed channels with no retry, so without
  * reconciliation Nia stays alive but deaf on every channel until a manual
  * restart. The alive monitor calls this every healthy heartbeat.
+ *
+ * It also covers the reverse case, where a channel is tracked as running but
+ * its transport has died underneath it. Being in the registry was the only
+ * liveness anyone checked, so such a channel was never retried; `healthy()`
+ * lets a channel say otherwise and get rebuilt.
  */
 export async function reconcileChannels(): Promise<StartResult> {
+  // Bringing a channel up can block for as long as its transport takes to
+  // connect. Without this, a slow start would let the next heartbeat reconcile
+  // the same channel again and leave two of them running.
+  if (reconciling) return { started: [], failed: [] };
+  reconciling = true;
+  try {
+    return await reconcile();
+  } finally {
+    reconciling = false;
+  }
+}
+
+async function reconcile(): Promise<StartResult> {
   const wanted = getConfiguredChannelNames();
   const running = getStarted();
   const runningNames = new Set(running.map((ch) => ch.name));
@@ -81,9 +102,11 @@ export async function reconcileChannels(): Promise<StartResult> {
 
   const missing = wanted.filter((name) => !runningNames.has(name));
   const extra = running.filter((ch) => !wantedSet.has(ch.name));
-  if (missing.length === 0 && extra.length === 0) return { started: [], failed: [] };
+  const dead = running.filter((ch) => wantedSet.has(ch.name) && ch.healthy?.() === false);
+  if (missing.length === 0 && extra.length === 0 && dead.length === 0) return { started: [], failed: [] };
 
-  log.warn({ missing, extra: extra.map((ch) => ch.name) }, "channels out of sync, reconciling");
+  const deadNames = dead.map((ch) => ch.name);
+  log.warn({ missing, extra: extra.map((ch) => ch.name), dead: deadNames }, "channels out of sync, reconciling");
 
   // A channel was removed from config. stopChannels() tears down the whole
   // registry (it stops the shared Twilio server and clears all tracking), so a
@@ -93,9 +116,16 @@ export async function reconcileChannels(): Promise<StartResult> {
     return wanted.length > 0 ? startChannels() : { started: [], failed: [] };
   }
 
-  // Only additions: start just the missing channels so healthy ones stay
-  // connected and one persistently-failing channel can't thrash the rest.
-  return startChannels(missing);
+  // Tear the dead ones down individually so healthy channels stay connected. A
+  // stop that fails must not block the restart — the point is to replace them.
+  for (const channel of dead) {
+    await ignore(channel.stop(), `stopping dead channel ${channel.name}`);
+    untrackStarted(channel.name);
+  }
+
+  // Start just the channels that need it so healthy ones stay connected and one
+  // persistently-failing channel can't thrash the rest.
+  return startChannels([...missing, ...deadNames]);
 }
 
 export function getConfiguredChannelNames(): string[] {

package/src/channels/registry.ts

@@ -11,6 +11,10 @@ export function getFactories(): readonly ChannelFactory[] {
   return factories;
 }
 
+export function clearFactories(): void {
+  factories.length = 0;
+}
+
 export function trackStarted(channel: Channel): void {
   started.set(channel.name, channel);
 }
@@ -23,6 +27,10 @@ export function getStarted(): Channel[] {
   return [...started.values()];
 }
 
+export function untrackStarted(name: string): void {
+  started.delete(name);
+}
+
 export function clearStarted(): void {
   started.clear();
 }

package/src/channels/slack.ts

@@ -1,4 +1,4 @@
-import { App } from "@slack/bolt";
+import { App, SocketModeReceiver } from "@slack/bolt";
 import type { WebClient } from "@slack/web-api";
 import type { Channel, ChatState, Attachment, Outbound, Recipient } from "../types";
 import { getConfig, updateRawConfig } from "../utils/config";
@@ -12,11 +12,50 @@ import { ChatSessions, chainLock } from "./common/chat-session";
 import { SlackAttachmentCache } from "./slack/attachments";
 import { SlackWatchReloader } from "./slack/watch";
 
-import { decideWatchReply, shouldSuppressReply } from "./common/reply";
+import { decideDelivery, shouldSuppressReply } from "./common/reply";
 import { createTurnPump } from "./common/coalesce";
 
 const logActivity = (status: string) => log.debug({ status }, "slack engine activity");
 
+/** A healthy reconnect lands in seconds, so a gap this long is not one in progress. */
+const SOCKET_STALL_MS = 3 * 60_000;
+
+/** Every Socket Mode state that is not "carrying events right now". */
+const DISCONNECTED_STATES = ["connecting", "reconnecting", "disconnecting", "disconnected"] as const;
+
+interface SocketStateEmitter {
+  on(event: string, listener: () => void): unknown;
+}
+
+/**
+ * Whether Socket Mode is actually carrying events, as opposed to merely having
+ * been started.
+ *
+ * Socket Mode can stop trying without saying so: a transport-level failure of
+ * `apps.connections.open` is classed unrecoverable, and the resulting rejection
+ * escapes an unawaited reconnect chain. The process stays up and the tokens stay
+ * valid, so nothing outside the socket can tell it is never coming back.
+ */
+export class SocketLiveness {
+  private downSince: number | null = null;
+
+  constructor(client: SocketStateEmitter) {
+    client.on("connected", () => {
+      if (this.downSince !== null) log.info("slack: socket connected");
+      this.downSince = null;
+    });
+    for (const state of DISCONNECTED_STATES) {
+      client.on(state, () => {
+        this.downSince ??= Date.now();
+      });
+    }
+  }
+
+  stalled(now = Date.now()): boolean {
+    return this.downSince !== null && now - this.downSince >= SOCKET_STALL_MS;
+  }
+}
+
 /** What answering a Slack message needs, carried per message so a coalesced
  *  turn can still reply in the right thread and clear every reaction. */
 interface SlackTurnCtx {
@@ -51,6 +90,11 @@ class SlackChannel implements Channel {
   private dmUserId: string | null = null;
   /** Timestamps of messages Nia posted proactively (used to detect replies to our own messages) */
   private outboundTs = new Set<string>();
+  private liveness: SocketLiveness | null = null;
+
+  healthy(): boolean {
+    return !this.liveness?.stalled();
+  }
 
   async deliver(out: Outbound): Promise<void> {
     if (!this.app) throw new Error("Slack not started");
@@ -155,7 +199,7 @@ class SlackChannel implements Channel {
      */
     const slackPump = createTurnPump<string, SlackTurnCtx>(
       (key) => (fn) => withLock(key, fn),
-      async (key, batch, merged) => {
+      async (key, batch, merged, turn) => {
         // The newest message decides where the reply goes; every message in the
         // batch needs its own reaction cleared.
         const last = batch[batch.length - 1]!.ctx;
@@ -222,17 +266,23 @@ class SlackChannel implements Channel {
             return;
           }
 
-          const decision = decideWatchReply(structured, result);
-          const reply = decision.text;
+          const delivery = decideDelivery(structured, result, turn);
+          const reply = delivery.text;
 
-          if (!decision.send) {
-            if (decision.ambiguous) {
+          if (!delivery.post) {
+            if (delivery.reason === "ambiguous") {
               log.warn(
-                { channel: msg.channel, key, reply: result.trim(), source: decision.source },
+                { channel: msg.channel, key, reply: result.trim(), source: delivery.source },
                 "slack: [NO_REPLY] sentinel mixed with content; suppressing send",
               );
+            } else if (delivery.reason === "superseded") {
+              // The text stays in the session, so the next turn answers both.
+              log.info(
+                { channel: msg.channel, key, chars: reply.length },
+                "slack: reply superseded by a newer message; folding into the next turn",
+              );
             } else {
-              log.info({ channel: msg.channel, key, source: decision.source }, "slack: agent chose not to reply");
+              log.info({ channel: msg.channel, key, source: delivery.source }, "slack: agent chose not to reply");
             }
             if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
             return;
@@ -269,10 +319,14 @@ class SlackChannel implements Channel {
 
     const self = this;
 
+    const receiver = new SocketModeReceiver({ appToken });
+    this.liveness = new SocketLiveness(receiver.client);
+
     const app = new App({
       token: botToken,
       appToken,
       socketMode: true,
+      receiver,
     });
 
     let botUserId: string | undefined;
@@ -566,6 +620,7 @@ class SlackChannel implements Channel {
     if (this.app) {
       await this.app.stop();
       this.app = null;
+      this.liveness = null;
     }
   }
 }

package/src/types/channel.ts

@@ -31,6 +31,13 @@ export interface Channel {
   name: string;
   start(): Promise<void>;
   stop(): Promise<void>;
+  /**
+   * Whether the channel can still receive. Implement it wherever having started
+   * is not the same as being connected — a transport can die under a process
+   * that stays up, and no caller above this seam can tell. Omit it and the
+   * channel is assumed healthy for as long as it is running.
+   */
+  healthy?(): boolean;
   /**
    * Deliver an outbound payload. Channels are expected to handle either
    * a text-only, media-only, or text+media payload; format details (chunking,