niahere 0.4.6 → 0.5.1

package/src/chat/engine.ts

@@ -4,15 +4,22 @@ import { buildSystemPrompt, buildContextSuffix, getSessionContext } from "./iden
 import { buildEmployeePrompt } from "./employee-prompt";
 import { getEmployee } from "../core/employees";
 import { getAgentDefinitions, scanAgents } from "../core/agents";
+import { gapMarker } from "./gap-marker";
+import { getConfig } from "../utils/config";
 import { Session, Message, ActiveEngine, Job } from "../db/models";
 import type { Attachment, SendResult, SendCallbacks, ChatEngine, EngineOptions } from "../types";
 import { finalizeSession, cancelPending } from "../core/finalizer";
 import { log } from "../utils/log";
+import { asError, errMsg, ignore } from "../utils/errors";
 import { registerActiveHandle, unregisterActiveHandle } from "../core/active-handles";
 import { resolveJobPrompt } from "../core/job-prompt";
-import { resolveBackends, type AgentSession } from "../agent";
+import { truncate } from "../utils/format-activity";
+import { resolveChain, ChainCursor, describeEntry, type AgentSession, type FailoverScope } from "../agent";
+import { scopeOf, parseFailure } from "../agent/failure";
 
 const IDLE_TIMEOUT = 10 * 60 * 1000; // 10 minutes
+const HANDOFF_MESSAGES = 20;
+const HANDOFF_CHARS = 2000;
 const LONG_RUNNING_WARN = 30 * 60 * 1000; // 30 minutes
 const GENERIC_CHAT_ERROR = "💀";
 
@@ -29,8 +36,7 @@ export function formatChatError(rawError: string | null | undefined): string {
 }
 
 export function getChatErrorSignal(rawError: string | null | undefined): SendResult["signal"] | undefined {
-  const error = rawError?.trim();
-  return !error || error.toLowerCase() === "unknown error" ? "provider_down" : undefined;
+  return scopeOf(parseFailure(rawError), "provider") === "provider" ? "provider_down" : undefined;
 }
 
 export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine> {
@@ -96,11 +102,10 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
     systemPrompt += `\n\n## Watch Mode — #${watchChannel}\n\nYou are monitoring this Slack channel. Follow the behavior instructions below.\nRespond with [NO_REPLY] if no action is needed — do not explain why.\n\n${behavior}`;
   }
 
-  // The backend chain: configured primary first, then provider-down fallbacks.
-  // Chat normally runs on the primary; a provider-down turn fails over to the
-  // next backend (answering the current message — see send()).
-  const backends = resolveBackends();
-  let backendIndex = 0;
+  // A turn that cannot be served moves down the chain and answers the current
+  // message there (see send()).
+  const chain = resolveChain();
+  let cursor = new ChainCursor(chain);
 
   let sessionId: string | null = null;
   if (typeof resume === "string") {
@@ -110,13 +115,15 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
     sessionId = await Session.getLatest(room);
   }
 
-  // Verify the primary backend can actually resume this session before
-  // attempting it (Claude probes the on-disk jsonl; others use their own check).
-  if (sessionId && !(await backends[0]!.canResume(sessionId, cwd))) {
+  // Only resume if the head of the chain can actually take this session id.
+  if (sessionId && !(await cursor.current!.backend.canResume(sessionId, cwd))) {
     sessionId = null;
   }
 
   let session: AgentSession | null = null;
+  // Prior turns, replayed into the system prompt when a failover starts a fresh
+  // session on another backend — the new one has no session to resume.
+  let handoff = "";
   let idleTimer: ReturnType<typeof setTimeout> | null = null;
   let longRunningTimer: ReturnType<typeof setTimeout> | null = null;
   let messageCount = 0;
@@ -165,22 +172,34 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
     clearIdleTimer();
     clearLongRunningTimer();
     if (session) {
-      await session.close().catch(() => {});
+      await ignore(session.close(), "close chat session");
       session = null;
     }
     unregisterActiveHandle(room);
   }
 
-  /** Lazily open (and reuse) the current backend's session for this engine. */
+  /** Transcript of the conversation so far, for a backend that cannot resume it. */
+  async function buildHandoff(currentMessage: string): Promise<string> {
+    const recent = await Message.getRecent(HANDOFF_MESSAGES, room).catch(() => []);
+    const lines = recent
+      .filter((m) => m.content !== currentMessage)
+      .map((m) => `${m.sender === "nia" ? "Nia" : "User"}: ${truncate(m.content, HANDOFF_CHARS)}`);
+    if (lines.length === 0) return "";
+    return `\n\n## Conversation So Far\nYou are continuing this conversation after switching models mid-turn.\n\n${lines.join("\n")}`;
+  }
+
+  /** Lazily open (and reuse) the current chain entry's session for this engine. */
   async function ensureSession(): Promise<AgentSession> {
     if (session) return session;
-    const backend = backends[backendIndex] ?? backends[0]!;
-    const s = await backend.openSession({
+    const entry = cursor.current!;
+    const s = await entry.backend.openSession({
       room,
       channel,
-      systemPrompt,
+      systemPrompt: systemPrompt + handoff,
       cwd,
-      model: contextModel ?? undefined,
+      // A context override names a model for the configured provider, so it
+      // only applies at the head of the chain.
+      model: (cursor.atHead ? (contextModel ?? entry.model) : entry.model) ?? undefined,
       mcpServers,
       resume: sessionId ?? false,
       subagents: getAgentDefinitions(),
@@ -202,7 +221,26 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
       return room;
     },
 
-    async send(userMessage: string, callbacks?: SendCallbacks, attachments?: Attachment[]) {
+    async send(rawMessage: string, callbacks?: SendCallbacks, attachments?: Attachment[]) {
+      // Date the turn when time has visibly passed. Computed before anything is
+      // saved, and used for BOTH the send and the save so the stored record is
+      // exactly what the model received.
+      const marker = gapMarker(new Date(), await Message.getLastAt(room).catch(() => null), getConfig().timezone);
+      const userMessage = marker ? `${marker}\n${rawMessage}` : rawMessage;
+
+      // Re-probe from the top once the failed provider's cooldown lapses, so a
+      // brief outage does not pin the conversation to the fallback for good.
+      if (!cursor.atHead) {
+        const fresh = new ChainCursor(chain);
+        if (fresh.current !== cursor.current) {
+          log.info({ room, to: fresh.current && describeEntry(fresh.current) }, "chat returning to preferred model");
+          cursor = fresh;
+          handoff = await buildHandoff("");
+          await teardown();
+          sessionId = null;
+        }
+      }
+
       // Clear idle timer — engine is not idle while processing a request
       clearIdleTimer();
       startLongRunningTimer();
@@ -210,7 +248,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
 
       // Cancel any pending finalization — session is active again
       if (sessionId) {
-        cancelPending(sessionId).catch(() => {});
+        void ignore(cancelPending(sessionId), "cancel pending finalization");
       }
 
       await ActiveEngine.register(room, channel);
@@ -227,12 +265,22 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
 
       let result: SendResult = { result: "", costUsd: 0, turns: 0 };
 
-      // Run the turn on the current backend; on a provider-down result, fail over
-      // to the next backend and answer the current message there.
+      // Run the turn on the current chain entry; a turn that cannot be served
+      // moves down the chain and answers the current message there.
       while (true) {
-        const sess = await ensureSession();
+        let sess: AgentSession;
+        try {
+          sess = await ensureSession();
+        } catch (err) {
+          // A backend that cannot start must not take the turn down.
+          const next = cursor.advance("provider");
+          log.warn({ room, err: String(err), to: next && describeEntry(next) }, "chat backend failed to start");
+          if (!next) throw asError(err);
+          handoff = await buildHandoff(userMessage);
+          continue;
+        }
         let accumulated = "";
-        let providerDown = false;
+        let failover: FailoverScope | undefined;
 
         try {
           for await (const ev of sess.send(userMessage, attachments)) {
@@ -279,13 +327,13 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
                     messageId = await Message.save({ ...saveParams, metadata: undefined });
                   }
                   await Session.touch(sessionId);
-                  Session.accumulateMetadata(sessionId, { ...(ev.metadata ?? {}), channel }).catch(() => {});
+                  void ignore(Session.accumulateMetadata(sessionId, { ...(ev.metadata ?? {}), channel }), "accumulate session metadata");
                 }
                 result = { result: ev.text, costUsd, turns, messageId };
                 break;
               }
               case "error": {
-                providerDown = ev.providerDown;
+                failover = ev.failover;
                 log.error(
                   { room, error: ev.message, terminal_reason: ev.terminalReason },
                   "chat send failed with backend error",
@@ -294,29 +342,30 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
                   result: formatChatError(ev.message),
                   costUsd: 0,
                   turns: 0,
-                  signal: ev.providerDown ? "provider_down" : undefined,
+                  signal: ev.failover === "provider" ? "provider_down" : undefined,
                 };
                 break;
               }
             }
           }
         } catch (err) {
-          await ActiveEngine.unregister(room).catch(() => {});
+          await ignore(ActiveEngine.unregister(room), "unregister active-engine");
           clearLongRunningTimer();
           inFlight = false;
           if (sess.backendSessionId) sessionId = sess.backendSessionId;
-          throw err instanceof Error ? err : new Error(String(err));
+          throw asError(err);
         }
 
         // Re-read the backend session id post-send so finalize/DB target it.
         if (sess.backendSessionId) sessionId = sess.backendSessionId;
 
-        if (providerDown && backendIndex < backends.length - 1) {
-          backendIndex++;
-          log.warn({ room, to: backends[backendIndex]!.name }, "chat provider down, failing over to next backend");
-          await teardown(); // close the dead session so ensureSession opens the next backend
+        const next = failover && cursor.advance(failover);
+        if (next) {
+          log.warn({ room, to: describeEntry(next), scope: failover }, "chat failing over to next model");
+          await teardown(); // close the dead session so ensureSession opens the next entry
           sessionId = null; // a cross-backend session id is meaningless; start fresh
-          userSaved = false; // re-save the user turn under the new backend's session
+          userSaved = false; // re-save the user turn under the new session
+          handoff = await buildHandoff(userMessage);
           continue;
         }
         break;
@@ -339,7 +388,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
         }
       }
       await teardown();
-      await ActiveEngine.unregister(room).catch(() => {});
+      await ignore(ActiveEngine.unregister(room), "unregister active-engine");
     },
   };
 }

package/src/chat/gap-marker.ts

@@ -0,0 +1,63 @@
+/**
+ * Dates a user turn when time has visibly passed.
+ *
+ * A resumed session replays its transcript with no timestamps, so a reply from
+ * three days ago reads as present-tense — ask "what should I wear?" twice in a
+ * week and the model happily repeats Monday's weather. The marker is prefixed
+ * onto the turn that is sent AND stored, so the transcript dates itself from
+ * then on.
+ */
+
+const MINUTE_MS = 60_000;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+
+/** Gap that counts as "time has passed" even within one day. */
+export const GAP_THRESHOLD_MS = 2 * HOUR_MS;
+
+const LOCALE = "en-US";
+
+function localDay(date: Date, timezone: string): string {
+  return new Intl.DateTimeFormat("en-CA", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    timeZone: timezone,
+  }).format(date);
+}
+
+function plural(n: number, unit: string): string {
+  return `${n} ${unit}${n === 1 ? "" : "s"}`;
+}
+
+/** Floored, never rounded up: the absolute stamp alongside it carries the
+ *  precision, so this should not claim more time passed than actually did. */
+function elapsed(ms: number): string {
+  if (ms >= DAY_MS) return plural(Math.floor(ms / DAY_MS), "day");
+  if (ms >= HOUR_MS) return plural(Math.floor(ms / HOUR_MS), "hour");
+  return plural(Math.max(1, Math.floor(ms / MINUTE_MS)), "minute");
+}
+
+/**
+ * The prefix for this turn, or null when the conversation is still continuous.
+ * Fires when the local date has changed or the gap exceeds the threshold.
+ */
+export function gapMarker(now: Date, last: Date | null, timezone: string): string | null {
+  if (!last) return null;
+
+  const gap = now.getTime() - last.getTime();
+  const dayChanged = localDay(now, timezone) !== localDay(last, timezone);
+  if (gap < GAP_THRESHOLD_MS && !dayChanged) return null;
+
+  const stamp = new Intl.DateTimeFormat(LOCALE, {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    timeZone: timezone,
+  }).format(now);
+
+  return `[${stamp} — ${elapsed(gap)} since the last message]`;
+}

package/src/chat/repl.ts

@@ -1,4 +1,5 @@
 import * as readline from "readline";
+import { errMsg, ignore } from "../utils/errors";
 import { createChatEngine } from "./engine";
 import { runMigrations } from "../db/migrate";
 import { closeDb } from "../db/connection";
@@ -118,7 +119,7 @@ export async function startRepl(
   try {
     await runMigrations();
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+    const msg = errMsg(err);
     console.error(`Failed to connect to postgres: ${msg}`);
     console.error(`Set database_url in ~/.niahere/config.yaml or run \`nia init\``);
     process.exit(1);
@@ -218,7 +219,7 @@ export async function startRepl(
       process.stdout.write("\n\n");
     } catch (err) {
       status.stop();
-      const msg = err instanceof Error ? err.message : String(err);
+      const msg = errMsg(err);
       console.error(`\n${DIM}error:${RESET} ${msg}\n`);
     }
   }
@@ -252,9 +253,8 @@ export async function startRepl(
   rl.on("close", async () => {
     console.log(`\n${DIM}bye${RESET}`);
     await engine.close();
-    closeDb()
-      .catch(() => {})
-      .finally(() => process.exit(0));
+    await ignore(closeDb(), "close db on exit");
+    process.exit(0);
   });
 
   process.on("SIGINT", () => {

package/src/cli/config.ts

@@ -0,0 +1,71 @@
+import { readRawConfig, updateRawConfig } from "../utils/config";
+
+const USAGE = [
+  "Usage: nia config <set|get|list>",
+  "  nia config set <key> <value>  — set a config value",
+  "  nia config get <key>          — get a config value",
+  "  nia config list               — show all config",
+].join("\n");
+
+/** Booleans and integers are written as their real types, not strings. */
+function parseValue(raw: string): unknown {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (/^\d+$/.test(raw)) return Number(raw);
+  return raw;
+}
+
+/** Expand `a.b.c` into `{ a: { b: { c: value } } }` for a merging write. */
+function nest(key: string, value: unknown): Record<string, unknown> {
+  const parts = key.split(".");
+  const root: Record<string, unknown> = {};
+  let cursor = root;
+  for (const part of parts.slice(0, -1)) {
+    cursor[part] = {};
+    cursor = cursor[part] as Record<string, unknown>;
+  }
+  cursor[parts[parts.length - 1]!] = value;
+  return root;
+}
+
+function readPath(raw: unknown, key: string): unknown {
+  let val = raw;
+  for (const part of key.split(".")) {
+    if (val && typeof val === "object") val = (val as Record<string, unknown>)[part];
+    else return undefined;
+  }
+  return val;
+}
+
+export async function configCommand(sub?: string, key?: string, value?: string): Promise<void> {
+  if (sub === "set" && key) {
+    if (!value) {
+      console.error("Usage: nia config set <key> <value>");
+      process.exit(1);
+    }
+    updateRawConfig(nest(key, parseValue(value)));
+    console.log(`${key} = ${value}`);
+    return;
+  }
+
+  if (sub === "get" && key) {
+    const val = readPath(readRawConfig(), key);
+    if (val === undefined) {
+      console.log(`${key}: (not set)`);
+    } else if (typeof val === "object") {
+      const yaml = (await import("js-yaml")).default;
+      console.log(yaml.dump(val, { lineWidth: -1 }).trim());
+    } else {
+      console.log(`${key} = ${val}`);
+    }
+    return;
+  }
+
+  if (!sub || sub === "list") {
+    const yaml = (await import("js-yaml")).default;
+    console.log(yaml.dump(readRawConfig(), { lineWidth: -1 }).trim());
+    return;
+  }
+
+  console.log(USAGE);
+}