niahere 0.2.41 → 0.2.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.41",
+  "version": "0.2.43",
   "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

@@ -4,7 +4,7 @@ import { log } from "../utils/log";
 import { createTelegramChannel } from "./telegram";
 import { createSlackChannel } from "./slack";
 
-export { getChannel } from "./registry";
+export { getChannel, getStarted } from "./registry";
 
 /** Register all built-in channel factories. Call once at startup. */
 export function registerAllChannels(): void {

package/src/channels/registry.ts

@@ -19,6 +19,10 @@ export function getChannel(name: string): Channel | undefined {
   return started.get(name);
 }
 
+export function getStarted(): Channel[] {
+  return [...started.values()];
+}
+
 export function clearStarted(): void {
   started.clear();
 }

package/src/chat/identity.ts

@@ -17,7 +17,7 @@ function loadFile(dir: string, name: string): string {
 
 export function loadIdentity(): string {
   const { selfDir } = getPaths();
-  const files = ["identity.md", "owner.md", "soul.md", "rules.md"];
+  const files = ["identity.md", "owner.md", "soul.md", "rules.md", "memory.md"];
   return files.map((f) => loadFile(selfDir, f)).filter(Boolean).join("\n\n");
 }
 

package/src/chat/repl.ts

@@ -2,7 +2,7 @@ import * as readline from "readline";
 import { createChatEngine } from "./engine";
 import { runMigrations } from "../db/migrate";
 import { closeDb } from "../db/connection";
-import { getMcpServers, setMcpServers } from "../mcp";
+import { getMcpServers, setMcpFactory } from "../mcp";
 import { createNiaMcpServer } from "../mcp/server";
 import { Session } from "../db/models";
 import { relativeTime } from "../utils/format";
@@ -113,12 +113,9 @@ export async function startRepl(mode: ChatMode = "continue", simulateChannel?: s
     process.exit(1);
   }
 
-  // Initialize MCP server if not already set (standalone chat mode)
+  // Initialize MCP server factory if not already set (standalone chat mode)
   if (!getMcpServers()) {
-    try {
-      const mcpConfig = createNiaMcpServer();
-      setMcpServers({ nia: mcpConfig });
-    } catch {}
+    setMcpFactory(() => ({ nia: createNiaMcpServer() }));
   }
 
   // Determine session to use

package/src/cli/index.ts

@@ -381,12 +381,16 @@ switch (command) {
   case "channels": {
     const sub = process.argv[3];
     const { updateRawConfig } = await import("../utils/config");
-    if (sub === "on") {
-      updateRawConfig({ channels: { enabled: true } });
-      console.log("channels enabled — restart to apply");
-    } else if (sub === "off") {
-      updateRawConfig({ channels: { enabled: false } });
-      console.log("channels disabled — restart to apply");
+    if (sub === "on" || sub === "off") {
+      const enabled = sub === "on";
+      updateRawConfig({ channels: { enabled } });
+      const pid = readPid();
+      if (pid && isRunning()) {
+        process.kill(pid, "SIGHUP");
+        console.log(`channels ${enabled ? "enabled" : "disabled"}`);
+      } else {
+        console.log(`channels ${enabled ? "enabled" : "disabled"} — start nia to apply`);
+      }
     } else {
       console.log(`channels: ${getConfig().channels.enabled ? "on" : "off"}`);
     }

package/src/core/daemon.ts

@@ -1,17 +1,17 @@
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { dirname } from "path";
 import { getPaths } from "../utils/paths";
-import { getConfig } from "../utils/config";
+import { getConfig, resetConfig } from "../utils/config";
 import { log } from "../utils/log";
 import { ActiveEngine } from "../db/models";
 import { runMigrations } from "../db/migrate";
 import { closeDb, getSql } from "../db/connection";
-import { registerAllChannels, startChannels, stopChannels } from "../channels";
+import { registerAllChannels, startChannels, stopChannels, getStarted } from "../channels";
 import type { Channel } from "../types";
 import { startScheduler, stopScheduler, recomputeAllNextRuns } from "./scheduler";
 import { startAlive, stopAlive } from "./alive";
 import { createNiaMcpServer } from "../mcp/server";
-import { setMcpServers } from "../mcp";
+import { setMcpFactory } from "../mcp";
 
 export function writePid(pid: number): void {
   const { pid: pidPath } = getPaths();
@@ -218,14 +218,9 @@ export async function runDaemon(): Promise<void> {
     log.info({ recovered }, "recovered stale running jobs");
   }
 
-  // Initialize MCP server (in-process, no HTTP needed)
-  try {
-    const mcpConfig = createNiaMcpServer();
-    setMcpServers({ nia: mcpConfig });
-    log.info("MCP server initialized");
-  } catch (err) {
-    log.error({ err }, "failed to initialize MCP server");
-  }
+  // Initialize MCP server factory (each query gets its own Protocol instance)
+  setMcpFactory(() => ({ nia: createNiaMcpServer() }));
+  log.info("MCP server factory initialized");
 
   // Register and start channels
   registerAllChannels();
@@ -265,9 +260,26 @@ export async function runDaemon(): Promise<void> {
     log.warn({ err }, "could not subscribe to nia_jobs, falling back to SIGHUP only");
   }
 
-  // SIGHUP as manual fallback
+  // SIGHUP: reload config, reconcile channels, recompute jobs
   process.on("SIGHUP", async () => {
-    log.info("received SIGHUP, recomputing job schedules");
+    log.info("received SIGHUP, reloading config");
+    resetConfig();
+    const fresh = getConfig();
+
+    const running = getStarted();
+    const wantChannels = fresh.channels.enabled;
+    const haveChannels = running.length > 0;
+
+    if (wantChannels && !haveChannels) {
+      log.info("SIGHUP: starting channels");
+      const result = await startChannels();
+      channels = result.started;
+    } else if (!wantChannels && haveChannels) {
+      log.info("SIGHUP: stopping channels");
+      await stopChannels(running);
+      channels = [];
+    }
+
     await recomputeAllNextRuns().catch(() => {});
   });
 

package/src/mcp/index.ts

@@ -1,10 +1,10 @@
-/** Shared MCP server config — set by daemon, read by chat engine creators. */
-let _mcpServers: Record<string, unknown> | null = null;
+/** Factory for per-query MCP servers — each query gets its own Protocol instance. */
+let _mcpFactory: (() => Record<string, unknown>) | null = null;
 
-export function setMcpServers(servers: Record<string, unknown>): void {
-  _mcpServers = servers;
+export function setMcpFactory(factory: () => Record<string, unknown>): void {
+  _mcpFactory = factory;
 }
 
 export function getMcpServers(): Record<string, unknown> | undefined {
-  return _mcpServers ?? undefined;
+  return _mcpFactory?.() ?? undefined;
 }

package/src/prompts/environment.md

@@ -92,31 +92,102 @@ Your persona files live in {{selfDir}}/:
 - `identity.md` — your personality and voice
 - `owner.md` — info about who runs you
 - `soul.md` — how you work
-- `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)
+- `rules.md` — behavioral instructions (loaded into every session automatically)
+- `memory.md` — facts and context (loaded into every session automatically)
 
 ### Rules vs Memory
 
-**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 `read_memory` to recall what you know. Use `add_memory` to save new memories.
-
-**Which to use?**
-- "From now on, do X" → rule
-- "Remember that X happened" / "I prefer X" → memory
-
-### When to save (proactive)
-Don't wait for the user to say "remember this." Proactively save when you learn:
-- Personal facts: travel plans, location, schedule, preferences
-- Work context: project decisions, team changes, deadlines
-- Corrections: user corrected you on something worth remembering
-- Patterns: recurring requests, preferred communication style
-
-Example: if the owner says "I'm going home on the 21st, early morning flight" — save it as a memory without being asked. These are facts future sessions need.
-- If unsure, ask.
+The difference is simple: **rules are instructions, memories are facts.**
+
+**Rules** = verbs. They change your behavior. They tell you to do or not do something.
+- Start with: do / don't / always / never / keep / avoid / when X then Y
+- Test: "If I ignore this, my response is **wrong**"
+- Tool: `add_rule`
+- Loaded: every session, always
+
+**Memory** = nouns. They give you context. They tell you something is true.
+- Start with: a name, date, or factual statement
+- Test: "If I don't know this, my response is **uninformed** but not wrong"
+- Tool: `add_memory`
+- Loaded: every session, always
+
+### The decision flowchart
+
+Ask yourself one question: **"Is this telling me HOW to act, or WHAT is true?"**
+
+| Signal | → | Where |
+|--------|---|-------|
+| "From now on..." / "Always..." / "Never..." / "Stop doing..." | → | **Rule** |
+| "I prefer..." / "I like when you..." / "Do it like this..." | → | **Rule** (it's a behavioral preference = instruction) |
+| "I'm traveling to Delhi on the 21st" | → | **Memory** |
+| "We use Postgres, not MySQL" / "The deploy is on Friday" | → | **Memory** |
+| "Last time X broke because of Y" | → | **Memory** (fact about past) |
+| "Don't do X again, it broke last time" | → | **Rule** (instruction) + **Memory** (the incident) |
+| User corrects your formatting/tone/length | → | **Rule** (you need to change behavior) |
+| User mentions a person, project, deadline | → | **Memory** |
+
+### Good vs bad entries
+
+**Good rules** — specific, actionable, earns its token cost every session:
+- "Stamp/standup job output: 1-2 lines max, no preamble"
+- "In Slack channels, keep replies under 3 paragraphs"
+- "Never send code blocks in Telegram — they render badly"
+- "When Aman says 'ship it', commit and push without asking"
+
+**Bad rules** — vague, redundant, or one-time:
+- "Be helpful" (already in your identity)
+- "Use good formatting" (too vague to act on)
+- "Send the report to #general today" (one-time task, not a rule)
+
+**Good memories** — dated, one fact, useful across sessions:
+- "2026-03-21: Aman traveling to Delhi, back 2026-03-28"
+- "Kay.ai is the main work project — ask.kay.ai is the product URL"
+- "Aman prefers debugging via terminal, not Slack"
+- "2026-03-13: Postgres went down, Telegram sends failed — DNS issue"
+
+**Bad memories** — raw logs, transient state, duplicates:
+- Pasting full error logs or stack traces
+- "Currently working on X" (stale by next session)
+- Anything already in rules.md or identity.md
+
+### When to save (be proactive)
+
+Rules and memories don't only come from the user telling you things. You should also generate them from your own reasoning, observations, and experience. **Think of yourself as learning, not just recording.**
+
+#### From the user (explicit)
+
+| You notice... | Save as |
+|---------------|---------|
+| User says "from now on" / "always" / "stop doing X" | **Rule** |
+| User corrects your tone, format, length, or approach | **Rule** |
+| User mentions a preference about how you communicate | **Rule** |
+| User shares travel plans, schedule, personal facts | **Memory** |
+| User mentions people, projects, deadlines, decisions | **Memory** |
+| User corrects a factual misunderstanding | **Memory** |
+| Both behavior change AND a fact behind it | **Rule** + **Memory** |
+
+#### From your own thinking (self-generated)
+
+You are not a passive recorder. Reflect on your own experience and save learnings:
+
+| You realize... | Save as |
+|----------------|---------|
+| A tool or approach failed — you should avoid it next time | **Rule** ("Don't use X for Y — it fails because Z") |
+| You found a better way to do something after trial and error | **Rule** ("For X, use Y approach instead of Z") |
+| A job keeps erroring the same way — there's a pattern | **Rule** (the workaround) + **Memory** (the incident pattern) |
+| You notice the user always ignores or rejects a certain kind of response | **Rule** (stop doing that) |
+| You discover how a system works (API quirk, config gotcha, infra detail) | **Memory** |
+| You learn who someone is, what team they're on, what they work on | **Memory** |
+| You notice a pattern in when/how the user communicates | **Memory** |
+| A job succeeded in an unusual way worth remembering | **Memory** |
+| You figure out the relationship between projects, services, or people | **Memory** |
+
+**The key principle:** if you'd want to know this at the start of your next session, save it now. Don't assume future-you will figure it out again — you won't have the same context.
+
+### Hygiene
+
+- **Before adding:** call `read_memory` / check rules.md — don't duplicate
+- **Update > add:** if a memory or rule already covers the topic, update it instead
+- **Date memories:** always include the date so stale entries are obvious
+- **Remove stale entries:** travel plans that passed, deadlines that shipped, incidents that are resolved
+- **Keep rules lean:** every rule costs tokens in every session — max ~20 rules, each must earn its place