niahere 0.2.18 → 0.2.20

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.18",
+  "version": "0.2.20",
   "description": "A personal AI assistant daemon — scheduled jobs, chat across Telegram and Slack, persona system, and visual identity.",
   "type": "module",
   "scripts": {

package/skills/gh-stamp/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: gh-stamp
+description: "Stamp a GitHub PR with an LGTM approval comment. Use when someone wants to approve, stamp, or give a thumbs-up to a pull request."
+---
+
+# gh-stamp
+
+Approve-stamp a GitHub PR by posting a comment.
+
+## Trigger
+
+User says "stamp", "stamp it", "stmap", or similar.
+
+- Stamp only → use this skill alone.
+- Stamp + review → run this skill first, then the pr-reviewer skill.
+- Review only → use the pr-reviewer skill, not this.
+
+## Steps
+
+1. **Find the PR.** Accept a full URL, `owner/repo#number`, or a bare number if the repo is obvious from context. If unclear, ask and stop.
+2. **Post the comment.**
+   ```sh
+   gh pr comment <pr-url-or-number> --body "LGTM, Stamped ✅"
+   # or with repo qualifier:
+   gh pr comment --repo <owner/repo> <number> --body "LGTM, Stamped ✅"
+   ```
+3. **Confirm to user:** `LGTM, Stamped ✅`
+
+Do not touch anything else on the PR.

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;
@@ -364,7 +369,7 @@ class SlackChannel implements Channel {
           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;
           }

package/src/chat/identity.ts

@@ -18,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");
 }
 

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/runner.ts

@@ -1,24 +1,119 @@
 import { homedir } from "os";
 import { existsSync } from "fs";
+import { randomUUID } from "crypto";
+import { query } from "@anthropic-ai/claude-agent-sdk";
 import type { JobInput, JobResult } from "../types";
 import { appendAudit, readState, writeState } from "../utils/logger";
 import type { AuditEntry, JobState } from "../types";
 import { getConfig } from "../utils/config";
 import { buildSystemPrompt } from "../chat/identity";
 
-// Resolve full path to codex so daemon doesn't depend on PATH
-const CODEX_CANDIDATES = ["/opt/homebrew/bin/codex", "/usr/local/bin/codex"];
-const codexPath = CODEX_CANDIDATES.find((p) => existsSync(p)) || "codex";
+interface RunnerOutput {
+  agentText: string;
+  sessionId: string;
+  error?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Codex runner
+// ---------------------------------------------------------------------------
+
+function resolveCodexPath(): string {
+  const candidates = ["/opt/homebrew/bin/codex", "/usr/local/bin/codex"];
+  return candidates.find((p) => existsSync(p)) || "codex";
+}
+
+async function runJobWithCodex(fullPrompt: string, cwd: string, model: string): Promise<RunnerOutput> {
+  const codexPath = resolveCodexPath();
+  const args = [codexPath, "exec", fullPrompt, "-C", cwd, "--json", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox"];
+  if (model && model !== "default") {
+    args.splice(3, 0, "-m", model);
+  }
 
+  const proc = Bun.spawn(args, {
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env },
+  });
+
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+
+  let agentText = "";
+  let sessionId = "";
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const event = JSON.parse(line);
+      if (event.type === "thread.started" && event.thread_id) {
+        sessionId = event.thread_id;
+      }
+      if (event.type === "item.completed" && event.item?.type === "agent_message") {
+        agentText = event.item.text || "";
+      }
+    } catch {}
+  }
 
-function buildPrompt(job: JobInput): string {
-  const systemPrompt = buildSystemPrompt("job");
-  return `${systemPrompt}\n\n---\n\nJob: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`;
+  if (exitCode !== 0) {
+    return { agentText, sessionId, error: stderr.trim() || `exit code ${exitCode}` };
+  }
+  return { agentText, sessionId };
 }
 
+// ---------------------------------------------------------------------------
+// Claude Agent SDK runner
+// ---------------------------------------------------------------------------
+
+async function runJobWithClaude(systemPrompt: string, jobPrompt: string, cwd: string): Promise<RunnerOutput> {
+  const sessionId = randomUUID();
+
+  // One-shot async iterable: emit a single user message then close
+  async function* singleMessage() {
+    yield {
+      type: "user" as const,
+      message: { role: "user" as const, content: jobPrompt },
+      parent_tool_use_id: null,
+      session_id: "",
+    };
+  }
+
+  const handle = query({
+    prompt: singleMessage() as any,
+    options: {
+      systemPrompt,
+      cwd,
+      permissionMode: "bypassPermissions",
+      sessionId,
+    } as any,
+  });
+
+  let agentText = "";
+  let actualSessionId = sessionId;
+
+  for await (const message of handle) {
+    if (message.type === "system" && (message as any).subtype === "init") {
+      actualSessionId = (message as any).session_id || sessionId;
+    }
+    if (message.type === "result") {
+      if (!(message as any).is_error) {
+        agentText = (message as any).result || "";
+      } else {
+        const errors = (message as any).errors;
+        return { agentText: "", sessionId: actualSessionId, error: errors?.join(", ") || "unknown error" };
+      }
+    }
+  }
+
+  return { agentText, sessionId: actualSessionId };
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
 export async function runJob(job: JobInput): Promise<JobResult> {
   const config = getConfig();
-  const model = config.model;
   const timestamp = new Date().toISOString();
   const startMs = performance.now();
 
@@ -28,48 +123,29 @@ export async function runJob(job: JobInput): Promise<JobResult> {
   writeState(state);
 
   try {
-    const fullPrompt = buildPrompt(job);
     const cwd = homedir();
-    const args = [codexPath, "exec", fullPrompt, "-C", cwd, "--json", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox"];
-    if (model && model !== "default") {
-      args.splice(3, 0, "-m", model);
+    let output: RunnerOutput;
+
+    if (config.runner === "codex") {
+      const fullPrompt = `${buildSystemPrompt("job")}\n\n---\n\nJob: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`;
+      output = await runJobWithCodex(fullPrompt, cwd, config.model);
+    } else {
+      const systemPrompt = buildSystemPrompt("job");
+      const jobPrompt = `Job: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`;
+      output = await runJobWithClaude(systemPrompt, jobPrompt, cwd);
     }
-    const proc = Bun.spawn(args, {
-      stdout: "pipe",
-      stderr: "pipe",
-      env: { ...process.env },
-    });
 
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
     const duration_ms = Math.round(performance.now() - startMs);
+    const ok = !output.error;
 
-    // Parse JSONL events for session ID and final agent message
-    let agentText = "";
-    let sessionId = "";
-    for (const line of stdout.split("\n")) {
-      if (!line.trim()) continue;
-      try {
-        const event = JSON.parse(line);
-        if (event.type === "thread.started" && event.thread_id) {
-          sessionId = event.thread_id;
-        }
-        if (event.type === "item.completed" && event.item?.type === "agent_message") {
-          agentText = event.item.text || "";
-        }
-      } catch {}
-    }
-
-    const ok = exitCode === 0;
     const result: JobResult = {
       job: job.name,
       timestamp,
       status: ok ? "ok" : "error",
-      result: agentText.trim(),
+      result: output.agentText.trim(),
       duration_ms,
-      session_id: sessionId || undefined,
-      error: ok ? undefined : stderr.trim() || `exit code ${exitCode}`,
+      session_id: output.sessionId || undefined,
+      error: output.error,
     };
 
     const auditEntry: AuditEntry = {

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/types/config.ts

@@ -25,6 +25,7 @@ export interface ChannelsConfig {
 
 export interface Config {
   model: string;
+  runner: "claude" | "codex";
   timezone: string;
   activeHours: { start: string; end: string };
   database_url: string;

package/src/utils/config.ts

@@ -10,6 +10,7 @@ const TIME_RE = /^\d{2}:\d{2}$/;
 
 const DEFAULTS: Config = {
   model: "default",
+  runner: "claude",
   timezone: process.env.TZ || Intl.DateTimeFormat().resolvedOptions().timeZone,
   activeHours: { start: "00:00", end: "23:59" },
   database_url: DEFAULT_DATABASE_URL,
@@ -54,6 +55,9 @@ export function loadConfig(): Config {
   // Model
   const model = typeof raw.model === "string" ? raw.model : DEFAULTS.model;
 
+  // Runner — "codex" is opt-in, everything else defaults to "claude"
+  const runner: Config["runner"] = raw.runner === "codex" ? "codex" : DEFAULTS.runner;
+
   // Timezone
   let timezone = DEFAULTS.timezone;
   if (typeof raw.timezone === "string") {
@@ -140,6 +144,7 @@ export function loadConfig(): Config {
 
   return {
     model,
+    runner,
     timezone,
     activeHours: { start, end },
     database_url,