niahere 0.5.5 → 0.5.6

package/package.json

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

package/src/chat/engine.ts

@@ -291,6 +291,9 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
 
         try {
           for await (const ev of sess.send(userMessage, attachments)) {
+            // Keep the lease alive while the turn runs, so a slow reply is
+            // never mistaken for a crashed one.
+            void ignore(ActiveEngine.throttledTouch(room), "touch active-engine");
             switch (ev.type) {
               case "session": {
                 if (!sessionId || ev.backendSessionId !== sessionId) {

package/src/core/engine-guard.ts

@@ -7,6 +7,7 @@
  */
 
 import { ActiveEngine } from "../db/models";
+import { isStale, type ActiveEngine as ActiveEngineRow } from "../db/models/active_engine";
 import { withDb } from "../db/with-db";
 import { DIM, RESET, ICON_WARN } from "../utils/cli";
 
@@ -38,21 +39,41 @@ export function withDefaultWait(opts: GuardOptions, defaultWaitMinutes: number):
 interface ActiveSummary {
   count: number;
   rooms: string[];
+  /** Rows nothing has pinged lately — ignored, but worth saying out loud. */
+  stale: number;
+}
+
+/**
+ * A row only counts as work if something is still pinging it. Without this a
+ * crash — or a test pointed at the wrong database — leaves a row that blocks
+ * stop, restart and update indefinitely, including the restart whose startup
+ * would have cleared it.
+ */
+export function partitionEngines(
+  engines: ActiveEngineRow[],
+  now: number = Date.now(),
+): { live: ActiveEngineRow[]; stale: ActiveEngineRow[] } {
+  const live: ActiveEngineRow[] = [];
+  const stale: ActiveEngineRow[] = [];
+  for (const e of engines) (isStale(e.lastPing, now) ? stale : live).push(e);
+  return { live, stale };
 }
 
 async function getActiveEngines(): Promise<ActiveSummary> {
   let count = 0;
   let rooms: string[] = [];
+  let stale = 0;
   try {
     await withDb(async () => {
-      const engines = await ActiveEngine.list();
-      count = engines.length;
-      rooms = engines.map((e) => `${e.room} (${e.channel})`);
+      const partitioned = partitionEngines(await ActiveEngine.list());
+      count = partitioned.live.length;
+      rooms = partitioned.live.map((e) => `${e.room} (${e.channel})`);
+      stale = partitioned.stale.length;
     });
   } catch {
     // DB unreachable — no engines to worry about
   }
-  return { count, rooms };
+  return { count, rooms, stale };
 }
 
 /**
@@ -62,7 +83,10 @@ async function getActiveEngines(): Promise<ActiveSummary> {
 export async function guardActiveEngines(action: string, opts: GuardOptions): Promise<boolean> {
   if (opts.force) return true;
 
-  const { count, rooms } = await getActiveEngines();
+  const { count, rooms, stale } = await getActiveEngines();
+  if (stale > 0) {
+    console.log(`${DIM}ignoring ${stale} stale engine row${stale > 1 ? "s" : ""} (no heartbeat)${RESET}`);
+  }
   if (count === 0) return true;
 
   // Active engines found

package/src/core/runner.ts

@@ -60,6 +60,9 @@ async function consumeBackendRun(
 
   try {
     for await (const ev of session.send(prompt)) {
+      // Keep the lease alive while the turn runs. Throttled, so a long job
+      // stays live without one write per event.
+      if (activeRoom) void ignore(ActiveEngine.throttledTouch(activeRoom), "touch active-engine");
       if (ev.type === "thinking") onActivity?.(ev.delta);
       else if (ev.type === "tool") onActivity?.(ev.summary ?? ev.name);
       else if (ev.type === "result") {

package/src/db/models/active_engine.ts

@@ -1,5 +1,21 @@
 import { getSql } from "../connection";
 
+/**
+ * How often a running turn re-stamps its row. Called from the event loops
+ * rather than a timer on purpose: a timer outlives the work it describes, so a
+ * process that died mid-turn would keep its row looking alive. A loop that
+ * stops simply stops pinging.
+ */
+export const PING_INTERVAL_MS = 30_000;
+
+/**
+ * Silence longer than this means the turn is gone, not slow — several missed
+ * pings, not one. Nothing read this column for a long time, so a row left
+ * behind by a crash (or a test aimed at the wrong database) counted as live
+ * work forever, and blocked the very restart that clears it.
+ */
+export const STALE_AFTER_MS = 3 * 60_000;
+
 export interface ActiveEngine {
   room: string;
   channel: string;
@@ -21,12 +37,45 @@ export async function ping(room: string): Promise<void> {
   await sql`UPDATE active_engines SET last_ping = NOW() WHERE room = ${room}`;
 }
 
+/** An unreadable timestamp counts as live: `--force` is the escape hatch, and
+ *  killing real work is the worse mistake. */
+export function isStale(lastPing: string, now: number = Date.now()): boolean {
+  const t = Date.parse(lastPing);
+  return Number.isFinite(t) ? now - t > STALE_AFTER_MS : false;
+}
+
+const lastTouch = new Map<string, number>();
+
+export interface TouchDeps {
+  now?: number;
+  seen?: Map<string, number>;
+  ping?: (room: string) => Promise<void>;
+}
+
+/** Re-stamp a running turn, at most once per interval. Safe to call from a hot
+ *  loop — the chat path fires per token. */
+export async function throttledTouch(room: string, deps: TouchDeps = {}): Promise<void> {
+  const now = deps.now ?? Date.now();
+  const seen = deps.seen ?? lastTouch;
+  const previous = seen.get(room);
+  if (previous !== undefined && now - previous < PING_INTERVAL_MS) return;
+  seen.set(room, now);
+  await (deps.ping ?? ping)(room);
+}
+
+/** Forget a room's throttle state so a later turn pings immediately. */
+export function forgetTouch(room: string): void {
+  lastTouch.delete(room);
+}
+
 export async function unregister(room: string): Promise<void> {
+  forgetTouch(room);
   const sql = getSql();
   await sql`DELETE FROM active_engines WHERE room = ${room}`;
 }
 
 export async function clearAll(): Promise<void> {
+  lastTouch.clear();
   const sql = getSql();
   await sql`DELETE FROM active_engines`;
 }