niahere 0.2.76 → 0.2.77

package/package.json

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

package/src/chat/engine.ts

@@ -23,6 +23,7 @@ import { truncate, formatToolUse } from "../utils/format-activity";
 import { finalizeSession, cancelPending } from "../core/finalizer";
 import { log } from "../utils/log";
 import { isRetryableApiError, sleep } from "../utils/retry";
+import { registerActiveHandle, unregisterActiveHandle } from "../core/active-handles";
 
 const IDLE_TIMEOUT = 10 * 60 * 1000; // 10 minutes
 const LONG_RUNNING_WARN = 30 * 60 * 1000; // 30 minutes
@@ -272,9 +273,20 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
       queryHandle.close();
       queryHandle = null;
     }
+    unregisterActiveHandle(room);
     alive = false;
   }
 
+  async function abortActiveQuery(reason: string) {
+    const activePending = pending;
+    pending = null;
+    if (activePending) {
+      activePending.reject(new Error(reason));
+    }
+    teardown();
+    await ActiveEngine.unregister(room).catch(() => {});
+  }
+
   function startQuery() {
     stream = new MessageStream();
     alive = true;
@@ -309,6 +321,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
       prompt: stream as any,
       options: options as any,
     });
+    registerActiveHandle(room, abortActiveQuery);
 
     // Background consumer — runs for the lifetime of the query
     (async () => {
@@ -523,6 +536,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
         }
       } finally {
         clearLongRunningTimer();
+        unregisterActiveHandle(room);
         alive = false;
         stream = null;
         queryHandle = null;
@@ -596,8 +610,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
           log.error({ err, room }, "finalization enqueue failed during close");
         }
       }
-      teardown();
-      await ActiveEngine.unregister(room).catch(() => {});
+      await abortActiveQuery("chat engine closed");
     },
   };
 }

package/src/cli/index.ts

@@ -116,8 +116,8 @@ switch (command) {
     const stopGuard = parseGuardFlags(process.argv.slice(3));
     if (!(await guardActiveEngines("stop", stopGuard))) process.exit(1);
     const { unregisterService } = await import("../commands/service");
-    await unregisterService();
-    stopDaemon();
+    await unregisterService({ force: stopGuard.force });
+    stopDaemon({ force: stopGuard.force });
     console.log("nia stopped");
     break;
   }
@@ -138,9 +138,9 @@ switch (command) {
     if (!(await guardActiveEngines("restart", restartGuard))) process.exit(1);
     const { isServiceInstalled, restartService } = await import("../commands/service");
     if (isServiceInstalled()) {
-      await restartService();
+      await restartService({ force: restartGuard.force });
     } else {
-      stopDaemon();
+      stopDaemon({ force: restartGuard.force });
       startDaemon();
     }
     const restartPid = readPid();
@@ -536,9 +536,9 @@ switch (command) {
         console.log("Restarting daemon...");
         const { isServiceInstalled, restartService } = await import("../commands/service");
         if (isServiceInstalled()) {
-          await restartService();
+          await restartService({ force: updateGuard.force });
         } else {
-          stopDaemon();
+          stopDaemon({ force: updateGuard.force });
           startDaemon();
         }
         console.log("Restarted.");

package/src/commands/service.ts

@@ -3,6 +3,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { getPaths } from "../utils/paths";
 import { findDaemonPids } from "../core/daemon";
+import { clearForceShutdownRequest, requestForceShutdown } from "../core/force-shutdown";
 
 const PLIST_NAME = "com.niahere.agent";
 const SYSTEMD_UNIT = "niahere.service";
@@ -173,7 +174,8 @@ export async function registerService(): Promise<void> {
   // Windows/other: no-op, daemon still works via startDaemon()
 }
 
-export async function unregisterService(): Promise<void> {
+export async function unregisterService(opts: { force?: boolean } = {}): Promise<void> {
+  if (opts.force) requestForceShutdown(findDaemonPids());
   if (process.platform === "darwin") {
     await uninstallLaunchd();
   } else if (process.platform === "linux") {
@@ -188,7 +190,9 @@ export function isServiceInstalled(): boolean {
 }
 
 /** Restart via service manager. Waits for old process to fully exit before starting new one. */
-export async function restartService(): Promise<void> {
+export async function restartService(opts: { force?: boolean } = {}): Promise<void> {
+  if (opts.force) requestForceShutdown(findDaemonPids());
+  const waitMs = opts.force ? 30_000 : 310_000;
   if (process.platform === "darwin") {
     const path = plistPath();
     // Unload — sends SIGTERM and disables KeepAlive respawn
@@ -198,7 +202,8 @@ export async function restartService(): Promise<void> {
       console.error(`  warning: launchctl unload failed: ${stderr.trim()}`);
     }
     // Wait for old daemon to fully exit (graceful shutdown may take time for active engines)
-    await waitForDaemonExit(310_000);
+    await waitForDaemonExit(waitMs);
+    if (opts.force) clearForceShutdownRequest();
     // Load — starts a fresh single instance
     const load = Bun.spawn(["launchctl", "load", path], { stdout: "pipe", stderr: "pipe" });
     if (await load.exited !== 0) {
@@ -209,6 +214,8 @@ export async function restartService(): Promise<void> {
     // systemd restart handles stop-wait-start internally
     const restart = Bun.spawn(["systemctl", "--user", "restart", SYSTEMD_UNIT], { stdout: "pipe", stderr: "pipe" });
     await restart.exited;
+    if (opts.force) await waitForDaemonExit(waitMs);
+    if (opts.force) clearForceShutdownRequest();
   }
 }
 

package/src/core/active-handles.ts

@@ -0,0 +1,31 @@
+import { log } from "../utils/log";
+
+type CloseHandle = (reason: string) => void | Promise<void>;
+
+const handles = new Map<string, CloseHandle>();
+
+export function registerActiveHandle(room: string, close: CloseHandle): void {
+  handles.set(room, close);
+}
+
+export function unregisterActiveHandle(room: string): void {
+  handles.delete(room);
+}
+
+export function activeHandleCount(): number {
+  return handles.size;
+}
+
+export async function closeAllActiveHandles(reason: string): Promise<number> {
+  const entries = [...handles.entries()];
+  for (const [room, close] of entries) {
+    try {
+      await close(reason);
+    } catch (err) {
+      log.warn({ err, room }, "failed to close active handle");
+    } finally {
+      handles.delete(room);
+    }
+  }
+  return entries.length;
+}

package/src/core/daemon.ts

@@ -15,6 +15,8 @@ import { startAlive, stopAlive } from "./alive";
 import { createNiaMcpServer } from "../mcp/server";
 import { setMcpFactory } from "../mcp";
 import { processPending, cleanupOldRequests } from "./finalizer";
+import { closeAllActiveHandles } from "./active-handles";
+import { clearForceShutdownRequest, consumeForceShutdownRequest, requestForceShutdown } from "./force-shutdown";
 
 export { isRunning, readPid, removePid, writePid };
 
@@ -46,8 +48,11 @@ export function startDaemon(): number {
   return pid;
 }
 
-export function stopDaemon(): boolean {
+export function stopDaemon(opts: { force?: boolean } = {}): boolean {
   const pidfilePid = readPid();
+  if (opts.force) {
+    requestForceShutdown([...(pidfilePid ? [pidfilePid] : []), ...findDaemonPids()]);
+  }
   removePid();
 
   // Kill all daemon processes — pidfile PID plus any orphans.
@@ -55,7 +60,8 @@ export function stopDaemon(): boolean {
   if (killed === 0 && pidfilePid === null) return false;
 
   // Wait for processes to finish (up to 5 min for active engines, then SIGKILL)
-  waitForExit(310_000);
+  waitForExit(opts.force ? 30_000 : 310_000);
+  if (opts.force) clearForceShutdownRequest();
   return true;
 }
 
@@ -361,16 +367,21 @@ export async function runDaemon(): Promise<void> {
   const shutdown = async () => {
     if (shuttingDown) return;
     shuttingDown = true;
+    const force = consumeForceShutdownRequest(process.pid);
 
-    log.info("shutting down...");
+    log.info({ force }, "shutting down...");
 
     stopAlive();
     stopScheduler();
     await stopChannels(channels);
 
     try {
+      if (force) {
+        const closed = await closeAllActiveHandles("force shutdown");
+        log.warn({ closed }, "force closed active engines");
+      }
       const engines = await ActiveEngine.list();
-      if (engines.length > 0) {
+      if (engines.length > 0 && !force) {
         log.info({ count: engines.length }, "waiting for active engines to finish");
         const deadline = Date.now() + 300_000;
         while (Date.now() < deadline) {
@@ -378,8 +389,8 @@ export async function runDaemon(): Promise<void> {
           if (remaining.length === 0) break;
           await new Promise((r) => setTimeout(r, 1000));
         }
-        await ActiveEngine.clearAll();
       }
+      if (engines.length > 0 || force) await ActiveEngine.clearAll();
     } catch {
       // postgres may be gone
     }

package/src/core/engine-guard.ts

@@ -3,7 +3,7 @@
  *
  * Default: warn and refuse.
  * --wait <minutes>: poll until engines clear, then proceed. Times out with error.
- * --force: skip the check entirely.
+ * --force: skip the guard and ask the daemon to close active handles.
  */
 
 import { ActiveEngine } from "../db/models";

package/src/core/force-shutdown.ts

@@ -0,0 +1,52 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { getNiaHome } from "../utils/paths";
+
+const FORCE_MARKER_MAX_AGE_MS = 10 * 60 * 1000;
+
+interface ForceShutdownMarker {
+  createdAt: number;
+  pids: number[];
+}
+
+function markerPath(): string {
+  return join(getNiaHome(), "tmp", "force-shutdown.json");
+}
+
+export function requestForceShutdown(pids: number[] = []): void {
+  const path = markerPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const uniquePids = [...new Set(pids.filter((pid) => Number.isInteger(pid) && pid > 0))];
+  const marker: ForceShutdownMarker = { createdAt: Date.now(), pids: uniquePids };
+  writeFileSync(path, JSON.stringify(marker));
+}
+
+export function clearForceShutdownRequest(): void {
+  try {
+    unlinkSync(markerPath());
+  } catch {
+    // already gone
+  }
+}
+
+export function consumeForceShutdownRequest(pid: number = process.pid): boolean {
+  const path = markerPath();
+  if (!existsSync(path)) return false;
+
+  let marker: ForceShutdownMarker;
+  try {
+    marker = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    clearForceShutdownRequest();
+    return false;
+  }
+
+  if (Date.now() - marker.createdAt > FORCE_MARKER_MAX_AGE_MS) {
+    clearForceShutdownRequest();
+    return false;
+  }
+
+  const applies = marker.pids.length === 0 || marker.pids.includes(pid);
+  if (applies) clearForceShutdownRequest();
+  return applies;
+}

package/src/core/runner.ts

@@ -17,6 +17,7 @@ import { ActiveEngine } from "../db/models";
 import { getPaths } from "../utils/paths";
 import { log } from "../utils/log";
 import { isRetryableApiError, sleep } from "../utils/retry";
+import { registerActiveHandle, unregisterActiveHandle } from "./active-handles";
 
 export type ActivityCallback = (line: string) => void;
 
@@ -98,6 +99,7 @@ export async function runJobWithClaude(
   onActivity?: ActivityCallback,
   model?: string,
   sourceCtx?: McpSourceContext,
+  activeRoom?: string,
 ): Promise<RunnerOutput> {
   const sessionId = randomUUID();
 
@@ -131,6 +133,13 @@ export async function runJobWithClaude(
     prompt: singleMessage() as any,
     options: options as any,
   });
+  let abortReason: string | null = null;
+  if (activeRoom) {
+    registerActiveHandle(activeRoom, (reason) => {
+      abortReason = reason;
+      handle.close();
+    });
+  }
 
   let agentText = "";
   let actualSessionId = sessionId;
@@ -214,8 +223,28 @@ export async function runJobWithClaude(
         }
       }
     }
+  } catch (err) {
+    if (abortReason) {
+      return {
+        agentText: "",
+        sessionId: actualSessionId,
+        terminalReason: "aborted",
+        error: abortReason,
+      };
+    }
+    throw err;
   } finally {
     handle.close();
+    if (activeRoom) unregisterActiveHandle(activeRoom);
+  }
+
+  if (abortReason) {
+    return {
+      agentText: "",
+      sessionId: actualSessionId,
+      terminalReason: "aborted",
+      error: abortReason,
+    };
   }
 
   return { agentText, sessionId: actualSessionId, terminalReason };
@@ -243,7 +272,7 @@ export async function runTask(opts: TaskOptions): Promise<RunnerOutput> {
   await ActiveEngine.register(room, "system").catch(() => {});
   try {
     const systemPrompt = opts.systemPrompt || buildSystemPrompt("job");
-    const output = await runJobWithClaude(systemPrompt, opts.prompt, homedir());
+    const output = await runJobWithClaude(systemPrompt, opts.prompt, homedir(), undefined, undefined, undefined, room);
     if (output.error) {
       log.error({ task: opts.name, error: output.error }, "task failed");
     } else {
@@ -297,11 +326,13 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
   const config = getConfig();
   const timestamp = new Date().toISOString();
   const startMs = performance.now();
+  const room = `job/${job.name}`;
 
   // Update state: running
   const state: Record<string, JobState> = { ...readState() };
   state[job.name] = { lastRun: timestamp, status: "running", duration_ms: 0 };
   writeState(state);
+  await ActiveEngine.register(room, "job").catch(() => {});
 
   try {
     let cwd = homedir();
@@ -352,7 +383,7 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
       const fullPrompt = `${systemPrompt}\n\n---\n\n${jobPrompt}`;
       output = await runJobWithCodex(fullPrompt, cwd, resolvedModel);
     } else {
-      output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity, resolvedModel, jobSourceCtx);
+      output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity, resolvedModel, jobSourceCtx, room);
 
       for (let attempt = 0; attempt < MAX_API_RETRIES && output.error && isRetryableApiError(output.error); attempt++) {
         const delay = RETRY_DELAYS[attempt] ?? 8_000;
@@ -361,7 +392,7 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
           "retrying after transient API error",
         );
         await sleep(delay);
-        output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity, resolvedModel, jobSourceCtx);
+        output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity, resolvedModel, jobSourceCtx, room);
       }
     }
 
@@ -435,5 +466,7 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     writeState(freshState);
 
     return result;
+  } finally {
+    await ActiveEngine.unregister(room).catch(() => {});
   }
 }

package/src/prompts/environment.md

@@ -9,6 +9,13 @@ You are running as part of the assistant daemon.
 - Current date (authoritative): {{currentDate}}
 - Current time: {{currentTime}}
 
+## Runtime OS
+
+- OS: {{osName}} ({{osType}} {{osRelease}})
+- Platform: {{osPlatform}}
+- Architecture: {{osArch}}
+- Shell: {{shell}}
+
 When writing calendar digests, standups, reminders, or any dated message, preserve the weekday/date pairing from the authoritative current date above. If a weekday/date mismatch would matter, verify with the system date or source calendar before sending.
 
 ## Nia CLI

package/src/prompts/index.ts

@@ -3,6 +3,7 @@ import { join, resolve } from "path";
 import { getPaths } from "../utils/paths";
 import { getConfig } from "../utils/config";
 import { formatPromptDate, formatPromptDateTime } from "../utils/time";
+import { getRuntimeOsInfo } from "../utils/os";
 import type { Mode } from "../types";
 
 const PROMPTS_DIR = resolve(import.meta.dir);
@@ -21,6 +22,7 @@ export function getEnvironmentPrompt(): string {
   const paths = getPaths();
   const config = getConfig();
   const now = new Date();
+  const osInfo = getRuntimeOsInfo();
 
   // Build watch channel summary if Slack is configured with watch channels
   let slackWatch = "";
@@ -37,6 +39,12 @@ export function getEnvironmentPrompt(): string {
     timezone: config.timezone,
     currentDate: formatPromptDate(now, config.timezone),
     currentTime: formatPromptDateTime(now, config.timezone),
+    osName: osInfo.osName,
+    osType: osInfo.osType,
+    osRelease: osInfo.osRelease,
+    osPlatform: osInfo.osPlatform,
+    osArch: osInfo.osArch,
+    shell: osInfo.shell,
     activeStart: config.activeHours.start,
     activeEnd: config.activeHours.end,
     model: config.model,

package/src/utils/os.ts

@@ -0,0 +1,33 @@
+import { arch, platform, release, type } from "os";
+
+function shellName(): string {
+  const raw = process.env.SHELL || process.env.ComSpec || "";
+  if (!raw) return "unknown";
+  const normalized = raw.replace(/\\/g, "/");
+  return normalized.split("/").filter(Boolean).pop() || "unknown";
+}
+
+function osName(osPlatform: NodeJS.Platform): string {
+  switch (osPlatform) {
+    case "darwin":
+      return "macOS";
+    case "linux":
+      return "Linux";
+    case "win32":
+      return "Windows";
+    default:
+      return type();
+  }
+}
+
+export function getRuntimeOsInfo(): Record<string, string> {
+  const osPlatform = platform();
+  return {
+    osName: osName(osPlatform),
+    osType: type(),
+    osRelease: release(),
+    osPlatform,
+    osArch: arch(),
+    shell: shellName(),
+  };
+}