niahere 0.2.32 → 0.2.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.32",
+  "version": "0.2.34",
   "description": "A personal AI assistant daemon — scheduled jobs, chat across Telegram and Slack, persona system, and visual identity.",
   "type": "module",
   "scripts": {

package/src/chat/engine.ts

@@ -8,6 +8,7 @@ import { randomUUID } from "crypto";
 import { buildSystemPrompt } from "./identity";
 import { Session, Message, ActiveEngine } from "../db/models";
 import type { Attachment, SendResult, StreamCallback, ActivityCallback, SendCallbacks, ChatEngine, EngineOptions } from "../types";
+import { truncate, formatToolUse } from "../utils/format-activity";
 
 const IDLE_TIMEOUT = 10 * 60 * 1000; // 10 minutes
 
@@ -97,101 +98,6 @@ interface PendingResult {
   reject: (error: Error) => void;
 }
 
-function truncate(s: string, max: number): string {
-  const oneline = s.replace(/\n/g, " ").trim();
-  return oneline.length > max ? oneline.slice(0, max) + "…" : oneline;
-}
-
-function formatToolUse(tool: string, input: any): string {
-  if (!input || typeof input !== "object") return tool.toLowerCase();
-
-  switch (tool) {
-    // File operations
-    case "Bash":
-      return input.description
-        ? truncate(input.description, 60)
-        : input.command ? `$ ${truncate(input.command, 55)}` : "running command";
-    case "Read":
-      return input.file_path ? `reading ${basename(input.file_path)}` : "reading file";
-    case "Edit":
-      return input.file_path ? `editing ${basename(input.file_path)}` : "editing file";
-    case "Write":
-      return input.file_path ? `writing ${basename(input.file_path)}` : "writing file";
-    case "NotebookEdit":
-      return input.file_path ? `editing notebook ${basename(input.file_path)}` : "editing notebook";
-
-    // Search operations
-    case "Grep":
-      return input.pattern ? `searching for "${truncate(input.pattern, 35)}"` : "searching code";
-    case "Glob":
-      return input.pattern ? `finding ${truncate(input.pattern, 40)}` : "finding files";
-    case "ToolSearch":
-      return input.query ? `looking up tool: ${truncate(input.query, 40)}` : "searching tools";
-
-    // Agent & task operations
-    case "Agent":
-      return input.description ? `⟩ ${truncate(input.description, 55)}` : "running agent";
-    case "Task":
-      return input.description || input.prompt?.slice(0, 50) || "running task";
-    case "TaskCreate":
-      return input.description ? `starting: ${truncate(input.description, 45)}` : "creating task";
-    case "TaskGet":
-    case "TaskOutput":
-      return "checking task progress";
-    case "TaskList":
-      return "listing tasks";
-    case "TaskStop":
-      return "stopping task";
-    case "TaskUpdate":
-      return "updating task";
-    case "SendMessage":
-      return input.to ? `messaging ${truncate(String(input.to), 30)}` : "sending message";
-
-    // Web operations
-    case "WebFetch":
-      return input.url ? `fetching ${truncate(input.url, 50)}` : "fetching url";
-    case "WebSearch":
-      return input.query ? `web search: ${truncate(input.query, 40)}` : "searching the web";
-
-    // Planning & workflow
-    case "EnterPlanMode":
-      return "entering plan mode";
-    case "ExitPlanMode":
-      return "exiting plan mode";
-    case "EnterWorktree":
-      return "creating worktree";
-    case "ExitWorktree":
-      return "leaving worktree";
-
-    // Skill & todo
-    case "Skill":
-      return input.skill ? `using /${truncate(input.skill, 40)}` : "invoking skill";
-    case "TodoWrite":
-    case "TodoRead":
-      return tool === "TodoWrite" ? "updating checklist" : "reading checklist";
-
-    // LSP
-    case "LSP":
-      return input.command ? `lsp: ${truncate(input.command, 50)}` : "querying language server";
-
-    // MCP tools (plugin_name__tool_name pattern)
-    default: {
-      // Handle MCP tools like mcp__playwright__browser_navigate
-      if (tool.startsWith("mcp__")) {
-        const parts = tool.split("__");
-        const action = parts[parts.length - 1]?.replace(/_/g, " ") || tool;
-        const val = input.url || input.selector || input.text || input.value || "";
-        return val ? `${action}: ${truncate(String(val), 40)}` : action;
-      }
-      const val = input.description || input.command || input.pattern || input.query || input.file_path || "";
-      return val ? `${tool.toLowerCase()}: ${truncate(String(val), 50)}` : tool.toLowerCase();
-    }
-  }
-}
-
-function basename(path: string): string {
-  return path.split("/").pop() || path;
-}
 
 function sessionFileExists(sessionId: string, cwd: string): boolean {
   // SDK stores sessions at ~/.claude/projects/<encoded-cwd>/<session-id>.jsonl

package/src/cli/job.ts

@@ -4,6 +4,7 @@ import { readState, readAudit } from "../utils/logger";
 import { getConfig } from "../utils/config";
 import { runJob } from "../core/runner";
 import { localTime } from "../utils/time";
+import { formatDuration } from "../utils/format";
 import { Job } from "../db/models";
 import { withDb } from "../db/connection";
 import type { ScheduleType } from "../types";
@@ -133,6 +134,38 @@ export async function jobCommand(): Promise<void> {
       break;
     }
 
+    case "update": {
+      const always = process.argv.includes("--always");
+      let cliArgs = process.argv.slice(4).filter((a) => a !== "--always");
+
+      const name = cliArgs[0];
+      if (!name) {
+        console.log('Usage: nia job update <name> [--schedule <schedule>] [--prompt <prompt>] [--always]');
+        fail('Example: nia job update curator --schedule "4h" --prompt "New prompt"');
+      }
+
+      const scheduleIdx = cliArgs.indexOf("--schedule");
+      const schedule = scheduleIdx !== -1 ? cliArgs[scheduleIdx + 1] : undefined;
+      const promptIdx = cliArgs.indexOf("--prompt");
+      const prompt = promptIdx !== -1 ? cliArgs.slice(promptIdx + 1).filter((a) => a !== "--always" && a !== "--schedule" && a !== schedule).join(" ") : undefined;
+
+      try {
+        await withDb(async () => {
+          const fields: Partial<{ schedule: string; prompt: string; always: boolean }> = {};
+          if (schedule) fields.schedule = schedule;
+          if (prompt) fields.prompt = prompt;
+          if (always) fields.always = always;
+
+          const updated = await Job.update(name, fields);
+          if (!updated) fail(`Job not found: "${name}". Use \`nia job list\` to see available jobs.`);
+          console.log(`Job "${name}" updated.`);
+        });
+      } catch (err) {
+        fail(`Failed to update job: ${errMsg(err)}`);
+      }
+      break;
+    }
+
     case "show": {
       const name = process.argv[4] || await pickJob("Show job");
 
@@ -152,7 +185,7 @@ export async function jobCommand(): Promise<void> {
           if (info) {
             console.log(`\n  last run: ${localTime(new Date(info.lastRun))}`);
             console.log(`  status:   ${info.status}`);
-            console.log(`  duration: ${info.duration_ms}ms`);
+            console.log(`  duration: ${formatDuration(info.duration_ms)}`);
             if (info.error) console.log(`  error:    ${info.error}`);
           } else {
             console.log("\n  never run");
@@ -163,7 +196,7 @@ export async function jobCommand(): Promise<void> {
             console.log("\n  recent runs:");
             for (const e of entries) {
               const time = localTime(new Date(e.timestamp));
-              const dur = `${e.duration_ms}ms`;
+              const dur = `${formatDuration(e.duration_ms)}`;
               const icon = e.status === "ok" ? ICON_PASS : ICON_FAIL;
               const summary = e.error || e.result.slice(0, 60).replace(/\n/g, " ") || "-";
               console.log(`    ${icon} ${time}  ${dur.padStart(8)}  ${summary}`);
@@ -187,7 +220,7 @@ export async function jobCommand(): Promise<void> {
           const state = readState();
           const info = state[job.name];
           const status = info
-            ? `${info.status} (${localTime(new Date(info.lastRun))}, ${info.duration_ms}ms)`
+            ? `${info.status} (${localTime(new Date(info.lastRun))}, ${formatDuration(info.duration_ms)})`
             : "never run";
           const tag = job.always ? " always" : "";
           console.log(`  ${job.enabled ? "●" : "○"} ${job.name}  [${job.schedule}]${tag}  ${status}`);
@@ -211,10 +244,40 @@ export async function jobCommand(): Promise<void> {
       if (!found) fail(`Job not found: ${name}`);
       const job = found as { name: string; schedule: string; prompt: string };
 
-      console.log(`Running job: ${job.name} (model: ${getConfig().model})`);
-      const result = await runJob(job);
-      console.log(`\nStatus: ${result.status}`);
-      console.log(`Duration: ${result.duration_ms}ms`);
+      console.log(`Running job: ${job.name} (model: ${getConfig().model})\n`);
+
+      const MAX_LOG_LINES = 15;
+      const logLines: string[] = [];
+      let linesRendered = 0;
+
+      function renderActivity(line: string) {
+        logLines.push(line);
+        if (logLines.length > MAX_LOG_LINES) logLines.shift();
+
+        // Clear previously rendered lines
+        if (linesRendered > 0) {
+          process.stdout.write(`\x1b[${linesRendered}A\x1b[J`);
+        }
+
+        // Render current log lines
+        const output = logLines.map((l, i) => {
+          const dim = i < logLines.length - 1;
+          return dim ? `  \x1b[2m${l}\x1b[0m` : `  \x1b[36m▸\x1b[0m ${l}`;
+        }).join("\n");
+
+        process.stdout.write(output + "\n");
+        linesRendered = logLines.length;
+      }
+
+      const result = await runJob(job, renderActivity);
+
+      // Clear the activity log and show final result
+      if (linesRendered > 0) {
+        process.stdout.write(`\x1b[${linesRendered}A\x1b[J`);
+      }
+
+      console.log(`Status: ${result.status}`);
+      console.log(`Duration: ${formatDuration(result.duration_ms)}`);
       if (result.result) console.log(`\nResult:\n${result.result}`);
       if (result.error) console.log(`\nError: ${result.error}`);
       break;
@@ -229,7 +292,7 @@ export async function jobCommand(): Promise<void> {
       }
       for (const e of entries) {
         const time = localTime(new Date(e.timestamp));
-        const dur = `${e.duration_ms}ms`;
+        const dur = `${formatDuration(e.duration_ms)}`;
         const status = e.status === "ok" ? ICON_PASS : ICON_FAIL;
         const summary = e.error || e.result.slice(0, 80).replace(/\n/g, " ") || "-";
         console.log(`  ${status} ${time}  ${dur.padStart(8)}  ${e.job}  ${summary}`);
@@ -238,12 +301,13 @@ export async function jobCommand(): Promise<void> {
     }
 
     default:
-      console.log("Usage: nia job <list|show|status|add|remove|enable|disable|run|log|import>\n");
+      console.log("Usage: nia job <list|show|status|add|update|remove|enable|disable|run|log|import>\n");
       console.log("  list                          — list all jobs");
       console.log("  show [name]                   — full job details + recent runs");
       console.log("  status [name]                 — quick status check");
       console.log("  add <name> <schedule> <prompt> — add a job (active hours only)")
       console.log("      --always                  — run 24/7 regardless of active hours");
+      console.log("  update <name> [--schedule s] [--prompt p] [--always] — update a job");
       console.log("  remove <name>                 — delete a job");
       console.log("  enable <name>                 — enable a job");
       console.log("  disable <name>                — disable a job");

package/src/cli/status.ts

@@ -9,6 +9,7 @@ import { withDb } from "../db/connection";
 import { errMsg } from "../utils/errors";
 import { checkForUpdate } from "../utils/update";
 import { ICON_PASS, ICON_FAIL, ICON_RUNNING } from "../utils/cli";
+import { formatDuration } from "../utils/format";
 
 type StatusOptions = {
   json: boolean;
@@ -247,7 +248,7 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
           !stateInfo;
 
         const statusIcon = status === "ok" ? ICON_PASS : status === "error" ? ICON_FAIL : status === "running" ? ICON_RUNNING : "\u2217";
-        const durationText = stateInfo?.duration_ms === undefined ? "n/a" : `${stateInfo.duration_ms}ms`;
+        const durationText = stateInfo?.duration_ms === undefined ? "n/a" : formatDuration(stateInfo.duration_ms);
         const nextText = nextRun ? formatTimeLine(nextRun, now) : "unknown";
         const lastText = lastRun ? formatTimeLine(lastRun, now) : "never";
         const staleText = stale ? "  ⚠ stale" : "";
@@ -294,7 +295,7 @@ export async function statusCommand(argv: string[] = []): Promise<void> {
       for (const [name, info] of fallbackEntries) {
         const last = formatTimeLine(info.lastRun, now);
         const icon = info.status === "ok" ? ICON_PASS : info.status === "error" ? ICON_FAIL : "\u2217";
-        console.log(`  ${icon} ${name}: ${info.status} (last: ${last}, ${info.duration_ms}ms)`);
+        console.log(`  ${icon} ${name}: ${info.status} (last: ${last}, ${formatDuration(info.duration_ms)})`);
       }
     } else if (dbError) {
       console.log(`\nJobs: database unavailable (${errMsg(dbError)})`);

package/src/core/runner.ts

@@ -7,6 +7,9 @@ import { appendAudit, readState, writeState } from "../utils/logger";
 import type { AuditEntry, JobState } from "../types";
 import { getConfig } from "../utils/config";
 import { buildSystemPrompt } from "../chat/identity";
+import { truncate, formatToolUse } from "../utils/format-activity";
+
+export type ActivityCallback = (line: string) => void;
 
 interface RunnerOutput {
   agentText: string;
@@ -65,7 +68,12 @@ async function runJobWithCodex(fullPrompt: string, cwd: string, model: string):
 // Claude Agent SDK runner
 // ---------------------------------------------------------------------------
 
-export async function runJobWithClaude(systemPrompt: string, jobPrompt: string, cwd: string): Promise<RunnerOutput> {
+export async function runJobWithClaude(
+  systemPrompt: string,
+  jobPrompt: string,
+  cwd: string,
+  onActivity?: ActivityCallback,
+): Promise<RunnerOutput> {
   const sessionId = randomUUID();
 
   // One-shot async iterable: emit a single user message then close
@@ -90,12 +98,69 @@ export async function runJobWithClaude(systemPrompt: string, jobPrompt: string,
 
   let agentText = "";
   let actualSessionId = sessionId;
+  let accumulatedThinking = "";
+  let lastThinkingLine = "";
 
   try {
     for await (const message of handle) {
       if (message.type === "system" && (message as any).subtype === "init") {
         actualSessionId = (message as any).session_id || sessionId;
       }
+
+      // Stream activity events
+      if (onActivity) {
+        const msg = message as any;
+
+        if (message.type === "stream_event") {
+          const event = msg.event;
+          if (event?.type === "content_block_start" && event.content_block?.type === "thinking") {
+            accumulatedThinking = "";
+            lastThinkingLine = "";
+            onActivity("thinking...");
+          }
+          if (event?.type === "content_block_delta") {
+            const delta = event.delta;
+            if (delta?.type === "thinking_delta" && delta.thinking) {
+              accumulatedThinking += delta.thinking;
+              const lines = accumulatedThinking.split("\n");
+              if (lines.length > 1) {
+                const completeLine = lines[lines.length - 2]?.trim();
+                if (completeLine && completeLine !== lastThinkingLine) {
+                  lastThinkingLine = completeLine;
+                  onActivity(truncate(completeLine, 70));
+                }
+              }
+            }
+          }
+          if (event?.type === "content_block_stop") {
+            accumulatedThinking = "";
+            lastThinkingLine = "";
+          }
+        }
+
+        if (message.type === "tool_use_summary") {
+          const name = msg.tool_name || "tool";
+          onActivity(formatToolUse(name, msg.tool_input));
+        }
+
+        if (message.type === "tool_progress") {
+          if (msg.tool_name === "Bash" && msg.content) {
+            onActivity(`$ ${truncate(msg.content, 60)}`);
+          } else if (msg.content) {
+            onActivity(truncate(msg.content, 70));
+          }
+        }
+
+        if (message.type === "system") {
+          if (msg.subtype === "task_started" && msg.description) {
+            onActivity(truncate(msg.description, 60));
+          }
+          if (msg.subtype === "task_progress" && msg.last_tool_name) {
+            onActivity(msg.summary || msg.last_tool_name);
+          }
+        }
+      }
+
       if (message.type === "result") {
         if (!(message as any).is_error) {
           agentText = (message as any).result || "";
@@ -116,7 +181,7 @@ export async function runJobWithClaude(systemPrompt: string, jobPrompt: string,
 // Public API
 // ---------------------------------------------------------------------------
 
-export async function runJob(job: JobInput): Promise<JobResult> {
+export async function runJob(job: JobInput, onActivity?: ActivityCallback): Promise<JobResult> {
   const config = getConfig();
   const timestamp = new Date().toISOString();
   const startMs = performance.now();
@@ -136,7 +201,7 @@ export async function runJob(job: JobInput): Promise<JobResult> {
     } else {
       const systemPrompt = buildSystemPrompt("job");
       const jobPrompt = `Job: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`;
-      output = await runJobWithClaude(systemPrompt, jobPrompt, cwd);
+      output = await runJobWithClaude(systemPrompt, jobPrompt, cwd, onActivity);
     }
 
     const duration_ms = Math.round(performance.now() - startMs);

package/src/db/models/job.ts

@@ -42,6 +42,10 @@ export async function create(
   scheduleType: ScheduleType = "cron",
   nextRunAt?: Date,
 ): Promise<void> {
+  const existing = await get(name);
+  if (existing) {
+    throw new Error(`Job "${name}" already exists. Use \`nia job remove ${name}\` first, or choose a different name.`);
+  }
   const sql = getSql();
   await sql`
     INSERT INTO jobs (name, schedule, prompt, always, schedule_type, next_run_at)

package/src/mcp/server.ts

@@ -29,6 +29,19 @@ export function createNiaMcpServer() {
           content: [{ type: "text" as const, text: await handlers.addJob(args) }],
         }),
       ),
+      tool(
+        "update_job",
+        "Update an existing job's schedule, prompt, or always flag. Only pass fields you want to change.",
+        {
+          name: z.string().describe("Job name to update"),
+          schedule: z.string().optional().describe("New schedule (cron expression, interval duration, or ISO timestamp)"),
+          prompt: z.string().optional().describe("New prompt"),
+          always: z.boolean().optional().describe("If true, runs 24/7 ignoring active hours"),
+        },
+        async (args) => ({
+          content: [{ type: "text" as const, text: await handlers.updateJob(args) }],
+        }),
+      ),
       tool(
         "remove_job",
         "Delete a scheduled job",
@@ -135,9 +148,17 @@ export function createNiaMcpServer() {
           content: [{ type: "text" as const, text: handlers.addRule(args.rule) }],
         }),
       ),
+      tool(
+        "read_memory",
+        "Read all saved memories. Use this to check what you already know before saving duplicates, or to recall context about the owner, past incidents, preferences, etc.",
+        {},
+        async () => ({
+          content: [{ type: "text" as const, text: handlers.readMemory() }],
+        }),
+      ),
       tool(
         "add_memory",
-        "Save a concise factual memory for future reference. Memories are read on demand, not loaded automatically. Use for preferences, corrections, or patterns worth keeping. RULES: Max 300 chars. One insight per entry. NO raw logs, NO conversation transcripts, NO status dumps, NO duplicate observations. Bad: pasting nia status output. Good: 'curator job can get stuck in running state — needs timeout recovery'.",
+        "Save a concise factual memory for future reference. Proactively save personal facts (travel, schedule), work context (decisions, deadlines), and corrections — don't wait to be asked. RULES: Max 300 chars. One insight per entry. NO raw logs, NO transcripts, NO status dumps.",
         {
           entry: z.string().max(300).describe("A single concise insight (max 300 chars, no raw logs or transcripts)"),
         },

package/src/mcp/tools.ts

@@ -31,6 +31,24 @@ export async function addJob(args: {
   return `Job "${args.name}" created (${scheduleType}: ${args.schedule}). Next run: ${nextRunAt.toISOString()}`;
 }
 
+export async function updateJob(args: {
+  name: string;
+  schedule?: string;
+  prompt?: string;
+  always?: boolean;
+}): Promise<string> {
+  const fields: Partial<{ schedule: string; prompt: string; always: boolean }> = {};
+  if (args.schedule) fields.schedule = args.schedule;
+  if (args.prompt) fields.prompt = args.prompt;
+  if (args.always !== undefined) fields.always = args.always;
+
+  if (Object.keys(fields).length === 0) return "Nothing to update. Pass at least one field (schedule, prompt, or always).";
+
+  const updated = await Job.update(args.name, fields);
+  if (!updated) return `Job "${args.name}" not found.`;
+  return `Job "${args.name}" updated.`;
+}
+
 export async function removeJob(name: string): Promise<string> {
   const removed = await Job.remove(name);
   return removed ? `Job "${name}" removed.` : `Job "${name}" not found.`;
@@ -273,6 +291,17 @@ export function disableWatchChannel(name: string): string {
   return `Watch channel "${name}" disabled. Takes effect on next message.`;
 }
 
+export function readMemory(): string {
+  const { selfDir } = getPaths();
+  const memoryPath = join(selfDir, "memory.md");
+  if (!existsSync(memoryPath)) return "No memories saved yet.";
+  const content = readFileSync(memoryPath, "utf8").trim();
+  // Extract just the entries, skip the header/instructions
+  const lines = content.split("\n").filter((l) => l.startsWith("- ") || l.startsWith("## "));
+  if (lines.length === 0) return "No memories saved yet.";
+  return lines.join("\n");
+}
+
 export function addMemory(entry: string): string {
   // Guard: reject raw logs, transcripts, and overly long entries
   const trimmed = entry.trim();

package/src/prompts/environment.md

@@ -25,6 +25,7 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
   - `interval`: duration string (e.g., "5m", "2h", "1d" = every 5 min/2 hours/1 day)
   - `once`: ISO timestamp for one-time execution (e.g., "2026-03-14T10:00:00")
   - Set `always: true` to run 24/7 (ignores active hours)
+- **update_job** — update an existing job's schedule, prompt, or always flag
 - **remove_job** — delete a job by name
 - **enable_job** / **disable_job** — toggle a job on or off
 - **run_job** — trigger a job to run immediately
@@ -34,7 +35,8 @@ You have MCP tools for managing jobs directly (preferred over CLI for speed):
 - **remove_watch_channel** — stop watching a Slack channel. Hot-reloads.
 - **enable_watch_channel** / **disable_watch_channel** — toggle a watch channel on/off without removing it. Hot-reloads.
 - **add_rule** — save a behavioral rule (loaded into every session, no restart needed). Use when told "from now on", "always", "never", or "remember to always..."
-- **add_memory** — save a factual memory (read on demand). Use when told "remember that...", or when you learn something surprising worth keeping
+- **read_memory** — recall all saved memories. Check before saving to avoid duplicates, or when you need context about the owner.
+- **add_memory** — save a factual memory. Proactively save personal facts, work context, corrections — don't wait to be asked.
 
 Active hours: {{activeStart}}–{{activeEnd}} ({{timezone}}). Jobs respect this; crons (always=true) don't.
 
@@ -90,9 +92,18 @@ Your persona files live in {{selfDir}}/:
 **Memory** (`memory.md`) = facts and context. Read on demand when relevant.
 - "2026-03-13: DB was down, Telegram send failed"
 - "Aman prefers terminal over Slack for debugging"
-- Use `add_memory` tool to save new memories.
+- Use `read_memory` to recall what you know. Use `add_memory` to save new memories.
 
 **Which to use?**
 - "From now on, do X" → rule
 - "Remember that X happened" / "I prefer X" → memory
+
+### When to save (proactive)
+Don't wait for the user to say "remember this." Proactively save when you learn:
+- Personal facts: travel plans, location, schedule, preferences
+- Work context: project decisions, team changes, deadlines
+- Corrections: user corrected you on something worth remembering
+- Patterns: recurring requests, preferred communication style
+
+Example: if the owner says "I'm going home on the 21st, early morning flight" — save it as a memory without being asked. These are facts future sessions need.
 - If unsure, ask.

package/src/utils/format-activity.ts

@@ -0,0 +1,99 @@
+/**
+ * Shared formatting utilities for SDK activity messages.
+ * Used by both the chat engine and the job runner for live activity display.
+ */
+
+export function truncate(s: string, max: number): string {
+  const oneline = s.replace(/\n/g, " ").trim();
+  return oneline.length > max ? oneline.slice(0, max) + "…" : oneline;
+}
+
+function basename(path: string): string {
+  return path.split("/").pop() || path;
+}
+
+export function formatToolUse(tool: string, input: any): string {
+  if (!input || typeof input !== "object") return tool.toLowerCase();
+
+  switch (tool) {
+    // File operations
+    case "Bash":
+      return input.description
+        ? truncate(input.description, 60)
+        : input.command ? `$ ${truncate(input.command, 55)}` : "running command";
+    case "Read":
+      return input.file_path ? `reading ${basename(input.file_path)}` : "reading file";
+    case "Edit":
+      return input.file_path ? `editing ${basename(input.file_path)}` : "editing file";
+    case "Write":
+      return input.file_path ? `writing ${basename(input.file_path)}` : "writing file";
+    case "NotebookEdit":
+      return input.file_path ? `editing notebook ${basename(input.file_path)}` : "editing notebook";
+
+    // Search operations
+    case "Grep":
+      return input.pattern ? `searching for "${truncate(input.pattern, 35)}"` : "searching code";
+    case "Glob":
+      return input.pattern ? `finding ${truncate(input.pattern, 40)}` : "finding files";
+    case "ToolSearch":
+      return input.query ? `looking up tool: ${truncate(input.query, 40)}` : "searching tools";
+
+    // Agent & task operations
+    case "Agent":
+      return input.description ? `⟩ ${truncate(input.description, 55)}` : "running agent";
+    case "Task":
+      return input.description || input.prompt?.slice(0, 50) || "running task";
+    case "TaskCreate":
+      return input.description ? `starting: ${truncate(input.description, 45)}` : "creating task";
+    case "TaskGet":
+    case "TaskOutput":
+      return "checking task progress";
+    case "TaskList":
+      return "listing tasks";
+    case "TaskStop":
+      return "stopping task";
+    case "TaskUpdate":
+      return "updating task";
+    case "SendMessage":
+      return input.to ? `messaging ${truncate(String(input.to), 30)}` : "sending message";
+
+    // Web operations
+    case "WebFetch":
+      return input.url ? `fetching ${truncate(input.url, 50)}` : "fetching url";
+    case "WebSearch":
+      return input.query ? `web search: ${truncate(input.query, 40)}` : "searching the web";
+
+    // Planning & workflow
+    case "EnterPlanMode":
+      return "entering plan mode";
+    case "ExitPlanMode":
+      return "exiting plan mode";
+    case "EnterWorktree":
+      return "creating worktree";
+    case "ExitWorktree":
+      return "leaving worktree";
+
+    // Skill & todo
+    case "Skill":
+      return input.skill ? `using /${truncate(input.skill, 40)}` : "invoking skill";
+    case "TodoWrite":
+    case "TodoRead":
+      return tool === "TodoWrite" ? "updating checklist" : "reading checklist";
+
+    // LSP
+    case "LSP":
+      return input.command ? `lsp: ${truncate(input.command, 50)}` : "querying language server";
+
+    // MCP tools (plugin_name__tool_name pattern)
+    default: {
+      if (tool.startsWith("mcp__")) {
+        const parts = tool.split("__");
+        const action = parts[parts.length - 1]?.replace(/_/g, " ") || tool;
+        const val = input.url || input.selector || input.text || input.value || "";
+        return val ? `${action}: ${truncate(String(val), 40)}` : action;
+      }
+      const val = input.description || input.command || input.pattern || input.query || input.file_path || "";
+      return val ? `${tool.toLowerCase()}: ${truncate(String(val), 50)}` : tool.toLowerCase();
+    }
+  }
+}

package/src/utils/format.ts

@@ -40,6 +40,18 @@ export function relativeTime(date: Date, now = new Date()): string {
   return deltaMs > 0 ? `in ${text}` : `${text} ago`;
 }
 
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  const totalSeconds = Math.round(ms / 1000);
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes < 60) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+}
+
 export function formatTimeLine(date: string | null | undefined, now = new Date()): string {
   const parsed = safeDate(date);
   if (!parsed) return "unknown";