@sanity-labs/nuum 0.2.2 → 0.4.0

package/dist/index.js

@@ -4245,7 +4245,7 @@ var require_conditions = __commonJS((exports, module) => {
     isNotNull: () => isNotNull,
     isNull: () => isNull2,
     like: () => like2,
-    lt: () => lt,
+    lt: () => lt2,
     lte: () => lte2,
     ne: () => ne,
     not: () => not,
@@ -4310,7 +4310,7 @@ var require_conditions = __commonJS((exports, module) => {
   var gte2 = (left, right) => {
     return import_sql4.sql`${left} >= ${bindIfParam2(right, left)}`;
   };
-  var lt = (left, right) => {
+  var lt2 = (left, right) => {
     return import_sql4.sql`${left} < ${bindIfParam2(right, left)}`;
   };
   var lte2 = (left, right) => {
@@ -8968,6 +8968,76 @@ var require_bun_sqlite = __commonJS((exports, module) => {
   __reExport(bun_sqlite_exports, require_session2(), module.exports);
 });
 
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index2 = string.indexOf(close, open.length);
+    return ~index2 ? open + replaceClose(string, close, replace, index2) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index2) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index2) + replace;
+      cursor = index2 + close.length;
+      index2 = string.indexOf(close, cursor);
+    } while (~index2);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
 // node_modules/secure-json-parse/index.js
 var require_secure_json_parse = __commonJS((exports, module) => {
   var hasBuffer = typeof Buffer !== "undefined";
@@ -17401,7 +17471,10 @@ __export(exports_schema, {
   sessionConfig: () => sessionConfig,
   presentState: () => presentState,
   ltmEntries: () => ltmEntries,
-  backgroundReports: () => backgroundReports
+  backgroundTasks: () => backgroundTasks,
+  backgroundTaskQueue: () => backgroundTaskQueue,
+  backgroundReports: () => backgroundReports,
+  alarms: () => alarms
 });
 
 // node_modules/drizzle-orm/entity.js
@@ -18575,6 +18648,9 @@ function and(...unfilteredConditions) {
 var gte = (left, right) => {
   return sql`${left} >= ${bindIfParam(right, left)}`;
 };
+var lt = (left, right) => {
+  return sql`${left} < ${bindIfParam(right, left)}`;
+};
 var lte = (left, right) => {
   return sql`${left} <= ${bindIfParam(right, left)}`;
 };
@@ -18643,9 +18719,7 @@ var temporalMessages = sqliteTable("temporal_messages", {
   content: text("content").notNull(),
   tokenEstimate: integer("token_estimate").notNull(),
   createdAt: text("created_at").notNull()
-}, (table) => [
-  index("idx_temporal_messages_created").on(table.id)
-]);
+}, (table) => [index("idx_temporal_messages_created").on(table.id)]);
 var temporalSummaries = sqliteTable("temporal_summaries", {
   id: text("id").primaryKey(),
   orderNum: integer("order_num").notNull(),
@@ -18701,9 +18775,29 @@ var backgroundReports = sqliteTable("background_reports", {
   subsystem: text("subsystem").notNull(),
   report: text("report").notNull(),
   surfacedAt: text("surfaced_at")
-}, (table) => [
-  index("idx_background_reports_unsurfaced").on(table.surfacedAt)
-]);
+}, (table) => [index("idx_background_reports_unsurfaced").on(table.surfacedAt)]);
+var backgroundTasks = sqliteTable("background_tasks", {
+  id: text("id").primaryKey(),
+  type: text("type").notNull(),
+  description: text("description").notNull(),
+  status: text("status").notNull(),
+  createdAt: text("created_at").notNull(),
+  completedAt: text("completed_at"),
+  result: text("result"),
+  error: text("error")
+}, (table) => [index("idx_background_tasks_status").on(table.status)]);
+var backgroundTaskQueue = sqliteTable("background_task_queue", {
+  id: text("id").primaryKey(),
+  taskId: text("task_id").notNull(),
+  createdAt: text("created_at").notNull(),
+  content: text("content").notNull()
+}, (table) => [index("idx_background_task_queue_created").on(table.createdAt)]);
+var alarms = sqliteTable("alarms", {
+  id: text("id").primaryKey(),
+  firesAt: text("fires_at").notNull(),
+  note: text("note").notNull(),
+  fired: integer("fired").notNull().default(0)
+}, (table) => [index("idx_alarms_fires_at").on(table.firesAt)]);
 
 // src/storage/db.ts
 var isBun = typeof globalThis.Bun !== "undefined";
@@ -22705,6 +22799,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 // src/util/log.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
 var Log;
 ((Log) => {
   Log.Level = exports_external.enum(["DEBUG", "INFO", "WARN", "ERROR"]);
@@ -22714,7 +22809,13 @@ var Log;
     WARN: 2,
     ERROR: 3
   };
-  let level = "INFO";
+  const levelColors = {
+    DEBUG: import_picocolors.default.gray,
+    INFO: import_picocolors.default.blue,
+    WARN: (s) => import_picocolors.default.bold(import_picocolors.default.yellow(s)),
+    ERROR: (s) => import_picocolors.default.bold(import_picocolors.default.red(s))
+  };
+  let level = "WARN";
   function shouldLog(input) {
     return levelPriority[input] >= levelPriority[level];
   }
@@ -22751,43 +22852,46 @@ var Log;
         return cached;
       }
     }
-    function build(message, extra) {
+    function build(logLevel, message, extra) {
       const prefix = Object.entries({
         ...tags,
         ...extra
       }).filter(([_, value]) => value !== undefined && value !== null).map(([key, value]) => {
-        const prefix2 = `${key}=`;
+        const keyStr = import_picocolors.default.dim(key + "=");
         if (value instanceof Error)
-          return prefix2 + formatError(value);
+          return keyStr + import_picocolors.default.red(formatError(value));
         if (typeof value === "object")
-          return prefix2 + JSON.stringify(value);
-        return prefix2 + value;
+          return keyStr + import_picocolors.default.cyan(JSON.stringify(value));
+        return keyStr + value;
       }).join(" ");
       const next = new Date;
       const diff = next.getTime() - last;
       last = next.getTime();
-      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + `
+      const timestamp = import_picocolors.default.dim(next.toISOString().split(".")[0]);
+      const duration = import_picocolors.default.dim("+" + diff + "ms");
+      const levelStr = levelColors[logLevel](logLevel.padEnd(5));
+      return [levelStr, timestamp, duration, prefix, message].filter(Boolean).join(" ") + `
 `;
     }
     const result = {
       debug(message, extra) {
         if (shouldLog("DEBUG")) {
-          write("DEBUG " + build(message, extra));
+          write(build("DEBUG", message, extra));
         }
       },
       info(message, extra) {
         if (shouldLog("INFO")) {
-          write("INFO  " + build(message, extra));
+          write(build("INFO", message, extra));
         }
       },
       error(message, extra) {
         if (shouldLog("ERROR")) {
-          write("ERROR " + build(message, extra));
+          write(build("ERROR", message, extra));
         }
       },
       warn(message, extra) {
         if (shouldLog("WARN")) {
-          write("WARN  " + build(message, extra));
+          write(build("WARN", message, extra));
         }
       },
       tag(key, value) {
@@ -22911,7 +23015,10 @@ function rebuildFTSIndexes(db) {
         db.exec(`INSERT INTO ${tableName}(${tableName}) VALUES('rebuild')`);
         log.debug("rebuilt FTS index", { table: tableName });
       } catch (error) {
-        log.debug("skipped FTS rebuild", { table: tableName, reason: String(error) });
+        log.debug("skipped FTS rebuild", {
+          table: tableName,
+          reason: String(error)
+        });
       }
     }
   } catch (error) {
@@ -23468,6 +23575,9 @@ var Identifier;
     entry: "ent",
     worker: "wrk",
     report: "rpt",
+    bgtask: "bgt",
+    queue: "que",
+    alarm: "alm",
     session: "ses",
     toolcall: "tcl"
   };
@@ -23612,6 +23722,159 @@ function createBackgroundStorage(db) {
   };
 }
 
+// src/storage/tasks.ts
+function createTasksStorage(db) {
+  return {
+    async createTask(input) {
+      const id = Identifier.ascending("bgtask");
+      const now = new Date().toISOString();
+      await db.insert(backgroundTasks).values({
+        id,
+        type: input.type,
+        description: input.description,
+        status: "running",
+        createdAt: now
+      });
+      return id;
+    },
+    async getTask(id) {
+      const rows = await db.select().from(backgroundTasks).where(eq(backgroundTasks.id, id)).limit(1);
+      if (rows.length === 0)
+        return null;
+      const row = rows[0];
+      return {
+        id: row.id,
+        type: row.type,
+        description: row.description,
+        status: row.status,
+        createdAt: row.createdAt,
+        completedAt: row.completedAt,
+        result: row.result ? JSON.parse(row.result) : null,
+        error: row.error
+      };
+    },
+    async listTasks(options) {
+      const limit = options?.limit ?? 50;
+      let query = db.select().from(backgroundTasks);
+      if (options?.status) {
+        query = query.where(eq(backgroundTasks.status, options.status));
+      }
+      const rows = await query.orderBy(backgroundTasks.createdAt).limit(limit);
+      return rows.map((row) => ({
+        id: row.id,
+        type: row.type,
+        description: row.description,
+        status: row.status,
+        createdAt: row.createdAt,
+        completedAt: row.completedAt,
+        result: row.result ? JSON.parse(row.result) : null,
+        error: row.error
+      }));
+    },
+    async completeTask(id, result) {
+      const now = new Date().toISOString();
+      await db.update(backgroundTasks).set({
+        status: "completed",
+        completedAt: now,
+        result: JSON.stringify(result)
+      }).where(eq(backgroundTasks.id, id));
+    },
+    async failTask(id, error) {
+      const now = new Date().toISOString();
+      await db.update(backgroundTasks).set({
+        status: "failed",
+        completedAt: now,
+        error
+      }).where(eq(backgroundTasks.id, id));
+    },
+    async recoverKilledTasks() {
+      const runningTasks = await db.select().from(backgroundTasks).where(eq(backgroundTasks.status, "running"));
+      if (runningTasks.length > 0) {
+        const now = new Date().toISOString();
+        await db.update(backgroundTasks).set({
+          status: "killed",
+          completedAt: now
+        }).where(eq(backgroundTasks.status, "running"));
+      }
+      return runningTasks.map((row) => ({
+        id: row.id,
+        type: row.type,
+        description: row.description,
+        status: "killed",
+        createdAt: row.createdAt,
+        completedAt: row.completedAt,
+        result: null,
+        error: null
+      }));
+    },
+    async queueResult(taskId, content) {
+      const id = Identifier.ascending("bgtask");
+      const now = new Date().toISOString();
+      await db.insert(backgroundTaskQueue).values({
+        id,
+        taskId,
+        createdAt: now,
+        content
+      });
+    },
+    async drainQueue() {
+      const rows = await db.select().from(backgroundTaskQueue).orderBy(backgroundTaskQueue.createdAt);
+      if (rows.length === 0)
+        return [];
+      const ids = rows.map((r) => r.id);
+      for (const id of ids) {
+        await db.delete(backgroundTaskQueue).where(eq(backgroundTaskQueue.id, id));
+      }
+      return rows.map((row) => ({
+        id: row.id,
+        taskId: row.taskId,
+        createdAt: row.createdAt,
+        content: row.content
+      }));
+    },
+    async hasQueuedResults() {
+      const rows = await db.select({ id: backgroundTaskQueue.id }).from(backgroundTaskQueue).limit(1);
+      return rows.length > 0;
+    },
+    async createAlarm(input) {
+      const id = Identifier.ascending("bgtask");
+      await db.insert(alarms).values({
+        id,
+        firesAt: input.firesAt,
+        note: input.note,
+        fired: 0
+      });
+      return id;
+    },
+    async getDueAlarms() {
+      const now = new Date().toISOString();
+      const rows = await db.select().from(alarms).where(and(eq(alarms.fired, 0), lt(alarms.firesAt, now))).orderBy(alarms.firesAt);
+      return rows.map((row) => ({
+        id: row.id,
+        firesAt: row.firesAt,
+        note: row.note,
+        fired: row.fired === 1
+      }));
+    },
+    async markAlarmFired(id) {
+      await db.update(alarms).set({ fired: 1 }).where(eq(alarms.id, id));
+    },
+    async listAlarms(options) {
+      let query = db.select().from(alarms);
+      if (!options?.includeFired) {
+        query = query.where(eq(alarms.fired, 0));
+      }
+      const rows = await query.orderBy(alarms.firesAt);
+      return rows.map((row) => ({
+        id: row.id,
+        firesAt: row.firesAt,
+        note: row.note,
+        fired: row.fired === 1
+      }));
+    }
+  };
+}
+
 // src/storage/index.ts
 function createStorage(dbPath, options) {
   const { mkdirSync } = __require("fs");
@@ -23631,6 +23894,7 @@ function createStorageFromDb(db) {
     workers: createWorkerStorage(db),
     session: createSessionStorage(db),
     background: createBackgroundStorage(db),
+    tasks: createTasksStorage(db),
     _db: db
   };
 }
@@ -31800,7 +32064,10 @@ Please check the tool's parameter schema and try again with correct arguments.`;
     });
   }
   function createToolCallRepairFunction() {
-    return async ({ toolCall, error }) => {
+    return async ({
+      toolCall,
+      error
+    }) => {
       const errorMessage = error.message || String(error);
       log3.warn("invalid tool call - redirecting to error tool", {
         toolName: toolCall.toolName,
@@ -31996,7 +32263,9 @@ var Shell;
       return;
     if (process.platform === "win32") {
       await new Promise((resolve2) => {
-        const killer = spawn("taskkill", ["/pid", String(pid), "/f", "/t"], { stdio: "ignore" });
+        const killer = spawn("taskkill", ["/pid", String(pid), "/f", "/t"], {
+          stdio: "ignore"
+        });
         killer.once("exit", () => resolve2());
         killer.once("error", () => resolve2());
       });
@@ -34293,63 +34562,246 @@ QUESTION: ${question}`
     };
   }
 });
-// src/util/activity-log.ts
+// src/cli/renderer.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+var lastEventType = "none";
+var replContext = null;
+function resetRenderer() {
+  lastEventType = "none";
+}
+function setReplContext(rl, prompt) {
+  replContext = { rl, prompt, isRunning: false };
+}
+function clearReplContext() {
+  replContext = null;
+}
+function setReplRunning(running) {
+  if (replContext) {
+    replContext.isRunning = running;
+  }
+}
+var DEFAULT_WIDTH = 80;
+var BULLET = import_picocolors2.default.blue("\u23FA");
+var CONTINUATION_INDENT = "  ";
+function getTerminalWidth() {
+  return process.stdout.columns || DEFAULT_WIDTH;
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+function displayWidth(str) {
+  const stripped = stripAnsi(str);
+  let width = 0;
+  for (const char of stripped) {
+    const code = char.codePointAt(0) || 0;
+    if (code >= 127744 && code <= 129535 || code >= 9728 && code <= 9983 || code >= 9984 && code <= 10175 || code >= 128512 && code <= 128591 || code >= 128640 && code <= 128767) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function wrapLine(text3, maxWidth) {
+  const tokens = text3.split(/(\s+)/);
+  const lines = [];
+  let currentLine = "";
+  let currentWidth = 0;
+  for (const token of tokens) {
+    if (!token)
+      continue;
+    if (!currentLine && /^\s+$/.test(token))
+      continue;
+    const isWhitespace = /^\s+$/.test(token);
+    const tokenWidth = displayWidth(token);
+    if (currentWidth + tokenWidth <= maxWidth) {
+      currentLine += token;
+      currentWidth += tokenWidth;
+    } else if (isWhitespace) {
+      continue;
+    } else if (!currentLine) {
+      currentLine = token;
+      currentWidth = tokenWidth;
+    } else {
+      lines.push(currentLine);
+      currentLine = token;
+      currentWidth = tokenWidth;
+    }
+  }
+  if (currentLine)
+    lines.push(currentLine);
+  return lines.length > 0 ? lines : [""];
+}
+function formatWithBullet(text3) {
+  const termWidth = getTerminalWidth();
+  const bulletPrefix = `${BULLET} `;
+  const bulletLen = displayWidth(bulletPrefix);
+  const maxFirstLine = termWidth - bulletLen;
+  const maxContLine = termWidth - CONTINUATION_INDENT.length;
+  const inputLines = text3.split(`
+`);
+  const result = [];
+  let isFirstOutputLine = true;
+  for (const inputLine of inputLines) {
+    if (inputLine === "") {
+      result.push(isFirstOutputLine ? bulletPrefix : CONTINUATION_INDENT);
+      isFirstOutputLine = false;
+      continue;
+    }
+    const maxWidth = isFirstOutputLine ? maxFirstLine : maxContLine;
+    const wrapped = wrapLine(inputLine, maxWidth);
+    for (const line of wrapped) {
+      if (isFirstOutputLine) {
+        result.push(bulletPrefix + line);
+        isFirstOutputLine = false;
+      } else {
+        result.push(CONTINUATION_INDENT + line);
+      }
+    }
+  }
+  return result.join(`
+`);
+}
 var ICONS = {
-  tool_call: "\uD83D\uDD27",
-  tool_result: "\u2713",
-  tool_error: "\u2717",
-  search: "\uD83D\uDD0D",
-  create: "\uD83D\uDCDD",
-  update: "\uD83D\uDCDD",
-  delete: "\uD83D\uDDD1\uFE0F",
-  start: "\u25B6",
-  complete: "\u2713",
-  skip: "\u2298",
-  thinking: "\uD83D\uDCAD",
-  info: "\u2139",
-  warn: "\u26A0",
-  error: "\u2717"
+  success: import_picocolors2.default.green("\u2713"),
+  error: import_picocolors2.default.red("\u2717"),
+  start: import_picocolors2.default.blue("\u25B6"),
+  complete: import_picocolors2.default.green("\u2713"),
+  skip: import_picocolors2.default.dim("\u2298"),
+  info: import_picocolors2.default.blue("\u2139"),
+  warn: import_picocolors2.default.yellow("\u26A0")
 };
-function formatWorker(worker) {
-  return `[${worker}]`;
-}
-function truncate(str, maxLen = 100) {
+function truncate(str, maxLen = 60) {
   if (str.length <= maxLen)
     return str;
   const half = Math.floor((maxLen - 5) / 2);
   return str.slice(0, half) + " ... " + str.slice(-half);
 }
-function formatSize(bytes, lines) {
-  const parts = [];
-  if (lines !== undefined)
-    parts.push(`${lines} lines`);
-  if (bytes !== undefined) {
-    if (bytes < 1024)
-      parts.push(`${bytes}b`);
-    else
-      parts.push(`${(bytes / 1024).toFixed(1)}kb`);
-  }
-  return parts.join(", ");
-}
-function formatArgs(args) {
+function formatToolArgs(args) {
   const parts = [];
   for (const [key, value] of Object.entries(args)) {
     if (value === undefined || value === null)
       continue;
+    let display;
     if (typeof value === "string") {
-      parts.push(`${key}=${truncate(value, 60)}`);
+      display = truncate(value, 50);
     } else if (typeof value === "number" || typeof value === "boolean") {
-      parts.push(`${key}=${value}`);
+      display = String(value);
     } else {
-      parts.push(`${key}=${truncate(JSON.stringify(value), 40)}`);
+      display = truncate(JSON.stringify(value), 40);
+    }
+    parts.push(`${import_picocolors2.default.dim(key + "=")}${import_picocolors2.default.cyan(display)}`);
+  }
+  return parts.length > 0 ? `${import_picocolors2.default.dim("(")}${parts.join(import_picocolors2.default.dim(", "))}${import_picocolors2.default.dim(")")}` : "";
+}
+function formatEvent(event) {
+  switch (event.type) {
+    case "tool_start": {
+      const args = formatToolArgs(event.args);
+      return formatWithBullet(`${import_picocolors2.default.magenta(event.tool)}${args}`);
+    }
+    case "tool_result": {
+      return formatWithBullet(`${ICONS.success} ${import_picocolors2.default.magenta(event.tool)}${import_picocolors2.default.dim(":")} ${event.summary}`);
+    }
+    case "tool_error": {
+      return formatWithBullet(`${ICONS.error} ${import_picocolors2.default.magenta(event.tool)}${import_picocolors2.default.dim(":")} ${import_picocolors2.default.red(truncate(event.error, 100))}`);
+    }
+    case "thinking": {
+      const msg = event.message || "processing...";
+      return formatWithBullet(import_picocolors2.default.dim(msg));
+    }
+    case "text": {
+      return formatWithBullet(event.text);
+    }
+    case "lifecycle": {
+      const icon = event.action === "start" ? ICONS.start : event.action === "complete" ? ICONS.complete : ICONS.skip;
+      const detail = event.detail ? import_picocolors2.default.dim(` (${formatDetailArgs(event.detail)})`) : "";
+      return formatWithBullet(`${icon} ${event.message}${detail}`);
+    }
+    case "info": {
+      const icon = event.level === "error" ? ICONS.error : event.level === "warn" ? ICONS.warn : ICONS.info;
+      const msg = event.level === "error" ? import_picocolors2.default.red(event.message) : event.level === "warn" ? import_picocolors2.default.yellow(event.message) : event.message;
+      return formatWithBullet(`${icon} ${msg}`);
     }
   }
+}
+function formatDetailArgs(detail) {
+  const parts = [];
+  for (const [key, value] of Object.entries(detail)) {
+    if (value === undefined || value === null)
+      continue;
+    parts.push(`${key}=${String(value)}`);
+  }
   return parts.join(", ");
 }
-function write(line) {
-  process.stderr.write(line + `
+function needsBlankLineBefore(event) {
+  if (lastEventType === "none")
+    return false;
+  if (event.type === "text" && lastEventType !== "text")
+    return true;
+  if (event.type === "thinking" && lastEventType === "tool_result")
+    return true;
+  if (event.type !== "text" && lastEventType === "text")
+    return true;
+  return false;
+}
+function writeStderr(text3) {
+  if (replContext && !replContext.isRunning) {
+    process.stdout.write("\r\x1B[K");
+    process.stderr.write(text3);
+    replContext.rl.prompt(true);
+  } else {
+    process.stderr.write(text3);
+  }
+}
+function writeStdout(text3) {
+  process.stdout.write(text3);
+}
+function render(event) {
+  if (needsBlankLineBefore(event)) {
+    if (event.type === "text") {
+      writeStdout(`
+`);
+    } else {
+      writeStderr(`
+`);
+    }
+  }
+  const formatted = formatEvent(event);
+  if (event.type === "text") {
+    writeStdout(formatted + `
+`);
+  } else {
+    writeStderr(formatted + `
+`);
+  }
+  lastEventType = event.type;
+}
+function renderEnd() {
+  writeStdout(`
+
 `);
 }
+function renderRaw(text3) {
+  writeStdout(text3);
+}
+function renderRawStderr(text3) {
+  writeStderr(text3);
+}
+
+// src/util/activity-log.ts
+function formatSize(bytes, lines) {
+  const parts = [];
+  if (lines !== undefined)
+    parts.push(`${lines} lines`);
+  if (bytes !== undefined) {
+    if (bytes < 1024)
+      parts.push(`${bytes}b`);
+    else
+      parts.push(`${(bytes / 1024).toFixed(1)}kb`);
+  }
+  return parts.join(", ");
+}
 
 class ActivityLog {
   worker;
@@ -34357,53 +34809,118 @@ class ActivityLog {
     this.worker = worker;
   }
   toolCall(name17, args) {
-    const argsStr = formatArgs(args);
-    write(`${formatWorker(this.worker)} ${ICONS.tool_call} ${name17}(${argsStr})`);
+    render({
+      type: "tool_start",
+      worker: this.worker,
+      tool: name17,
+      args
+    });
   }
   toolResult(name17, summary) {
-    write(`${formatWorker(this.worker)} ${ICONS.tool_result} ${name17}: ${summary}`);
+    render({
+      type: "tool_result",
+      worker: this.worker,
+      tool: name17,
+      summary
+    });
   }
   toolError(name17, error) {
-    write(`${formatWorker(this.worker)} ${ICONS.tool_error} ${name17}: ${truncate(error, 100)}`);
+    render({
+      type: "tool_error",
+      worker: this.worker,
+      tool: name17,
+      error
+    });
   }
   fileRead(path8, lines, bytes) {
-    write(`${formatWorker(this.worker)} ${ICONS.tool_result} read: ${formatSize(bytes, lines)}`);
+    render({
+      type: "tool_result",
+      worker: this.worker,
+      tool: "read",
+      summary: formatSize(bytes, lines)
+    });
   }
-  searchResult(type, count, query) {
-    const queryStr = query ? ` "${truncate(query, 30)}"` : "";
-    write(`${formatWorker(this.worker)} ${ICONS.search} ${type}${queryStr} \u2192 ${count} results`);
+  searchResult(type, count, _query) {
+    render({
+      type: "tool_result",
+      worker: this.worker,
+      tool: type,
+      summary: `${count} matches`
+    });
   }
   ltmOperation(op, slug, detail) {
-    const icon = op === "archive" ? ICONS.delete : ICONS.update;
-    const detailStr = detail ? ` - ${detail}` : "";
-    write(`${formatWorker(this.worker)} ${icon} ltm_${op}("${slug}")${detailStr}`);
+    render({
+      type: "tool_result",
+      worker: this.worker,
+      tool: `ltm_${op}`,
+      summary: `"${slug}"${detail ? ` - ${detail}` : ""}`
+    });
   }
   start(description, detail) {
-    const detailStr = detail ? ` (${formatArgs(detail)})` : "";
-    write(`${formatWorker(this.worker)} ${ICONS.start} ${description}${detailStr}`);
+    render({
+      type: "lifecycle",
+      worker: this.worker,
+      action: "start",
+      message: description,
+      detail
+    });
   }
   complete(summary) {
-    write(`${formatWorker(this.worker)} ${ICONS.complete} ${summary}`);
+    render({
+      type: "lifecycle",
+      worker: this.worker,
+      action: "complete",
+      message: summary
+    });
   }
   skip(reason) {
-    write(`${formatWorker(this.worker)} ${ICONS.skip} Skipped: ${reason}`);
+    render({
+      type: "lifecycle",
+      worker: this.worker,
+      action: "skip",
+      message: `Skipped: ${reason}`
+    });
   }
   thinking(thought) {
-    write(`${formatWorker(this.worker)} ${ICONS.thinking} ${truncate(thought, 150)}`);
+    render({
+      type: "thinking",
+      worker: this.worker,
+      message: thought
+    });
   }
   info(message) {
-    write(`${formatWorker(this.worker)} ${ICONS.info} ${message}`);
+    render({
+      type: "info",
+      worker: this.worker,
+      level: "info",
+      message
+    });
   }
   warn(message) {
-    write(`${formatWorker(this.worker)} ${ICONS.warn} ${message}`);
+    render({
+      type: "info",
+      worker: this.worker,
+      level: "warn",
+      message
+    });
   }
   error(message) {
-    write(`${formatWorker(this.worker)} ${ICONS.error} ${message}`);
+    render({
+      type: "info",
+      worker: this.worker,
+      level: "error",
+      message
+    });
   }
   tokens(before, after, detail) {
     const reduction = Math.round((1 - after / before) * 100);
-    const detailStr = detail ? `, ${detail}` : "";
-    write(`${formatWorker(this.worker)} ${ICONS.info} ${before.toLocaleString()} \u2192 ${after.toLocaleString()} tokens (${reduction}% reduction${detailStr})`);
+    const msg = `${before.toLocaleString()} \u2192 ${after.toLocaleString()} tokens (${reduction}% reduction${detail ? `, ${detail}` : ""})`;
+    render({
+      type: "info",
+      worker: this.worker,
+      level: "info",
+      message: msg
+    });
   }
 }
 var activity = {
@@ -34772,7 +35289,10 @@ function processMessageForTurn(message, allMessages, currentIdx) {
   const turns = [];
   switch (message.type) {
     case "user":
-      turns.push({ role: "user", content: formatWithId(message.id, message.createdAt, message.content) });
+      turns.push({
+        role: "user",
+        content: formatWithId(message.id, message.createdAt, message.content)
+      });
       return { turns, nextIdx: currentIdx + 1 };
     case "assistant": {
       const toolCalls = [];
@@ -34816,7 +35336,10 @@ function processMessageForTurn(message, allMessages, currentIdx) {
         const assistantContent = [];
         const idPrefix = formatIdRange(message.id, lastMessageId, message.createdAt);
         if (message.content) {
-          assistantContent.push({ type: "text", text: `${idPrefix} ${message.content}` });
+          assistantContent.push({
+            type: "text",
+            text: `${idPrefix} ${message.content}`
+          });
         } else {
           assistantContent.push({ type: "text", text: idPrefix });
         }
@@ -34833,7 +35356,10 @@ function processMessageForTurn(message, allMessages, currentIdx) {
         };
         turns.push(toolMsg);
       } else {
-        turns.push({ role: "assistant", content: formatWithId(message.id, message.createdAt, message.content) });
+        turns.push({
+          role: "assistant",
+          content: formatWithId(message.id, message.createdAt, message.content)
+        });
       }
       return { turns, nextIdx };
     }
@@ -34878,10 +35404,7 @@ function processMessageForTurn(message, allMessages, currentIdx) {
       }
       if (toolCalls.length > 0) {
         const idPrefix = formatIdRange(firstMessageId, lastMessageId, message.createdAt);
-        const assistantContent = [
-          { type: "text", text: idPrefix },
-          ...toolCalls
-        ];
+        const assistantContent = [{ type: "text", text: idPrefix }, ...toolCalls];
         const assistantMsg = {
           role: "assistant",
           content: assistantContent
@@ -34983,7 +35506,8 @@ async function runAgentLoop(options) {
     onToolResult,
     onText,
     onToolCall,
-    onBeforeTurn
+    onBeforeTurn,
+    onThinking
   } = options;
   if (abortSignal?.aborted) {
     throw new AgentLoopCancelledError;
@@ -35005,9 +35529,14 @@ async function runAgentLoop(options) {
         role: "user",
         content: injectedContent
       });
-      log5.info("injected mid-turn user message", { contentLength: injectedContent.length });
+      log5.info("injected mid-turn user message", {
+        contentLength: injectedContent.length
+      });
     }
     turnsUsed++;
+    if (turn > 0) {
+      onThinking?.();
+    }
     const messagesWithCache = addCacheMarkers(messages);
     const response = await Provider.generate({
       model,
@@ -35583,7 +36112,11 @@ function buildGetMessageTool(ctx) {
       contextAfter: exports_external.number().optional().describe("Number of messages to include after (default: 0)")
     }),
     execute: async ({ id, contextBefore, contextAfter }) => {
-      activity.reflection.toolCall("get_message", { id, contextBefore, contextAfter });
+      activity.reflection.toolCall("get_message", {
+        id,
+        contextBefore,
+        contextAfter
+      });
       const messages = await storage.temporal.getMessageWithContext({
         id,
         contextBefore: contextBefore ?? 0,
@@ -35683,7 +36216,9 @@ I'll search my memory now. Once I have enough information, I MUST call finish_re
 `;
 }
 async function runReflection(storage, question) {
-  activity.reflection.start("Memory research", { question: question.slice(0, 50) });
+  activity.reflection.start("Memory research", {
+    question: question.slice(0, 50)
+  });
   const { tools, getAnswer } = buildReflectionTools({ storage });
   const result = await runSubAgent(storage, {
     name: "reflection",
@@ -35996,7 +36531,11 @@ ${marker17}${m.content}`;
       report: exports_external.string().describe("Your research report. Include: 1) Summary of what you learned, 2) LTM entries created/updated with [[slug]] references, 3) Key sources consulted.")
     }),
     execute: async ({ report }, { toolCallId }) => {
-      results.set(toolCallId, { output: "Research complete.", done: true, report });
+      results.set(toolCallId, {
+        output: "Research complete.",
+        done: true,
+        report
+      });
       return "Research complete.";
     }
   });
@@ -44317,8 +44856,8 @@ var Mcp;
     parse: (data) => Mcp.ConfigSchema.parse(data),
     safeParse: (data) => Mcp.ConfigSchema.safeParse(data)
   };
-  const CONFIG_FILE_PATH = path8.join(os2.homedir(), ".config", "miriad", "code.json");
-  const CONFIG_ENV_VAR = "MIRIAD_MCP_CONFIG";
+  const CONFIG_FILE_PATH = path8.join(os2.homedir(), ".config", "nuum", "mcp.json");
+  const CONFIG_ENV_VAR = "NUUM_MCP_CONFIG";
   async function loadConfig() {
     const envConfig = process.env[CONFIG_ENV_VAR];
     if (envConfig) {
@@ -44384,7 +44923,7 @@ var Mcp;
           status: "disabled"
         };
       }
-      const client = new Client({ name: "miriad-code", version: "0.1.0" }, { capabilities: {} });
+      const client = new Client({ name: "nuum", version: "0.1.0" }, { capabilities: {} });
       try {
         const transport = this.createTransport(config2);
         if (transport instanceof StdioClientTransport && transport.stderr) {
@@ -44751,7 +45290,10 @@ Returns: [{ slug, title, path, snippet }, ...] ranked by relevance`,
     const { query, path: path9, limit } = args;
     const results = await ltm.search(query, path9);
     const limited = results.slice(0, limit ?? 10);
-    ctx.metadata({ title: `ltm_search("${query}")`, metadata: { operation: "search" } });
+    ctx.metadata({
+      title: `ltm_search("${query}")`,
+      metadata: { operation: "search" }
+    });
     if (limited.length === 0) {
       return {
         title: `ltm_search("${query}")`,
@@ -44789,7 +45331,10 @@ Knowledge entries may contain [[slug]] cross-references - follow these to explor
     const { ltm } = ctx.extra;
     const { slug } = args;
     const entry = await ltm.read(slug);
-    ctx.metadata({ title: `ltm_read("${slug}")`, metadata: { entrySlug: slug, operation: "read" } });
+    ctx.metadata({
+      title: `ltm_read("${slug}")`,
+      metadata: { entrySlug: slug, operation: "read" }
+    });
     if (!entry) {
       return {
         title: `ltm_read("${slug}")`,
@@ -44832,7 +45377,10 @@ Example: ltm_create({
   async execute(args, ctx) {
     const { ltm, agentType } = ctx.extra;
     const { slug, parentSlug, title, body, links } = args;
-    ctx.metadata({ title: `ltm_create("${slug}")`, metadata: { entrySlug: slug, operation: "create" } });
+    ctx.metadata({
+      title: `ltm_create("${slug}")`,
+      metadata: { entrySlug: slug, operation: "create" }
+    });
     try {
       await ltm.create({
         slug,
@@ -44876,7 +45424,10 @@ On version conflict: Error shows current version. Re-read and retry.`,
   async execute(args, ctx) {
     const { ltm, agentType } = ctx.extra;
     const { slug, newBody, expectedVersion } = args;
-    ctx.metadata({ title: `ltm_update("${slug}")`, metadata: { entrySlug: slug, operation: "update" } });
+    ctx.metadata({
+      title: `ltm_update("${slug}")`,
+      metadata: { entrySlug: slug, operation: "update" }
+    });
     try {
       await ltm.update(slug, newBody, expectedVersion, agentType);
       return {
@@ -44926,7 +45477,10 @@ On version conflict: Error shows current version - re-read and retry.`,
   async execute(args, ctx) {
     const { ltm, agentType } = ctx.extra;
     const { slug, oldString, newString, expectedVersion } = args;
-    ctx.metadata({ title: `ltm_edit("${slug}")`, metadata: { entrySlug: slug, operation: "edit" } });
+    ctx.metadata({
+      title: `ltm_edit("${slug}")`,
+      metadata: { entrySlug: slug, operation: "edit" }
+    });
     try {
       await ltm.edit(slug, oldString, newString, expectedVersion, agentType);
       return {
@@ -44973,7 +45527,10 @@ Updates path for this entry and all descendants.`,
   async execute(args, ctx) {
     const { ltm, agentType } = ctx.extra;
     const { slug, newParentSlug, expectedVersion } = args;
-    ctx.metadata({ title: `ltm_reparent("${slug}")`, metadata: { entrySlug: slug, operation: "reparent" } });
+    ctx.metadata({
+      title: `ltm_reparent("${slug}")`,
+      metadata: { entrySlug: slug, operation: "reparent" }
+    });
     try {
       const updated = await ltm.reparent(slug, newParentSlug, expectedVersion, agentType);
       return {
@@ -45020,7 +45577,10 @@ Updates all paths. Children keep their relative position.`,
   async execute(args, ctx) {
     const { ltm, agentType } = ctx.extra;
     const { slug, newSlug, expectedVersion } = args;
-    ctx.metadata({ title: `ltm_rename("${slug}")`, metadata: { entrySlug: slug, operation: "rename" } });
+    ctx.metadata({
+      title: `ltm_rename("${slug}")`,
+      metadata: { entrySlug: slug, operation: "rename" }
+    });
     try {
       const updated = await ltm.rename(slug, newSlug, expectedVersion, agentType);
       return {
@@ -45061,7 +45621,10 @@ Example: ltm_archive({
   async execute(args, ctx) {
     const { ltm } = ctx.extra;
     const { slug, expectedVersion } = args;
-    ctx.metadata({ title: `ltm_archive("${slug}")`, metadata: { entrySlug: slug, operation: "archive" } });
+    ctx.metadata({
+      title: `ltm_archive("${slug}")`,
+      metadata: { entrySlug: slug, operation: "archive" }
+    });
     try {
       await ltm.archive(slug, expectedVersion);
       return {
@@ -45105,6 +45668,494 @@ var LTMTools = {
   ...LTMReadOnlyTools,
   ...LTMWriteTools
 };
+// src/tool/list-tasks.ts
+function formatElapsed(startTime) {
+  const start = new Date(startTime).getTime();
+  const now2 = Date.now();
+  const elapsed = Math.floor((now2 - start) / 1000);
+  if (elapsed < 60)
+    return `${elapsed}s`;
+  if (elapsed < 3600)
+    return `${Math.floor(elapsed / 60)}m ${elapsed % 60}s`;
+  const hours = Math.floor(elapsed / 3600);
+  const mins = Math.floor(elapsed % 3600 / 60);
+  return `${hours}h ${mins}m`;
+}
+function formatTimeUntil(firesAt) {
+  const fires = new Date(firesAt).getTime();
+  const now2 = Date.now();
+  const remaining = Math.floor((fires - now2) / 1000);
+  if (remaining <= 0)
+    return "due now";
+  if (remaining < 60)
+    return `in ${remaining}s`;
+  if (remaining < 3600)
+    return `in ${Math.floor(remaining / 60)}m`;
+  const hours = Math.floor(remaining / 3600);
+  const mins = Math.floor(remaining % 3600 / 60);
+  return `in ${hours}h ${mins}m`;
+}
+function formatTask(task) {
+  const elapsed = formatElapsed(task.createdAt);
+  const statusIcon = {
+    running: "\uD83D\uDD04",
+    completed: "\u2705",
+    failed: "\u274C",
+    killed: "\uD83D\uDC80"
+  }[task.status];
+  let line = `${statusIcon} #${task.id.slice(-8)} ${task.type}: "${task.description}" (${task.status}, ${elapsed})`;
+  if (task.error) {
+    line += `
+   Error: ${task.error}`;
+  }
+  return line;
+}
+function formatAlarm(alarm) {
+  const timeUntil = formatTimeUntil(alarm.firesAt);
+  return `\u23F0 #${alarm.id.slice(-8)}: "${alarm.note}" (${timeUntil})`;
+}
+var DESCRIPTION5 = `List background tasks and alarms.
+
+Shows:
+- Running background tasks (research, reflect)
+- Scheduled alarms (notes to self)
+- Recent completed/failed tasks (if includeCompleted=true)
+
+Use this to see what's in progress or scheduled.`;
+var parameters6 = exports_external.object({
+  includeCompleted: exports_external.boolean().optional().describe("Include completed/failed tasks (default: false, only shows running)")
+});
+var ListTasksTool = Tool.define("list_tasks", {
+  description: DESCRIPTION5,
+  parameters: parameters6,
+  async execute({ includeCompleted }, ctx) {
+    const tasksStorage = ctx.extra?.tasks;
+    if (!tasksStorage) {
+      return {
+        output: "Error: Tasks storage not available",
+        title: "List tasks failed",
+        metadata: {
+          runningCount: 0,
+          alarmCount: 0,
+          completedCount: 0
+        }
+      };
+    }
+    const allTasks = await tasksStorage.listTasks({ limit: 20 });
+    const runningTasks = allTasks.filter((t) => t.status === "running");
+    const completedTasks = allTasks.filter((t) => t.status !== "running");
+    const alarms2 = await tasksStorage.listAlarms();
+    const lines = [];
+    if (runningTasks.length > 0) {
+      lines.push("**Running Tasks:**");
+      for (const task of runningTasks) {
+        lines.push(formatTask(task));
+      }
+    }
+    if (alarms2.length > 0) {
+      if (lines.length > 0)
+        lines.push("");
+      lines.push("**Scheduled Alarms:**");
+      for (const alarm of alarms2) {
+        lines.push(formatAlarm(alarm));
+      }
+    }
+    if (includeCompleted && completedTasks.length > 0) {
+      if (lines.length > 0)
+        lines.push("");
+      lines.push("**Recent Completed/Failed:**");
+      for (const task of completedTasks.slice(0, 10)) {
+        lines.push(formatTask(task));
+      }
+    }
+    if (lines.length === 0) {
+      return {
+        output: "No background tasks or alarms.",
+        title: "No tasks",
+        metadata: {
+          runningCount: 0,
+          alarmCount: 0,
+          completedCount: 0
+        }
+      };
+    }
+    return {
+      output: lines.join(`
+`),
+      title: `${runningTasks.length} running, ${alarms2.length} alarms`,
+      metadata: {
+        runningCount: runningTasks.length,
+        alarmCount: alarms2.length,
+        completedCount: completedTasks.length
+      }
+    };
+  }
+});
+// src/tool/set-alarm.ts
+function parseDelay(delay2) {
+  const match = delay2.match(/^(\d+(?:\.\d+)?)\s*(s|sec|second|seconds|m|min|minute|minutes|h|hr|hour|hours)$/i);
+  if (!match)
+    return null;
+  const value = parseFloat(match[1]);
+  const unit = match[2].toLowerCase();
+  switch (unit) {
+    case "s":
+    case "sec":
+    case "second":
+    case "seconds":
+      return value * 1000;
+    case "m":
+    case "min":
+    case "minute":
+    case "minutes":
+      return value * 60 * 1000;
+    case "h":
+    case "hr":
+    case "hour":
+    case "hours":
+      return value * 60 * 60 * 1000;
+    default:
+      return null;
+  }
+}
+var DESCRIPTION6 = `Schedule a future reminder (alarm).
+
+When the alarm fires, you'll receive a message with your note.
+Use this to:
+- Check back on something later ("check if deploy succeeded")
+- Set a reminder for a task
+- Schedule periodic check-ins
+
+Examples:
+- set_alarm({ delay: "5m", note: "check deployment status" })
+- set_alarm({ delay: "1h", note: "follow up on PR review" })
+- set_alarm({ delay: "30s", note: "verify test results" })`;
+var parameters7 = exports_external.object({
+  delay: exports_external.string().describe('How long until the alarm fires (e.g., "5m", "1h", "30s")'),
+  note: exports_external.string().describe("The reminder message you'll receive when the alarm fires")
+});
+var SetAlarmTool = Tool.define("set_alarm", {
+  description: DESCRIPTION6,
+  parameters: parameters7,
+  async execute({ delay: delay2, note }, ctx) {
+    const tasksStorage = ctx.extra?.tasks;
+    if (!tasksStorage) {
+      return {
+        output: "Error: Tasks storage not available",
+        title: "Set alarm failed",
+        metadata: {
+          alarmId: "",
+          firesAt: "",
+          delayMs: 0
+        }
+      };
+    }
+    const delayMs = parseDelay(delay2);
+    if (delayMs === null) {
+      return {
+        output: `Invalid delay format: "${delay2}". Use formats like "5m", "1h", "30s".`,
+        title: "Invalid delay",
+        metadata: {
+          alarmId: "",
+          firesAt: "",
+          delayMs: 0
+        }
+      };
+    }
+    const firesAt = new Date(Date.now() + delayMs).toISOString();
+    const alarmId = await tasksStorage.createAlarm({
+      firesAt,
+      note
+    });
+    const displayDelay = delayMs >= 3600000 ? `${Math.round(delayMs / 3600000 * 10) / 10}h` : delayMs >= 60000 ? `${Math.round(delayMs / 60000)}m` : `${Math.round(delayMs / 1000)}s`;
+    return {
+      output: `\u23F0 Alarm set for ${displayDelay} from now.
+Note: "${note}"
+Fires at: ${firesAt}`,
+      title: `Alarm in ${displayDelay}`,
+      metadata: {
+        alarmId,
+        firesAt,
+        delayMs
+      }
+    };
+  }
+});
+// src/tool/background-research.ts
+var log9 = Log.create({ service: "background-research" });
+var DESCRIPTION7 = `Start a research task in the background.
+
+This spawns a research sub-agent that runs asynchronously while you continue working.
+When the research completes, you'll receive the results automatically.
+
+Use this when:
+- You want to research something without blocking your current work
+- The research might take a while and you have other things to do
+- You want to parallelize multiple research tasks
+
+The research agent can:
+- Search and update your long-term knowledge base
+- Search the web and fetch documentation
+- Search your conversation history
+- Read files in the codebase
+
+Example: background_research({ topic: "How does Stripe's payment intent API work?" })`;
+var parameters8 = exports_external.object({
+  topic: exports_external.string().describe("The topic to research. Be specific about what you want to learn.")
+});
+var BackgroundResearchTool = Tool.define("background_research", {
+  description: DESCRIPTION7,
+  parameters: parameters8,
+  async execute({ topic }, ctx) {
+    const storage = ctx.extra?.storage;
+    if (!storage) {
+      return {
+        output: "Error: Storage not available for background research",
+        title: "Background research failed",
+        metadata: {
+          taskId: "",
+          topic
+        }
+      };
+    }
+    const MAX_CONCURRENT_TASKS = 3;
+    const runningTasks = await storage.tasks.listTasks({ status: "running" });
+    if (runningTasks.length >= MAX_CONCURRENT_TASKS) {
+      return {
+        output: `Too many background tasks running (${runningTasks.length}/${MAX_CONCURRENT_TASKS}). Wait for some to complete or cancel them with cancel_task.`,
+        title: "Too many tasks",
+        metadata: {
+          taskId: "",
+          topic
+        }
+      };
+    }
+    const taskId = await storage.tasks.createTask({
+      type: "research",
+      description: topic.slice(0, 100) + (topic.length > 100 ? "..." : "")
+    });
+    log9.info("spawning background research", {
+      taskId,
+      topic: topic.slice(0, 50)
+    });
+    runBackgroundResearch(storage, taskId, topic).catch((error2) => {
+      log9.error("background research failed", { taskId, error: error2 });
+    });
+    return {
+      output: `\uD83D\uDD2C Research started in background.
+Task ID: ${taskId}
+Topic: "${topic}"
+
+You'll receive the results when the research completes. Use list_tasks to check status.`,
+      title: `Research started: ${topic.slice(0, 30)}...`,
+      metadata: {
+        taskId,
+        topic
+      }
+    };
+  }
+});
+async function runBackgroundResearch(storage, taskId, topic) {
+  try {
+    const result = await runResearch(storage, topic);
+    const entriesCreated = result.entriesCreated.length;
+    const entriesUpdated = result.entriesUpdated.length;
+    const report = [
+      `## Research Complete: ${topic}`,
+      "",
+      result.report,
+      "",
+      `---`,
+      `*Research used ${result.turnsUsed} turns, ${result.usage.inputTokens} input / ${result.usage.outputTokens} output tokens*`,
+      entriesCreated > 0 ? `*Created ${entriesCreated} LTM entries: ${result.entriesCreated.join(", ")}*` : "",
+      entriesUpdated > 0 ? `*Updated ${entriesUpdated} LTM entries: ${result.entriesUpdated.join(", ")}*` : ""
+    ].filter(Boolean).join(`
+`);
+    await storage.tasks.completeTask(taskId, {
+      report: result.report,
+      entriesCreated: result.entriesCreated,
+      entriesUpdated: result.entriesUpdated,
+      turnsUsed: result.turnsUsed,
+      usage: result.usage
+    });
+    await storage.tasks.queueResult(taskId, report);
+    log9.info("background research completed", {
+      taskId,
+      turnsUsed: result.turnsUsed,
+      entriesCreated,
+      entriesUpdated
+    });
+  } catch (error2) {
+    const errorMsg = error2 instanceof Error ? error2.message : String(error2);
+    await storage.tasks.failTask(taskId, errorMsg);
+    await storage.tasks.queueResult(taskId, `## Research Failed: ${topic}
+
+Error: ${errorMsg}`);
+    log9.error("background research failed", { taskId, error: errorMsg });
+  }
+}
+// src/tool/background-reflect.ts
+var log10 = Log.create({ service: "background-reflect" });
+var DESCRIPTION8 = `Start a reflection task in the background.
+
+This spawns a reflection sub-agent that runs asynchronously while you continue working.
+When the reflection completes, you'll receive the answer automatically.
+
+Use this when:
+- You want to search your memory without blocking your current work
+- The question might require extensive searching
+- You want to parallelize multiple reflection tasks
+
+The reflection agent can:
+- Search your conversation history with full-text search
+- Retrieve specific messages with surrounding context
+- Search and read your long-term knowledge base
+
+Example: background_reflect({ question: "What did we decide about the API authentication approach?" })`;
+var parameters9 = exports_external.object({
+  question: exports_external.string().describe("The question to answer or research task to complete. Be specific about what you're looking for.")
+});
+var BackgroundReflectTool = Tool.define("background_reflect", {
+  description: DESCRIPTION8,
+  parameters: parameters9,
+  async execute({ question }, ctx) {
+    const storage = ctx.extra?.storage;
+    if (!storage) {
+      return {
+        output: "Error: Storage not available for background reflection",
+        title: "Background reflection failed",
+        metadata: {
+          taskId: "",
+          question
+        }
+      };
+    }
+    const MAX_CONCURRENT_TASKS = 3;
+    const runningTasks = await storage.tasks.listTasks({ status: "running" });
+    if (runningTasks.length >= MAX_CONCURRENT_TASKS) {
+      return {
+        output: `Too many background tasks running (${runningTasks.length}/${MAX_CONCURRENT_TASKS}). Wait for some to complete or cancel them with cancel_task.`,
+        title: "Too many tasks",
+        metadata: {
+          taskId: "",
+          question
+        }
+      };
+    }
+    const taskId = await storage.tasks.createTask({
+      type: "reflect",
+      description: question.slice(0, 100) + (question.length > 100 ? "..." : "")
+    });
+    log10.info("spawning background reflection", {
+      taskId,
+      question: question.slice(0, 50)
+    });
+    runBackgroundReflection(storage, taskId, question).catch((error2) => {
+      log10.error("background reflection failed", { taskId, error: error2 });
+    });
+    return {
+      output: `\uD83D\uDD0D Reflection started in background.
+Task ID: ${taskId}
+Question: "${question}"
+
+You'll receive the answer when the reflection completes. Use list_tasks to check status.`,
+      title: `Reflection started: ${question.slice(0, 30)}...`,
+      metadata: {
+        taskId,
+        question
+      }
+    };
+  }
+});
+async function runBackgroundReflection(storage, taskId, question) {
+  try {
+    const result = await runReflection(storage, question);
+    const report = [
+      `## Reflection Complete: ${question}`,
+      "",
+      result.answer,
+      "",
+      `---`,
+      `*Reflection used ${result.turnsUsed} turns, ${result.usage.inputTokens} input / ${result.usage.outputTokens} output tokens*`
+    ].join(`
+`);
+    await storage.tasks.completeTask(taskId, {
+      answer: result.answer,
+      turnsUsed: result.turnsUsed,
+      usage: result.usage
+    });
+    await storage.tasks.queueResult(taskId, report);
+    log10.info("background reflection completed", {
+      taskId,
+      turnsUsed: result.turnsUsed
+    });
+  } catch (error2) {
+    const errorMsg = error2 instanceof Error ? error2.message : String(error2);
+    await storage.tasks.failTask(taskId, errorMsg);
+    await storage.tasks.queueResult(taskId, `## Reflection Failed: ${question}
+
+Error: ${errorMsg}`);
+    log10.error("background reflection failed", { taskId, error: errorMsg });
+  }
+}
+// src/tool/cancel-task.ts
+var DESCRIPTION9 = `Cancel a running background task.
+
+Note: This marks the task as cancelled, but cannot stop work already in progress.
+The task may still complete, but its results will be discarded.
+
+Use list_tasks to see running tasks and their IDs.`;
+var parameters10 = exports_external.object({
+  taskId: exports_external.string().describe("The task ID to cancel (from list_tasks)")
+});
+var CancelTaskTool = Tool.define("cancel_task", {
+  description: DESCRIPTION9,
+  parameters: parameters10,
+  async execute({ taskId }, ctx) {
+    const tasksStorage = ctx.extra?.tasks;
+    if (!tasksStorage) {
+      return {
+        output: "Error: Tasks storage not available",
+        title: "Cancel task failed",
+        metadata: {
+          taskId,
+          success: false
+        }
+      };
+    }
+    const task = await tasksStorage.getTask(taskId);
+    if (!task) {
+      return {
+        output: `Task not found: ${taskId}`,
+        title: "Task not found",
+        metadata: {
+          taskId,
+          success: false
+        }
+      };
+    }
+    if (task.status !== "running") {
+      return {
+        output: `Task ${taskId} is not running (status: ${task.status})`,
+        title: "Cannot cancel",
+        metadata: {
+          taskId,
+          success: false
+        }
+      };
+    }
+    await tasksStorage.failTask(taskId, "Cancelled by user");
+    return {
+      output: `Task ${taskId} marked as cancelled.
+Note: The task may still complete in the background, but results will be discarded.`,
+      title: "Task cancelled",
+      metadata: {
+        taskId,
+        success: true
+      }
+    };
+  }
+});
 // src/ltm/tools.ts
 var AGENT_TYPE2 = "ltm-consolidate";
 function buildConsolidationTools(storage) {
@@ -45134,7 +46185,10 @@ function buildConsolidationTools(storage) {
     parameters: LTMReadTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
       const toolResult = await LTMReadTool.definition.execute(args, createLTMContext2(toolCallId));
-      const result = { output: toolResult.output, done: false };
+      const result = {
+        output: toolResult.output,
+        done: false
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -45144,7 +46198,10 @@ function buildConsolidationTools(storage) {
     parameters: LTMGlobTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
       const toolResult = await LTMGlobTool.definition.execute(args, createLTMContext2(toolCallId));
-      const result = { output: toolResult.output, done: false };
+      const result = {
+        output: toolResult.output,
+        done: false
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -45156,7 +46213,10 @@ function buildConsolidationTools(storage) {
       const toolResult = await LTMSearchTool.definition.execute(args, createLTMContext2(toolCallId));
       const matchCount = (toolResult.output.match(/^- \*\*/gm) || []).length;
       activity.ltmCurator.searchResult("ltm_search", matchCount, args.query);
-      const result = { output: toolResult.output, done: false };
+      const result = {
+        output: toolResult.output,
+        done: false
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -45281,7 +46341,10 @@ function buildConsolidationTools(storage) {
     parameters: ReadTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
       const toolResult = await ReadTool.definition.execute(args, createBaseContext(toolCallId));
-      const result = { output: toolResult.output, done: false };
+      const result = {
+        output: toolResult.output,
+        done: false
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -45291,7 +46354,10 @@ function buildConsolidationTools(storage) {
     parameters: GlobTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
       const toolResult = await GlobTool.definition.execute(args, createBaseContext(toolCallId));
-      const result = { output: toolResult.output, done: false };
+      const result = {
+        output: toolResult.output,
+        done: false
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -45301,7 +46367,10 @@ function buildConsolidationTools(storage) {
     parameters: GrepTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
       const toolResult = await GrepTool.definition.execute(args, createBaseContext(toolCallId));
-      const result = { output: toolResult.output, done: false };
+      const result = {
+        output: toolResult.output,
+        done: false
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -45311,7 +46380,10 @@ function buildConsolidationTools(storage) {
     parameters: WebSearchTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
       const toolResult = await WebSearchTool.definition.execute(args, createBaseContext(toolCallId));
-      const result = { output: toolResult.output, done: false };
+      const result = {
+        output: toolResult.output,
+        done: false
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -45321,7 +46393,10 @@ function buildConsolidationTools(storage) {
     parameters: WebFetchTool.definition.parameters,
     execute: async (args, { toolCallId }) => {
       const toolResult = await WebFetchTool.definition.execute(args, createBaseContext(toolCallId));
-      const result = { output: toolResult.output, done: false };
+      const result = {
+        output: toolResult.output,
+        done: false
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -45332,7 +46407,11 @@ function buildConsolidationTools(storage) {
       summary: exports_external.string().describe("A note to your future self: what did you capture and why does it matter? Reference entries with [[slug]] syntax. Example: 'Captured the bloom filter insights in [[bloom-filter-overview]]. Archived X system workarounds since it's decommissioned.'")
     }),
     execute: async ({ summary }, { toolCallId }) => {
-      const result = { output: "Curation complete", done: true, summary };
+      const result = {
+        output: "Curation complete",
+        done: true,
+        summary
+      };
       results.set(toolCallId, result);
       return result.output;
     }
@@ -45344,7 +46423,7 @@ function buildConsolidationTools(storage) {
 }
 
 // src/ltm/consolidation.ts
-var log9 = Log.create({ service: "consolidation-agent" });
+var log11 = Log.create({ service: "consolidation-agent" });
 var MAX_CONSOLIDATION_TURNS = 20;
 function isConversationNoteworthy(messages) {
   if (messages.length < 5) {
@@ -45499,14 +46578,14 @@ async function runConsolidation(storage, messages) {
     usage: { inputTokens: 0, outputTokens: 0 }
   };
   if (!isConversationNoteworthy(messages)) {
-    log9.info("skipping consolidation - conversation not noteworthy", {
+    log11.info("skipping consolidation - conversation not noteworthy", {
       messageCount: messages.length
     });
     result.summary = "Skipped - conversation not noteworthy";
     return result;
   }
   result.ran = true;
-  log9.info("starting consolidation", { messageCount: messages.length });
+  log11.info("starting consolidation", { messageCount: messages.length });
   const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
   const allEntries = await storage.ltm.glob("/**");
   const recentlyUpdated = allEntries.filter((e) => e.updatedAt > oneHourAgo && e.slug !== "identity" && e.slug !== "behavior");
@@ -45554,7 +46633,7 @@ async function runConsolidation(storage, messages) {
   if (!result.summary) {
     result.summary = "Consolidation ended without explicit finish";
   }
-  log9.info("consolidation complete", {
+  log11.info("consolidation complete", {
     entriesCreated: result.entriesCreated,
     entriesUpdated: result.entriesUpdated,
     entriesArchived: result.entriesArchived,
@@ -45673,13 +46752,13 @@ async function runDistillation(storage, threshold, target, force) {
 }
 
 // src/agent/index.ts
-var log10 = Log.create({ service: "agent" });
+var log12 = Log.create({ service: "agent" });
 var MAX_TURNS = 200;
 async function surfaceBackgroundReports(storage) {
   const reports = await storage.background.getUnsurfaced();
   if (reports.length === 0)
     return;
-  log10.info("surfacing background reports", { count: reports.length });
+  log12.info("surfacing background reports", { count: reports.length });
   for (const report of reports) {
     const toolCallId = Identifier.ascending("toolcall");
     await storage.temporal.appendMessage({
@@ -45849,6 +46928,16 @@ function createToolContextFactory(storage, sessionId, messageId, abortSignal) {
         storage
       };
       return ctx;
+    },
+    createListTasksContext(callId) {
+      const ctx = Tool.createContext({
+        ...baseContext,
+        callID: callId
+      });
+      ctx.extra = {
+        tasks: storage.tasks
+      };
+      return ctx;
     }
   };
 }
@@ -45961,15 +47050,30 @@ function buildTools(storage, sessionId, messageId, abortSignal) {
     parameters: LTMReadTool.definition.parameters,
     execute: async (args, { toolCallId }) => safeExecute("ltm_read", () => LTMReadTool.definition.execute(args, factory.createLTMContext(toolCallId)))
   });
-  tools.reflect = tool({
-    description: ReflectTool.definition.description,
-    parameters: ReflectTool.definition.parameters,
-    execute: async (args, { toolCallId }) => safeExecute("reflect", () => ReflectTool.definition.execute(args, factory.createReflectContext(toolCallId)))
+  tools.list_tasks = tool({
+    description: ListTasksTool.definition.description,
+    parameters: ListTasksTool.definition.parameters,
+    execute: async (args, { toolCallId }) => safeExecute("list_tasks", () => ListTasksTool.definition.execute(args, factory.createListTasksContext(toolCallId)))
+  });
+  tools.set_alarm = tool({
+    description: SetAlarmTool.definition.description,
+    parameters: SetAlarmTool.definition.parameters,
+    execute: async (args, { toolCallId }) => safeExecute("set_alarm", () => SetAlarmTool.definition.execute(args, factory.createListTasksContext(toolCallId)))
   });
-  tools.research = tool({
-    description: ResearchTool.definition.description,
-    parameters: ResearchTool.definition.parameters,
-    execute: async (args, { toolCallId }) => safeExecute("research", () => ResearchTool.definition.execute(args, factory.createResearchContext(toolCallId)))
+  tools.background_research = tool({
+    description: BackgroundResearchTool.definition.description,
+    parameters: BackgroundResearchTool.definition.parameters,
+    execute: async (args, { toolCallId }) => safeExecute("background_research", () => BackgroundResearchTool.definition.execute(args, factory.createResearchContext(toolCallId)))
+  });
+  tools.background_reflect = tool({
+    description: BackgroundReflectTool.definition.description,
+    parameters: BackgroundReflectTool.definition.parameters,
+    execute: async (args, { toolCallId }) => safeExecute("background_reflect", () => BackgroundReflectTool.definition.execute(args, factory.createReflectContext(toolCallId)))
+  });
+  tools.cancel_task = tool({
+    description: CancelTaskTool.definition.description,
+    parameters: CancelTaskTool.definition.parameters,
+    execute: async (args, { toolCallId }) => safeExecute("cancel_task", () => CancelTaskTool.definition.execute(args, factory.createListTasksContext(toolCallId)))
   });
   return tools;
 }
@@ -45979,14 +47083,14 @@ async function initializeMcp() {
     if (didInitialize) {
       const status = Mcp.getStatus();
       if (status.length > 0) {
-        log10.info("MCP servers connected", {
+        log12.info("MCP servers connected", {
           servers: status.map((s) => `${s.name} (${s.toolCount} tools)`)
         });
       }
     }
     return didInitialize;
   } catch (error2) {
-    log10.error("Failed to initialize MCP", { error: error2 });
+    log12.error("Failed to initialize MCP", { error: error2 });
     return false;
   }
 }
@@ -46000,11 +47104,14 @@ async function runAgent(prompt, options) {
   const hardLimit = config2.tokenBudgets.compactionHardLimit;
   const tokensBefore = await getEffectiveViewTokens(storage.temporal);
   if (tokensBefore > hardLimit) {
-    log10.error("context overflow - refusing turn", { tokens: tokensBefore, hardLimit });
-    throw new Error(`Context overflow: ${tokensBefore} tokens exceeds hard limit of ${hardLimit}. ` + `Run 'miriad-code --compact' to reduce context size before continuing.`);
+    log12.error("context overflow - refusing turn", {
+      tokens: tokensBefore,
+      hardLimit
+    });
+    throw new Error(`Context overflow: ${tokensBefore} tokens exceeds hard limit of ${hardLimit}. ` + `Run 'nuum --compact' to reduce context size before continuing.`);
   }
   if (tokensBefore > softLimit) {
-    log10.warn("approaching token limit, running compaction before turn", {
+    log12.warn("approaching token limit, running compaction before turn", {
       tokens: tokensBefore,
       softLimit,
       target: config2.tokenBudgets.compactionTarget
@@ -46012,13 +47119,16 @@ async function runAgent(prompt, options) {
     await runMemoryCuration(storage, { force: true });
     const tokensAfter = await getEffectiveViewTokens(storage.temporal);
     if (tokensAfter > softLimit) {
-      log10.warn("compaction didn't reduce tokens below soft limit", {
+      log12.warn("compaction didn't reduce tokens below soft limit", {
         before: tokensBefore,
         after: tokensAfter,
         softLimit
       });
     } else {
-      log10.info("pre-turn compaction successful", { before: tokensBefore, after: tokensAfter });
+      log12.info("pre-turn compaction successful", {
+        before: tokensBefore,
+        after: tokensAfter
+      });
     }
   }
   const model = Provider.getModelForTier("reasoning");
@@ -46033,7 +47143,7 @@ async function runAgent(prompt, options) {
       createdAt: new Date().toISOString()
     });
   } catch (error2) {
-    log10.error("failed to persist user message", {
+    log12.error("failed to persist user message", {
       messageId: userMessageId,
       error: error2 instanceof Error ? error2.message : String(error2)
     });
@@ -46067,7 +47177,7 @@ async function runAgent(prompt, options) {
           });
           lastLoggedText = text3;
         } catch (error2) {
-          log10.error("failed to persist assistant message", {
+          log12.error("failed to persist assistant message", {
             messageId: assistantMessageId,
             error: error2 instanceof Error ? error2.message : String(error2)
           });
@@ -46088,7 +47198,7 @@ async function runAgent(prompt, options) {
           createdAt: new Date().toISOString()
         });
       } catch (error2) {
-        log10.error("failed to persist tool call", {
+        log12.error("failed to persist tool call", {
           messageId: toolCallMsgId,
           toolName,
           toolCallId,
@@ -46117,7 +47227,7 @@ async function runAgent(prompt, options) {
           createdAt: new Date().toISOString()
         });
       } catch (error2) {
-        log10.error("failed to persist tool result", {
+        log12.error("failed to persist tool result", {
           messageId: toolResultMsgId,
           toolName,
           toolCallId,
@@ -46145,7 +47255,7 @@ async function runAgent(prompt, options) {
             createdAt: new Date().toISOString()
           });
         } catch (error2) {
-          log10.error("failed to persist injected user message", {
+          log12.error("failed to persist injected user message", {
             messageId: injectedMsgId,
             error: error2 instanceof Error ? error2.message : String(error2)
           });
@@ -46155,6 +47265,9 @@ async function runAgent(prompt, options) {
         return content;
       }
       return null;
+    },
+    onThinking: () => {
+      activity.mainAgent.thinking("processing tool results...");
     }
   });
   onEvent?.({ type: "done", content: result.finalText });
@@ -46177,7 +47290,9 @@ async function runAgent(prompt, options) {
       }
     }
   }).catch((error2) => {
-    log10.error("background memory curation failed", { error: error2 instanceof Error ? error2.message : String(error2) });
+    log12.error("background memory curation failed", {
+      error: error2 instanceof Error ? error2.message : String(error2)
+    });
   });
   return {
     response: result.finalText,
@@ -46188,11 +47303,56 @@ async function runAgent(prompt, options) {
   };
 }
 
+// src/util/colors.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+var styles = {
+  header: (s) => import_picocolors3.default.bold(import_picocolors3.default.cyan(s)),
+  subheader: (s) => import_picocolors3.default.cyan(s),
+  label: (s) => import_picocolors3.default.dim(s),
+  separator: (s) => import_picocolors3.default.dim(import_picocolors3.default.gray(s)),
+  success: (s) => import_picocolors3.default.green(s),
+  warning: (s) => import_picocolors3.default.yellow(s),
+  error: (s) => import_picocolors3.default.red(s),
+  code: (s) => import_picocolors3.default.yellowBright(s),
+  path: (s) => import_picocolors3.default.redBright(s),
+  command: (s) => import_picocolors3.default.yellow(s),
+  tool: (s) => import_picocolors3.default.whiteBright(s),
+  user: (s) => import_picocolors3.default.blue(s),
+  assistant: (s) => import_picocolors3.default.green(s),
+  timestamp: (s) => import_picocolors3.default.gray(s),
+  number: (s) => import_picocolors3.default.yellow(s),
+  arrow: (s) => import_picocolors3.default.dim(s)
+};
+function colorPercent(value, total) {
+  const pct = value / total * 100;
+  const formatted = pct.toFixed(1) + "%";
+  if (pct < 50)
+    return import_picocolors3.default.green(formatted);
+  if (pct < 80)
+    return import_picocolors3.default.yellow(formatted);
+  return import_picocolors3.default.red(formatted);
+}
+function progressBar(complete, total, width = 20) {
+  const filled = Math.round(complete / total * width);
+  const empty = width - filled;
+  return import_picocolors3.default.green("\u2588".repeat(filled)) + import_picocolors3.default.dim("\u2591".repeat(empty));
+}
+
 // src/cli/verbose.ts
-var SEPARATOR = "\u2500".repeat(70);
+var SEPARATOR_WIDTH = 70;
 function formatTimestamp2() {
   return new Date().toISOString().slice(11, 23);
 }
+function separator(title) {
+  const line = styles.separator("\u2500".repeat(SEPARATOR_WIDTH));
+  if (title) {
+    return `
+${line}
+${styles.header(title)}
+${line}`;
+  }
+  return line;
+}
 
 class VerboseOutput {
   enabled;
@@ -46207,130 +47367,153 @@ class VerboseOutput {
     }
   }
   separator(title) {
-    if (title) {
-      this.log(`
-${SEPARATOR}
-${title}
-${SEPARATOR}`);
-    } else {
-      this.log(SEPARATOR);
-    }
+    this.log(separator(title));
   }
   memoryStateBefore(stats, present) {
     this.separator("MEMORY STATE (before prompt)");
-    this.log(`Present:`);
-    this.log(`  Mission: ${present.mission ?? "(none)"}`);
-    this.log(`  Status: ${present.status ?? "(none)"}`);
+    this.log(styles.subheader(`
+Present:`));
+    this.log(`  ${styles.label("Mission:")} ${present.mission ?? import_picocolors3.default.dim("(none)")}`);
+    this.log(`  ${styles.label("Status:")} ${present.status ?? import_picocolors3.default.dim("(none)")}`);
     const completed = present.tasks.filter((t) => t.status === "completed").length;
     const total = present.tasks.length;
     if (total > 0) {
-      const bar = "\u2588".repeat(completed) + "\u2591".repeat(total - completed);
-      this.log(`  Tasks: [${completed}/${total} complete] ${bar}`);
+      const bar = progressBar(completed, total, total);
+      this.log(`  ${styles.label("Tasks:")} [${styles.number(String(completed))}/${styles.number(String(total))} complete] ${bar}`);
     } else {
-      this.log(`  Tasks: (none)`);
+      this.log(`  ${styles.label("Tasks:")} ${import_picocolors3.default.dim("(none)")}`);
     }
-    this.log(`
-Temporal:`);
-    this.log(`  Total messages: ${stats.totalMessages} (${stats.totalMessageTokens.toLocaleString()} tokens)`);
+    this.log(styles.subheader(`
+Temporal:`));
+    this.log(`  ${styles.label("Total messages:")} ${styles.number(String(stats.totalMessages))} (${styles.number(stats.totalMessageTokens.toLocaleString())} tokens)`);
     if (stats.summariesByOrder.length > 0) {
       const maxOrder = Math.max(...stats.summariesByOrder.map((s) => s.order));
-      this.log(`  Summaries: ${stats.totalSummaries} (orders 1-${maxOrder})`);
+      this.log(`  ${styles.label("Summaries:")} ${styles.number(String(stats.totalSummaries))} (orders 1-${maxOrder})`);
       for (const orderStats of stats.summariesByOrder) {
-        const coverage = orderStats.order === 1 ? orderStats.coveringMessages ? `covering ${orderStats.coveringMessages} messages` : "" : orderStats.coveringSummaries ? `covering ${orderStats.coveringSummaries} order-${orderStats.order - 1}` : "";
-        this.log(`    Order ${orderStats.order}: ${orderStats.count} summaries (${orderStats.totalTokens.toLocaleString()} tokens${coverage ? ", " + coverage : ""})`);
+        const coverage = orderStats.order === 1 ? orderStats.coveringMessages ? import_picocolors3.default.dim(`covering ${orderStats.coveringMessages} messages`) : "" : orderStats.coveringSummaries ? import_picocolors3.default.dim(`covering ${orderStats.coveringSummaries} order-${orderStats.order - 1}`) : "";
+        this.log(`    ${styles.label(`Order ${orderStats.order}:`)} ${styles.number(String(orderStats.count))} summaries (${styles.number(orderStats.totalTokens.toLocaleString())} tokens${coverage ? ", " + coverage : ""})`);
       }
     } else {
-      this.log(`  Summaries: ${stats.totalSummaries}`);
+      this.log(`  ${styles.label("Summaries:")} ${styles.number(String(stats.totalSummaries))}`);
     }
     const needsCompaction = stats.effectiveViewTokens > stats.compactionThreshold;
-    this.log(`  Effective view: ${stats.effectiveViewTokens.toLocaleString()} / ${stats.compactionThreshold.toLocaleString()} tokens${needsCompaction ? " (compaction needed)" : ""}`);
-    this.log(`
-LTM:`);
-    this.log(`  Entries: ${stats.ltmEntries}`);
-    this.log(`  /identity: ${stats.identityTokens.toLocaleString()} tokens`);
-    this.log(`  /behavior: ${stats.behaviorTokens.toLocaleString()} tokens`);
+    const viewStatus = needsCompaction ? styles.warning(" (compaction needed)") : "";
+    this.log(`  ${styles.label("Effective view:")} ${styles.number(stats.effectiveViewTokens.toLocaleString())} / ${styles.number(stats.compactionThreshold.toLocaleString())} tokens${viewStatus}`);
+    this.log(styles.subheader(`
+LTM:`));
+    this.log(`  ${styles.label("Entries:")} ${styles.number(String(stats.ltmEntries))}`);
+    this.log(`  ${styles.label("/identity:")} ${styles.number(stats.identityTokens.toLocaleString())} tokens`);
+    this.log(`  ${styles.label("/behavior:")} ${styles.number(stats.behaviorTokens.toLocaleString())} tokens`);
   }
   tokenBudget(budget) {
     this.separator("TOKEN BUDGET");
-    const pct = (n) => (n / budget.total * 100).toFixed(1);
-    this.log(`Component            Tokens    % of ${(budget.total / 1000).toFixed(0)}k`);
-    this.log("\u2500".repeat(41));
-    this.log(`System prompt       ${budget.systemPrompt.toString().padStart(7)}   ${pct(budget.systemPrompt).padStart(5)}%`);
-    this.log(`Identity/behavior   ${(budget.identity + budget.behavior).toString().padStart(7)}   ${pct(budget.identity + budget.behavior).padStart(5)}%`);
-    this.log(`Temporal summaries  ${budget.temporalSummaries.toString().padStart(7)}   ${pct(budget.temporalSummaries).padStart(5)}%`);
-    this.log(`Temporal messages   ${budget.temporalMessages.toString().padStart(7)}   ${pct(budget.temporalMessages).padStart(5)}%`);
-    this.log(`Present state       ${budget.present.toString().padStart(7)}   ${pct(budget.present).padStart(5)}%`);
-    this.log(`Tools               ${budget.tools.toString().padStart(7)}   ${pct(budget.tools).padStart(5)}%`);
-    this.log("\u2500".repeat(41));
-    this.log(`Total used          ${budget.used.toString().padStart(7)}   ${pct(budget.used).padStart(5)}%`);
-    this.log(`Available           ${budget.available.toString().padStart(7)}   ${pct(budget.available).padStart(5)}%`);
+    const pct = (n) => colorPercent(n, budget.total);
+    const totalK = (budget.total / 1000).toFixed(0);
+    this.log(`
+${styles.label("Component".padEnd(20))} ${styles.label("Tokens".padStart(7))}   ${styles.label(`% of ${totalK}k`)}`);
+    this.log(styles.separator("\u2500".repeat(41)));
+    this.log(`${"System prompt".padEnd(20)} ${styles.number(budget.systemPrompt.toString().padStart(7))}   ${pct(budget.systemPrompt).padStart(10)}`);
+    this.log(`${"Identity/behavior".padEnd(20)} ${styles.number((budget.identity + budget.behavior).toString().padStart(7))}   ${pct(budget.identity + budget.behavior).padStart(10)}`);
+    this.log(`${"Temporal summaries".padEnd(20)} ${styles.number(budget.temporalSummaries.toString().padStart(7))}   ${pct(budget.temporalSummaries).padStart(10)}`);
+    this.log(`${"Temporal messages".padEnd(20)} ${styles.number(budget.temporalMessages.toString().padStart(7))}   ${pct(budget.temporalMessages).padStart(10)}`);
+    this.log(`${"Present state".padEnd(20)} ${styles.number(budget.present.toString().padStart(7))}   ${pct(budget.present).padStart(10)}`);
+    this.log(`${"Tools".padEnd(20)} ${styles.number(budget.tools.toString().padStart(7))}   ${pct(budget.tools).padStart(10)}`);
+    this.log(styles.separator("\u2500".repeat(41)));
+    this.log(`${import_picocolors3.default.bold("Total used".padEnd(20))} ${import_picocolors3.default.bold(styles.number(budget.used.toString().padStart(7)))}   ${pct(budget.used).padStart(10)}`);
+    this.log(`${styles.success("Available".padEnd(20))} ${styles.success(budget.available.toString().padStart(7))}   ${colorPercent(budget.available, budget.total).padStart(10)}`);
   }
   executionStart() {
     this.separator("AGENT EXECUTION");
     this.events = [];
   }
   event(event) {
-    const ts = event.timestamp ?? formatTimestamp2();
+    const ts = styles.timestamp(event.timestamp ?? formatTimestamp2());
     const arrow = event.type === "user" || event.type === "tool_result" ? "\u2192" : "\u2190";
-    const typeLabel = event.type.replace("_", " ");
-    const content = event.content.length > 100 ? event.content.slice(0, 100) + "..." : event.content;
-    this.log(`[${ts}] ${arrow} ${typeLabel}: ${content}`);
-    this.events.push({ ...event, timestamp: ts });
+    const styledArrow = styles.arrow(arrow);
+    let typeLabel;
+    switch (event.type) {
+      case "user":
+        typeLabel = styles.user("user");
+        break;
+      case "assistant":
+        typeLabel = styles.assistant("assistant");
+        break;
+      case "tool_call":
+        typeLabel = styles.tool("tool call");
+        break;
+      case "tool_result":
+        typeLabel = styles.tool("tool result");
+        break;
+      case "error":
+        typeLabel = styles.error("error");
+        break;
+    }
+    const content = event.content.length > 100 ? event.content.slice(0, 100) + import_picocolors3.default.dim("...") : event.content;
+    this.log(`[${ts}] ${styledArrow} ${typeLabel}: ${content}`);
+    this.events.push({
+      ...event,
+      timestamp: event.timestamp ?? formatTimestamp2()
+    });
   }
   memoryStateAfter(stats, present, usage) {
     this.separator("MEMORY STATE (after prompt)");
-    this.log(`Present:`);
-    this.log(`  Mission: ${present.mission ?? "(none)"}`);
-    this.log(`  Status: ${present.status ?? "(none)"}`);
+    this.log(styles.subheader(`
+Present:`));
+    this.log(`  ${styles.label("Mission:")} ${present.mission ?? import_picocolors3.default.dim("(none)")}`);
+    this.log(`  ${styles.label("Status:")} ${present.status ?? import_picocolors3.default.dim("(none)")}`);
     const completed = present.tasks.filter((t) => t.status === "completed").length;
     const total = present.tasks.length;
     if (total > 0) {
-      const bar = "\u2588".repeat(completed) + "\u2591".repeat(total - completed);
-      this.log(`  Tasks: [${completed}/${total} complete] ${bar}`);
+      const bar = progressBar(completed, total, total);
+      this.log(`  ${styles.label("Tasks:")} [${styles.number(String(completed))}/${styles.number(String(total))} complete] ${bar}`);
     } else {
-      this.log(`  Tasks: (none)`);
+      this.log(`  ${styles.label("Tasks:")} ${import_picocolors3.default.dim("(none)")}`);
     }
-    this.log(`
-Temporal:`);
-    this.log(`  Total messages: ${stats.totalMessages} (${stats.totalMessageTokens.toLocaleString()} tokens)`);
+    this.log(styles.subheader(`
+Temporal:`));
+    this.log(`  ${styles.label("Total messages:")} ${styles.number(String(stats.totalMessages))} (${styles.number(stats.totalMessageTokens.toLocaleString())} tokens)`);
     if (stats.summariesByOrder.length > 0) {
       const maxOrder = Math.max(...stats.summariesByOrder.map((s) => s.order));
-      this.log(`  Summaries: ${stats.totalSummaries} (orders 1-${maxOrder})`);
+      this.log(`  ${styles.label("Summaries:")} ${styles.number(String(stats.totalSummaries))} (orders 1-${maxOrder})`);
       for (const orderStats of stats.summariesByOrder) {
-        const coverage = orderStats.order === 1 ? orderStats.coveringMessages ? `covering ${orderStats.coveringMessages} messages` : "" : orderStats.coveringSummaries ? `covering ${orderStats.coveringSummaries} order-${orderStats.order - 1}` : "";
-        this.log(`    Order ${orderStats.order}: ${orderStats.count} summaries (${orderStats.totalTokens.toLocaleString()} tokens${coverage ? ", " + coverage : ""})`);
+        const coverage = orderStats.order === 1 ? orderStats.coveringMessages ? import_picocolors3.default.dim(`covering ${orderStats.coveringMessages} messages`) : "" : orderStats.coveringSummaries ? import_picocolors3.default.dim(`covering ${orderStats.coveringSummaries} order-${orderStats.order - 1}`) : "";
+        this.log(`    ${styles.label(`Order ${orderStats.order}:`)} ${styles.number(String(orderStats.count))} summaries (${styles.number(orderStats.totalTokens.toLocaleString())} tokens${coverage ? ", " + coverage : ""})`);
       }
     } else {
-      this.log(`  Summaries: ${stats.totalSummaries}`);
+      this.log(`  ${styles.label("Summaries:")} ${styles.number(String(stats.totalSummaries))}`);
     }
     const needsCompaction = stats.effectiveViewTokens > stats.compactionThreshold;
-    this.log(`  Effective view: ${stats.effectiveViewTokens.toLocaleString()} / ${stats.compactionThreshold.toLocaleString()} tokens${needsCompaction ? " (compaction needed)" : ""}`);
+    const viewStatus = needsCompaction ? styles.warning(" (compaction needed)") : "";
+    this.log(`  ${styles.label("Effective view:")} ${styles.number(stats.effectiveViewTokens.toLocaleString())} / ${styles.number(stats.compactionThreshold.toLocaleString())} tokens${viewStatus}`);
     const inputCost = usage.inputTokens / 1e6 * 15;
     const outputCost = usage.outputTokens / 1e6 * 75;
     const totalCost = inputCost + outputCost;
-    this.log(`
-Usage: ${usage.inputTokens.toLocaleString()} input tokens, ${usage.outputTokens.toLocaleString()} output tokens`);
-    this.log(`Cost: $${totalCost.toFixed(4)} (input: $${inputCost.toFixed(4)}, output: $${outputCost.toFixed(4)})`);
+    this.log(styles.subheader(`
+Usage:`));
+    this.log(`  ${styles.label("Input:")} ${styles.number(usage.inputTokens.toLocaleString())} tokens`);
+    this.log(`  ${styles.label("Output:")} ${styles.number(usage.outputTokens.toLocaleString())} tokens`);
+    this.log(`  ${styles.label("Cost:")} ${styles.success("$" + totalCost.toFixed(4))} ${import_picocolors3.default.dim(`(input: $${inputCost.toFixed(4)}, output: $${outputCost.toFixed(4)})`)}`);
   }
   error(message, error2) {
     this.log(`
-[ERROR] ${message}`);
+${styles.error("[ERROR]")} ${message}`);
     if (error2?.stack) {
-      this.log(error2.stack);
+      this.log(import_picocolors3.default.dim(error2.stack));
     }
   }
   compaction(result) {
     this.separator("COMPACTION");
-    this.log(`Distillations created: ${result.distillationsCreated}`);
-    this.log(`Agent turns used: ${result.turnsUsed}`);
-    const tokensCompressed = result.tokensBefore - result.tokensAfter;
     this.log(`
-Tokens:`);
-    this.log(`  Before: ${result.tokensBefore.toLocaleString()}`);
-    this.log(`  After: ${result.tokensAfter.toLocaleString()}`);
-    this.log(`  Compressed: ${tokensCompressed.toLocaleString()}`);
+${styles.label("Distillations created:")} ${styles.number(String(result.distillationsCreated))}`);
+    this.log(`${styles.label("Agent turns used:")} ${styles.number(String(result.turnsUsed))}`);
+    const tokensCompressed = result.tokensBefore - result.tokensAfter;
+    this.log(styles.subheader(`
+Tokens:`));
+    this.log(`  ${styles.label("Before:")} ${styles.number(result.tokensBefore.toLocaleString())}`);
+    this.log(`  ${styles.label("After:")} ${styles.number(result.tokensAfter.toLocaleString())}`);
+    this.log(`  ${styles.label("Compressed:")} ${styles.success(tokensCompressed.toLocaleString())}`);
     const ratio = tokensCompressed > 0 ? (tokensCompressed / result.tokensBefore * 100).toFixed(1) : "0.0";
-    this.log(`  Compression: ${ratio}%`);
+    this.log(`  ${styles.label("Compression:")} ${styles.success(ratio + "%")}`);
   }
 }
 
@@ -46431,6 +47614,7 @@ async function runBatch(options) {
       verbose.executionStart();
     }
     const events = [];
+    resetRenderer();
     const result = await runAgent(options.prompt, {
       storage,
       verbose: options.verbose,
@@ -46464,36 +47648,29 @@ async function runBatch(options) {
           ...e.toolCallId && { toolCallId: e.toolCallId }
         }))
       };
-      console.log(JSON.stringify(output, null, 2));
+      renderRaw(JSON.stringify(output, null, 2) + `
+`);
     } else {
-      console.log(result.response);
+      render({ type: "text", text: result.response });
     }
+    renderEnd();
   } catch (error2) {
-    const err = error2;
-    if (err.message?.includes("API") || err.message?.includes("rate limit") || err.message?.includes("429")) {
-      verbose.error("API request failed", err);
-      console.error(`Error: API request failed - ${err.message}`);
-    } else if (err.message?.includes("ENOENT") || err.message?.includes("EACCES")) {
-      verbose.error("File system error", err);
-      console.error(`Error: File system error - ${err.message}`);
-    } else if (err.message?.includes("database") || err.message?.includes("SQLite")) {
-      verbose.error("Database error", err);
-      console.error(`Error: Database error - ${err.message}`);
-    } else {
-      verbose.error("Unexpected error", err);
-      console.error(`Error: ${err.message}`);
-    }
-    process.exit(1);
+    throw error2;
   }
 }
 
 // src/cli/inspect.ts
-var SEPARATOR2 = "\u2550".repeat(70);
-var SUBSEPARATOR = "\u2500".repeat(70);
+var log13 = console.log;
+var blank = () => console.log();
+var SEPARATOR = styles.separator("\u2550".repeat(70));
+var SUBSEPARATOR = styles.separator("\u2500".repeat(70));
 function estimateTokens4(text3) {
   return Math.ceil(text3.length / 4);
 }
 function fmt(n) {
+  return styles.number(n.toLocaleString());
+}
+function fmtPlain(n) {
   return n.toLocaleString();
 }
 async function buildLTMTree(storage) {
@@ -46532,12 +47709,17 @@ async function buildLTMTree(storage) {
 }
 function renderLTMTree(nodes, indent = 0) {
   const lines = [];
-  const prefix = "  ".repeat(indent);
-  for (const node of nodes) {
-    const archived = node.archived ? " [archived]" : "";
-    const title = node.title ? ` "${node.title}"` : "";
-    const tokens = node.tokens > 0 ? ` (${fmt(node.tokens)} tokens)` : "";
-    lines.push(`${prefix}/${node.slug}${title}${tokens}${archived}`);
+  for (let i = 0;i < nodes.length; i++) {
+    const node = nodes[i];
+    const isLast = i === nodes.length - 1;
+    const branch = indent === 0 ? "" : isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const childPrefix = indent === 0 ? "" : isLast ? "    " : "\u2502   ";
+    const linePrefix = import_picocolors3.default.dim("  ".repeat(Math.max(0, indent - 1)) + branch);
+    const archived = node.archived ? import_picocolors3.default.dim(" [archived]") : "";
+    const title = node.title ? import_picocolors3.default.dim(` "${node.title}"`) : "";
+    const tokens = node.tokens > 0 ? import_picocolors3.default.dim(` (${fmtPlain(node.tokens)} tokens)`) : "";
+    const path9 = styles.path("/" + node.slug);
+    lines.push(`${linePrefix}${path9}${title}${tokens}${archived}`);
     if (node.children.length > 0) {
       lines.push(renderLTMTree(node.children, indent + 1));
     }
@@ -46615,62 +47797,63 @@ async function runInspect(dbPath) {
   await initializeDefaultEntries(storage);
   const stats = await getMemoryStats2(storage);
   const ltmTree = await buildLTMTree(storage);
-  console.log();
-  console.log(SEPARATOR2);
-  console.log("LONG-TERM MEMORY TREE");
-  console.log(SEPARATOR2);
-  console.log();
+  blank();
+  log13(SEPARATOR);
+  log13(styles.header("LONG-TERM MEMORY TREE"));
+  log13(SEPARATOR);
+  blank();
   if (ltmTree.length > 0) {
-    console.log(renderLTMTree(ltmTree));
+    log13(renderLTMTree(ltmTree));
   } else {
-    console.log("(no entries)");
-  }
-  console.log();
-  console.log(`Total: ${stats.ltmActiveEntries} active, ${stats.ltmTotalEntries - stats.ltmActiveEntries} archived (${fmt(stats.ltmTotalTokens)} tokens)`);
-  console.log();
-  console.log(SEPARATOR2);
-  console.log("TEMPORAL MEMORY");
-  console.log(SEPARATOR2);
-  console.log();
-  console.log(`Messages: ${fmt(stats.totalMessages)} (${fmt(stats.totalMessageTokens)} tokens)`);
+    log13(import_picocolors3.default.dim("(no entries)"));
+  }
+  blank();
+  const archivedCount = stats.ltmTotalEntries - stats.ltmActiveEntries;
+  log13(`${styles.label("Total:")} ${fmt(stats.ltmActiveEntries)} active${archivedCount > 0 ? `, ${fmt(archivedCount)} archived` : ""} (${fmt(stats.ltmTotalTokens)} tokens)`);
+  blank();
+  log13(SEPARATOR);
+  log13(styles.header("TEMPORAL MEMORY"));
+  log13(SEPARATOR);
+  blank();
+  log13(`${styles.label("Messages:")} ${fmt(stats.totalMessages)} (${fmt(stats.totalMessageTokens)} tokens)`);
   if (stats.summariesByOrder.length > 0) {
-    console.log(`Summaries:`);
+    log13(`${styles.label("Summaries:")}`);
     for (const orderStats of stats.summariesByOrder) {
-      console.log(`  Order-${orderStats.order}: ${orderStats.count} (${fmt(orderStats.totalTokens)} tokens)`);
+      log13(`  ${import_picocolors3.default.dim(`Order-${orderStats.order}:`)} ${fmt(orderStats.count)} (${fmt(orderStats.totalTokens)} tokens)`);
     }
   } else {
-    console.log(`Summaries: none`);
+    log13(`${styles.label("Summaries:")} ${import_picocolors3.default.dim("none")}`);
   }
-  console.log();
+  blank();
   const needsCompaction = stats.viewTotalTokens > stats.compactionThreshold;
-  const compactionStatus = needsCompaction ? " (compaction needed)" : "";
-  console.log(`Effective view (what goes to agent):`);
-  console.log(`  Summaries: ${stats.viewSummaryCount} (${fmt(stats.viewSummaryTokens)} tokens)`);
-  console.log(`  Messages: ${stats.viewMessageCount} (${fmt(stats.viewMessageTokens)} tokens)`);
-  console.log(`  Total: ${fmt(stats.viewTotalTokens)} / ${fmt(stats.compactionThreshold)} threshold${compactionStatus}`);
-  console.log(`  Target: ${fmt(stats.compactionTarget)} tokens`);
-  console.log();
-  console.log(SEPARATOR2);
-  console.log("PRESENT STATE");
-  console.log(SEPARATOR2);
-  console.log();
-  console.log(`Mission: ${stats.mission ?? "(none)"}`);
-  console.log(`Status: ${stats.status ?? "(none)"}`);
+  const compactionStatus = needsCompaction ? styles.warning(" (compaction needed)") : "";
+  log13(`${styles.label("Effective view")} ${import_picocolors3.default.dim("(what goes to agent)")}:`);
+  log13(`  ${styles.label("Summaries:")} ${fmt(stats.viewSummaryCount)} (${fmt(stats.viewSummaryTokens)} tokens)`);
+  log13(`  ${styles.label("Messages:")} ${fmt(stats.viewMessageCount)} (${fmt(stats.viewMessageTokens)} tokens)`);
+  log13(`  ${styles.label("Total:")} ${fmt(stats.viewTotalTokens)} / ${fmt(stats.compactionThreshold)} threshold${compactionStatus}`);
+  log13(`  ${styles.label("Target:")} ${fmt(stats.compactionTarget)} tokens`);
+  blank();
+  log13(SEPARATOR);
+  log13(styles.header("PRESENT STATE"));
+  log13(SEPARATOR);
+  blank();
+  log13(`${styles.label("Mission:")} ${stats.mission ?? import_picocolors3.default.dim("(none)")}`);
+  log13(`${styles.label("Status:")} ${stats.status ?? import_picocolors3.default.dim("(none)")}`);
   const totalTasks = stats.tasksPending + stats.tasksInProgress + stats.tasksCompleted + stats.tasksBlocked;
   if (totalTasks > 0) {
-    console.log(`Tasks: ${totalTasks} total`);
+    log13(`${styles.label("Tasks:")} ${fmt(totalTasks)} total`);
     if (stats.tasksPending > 0)
-      console.log(`  Pending: ${stats.tasksPending}`);
+      log13(`  ${import_picocolors3.default.dim("Pending:")} ${fmt(stats.tasksPending)}`);
     if (stats.tasksInProgress > 0)
-      console.log(`  In progress: ${stats.tasksInProgress}`);
+      log13(`  ${styles.warning("In progress:")} ${fmt(stats.tasksInProgress)}`);
     if (stats.tasksCompleted > 0)
-      console.log(`  Completed: ${stats.tasksCompleted}`);
+      log13(`  ${styles.success("Completed:")} ${fmt(stats.tasksCompleted)}`);
     if (stats.tasksBlocked > 0)
-      console.log(`  Blocked: ${stats.tasksBlocked}`);
+      log13(`  ${styles.error("Blocked:")} ${fmt(stats.tasksBlocked)}`);
   } else {
-    console.log(`Tasks: none`);
+    log13(`${styles.label("Tasks:")} ${import_picocolors3.default.dim("none")}`);
   }
-  console.log();
+  blank();
 }
 function renderTurnContent(turn) {
   if (typeof turn.content === "string") {
@@ -46681,10 +47864,10 @@ function renderTurnContent(turn) {
       if (part.type === "text") {
         parts.push(part.text);
       } else if (part.type === "tool-call") {
-        parts.push(`[tool_call: ${part.toolName}(${JSON.stringify(part.args)})]`);
+        parts.push(styles.tool(`[tool_call: ${part.toolName}(${JSON.stringify(part.args)})]`));
       } else if (part.type === "tool-result") {
         const result = typeof part.result === "string" ? part.result.slice(0, 500) + (part.result.length > 500 ? "..." : "") : JSON.stringify(part.result).slice(0, 500);
-        parts.push(`[tool_result: ${part.toolName}] ${result}`);
+        parts.push(import_picocolors3.default.dim(`[tool_result: ${part.toolName}] `) + result);
       }
     }
     return parts.join(`
@@ -46718,25 +47901,26 @@ async function runDump(dbPath) {
     return sum;
   }, 0);
   const totalTokens = systemTokens + conversationTokens;
-  console.log();
-  console.log(`# Agent Prompt Dump`);
-  console.log(`# System: ~${fmt(systemTokens)} tokens | Conversation: ${conversationTurns.length} turns, ~${fmt(conversationTokens)} tokens | Total: ~${fmt(totalTokens)} tokens`);
-  console.log();
-  console.log(`=== SYSTEM ===`);
-  console.log(systemPrompt);
+  blank();
+  log13(styles.header("Agent Prompt Dump"));
+  log13(import_picocolors3.default.dim(`System: ~${fmtPlain(systemTokens)} tokens | Conversation: ${conversationTurns.length} turns, ~${fmtPlain(conversationTokens)} tokens | Total: ~${fmtPlain(totalTokens)} tokens`));
+  blank();
+  log13(styles.subheader("=== SYSTEM ==="));
+  log13(systemPrompt);
   if (conversationTurns.length > 0) {
-    console.log();
-    console.log(`=== CONVERSATION (${conversationTurns.length} turns) ===`);
+    blank();
+    log13(styles.subheader(`=== CONVERSATION (${conversationTurns.length} turns) ===`));
     for (const turn of conversationTurns) {
-      console.log();
-      console.log(`--- ${turn.role.toUpperCase()} ---`);
-      console.log(renderTurnContent(turn));
+      blank();
+      const roleColor = turn.role === "user" ? styles.user : styles.assistant;
+      log13(roleColor(`--- ${turn.role.toUpperCase()} ---`));
+      log13(renderTurnContent(turn));
     }
   } else {
-    console.log();
-    console.log(`=== CONVERSATION (empty) ===`);
+    blank();
+    log13(styles.subheader("=== CONVERSATION (empty) ==="));
   }
-  console.log();
+  blank();
 }
 async function runCompact(dbPath) {
   const storage = createStorage(dbPath);
@@ -46745,39 +47929,39 @@ async function runCompact(dbPath) {
   const threshold = config2.tokenBudgets.compactionThreshold;
   const target = config2.tokenBudgets.compactionTarget;
   const tokensBefore = await getEffectiveViewTokens(storage.temporal);
-  console.log(`Effective view: ${fmt(tokensBefore)} tokens`);
-  console.log(`Threshold: ${fmt(threshold)} tokens`);
-  console.log(`Target: ${fmt(target)} tokens`);
-  console.log();
+  log13(`${styles.label("Effective view:")} ${fmt(tokensBefore)} tokens`);
+  log13(`${styles.label("Threshold:")} ${fmt(threshold)} tokens`);
+  log13(`${styles.label("Target:")} ${fmt(target)} tokens`);
+  blank();
   if (tokensBefore <= target) {
-    console.log(`Already under target, but running anyway (forced)...`);
+    log13(import_picocolors3.default.dim(`Already under target, but running anyway (forced)...`));
   } else {
-    console.log(`Running memory curation...`);
+    log13(`Running memory curation...`);
   }
-  console.log();
+  blank();
   const result = await runMemoryCuration(storage, { force: true });
   if (!result.ran) {
-    console.log(`Curation did not run (already in progress?)`);
+    log13(styles.warning(`Curation did not run (already in progress?)`));
     return;
   }
   if (result.consolidation?.ran) {
     const c = result.consolidation;
     const changes = c.entriesCreated + c.entriesUpdated + c.entriesArchived;
-    console.log(`LTM Consolidation:`);
+    log13(styles.subheader(`LTM Consolidation:`));
     if (changes > 0) {
-      console.log(`  ${c.entriesCreated} created, ${c.entriesUpdated} updated, ${c.entriesArchived} archived`);
+      log13(`  ${styles.success(String(c.entriesCreated))} created, ${styles.number(String(c.entriesUpdated))} updated, ${import_picocolors3.default.dim(String(c.entriesArchived))} archived`);
     } else {
-      console.log(`  No changes needed`);
+      log13(import_picocolors3.default.dim(`  No changes needed`));
     }
-    console.log();
+    blank();
   }
   if (result.distillation) {
     const d = result.distillation;
-    console.log(`Distillation:`);
-    console.log(`  Distillations created: ${d.distillationsCreated}`);
-    console.log(`  Tokens: ${fmt(d.tokensBefore)} \u2192 ${fmt(d.tokensAfter)}`);
-    console.log(`  Turns used: ${d.turnsUsed}`);
-    console.log(`  LLM usage: ${fmt(d.usage.inputTokens)} input, ${fmt(d.usage.outputTokens)} output`);
+    log13(styles.subheader(`Distillation:`));
+    log13(`  ${styles.label("Distillations created:")} ${fmt(d.distillationsCreated)}`);
+    log13(`  ${styles.label("Tokens:")} ${fmt(d.tokensBefore)} ${import_picocolors3.default.dim("\u2192")} ${styles.success(fmtPlain(d.tokensAfter))}`);
+    log13(`  ${styles.label("Turns used:")} ${fmt(d.turnsUsed)}`);
+    log13(`  ${styles.label("LLM usage:")} ${fmt(d.usage.inputTokens)} input, ${fmt(d.usage.outputTokens)} output`);
   }
 }
 
@@ -46842,12 +48026,21 @@ function assistantText(text3, model, sessionId) {
 function assistantToolUse(id, name17, input, model, sessionId) {
   return {
     type: "assistant",
-    message: { role: "assistant", content: [{ type: "tool_use", id, name: name17, input }], model },
+    message: {
+      role: "assistant",
+      content: [{ type: "tool_use", id, name: name17, input }],
+      model
+    },
     session_id: sessionId
   };
 }
 function toolResult(toolUseId, content, isError = false) {
-  return { type: "tool_result", tool_use_id: toolUseId, content, is_error: isError || undefined };
+  return {
+    type: "tool_result",
+    tool_use_id: toolUseId,
+    content,
+    is_error: isError || undefined
+  };
 }
 function resultMessage(sessionId, subtype, durationMs, numTurns, options = {}) {
   return {
@@ -46858,7 +48051,10 @@ function resultMessage(sessionId, subtype, durationMs, numTurns, options = {}) {
     num_turns: numTurns,
     session_id: sessionId,
     result: options.result,
-    usage: options.inputTokens !== undefined ? { input_tokens: options.inputTokens, output_tokens: options.outputTokens ?? 0 } : undefined
+    usage: options.inputTokens !== undefined ? {
+      input_tokens: options.inputTokens,
+      output_tokens: options.outputTokens ?? 0
+    } : undefined
   };
 }
 function systemMessage(subtype, data = {}) {
@@ -46869,7 +48065,7 @@ function systemMessage(subtype, data = {}) {
 function getModelId() {
   return Config.resolveModelTier("reasoning");
 }
-var log11 = Log.create({ service: "server" });
+var log14 = Log.create({ service: "server" });
 
 class Server {
   options;
@@ -46879,33 +48075,52 @@ class Server {
   rl = null;
   processing = false;
   sessionId = "";
+  alarmInterval = null;
+  checkingAlarms = false;
+  outputHandler;
+  turnCompleteResolve = null;
   constructor(options) {
     this.options = options;
     this.storage = createStorage(options.dbPath);
+    this.outputHandler = options.outputHandler ?? ((msg) => {
+      process.stdout.write(JSON.stringify(msg) + `
+`);
+    });
   }
   async start() {
     await cleanupStaleWorkers(this.storage);
     await initializeDefaultEntries(this.storage);
+    await this.recoverKilledTasks();
     this.sessionId = await this.storage.session.getId();
     await Mcp.initialize();
     const mcpTools = Mcp.getToolNames();
-    process.on("SIGTERM", () => this.shutdown("SIGTERM"));
-    process.on("SIGINT", () => this.shutdown("SIGINT"));
-    this.rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      terminal: false
-    });
-    this.rl.on("line", (line) => {
-      this.handleLine(line).catch((error2) => {
-        log11.error("unhandled error in line handler", { error: error2 });
+    if (!this.options.noStdin) {
+      process.on("SIGTERM", () => this.shutdown("SIGTERM"));
+      process.on("SIGINT", () => this.shutdown("SIGINT"));
+      this.rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false
       });
+      this.rl.on("line", (line) => {
+        this.handleLine(line).catch((error2) => {
+          log14.error("unhandled error in line handler", { error: error2 });
+        });
+      });
+      this.rl.on("close", () => {
+        log14.info("stdin closed, shutting down");
+        this.shutdown("stdin closed");
+      });
+    }
+    this.alarmInterval = setInterval(() => {
+      this.checkAlarms().catch((error2) => {
+        log14.error("error checking alarms", { error: error2 });
+      });
+    }, 1000);
+    log14.info("server started", {
+      dbPath: this.options.dbPath,
+      sessionId: this.sessionId
     });
-    this.rl.on("close", () => {
-      log11.info("stdin closed, shutting down");
-      this.shutdown("stdin closed");
-    });
-    log11.info("server started", { dbPath: this.options.dbPath, sessionId: this.sessionId });
     this.send(systemMessage("init", {
       session_id: this.sessionId,
       model: getModelId(),
@@ -46932,9 +48147,13 @@ class Server {
     switch (request.action) {
       case "interrupt":
         if (this.currentTurn) {
-          log11.info("interrupting current turn", { sessionId: this.currentTurn.sessionId });
+          log14.info("interrupting current turn", {
+            sessionId: this.currentTurn.sessionId
+          });
           this.currentTurn.abortController.abort();
-          this.send(systemMessage("interrupted", { session_id: this.currentTurn.sessionId }));
+          this.send(systemMessage("interrupted", {
+            session_id: this.currentTurn.sessionId
+          }));
         } else {
           this.send(systemMessage("error", { message: "No turn is currently running" }));
         }
@@ -46954,8 +48173,29 @@ class Server {
         break;
     }
   }
+  async recoverKilledTasks() {
+    const killedTasks = await this.storage.tasks.recoverKilledTasks();
+    if (killedTasks.length === 0)
+      return;
+    log14.info("recovered killed tasks", { count: killedTasks.length });
+    for (const task of killedTasks) {
+      await this.storage.background.fileReport({
+        subsystem: "task_recovery",
+        report: {
+          message: `Background task was killed when agent restarted: ${task.type} - "${task.description}". You may want to restart it.`,
+          taskId: task.id,
+          type: task.type,
+          description: task.description
+        }
+      });
+    }
+  }
   async shutdown(reason) {
-    log11.info("shutting down", { reason });
+    log14.info("shutting down", { reason });
+    if (this.alarmInterval) {
+      clearInterval(this.alarmInterval);
+      this.alarmInterval = null;
+    }
     if (this.currentTurn) {
       this.currentTurn.abortController.abort();
     }
@@ -46963,10 +48203,76 @@ class Server {
     this.rl?.close();
     process.exit(0);
   }
+  interrupt() {
+    if (this.currentTurn) {
+      log14.info("interrupting current turn", {
+        sessionId: this.currentTurn.sessionId
+      });
+      this.currentTurn.abortController.abort();
+      this.send(systemMessage("interrupted", { session_id: this.currentTurn.sessionId }));
+    }
+  }
+  async sendUserMessage(prompt) {
+    const userMessage = {
+      type: "user",
+      session_id: this.sessionId,
+      message: {
+        role: "user",
+        content: prompt
+      }
+    };
+    const turnComplete = new Promise((resolve5) => {
+      this.turnCompleteResolve = resolve5;
+    });
+    await this.handleUserMessage(userMessage);
+    await turnComplete;
+  }
+  async checkAlarms() {
+    if (this.checkingAlarms)
+      return;
+    this.checkingAlarms = true;
+    try {
+      const dueAlarms = await this.storage.tasks.getDueAlarms();
+      if (dueAlarms.length > 0) {
+        log14.info("alarms fired", { count: dueAlarms.length });
+        for (const alarm of dueAlarms) {
+          await this.storage.tasks.markAlarmFired(alarm.id);
+          await this.storage.tasks.queueResult(alarm.id, `\u23F0 **Alarm fired**: ${alarm.note}`);
+        }
+      }
+      const hasResults = await this.storage.tasks.hasQueuedResults();
+      if (hasResults && !this.currentTurn && !this.processing) {
+        await this.triggerSelfTurn();
+      }
+    } finally {
+      this.checkingAlarms = false;
+    }
+  }
+  async triggerSelfTurn() {
+    const results = await this.storage.tasks.drainQueue();
+    if (results.length === 0)
+      return;
+    log14.info("triggering self-turn", { resultCount: results.length });
+    const content = results.map((r) => r.content).join(`
+
+`);
+    const selfMessage = {
+      type: "user",
+      session_id: this.sessionId,
+      message: {
+        role: "user",
+        content: `[SYSTEM: Background events occurred]
+
+${content}`
+      }
+    };
+    await this.processTurn(selfMessage);
+    await this.processQueue();
+  }
   async handleUserMessage(userMessage) {
     if (this.currentTurn) {
       this.messageQueue.push(userMessage);
-      log11.info("queued message", {
+      log14.info("queued message", {
         sessionId: userMessage.session_id,
         queueLength: this.messageQueue.length,
         currentSession: this.currentTurn.sessionId
@@ -46992,7 +48298,7 @@ class Server {
     }
     if (userMessage.environment !== undefined) {
       setEnvironment(userMessage.environment);
-      log11.info("applied environment from message", {
+      log14.info("applied environment from message", {
         count: Object.keys(userMessage.environment).length
       });
     } else {
@@ -47005,7 +48311,7 @@ class Server {
       numTurns: 0,
       startTime: Date.now()
     };
-    log11.debug("starting turn", { sessionId, promptLength: prompt.length });
+    log14.debug("starting turn", { sessionId, promptLength: prompt.length });
     try {
       const agentOptions = {
         storage: this.storage,
@@ -47029,12 +48335,16 @@ class Server {
         return;
       }
       const message = error2 instanceof Error ? error2.message : String(error2);
-      log11.error("turn failed", { sessionId, error: message });
+      log14.error("turn failed", { sessionId, error: message });
       this.send(resultMessage(sessionId, "error", Date.now() - (this.currentTurn?.startTime ?? Date.now()), this.currentTurn?.numTurns ?? 0, {
         result: message
       }));
     } finally {
       this.currentTurn = null;
+      if (this.turnCompleteResolve) {
+        this.turnCompleteResolve();
+        this.turnCompleteResolve = null;
+      }
     }
   }
   async processQueue() {
@@ -47044,7 +48354,7 @@ class Server {
     try {
       while (this.messageQueue.length > 0 && !this.currentTurn) {
         const nextMessage = this.messageQueue.shift();
-        log11.info("processing queued message", {
+        log14.info("processing queued message", {
           sessionId: nextMessage.session_id,
           remainingInQueue: this.messageQueue.length
         });
@@ -47063,7 +48373,7 @@ class Server {
     const combined = contents.join(`
 
 `);
-    log11.info("injecting mid-turn messages", {
+    log14.info("injecting mid-turn messages", {
       messageCount: messages.length,
       combinedLength: combined.length
     });
@@ -47097,7 +48407,10 @@ class Server {
         }
         break;
       case "error":
-        this.send(systemMessage("error", { message: event.content, session_id: sessionId }));
+        this.send(systemMessage("error", {
+          message: event.content,
+          session_id: sessionId
+        }));
         break;
       case "consolidation":
         if (event.consolidationResult?.ran) {
@@ -47122,14 +48435,13 @@ class Server {
     };
     const reinitialized = await Mcp.initialize(mergedConfig);
     if (reinitialized) {
-      log11.info("MCP reinitialized with message config", {
+      log14.info("MCP reinitialized with message config", {
         serverCount: Object.keys(mergedConfig.mcpServers ?? {}).length
       });
     }
   }
   send(message) {
-    process.stdout.write(JSON.stringify(message) + `
-`);
+    this.outputHandler(message);
   }
 }
 async function runServer(options) {
@@ -47142,24 +48454,53 @@ import * as readline2 from "readline";
 import * as fs8 from "fs";
 import * as path9 from "path";
 import * as os3 from "os";
-var PROMPT = "miriad-code> ";
-var HISTORY_FILE = path9.join(os3.homedir(), ".miriad-code-history");
+
+// src/util/markdown.ts
+function renderMarkdown(text3) {
+  text3 = text3.replace(/```(\w*)\n([\s\S]*?)```/g, (_, lang, code) => {
+    return styles.label("```" + lang) + `
+` + code.trimEnd() + `
+` + styles.label("```");
+  });
+  text3 = text3.replace(/`([^`]+)`/g, (_, code) => styles.code(code));
+  text3 = text3.replace(/\*\*([^*]+)\*\*/g, (_, content) => import_picocolors3.default.bold(content));
+  text3 = text3.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, content) => styles.label(content));
+  text3 = text3.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, linkText, url2) => {
+    return import_picocolors3.default.underline(linkText) + styles.label(` (${url2})`);
+  });
+  text3 = text3.replace(/^(#{1,6})\s+(.+)$/gm, (_, _hashes, content) => {
+    return styles.header(content);
+  });
+  text3 = text3.replace(/^(\s*)[-*]\s+/gm, (_, indent) => {
+    return indent + styles.label("\u2022") + " ";
+  });
+  text3 = text3.replace(/^(\s*)(\d+)\.\s+/gm, (_, indent, num) => {
+    return indent + styles.label(num + ".") + " ";
+  });
+  return text3;
+}
+
+// src/cli/repl.ts
+var PROMPT = import_picocolors3.default.cyan("nuum") + import_picocolors3.default.dim("> ");
+var HISTORY_FILE = path9.join(os3.homedir(), ".nuum-history");
 var MAX_HISTORY = 1000;
 
 class ReplSession {
   options;
-  storage;
+  server;
   rl = null;
-  abortController = null;
-  isRunning = false;
   history = [];
+  isRunning = false;
   constructor(options) {
     this.options = options;
-    this.storage = createStorage(options.dbPath);
+    this.server = new Server({
+      dbPath: options.dbPath,
+      outputHandler: (message) => this.handleServerOutput(message),
+      noStdin: true
+    });
   }
   async start() {
-    await cleanupStaleWorkers(this.storage);
-    await initializeDefaultEntries(this.storage);
+    await this.server.start();
     this.loadHistory();
     this.rl = readline2.createInterface({
       input: process.stdin,
@@ -47171,28 +48512,35 @@ class ReplSession {
     for (const line of this.history) {
       this.rl.history?.unshift(line);
     }
+    setReplContext(this.rl, PROMPT);
     this.rl.on("SIGINT", () => {
-      if (this.isRunning && this.abortController) {
-        this.abortController.abort();
-        process.stdout.write(`
-^C - Request cancelled
+      if (this.isRunning) {
+        this.server.interrupt();
+        renderRaw(`
+`);
+        renderRaw(styles.warning("^C - Request cancelled") + `
 `);
       } else {
-        process.stdout.write(`
-(Use /quit or Ctrl+D to exit)
+        renderRaw(`
+`);
+        renderRaw(import_picocolors3.default.dim("(Use /quit or Ctrl+D to exit)") + `
 `);
         this.rl?.prompt();
       }
     });
     this.rl.on("close", () => {
+      clearReplContext();
       this.saveHistory();
-      console.log(`
-Goodbye!`);
-      process.exit(0);
+      renderRaw(`
+`);
+      renderRaw(import_picocolors3.default.dim("Goodbye!") + `
+`);
+      this.server.shutdown("user exit");
     });
     this.rl.on("line", (line) => {
       this.handleLine(line).catch((error2) => {
-        console.error(`Error: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        renderRaw(styles.error(`Error: ${error2 instanceof Error ? error2.message : String(error2)}`) + `
+`);
         this.rl?.prompt();
       });
     });
@@ -47200,10 +48548,14 @@ Goodbye!`);
     this.rl.prompt();
   }
   printWelcome() {
-    console.log();
-    console.log("miriad-code interactive mode");
-    console.log("Type /help for commands, /quit to exit");
-    console.log();
+    renderRaw(`
+`);
+    renderRaw(import_picocolors3.default.bold(import_picocolors3.default.cyan("nuum")) + " " + import_picocolors3.default.dim("interactive mode") + `
+`);
+    renderRaw(import_picocolors3.default.dim("Type /help for commands, /quit to exit") + `
+`);
+    renderRaw(`
+`);
   }
   async handleLine(line) {
     const trimmed = line.trim();
@@ -47225,15 +48577,18 @@ Goodbye!`);
       case "quit":
       case "exit":
       case "q":
+        clearReplContext();
         this.saveHistory();
-        console.log("Goodbye!");
-        process.exit(0);
+        renderRaw(import_picocolors3.default.dim("Goodbye!") + `
+`);
+        this.server.shutdown("user exit");
         break;
       case "inspect":
         try {
           await runInspect(this.options.dbPath);
         } catch (error2) {
-          console.error(`Error: ${error2 instanceof Error ? error2.message : String(error2)}`);
+          renderRaw(styles.error(`Error: ${error2 instanceof Error ? error2.message : String(error2)}`) + `
+`);
         }
         this.rl?.prompt();
         break;
@@ -47241,7 +48596,8 @@ Goodbye!`);
         try {
           await runDump(this.options.dbPath);
         } catch (error2) {
-          console.error(`Error: ${error2 instanceof Error ? error2.message : String(error2)}`);
+          renderRaw(styles.error(`Error: ${error2 instanceof Error ? error2.message : String(error2)}`) + `
+`);
         }
         this.rl?.prompt();
         break;
@@ -47252,129 +48608,106 @@ Goodbye!`);
         this.rl?.prompt();
         break;
       default:
-        console.log(`Unknown command: /${command}`);
-        console.log("Type /help for available commands.");
+        renderRaw(styles.warning(`Unknown command: /${command}`) + `
+`);
+        renderRaw(import_picocolors3.default.dim("Type /help for available commands.") + `
+`);
         this.rl?.prompt();
     }
   }
   printHelp() {
-    console.log();
-    console.log("Commands:");
-    console.log("  /help, /h, /?    Show this help");
-    console.log("  /quit, /exit, /q Exit the REPL");
-    console.log("  /inspect         Show memory statistics");
-    console.log("  /dump            Show full system prompt");
-    console.log();
-    console.log("Shortcuts:");
-    console.log("  Ctrl+C           Cancel current request");
-    console.log("  Ctrl+D           Exit");
-    console.log("  Up/Down arrows   Navigate history");
-    console.log("  Ctrl+R           Reverse history search");
-    console.log();
+    renderRaw(`
+`);
+    renderRaw(styles.header("Commands") + `
+`);
+    renderRaw(`  ${import_picocolors3.default.cyan("/help")}, ${import_picocolors3.default.cyan("/h")}, ${import_picocolors3.default.cyan("/?")}    ${import_picocolors3.default.dim("Show this help")}
+`);
+    renderRaw(`  ${import_picocolors3.default.cyan("/quit")}, ${import_picocolors3.default.cyan("/exit")}, ${import_picocolors3.default.cyan("/q")} ${import_picocolors3.default.dim("Exit the REPL")}
+`);
+    renderRaw(`  ${import_picocolors3.default.cyan("/inspect")}         ${import_picocolors3.default.dim("Show memory statistics")}
+`);
+    renderRaw(`  ${import_picocolors3.default.cyan("/dump")}            ${import_picocolors3.default.dim("Show full system prompt")}
+`);
+    renderRaw(`
+`);
+    renderRaw(styles.header("Shortcuts") + `
+`);
+    renderRaw(`  ${import_picocolors3.default.yellow("Ctrl+C")}           ${import_picocolors3.default.dim("Cancel current request")}
+`);
+    renderRaw(`  ${import_picocolors3.default.yellow("Ctrl+D")}           ${import_picocolors3.default.dim("Exit")}
+`);
+    renderRaw(`  ${import_picocolors3.default.yellow("Up/Down arrows")}   ${import_picocolors3.default.dim("Navigate history")}
+`);
+    renderRaw(`  ${import_picocolors3.default.yellow("Ctrl+R")}           ${import_picocolors3.default.dim("Reverse history search")}
+`);
+    renderRaw(`
+`);
   }
   async runPrompt(prompt) {
     this.isRunning = true;
-    this.abortController = new AbortController;
-    let hasOutput = false;
-    const agentOptions = {
-      storage: this.storage,
-      verbose: false,
-      abortSignal: this.abortController.signal,
-      onEvent: (event) => this.handleAgentEvent(event, () => {
-        hasOutput = true;
-      })
-    };
+    setReplRunning(true);
+    resetRenderer();
+    resetRenderer();
     try {
-      await runAgent(prompt, agentOptions);
-      if (hasOutput) {
-        console.log();
-      }
-    } catch (error2) {
-      if (error2 instanceof AgentLoopCancelledError) {} else {
-        console.error(`
-Error: ${error2 instanceof Error ? error2.message : String(error2)}`);
-      }
+      renderRaw(`
+`);
+      await this.server.sendUserMessage(prompt);
     } finally {
       this.isRunning = false;
-      this.abortController = null;
-      console.log();
+      setReplRunning(false);
+      renderEnd();
       this.rl?.prompt();
     }
   }
-  handleAgentEvent(event, markOutput) {
-    switch (event.type) {
-      case "assistant":
-        process.stdout.write(event.content);
-        markOutput();
-        break;
-      case "tool_call":
-        if (event.toolName) {
-          const displayName = this.formatToolName(event.toolName);
-          const args = this.formatToolArgs(event.content);
-          process.stdout.write(`
-[${displayName}${args}...]
-`);
-          markOutput();
+  handleServerOutput(message) {
+    const msg = message;
+    const type = msg.type;
+    switch (type) {
+      case "assistant": {
+        const assistantMsg = msg.message;
+        if (assistantMsg?.content) {
+          for (const block of assistantMsg.content) {
+            if (block.type === "text" && block.text) {
+              render({ type: "text", text: renderMarkdown(block.text) });
+            }
+          }
         }
         break;
-      case "tool_result":
-        break;
-      case "error":
-        process.stdout.write(`
-[Error: ${event.content}]
-`);
-        markOutput();
-        break;
-      case "consolidation":
-        if (event.consolidationResult?.ran) {
-          const r = event.consolidationResult;
-          const changes = r.entriesCreated + r.entriesUpdated + r.entriesArchived;
-          if (changes > 0) {
-            process.stdout.write(`
-[LTM updated: ${changes} change(s)]
-`);
+      }
+      case "system": {
+        const subtype = msg.subtype;
+        switch (subtype) {
+          case "init":
+          case "tool_result":
+          case "interrupted":
+            break;
+          case "error":
+            render({
+              type: "info",
+              worker: "server",
+              level: "error",
+              message: msg.message || "Unknown error"
+            });
+            break;
+          case "consolidation": {
+            const changes = (msg.entries_created ?? 0) + (msg.entries_updated ?? 0) + (msg.entries_archived ?? 0);
+            if (changes > 0) {
+              render({
+                type: "lifecycle",
+                worker: "ltm-curator",
+                action: "complete",
+                message: `LTM updated: ${changes} change(s)`
+              });
+            }
+            break;
           }
         }
-        markOutput();
         break;
-      case "compaction":
-        process.stdout.write(`
-[Memory compacted]
-`);
-        markOutput();
+      }
+      case "result": {
         break;
-    }
-  }
-  formatToolName(name17) {
-    const displayNames = {
-      bash: "Running command",
-      read: "Reading",
-      write: "Writing",
-      edit: "Editing",
-      glob: "Searching files",
-      grep: "Searching content",
-      present_set_mission: "Setting mission",
-      present_set_status: "Setting status",
-      present_update_tasks: "Updating tasks"
-    };
-    return displayNames[name17] || name17;
-  }
-  formatToolArgs(content) {
-    try {
-      const match = content.match(/\((\{.+?\})\.\.\.\)$/);
-      if (match) {
-        const args = JSON.parse(match[1] + "}");
-        if (args.path)
-          return ` ${args.path}`;
-        if (args.file)
-          return ` ${args.file}`;
-        if (args.pattern)
-          return ` ${args.pattern}`;
-        if (args.command)
-          return ` ${args.command.slice(0, 50)}${args.command.length > 50 ? "..." : ""}`;
       }
-    } catch {}
-    return "";
+    }
   }
   loadHistory() {
     try {
@@ -47408,9 +48741,155 @@ async function runRepl(options) {
 }
 
 // src/version.ts
-var VERSION = "0.2.2";
-var GIT_HASH = "0764a52";
-var VERSION_STRING = `miriad-code v${VERSION} (${GIT_HASH})`;
+var VERSION = "0.4.0";
+var GIT_HASH = "ae44f42";
+var VERSION_STRING = `nuum v${VERSION} (${GIT_HASH})`;
+
+// src/cli/error.ts
+function categorizeError(error2) {
+  if (!(error2 instanceof Error)) {
+    return {
+      title: "Unknown Error",
+      message: String(error2)
+    };
+  }
+  const msg = error2.message;
+  if (msg.includes("rate limit") || msg.includes("429") || msg.includes("Too Many Requests")) {
+    return {
+      title: "Rate Limited",
+      message: "API rate limit exceeded",
+      hint: "Wait a moment and try again, or check your API usage limits."
+    };
+  }
+  if (msg.includes("ANTHROPIC_API_KEY") && msg.includes("required")) {
+    return {
+      title: "Missing API Key",
+      message: "ANTHROPIC_API_KEY environment variable is not set",
+      hint: "Set it with: export ANTHROPIC_API_KEY=sk-ant-..."
+    };
+  }
+  if (msg.includes("401") || msg.includes("Unauthorized") || msg.includes("invalid x-api-key") || msg.includes("invalid_api_key") || /invalid.*api.*key/i.test(msg)) {
+    return {
+      title: "Authentication Failed",
+      message: "Invalid or missing API key",
+      hint: "Set ANTHROPIC_API_KEY environment variable with a valid key."
+    };
+  }
+  if (msg.includes("API") || msg.includes("fetch") || msg.includes("ECONNREFUSED") || msg.includes("ETIMEDOUT")) {
+    return {
+      title: "API Error",
+      message: msg,
+      hint: "Check your internet connection and try again."
+    };
+  }
+  if (msg.includes("ENOENT")) {
+    const match = msg.match(/ENOENT.*'([^']+)'/);
+    const path10 = match?.[1] ?? "unknown";
+    return {
+      title: "File Not Found",
+      message: `Cannot find: ${path10}`,
+      hint: "Check that the file or directory exists."
+    };
+  }
+  if (msg.includes("EACCES") || msg.includes("EPERM")) {
+    return {
+      title: "Permission Denied",
+      message: msg,
+      hint: "Check file permissions or try running with appropriate access."
+    };
+  }
+  if (msg.includes("EROFS")) {
+    return {
+      title: "Read-Only File System",
+      message: msg,
+      hint: "Cannot write to this location. Try a different path."
+    };
+  }
+  if (msg.includes("database") || msg.includes("SQLite") || msg.includes("SQLITE")) {
+    return {
+      title: "Database Error",
+      message: msg,
+      hint: "Try removing the database file and starting fresh, or check disk space."
+    };
+  }
+  if (msg.includes("context") && msg.includes("overflow")) {
+    return {
+      title: "Context Overflow",
+      message: "Conversation history is too large",
+      hint: "Run 'nuum --compact' to reduce context size."
+    };
+  }
+  if (msg.includes("MCP") || msg.includes("mcp")) {
+    return {
+      title: "MCP Error",
+      message: msg,
+      hint: "Check your MCP server configuration in ~/.nuum/mcp.json"
+    };
+  }
+  return {
+    title: "Error",
+    message: msg,
+    details: error2.stack
+  };
+}
+function printError(error2, options) {
+  const info = categorizeError(error2);
+  const boxWidth = 60;
+  const topBorder = import_picocolors3.default.red("\u256D" + "\u2500".repeat(boxWidth - 2) + "\u256E");
+  const bottomBorder = import_picocolors3.default.red("\u2570" + "\u2500".repeat(boxWidth - 2) + "\u256F");
+  const write = (text3) => renderRawStderr(text3 + `
+`);
+  write("");
+  write(topBorder);
+  write(import_picocolors3.default.red("\u2502") + " " + import_picocolors3.default.bold(import_picocolors3.default.red(info.title.padEnd(boxWidth - 4))) + " " + import_picocolors3.default.red("\u2502"));
+  write(import_picocolors3.default.red("\u2502") + " ".repeat(boxWidth - 2) + import_picocolors3.default.red("\u2502"));
+  const messageLines = wrapText(info.message, boxWidth - 4);
+  for (const line of messageLines) {
+    write(import_picocolors3.default.red("\u2502") + " " + line.padEnd(boxWidth - 4) + " " + import_picocolors3.default.red("\u2502"));
+  }
+  if (info.hint) {
+    write(import_picocolors3.default.red("\u2502") + " ".repeat(boxWidth - 2) + import_picocolors3.default.red("\u2502"));
+    const hintLines = wrapText(info.hint, boxWidth - 4);
+    for (const line of hintLines) {
+      write(import_picocolors3.default.red("\u2502") + " " + import_picocolors3.default.dim(line.padEnd(boxWidth - 4)) + " " + import_picocolors3.default.red("\u2502"));
+    }
+  }
+  write(bottomBorder);
+  write("");
+  if (options?.verbose && info.details) {
+    write(import_picocolors3.default.dim("Stack trace:"));
+    write(import_picocolors3.default.dim(info.details));
+    write("");
+  }
+}
+function wrapText(text3, maxWidth) {
+  const normalized = text3.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+  const words = normalized.split(" ");
+  const lines = [];
+  let currentLine = "";
+  for (const word of words) {
+    if (currentLine.length + word.length + 1 <= maxWidth) {
+      currentLine += (currentLine ? " " : "") + word;
+    } else {
+      if (currentLine)
+        lines.push(currentLine);
+      currentLine = word;
+    }
+  }
+  if (currentLine)
+    lines.push(currentLine);
+  return lines.length > 0 ? lines : [""];
+}
+function printSimpleError(message, hint) {
+  const write = (text3) => renderRawStderr(text3 + `
+`);
+  write("");
+  write(`${import_picocolors3.default.red("\u2717")} ${import_picocolors3.default.bold("Error:")} ${message}`);
+  if (hint) {
+    write(`  ${import_picocolors3.default.dim(hint)}`);
+  }
+  write("");
+}
 
 // src/cli/index.ts
 function parseCliArgs() {
@@ -47451,14 +48930,14 @@ ${VERSION_STRING}
 A coding agent with persistent memory
 
 Usage:
-  miriad-code -p "prompt"           Run agent with a prompt
-  miriad-code -p "prompt" --verbose Show debug output
-  miriad-code --repl                Start interactive REPL mode
-  miriad-code --stdio               Start protocol server over stdin/stdout
-  miriad-code --inspect             Show memory stats (no LLM call)
-  miriad-code --dump                Show raw system prompt (no LLM call)
-  miriad-code --compact             Force run compaction (distillation)
-  miriad-code --help                Show this help
+  nuum -p "prompt"           Run agent with a prompt
+  nuum -p "prompt" --verbose Show debug output
+  nuum --repl                Start interactive REPL mode
+  nuum --stdio               Start protocol server over stdin/stdout
+  nuum --inspect             Show memory stats (no LLM call)
+  nuum --dump                Show raw system prompt (no LLM call)
+  nuum --compact             Force run compaction (distillation)
+  nuum --help                Show this help
 
 Options:
   -p, --prompt <text>   The prompt to send to the agent
@@ -47495,35 +48974,35 @@ JSON-RPC Mode (--stdio):
   Methods: run, cancel, status
 
 Examples:
-  miriad-code -p "What files are in src/"
-  miriad-code -p "Refactor the auth module" --verbose
-  miriad-code --repl
-  miriad-code --repl --db ./project.db
-  miriad-code -p "List todos" --format=json
-  miriad-code --inspect --db ./my-agent.db
-  miriad-code --dump
-  miriad-code --stdio --db ./agent.db
+  nuum -p "What files are in src/"
+  nuum -p "Refactor the auth module" --verbose
+  nuum --repl
+  nuum --repl --db ./project.db
+  nuum -p "List todos" --format=json
+  nuum --inspect --db ./my-agent.db
+  nuum --dump
+  nuum --stdio --db ./agent.db
 `);
 }
 async function main() {
   const options = parseCliArgs();
+  if (options.verbose) {
+    Log.setLevel("DEBUG");
+  }
   if (options.help) {
     printHelp();
     process.exit(0);
   }
   if (options.version) {
-    console.log(VERSION_STRING);
+    renderRaw(VERSION_STRING + `
+`);
     process.exit(0);
   }
   if (options.repl) {
     try {
       await runRepl({ dbPath: options.db });
     } catch (error2) {
-      if (error2 instanceof Error) {
-        console.error(`Error: ${error2.message}`);
-      } else {
-        console.error("Unknown error:", error2);
-      }
+      printError(error2, { verbose: options.verbose });
       process.exit(1);
     }
     return;
@@ -47532,11 +49011,7 @@ async function main() {
     try {
       await runServer({ dbPath: options.db });
     } catch (error2) {
-      if (error2 instanceof Error) {
-        console.error(`Error: ${error2.message}`);
-      } else {
-        console.error("Unknown error:", error2);
-      }
+      printError(error2, { verbose: options.verbose });
       process.exit(1);
     }
     return;
@@ -47546,11 +49021,7 @@ async function main() {
       await runInspect(options.db);
       process.exit(0);
     } catch (error2) {
-      if (error2 instanceof Error) {
-        console.error(`Error: ${error2.message}`);
-      } else {
-        console.error("Unknown error:", error2);
-      }
+      printError(error2, { verbose: options.verbose });
       process.exit(1);
     }
   }
@@ -47559,11 +49030,7 @@ async function main() {
       await runDump(options.db);
       process.exit(0);
     } catch (error2) {
-      if (error2 instanceof Error) {
-        console.error(`Error: ${error2.message}`);
-      } else {
-        console.error("Unknown error:", error2);
-      }
+      printError(error2, { verbose: options.verbose });
       process.exit(1);
     }
   }
@@ -47572,17 +49039,12 @@ async function main() {
       await runCompact(options.db);
       process.exit(0);
     } catch (error2) {
-      if (error2 instanceof Error) {
-        console.error(`Error: ${error2.message}`);
-      } else {
-        console.error("Unknown error:", error2);
-      }
+      printError(error2, { verbose: options.verbose });
       process.exit(1);
     }
   }
   if (!options.prompt) {
-    console.error("Error: --prompt (-p) is required (or use --repl/--stdio/--inspect/--dump)");
-    console.error("Run with --help for usage information");
+    printSimpleError("--prompt (-p) is required (or use --repl/--stdio/--inspect/--dump)", "Run with --help for usage information");
     process.exit(1);
   }
   try {
@@ -47593,14 +49055,7 @@ async function main() {
       format: options.format
     });
   } catch (error2) {
-    if (error2 instanceof Error) {
-      console.error(`Error: ${error2.message}`);
-      if (options.verbose && error2.stack) {
-        console.error(error2.stack);
-      }
-    } else {
-      console.error("Unknown error:", error2);
-    }
+    printError(error2, { verbose: options.verbose });
     process.exit(1);
   }
 }