niahere 0.2.17 → 0.2.19

package/defaults/self/memory.md

@@ -8,7 +8,7 @@ Write here when:
 - I learned a preference, habit, or pattern worth remembering
 - A workaround was needed that future-me should know about
 
-Format: `- YYYY-MM-DD: what happened and what I learned`
+Entries are grouped by date. Use `add_memory` tool to append, or edit directly.
 
 ---
 

package/defaults/self/rules.md

@@ -0,0 +1,9 @@
+# Rules
+
+Custom instructions and behavioral overrides. Nia reads this file at the start of every session — edits take effect immediately without restart.
+
+Add rules here to change how Nia behaves. Examples:
+
+- "When asked for a standup, keep it to 1-2 lines"
+- "Always use bullet points for status updates"
+- "Never send messages longer than 3 sentences in Slack channels"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "description": "A personal AI assistant daemon — scheduled jobs, chat across Telegram and Slack, persona system, and visual identity.",
   "type": "module",
   "scripts": {

package/src/channels/index.ts

@@ -12,33 +12,60 @@ export function registerAllChannels(): void {
   registerChannel(() => createSlackChannel());
 }
 
-export async function startChannels(): Promise<Channel[]> {
-  const channels: Channel[] = [];
+export interface StartResult {
+  started: Channel[];
+  failed: string[];
+}
+
+export async function startChannels(): Promise<StartResult> {
+  const pending = getFactories()
+    .map((factory) => factory())
+    .filter((ch): ch is Channel => ch !== null);
 
-  for (const factory of getFactories()) {
-    const channel = factory();
-    if (!channel) continue;
+  if (pending.length === 0) return { started: [], failed: [] };
 
-    try {
+  const results = await Promise.allSettled(
+    pending.map(async (channel) => {
       await channel.start();
-      channels.push(channel);
-      trackStarted(channel);
-      log.info({ channel: channel.name }, "channel started");
-    } catch (err) {
-      log.error({ err, channel: channel.name }, "channel failed to start");
+      return channel;
+    }),
+  );
+
+  const started: Channel[] = [];
+  const failed: string[] = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === "fulfilled") {
+      started.push(result.value);
+      trackStarted(result.value);
+      log.info({ channel: result.value.name }, "channel started");
+    } else {
+      failed.push(pending[i].name);
+      log.error({ err: result.reason, channel: pending[i].name }, "channel failed to start");
     }
   }
 
-  return channels;
+  if (failed.length > 0) {
+    log.warn({ failed }, "some channels failed to start");
+  }
+
+  return { started, failed };
 }
 
 export async function stopChannels(channels: Channel[]): Promise<void> {
-  for (const channel of channels) {
-    try {
+  const results = await Promise.allSettled(
+    channels.map(async (channel) => {
       await channel.stop();
-      log.info({ channel: channel.name }, "channel stopped");
-    } catch (err) {
-      log.error({ err, channel: channel.name }, "channel failed to stop");
+      return channel;
+    }),
+  );
+
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === "fulfilled") {
+      log.info({ channel: result.value.name }, "channel stopped");
+    } else {
+      log.error({ err: result.reason, channel: channels[i].name }, "channel failed to stop");
     }
   }
   clearStarted();

package/src/channels/slack.ts

@@ -8,6 +8,11 @@ import { log } from "../utils/log";
 import { getMcpServers } from "../mcp";
 import { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
 
+/** Strip markdown backticks so sentinel tokens like [NO_REPLY] match even when the LLM wraps them. */
+function cleanSentinel(text: string): string {
+  return text.replace(/`/g, "").trim();
+}
+
 class SlackChannel implements Channel {
   name = "slack";
   private app: App | null = null;
@@ -94,9 +99,11 @@ class SlackChannel implements Channel {
       // daemon restarts (otherwise getState falls back to the old room).
       await Session.create(`placeholder-${room}`, room);
 
+      log.info({ key, room }, "slack: creating chat engine");
       const engine = await createChatEngine({ room, channel: "slack", resume: false, mcpServers: getMcpServers() });
       const state: ChatState = { engine, roomIndex: newIdx, lock: Promise.resolve() };
       chats.set(key, state);
+      log.info({ key, room, activeSessions: chats.size }, "slack: engine ready");
       return state;
     }
 
@@ -106,6 +113,8 @@ class SlackChannel implements Channel {
         fn().catch((err) => log.error({ err, key }, "unhandled error in locked handler"));
         return;
       }
+      const queued = state.lock !== Promise.resolve();
+      if (queued) log.debug({ key }, "slack: message queued behind active lock");
       state.lock = state.lock.then(fn, fn);
     }
 
@@ -345,10 +354,11 @@ class SlackChannel implements Channel {
 
       const state = await getState(key);
 
-      // Add thinking reaction while processing
-      await client.reactions.add({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" }).catch(() => {});
-
       withLock(key, async () => {
+        // Add thinking reaction inside the lock so cleanup is guaranteed
+        await client.reactions.add({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" })
+          .catch((err) => log.debug({ err, channel: msg.channel }, "slack: failed to add thinking reaction"));
+
         try {
           const { result } = await state.engine.send(text, {
             onActivity(status) {
@@ -356,12 +366,10 @@ class SlackChannel implements Channel {
             },
           }, attachments);
 
-          await client.reactions.remove({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" }).catch(() => {});
-
           const reply = result.trim();
 
           // [NO_REPLY] or empty = agent chose not to respond (thread judgement)
-          if (!reply || reply === "[NO_REPLY]") {
+          if (!reply || cleanSentinel(reply) === "[NO_REPLY]") {
             log.info({ channel: msg.channel, key }, "slack: agent chose not to reply");
             return;
           }
@@ -378,7 +386,6 @@ class SlackChannel implements Channel {
 
           log.info({ channel: msg.channel, key, chars: reply.length }, "slack reply sent");
         } catch (err) {
-          await client.reactions.remove({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" }).catch(() => {});
 
           const errText = err instanceof Error ? err.message : String(err);
           log.error({ err, channel: msg.channel }, "slack message processing failed");
@@ -392,6 +399,9 @@ class SlackChannel implements Channel {
           } else {
             await say(`[error] ${errText}`);
           }
+        } finally {
+          await client.reactions.remove({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" })
+            .catch((err) => log.debug({ err, channel: msg.channel }, "slack: failed to remove thinking reaction"));
         }
       });
     });

package/src/channels/telegram.ts

@@ -68,9 +68,11 @@ class TelegramChannel implements Channel {
         const prefix = roomPrefix(chatId);
         const idx = await Session.getLatestRoomIndex(prefix);
         const room = roomName(chatId, idx);
+        log.info({ chatId, room }, "telegram: creating chat engine");
         const engine = await createChatEngine({ room, channel: "telegram", resume: true, mcpServers: getMcpServers() });
         state = { engine, roomIndex: idx, lock: Promise.resolve() };
         chats.set(chatId, state);
+        log.info({ chatId, room, activeSessions: chats.size }, "telegram: engine ready");
       }
       return state;
     }
@@ -100,6 +102,8 @@ class TelegramChannel implements Channel {
         fn().catch((err) => log.error({ err, chatId }, "unhandled error in locked handler"));
         return;
       }
+      const queued = state.lock !== Promise.resolve();
+      if (queued) log.debug({ chatId }, "telegram: message queued behind active lock");
       state.lock = state.lock.then(fn, fn);
     }
 
@@ -134,8 +138,6 @@ class TelegramChannel implements Channel {
       try {
         const { result } = await state.engine.send(text, {}, attachments);
 
-        clearInterval(typingInterval);
-
         const reply = result.trim() || "(no response)";
         try {
           await bot.api.sendMessage(chatId, reply, { parse_mode: "MarkdownV2" });
@@ -145,11 +147,11 @@ class TelegramChannel implements Channel {
 
         log.info({ chatId, chars: result.length }, "telegram reply sent");
       } catch (err) {
-        clearInterval(typingInterval);
-
         const errText = err instanceof Error ? err.message : String(err);
         log.error({ err, chatId }, "telegram message processing failed");
         await bot.api.sendMessage(chatId, `[error] ${errText}`).catch(() => {});
+      } finally {
+        clearInterval(typingInterval);
       }
     }
 

package/src/chat/identity.ts

@@ -4,6 +4,7 @@ import { homedir } from "os";
 import yaml from "js-yaml";
 import { getNiaHome, getPaths } from "../utils/paths";
 import { getEnvironmentPrompt, getModePrompt, getChannelPrompt } from "../prompts";
+import { log } from "../utils/log";
 import type { Mode } from "../types";
 
 // niahere project root (resolved from this file's location)
@@ -17,7 +18,7 @@ function loadFile(dir: string, name: string): string {
 
 export function loadIdentity(): string {
   const { selfDir } = getPaths();
-  const files = ["identity.md", "owner.md", "soul.md"];
+  const files = ["identity.md", "owner.md", "soul.md", "rules.md"];
   return files.map((f) => loadFile(selfDir, f)).filter(Boolean).join("\n\n");
 }
 
@@ -51,7 +52,12 @@ function scanSkills(): { name: string; description: string }[] {
       if (!fmMatch) continue;
 
       let meta: Record<string, unknown> = {};
-      try { meta = (yaml.load(fmMatch[1]) as Record<string, unknown>) || {}; } catch { continue; }
+      try {
+        meta = (yaml.load(fmMatch[1]) as Record<string, unknown>) || {};
+      } catch (err) {
+        log.warn({ err, skill: entry.name, path: skillFile }, "failed to parse skill metadata, skipping");
+        continue;
+      }
       const name = (typeof meta.name === "string" ? meta.name : "") || entry.name;
 
       if (seen.has(name)) continue;

package/src/chat/repl.ts

@@ -112,7 +112,7 @@ async function pickSession(): Promise<string | null> {
 
 export type ChatMode = "continue" | "new" | "pick";
 
-export async function startRepl(mode: ChatMode = "continue"): Promise<void> {
+export async function startRepl(mode: ChatMode = "continue", simulateChannel?: string): Promise<void> {
   try {
     await runMigrations();
   } catch (err) {
@@ -142,12 +142,14 @@ export async function startRepl(mode: ChatMode = "continue"): Promise<void> {
     resume = true;
   }
 
-  const engine = await createChatEngine({ room: "terminal", channel: "terminal", resume, mcpServers: getMcpServers() });
+  const channel = simulateChannel || "terminal";
+  const engine = await createChatEngine({ room: "terminal", channel, resume, mcpServers: getMcpServers() });
 
   // Welcome
   const isResumed = engine.sessionId && resume;
   const sessionNote = isResumed ? "resumed" : "new session";
-  console.log(`\n${DIM}nia chat${RESET} ${DIM}(${sessionNote})${RESET}`);
+  const channelNote = simulateChannel ? ` as ${simulateChannel}` : "";
+  console.log(`\n${DIM}nia chat${channelNote}${RESET} ${DIM}(${sessionNote})${RESET}`);
   console.log(`${DIM}type /exit to quit${RESET}\n`);
 
   const rl = readline.createInterface({

package/src/cli/index.ts

@@ -115,6 +115,12 @@ switch (command) {
     break;
   }
 
+  case "health": {
+    const { healthCommand } = await import("../commands/health");
+    await healthCommand();
+    break;
+  }
+
   case "restart": {
     const { isServiceInstalled, restartService } = await import("../commands/service");
     if (isServiceInstalled()) {
@@ -227,10 +233,23 @@ switch (command) {
   case "logs": {
     const { daemonLog } = getPaths();
     if (!existsSync(daemonLog)) fail("No daemon log found. Is nia running?");
-    const follow = process.argv[3] === "-f" || process.argv[3] === "--follow";
-    const args = follow ? ["tail", "-f", daemonLog] : ["tail", "-50", daemonLog];
-    const proc = Bun.spawn(args, { stdio: ["ignore", "inherit", "inherit"] });
-    await proc.exited;
+    const logArgs = process.argv.slice(3);
+    const follow = logArgs.includes("-f") || logArgs.includes("--follow");
+    // --channel <name> filters logs by channel/component via grep
+    const chIdx = logArgs.indexOf("--channel");
+    const channelFilter = chIdx !== -1 && logArgs[chIdx + 1] ? logArgs[chIdx + 1] : null;
+
+    if (channelFilter) {
+      // Pipe through grep to filter by channel name in structured logs
+      const tailArgs = follow ? ["tail", "-f", daemonLog] : ["tail", "-200", daemonLog];
+      const tail = Bun.spawn(tailArgs, { stdio: ["ignore", "pipe", "inherit"] });
+      const grep = Bun.spawn(["grep", "-i", channelFilter], { stdio: [tail.stdout, "inherit", "inherit"] });
+      await grep.exited;
+    } else {
+      const args = follow ? ["tail", "-f", daemonLog] : ["tail", "-50", daemonLog];
+      const proc = Bun.spawn(args, { stdio: ["ignore", "inherit", "inherit"] });
+      await proc.exited;
+    }
     break;
   }
 
@@ -240,13 +259,15 @@ switch (command) {
   }
 
   case "chat": {
-    const arg = process.argv[3];
-    const mode = (arg === "--new" || arg === "-n")
+    const chatArgs = process.argv.slice(3);
+    const mode = (chatArgs.includes("--new") || chatArgs.includes("-n"))
       ? "new" as const
-      : (arg === "--resume" || arg === "-r")
+      : (chatArgs.includes("--resume") || chatArgs.includes("-r"))
         ? "pick" as const
         : "continue" as const;
-    await startRepl(mode);
+    const chIdx = chatArgs.indexOf("--channel");
+    const simChannel = chIdx !== -1 && chatArgs[chIdx + 1] ? chatArgs[chIdx + 1] : undefined;
+    await startRepl(mode, simChannel);
     break;
   }
 
@@ -392,10 +413,11 @@ switch (command) {
     console.log("  start / stop        — daemon + service control");
     console.log("  restart             — restart daemon");
     console.log("  status [--json --rooms N --all]  — show daemon, jobs, channels");
-    console.log("  chat                — interactive chat (auto-continues last session)");
+    console.log("  health              — check daemon, db, channels, config");
+    console.log("  chat [--channel ch] — interactive chat (--channel simulates a channel)");
     console.log("  run <prompt>        — one-shot execution");
     console.log("  history [room]      — recent messages");
-    console.log("  logs [-f]           — daemon logs");
+    console.log("  logs [-f] [--channel ch]  — daemon logs (filter by channel)");
     console.log("  job <sub>           — manage jobs");
     console.log("  db <sub>            — database setup/status/migrate");
     console.log("  skills              — list available skills");

package/src/commands/health-db.ts

@@ -0,0 +1,12 @@
+import postgres from "postgres";
+
+/** Quick DB connectivity check. Returns true if SELECT 1 succeeds. */
+export async function checkDbHealth(url: string): Promise<boolean> {
+  const db = postgres(url, { onnotice: () => {}, connect_timeout: 5 });
+  try {
+    const [row] = await db`SELECT 1 as ok`;
+    return row?.ok === 1;
+  } finally {
+    await db.end();
+  }
+}

package/src/commands/health.ts

@@ -0,0 +1,119 @@
+import { existsSync, statSync } from "fs";
+import { join } from "path";
+import { isRunning, readPid } from "../core/daemon";
+import { getConfig, readRawConfig } from "../utils/config";
+import { getPaths } from "../utils/paths";
+import { errMsg } from "../utils/errors";
+import { localTime } from "../utils/time";
+
+type Check = { name: string; status: "ok" | "warn" | "fail"; detail: string };
+
+function push(checks: Check[], name: string, status: Check["status"], detail: string): void {
+  checks.push({ name, status, detail });
+}
+
+export async function healthCommand(): Promise<void> {
+  const checks: Check[] = [];
+  const paths = getPaths();
+
+  // 1. Daemon
+  const pid = readPid();
+  if (isRunning()) {
+    push(checks, "daemon", "ok", "running (pid: " + pid + ")");
+  } else if (pid) {
+    push(checks, "daemon", "fail", "stale pid file (pid: " + pid + ", not running)");
+  } else {
+    push(checks, "daemon", "warn", "not running");
+  }
+
+  // 2. Config
+  if (existsSync(paths.config)) {
+    const raw = readRawConfig();
+    push(checks, "config", "ok", Object.keys(raw).length + " keys loaded");
+  } else {
+    push(checks, "config", "fail", "missing (" + paths.config + ")");
+  }
+
+  // 3. Database
+  try {
+    const config = getConfig();
+    if (!config.database_url || !config.database_url.startsWith("postgres")) {
+      push(checks, "database", "fail", 'invalid url: "' + (config.database_url || "(empty)") + '"');
+    } else {
+      const { checkDbHealth } = await import("./health-db");
+      const ok = await checkDbHealth(config.database_url);
+      push(checks, "database", ok ? "ok" : "fail", config.database_url.replace(/\/\/.*@/, "//***@"));
+    }
+  } catch (err) {
+    push(checks, "database", "fail", errMsg(err));
+  }
+
+  // 4. Channels
+  const config = getConfig();
+  if (!config.channels.enabled) {
+    push(checks, "channels", "warn", "disabled");
+  } else {
+    const chans: string[] = [];
+    if (config.channels.telegram.bot_token) chans.push("telegram");
+    if (config.channels.slack.bot_token && config.channels.slack.app_token) chans.push("slack");
+    if (chans.length > 0) {
+      push(checks, "channels", "ok", "configured: " + chans.join(", "));
+    } else {
+      push(checks, "channels", "warn", "enabled but no tokens configured");
+    }
+  }
+
+  // 5. API keys
+  const geminiKey = config.gemini_api_key;
+  const rawConfig = readRawConfig();
+  const openaiKey = typeof rawConfig.openai_api_key === "string" ? rawConfig.openai_api_key : null;
+  const apiKeys: string[] = [];
+  if (geminiKey) apiKeys.push("gemini");
+  if (openaiKey) apiKeys.push("openai");
+  push(checks, "api keys", apiKeys.length > 0 ? "ok" : "warn",
+    apiKeys.length > 0 ? apiKeys.join(", ") : "none configured");
+
+  // 6. Persona files
+  const personaFiles = ["identity.md", "owner.md", "soul.md"];
+  const missing = personaFiles.filter((f) => !existsSync(join(paths.selfDir, f)));
+  if (missing.length === 0) {
+    push(checks, "persona", "ok", "all files present");
+  } else {
+    push(checks, "persona", "warn", "missing: " + missing.join(", "));
+  }
+
+  // 7. Daemon log
+  if (existsSync(paths.daemonLog)) {
+    const stat = statSync(paths.daemonLog);
+    const sizeMb = (stat.size / 1024 / 1024).toFixed(1);
+    const lastMod = localTime(stat.mtime);
+    push(checks, "logs", stat.size > 100 * 1024 * 1024 ? "warn" : "ok",
+      sizeMb + " MB, last write: " + lastMod);
+  } else {
+    push(checks, "logs", "warn", "no log file");
+  }
+
+  // 8. Bun version
+  const bunVersion = typeof Bun !== "undefined" ? Bun.version : "unknown";
+  push(checks, "bun", "ok", "v" + bunVersion);
+
+  // Output
+  const GREEN = "\x1b[32m";
+  const YELLOW = "\x1b[33m";
+  const RED = "\x1b[31m";
+  const RST = "\x1b[0m";
+  const icons: Record<string, string> = {
+    ok: GREEN + "\u2713" + RST,
+    warn: YELLOW + "!" + RST,
+    fail: RED + "\u2717" + RST,
+  };
+
+  console.log();
+  for (const c of checks) {
+    console.log("  " + icons[c.status] + " " + c.name.padEnd(12) + " " + c.detail);
+  }
+  console.log();
+
+  const failCount = checks.filter((c) => c.status === "fail").length;
+  if (failCount > 0) process.exit(1);
+}

package/src/commands/init.ts

@@ -427,8 +427,9 @@ export async function runInit(): Promise<void> {
       console.log(`  \u2713 wrote ${selfFile("owner.md")}`);
     }
 
-    // Soul and memory — only create if missing (user may have customized)
+    // Soul, rules, and memory — only create if missing (user may have customized)
     writeIfMissing(selfFile("soul.md"), loadTemplate("soul.md", vars), selfFile("soul.md"));
+    writeIfMissing(selfFile("rules.md"), loadTemplate("rules.md", vars), selfFile("rules.md"));
     writeIfMissing(selfFile("memory.md"), loadTemplate("memory.md", vars), selfFile("memory.md"));
 
     resetConfig();

package/src/core/daemon.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { dirname } from "path";
 import { getPaths } from "../utils/paths";
 import { getConfig } from "../utils/config";
@@ -46,6 +46,7 @@ export function isRunning(): boolean {
     process.kill(pid, 0);
     return true;
   } catch {
+    log.warn({ stalePid: pid }, "removing stale pid file (process not running)");
     removePid();
     return false;
   }
@@ -73,6 +74,7 @@ export function startDaemon(): number {
   });
 
   proc.unref();
+  closeSync(logFd); // Child owns the fd now; close parent's copy to prevent leak
   const pid = proc.pid;
   writePid(pid);
   return pid;
@@ -211,7 +213,8 @@ export async function runDaemon(): Promise<void> {
   let channels: Channel[] = [];
   const config = getConfig();
   if (config.channels.enabled) {
-    channels = await startChannels();
+    const result = await startChannels();
+    channels = result.started;
   } else {
     log.info("channels disabled (channels_enabled: false)");
   }

package/src/db/connection.ts

@@ -1,11 +1,18 @@
 import postgres from "postgres";
 import { getConfig } from "../utils/config";
+import { log } from "../utils/log";
 
 let _sql: ReturnType<typeof postgres> | null = null;
 
 export function getSql(): ReturnType<typeof postgres> {
   if (!_sql) {
-    _sql = postgres(getConfig().database_url, { onnotice: () => {} });
+    const url = getConfig().database_url;
+    if (!url || !url.startsWith("postgres")) {
+      const msg = `Invalid database_url: "${url || "(empty)"}". Expected a postgres:// connection string.`;
+      log.error(msg);
+      throw new Error(msg);
+    }
+    _sql = postgres(url, { onnotice: () => {} });
   }
   return _sql;
 }

package/src/mcp/server.ts

@@ -84,6 +84,26 @@ export function createNiaMcpServer() {
           content: [{ type: "text" as const, text: await handlers.listMessages(args.limit, args.room) }],
         }),
       ),
+      tool(
+        "add_rule",
+        "Add a behavioral rule. Rules are loaded into every session and take effect without restart. Use for 'from now on' / 'always' / 'never' type instructions.",
+        {
+          rule: z.string().describe("The rule to add (e.g. 'stamp updates: 1-2 lines max, no preamble')"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: handlers.addRule(args.rule) }],
+        }),
+      ),
+      tool(
+        "add_memory",
+        "Save a factual memory for future reference. Memories are read on demand, not loaded automatically. Use for things learned, preferences discovered, or context worth keeping.",
+        {
+          entry: z.string().describe("What to remember (e.g. 'Aman prefers short Slack messages in #tech')"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: handlers.addMemory(args.entry) }],
+        }),
+      ),
     ],
   });
 }

package/src/mcp/tools.ts

@@ -1,9 +1,10 @@
-import { readFileSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, appendFileSync, existsSync } from "fs";
 import type { ScheduleType } from "../types";
-import { basename } from "path";
+import { basename, join } from "path";
 import { Job, Message, Session } from "../db/models";
 import { computeInitialNextRun } from "../core/scheduler";
 import { getConfig } from "../utils/config";
+import { getPaths } from "../utils/paths";
 import { getChannel } from "../channels/registry";
 import { log } from "../utils/log";
 import { classifyMime } from "../utils/attachment";
@@ -219,3 +220,29 @@ export async function listMessages(limit = 20, room?: string): Promise<string> {
   if (messages.length === 0) return "No messages found.";
   return JSON.stringify(messages, null, 2);
 }
+
+export function addRule(rule: string): string {
+  const { selfDir } = getPaths();
+  const rulesPath = join(selfDir, "rules.md");
+  const line = `\n- ${rule}\n`;
+  appendFileSync(rulesPath, line, "utf8");
+  return `Rule added to rules.md. Takes effect on next new session.`;
+}
+
+export function addMemory(entry: string): string {
+  const { selfDir } = getPaths();
+  const memoryPath = join(selfDir, "memory.md");
+  const date = new Date().toISOString().slice(0, 10);
+  const header = `\n## ${date}`;
+
+  const existing = existsSync(memoryPath) ? readFileSync(memoryPath, "utf8") : "";
+  if (existing.includes(header)) {
+    // Append under existing date header
+    const updated = existing.replace(header, `${header}\n- ${entry}`);
+    writeFileSync(memoryPath, updated, "utf8");
+  } else {
+    // New date section
+    appendFileSync(memoryPath, `${header}\n- ${entry}\n`, "utf8");
+  }
+  return `Memory saved.`;
+}

package/src/prompts/environment.md

@@ -22,6 +22,8 @@ You have MCP tools for managing jobs directly — no need for shell commands:
 - **run_job** — trigger a job to run immediately
 - **send_message** — send a message to the user (via telegram, slack, or default channel). Supports `media_path` to send images/files.
 - **list_messages** — read recent chat history
+- **add_rule** — save a behavioral rule (loaded into every session, no restart needed). Use when told "from now on", "always", "never", or "remember to always..."
+- **add_memory** — save a factual memory (read on demand). Use when told "remember that...", or when you learn something surprising worth keeping
 
 Active hours: {{activeStart}}–{{activeEnd}} ({{timezone}}). Jobs respect this; crons (always=true) don't.
 
@@ -62,10 +64,22 @@ Your persona files live in {{selfDir}}/:
 - `identity.md` — your personality and voice
 - `owner.md` — info about who runs you
 - `soul.md` — how you work
-- `memory.md` — persistent learnings (read/write on demand, not loaded automatically)
+- `rules.md` — behavioral overrides and custom instructions (loaded into every session, hot-reloads without restart)
+- `memory.md` — persistent learnings (read on demand, not loaded automatically)
 
-Memory is NOT loaded into your context automatically. Read it when you need context, write to it when you learn something worth keeping.
+### Rules vs Memory
 
-- **Read** when: you're unsure about a preference, a past issue, or something you might have seen before.
-- **Write** when: something surprised you, you were corrected, or you found a workaround future-you should know.
-- Append with: `echo "- $(date +%Y-%m-%d): <what you learned>" >> {{selfDir}}/memory.md`
+**Rules** (`rules.md`) = instructions for how to behave. Loaded into every session automatically.
+- "stamp updates should be 1-2 lines max"
+- "never send long messages in #tech"
+- Use `add_rule` tool to add new rules, or edit the file directly.
+
+**Memory** (`memory.md`) = facts and context. Read on demand when relevant.
+- "2026-03-13: DB was down, Telegram send failed"
+- "Aman prefers terminal over Slack for debugging"
+- Use `add_memory` tool to save new memories.
+
+**Which to use?**
+- "From now on, do X" → rule
+- "Remember that X happened" / "I prefer X" → memory
+- If unsure, ask.

package/src/prompts/mode-job.md

@@ -3,4 +3,6 @@
 You are executing a scheduled job. Be terse — execute the task and report the result. No small talk.
 
 - State the outcome first, then supporting details if needed.
-- If the job failed, report what went wrong clearly.
+- If the job failed, report what went wrong clearly.
+- When sending results to a channel (Slack, Telegram), keep it minimal. The recipient knows the context — just deliver the key info.
+- Check rules.md for job-specific output instructions (e.g. brevity rules for specific jobs like stamp/standup).

package/src/utils/config.ts

@@ -1,5 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname } from "path";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
 import yaml from "js-yaml";
 import { getPaths } from "./paths";
 import { log } from "./log";
@@ -179,12 +179,20 @@ function deepMerge(target: Record<string, unknown>, source: Record<string, unkno
   }
 }
 
-/** Deep-merge fields into config.yaml and write back. */
+/** Deep-merge fields into config.yaml and write back atomically. */
 export function updateRawConfig(fields: Record<string, unknown>): void {
   const { config } = getPaths();
   const raw = readRawConfig();
   deepMerge(raw, fields);
-  mkdirSync(dirname(config), { recursive: true });
-  writeFileSync(config, yaml.dump(raw, { lineWidth: -1 }));
+  const dir = dirname(config);
+  mkdirSync(dir, { recursive: true });
+  // Back up current config before overwriting
+  if (existsSync(config)) {
+    copyFileSync(config, join(dir, "config.yaml.bak"));
+  }
+  // Write to temp file then rename for atomic update (prevents corruption on crash)
+  const tmp = join(dir, `.config.yaml.tmp.${process.pid}`);
+  writeFileSync(tmp, yaml.dump(raw, { lineWidth: -1 }));
+  renameSync(tmp, config);
   resetConfig();
 }