niahere 0.2.83 → 0.2.85

package/README.md

@@ -43,8 +43,8 @@ nia start               # starts daemon + registers OS service
 - **Skills** — loads skills from multiple directories, invokable as slash commands
 - **Cross-platform service** — launchd (macOS), systemd (Linux), service-aware restart
 - **MCP tools** — 20 tools for job management, messaging, memory, rules, and channel control
-- **Background memory consolidation** — extracts memories from conversations and job runs automatically
-- **Session summaries** — handoff notes between sessions for continuity
+- **Background memory consolidation** — stages memory candidates from conversations automatically
+- **Session summaries** — optional handoff notes between sessions for continuity
 - **Backups** — `nia backup` with auto-backup before updates
 - **Optional integrations** — add Gmail, Discord, and more via skills
 
@@ -55,6 +55,8 @@ nia init                       — interactive setup (db, channels, persona, age
 nia start / stop               — daemon + OS service (launchd/systemd)
 nia restart                    — restart daemon (service-aware)
 nia status                     — show daemon, jobs, channels, chat rooms
+nia active [--full]            — show active engine count or details
+nia model [name]               — show or set global Claude model
 nia health                     — check daemon, db, channels, config
 nia chat [-c|-r] [--channel ch] — terminal chat (new by default, -c continue, -r pick)
 nia run <prompt>               — one-shot prompt execution
@@ -119,6 +121,17 @@ All config and data lives in `~/.niahere/`:
     nia.pid, daemon.log, cron-state.json, cron-audit.jsonl
 ```
 
+Post-session background LLM work can be disabled in `config.yaml`:
+
+```yaml
+session_finalization:
+  enabled: true
+  memory_consolidation: true
+  summaries: true
+```
+
+Use `nia config set session_finalization.memory_consolidation false` to stop memory staging, `nia config set session_finalization.summaries false` to stop session summaries, or `nia config set session_finalization.enabled false` to disable both.
+
 ## Contributing
 
 **Don't add features. Add skills.**

package/package.json

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

package/src/chat/engine.ts

@@ -22,6 +22,7 @@ import type {
 import { truncate, formatToolUse } from "../utils/format-activity";
 import { finalizeSession, cancelPending } from "../core/finalizer";
 import { log } from "../utils/log";
+import { getConfig } from "../utils/config";
 import { isRetryableApiError, sleep } from "../utils/retry";
 import { registerActiveHandle, unregisterActiveHandle } from "../core/active-handles";
 import { resolveJobPrompt } from "../core/job-prompt";
@@ -108,6 +109,11 @@ export function formatChatError(rawError: string | null | undefined): string {
   return `[error] ${error}`;
 }
 
+export function resolveSdkModel(contextModel?: string | null): string | undefined {
+  const model = contextModel || getConfig().model;
+  return model && model !== "default" ? model : undefined;
+}
+
 /**
  * Push-based async iterable for streaming user messages to the SDK.
  * Keeps the query subprocess alive between messages.
@@ -177,30 +183,40 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
 
   // Context overrides: employee > agent > job > default
   let cwd = homedir();
+  let contextModel: string | null | undefined;
   if (opts.employee) {
     const empPrompt = buildEmployeePrompt(opts.employee);
     if (empPrompt) systemPrompt = empPrompt;
     const emp = getEmployee(opts.employee);
+    contextModel = emp?.model;
     if (emp?.repo && existsSync(emp.repo)) cwd = emp.repo;
   } else if (opts.agent) {
     const agents = scanAgents();
     const agentDef = agents.find((a) => a.name === opts.agent);
-    if (agentDef) systemPrompt = agentDef.body + "\n\n" + buildContextSuffix("chat");
+    if (agentDef) {
+      systemPrompt = agentDef.body + "\n\n" + buildContextSuffix("chat");
+      contextModel = agentDef.model;
+    }
   } else if (opts.job) {
     // Job chat: load job and use its context
     const jobData = await Job.get(opts.job);
     if (jobData) {
+      contextModel = jobData.model;
       // If job has an employee, use employee prompt
       if (jobData.employee) {
         const empPrompt = buildEmployeePrompt(jobData.employee);
         if (empPrompt) systemPrompt = empPrompt;
         const emp = getEmployee(jobData.employee);
+        if (!contextModel) contextModel = emp?.model;
         if (emp?.repo && existsSync(emp.repo)) cwd = emp.repo;
       } else if (jobData.agent) {
         // If job has an agent, use agent prompt + context
         const agents = scanAgents();
         const agentDef = agents.find((a) => a.name === jobData.agent);
-        if (agentDef) systemPrompt = agentDef.body + "\n\n" + buildContextSuffix("chat");
+        if (agentDef) {
+          systemPrompt = agentDef.body + "\n\n" + buildContextSuffix("chat");
+          if (!contextModel) contextModel = agentDef.model;
+        }
       }
       const resolvedPrompt = resolveJobPrompt(jobData);
       const source = resolvedPrompt.source === "file" ? ` from ${resolvedPrompt.filePath}` : "";
@@ -316,6 +332,10 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
       settingSources: ["project", "user"],
       skills: [],
     };
+    const model = resolveSdkModel(contextModel);
+    if (model) {
+      options.model = model;
+    }
 
     if (sessionId) {
       options.resume = sessionId;

package/src/cli/active.ts

@@ -0,0 +1,36 @@
+import { ActiveEngine } from "../db/models";
+import { withDb } from "../db/with-db";
+import { errMsg } from "../utils/errors";
+import { dateSortValue, formatTimeLine } from "../utils/format";
+
+function hasFullFlag(argv: string[]): boolean {
+  return argv.includes("--full");
+}
+
+export async function activeCommand(argv: string[] = []): Promise<void> {
+  const full = hasFullFlag(argv);
+  const now = new Date();
+  let engines: Awaited<ReturnType<typeof ActiveEngine.list>> = [];
+
+  try {
+    await withDb(async () => {
+      engines = await ActiveEngine.list();
+    });
+  } catch (err) {
+    console.error(`active engines unavailable: ${errMsg(err)}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!full) {
+    console.log(String(engines.length));
+    return;
+  }
+
+  console.log(`Active engines: ${engines.length === 0 ? "none" : engines.length}`);
+  for (const engine of engines.sort((a, b) => dateSortValue(a.startedAt) - dateSortValue(b.startedAt))) {
+    const started = formatTimeLine(engine.startedAt, now);
+    const ping = formatTimeLine(engine.lastPing, now);
+    console.log(`  ${engine.room} (${engine.channel}) • started ${started} • last ping ${ping}`);
+  }
+}

package/src/cli/index.ts

@@ -11,6 +11,8 @@ import { errMsg } from "../utils/errors";
 import { fail, ICON_PASS, ICON_WARN } from "../utils/cli";
 import { jobCommand } from "./job";
 import { statusCommand } from "./status";
+import { activeCommand } from "./active";
+import { modelCommand } from "./model";
 import { sendCommand, telegramCommand, slackCommand } from "./channels";
 import { rulesCommand, memoryCommand } from "./self";
 import { watchCommand } from "./watch";
@@ -127,6 +129,16 @@ switch (command) {
     break;
   }
 
+  case "active": {
+    await activeCommand(process.argv.slice(3));
+    break;
+  }
+
+  case "model": {
+    await modelCommand(process.argv.slice(3));
+    break;
+  }
+
   case "health": {
     const { healthCommand } = await import("../commands/health");
     await healthCommand();
@@ -565,6 +577,8 @@ Daemon:
   restart [--wait N] [--force]    Restart daemon
   update [--wait N] [--force]     Update to latest version
   status [--json --rooms N --all] Show daemon, jobs, channels
+  active [--full]                 Show active engine count or details
+  model [name]                    Show or set global Claude model
   health                          Check daemon, db, channels, config
   logs [-f] [--channel ch]        Daemon logs (filter by channel)
 

package/src/cli/model.ts

@@ -0,0 +1,29 @@
+import { isRunning, readPid } from "../core/daemon";
+import { getConfig, resetConfig, updateRawConfig } from "../utils/config";
+
+function printUsage(): void {
+  console.log("Usage: nia model [default|sonnet|opus|opusplan|haiku|<model-id>]");
+}
+
+export async function modelCommand(argv: string[] = []): Promise<void> {
+  const model = argv[0];
+
+  if (!model) {
+    console.log(`model = ${getConfig().model}`);
+    return;
+  }
+
+  if (model === "--help" || model === "-h") {
+    printUsage();
+    return;
+  }
+
+  updateRawConfig({ model });
+  resetConfig();
+  console.log(`model = ${model}`);
+
+  const pid = readPid();
+  if (pid && isRunning()) {
+    process.kill(pid, "SIGHUP");
+  }
+}

package/src/commands/validate.ts

@@ -85,6 +85,29 @@ export function validateConfig(): Result {
     messages.push(`${PASS} runner: ${runner}`);
   }
 
+  // Session finalization
+  const sf = raw.session_finalization as Record<string, unknown> | undefined;
+  if (sf) {
+    let sessionFinalizationOk = true;
+    for (const key of ["enabled", "memory_consolidation", "summaries"]) {
+      const val = sf[key];
+      if (val !== undefined && typeof val !== "boolean") {
+        messages.push(`${FAIL} session_finalization.${key} must be true or false`);
+        ok = false;
+        sessionFinalizationOk = false;
+      }
+    }
+    if (sessionFinalizationOk) {
+      const enabled = sf.enabled !== false;
+      const memoryConsolidation = sf.memory_consolidation !== false;
+      const summaries = sf.summaries !== false;
+      messages.push(
+        `${PASS} session_finalization: ${enabled ? "enabled" : "disabled"} ` +
+          `(memory_consolidation=${memoryConsolidation}, summaries=${summaries})`,
+      );
+    }
+  }
+
   // Channels
   const ch = raw.channels as Record<string, unknown> | undefined;
   if (ch) {

package/src/core/finalizer.ts

@@ -10,10 +10,25 @@
 import { getSql } from "../db/connection";
 import { consolidateSession } from "./consolidator";
 import { summarizeSession } from "./summarizer";
+import { loadConfig } from "../utils/config";
 import { log } from "../utils/log";
 
+type FinalizationTask = "consolidate" | "summarize";
+
+function getEnabledTasks(): FinalizationTask[] {
+  const { sessionFinalization } = loadConfig();
+  if (!sessionFinalization.enabled) return [];
+
+  const tasks: FinalizationTask[] = [];
+  if (sessionFinalization.memoryConsolidation) tasks.push("consolidate");
+  if (sessionFinalization.summaries) tasks.push("summarize");
+  return tasks;
+}
+
 /** Enqueue a session for finalization. Always returns immediately. */
 export async function finalizeSession(sessionId: string, room: string): Promise<void> {
+  if (getEnabledTasks().length === 0) return;
+
   const sql = getSql();
 
   // Get current message count for idempotency
@@ -77,19 +92,30 @@ async function processOne(sessionId: string, room: string, messageCount: number)
   if (claimed.length === 0) return; // Already claimed or cancelled
 
   const requestId = claimed[0].id;
+  const tasks = getEnabledTasks();
+  if (tasks.length === 0) {
+    await sql`
+      UPDATE finalization_requests
+      SET status = 'done', updated_at = NOW()
+      WHERE id = ${requestId}
+    `;
+    log.info({ sessionId, room, messageCount }, "finalizer: skipped because all tasks are disabled");
+    return;
+  }
 
   try {
-    const [consolidateResult, summarizeResult] = await Promise.allSettled([
-      consolidateSession(sessionId, room),
-      summarizeSession(sessionId, room),
-    ]);
+    const results = await Promise.allSettled(
+      tasks.map((task) =>
+        task === "consolidate" ? consolidateSession(sessionId, room) : summarizeSession(sessionId, room),
+      ),
+    );
 
     const errors: string[] = [];
-    if (consolidateResult.status === "rejected") {
-      errors.push(`consolidate: ${formatRejection(consolidateResult.reason)}`);
-    }
-    if (summarizeResult.status === "rejected") {
-      errors.push(`summarize: ${formatRejection(summarizeResult.reason)}`);
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result.status === "rejected") {
+        errors.push(`${tasks[i]}: ${formatRejection(result.reason)}`);
+      }
     }
 
     const finalStatus = errors.length === 0 ? "done" : "failed";

package/src/types/config.ts

@@ -35,6 +35,12 @@ export interface ChannelsConfig {
   slack: SlackConfig;
 }
 
+export interface SessionFinalizationConfig {
+  enabled: boolean;
+  memoryConsolidation: boolean;
+  summaries: boolean;
+}
+
 export interface Config {
   model: string;
   runner: "claude" | "codex";
@@ -43,5 +49,6 @@ export interface Config {
   database_url: string;
   log_level: string;
   gemini_api_key: string | null;
+  sessionFinalization: SessionFinalizationConfig;
   channels: ChannelsConfig;
 }

package/src/utils/config.ts

@@ -16,6 +16,11 @@ const DEFAULTS: Config = {
   database_url: DEFAULT_DATABASE_URL,
   log_level: "info",
   gemini_api_key: null,
+  sessionFinalization: {
+    enabled: true,
+    memoryConsolidation: true,
+    summaries: true,
+  },
   channels: {
     enabled: true,
     default: "telegram",
@@ -100,6 +105,14 @@ export function loadConfig(): Config {
   const gemini_api_key =
     process.env.GEMINI_API_KEY || (typeof raw.gemini_api_key === "string" ? raw.gemini_api_key : null);
 
+  // Session finalization — controls post-session background LLM work.
+  const sf = (raw.session_finalization || {}) as Record<string, unknown>;
+  const sessionFinalization = {
+    enabled: sf.enabled !== false,
+    memoryConsolidation: sf.memory_consolidation !== false,
+    summaries: sf.summaries !== false,
+  };
+
   // --- Channels (nested under `channels:` in yaml) ---
   const ch = (raw.channels || {}) as Record<string, unknown>;
   const chTg = (ch.telegram || {}) as Record<string, unknown>;
@@ -159,6 +172,7 @@ export function loadConfig(): Config {
     database_url,
     log_level,
     gemini_api_key,
+    sessionFinalization,
     channels: {
       enabled: channelsEnabled,
       default: defaultChannel,