multi-project-gateway 0.5.1 → 0.6.0

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve4 } from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync6, copyFileSync, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve5 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync6, copyFileSync, mkdirSync as mkdirSync8 } from "fs";
 import { config as loadEnv } from "dotenv";
 
 // src/persona-presets.ts
@@ -247,7 +247,10 @@ ${extra}` : basePrompt;
       ...projectDisallowed && { disallowedTools: projectDisallowed },
       ...agents && { agents },
       ...allowedRoles && allowedRoles.length > 0 && { allowedRoles },
-      ...rateLimitPerUser !== void 0 && { rateLimitPerUser }
+      ...rateLimitPerUser !== void 0 && { rateLimitPerUser },
+      ...typeof p.maxAttachmentSizeMb === "number" && { maxAttachmentSizeMb: p.maxAttachmentSizeMb },
+      ...Array.isArray(p.allowedMimeTypes) && { allowedMimeTypes: p.allowedMimeTypes },
+      ...typeof p.maxAttachmentsPerMessage === "number" && { maxAttachmentsPerMessage: p.maxAttachmentsPerMessage }
     };
   }
   const defaults = obj.defaults ?? {};
@@ -267,8 +270,13 @@ ${extra}` : basePrompt;
       disallowedTools: defaultDisallowed,
       maxTurnsPerAgent: typeof defaults.maxTurnsPerAgent === "number" ? defaults.maxTurnsPerAgent : 5,
       agentTimeoutMs: typeof defaults.agentTimeoutMs === "number" ? defaults.agentTimeoutMs : 3 * 60 * 1e3,
+      stuckNotifyMs: typeof defaults.stuckNotifyMs === "number" ? defaults.stuckNotifyMs : 3e5,
       httpPort: defaults.httpPort === false ? false : typeof defaults.httpPort === "number" ? defaults.httpPort : 3100,
-      logLevel: isValidLogLevel(defaults.logLevel) ? defaults.logLevel : "info"
+      logLevel: isValidLogLevel(defaults.logLevel) ? defaults.logLevel : "info",
+      maxAttachmentSizeMb: typeof defaults.maxAttachmentSizeMb === "number" ? defaults.maxAttachmentSizeMb : 10,
+      allowedMimeTypes: Array.isArray(defaults.allowedMimeTypes) ? defaults.allowedMimeTypes : ["image/*", "text/*", "application/pdf", "application/json"],
+      maxAttachmentsPerMessage: typeof defaults.maxAttachmentsPerMessage === "number" ? defaults.maxAttachmentsPerMessage : 5,
+      persistence: defaults.persistence === "tmux" ? "tmux" : "direct"
     },
     projects: validated
   };
@@ -293,119 +301,8 @@ function createRouter(config) {
   };
 }
 
-// src/claude-cli.ts
-import { spawn } from "child_process";
-function parseClaudeJsonOutput(raw) {
-  const data = JSON.parse(raw);
-  let usage;
-  if (data.total_cost_usd != null || data.usage) {
-    const model = data.model ?? (data.modelUsage ? Object.keys(data.modelUsage)[0] : void 0);
-    usage = {
-      input_tokens: data.usage?.input_tokens ?? 0,
-      output_tokens: data.usage?.output_tokens ?? 0,
-      cache_creation_input_tokens: data.usage?.cache_creation_input_tokens ?? 0,
-      cache_read_input_tokens: data.usage?.cache_read_input_tokens ?? 0,
-      total_cost_usd: data.total_cost_usd ?? 0,
-      duration_ms: data.duration_ms ?? 0,
-      duration_api_ms: data.duration_api_ms ?? 0,
-      num_turns: data.num_turns ?? 0,
-      model
-    };
-  }
-  return {
-    text: data.result ?? "",
-    sessionId: data.session_id ?? "",
-    isError: Boolean(data.is_error),
-    usage
-  };
-}
-function buildToolArgs(defaults, projectOverrides, existingArgs) {
-  if (existingArgs?.includes("--allowed-tools") || existingArgs?.includes("--disallowed-tools")) {
-    return [];
-  }
-  const allowed = projectOverrides?.allowedTools ?? defaults.allowedTools;
-  const disallowed = projectOverrides?.disallowedTools ?? defaults.disallowedTools;
-  const args2 = [];
-  if (allowed && allowed.length > 0) {
-    args2.push("--allowed-tools", ...allowed);
-  } else if (disallowed && disallowed.length > 0) {
-    args2.push("--disallowed-tools", ...disallowed);
-  }
-  return args2;
-}
-function buildClaudeArgs(baseArgs, prompt, sessionId, systemPrompt) {
-  const args2 = ["--print", prompt, ...baseArgs];
-  if (sessionId) {
-    args2.push("--resume", sessionId);
-  }
-  if (systemPrompt) {
-    args2.push("--append-system-prompt", systemPrompt);
-  }
-  return args2;
-}
-function friendlyError(stderr) {
-  const combined = stderr.toLowerCase();
-  if (combined.includes("rate limit") || combined.includes("rate_limit_error")) {
-    return "Claude usage limit reached \u2014 please wait a few minutes and try again.";
-  }
-  if (combined.includes("overloaded") || combined.includes("overloaded_error")) {
-    return "Claude API is temporarily overloaded \u2014 please try again shortly.";
-  }
-  if (combined.includes("invalid api key") || combined.includes("authentication_error") || combined.includes("authentication failed")) {
-    return "Claude authentication failed \u2014 check your API key or CLI login.";
-  }
-  if (combined.includes("no messages returned")) {
-    return "Claude returned an empty response \u2014 try sending your message again.";
-  }
-  return `Claude error: ${stderr.slice(0, 500)}`;
-}
-var DEFAULT_TIMEOUT_MS = 20 * 60 * 1e3;
-function runClaude(cwd, baseArgs, prompt, sessionId, systemPrompt, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  return new Promise((resolve5, reject) => {
-    const args2 = buildClaudeArgs(baseArgs, prompt, sessionId, systemPrompt);
-    const proc = spawn("claude", args2, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    const timer = setTimeout(() => {
-      if (!settled) {
-        settled = true;
-        proc.kill("SIGTERM");
-        reject(new Error(`Claude CLI timed out after ${timeoutMs / 1e3}s`));
-      }
-    }, timeoutMs);
-    proc.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    proc.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-      if (settled) return;
-      settled = true;
-      if (code !== 0) {
-        reject(new Error(friendlyError(stderr)));
-        return;
-      }
-      try {
-        const result = parseClaudeJsonOutput(stdout.trim());
-        resolve5(result);
-      } catch (err) {
-        reject(new Error(`Failed to parse claude output: ${stdout.slice(0, 200)}`));
-      }
-    });
-    proc.on("error", (err) => {
-      clearTimeout(timer);
-      if (settled) return;
-      settled = true;
-      reject(new Error(`Failed to spawn claude: ${err.message}`));
-    });
-  });
-}
+// src/session-manager.ts
+import { existsSync as existsSync2 } from "fs";
 
 // src/worktree.ts
 import { execFileSync } from "child_process";
@@ -497,8 +394,100 @@ function reconcileWorktrees(projectDir, knownKeys) {
   }
 }
 
+// src/attachments.ts
+import { mkdir, writeFile, rm } from "fs/promises";
+import { basename, join as join2, resolve } from "path";
+function matchesMimeType(contentType, patterns) {
+  if (!contentType) return false;
+  const mime = contentType.split(";")[0].trim().toLowerCase();
+  return patterns.some((pattern) => {
+    if (pattern.endsWith("/*")) {
+      return mime.startsWith(pattern.slice(0, -1));
+    }
+    return mime === pattern;
+  });
+}
+async function downloadAttachments(attachments, messageId, baseDir, config) {
+  const warnings = [];
+  const downloaded = [];
+  const items = [...attachments.values()];
+  if (items.length > config.maxAttachmentsPerMessage) {
+    warnings.push(
+      `Only processing first ${config.maxAttachmentsPerMessage} of ${items.length} attachments.`
+    );
+  }
+  const toProcess = items.slice(0, config.maxAttachmentsPerMessage);
+  const maxBytes = config.maxAttachmentSizeMb * 1024 * 1024;
+  const dir = join2(baseDir, ".mpg-attachments", messageId);
+  let dirCreated = false;
+  for (const att of toProcess) {
+    const rawName = att.name ?? `attachment-${att.id}`;
+    const name = basename(rawName).replace(/^\.+/, "") || `attachment-${att.id}`;
+    if (att.size > maxBytes) {
+      warnings.push(`Skipped \`${name}\` \u2014 exceeds ${config.maxAttachmentSizeMb}MB limit.`);
+      continue;
+    }
+    if (!matchesMimeType(att.contentType, config.allowedMimeTypes)) {
+      warnings.push(`Skipped \`${name}\` \u2014 type \`${att.contentType ?? "unknown"}\` not allowed.`);
+      continue;
+    }
+    try {
+      const parsedUrl = new URL(att.url);
+      if (!parsedUrl.hostname.endsWith(".discordapp.com") && !parsedUrl.hostname.endsWith(".discord.com")) {
+        warnings.push(`Skipped \`${name}\` \u2014 untrusted URL host.`);
+        continue;
+      }
+      const response = await fetch(att.url);
+      if (!response.ok) {
+        warnings.push(`Failed to download \`${name}\` \u2014 HTTP ${response.status}.`);
+        continue;
+      }
+      if (!dirCreated) {
+        await mkdir(dir, { recursive: true });
+        dirCreated = true;
+      }
+      const buffer = Buffer.from(await response.arrayBuffer());
+      const filePath = join2(dir, name);
+      if (!resolve(filePath).startsWith(resolve(dir) + "/")) {
+        warnings.push(`Skipped \`${rawName}\` \u2014 unsafe filename.`);
+        continue;
+      }
+      await writeFile(filePath, buffer);
+      downloaded.push({ path: filePath, name });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warnings.push(`Failed to download \`${name}\` \u2014 ${msg}.`);
+    }
+  }
+  return { downloaded, warnings };
+}
+function buildAttachmentPrompt(attachments) {
+  if (attachments.length === 0) return "";
+  const paths = attachments.map((a) => a.path).join("\n  ");
+  return `[Attached files \u2014 use the Read tool to view these:
+  ${paths}]
+
+`;
+}
+async function reconcileAttachments(projectDir) {
+  const dir = join2(projectDir, ".mpg-attachments");
+  try {
+    await rm(dir, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function cleanupAttachments(baseDir) {
+  const dir = join2(baseDir, ".mpg-attachments");
+  try {
+    await rm(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+
 // src/session-manager.ts
-function createSessionManager(defaults, store, pulseEmitter) {
+function createSessionManager(defaults, runtime, store, pulseEmitter) {
   const sessions = /* @__PURE__ */ new Map();
   const sessionTtlMs = defaults.sessionTtlMs ?? 7 * 24 * 60 * 60 * 1e3;
   const maxPersistedSessions = defaults.maxPersistedSessions ?? 50;
@@ -546,10 +535,10 @@ function createSessionManager(defaults, store, pulseEmitter) {
       activeProcesses++;
       return;
     }
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       waiters.push(() => {
         activeProcesses++;
-        resolve5();
+        resolve6();
       });
     });
   }
@@ -571,6 +560,9 @@ function createSessionManager(defaults, store, pulseEmitter) {
           session.messageCount
         );
       }
+      cleanupAttachments(session.projectDir ?? session.cwd).catch(() => {
+      });
+      if (runtime.cleanup) runtime.cleanup(session.projectKey);
       sessions.delete(session.projectKey);
     }, defaults.idleTimeoutMs);
   }
@@ -591,14 +583,15 @@ function createSessionManager(defaults, store, pulseEmitter) {
         );
       }
       try {
-        const result = await runClaude(
-          session.cwd,
-          effectiveArgs,
-          item.prompt,
-          session.sessionId,
-          item.systemPrompt,
-          item.timeoutMs
-        );
+        const result = await runtime.spawn({
+          cwd: session.cwd,
+          baseArgs: effectiveArgs,
+          prompt: item.prompt,
+          sessionId: session.sessionId,
+          systemPrompt: item.systemPrompt,
+          timeoutMs: item.timeoutMs,
+          projectKey: session.projectKey
+        });
         const sessionChanged = !!(session.sessionId && result.sessionId && result.sessionId !== session.sessionId);
         session.sessionId = result.sessionId || session.sessionId;
         session.lastActivity = Date.now();
@@ -624,7 +617,7 @@ function createSessionManager(defaults, store, pulseEmitter) {
         if (session.sessionId) {
           session.sessionId = void 0;
           try {
-            const result = await runClaude(session.cwd, effectiveArgs, item.prompt, void 0, item.systemPrompt, item.timeoutMs);
+            const result = await runtime.spawn({ cwd: session.cwd, baseArgs: effectiveArgs, prompt: item.prompt, sessionId: void 0, systemPrompt: item.systemPrompt, timeoutMs: item.timeoutMs, projectKey: session.projectKey });
             session.sessionId = result.sessionId || void 0;
             session.lastActivity = Date.now();
             session.messageCount++;
@@ -678,7 +671,7 @@ function createSessionManager(defaults, store, pulseEmitter) {
         }
       }
       let effectiveCwd = cwd;
-      let worktreePath2 = restoredWorktreePath;
+      let worktreePath2 = restoredWorktreePath && existsSync2(restoredWorktreePath) ? restoredWorktreePath : void 0;
       let projectDir;
       if (useWorktree && !worktreePath2) {
         worktreePath2 = createWorktree(cwd, projectKey);
@@ -759,8 +752,8 @@ function createSessionManager(defaults, store, pulseEmitter) {
   return {
     send(projectKey, cwd, prompt, opts) {
       const session = getOrCreateSession(projectKey, cwd, opts?.worktree);
-      return new Promise((resolve5, reject) => {
-        session.queue.push({ prompt, systemPrompt: opts?.systemPrompt, timeoutMs: opts?.timeoutMs, extraArgs: opts?.extraArgs, resolve: resolve5, reject });
+      return new Promise((resolve6, reject) => {
+        session.queue.push({ prompt, systemPrompt: opts?.systemPrompt, timeoutMs: opts?.timeoutMs, extraArgs: opts?.extraArgs, resolve: resolve6, reject });
         processQueue(session);
       });
     },
@@ -770,16 +763,24 @@ function createSessionManager(defaults, store, pulseEmitter) {
       return {
         sessionId: session.sessionId ?? "",
         projectKey: session.projectKey,
+        cwd: session.cwd,
+        projectDir: session.projectDir,
         lastActivity: session.lastActivity,
-        queueLength: session.queue.length
+        queueLength: session.queue.length,
+        createdAt: session.createdAt,
+        processing: session.processing
       };
     },
     listSessions() {
       return Array.from(sessions.values()).map((s) => ({
         sessionId: s.sessionId ?? "",
         projectKey: s.projectKey,
+        cwd: s.cwd,
+        projectDir: s.projectDir,
         lastActivity: s.lastActivity,
-        queueLength: s.queue.length
+        queueLength: s.queue.length,
+        createdAt: s.createdAt,
+        processing: s.processing
       }));
     },
     clearSession(projectKey) {
@@ -798,6 +799,9 @@ function createSessionManager(defaults, store, pulseEmitter) {
       if (session.worktreePath && session.projectDir) {
         removeWorktree(session.projectDir, session.projectKey);
       }
+      cleanupAttachments(session.projectDir ?? session.cwd).catch(() => {
+      });
+      if (runtime.cleanup) runtime.cleanup(projectKey);
       sessions.delete(projectKey);
       persistSessions();
       return true;
@@ -811,10 +815,71 @@ function createSessionManager(defaults, store, pulseEmitter) {
       persistSessions();
       return true;
     },
+    async recoverOrphanedSessions(onResult) {
+      if (!runtime.canResume) {
+        console.log("[recovery] Skipping: runtime.canResume is false");
+        return;
+      }
+      console.log("[recovery] Checking for orphaned tmux sessions...");
+      let orphanedKeys;
+      try {
+        orphanedKeys = await runtime.listOrphanedSessions();
+      } catch (err) {
+        console.error("Failed to list orphaned sessions:", err);
+        return;
+      }
+      console.log(`[recovery] Found ${orphanedKeys.length} orphaned tmux session(s): ${JSON.stringify(orphanedKeys)}`);
+      if (orphanedKeys.length === 0) return;
+      console.log(`Discovered ${orphanedKeys.length} orphaned tmux session(s)`);
+      const persisted = store ? store.load() : /* @__PURE__ */ new Map();
+      console.log(`[recovery] Persisted store has ${persisted.size} entries. Keys: ${JSON.stringify([...persisted.keys()].slice(0, 20))}`);
+      const sanitizedLookup = /* @__PURE__ */ new Map();
+      for (const [key, entry] of persisted) {
+        const sanitized = key.replace(/[^a-zA-Z0-9_-]/g, "-");
+        sanitizedLookup.set(sanitized, entry);
+      }
+      const reattachPromises = [];
+      for (const key of orphanedKeys) {
+        const entry = sanitizedLookup.get(key);
+        console.log(`[recovery] Orphan key "${key}" \u2192 match: ${entry ? `yes (projectKey=${entry.projectKey})` : "NO"}`);
+        if (!entry) {
+          console.log(`Cleaning up unmatched orphan: ${key}`);
+          if (runtime.cleanup) runtime.cleanup(key);
+          continue;
+        }
+        reattachPromises.push(
+          (async () => {
+            try {
+              if (pulseEmitter) {
+                pulseEmitter.sessionResume(
+                  entry.sessionId,
+                  entry.projectKey,
+                  entry.cwd,
+                  Date.now() - entry.lastActivity
+                );
+              }
+              const result = await runtime.reattach(key);
+              console.log(`Reattached orphan ${key}: ${result.text.length} chars`);
+              onResult(entry.projectKey, result);
+            } catch (err) {
+              console.error(`Failed to reattach orphan ${key}:`, err);
+            } finally {
+              if (runtime.cleanup) runtime.cleanup(key);
+            }
+          })()
+        );
+      }
+      await Promise.all(reattachPromises);
+    },
     shutdown() {
       persistSessions();
+      const activeKeys = [...sessions.values()].map((s) => s.projectKey);
+      console.log(`[shutdown] Persisted ${activeKeys.length} session(s). canResume=${runtime.canResume}. Keys: ${JSON.stringify(activeKeys.slice(0, 10))}`);
       for (const session of sessions.values()) {
         if (session.idleTimer) clearTimeout(session.idleTimer);
+        if (!runtime.canResume && runtime.cleanup) runtime.cleanup(session.projectKey);
+        cleanupAttachments(session.projectDir ?? session.cwd).catch(() => {
+        });
       }
       sessions.clear();
     }
@@ -853,9 +918,344 @@ function createFileSessionStore(filePath) {
   };
 }
 
+// src/claude-cli.ts
+import { spawn } from "child_process";
+function parseClaudeJsonOutput(raw) {
+  const data = JSON.parse(raw);
+  let usage;
+  if (data.total_cost_usd != null || data.usage) {
+    const model = data.model ?? (data.modelUsage ? Object.keys(data.modelUsage)[0] : void 0);
+    usage = {
+      input_tokens: data.usage?.input_tokens ?? 0,
+      output_tokens: data.usage?.output_tokens ?? 0,
+      cache_creation_input_tokens: data.usage?.cache_creation_input_tokens ?? 0,
+      cache_read_input_tokens: data.usage?.cache_read_input_tokens ?? 0,
+      total_cost_usd: data.total_cost_usd ?? 0,
+      duration_ms: data.duration_ms ?? 0,
+      duration_api_ms: data.duration_api_ms ?? 0,
+      num_turns: data.num_turns ?? 0,
+      model
+    };
+  }
+  return {
+    text: data.result ?? "",
+    sessionId: data.session_id ?? "",
+    isError: Boolean(data.is_error),
+    usage
+  };
+}
+function buildToolArgs(defaults, projectOverrides, existingArgs) {
+  if (existingArgs?.includes("--allowed-tools") || existingArgs?.includes("--disallowed-tools")) {
+    return [];
+  }
+  const allowed = projectOverrides?.allowedTools ?? defaults.allowedTools;
+  const disallowed = projectOverrides?.disallowedTools ?? defaults.disallowedTools;
+  const args2 = [];
+  if (allowed && allowed.length > 0) {
+    args2.push("--allowed-tools", ...allowed);
+  } else if (disallowed && disallowed.length > 0) {
+    args2.push("--disallowed-tools", ...disallowed);
+  }
+  return args2;
+}
+function buildClaudeArgs(baseArgs, prompt, sessionId, systemPrompt) {
+  const args2 = ["--print", prompt, ...baseArgs];
+  if (sessionId) {
+    args2.push("--resume", sessionId);
+  }
+  if (systemPrompt) {
+    args2.push("--append-system-prompt", systemPrompt);
+  }
+  return args2;
+}
+function friendlyError(stderr) {
+  const combined = stderr.toLowerCase();
+  if (combined.includes("rate limit") || combined.includes("rate_limit_error")) {
+    return "Claude usage limit reached \u2014 please wait a few minutes and try again.";
+  }
+  if (combined.includes("overloaded") || combined.includes("overloaded_error")) {
+    return "Claude API is temporarily overloaded \u2014 please try again shortly.";
+  }
+  if (combined.includes("invalid api key") || combined.includes("authentication_error") || combined.includes("authentication failed")) {
+    return "Claude authentication failed \u2014 check your API key or CLI login.";
+  }
+  if (combined.includes("no messages returned")) {
+    return "Claude returned an empty response \u2014 try sending your message again.";
+  }
+  return `Claude error: ${stderr.slice(0, 500)}`;
+}
+var DEFAULT_TIMEOUT_MS = 20 * 60 * 1e3;
+function runClaude(cwd, baseArgs, prompt, sessionId, systemPrompt, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  return new Promise((resolve6, reject) => {
+    const args2 = buildClaudeArgs(baseArgs, prompt, sessionId, systemPrompt);
+    const proc = spawn("claude", args2, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        proc.kill("SIGTERM");
+        reject(new Error(`Claude CLI timed out after ${timeoutMs / 1e3}s`));
+      }
+    }, timeoutMs);
+    proc.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      if (settled) return;
+      settled = true;
+      if (code !== 0) {
+        reject(new Error(friendlyError(stderr)));
+        return;
+      }
+      try {
+        const result = parseClaudeJsonOutput(stdout.trim());
+        resolve6(result);
+      } catch (err) {
+        reject(new Error(`Failed to parse claude output: ${stdout.slice(0, 200)}`));
+      }
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      if (settled) return;
+      settled = true;
+      reject(new Error(`Failed to spawn claude: ${err.message}`));
+    });
+  });
+}
+
+// src/runtimes/claude-cli-runtime.ts
+var ClaudeCliRuntime = class {
+  name = "claude-cli";
+  canResume = false;
+  spawn(opts) {
+    return runClaude(
+      opts.cwd,
+      opts.baseArgs,
+      opts.prompt,
+      opts.sessionId,
+      opts.systemPrompt,
+      opts.timeoutMs
+    );
+  }
+  async listOrphanedSessions() {
+    return [];
+  }
+  async reattach(_sessionId) {
+    throw new Error("ClaudeCliRuntime does not support session reattachment");
+  }
+};
+
+// src/runtimes/tmux-runtime.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, existsSync as existsSync3, watch } from "fs";
+import { join as join3 } from "path";
+
+// src/tmux.ts
+import { execFileSync as execFileSync2 } from "child_process";
+var TIMEOUT2 = 1e4;
+function ensureTmux() {
+  try {
+    execFileSync2("tmux", ["-V"], { timeout: TIMEOUT2, stdio: "pipe" });
+  } catch {
+    throw new Error(
+      "tmux is not installed or not on PATH. Install tmux to use persistent sessions (e.g. `apt install tmux`)."
+    );
+  }
+}
+function createSession(name, command2, opts) {
+  ensureTmux();
+  execFileSync2("tmux", ["new-session", "-d", "-s", name, command2], {
+    cwd: opts?.cwd,
+    timeout: TIMEOUT2,
+    stdio: "pipe"
+  });
+}
+function sessionExists(name) {
+  try {
+    execFileSync2("tmux", ["has-session", "-t", name], {
+      timeout: TIMEOUT2,
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listSessions(prefix) {
+  try {
+    const raw = execFileSync2("tmux", ["ls", "-F", "#{session_name}"], {
+      timeout: TIMEOUT2,
+      stdio: "pipe"
+    }).toString();
+    return raw.split("\n").map((l) => l.trim()).filter((l) => l.startsWith(prefix));
+  } catch {
+    return [];
+  }
+}
+function killSession(name) {
+  try {
+    execFileSync2("tmux", ["kill-session", "-t", name], {
+      timeout: TIMEOUT2,
+      stdio: "pipe"
+    });
+  } catch {
+  }
+}
+
+// src/runtimes/tmux-runtime.ts
+var SESSION_PREFIX = "mpg-";
+var OUTPUT_BASE_DIR = "/tmp/mpg-sessions";
+var DEFAULT_TIMEOUT_MS2 = 20 * 60 * 1e3;
+var HEALTH_CHECK_DELAY_MS = 2 * 60 * 1e3;
+var POLL_INTERVAL_MS = 500;
+function sanitizeSessionName(key) {
+  return key.replace(/[^a-zA-Z0-9_-]/g, "-");
+}
+function outputDir(sessionKey) {
+  return join3(OUTPUT_BASE_DIR, sanitizeSessionName(sessionKey));
+}
+function outputFile(sessionKey) {
+  return join3(outputDir(sessionKey), "output.json");
+}
+function stderrFile(sessionKey) {
+  return join3(outputDir(sessionKey), "stderr.log");
+}
+var TmuxRuntime = class {
+  name = "tmux";
+  canResume = true;
+  constructor() {
+    ensureTmux();
+  }
+  async spawn(opts) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+    const sessionKey = opts.projectKey ?? opts.sessionId ?? `spawn-${Date.now()}`;
+    const tmuxName = SESSION_PREFIX + sanitizeSessionName(sessionKey);
+    const outDir = outputDir(sessionKey);
+    mkdirSync2(outDir, { recursive: true });
+    const outPath = outputFile(sessionKey);
+    const errPath = stderrFile(sessionKey);
+    const args2 = buildClaudeArgs(opts.baseArgs, opts.prompt, opts.sessionId, opts.systemPrompt);
+    const escapedArgs = args2.map((a) => shellEscape(a));
+    const bufferMs = 5 * 60 * 1e3;
+    const timeoutSec = Math.ceil((timeoutMs + bufferMs) / 1e3);
+    const command2 = `timeout ${timeoutSec} claude ${escapedArgs.join(" ")} > ${shellEscape(outPath)} 2> ${shellEscape(errPath)}`;
+    if (sessionExists(tmuxName)) {
+      killSession(tmuxName);
+    }
+    createSession(tmuxName, command2, { cwd: opts.cwd });
+    return this._waitForResult(tmuxName, sessionKey, outPath, errPath, timeoutMs);
+  }
+  async listOrphanedSessions() {
+    const sessions = listSessions(SESSION_PREFIX);
+    console.log(`[tmux] listOrphanedSessions: raw tmux sessions with prefix '${SESSION_PREFIX}': ${JSON.stringify(sessions)}`);
+    return sessions.map((name) => name.slice(SESSION_PREFIX.length));
+  }
+  async reattach(sessionKey) {
+    const tmuxName = SESSION_PREFIX + sanitizeSessionName(sessionKey);
+    const outPath = outputFile(sessionKey);
+    const errPath = stderrFile(sessionKey);
+    if (!sessionExists(tmuxName)) {
+      if (existsSync3(outPath)) {
+        return this._readResult(outPath, errPath);
+      }
+      throw new Error(`tmux session ${tmuxName} does not exist and no output file found`);
+    }
+    return this._waitForResult(tmuxName, sessionKey, outPath, errPath, DEFAULT_TIMEOUT_MS2);
+  }
+  /** Clean up tmux session and temp files for a given session key. */
+  cleanup(sessionKey) {
+    const tmuxName = SESSION_PREFIX + sanitizeSessionName(sessionKey);
+    killSession(tmuxName);
+    const dir = outputDir(sessionKey);
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  _readResult(outPath, errPath) {
+    const stdout = existsSync3(outPath) ? readFileSync2(outPath, "utf-8").trim() : "";
+    const stderr = existsSync3(errPath) ? readFileSync2(errPath, "utf-8").trim() : "";
+    if (!stdout && stderr) {
+      throw new Error(friendlyError(stderr));
+    }
+    if (!stdout) {
+      throw new Error("Claude produced no output");
+    }
+    try {
+      return parseClaudeJsonOutput(stdout);
+    } catch {
+      throw new Error(`Failed to parse claude output: ${stdout.slice(0, 200)}`);
+    }
+  }
+  _waitForResult(tmuxName, sessionKey, outPath, errPath, timeoutMs) {
+    return new Promise((resolve6, reject) => {
+      let settled = false;
+      let healthCheckDone = false;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        killSession(tmuxName);
+        reject(new Error(`Claude CLI timed out after ${timeoutMs / 1e3}s`));
+      }, timeoutMs);
+      const healthTimer = setTimeout(() => {
+        if (settled) return;
+        healthCheckDone = true;
+        if (!sessionExists(tmuxName)) {
+          tryResolve();
+        }
+      }, Math.min(HEALTH_CHECK_DELAY_MS, timeoutMs));
+      let watcher;
+      try {
+        const dir = outputDir(sessionKey);
+        watcher = watch(dir, () => {
+          if (!settled) tryResolve();
+        });
+      } catch {
+      }
+      const pollTimer = setInterval(() => {
+        if (!settled) tryResolve();
+      }, POLL_INTERVAL_MS);
+      function tryResolve() {
+        if (sessionExists(tmuxName)) return;
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        clearTimeout(healthTimer);
+        clearInterval(pollTimer);
+        if (watcher) watcher.close();
+        try {
+          const stdout = existsSync3(outPath) ? readFileSync2(outPath, "utf-8").trim() : "";
+          const stderr = existsSync3(errPath) ? readFileSync2(errPath, "utf-8").trim() : "";
+          if (!stdout && stderr) {
+            reject(new Error(friendlyError(stderr)));
+            return;
+          }
+          if (!stdout) {
+            reject(new Error("Claude produced no output"));
+            return;
+          }
+          const result = parseClaudeJsonOutput(stdout);
+          resolve6(result);
+        } catch (err) {
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    });
+  }
+};
+function shellEscape(s) {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+
 // src/discord.ts
-import { readdirSync, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
 import { Client, GatewayIntentBits, Events, Status } from "discord.js";
 
 // src/agent-dispatch.ts
@@ -1173,34 +1573,6 @@ ${lines.join("\n")}
 
 Dispatch: \`!ask <agent> <message>\` or shorthand \`!<agent> <message>\``;
   }
-  if (cmd === "!apo") {
-    if (!context) return "Run `!apo` in a project channel or thread.";
-    const match = findProjectByName(config, context.projectName);
-    const projectDir = match ? config.projects[match.channelId]?.directory : void 0;
-    if (!projectDir) return "Run `!apo` in a project channel or thread.";
-    const pulseDir = join2(projectDir, ".pulse");
-    let files;
-    try {
-      files = readdirSync(pulseDir).filter((f) => f.endsWith(".json")).sort();
-    } catch {
-      return `No pulse reports found for **${context.projectName}**.`;
-    }
-    if (files.length === 0) return `No pulse reports found for **${context.projectName}**.`;
-    try {
-      const raw = readFileSync2(join2(pulseDir, files[files.length - 1]), "utf-8");
-      const report = JSON.parse(raw);
-      const c = report.convergence ?? {};
-      return [
-        `Pulse \u2014 ${report.project ?? context.projectName}`,
-        "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
-        `${c.exchanges ?? "?"} exchanges | ${c.outcomes ?? "?"} outcomes | rate ${c.rate ?? "?"}`,
-        `Rework: ${c.reworkPercent ?? "?"}%`,
-        `Reported: ${report.timestamp ?? "unknown"}`
-      ].join("\n");
-    } catch {
-      return `Failed to read pulse report for **${context.projectName}**.`;
-    }
-  }
   if (cmd === "!help") {
     return [
       "**Gateway commands**",
@@ -1211,7 +1583,6 @@ Dispatch: \`!ask <agent> <message>\` or shorthand \`!<agent> <message>\``;
       "`!restart <name>` \u2014 reset a session (fresh context, keeps worktree)",
       "`!kill <name>` \u2014 force-close a project session",
       "`!agents` \u2014 list available agents for the current project",
-      "`!apo` \u2014 show latest pulse interaction report",
       "`!help` \u2014 show this message"
     ].join("\n");
   }
@@ -1328,6 +1699,17 @@ Usage: \`!ask <agent> <message>\``
     }, 7e3);
     replyChannel.sendTyping().catch(() => {
     });
+    const stuckNotifyMs = config.defaults.stuckNotifyMs;
+    const isWorktreeSession = replyChannel.isThread();
+    const sendStartTime = Date.now();
+    let stuckNotifyInterval = null;
+    if (stuckNotifyMs > 0 && isWorktreeSession) {
+      stuckNotifyInterval = setInterval(() => {
+        const elapsed = Math.floor((Date.now() - sendStartTime) / 6e4);
+        replyChannel.send(`\u23F3 Still working\u2026 (${elapsed}m elapsed)`).catch(() => {
+        });
+      }, stuckNotifyMs);
+    }
     const projectChannelId = parentId || resolved.channelId;
     const project = config.projects[projectChannelId];
     const agents = project?.agents;
@@ -1346,11 +1728,35 @@ Usage: \`!ask <agent> <message>\``
 
 ${activeAgent.agent.prompt}` : void 0;
     try {
+      let attachmentPrefix = "";
+      if (message.attachments.size > 0) {
+        const attachmentConfig = {
+          maxAttachmentSizeMb: project?.maxAttachmentSizeMb ?? config.defaults.maxAttachmentSizeMb,
+          allowedMimeTypes: project?.allowedMimeTypes ?? config.defaults.allowedMimeTypes,
+          maxAttachmentsPerMessage: project?.maxAttachmentsPerMessage ?? config.defaults.maxAttachmentsPerMessage
+        };
+        const attachmentResult = await downloadAttachments(
+          message.attachments,
+          message.id,
+          resolved.directory,
+          attachmentConfig
+        );
+        if (attachmentResult.warnings.length > 0) {
+          await replyChannel.send(`\u26A0\uFE0F ${attachmentResult.warnings.join("\n")}`);
+        }
+        attachmentPrefix = buildAttachmentPrompt(attachmentResult.downloaded);
+      }
       let userPrompt = mention ? mention.prompt : message.content;
       if (activeAgent && message.channel.isThread()) {
         const history = await fetchThreadHistory(replyChannel, message.id);
         if (history) userPrompt = `${history}${userPrompt}`;
       }
+      if (!userPrompt.trim() && attachmentPrefix) {
+        userPrompt = "Please review the attached files.";
+      }
+      if (attachmentPrefix) {
+        userPrompt = `${attachmentPrefix}${userPrompt}`;
+      }
       if (!userPrompt.trim()) {
         await replyChannel.send("Please include a message with your request.");
         return;
@@ -1443,6 +1849,7 @@ ${handoff.agent.prompt}`;
       );
     } finally {
       clearInterval(typingInterval);
+      if (stuckNotifyInterval) clearInterval(stuckNotifyInterval);
     }
   });
   return {
@@ -1468,15 +1875,35 @@ ${handoff.agent.prompt}`;
         [Status.Resuming]: "resuming"
       };
       return statusMap[ws.status] ?? "unknown";
+    },
+    async deliverOrphanResult(projectKey, result) {
+      const threadId = projectKey.includes(":") ? projectKey.split(":")[0] : projectKey;
+      const agentName = projectKey.includes(":") ? projectKey.split(":").pop() : void 0;
+      try {
+        const channel = await client.channels.fetch(threadId);
+        if (!channel || !("send" in channel)) {
+          console.error(`Cannot deliver orphan result: channel ${threadId} not found or not sendable`);
+          return;
+        }
+        let agentRole;
+        if (agentName && channel.isThread() && channel.parentId) {
+          const project = config.projects[channel.parentId];
+          agentRole = project?.agents?.[agentName]?.role;
+        }
+        await channel.send("\u{1F504} Resumed after gateway restart \u2014 here is the pending response:");
+        await sendAgentMessage(channel, result.text, agentName, agentRole);
+      } catch (err) {
+        console.error(`Failed to deliver orphan result to ${threadId}:`, err);
+      }
     }
   };
 }
 
 // src/pulse-events.ts
-import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
+import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
 import { homedir } from "os";
-var DEFAULT_PATH = join3(homedir(), ".pulse", "events", "mpg-sessions.jsonl");
+var DEFAULT_PATH = join4(homedir(), ".pulse", "events", "mpg-sessions.jsonl");
 function baseEvent(eventType, sessionId, projectKey, projectDir) {
   return {
     schema_version: 1,
@@ -1493,7 +1920,7 @@ function createPulseEmitter(filePath) {
   function emit(event) {
     try {
       if (!dirCreated) {
-        mkdirSync2(dirname2(target), { recursive: true });
+        mkdirSync3(dirname2(target), { recursive: true });
         dirCreated = true;
       }
       appendFileSync(target, JSON.stringify(event) + "\n");
@@ -1554,17 +1981,19 @@ function createPulseEmitter(filePath) {
 }
 
 // src/activity-engine.ts
-import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
 import { homedir as homedir2 } from "os";
-var DEFAULT_PATH2 = join4(homedir2(), ".pulse", "events", "mpg-sessions.jsonl");
+var DEFAULT_PATH2 = join5(homedir2(), ".pulse", "events", "mpg-sessions.jsonl");
 var RANGE_MS = {
+  "3h": 3 * 60 * 60 * 1e3,
+  "12h": 12 * 60 * 60 * 1e3,
   "24h": 24 * 60 * 60 * 1e3,
   "7d": 7 * 24 * 60 * 60 * 1e3,
   "30d": 30 * 24 * 60 * 60 * 1e3
 };
 function readEvents(filePath, range) {
-  if (!existsSync2(filePath)) return [];
+  if (!existsSync4(filePath)) return [];
   try {
     const content = readFileSync3(filePath, "utf-8").trim();
     if (!content) return [];
@@ -1586,13 +2015,23 @@ function readEvents(filePath, range) {
 }
 function bucketKey(timestamp, bucket) {
   const d = new Date(timestamp);
-  if (bucket === "hour") {
+  if (bucket === "15min") {
+    d.setMinutes(Math.floor(d.getMinutes() / 15) * 15, 0, 0);
+  } else if (bucket === "hour") {
     d.setMinutes(0, 0, 0);
   } else {
     d.setHours(0, 0, 0, 0);
   }
   return d.toISOString();
 }
+function resolveNameFromDir(projectDir, dirToNameMap) {
+  if (!dirToNameMap || !projectDir) return void 0;
+  if (dirToNameMap[projectDir]) return dirToNameMap[projectDir];
+  for (const [dir, name] of Object.entries(dirToNameMap)) {
+    if (projectDir.startsWith(dir + "/")) return name;
+  }
+  return void 0;
+}
 function createActivityEngine(filePath) {
   const target = filePath ?? DEFAULT_PATH2;
   function getEvents(range, eventType) {
@@ -1615,18 +2054,18 @@ function createActivityEngine(filePath) {
         avg_session_duration_ms: endings.length > 0 ? totalDuration / endings.length : 0
       };
     },
-    tokensByProject(range) {
+    tokensByProject(range, dirToNameMap) {
       const messages = getEvents(range, "message_completed");
       const map = /* @__PURE__ */ new Map();
       for (const e of messages) {
-        const key = e.project_key;
-        const row = map.get(key) ?? { project_key: key, project_dir: e.project_dir, input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cost_usd: 0, message_count: 0 };
+        const name = resolveNameFromDir(e.project_dir, dirToNameMap) ?? e.project_key;
+        const row = map.get(name) ?? { project_name: name, input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cost_usd: 0, message_count: 0 };
         row.input_tokens += Number(e.input_tokens) || 0;
         row.output_tokens += Number(e.output_tokens) || 0;
         row.cache_read_input_tokens += Number(e.cache_read_input_tokens) || 0;
         row.cost_usd += Number(e.total_cost_usd) || 0;
         row.message_count++;
-        map.set(key, row);
+        map.set(name, row);
       }
       return Array.from(map.values());
     },
@@ -1653,6 +2092,17 @@ function createActivityEngine(filePath) {
         const val = valueField ? Number(e[valueField]) || 0 : 1;
         map.set(key, (map.get(key) ?? 0) + val);
       }
+      const now = /* @__PURE__ */ new Date();
+      const start2 = new Date(now.getTime() - RANGE_MS[range]);
+      const stepMs = bucket === "15min" ? 15 * 60 * 1e3 : bucket === "hour" ? 60 * 60 * 1e3 : 24 * 60 * 60 * 1e3;
+      const startKey = bucketKey(start2.toISOString(), bucket);
+      const cursor = new Date(startKey);
+      const endTime = now.getTime();
+      while (cursor.getTime() <= endTime) {
+        const key = cursor.toISOString();
+        if (!map.has(key)) map.set(key, 0);
+        cursor.setTime(cursor.getTime() + stepMs);
+      }
       return Array.from(map.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([b, value]) => ({ bucket: b, value }));
     },
     sessionDurations(range) {
@@ -1689,16 +2139,109 @@ function createActivityEngine(filePath) {
       const messages = getEvents(range, "message_completed");
       const totalInput = messages.reduce((s, e) => s + (Number(e.input_tokens) || 0), 0);
       const cacheRead = messages.reduce((s, e) => s + (Number(e.cache_read_input_tokens) || 0), 0);
+      const denominator = cacheRead + totalInput;
       return {
         total_input_tokens: totalInput,
         cache_read_tokens: cacheRead,
-        cache_hit_ratio: totalInput > 0 ? cacheRead / totalInput : 0
+        cache_hit_ratio: denominator > 0 ? cacheRead / denominator : 0
       };
+    },
+    sessionTimeline(range, projectNameMap, dirToNameMap) {
+      const events = readEvents(target, range);
+      const TIMELINE_TYPES = /* @__PURE__ */ new Set(["session_start", "session_resume", "message_routed", "message_completed", "session_end", "session_idle"]);
+      const relevant = events.filter((e) => TIMELINE_TYPES.has(e.event_type));
+      const completedBySession = /* @__PURE__ */ new Map();
+      for (const e of events) {
+        if (e.event_type === "message_completed") {
+          const list = completedBySession.get(e.session_id);
+          if (list) list.push(e);
+          else completedBySession.set(e.session_id, [e]);
+        }
+      }
+      const sessionMap = /* @__PURE__ */ new Map();
+      for (const e of relevant) {
+        const list = sessionMap.get(e.session_id);
+        if (list) list.push(e);
+        else sessionMap.set(e.session_id, [e]);
+      }
+      const result = [];
+      for (const [sessionId, sessionEvents] of sessionMap) {
+        sessionEvents.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        let persona = "default";
+        const startEvent = sessionEvents.find((e) => e.event_type === "session_start");
+        if (startEvent && startEvent.agent_name) {
+          persona = String(startEvent.agent_name);
+        } else {
+          const routedEvent = sessionEvents.find((e) => e.event_type === "message_routed");
+          if (routedEvent && routedEvent.agent_target) {
+            persona = String(routedEvent.agent_target);
+          }
+        }
+        const projectDir = sessionEvents[0].project_dir;
+        const projectKey = sessionEvents[0].project_key;
+        const channelId = projectKey?.includes(":") ? projectKey.split(":")[0] : projectKey;
+        const projectName = resolveNameFromDir(projectDir, dirToNameMap) ?? (projectNameMap && channelId ? projectNameMap[channelId] : void 0) ?? "unknown";
+        const shortId = channelId ? channelId.slice(-8) : sessionId.substring(0, 8);
+        const label = `${projectName}/${shortId}/${persona}`;
+        const segments = [];
+        let currentState = "idle";
+        let segmentStart = sessionEvents[0].timestamp;
+        for (let i = 1; i < sessionEvents.length; i++) {
+          const e = sessionEvents[i];
+          if (e.event_type === "message_routed" && currentState === "idle") {
+            segments.push({ start: segmentStart, end: e.timestamp, state: "idle" });
+            segmentStart = e.timestamp;
+            currentState = "processing";
+          } else if (e.event_type === "message_completed" && currentState === "processing") {
+            segments.push({ start: segmentStart, end: e.timestamp, state: "processing" });
+            segmentStart = e.timestamp;
+            currentState = "idle";
+          } else if (e.event_type === "session_resume") {
+            if (i > 0) {
+              const prevEvent = sessionEvents[i - 1];
+              if (segmentStart !== prevEvent.timestamp) {
+                segments.push({ start: segmentStart, end: prevEvent.timestamp, state: currentState });
+              }
+            }
+            segmentStart = e.timestamp;
+            currentState = "idle";
+          } else if (e.event_type === "session_end" || e.event_type === "session_idle") {
+            segments.push({ start: segmentStart, end: e.timestamp, state: currentState });
+            segmentStart = e.timestamp;
+          }
+        }
+        const lastEvent = sessionEvents[sessionEvents.length - 1];
+        if (lastEvent.event_type !== "session_end" && lastEvent.event_type !== "session_idle") {
+          if (segmentStart !== lastEvent.timestamp || segments.length === 0) {
+            if (segments.length > 0 || sessionEvents.length > 1) {
+              segments.push({ start: segmentStart, end: lastEvent.timestamp, state: currentState });
+            }
+          }
+        }
+        const completed = completedBySession.get(sessionId) || [];
+        for (const seg of segments) {
+          if (seg.state !== "processing") continue;
+          const segStartMs = new Date(seg.start).getTime();
+          const segEndMs = new Date(seg.end).getTime();
+          const durationSec = (segEndMs - segStartMs) / 1e3;
+          let tokenCount = 0;
+          for (const ev of completed) {
+            const evMs = new Date(ev.timestamp).getTime();
+            if (evMs >= segStartMs && evMs <= segEndMs) {
+              tokenCount += (Number(ev.input_tokens) || 0) + (Number(ev.output_tokens) || 0);
+            }
+          }
+          seg.token_count = tokenCount;
+          seg.token_rate = durationSec > 0 ? Math.round(tokenCount / durationSec) : 0;
+        }
+        result.push({ session_id: sessionId, thread_id: channelId ?? "", label, segments });
+      }
+      return result;
     }
   };
 }
 
-// src/health-server.ts
+// src/dashboard-server.ts
 import { createServer } from "http";
 import { readFileSync as readFileSync4 } from "fs";
 function getVersion() {
@@ -1758,6 +2301,7 @@ function buildDashboardHtml() {
 <div class="tabs">
   <button class="tab active" onclick="switchTab('overview')">Overview</button>
   <button class="tab" onclick="switchTab('activity')">Activity</button>
+  <button class="tab" onclick="switchTab('timeline')">Timeline</button>
 </div>
 
 <div id="tab-overview">
@@ -1810,7 +2354,8 @@ function buildDashboardHtml() {
     <div class="chart-card"><h3>Messages Over Time</h3><canvas id="messages-chart"></canvas></div>
     <div class="chart-card"><h3>Cost Over Time</h3><canvas id="cost-chart"></canvas></div>
     <div class="chart-card"><h3>Sessions Over Time</h3><canvas id="sessions-chart"></canvas></div>
-    <div class="chart-card"><h3>Token Usage Over Time</h3><canvas id="tokens-chart"></canvas></div>
+    <div class="chart-card"><h3>Token Usage Over Time (Input / Output)</h3><canvas id="tokens-chart"></canvas></div>
+    <div class="chart-card"><h3>Cache Read Tokens Over Time</h3><canvas id="cache-chart-time"></canvas></div>
     <div class="chart-card"><h3>Persona Breakdown</h3><canvas id="persona-chart"></canvas></div>
     <div class="chart-card"><h3>Model Breakdown</h3><canvas id="model-chart"></canvas></div>
   </div>
@@ -1822,6 +2367,17 @@ function buildDashboardHtml() {
   <div id="cache-table"></div>
 </div>
 
+<div id="tab-timeline" style="display:none">
+  <div class="range-selector timeline-range">
+    <button class="tl-range-btn range-btn active" data-range="3h">3h</button>
+    <button class="tl-range-btn range-btn" data-range="12h">12h</button>
+    <button class="tl-range-btn range-btn" data-range="24h">24h</button>
+    <button class="tl-range-btn range-btn" data-range="7d">7d</button>
+    <button class="tl-range-btn range-btn" data-range="30d">30d</button>
+  </div>
+  <div class="chart-card"><h3>Session Timeline</h3><canvas id="timeline-chart"></canvas><div id="timeline-tooltip" style="display:none;position:fixed;background:#161b22;border:1px solid #30363d;border-radius:6px;padding:8px 12px;color:#e1e4e8;font-size:12px;pointer-events:none;z-index:100;white-space:nowrap"></div></div>
+</div>
+
 <script>
 function formatUptime(s) {
   if (s < 60) return s + 's';
@@ -1836,6 +2392,19 @@ function formatAgo(ts) {
   if (diff < 3600) return Math.floor(diff / 60) + 'm ago';
   return Math.floor(diff / 3600) + 'h ago';
 }
+function formatDuration(startTs) {
+  var diff = Math.floor((Date.now() - startTs) / 1000);
+  if (diff < 60) return diff + 's';
+  if (diff < 3600) return Math.floor(diff / 60) + 'm';
+  var h = Math.floor(diff / 3600);
+  var m = Math.floor((diff % 3600) / 60);
+  return h + 'h ' + m + 'm';
+}
+function sessionStatus(s) {
+  if (s.processing) return '<span style="color:#3fb950">processing</span>';
+  if (s.queueLength > 0) return '<span style="color:#d29922">waiting</span>';
+  return '<span style="color:#8b949e">idle</span>';
+}
 function statusClass(v) {
   if (v === 'ok' || v === 'connected') return 'status-ok';
   if (v === 'reconnecting') return 'status-warn';
@@ -1846,6 +2415,44 @@ function escapeHtml(s) {
   d.textContent = s;
   return d.innerHTML;
 }
+function compactTokens(n) {
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + 'M';
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + 'K';
+  return String(n);
+}
+function formatLocalTime(isoStr, isHourBucket) {
+  var d = new Date(isoStr);
+  if (isHourBucket) return String(d.getHours()).padStart(2, '0') + ':00';
+  var months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+  return months[d.getMonth()] + ' ' + d.getDate();
+}
+function resolveProjectName(key, nameMap) {
+  if (!key) return '\u2014';
+  var parts = key.split(':');
+  var channelId = parts[0];
+  var agent = parts.length > 1 ? parts[1] : null;
+  var name = (nameMap && nameMap[channelId]) ? nameMap[channelId] : channelId;
+  return agent ? name + ':' + agent : name;
+}
+function resolveProjectNameFromDir(dir, dirMap) {
+  if (!dir || !dirMap) return null;
+  if (dirMap[dir]) return dirMap[dir];
+  var keys = Object.keys(dirMap);
+  for (var i = 0; i < keys.length; i++) {
+    if (dir.indexOf(keys[i] + '/') === 0) return dirMap[keys[i]];
+  }
+  return null;
+}
+function copyToClipboard(text, el) {
+  navigator.clipboard.writeText(text).then(function() {
+    var orig = el.textContent;
+    el.textContent = 'copied!';
+    el.style.color = '#3fb950';
+    setTimeout(function() { el.textContent = orig; el.style.color = ''; }, 1200);
+  });
+}
+
+var projectNameMap = {};
 
 function refresh() {
   fetch('/api/status')
@@ -1862,15 +2469,33 @@ function refresh() {
       discordEl.textContent = d.health.discord;
       discordEl.className = 'card-value ' + statusClass(d.health.discord);
 
-      // Sessions table
+      // Build name maps from projects list
+      var dirToNameMap = {};
+      if (d.projects) {
+        d.projects.forEach(function(p) {
+          if (p.channelId && p.name) projectNameMap[p.channelId] = p.name;
+          if (p.directory && p.name) dirToNameMap[p.directory] = p.name;
+        });
+      }
+
+      // Sessions table \u2014 sort by most recent last activity first
+      d.sessions.sort(function(a, b) {
+        return (b.lastActivity || 0) - (a.lastActivity || 0);
+      });
       var st = document.getElementById('sessions-table');
       if (d.sessions.length === 0) {
         st.innerHTML = '<div class="empty">No active sessions</div>';
       } else {
-        var h = '<table><tr><th>Project</th><th>Session ID</th><th>Last Activity</th><th>Queue</th></tr>';
+        var h = '<table><tr><th>Session</th><th>Status</th><th>Duration</th><th>Last Activity</th></tr>';
         for (var i = 0; i < d.sessions.length; i++) {
           var s = d.sessions[i];
-          h += '<tr><td>' + escapeHtml(s.projectKey) + '</td><td>' + escapeHtml(s.sessionId ? s.sessionId.slice(0, 12) + '...' : '\u2014') + '</td><td>' + formatAgo(s.lastActivity) + '</td><td>' + s.queueLength + '</td></tr>';
+          var sid = s.sessionId || '';
+          var shortId = sid ? sid.slice(0, 8) : '';
+          var pkParts = (s.projectKey || '').split(':');
+          var projName = resolveProjectNameFromDir(s.projectDir || s.cwd, dirToNameMap) || (projectNameMap && projectNameMap[pkParts[0]] ? projectNameMap[pkParts[0]] : null) || pkParts[0];
+          var role = pkParts.length > 1 ? pkParts[1] : '';
+          var sessionLabel = projName && shortId ? (role ? projName + '/' + shortId + '/' + role : projName + '/' + shortId) : (shortId || '\u2014');
+          h += '<tr><td><span class="clickable-id" style="cursor:pointer;text-decoration:underline dotted" title="Click to copy: ' + escapeHtml(sid) + '" onclick="copyToClipboard(\\'' + escapeHtml(sid) + '\\', this)">' + escapeHtml(sessionLabel) + '</span></td><td>' + sessionStatus(s) + '</td><td>' + formatDuration(s.createdAt) + '</td><td>' + formatAgo(s.lastActivity) + '</td></tr>';
         }
         h += '</table>';
         st.innerHTML = h;
@@ -1900,7 +2525,8 @@ refresh();
 setInterval(refresh, 5000);
 
 var chartInstances = {};
-var currentRange = '7d';
+var currentRange = '24h';
+var timelineRange = '3h';
 var CHART_COLORS = ['#58a6ff', '#3fb950', '#d29922', '#f85149', '#bc8cff', '#79c0ff'];
 
 function switchTab(tab) {
@@ -1910,41 +2536,309 @@ function switchTab(tab) {
   });
   document.getElementById('tab-overview').style.display = tab === 'overview' ? '' : 'none';
   document.getElementById('tab-activity').style.display = tab === 'activity' ? '' : 'none';
+  document.getElementById('tab-timeline').style.display = tab === 'timeline' ? '' : 'none';
   if (tab === 'activity') refreshActivity();
+  if (tab === 'timeline') refreshTimeline();
 }
 
-document.querySelectorAll('.range-btn').forEach(function(btn) {
+document.querySelectorAll('#tab-activity .range-btn').forEach(function(btn) {
   btn.addEventListener('click', function() {
-    document.querySelectorAll('.range-btn').forEach(function(b) { b.classList.remove('active'); });
+    document.querySelectorAll('#tab-activity .range-btn').forEach(function(b) { b.classList.remove('active'); });
     btn.classList.add('active');
     currentRange = btn.dataset.range;
     refreshActivity();
   });
 });
 
+document.querySelectorAll('.tl-range-btn').forEach(function(btn) {
+  btn.addEventListener('click', function() {
+    document.querySelectorAll('.tl-range-btn').forEach(function(b) { b.classList.remove('active'); });
+    btn.classList.add('active');
+    timelineRange = btn.dataset.range;
+    refreshTimeline();
+  });
+});
+
 function destroyChart(key) {
   if (chartInstances[key]) { chartInstances[key].destroy(); chartInstances[key] = null; }
 }
 
+function timeAxisOptions(isHourBucket) {
+  return {
+    ticks: {
+      color: '#8b949e',
+      callback: function(value, index, ticks) {
+        var label = this.getLabelForValue(value);
+        return formatLocalTime(label, isHourBucket);
+      }
+    },
+    grid: { color: '#30363d' }
+  };
+}
+
+function formatSegmentDuration(startIso, endIso) {
+  var ms = new Date(endIso).getTime() - new Date(startIso).getTime();
+  if (ms < 1000) return ms + 'ms';
+  var s = Math.floor(ms / 1000);
+  if (s < 60) return s + 's';
+  var m = Math.floor(s / 60);
+  s = s % 60;
+  if (m < 60) return m + 'm ' + s + 's';
+  var h = Math.floor(m / 60);
+  m = m % 60;
+  return h + 'h ' + m + 'm';
+}
+
+var _tlHitRects = [];
+
+function refreshTimeline() {
+  var RANGE_MS = { '3h': 10800000, '12h': 43200000, '24h': 86400000, '7d': 604800000, '30d': 2592000000 };
+  var now = Date.now();
+  var rangeMs = RANGE_MS[timelineRange] || RANGE_MS['3h'];
+  var xMin = now - rangeMs;
+  var xMax = now;
+
+  fetch('/api/activity/timeline?range=' + timelineRange)
+    .then(function(r) { return r.json(); })
+    .then(function(sessions) {
+      var canvas = document.getElementById('timeline-chart');
+      var dpr = window.devicePixelRatio || 1;
+      var containerW = canvas.parentElement.clientWidth - 32;
+
+      // Filter out sessions with only idle segments (no processing)
+      var activeSessions = sessions ? sessions.filter(function(s) {
+        return s.segments.some(function(seg) { return seg.state === 'processing'; });
+      }) : [];
+
+      var LABEL_W = 160;
+      var ROW_H = 32;
+      var HEADER_H = 28;
+      var FOOTER_H = 8;
+      var chartW = containerW;
+
+      if (!activeSessions.length) {
+        var h = 60;
+        canvas.width = Math.floor(chartW * dpr);
+        canvas.height = Math.floor(h * dpr);
+        canvas.style.width = chartW + 'px';
+        canvas.style.height = h + 'px';
+        var c = canvas.getContext('2d');
+        c.setTransform(dpr, 0, 0, dpr, 0, 0);
+        c.fillStyle = '#0d1117';
+        c.fillRect(0, 0, chartW, h);
+        c.fillStyle = '#8b949e';
+        c.font = '13px -apple-system, sans-serif';
+        c.textAlign = 'center';
+        c.fillText('No active sessions in range', chartW / 2, h / 2 + 4);
+        _tlHitRects = [];
+        return;
+      }
+
+      var LEGEND_H = 28;
+      var totalH = HEADER_H + activeSessions.length * ROW_H + FOOTER_H + LEGEND_H;
+      canvas.width = Math.floor(chartW * dpr);
+      canvas.height = Math.floor(totalH * dpr);
+      canvas.style.width = chartW + 'px';
+      canvas.style.height = totalH + 'px';
+      var ctx = canvas.getContext('2d');
+      ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+
+      // Background
+      ctx.fillStyle = '#0d1117';
+      ctx.fillRect(0, 0, chartW, totalH);
+
+      var plotLeft = LABEL_W;
+      var plotRight = chartW - 12;
+      var plotW = plotRight - plotLeft;
+
+      function timeToX(t) {
+        return plotLeft + ((t - xMin) / (xMax - xMin)) * plotW;
+      }
+
+      // X-axis time labels at top
+      ctx.fillStyle = '#8b949e';
+      ctx.font = '10px -apple-system, sans-serif';
+      ctx.textAlign = 'center';
+      var tickCount = Math.max(2, Math.min(8, Math.floor(plotW / 90)));
+      for (var ti = 0; ti <= tickCount; ti++) {
+        var t = xMin + (ti / tickCount) * (xMax - xMin);
+        var tx = timeToX(t);
+        var d = new Date(t);
+        var months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+        var lbl = months[d.getMonth()] + ' ' + d.getDate() + ' ' + String(d.getHours()).padStart(2,'0') + ':' + String(d.getMinutes()).padStart(2,'0');
+        ctx.fillText(lbl, tx, 14);
+        // Grid line
+        ctx.strokeStyle = '#30363d';
+        ctx.lineWidth = 0.5;
+        ctx.beginPath();
+        ctx.moveTo(tx, HEADER_H);
+        ctx.lineTo(tx, totalH - FOOTER_H);
+        ctx.stroke();
+      }
+
+      _tlHitRects = [];
+
+      // Compute maxTokenRate across all visible processing segments for normalization
+      var maxTokenRate = 0;
+      for (var mi = 0; mi < activeSessions.length; mi++) {
+        for (var mj = 0; mj < activeSessions[mi].segments.length; mj++) {
+          var mseg = activeSessions[mi].segments[mj];
+          if (mseg.state === 'processing' && mseg.token_rate > maxTokenRate) {
+            maxTokenRate = mseg.token_rate;
+          }
+        }
+      }
+
+      function tokenRateColor(rate) {
+        if (!maxTokenRate || !rate) return 'hsl(220, 40%, 55%)';
+        var t = Math.min(rate / maxTokenRate, 1);
+        // Interpolate: low rate \u2192 cool blue, high rate \u2192 warm orange
+        var hue = 220 - t * 190;   // 220 (blue) \u2192 30 (orange)
+        var sat = 40 + t * 40;     // 40% \u2192 80%
+        var light = 55 - t * 15;   // 55% \u2192 40%
+        return 'hsl(' + hue + ', ' + sat + '%, ' + light + '%)';
+      }
+
+      for (var ri = 0; ri < activeSessions.length; ri++) {
+        var sess = activeSessions[ri];
+        var rowY = HEADER_H + ri * ROW_H;
+        var barY = rowY + 6;
+        var barH = ROW_H - 12;
+
+        // Y-axis label
+        ctx.fillStyle = '#8b949e';
+        ctx.font = '11px monospace';
+        ctx.textAlign = 'right';
+        ctx.fillText(sess.label, LABEL_W - 8, rowY + ROW_H / 2 + 4);
+
+        // Row separator
+        ctx.strokeStyle = '#21262d';
+        ctx.lineWidth = 0.5;
+        ctx.beginPath();
+        ctx.moveTo(plotLeft, rowY + ROW_H);
+        ctx.lineTo(plotRight, rowY + ROW_H);
+        ctx.stroke();
+
+        // Draw segments
+        for (var si = 0; si < sess.segments.length; si++) {
+          var seg = sess.segments[si];
+          var segStart = Math.max(new Date(seg.start).getTime(), xMin);
+          var segEnd = Math.min(new Date(seg.end).getTime(), xMax);
+          if (segStart >= segEnd) continue;
+
+          var x1 = timeToX(segStart);
+          var x2 = timeToX(segEnd);
+          var w = Math.max(x2 - x1, 1);
+
+          ctx.fillStyle = seg.state === 'processing' ? tokenRateColor(seg.token_rate || 0) : '#484f58';
+          ctx.fillRect(x1, barY, w, barH);
+
+          _tlHitRects.push({ x: x1, y: barY, w: w, h: barH, label: sess.label, state: seg.state, start: seg.start, end: seg.end, token_count: seg.token_count || 0, token_rate: seg.token_rate || 0 });
+        }
+      }
+
+      // Draw intensity legend below the chart
+      if (maxTokenRate > 0) {
+        var lgX = plotLeft;
+        var lgY = totalH - LEGEND_H + 4;
+        var lgW = 120;
+        var lgH = 10;
+
+        ctx.fillStyle = '#8b949e';
+        ctx.font = '10px -apple-system, sans-serif';
+        ctx.textAlign = 'left';
+        ctx.fillText('Token rate:', lgX, lgY + 9);
+
+        var gradX = lgX + 68;
+        // Draw gradient bar
+        for (var gi = 0; gi < lgW; gi++) {
+          var gt = gi / lgW;
+          var gHue = 220 - gt * 190;   // blue \u2192 orange
+          var gSat = 40 + gt * 40;
+          var gLight = 55 - gt * 15;
+          ctx.fillStyle = 'hsl(' + gHue + ', ' + gSat + '%, ' + gLight + '%)';
+          ctx.fillRect(gradX + gi, lgY + 1, 1, lgH);
+        }
+
+        ctx.fillStyle = '#8b949e';
+        ctx.font = '9px -apple-system, sans-serif';
+        ctx.textAlign = 'left';
+        ctx.fillText('0', gradX, lgY + 22);
+        ctx.textAlign = 'right';
+        ctx.fillText(compactTokens(maxTokenRate) + '/s', gradX + lgW, lgY + 22);
+
+        // Idle swatch
+        var idleX = gradX + lgW + 16;
+        ctx.fillStyle = '#484f58';
+        ctx.fillRect(idleX, lgY + 1, lgH, lgH);
+        ctx.fillStyle = '#8b949e';
+        ctx.font = '9px -apple-system, sans-serif';
+        ctx.textAlign = 'left';
+        ctx.fillText('Idle', idleX + lgH + 4, lgY + 9);
+      }
+    })
+    .catch(function(err) { console.error('Timeline fetch error:', err); });
+}
+
+// Timeline tooltip via mousemove
+(function() {
+  var canvas = document.getElementById('timeline-chart');
+  var tooltip = document.getElementById('timeline-tooltip');
+  canvas.addEventListener('mousemove', function(e) {
+    var rect = canvas.getBoundingClientRect();
+    var dpr = window.devicePixelRatio || 1;
+    var mx = (e.clientX - rect.left);
+    var my = (e.clientY - rect.top);
+    var hit = null;
+    for (var i = _tlHitRects.length - 1; i >= 0; i--) {
+      var r = _tlHitRects[i];
+      if (mx >= r.x && mx <= r.x + r.w && my >= r.y && my <= r.y + r.h) { hit = r; break; }
+    }
+    if (hit) {
+      var state = hit.state.charAt(0).toUpperCase() + hit.state.slice(1);
+      var tokenInfo = '';
+      if (hit.state === 'processing' && hit.token_count > 0) {
+        tokenInfo = '<br>Tokens: ' + compactTokens(hit.token_count) + ' (' + compactTokens(hit.token_rate) + ' tok/s)';
+      }
+      tooltip.innerHTML = '<strong>' + hit.label + '</strong><br>' + state + ': ' + formatSegmentDuration(hit.start, hit.end) + tokenInfo;
+      tooltip.style.display = 'block';
+      tooltip.style.left = (e.clientX + 12) + 'px';
+      tooltip.style.top = (e.clientY - 10) + 'px';
+    } else {
+      tooltip.style.display = 'none';
+    }
+  });
+  canvas.addEventListener('mouseleave', function() {
+    tooltip.style.display = 'none';
+  });
+})();
+
 function refreshActivity() {
+  var isHourBucket = currentRange === '24h';
   fetch('/api/activity/summary?range=' + currentRange)
     .then(function(r) { return r.json(); })
     .then(function(d) {
+      var nameMap = d.project_name_map || {};
+      // Merge into global map
+      Object.keys(nameMap).forEach(function(k) { projectNameMap[k] = nameMap[k]; });
+
       // Summary cards
       var s = d.summary;
       document.getElementById('total-cost').textContent = '$' + s.total_cost_usd.toFixed(2);
       var totalTok = s.total_input_tokens + s.total_output_tokens;
-      document.getElementById('total-tokens').textContent = totalTok > 1e6 ? (totalTok / 1e6).toFixed(1) + 'M' : totalTok > 1e3 ? (totalTok / 1e3).toFixed(1) + 'k' : String(totalTok);
+      document.getElementById('total-tokens').textContent = compactTokens(totalTok);
       document.getElementById('total-sessions-card').textContent = String(s.total_sessions);
       document.getElementById('total-messages').textContent = String(s.total_messages);
       document.getElementById('avg-duration').textContent = Math.round(s.avg_session_duration_ms / 60000) + 'm';
 
-      // Messages Over Time (bar)
+      var xOpts = timeAxisOptions(isHourBucket);
+
+      // Messages Over Time (line)
       destroyChart('messages');
       chartInstances['messages'] = new Chart(document.getElementById('messages-chart'), {
-        type: 'bar',
-        data: { labels: d.messages_over_time.map(function(e) { return e.bucket; }), datasets: [{ label: 'Messages', data: d.messages_over_time.map(function(e) { return e.value; }), backgroundColor: '#58a6ff' }] },
-        options: { scales: { y: { beginAtZero: true, ticks: { color: '#8b949e' }, grid: { color: '#30363d' } }, x: { ticks: { color: '#8b949e' }, grid: { color: '#30363d' } } }, plugins: { legend: { display: false } } }
+        type: 'line',
+        data: { labels: d.messages_over_time.map(function(e) { return e.bucket; }), datasets: [{ label: 'Messages', data: d.messages_over_time.map(function(e) { return e.value; }), borderColor: '#58a6ff', tension: 0.3 }] },
+        options: { scales: { y: { beginAtZero: true, ticks: { color: '#8b949e' }, grid: { color: '#30363d' } }, x: xOpts }, plugins: { legend: { display: false } } }
       });
 
       // Cost Over Time (line)
@@ -1952,23 +2846,43 @@ function refreshActivity() {
       chartInstances['cost'] = new Chart(document.getElementById('cost-chart'), {
         type: 'line',
         data: { labels: d.cost_over_time.map(function(e) { return e.bucket; }), datasets: [{ label: 'Cost ($)', data: d.cost_over_time.map(function(e) { return e.value; }), borderColor: '#3fb950', tension: 0.3 }] },
-        options: { scales: { y: { beginAtZero: true, ticks: { color: '#8b949e' }, grid: { color: '#30363d' } }, x: { ticks: { color: '#8b949e' }, grid: { color: '#30363d' } } }, plugins: { legend: { display: false } } }
+        options: { scales: { y: { beginAtZero: true, ticks: { color: '#8b949e' }, grid: { color: '#30363d' } }, x: xOpts }, plugins: { legend: { display: false } } }
       });
 
-      // Sessions Over Time (bar)
+      // Sessions Over Time (line)
       destroyChart('sessions');
       chartInstances['sessions'] = new Chart(document.getElementById('sessions-chart'), {
-        type: 'bar',
-        data: { labels: d.sessions_over_time.map(function(e) { return e.bucket; }), datasets: [{ label: 'Sessions', data: d.sessions_over_time.map(function(e) { return e.value; }), backgroundColor: '#d29922' }] },
-        options: { scales: { y: { beginAtZero: true, ticks: { color: '#8b949e', stepSize: 1 }, grid: { color: '#30363d' } }, x: { ticks: { color: '#8b949e' }, grid: { color: '#30363d' } } }, plugins: { legend: { display: false } } }
+        type: 'line',
+        data: { labels: d.sessions_over_time.map(function(e) { return e.bucket; }), datasets: [{ label: 'Sessions', data: d.sessions_over_time.map(function(e) { return e.value; }), borderColor: '#d29922', tension: 0.3 }] },
+        options: { scales: { y: { beginAtZero: true, ticks: { color: '#8b949e', stepSize: 1 }, grid: { color: '#30363d' } }, x: xOpts }, plugins: { legend: { display: false } } }
       });
 
-      // Token Usage Over Time (stacked bar)
+      // Token Usage Over Time \u2014 Input + Output stacked (NO cache reads)
+      var allBuckets = {};
+      (d.input_tokens_over_time || []).forEach(function(e) { allBuckets[e.bucket] = true; });
+      (d.output_tokens_over_time || []).forEach(function(e) { allBuckets[e.bucket] = true; });
+      var bucketKeys = Object.keys(allBuckets).sort();
+      var inputMap = {}; (d.input_tokens_over_time || []).forEach(function(e) { inputMap[e.bucket] = e.value; });
+      var outputMap = {}; (d.output_tokens_over_time || []).forEach(function(e) { outputMap[e.bucket] = e.value; });
       destroyChart('tokens');
       chartInstances['tokens'] = new Chart(document.getElementById('tokens-chart'), {
         type: 'bar',
-        data: { labels: d.tokens_over_time.map(function(e) { return e.bucket; }), datasets: [{ label: 'Input Tokens', data: d.tokens_over_time.map(function(e) { return e.value; }), backgroundColor: '#58a6ff' }] },
-        options: { scales: { y: { beginAtZero: true, ticks: { color: '#8b949e' }, grid: { color: '#30363d' } }, x: { ticks: { color: '#8b949e' }, grid: { color: '#30363d' } } }, plugins: { legend: { labels: { color: '#8b949e' } } } }
+        data: {
+          labels: bucketKeys,
+          datasets: [
+            { label: 'Input', data: bucketKeys.map(function(k) { return inputMap[k] || 0; }), backgroundColor: '#58a6ff' },
+            { label: 'Output', data: bucketKeys.map(function(k) { return outputMap[k] || 0; }), backgroundColor: '#3fb950' }
+          ]
+        },
+        options: { scales: { y: { beginAtZero: true, stacked: true, ticks: { color: '#8b949e', callback: function(v) { return compactTokens(v); } }, grid: { color: '#30363d' } }, x: Object.assign({}, xOpts, { stacked: true }) }, plugins: { legend: { labels: { color: '#8b949e' } } } }
+      });
+
+      // Cache Read Tokens Over Time \u2014 separate chart
+      destroyChart('cache-time');
+      chartInstances['cache-time'] = new Chart(document.getElementById('cache-chart-time'), {
+        type: 'bar',
+        data: { labels: (d.cache_read_over_time || []).map(function(e) { return e.bucket; }), datasets: [{ label: 'Cache Read', data: (d.cache_read_over_time || []).map(function(e) { return e.value; }), backgroundColor: '#bc8cff' }] },
+        options: { scales: { y: { beginAtZero: true, ticks: { color: '#8b949e', callback: function(v) { return compactTokens(v); } }, grid: { color: '#30363d' } }, x: xOpts }, plugins: { legend: { display: false } } }
       });
 
       // Persona Breakdown (doughnut)
@@ -1991,28 +2905,31 @@ function refreshActivity() {
         });
       }
 
-      // Token Usage by Project table
+      // Token Usage by Project table \u2014 resolve names, compact token notation
       var pt = document.getElementById('project-table');
       if (d.tokens_by_project.length === 0) { pt.innerHTML = '<div class="empty">No data</div>'; }
       else {
         var h = '<table><tr><th>Project</th><th>Input</th><th>Output</th><th>Cache Read</th><th>Cost</th><th>Messages</th></tr>';
-        d.tokens_by_project.forEach(function(p) { h += '<tr><td>' + escapeHtml(p.project_key) + '</td><td>' + p.input_tokens.toLocaleString() + '</td><td>' + p.output_tokens.toLocaleString() + '</td><td>' + p.cache_read_input_tokens.toLocaleString() + '</td><td>$' + p.cost_usd.toFixed(3) + '</td><td>' + p.message_count + '</td></tr>'; });
+        d.tokens_by_project.forEach(function(p) { h += '<tr><td>' + escapeHtml(p.project_name || 'unknown') + '</td><td>' + compactTokens(p.input_tokens) + '</td><td>' + compactTokens(p.output_tokens) + '</td><td>' + compactTokens(p.cache_read_input_tokens) + '</td><td>$' + p.cost_usd.toFixed(3) + '</td><td>' + p.message_count + '</td></tr>'; });
         pt.innerHTML = h + '</table>';
       }
 
-      // Token Usage by Session table
+      // Token Usage by Session table \u2014 resolve names, copy-to-clipboard session IDs
       var st = document.getElementById('session-table');
       if (d.tokens_by_session.length === 0) { st.innerHTML = '<div class="empty">No data</div>'; }
       else {
         var h2 = '<table><tr><th>Session</th><th>Project</th><th>Input</th><th>Output</th><th>Cost</th><th>Msgs</th><th>Duration</th></tr>';
-        d.tokens_by_session.forEach(function(row) { h2 += '<tr><td>' + escapeHtml(row.session_id.substring(0, 8)) + '</td><td>' + escapeHtml(row.project_key) + '</td><td>' + row.input_tokens.toLocaleString() + '</td><td>' + row.output_tokens.toLocaleString() + '</td><td>$' + row.cost_usd.toFixed(3) + '</td><td>' + row.message_count + '</td><td>' + Math.round(row.duration_ms / 60000) + 'm</td></tr>'; });
+        d.tokens_by_session.forEach(function(row) {
+          var shortId = row.session_id.substring(0, 8) + '...';
+          h2 += '<tr><td><span class="clickable-id" style="cursor:pointer;text-decoration:underline dotted" title="Click to copy: ' + escapeHtml(row.session_id) + '" onclick="copyToClipboard(\\'' + escapeHtml(row.session_id) + '\\', this)">' + escapeHtml(shortId) + '</span></td><td>' + escapeHtml(resolveProjectName(row.project_key, nameMap)) + '</td><td>' + compactTokens(row.input_tokens) + '</td><td>' + compactTokens(row.output_tokens) + '</td><td>$' + row.cost_usd.toFixed(3) + '</td><td>' + row.message_count + '</td><td>' + Math.round(row.duration_ms / 60000) + 'm</td></tr>';
+        });
         st.innerHTML = h2 + '</table>';
       }
 
       // Cache Efficiency table
       var ct = document.getElementById('cache-table');
       var ce = d.cache_efficiency;
-      ct.innerHTML = '<table><tr><th>Total Input</th><th>Cache Read</th><th>Hit Ratio</th></tr><tr><td>' + ce.total_input_tokens.toLocaleString() + '</td><td>' + ce.cache_read_tokens.toLocaleString() + '</td><td>' + (ce.cache_hit_ratio * 100).toFixed(1) + '%</td></tr></table>';
+      ct.innerHTML = '<table><tr><th>Total Input</th><th>Cache Read</th><th>Hit Ratio</th></tr><tr><td>' + compactTokens(ce.total_input_tokens) + '</td><td>' + compactTokens(ce.cache_read_tokens) + '</td><td>' + (ce.cache_hit_ratio * 100).toFixed(1) + '%</td></tr></table>';
     })
     .catch(function(err) { console.error('Activity fetch error:', err); });
 }
@@ -2021,12 +2938,15 @@ setInterval(function() {
   if (document.getElementById('tab-activity').style.display !== 'none') {
     refreshActivity();
   }
+  if (document.getElementById('tab-timeline').style.display !== 'none') {
+    refreshTimeline();
+  }
 }, 30000);
 </script>
 </body>
 </html>`;
 }
-function createHealthServer(port, sessionManager, bot, config, options) {
+function createDashboardServer(port, sessionManager, bot, config, options) {
   const startTime = Date.now();
   const version2 = getVersion();
   const dashboardHtml = buildDashboardHtml();
@@ -2087,6 +3007,38 @@ function createHealthServer(port, sessionManager, bot, config, options) {
       res.end(body);
       return;
     }
+    if (pathname === "/api/activity/timeline") {
+      const url = new URL(req.url ?? "/", `http://localhost`);
+      const rangeParam = url.searchParams.get("range") || "7d";
+      if (rangeParam !== "3h" && rangeParam !== "12h" && rangeParam !== "24h" && rangeParam !== "7d" && rangeParam !== "30d") {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid range. Must be 3h, 12h, 24h, 7d, or 30d" }));
+        return;
+      }
+      const engine = options?.activityEngine;
+      if (!engine) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify([]));
+        return;
+      }
+      try {
+        const projectNameMap = {};
+        const dirToNameMap = {};
+        if (config) {
+          for (const [channelId, project] of Object.entries(config.projects)) {
+            projectNameMap[channelId] = project.name;
+            dirToNameMap[project.directory] = project.name;
+          }
+        }
+        const data = engine.sessionTimeline(rangeParam, projectNameMap, dirToNameMap);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(data));
+      } catch {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Failed to compute timeline data" }));
+      }
+      return;
+    }
     if (pathname === "/api/activity/summary") {
       const url = new URL(req.url ?? "/", `http://localhost`);
       const rangeParam = url.searchParams.get("range") || "7d";
@@ -2107,27 +3059,43 @@ function createHealthServer(port, sessionManager, bot, config, options) {
           sessions_over_time: [],
           messages_over_time: [],
           cost_over_time: [],
-          tokens_over_time: [],
+          input_tokens_over_time: [],
+          output_tokens_over_time: [],
+          cache_read_over_time: [],
           session_durations: [],
           model_breakdown: [],
           persona_breakdown: [],
-          cache_efficiency: { total_input_tokens: 0, cache_read_tokens: 0, cache_hit_ratio: 0 }
+          cache_efficiency: { total_input_tokens: 0, cache_read_tokens: 0, cache_hit_ratio: 0 },
+          project_name_map: {},
+          dir_to_name_map: {}
         }));
         return;
       }
       try {
+        const projectNameMap = {};
+        const dirToNameMap = {};
+        if (config) {
+          for (const [channelId, project] of Object.entries(config.projects)) {
+            projectNameMap[channelId] = project.name;
+            dirToNameMap[project.directory] = project.name;
+          }
+        }
         const data = {
           summary: engine.computeSummary(range),
-          tokens_by_project: engine.tokensByProject(range),
+          tokens_by_project: engine.tokensByProject(range, dirToNameMap),
           tokens_by_session: engine.tokensBySession(range),
           sessions_over_time: engine.bucketed(range, bucket, "session_start"),
           messages_over_time: engine.bucketed(range, bucket, "message_completed"),
           cost_over_time: engine.bucketed(range, bucket, "message_completed", "total_cost_usd"),
-          tokens_over_time: engine.bucketed(range, bucket, "message_completed", "input_tokens"),
+          input_tokens_over_time: engine.bucketed(range, bucket, "message_completed", "input_tokens"),
+          output_tokens_over_time: engine.bucketed(range, bucket, "message_completed", "output_tokens"),
+          cache_read_over_time: engine.bucketed(range, bucket, "message_completed", "cache_read_input_tokens"),
           session_durations: engine.sessionDurations(range),
           model_breakdown: engine.modelBreakdown(range),
           persona_breakdown: engine.personaBreakdown(range),
-          cache_efficiency: engine.cacheEfficiency(range)
+          cache_efficiency: engine.cacheEfficiency(range),
+          project_name_map: projectNameMap,
+          dir_to_name_map: dirToNameMap
         };
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify(data));
@@ -2145,11 +3113,11 @@ function createHealthServer(port, sessionManager, bot, config, options) {
     res.writeHead(404, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ error: "Not Found" }));
   });
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     server.on("error", reject);
     server.listen(port, () => {
-      console.log(`Health endpoint listening on http://localhost:${port}/health`);
-      resolve5({
+      console.log(`Dashboard server listening on http://localhost:${port}/`);
+      resolve6({
         close() {
           return new Promise((res, rej) => {
             server.close((err) => err ? rej(err) : res());
@@ -2181,74 +3149,74 @@ function createTurnCounter() {
 
 // src/init.ts
 import { createInterface } from "readline";
-import { writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
-import { resolve as resolve2 } from "path";
+import { writeFileSync as writeFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { resolve as resolve3 } from "path";
 import { execSync } from "child_process";
 
 // src/resolve-home.ts
-import { resolve, dirname as dirname3 } from "path";
-import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve2, dirname as dirname3 } from "path";
+import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir3 } from "os";
 function resolveMpgHome() {
-  return process.env.MPG_HOME ?? resolve(homedir3(), ".mpg");
+  return process.env.MPG_HOME ?? resolve2(homedir3(), ".mpg");
 }
 function resolveProfileDir(profile) {
-  return resolve(resolveMpgHome(), "profiles", profile);
+  return resolve2(resolveMpgHome(), "profiles", profile);
 }
 function resolveEnvPath() {
   const mpgHome = resolveMpgHome();
-  const mpgEnv = resolve(mpgHome, ".env");
-  if (existsSync3(mpgEnv)) {
+  const mpgEnv = resolve2(mpgHome, ".env");
+  if (existsSync5(mpgEnv)) {
     return mpgEnv;
   }
-  const cwdEnv = resolve(process.cwd(), ".env");
-  if (existsSync3(cwdEnv)) {
+  const cwdEnv = resolve2(process.cwd(), ".env");
+  if (existsSync5(cwdEnv)) {
     return cwdEnv;
   }
   return void 0;
 }
 function resolveConfigPath(options) {
   if (options?.configFlag) {
-    const explicit = resolve(options.configFlag);
-    if (existsSync3(explicit)) {
+    const explicit = resolve2(options.configFlag);
+    if (existsSync5(explicit)) {
       return explicit;
     }
     return explicit;
   }
   if (options?.profileFlag) {
-    const profileConfig = resolve(
+    const profileConfig = resolve2(
       resolveProfileDir(options.profileFlag),
       "config.json"
     );
-    if (existsSync3(profileConfig)) {
+    if (existsSync5(profileConfig)) {
       return profileConfig;
     }
     return profileConfig;
   }
   const mpgHome = resolveMpgHome();
-  const defaultConfig = resolve(mpgHome, "profiles", "default", "config.json");
-  if (existsSync3(defaultConfig)) {
+  const defaultConfig = resolve2(mpgHome, "profiles", "default", "config.json");
+  if (existsSync5(defaultConfig)) {
     return defaultConfig;
   }
-  const cwdConfig = resolve(process.cwd(), "config.json");
-  if (existsSync3(cwdConfig)) {
+  const cwdConfig = resolve2(process.cwd(), "config.json");
+  if (existsSync5(cwdConfig)) {
     return cwdConfig;
   }
   return void 0;
 }
 function resolveSessionsPath(configPath) {
-  return resolve(dirname3(configPath), "sessions.json");
+  return resolve2(dirname3(configPath), "sessions.json");
 }
 function resolvePidPath(profile) {
   const name = !profile || profile === "default" ? "mpg" : `mpg-${profile}`;
-  return resolve(resolveMpgHome(), `${name}.pid`);
+  return resolve2(resolveMpgHome(), `${name}.pid`);
 }
 function resolveLogDir() {
-  return resolve(resolveMpgHome(), "logs");
+  return resolve2(resolveMpgHome(), "logs");
 }
 function resolveLogPath(profile) {
   const name = !profile || profile === "default" ? "mpg" : `mpg-${profile}`;
-  return resolve(resolveLogDir(), `${name}.log`);
+  return resolve2(resolveLogDir(), `${name}.log`);
 }
 function parseFlags(argv) {
   const result = {};
@@ -2277,7 +3245,7 @@ function parseFlags(argv) {
 // src/init.ts
 function createPrompt() {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return (question) => new Promise((resolve5) => rl.question(question, (answer) => resolve5(answer.trim())));
+  return (question) => new Promise((resolve6) => rl.question(question, (answer) => resolve6(answer.trim())));
 }
 async function runInit(profile) {
   const ask = createPrompt();
@@ -2286,8 +3254,8 @@ async function runInit(profile) {
   if (profile) {
     configDir = resolveProfileDir(profile);
     envDir = resolveMpgHome();
-    mkdirSync3(configDir, { recursive: true });
-    mkdirSync3(envDir, { recursive: true });
+    mkdirSync4(configDir, { recursive: true });
+    mkdirSync4(envDir, { recursive: true });
     console.log(`
 mpg init \u2014 set up profile "${profile}"
 `);
@@ -2312,13 +3280,13 @@ mpg init \u2014 set up profile "${profile}"
     console.error("A Discord bot token is required. Create one at https://discord.com/developers/applications");
     process.exit(1);
   }
-  const envPath = resolve2(envDir, ".env");
+  const envPath = resolve3(envDir, ".env");
   writeFileSync2(envPath, `DISCORD_BOT_TOKEN=${token}
 `);
   console.log(`Wrote ${envPath}`);
   const projects = [];
-  const configPath = resolve2(configDir, "config.json");
-  if (existsSync4(configPath)) {
+  const configPath = resolve3(configDir, "config.json");
+  if (existsSync6(configPath)) {
     try {
       const existing = JSON.parse(
         (await import("fs")).readFileSync(configPath, "utf-8")
@@ -2348,7 +3316,7 @@ Existing projects (${projects.length}):`);
       console.log("Directory is required, skipping.");
       continue;
     }
-    if (!existsSync4(directory)) {
+    if (!existsSync6(directory)) {
       console.warn(`Warning: ${directory} does not exist.`);
     }
     const channelId = await ask("Discord channel ID: ");
@@ -2379,11 +3347,11 @@ Existing projects (${projects.length}):`);
 }
 
 // src/health.ts
-import { statSync } from "fs";
-import { execFileSync as execFileSync2 } from "child_process";
+import { statSync as statSync2 } from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
 function runHealthChecks(config) {
   try {
-    execFileSync2("claude", ["--version"], { timeout: 5e3, stdio: "ignore" });
+    execFileSync3("claude", ["--version"], { timeout: 5e3, stdio: "ignore" });
   } catch {
     console.error(
       'Health check failed:\n  \u2717 "claude" CLI not found on PATH. Install: https://docs.anthropic.com/en/docs/claude-code'
@@ -2394,7 +3362,7 @@ function runHealthChecks(config) {
   const missing = [];
   for (const project of Object.values(config.projects)) {
     try {
-      if (!statSync(project.directory).isDirectory()) {
+      if (!statSync2(project.directory).isDirectory()) {
         missing.push(`  \u2717 Project "${project.name}" path is not a directory: ${project.directory}`);
       }
     } catch {
@@ -2408,10 +3376,10 @@ function runHealthChecks(config) {
 }
 
 // src/pid.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, unlinkSync, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, unlinkSync, mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname4 } from "path";
 function writePid(pidPath, pid = process.pid) {
-  mkdirSync4(dirname4(pidPath), { recursive: true });
+  mkdirSync5(dirname4(pidPath), { recursive: true });
   writeFileSync3(pidPath, `${pid}
 `);
 }
@@ -2451,14 +3419,14 @@ function checkPidFile(pidPath) {
 }
 
 // src/file-logger.ts
-import { appendFileSync as appendFileSync2, renameSync, unlinkSync as unlinkSync2, existsSync as existsSync5, mkdirSync as mkdirSync5, statSync as statSync2 } from "fs";
+import { appendFileSync as appendFileSync2, renameSync, unlinkSync as unlinkSync2, existsSync as existsSync7, mkdirSync as mkdirSync6, statSync as statSync3 } from "fs";
 import { dirname as dirname5 } from "path";
 var DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
 var DEFAULT_MAX_FILES = 5;
 function rotateLog(logPath, maxFiles = DEFAULT_MAX_FILES) {
-  if (!existsSync5(logPath)) return;
+  if (!existsSync7(logPath)) return;
   const oldest = `${logPath}.${maxFiles}`;
-  if (existsSync5(oldest)) {
+  if (existsSync7(oldest)) {
     try {
       unlinkSync2(oldest);
     } catch {
@@ -2467,7 +3435,7 @@ function rotateLog(logPath, maxFiles = DEFAULT_MAX_FILES) {
   for (let i = maxFiles - 1; i >= 1; i--) {
     const from = `${logPath}.${i}`;
     const to = `${logPath}.${i + 1}`;
-    if (existsSync5(from)) {
+    if (existsSync7(from)) {
       try {
         renameSync(from, to);
       } catch {
@@ -2484,9 +3452,9 @@ function createFileWriter(logPath, opts) {
   const maxFiles = opts?.maxFiles ?? DEFAULT_MAX_FILES;
   let currentBytes = 0;
   const dir = dirname5(logPath);
-  mkdirSync5(dir, { recursive: true });
+  mkdirSync6(dir, { recursive: true });
   try {
-    currentBytes = statSync2(logPath).size;
+    currentBytes = statSync3(logPath).size;
   } catch {
     currentBytes = 0;
   }
@@ -2503,10 +3471,10 @@ function createFileWriter(logPath, opts) {
 }
 
 // src/daemon.ts
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 import { homedir as homedir4 } from "os";
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, existsSync as existsSync6 } from "fs";
-import { execFileSync as execFileSync3, execSync as execSync2 } from "child_process";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, existsSync as existsSync8 } from "fs";
+import { execFileSync as execFileSync4, execSync as execSync2 } from "child_process";
 
 // src/systemd.ts
 import { dirname as dirname6 } from "path";
@@ -2540,14 +3508,14 @@ WantedBy=default.target
 
 // src/daemon.ts
 function resolveServiceDir() {
-  return resolve3(homedir4(), ".config", "systemd", "user");
+  return resolve4(homedir4(), ".config", "systemd", "user");
 }
 function resolveServicePath(profile) {
-  return resolve3(resolveServiceDir(), unitFileName(profile));
+  return resolve4(resolveServiceDir(), unitFileName(profile));
 }
 function daemonInstall(profile) {
   const serviceDir = resolveServiceDir();
-  mkdirSync6(serviceDir, { recursive: true });
+  mkdirSync7(serviceDir, { recursive: true });
   const nodePath = process.execPath;
   const mpgPath = resolveOwnBinary();
   const unit = generateUnitFile({ nodePath, mpgPath, profile });
@@ -2555,11 +3523,11 @@ function daemonInstall(profile) {
   writeFileSync4(servicePath, unit);
   const name = unitFileName(profile);
   try {
-    execFileSync3("loginctl", ["enable-linger"], { stdio: "ignore" });
+    execFileSync4("loginctl", ["enable-linger"], { stdio: "ignore" });
   } catch {
   }
-  execFileSync3("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" });
-  execFileSync3("systemctl", ["--user", "enable", "--now", name], { stdio: "inherit" });
+  execFileSync4("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" });
+  execFileSync4("systemctl", ["--user", "enable", "--now", name], { stdio: "inherit" });
   console.log(`Installed and started ${name}`);
   console.log(`  Unit file: ${servicePath}`);
   console.log(`  Status:    systemctl --user status ${name}`);
@@ -2569,18 +3537,18 @@ function daemonUninstall(profile) {
   const name = unitFileName(profile);
   const servicePath = resolveServicePath(profile);
   try {
-    execFileSync3("systemctl", ["--user", "stop", name], { stdio: "inherit" });
+    execFileSync4("systemctl", ["--user", "stop", name], { stdio: "inherit" });
   } catch {
   }
   try {
-    execFileSync3("systemctl", ["--user", "disable", name], { stdio: "inherit" });
+    execFileSync4("systemctl", ["--user", "disable", name], { stdio: "inherit" });
   } catch {
   }
-  if (existsSync6(servicePath)) {
+  if (existsSync8(servicePath)) {
     unlinkSync3(servicePath);
   }
   try {
-    execFileSync3("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" });
+    execFileSync4("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" });
   } catch {
   }
   console.log(`Uninstalled ${name}`);
@@ -2588,7 +3556,7 @@ function daemonUninstall(profile) {
 function daemonStatus(profile) {
   const name = unitFileName(profile);
   try {
-    execFileSync3("systemctl", ["--user", "status", name], { stdio: "inherit" });
+    execFileSync4("systemctl", ["--user", "status", name], { stdio: "inherit" });
   } catch {
   }
 }
@@ -2597,7 +3565,7 @@ function daemonLogs(profile, follow) {
   const args2 = ["--user", "-u", name, "--no-pager"];
   if (follow) args2.push("-f");
   try {
-    execFileSync3("journalctl", args2, { stdio: "inherit" });
+    execFileSync4("journalctl", args2, { stdio: "inherit" });
   } catch {
     console.error(`journalctl not available. View logs at: ${resolveLogPath(profile)}`);
   }
@@ -2608,7 +3576,7 @@ function resolveOwnBinary() {
     if (which) return which;
   } catch {
   }
-  const fallback = resolve3(process.argv[1] ?? ".");
+  const fallback = resolve4(process.argv[1] ?? ".");
   console.warn(`Warning: 'mpg' not found on PATH. Using ${fallback} in service file.`);
   return fallback;
 }
@@ -2704,7 +3672,7 @@ function start() {
     configFlag: flags.configFlag,
     profileFlag: flags.profileFlag
   });
-  if (!configPath || !existsSync7(configPath)) {
+  if (!configPath || !existsSync9(configPath)) {
     console.error("config.json not found. Run `mpg init` to create one.");
     process.exit(1);
   }
@@ -2727,7 +3695,24 @@ function start() {
   const sessionsPath = resolveSessionsPath(configPath);
   const sessionStore = createFileSessionStore(sessionsPath);
   const pulseEmitter = createPulseEmitter();
-  const sessionManager = createSessionManager(config.defaults, sessionStore, pulseEmitter);
+  let runtime;
+  if (config.defaults.persistence === "tmux") {
+    runtime = new TmuxRuntime();
+    log.info("Using tmux-based persistent runtime");
+  } else {
+    runtime = new ClaudeCliRuntime();
+    try {
+      const stale = listSessions("mpg-");
+      for (const name of stale) {
+        killSession(name);
+      }
+      if (stale.length > 0) {
+        log.info(`Cleaned up ${stale.length} stale tmux session(s)`);
+      }
+    } catch {
+    }
+  }
+  const sessionManager = createSessionManager(config.defaults, runtime, sessionStore, pulseEmitter);
   const persistedSessions = sessionStore.load();
   const knownKeysByProject = /* @__PURE__ */ new Map();
   for (const [key, entry] of persistedSessions) {
@@ -2743,14 +3728,23 @@ function start() {
   for (const [projectDir, keys] of knownKeysByProject) {
     reconcileWorktrees(projectDir, keys);
   }
+  const seenDirs = /* @__PURE__ */ new Set();
+  for (const project of Object.values(config.projects)) {
+    if (seenDirs.has(project.directory)) continue;
+    seenDirs.add(project.directory);
+    reconcileAttachments(project.directory).then((removed) => {
+      if (removed) log.info(`Removed orphaned attachments in ${project.directory}`);
+    }).catch(() => {
+    });
+  }
   const turnCounter = createTurnCounter();
   const bot = createDiscordBot(router, sessionManager, config, turnCounter);
-  let healthServer;
+  let dashboardServer;
   function shutdown() {
     log.info("Shutting down...");
     removePid(pidPath);
-    if (healthServer) {
-      healthServer.close().catch(() => {
+    if (dashboardServer) {
+      dashboardServer.close().catch(() => {
       });
     }
     sessionManager.shutdown();
@@ -2763,11 +3757,18 @@ function start() {
     if (config.defaults.httpPort !== false) {
       try {
         const activityEngine = createActivityEngine();
-        healthServer = await createHealthServer(config.defaults.httpPort, sessionManager, bot, config, { activityEngine });
+        dashboardServer = await createDashboardServer(config.defaults.httpPort, sessionManager, bot, config, { activityEngine });
       } catch (err) {
-        log.warn(`Health server failed to start on port ${config.defaults.httpPort}: ${err}`);
+        log.warn(`Dashboard server failed to start on port ${config.defaults.httpPort}: ${err}`);
       }
     }
+    sessionManager.recoverOrphanedSessions((projectKey, result) => {
+      bot.deliverOrphanResult(projectKey, result).catch((err) => {
+        log.error(`Failed to deliver orphan result for ${projectKey}: ${err}`);
+      });
+    }).catch((err) => {
+      log.error(`Orphan session recovery failed: ${err}`);
+    });
   }).catch((err) => {
     log.error(`Failed to start bot: ${err}`);
     process.exit(1);
@@ -2778,13 +3779,13 @@ function status() {
     configFlag: flags.configFlag,
     profileFlag: flags.profileFlag
   });
-  const sessionsPath = configPath ? resolveSessionsPath(configPath) : resolve4(process.cwd(), ".sessions.json");
-  if (!existsSync7(sessionsPath)) {
+  const sessionsPath = configPath ? resolveSessionsPath(configPath) : resolve5(process.cwd(), ".sessions.json");
+  if (!existsSync9(sessionsPath)) {
     console.log("No sessions file found. Is the gateway running?");
     return;
   }
   let projectNames = {};
-  if (configPath && existsSync7(configPath)) {
+  if (configPath && existsSync9(configPath)) {
     try {
       const raw = JSON.parse(readFileSync6(configPath, "utf-8"));
       const config = loadConfig(raw);
@@ -2814,23 +3815,23 @@ function status() {
 function migrate() {
   const mpgHome = resolveMpgHome();
   const profileDir = resolveProfileDir("default");
-  const cwdEnv = resolve4(process.cwd(), ".env");
-  const cwdConfig = resolve4(process.cwd(), "config.json");
-  const cwdSessions = resolve4(process.cwd(), ".sessions.json");
+  const cwdEnv = resolve5(process.cwd(), ".env");
+  const cwdConfig = resolve5(process.cwd(), "config.json");
+  const cwdSessions = resolve5(process.cwd(), ".sessions.json");
   const copied = [];
-  mkdirSync7(profileDir, { recursive: true });
-  if (existsSync7(cwdEnv)) {
-    const dest = resolve4(mpgHome, ".env");
+  mkdirSync8(profileDir, { recursive: true });
+  if (existsSync9(cwdEnv)) {
+    const dest = resolve5(mpgHome, ".env");
     copyFileSync(cwdEnv, dest);
     copied.push(`  ${cwdEnv} \u2192 ${dest}`);
   }
-  if (existsSync7(cwdConfig)) {
-    const dest = resolve4(profileDir, "config.json");
+  if (existsSync9(cwdConfig)) {
+    const dest = resolve5(profileDir, "config.json");
     copyFileSync(cwdConfig, dest);
     copied.push(`  ${cwdConfig} \u2192 ${dest}`);
   }
-  if (existsSync7(cwdSessions)) {
-    const dest = resolve4(profileDir, "sessions.json");
+  if (existsSync9(cwdSessions)) {
+    const dest = resolve5(profileDir, "sessions.json");
     copyFileSync(cwdSessions, dest);
     copied.push(`  ${cwdSessions} \u2192 ${dest}`);
   }