@sanity-labs/nuum 0.2.2 → 0.3.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) => {
@@ -17401,7 +17401,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 +18578,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)}`;
 };
@@ -18704,6 +18710,34 @@ var backgroundReports = sqliteTable("background_reports", {
 }, (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";
@@ -23468,6 +23502,9 @@ var Identifier;
     entry: "ent",
     worker: "wrk",
     report: "rpt",
+    bgtask: "bgt",
+    queue: "que",
+    alarm: "alm",
     session: "ses",
     toolcall: "tcl"
   };
@@ -23612,6 +23649,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 +23821,7 @@ function createStorageFromDb(db) {
     workers: createWorkerStorage(db),
     session: createSessionStorage(db),
     background: createBackgroundStorage(db),
+    tasks: createTasksStorage(db),
     _db: db
   };
 }
@@ -45105,6 +45296,488 @@ 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) {
@@ -45344,7 +46017,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 +46172,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 +46227,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 +46346,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 +46522,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 +46644,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.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.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_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 +46677,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 +46698,11 @@ 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 });
+    log12.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.`);
   }
   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 +46710,13 @@ 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 +46731,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 +46765,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 +46786,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 +46815,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 +46843,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)
           });
@@ -46177,7 +46875,7 @@ 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,
@@ -46869,7 +47567,7 @@ function systemMessage(subtype, data = {}) {
 function getModelId() {
   return Config.resolveModelTier("reasoning");
 }
-var log11 = Log.create({ service: "server" });
+var log13 = Log.create({ service: "server" });
 
 class Server {
   options;
@@ -46879,33 +47577,49 @@ 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("close", () => {
-      log11.info("stdin closed, shutting down");
-      this.shutdown("stdin closed");
-    });
-    log11.info("server started", { dbPath: this.options.dbPath, sessionId: this.sessionId });
+      this.rl.on("line", (line) => {
+        this.handleLine(line).catch((error2) => {
+          log13.error("unhandled error in line handler", { error: error2 });
+        });
+      });
+      this.rl.on("close", () => {
+        log13.info("stdin closed, shutting down");
+        this.shutdown("stdin closed");
+      });
+    }
+    this.alarmInterval = setInterval(() => {
+      this.checkAlarms().catch((error2) => {
+        log13.error("error checking alarms", { error: error2 });
+      });
+    }, 1000);
+    log13.info("server started", { dbPath: this.options.dbPath, sessionId: this.sessionId });
     this.send(systemMessage("init", {
       session_id: this.sessionId,
       model: getModelId(),
@@ -46932,7 +47646,7 @@ class Server {
     switch (request.action) {
       case "interrupt":
         if (this.currentTurn) {
-          log11.info("interrupting current turn", { sessionId: this.currentTurn.sessionId });
+          log13.info("interrupting current turn", { sessionId: this.currentTurn.sessionId });
           this.currentTurn.abortController.abort();
           this.send(systemMessage("interrupted", { session_id: this.currentTurn.sessionId }));
         } else {
@@ -46954,8 +47668,29 @@ class Server {
         break;
     }
   }
+  async recoverKilledTasks() {
+    const killedTasks = await this.storage.tasks.recoverKilledTasks();
+    if (killedTasks.length === 0)
+      return;
+    log13.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 });
+    log13.info("shutting down", { reason });
+    if (this.alarmInterval) {
+      clearInterval(this.alarmInterval);
+      this.alarmInterval = null;
+    }
     if (this.currentTurn) {
       this.currentTurn.abortController.abort();
     }
@@ -46963,10 +47698,74 @@ class Server {
     this.rl?.close();
     process.exit(0);
   }
+  interrupt() {
+    if (this.currentTurn) {
+      log13.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) {
+        log13.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;
+    log13.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", {
+      log13.info("queued message", {
         sessionId: userMessage.session_id,
         queueLength: this.messageQueue.length,
         currentSession: this.currentTurn.sessionId
@@ -46992,7 +47791,7 @@ class Server {
     }
     if (userMessage.environment !== undefined) {
       setEnvironment(userMessage.environment);
-      log11.info("applied environment from message", {
+      log13.info("applied environment from message", {
         count: Object.keys(userMessage.environment).length
       });
     } else {
@@ -47005,7 +47804,7 @@ class Server {
       numTurns: 0,
       startTime: Date.now()
     };
-    log11.debug("starting turn", { sessionId, promptLength: prompt.length });
+    log13.debug("starting turn", { sessionId, promptLength: prompt.length });
     try {
       const agentOptions = {
         storage: this.storage,
@@ -47029,12 +47828,16 @@ class Server {
         return;
       }
       const message = error2 instanceof Error ? error2.message : String(error2);
-      log11.error("turn failed", { sessionId, error: message });
+      log13.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 +47847,7 @@ class Server {
     try {
       while (this.messageQueue.length > 0 && !this.currentTurn) {
         const nextMessage = this.messageQueue.shift();
-        log11.info("processing queued message", {
+        log13.info("processing queued message", {
           sessionId: nextMessage.session_id,
           remainingInQueue: this.messageQueue.length
         });
@@ -47063,7 +47866,7 @@ class Server {
     const combined = contents.join(`
 
 `);
-    log11.info("injecting mid-turn messages", {
+    log13.info("injecting mid-turn messages", {
       messageCount: messages.length,
       combinedLength: combined.length
     });
@@ -47122,14 +47925,13 @@ class Server {
     };
     const reinitialized = await Mcp.initialize(mergedConfig);
     if (reinitialized) {
-      log11.info("MCP reinitialized with message config", {
+      log13.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) {
@@ -47148,18 +47950,20 @@ 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,
@@ -47172,8 +47976,8 @@ class ReplSession {
       this.rl.history?.unshift(line);
     }
     this.rl.on("SIGINT", () => {
-      if (this.isRunning && this.abortController) {
-        this.abortController.abort();
+      if (this.isRunning) {
+        this.server.interrupt();
         process.stdout.write(`
 ^C - Request cancelled
 `);
@@ -47188,7 +47992,7 @@ class ReplSession {
       this.saveHistory();
       console.log(`
 Goodbye!`);
-      process.exit(0);
+      this.server.shutdown("user exit");
     });
     this.rl.on("line", (line) => {
       this.handleLine(line).catch((error2) => {
@@ -47227,7 +48031,7 @@ Goodbye!`);
       case "q":
         this.saveHistory();
         console.log("Goodbye!");
-        process.exit(0);
+        this.server.shutdown("user exit");
         break;
       case "inspect":
         try {
@@ -47274,75 +48078,64 @@ Goodbye!`);
   }
   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;
-      })
-    };
     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)}`);
-      }
+      await this.server.sendUserMessage(prompt);
     } finally {
       this.isRunning = false;
-      this.abortController = null;
       console.log();
       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(`
+  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) {
+              process.stdout.write(block.text);
+            } else if (block.type === "tool_use" && block.name) {
+              const displayName = this.formatToolName(block.name);
+              const args = this.formatToolArgs(block.input);
+              process.stdout.write(`
 [${displayName}${args}...]
 `);
-          markOutput();
+            }
+          }
         }
         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) {
+      }
+      case "system": {
+        const subtype = msg.subtype;
+        switch (subtype) {
+          case "init":
+            break;
+          case "tool_result":
+            break;
+          case "error":
             process.stdout.write(`
+[Error: ${msg.message}]
+`);
+            break;
+          case "consolidation": {
+            const changes = (msg.entries_created ?? 0) + (msg.entries_updated ?? 0) + (msg.entries_archived ?? 0);
+            if (changes > 0) {
+              process.stdout.write(`
 [LTM updated: ${changes} change(s)]
 `);
+            }
+            break;
           }
+          case "interrupted":
+            break;
         }
-        markOutput();
         break;
-      case "compaction":
-        process.stdout.write(`
-[Memory compacted]
-`);
-        markOutput();
+      }
+      case "result": {
         break;
+      }
     }
   }
   formatToolName(name17) {
@@ -47355,25 +48148,35 @@ Error: ${error2 instanceof Error ? error2.message : String(error2)}`);
       grep: "Searching content",
       present_set_mission: "Setting mission",
       present_set_status: "Setting status",
-      present_update_tasks: "Updating tasks"
+      present_update_tasks: "Updating tasks",
+      set_alarm: "Setting alarm",
+      list_tasks: "Listing tasks",
+      background_research: "Starting research",
+      background_reflect: "Starting reflection",
+      cancel_task: "Cancelling task"
     };
     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 {}
+  formatToolArgs(input) {
+    if (!input || typeof input !== "object")
+      return "";
+    const args = input;
+    if (args.path)
+      return ` ${args.path}`;
+    if (args.filePath)
+      return ` ${args.filePath}`;
+    if (args.pattern)
+      return ` ${args.pattern}`;
+    if (args.command) {
+      const cmd = String(args.command);
+      return ` ${cmd.slice(0, 50)}${cmd.length > 50 ? "..." : ""}`;
+    }
+    if (args.delay)
+      return ` ${args.delay}`;
+    if (args.topic)
+      return ` "${String(args.topic).slice(0, 40)}..."`;
+    if (args.question)
+      return ` "${String(args.question).slice(0, 40)}..."`;
     return "";
   }
   loadHistory() {
@@ -47408,8 +48211,8 @@ async function runRepl(options) {
 }
 
 // src/version.ts
-var VERSION = "0.2.2";
-var GIT_HASH = "0764a52";
+var VERSION = "0.3.0";
+var GIT_HASH = "18005cc";
 var VERSION_STRING = `miriad-code v${VERSION} (${GIT_HASH})`;
 
 // src/cli/index.ts