niahere 0.2.19 → 0.2.21

package/defaults/self/memory.md

@@ -1,14 +1,15 @@
 # Memory
 
-Things I've picked up that I don't want to forget. I maintain this myself.
+Concise things I've picked up that I don't want to forget. I maintain this myself.
 
-Write here when:
-- Something surprised me or broke unexpectedly
-- {{ownerName}} corrected me or preferred a different approach
-- I learned a preference, habit, or pattern worth remembering
-- A workaround was needed that future-me should know about
+Rules:
+- One insight per entry, max 200 chars
+- NO raw logs, transcripts, or status dumps
+- NO duplicates — check before adding
+- Good: "curator job can hang — needs timeout recovery"
+- Bad: pasting nia status output or conversation logs
 
-Entries are grouped by date. Use `add_memory` tool to append, or edit directly.
+Entries are grouped by date. Use `add_memory` tool to append.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "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/cli/index.ts

@@ -12,6 +12,7 @@ import { fail } from "../utils/cli";
 import { jobCommand } from "./job";
 import { statusCommand } from "./status";
 import { sendCommand, telegramCommand, slackCommand } from "./channels";
+import { rulesCommand, memoryCommand } from "./self";
 
 // Set LOG_LEVEL from config before anything else logs
 try {
@@ -207,6 +208,16 @@ switch (command) {
     break;
   }
 
+  case "rules": {
+    rulesCommand();
+    break;
+  }
+
+  case "memory": {
+    memoryCommand();
+    break;
+  }
+
   case "history": {
     const room = process.argv[3];
     try {
@@ -419,6 +430,8 @@ switch (command) {
     console.log("  history [room]      — recent messages");
     console.log("  logs [-f] [--channel ch]  — daemon logs (filter by channel)");
     console.log("  job <sub>           — manage jobs");
+    console.log("  rules [show|reset]  — view or reset rules.md");
+    console.log("  memory [show|reset] — view or reset memory.md");
     console.log("  db <sub>            — database setup/status/migrate");
     console.log("  skills              — list available skills");
     console.log("  config <sub>        — get/set/list config values");

package/src/cli/job.ts

@@ -49,7 +49,7 @@ export async function jobCommand(): Promise<void> {
             for (const job of jobs) {
               const tag = job.always ? "  always" : "";
               const type = job.scheduleType !== "cron" ? ` (${job.scheduleType})` : "";
-              console.log(`  ${job.enabled ? "●" : "○"} ${job.name}  ${job.schedule}${type}${tag}  ${job.prompt.slice(0, 60)}${job.prompt.length > 60 ? "..." : ""}`);
+              console.log(`  ${job.enabled ? "●" : "○"} ${job.name}  ${job.schedule}${type}${tag}`);
             }
           }
         });

package/src/cli/self.ts

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync, copyFileSync } from "fs";
+import { join } from "path";
+import { getPaths } from "../utils/paths";
+import { fail } from "../utils/cli";
+
+function selfFilePath(name: "rules" | "memory"): string {
+  const { selfDir } = getPaths();
+  return join(selfDir, `${name}.md`);
+}
+
+function defaultFilePath(name: "rules" | "memory"): string {
+  const projectRoot = join(import.meta.dir, "../..");
+  return join(projectRoot, "defaults", "self", `${name}.md`);
+}
+
+function show(name: "rules" | "memory"): void {
+  const path = selfFilePath(name);
+  if (!existsSync(path)) {
+    console.log(`No ${name}.md found.`);
+    return;
+  }
+  console.log(readFileSync(path, "utf8").trim());
+}
+
+function reset(name: "rules" | "memory"): void {
+  const path = selfFilePath(name);
+  const defaultPath = defaultFilePath(name);
+
+  if (!existsSync(defaultPath)) {
+    fail(`Default ${name}.md template not found.`);
+  }
+
+  if (existsSync(path)) {
+    copyFileSync(path, `${path}.bak`);
+    console.log(`  backed up → ${name}.md.bak`);
+  }
+
+  copyFileSync(defaultPath, path);
+  console.log(`  ${name}.md reset to default.`);
+}
+
+export function rulesCommand(): void {
+  const sub = process.argv[3];
+  switch (sub) {
+    case "show":
+    case undefined:
+      show("rules");
+      break;
+    case "reset":
+      reset("rules");
+      break;
+    default:
+      console.log("Usage: nia rules <show|reset>");
+      console.log("  show   — display current rules (default)");
+      console.log("  reset  — reset to default template (backs up current)");
+  }
+}
+
+export function memoryCommand(): void {
+  const sub = process.argv[3];
+  switch (sub) {
+    case "show":
+    case undefined:
+      show("memory");
+      break;
+    case "reset":
+      reset("memory");
+      break;
+    default:
+      console.log("Usage: nia memory <show|reset>");
+      console.log("  show   — display current memory (default)");
+      console.log("  reset  — reset to default template (backs up current)");
+  }
+}

package/src/core/runner.ts

@@ -1,24 +1,123 @@
 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 {}
+  }
+
+  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;
 
+  try {
+    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" };
+        }
+      }
+    }
+  } finally {
+    handle.close();
+  }
 
-function buildPrompt(job: JobInput): string {
-  const systemPrompt = buildSystemPrompt("job");
-  return `${systemPrompt}\n\n---\n\nJob: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`;
+  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 +127,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

@@ -96,9 +96,9 @@ export function createNiaMcpServer() {
       ),
       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.",
+        "Save a concise factual memory for future reference. Memories are read on demand, not loaded automatically. Use for preferences, corrections, or patterns worth keeping. RULES: Max 200 chars. One insight per entry. NO raw logs, NO conversation transcripts, NO status dumps, NO duplicate observations. Bad: pasting nia status output. Good: 'curator job can get stuck in running state — needs timeout recovery'.",
         {
-          entry: z.string().describe("What to remember (e.g. 'Aman prefers short Slack messages in #tech')"),
+          entry: z.string().max(300).describe("A single concise insight (max 200 chars, no raw logs or transcripts)"),
         },
         async (args) => ({
           content: [{ type: "text" as const, text: handlers.addMemory(args.entry) }],

package/src/mcp/tools.ts

@@ -230,19 +230,39 @@ export function addRule(rule: string): string {
 }
 
 export function addMemory(entry: string): string {
+  // Guard: reject raw logs, transcripts, and overly long entries
+  const trimmed = entry.trim();
+  if (!trimmed) return "Rejected: empty entry.";
+  if (trimmed.length > 300) return "Rejected: too long (max 300 chars). Distill to a single concise insight.";
+  if (trimmed.includes("[Thread context]") || trimmed.includes("[Current messag")) return "Rejected: no raw conversation transcripts.";
+  if (trimmed.split("\n").length > 5) return "Rejected: too many lines. One concise insight per memory.";
+
   const { selfDir } = getPaths();
   const memoryPath = join(selfDir, "memory.md");
+  const existing = existsSync(memoryPath) ? readFileSync(memoryPath, "utf8") : "";
+
+  // Deduplicate: skip if a substantially similar entry already exists
+  const normalized = trimmed.toLowerCase().replace(/[^a-z0-9 ]/g, "");
+  const lines = existing.split("\n").filter((l) => l.startsWith("- "));
+  for (const line of lines) {
+    const norm = line.slice(2).toLowerCase().replace(/[^a-z0-9 ]/g, "");
+    // Check if >60% of words overlap
+    const newWords = new Set(normalized.split(/\s+/).filter(Boolean));
+    const oldWords = new Set(norm.split(/\s+/).filter(Boolean));
+    if (newWords.size === 0) continue;
+    let overlap = 0;
+    for (const w of newWords) { if (oldWords.has(w)) overlap++; }
+    if (overlap / newWords.size > 0.6) return "Rejected: similar memory already exists.";
+  }
+
   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}`);
+    const updated = existing.replace(header, `${header}\n- ${trimmed}`);
     writeFileSync(memoryPath, updated, "utf8");
   } else {
-    // New date section
-    appendFileSync(memoryPath, `${header}\n- ${entry}\n`, "utf8");
+    appendFileSync(memoryPath, `${header}\n- ${trimmed}\n`, "utf8");
   }
   return `Memory saved.`;
 }

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,