niahere 0.5.7 → 0.5.8

package/package.json

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

package/src/agent/backends/claude-normalize.ts

@@ -90,6 +90,15 @@ function attribute(modelUsage: unknown): Record<string, unknown> | undefined {
  * stay backend-agnostic.
  */
 export class SdkNormalizer implements Normalizer {
+  /**
+   * The SDK's `apiKeySource` only describes where an *API key* came from: it
+   * reports "none" for every OAuth path, so it cannot tell a configured token
+   * from the CLI's inherited login. Nia resolved the credential itself, so it
+   * records that too — the SDK's value is kept because it is genuinely
+   * informative when an API key is in play.
+   */
+  constructor(private readonly credential?: string) {}
+
   private apiKeySource: string | undefined;
   private accumulatedThinking = "";
   private lastThinkingLine = "";
@@ -217,6 +226,7 @@ export class SdkNormalizer implements Normalizer {
           session_id: msg.session_id,
           subtype: msg.subtype,
           api_key_source: this.apiKeySource,
+          credential: this.credential,
           usage: msg.usage,
           model_usage: attribute(msg.modelUsage),
         },

package/src/agent/backends/claude.ts

@@ -128,7 +128,7 @@ class ClaudeSession implements AgentSession {
     while (true) {
       if (!this.iterator || !this.stream) this.startQuery();
       this.stream!.push(text, attachments);
-      const normalizer = new SdkNormalizer();
+      const normalizer = new SdkNormalizer(resolveClaudeCredential(getConfig()).kind);
       let retry = false;
 
       while (true) {

package/src/channels/common/reply.ts

@@ -0,0 +1,79 @@
+/**
+ * What counts as a reply, and what is just the model talking to itself.
+ *
+ * Two related jobs live here on purpose, because splitting them is how the
+ * codebase ended up with two sentinel parsers that disagreed:
+ *
+ *  - `shouldSuppressReply` is the cross-channel guard. Control artifacts have
+ *    escaped as real messages before — `nia send --help` once DM'd the flag
+ *    itself — so every channel checks the same list.
+ *  - `decideWatchReply` is the richer judgement a watch turn needs: it prefers
+ *    a schema's answer, and can tell a bare sentinel from one tangled up with
+ *    content.
+ */
+
+export const WATCH_JUDGEMENT_SCHEMA: Record<string, unknown> = {
+  type: "object",
+  properties: {
+    reply: {
+      type: ["string", "null"],
+      description: "The message to post in the channel, or null to stay silent. Most turns are null.",
+    },
+  },
+  required: ["reply"],
+  additionalProperties: false,
+};
+
+/** Strip markdown fencing so a sentinel matches even when the model wraps it.
+ *  Underscores are left alone — the sentinel contains one. */
+export function cleanControlReply(text: string): string {
+  return text.replace(/[`*]/g, "").trim();
+}
+
+/** Outputs that are control artifacts rather than anything a person should see. */
+const CONTROL_ARTIFACTS = new Set(["[NO_REPLY]", "--help", "-h"]);
+
+/**
+ * Exact matches only. "Use `--help` to see the flags" is a real answer and must
+ * survive; a reply that is nothing but `--help` is the CLI leaking.
+ */
+export function shouldSuppressReply(text: string): boolean {
+  const cleaned = cleanControlReply(text);
+  return !cleaned || CONTROL_ARTIFACTS.has(cleaned);
+}
+
+export interface WatchDecision {
+  /** Whether to post at all. */
+  send: boolean;
+  /** What to post. Empty when staying quiet. */
+  text: string;
+  /** Which path decided, so a drop in schema coverage is visible in the log. */
+  source: "structured" | "sentinel";
+  /** Set only on the sentinel path, when the model emitted both a sentinel and content. */
+  ambiguous?: boolean;
+}
+
+/**
+ * `structured` wins when it carries the `reply` key the schema requires —
+ * including an explicit null, which is a decision, not an absence.
+ *
+ * The sentinel fallback matches `[NO_REPLY]` anywhere, not just exactly: a watch
+ * turn that says both is confused, and staying quiet is the safer reading. That
+ * is deliberately looser than `shouldSuppressReply`, which guards ordinary
+ * replies where a substring match would swallow real answers.
+ */
+export function decideWatchReply(structured: unknown, raw: string): WatchDecision {
+  if (structured && typeof structured === "object" && "reply" in structured) {
+    const reply = (structured as { reply: unknown }).reply;
+    const text = typeof reply === "string" ? reply.trim() : "";
+    return { send: text.length > 0, text, source: "structured" };
+  }
+
+  const trimmed = raw.trim();
+  const cleaned = cleanControlReply(trimmed);
+  if (!trimmed || cleaned.includes("[NO_REPLY]") || CONTROL_ARTIFACTS.has(cleaned)) {
+    const exact = !trimmed || CONTROL_ARTIFACTS.has(cleaned);
+    return { send: false, text: "", source: "sentinel", ambiguous: !exact };
+  }
+  return { send: true, text: trimmed, source: "sentinel" };
+}

package/src/channels/slack.ts

@@ -12,7 +12,7 @@ import { ChatSessions, chainLock } from "./common/chat-session";
 import { SlackAttachmentCache } from "./slack/attachments";
 import { SlackWatchReloader } from "./slack/watch";
 
-import { decideWatchReply } from "./common/watch-judgement";
+import { decideWatchReply, shouldSuppressReply } from "./common/reply";
 import { createTurnPump } from "./common/coalesce";
 
 const logActivity = (status: string) => log.debug({ status }, "slack engine activity");
@@ -304,7 +304,8 @@ class SlackChannel implements Channel {
             const { result } = await state.engine.send(subcommand, {
               onActivity: logActivity,
             });
-            await respond(result.trim() || "(no response)");
+            if (shouldSuppressReply(result)) return;
+            await respond(result.trim());
           } catch (err) {
             const errText = errMsg(err);
             await respond(`[error] ${errText}`);

package/src/channels/sms.ts

@@ -23,6 +23,8 @@ import { errMsg, ignore } from "../utils/errors";
 import { sendMessage as twilioSendMessage } from "./twilio/rest";
 import { getTwilioServer } from "./twilio/server";
 import { ChatSessions, chainLock } from "./common/chat-session";
+import { Message } from "../db/models";
+import { shouldSuppressReply } from "./common/reply";
 import { ackTwiml, deliveryStatusAck, isAllowedSender } from "./twilio/shared";
 
 class SmsChannel implements Channel {
@@ -105,8 +107,13 @@ class SmsChannel implements Channel {
     // Twilio's ~15s webhook timeout when the engine takes longer.
     chainLock(state, async () => {
       try {
-        const { result } = await state.engine.send(body);
-        const reply = result.trim() || "(no response)";
+        const { result, messageId } = await state.engine.send(body);
+        const reply = result.trim();
+        if (shouldSuppressReply(reply)) {
+          if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record suppressed delivery status");
+          log.info({ from }, "sms: agent chose not to reply");
+          return;
+        }
         await this.sendTo(from, reply);
       } catch (err) {
         log.error({ err, from }, "sms: engine error");

package/src/channels/telegram.ts

@@ -12,6 +12,7 @@ import { getMcpServers } from "../mcp";
 import { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
 import { getNiaHome } from "../utils/paths";
 import { ChatSessions, chainLock } from "./common/chat-session";
+import { shouldSuppressReply } from "./common/reply";
 
 function safeExtension(filename?: string): string {
   const ext = filename?.split(".").pop();
@@ -187,7 +188,12 @@ class TelegramChannel implements Channel {
 
     try {
       const { result, messageId } = await state.engine.send(text, {}, attachments);
-      const reply = result.trim() || "(no response)";
+      const reply = result.trim();
+        if (shouldSuppressReply(reply)) {
+          if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record suppressed delivery status");
+          log.info({ chatId }, "telegram: agent chose not to reply");
+          return;
+        }
       try {
         await bot.api.sendMessage(chatId, reply);
         if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");

package/src/channels/whatsapp.ts

@@ -21,6 +21,7 @@ import { getMcpServers } from "../mcp";
 import { Message } from "../db/models";
 import { runMigrations } from "../db/migrate";
 import { ChatSessions, chainLock } from "./common/chat-session";
+import { shouldSuppressReply } from "./common/reply";
 import { ackTwiml, deliveryStatusAck, isAllowedSender } from "./twilio/shared";
 import type { Attachment, Channel, ChatState, Outbound, TwilioConfig, WhatsappConfig, PhoneConfig } from "../types";
 import { getConfig } from "../utils/config";
@@ -201,7 +202,12 @@ class WhatsAppChannel implements Channel {
 
       try {
         const { result, messageId } = await state.engine.send(userText || "(media only)", {}, attachments);
-        const reply = result.trim() || "(no response)";
+        const reply = result.trim();
+        if (shouldSuppressReply(reply)) {
+          if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record suppressed delivery status");
+          log.info({ from }, "whatsapp: agent chose not to reply");
+          return;
+        }
         try {
           await this.sendTextTo(from, reply);
           if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");

package/src/cli/channels.ts

@@ -1,28 +1,38 @@
 import { getConfig, updateRawConfig } from "../utils/config";
 import { getPaths } from "../utils/paths";
 import { errMsg } from "../utils/errors";
-import { fail, ICON_PASS, ICON_FAIL } from "../utils/cli";
+import { fail, ICON_PASS, ICON_FAIL, parseArgs } from "../utils/cli";
 import { log } from "../utils/log";
 
+const SEND_USAGE = "Usage: nia send [-c channel] [--to <slack-channel-id>] [--thread <ts>] <message>";
+
+export interface SendArgs {
+  channel?: string;
+  toChannelId?: string;
+  threadTs?: string;
+  message: string;
+  help: boolean;
+}
+
+/** Extracted so the parse is testable — `nia send --help` used to DM the flag. */
+export function parseSendArgs(args: string[] = process.argv.slice(3)): SendArgs {
+  const parsed = parseArgs(args);
+  return {
+    channel: parsed.getString("channel") || parsed.getString("c"),
+    toChannelId: parsed.getString("to"),
+    threadTs: parsed.getString("thread"),
+    message: parsed.positional.join(" "),
+    help: parsed.help,
+  };
+}
+
 export async function sendCommand(): Promise<void> {
-  const args = process.argv.slice(3);
-  let channel: string | undefined;
-  let toChannelId: string | undefined;
-  let threadTs: string | undefined;
-  const msgParts: string[] = [];
-  for (let i = 0; i < args.length; i++) {
-    if ((args[i] === "--channel" || args[i] === "-c") && args[i + 1]) {
-      channel = args[++i];
-    } else if (args[i] === "--to" && args[i + 1]) {
-      toChannelId = args[++i];
-    } else if (args[i] === "--thread" && args[i + 1]) {
-      threadTs = args[++i];
-    } else {
-      msgParts.push(args[i]);
-    }
+  let { channel, toChannelId, threadTs, message, help } = parseSendArgs();
+  if (help) {
+    console.log(SEND_USAGE);
+    return;
   }
-  const message = msgParts.join(" ");
-  if (!message) fail("Usage: nia send [-c channel] [--to <slack-channel-id>] [--thread <ts>] <message>");
+  if (!message) fail(SEND_USAGE);
 
   // --to implies slack channel
   if (toChannelId) channel = channel || "slack";

package/src/channels/common/watch-judgement.ts

@@ -1,61 +0,0 @@
-/**
- * A watch turn answers one question: say something, or stay quiet.
- *
- * That answer used to travel as a `[NO_REPLY]` sentinel inside prose, which
- * means parsing a decision out of an answer that was free to phrase it any way
- * it liked. It mostly worked — and 47 times it produced the sentinel *and*
- * content, where the code has to guess which the model meant.
- *
- * A schema removes the guess. The sentinel path stays as the fallback, because
- * a backend can decline to produce structured output and a watch that stops
- * deciding is worse than one that decides the old way.
- */
-
-export const WATCH_JUDGEMENT_SCHEMA: Record<string, unknown> = {
-  type: "object",
-  properties: {
-    reply: {
-      type: ["string", "null"],
-      description: "The message to post in the channel, or null to stay silent. Most turns are null.",
-    },
-  },
-  required: ["reply"],
-  additionalProperties: false,
-};
-
-export interface WatchDecision {
-  /** Whether to post at all. */
-  send: boolean;
-  /** What to post. Empty when staying quiet. */
-  text: string;
-  /** Which path decided, so a drop in schema coverage is visible in the log. */
-  source: "structured" | "sentinel";
-  /** Set only on the sentinel path, when the model emitted both a sentinel and content. */
-  ambiguous?: boolean;
-}
-
-/** Strip markdown fencing so a sentinel matches even when the model wraps it.
- *  Underscores are left alone — the sentinel contains one. */
-export function cleanSentinel(text: string): string {
-  return text.replace(/[`*]/g, "").trim();
-}
-
-/**
- * `structured` wins when it carries the `reply` key the schema requires —
- * including an explicit null, which is a decision, not an absence.
- */
-export function decideWatchReply(structured: unknown, raw: string): WatchDecision {
-  if (structured && typeof structured === "object" && "reply" in structured) {
-    const reply = (structured as { reply: unknown }).reply;
-    const text = typeof reply === "string" ? reply.trim() : "";
-    return { send: text.length > 0, text, source: "structured" };
-  }
-
-  const trimmed = raw.trim();
-  const cleaned = cleanSentinel(trimmed);
-  if (!trimmed || cleaned.includes("[NO_REPLY]")) {
-    const exact = !trimmed || cleaned === "[NO_REPLY]";
-    return { send: false, text: "", source: "sentinel", ambiguous: !exact };
-  }
-  return { send: true, text: trimmed, source: "sentinel" };
-}