stashes 0.1.50 → 0.1.52

package/dist/mcp.js

@@ -26,8 +26,8 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 
 // ../core/dist/generation.js
-import { readFileSync as readFileSync2, existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
 var {spawn: spawn3 } = globalThis.Bun;
 import simpleGit3 from "simple-git";
 // ../shared/dist/constants/index.js
@@ -529,37 +529,68 @@ class PersistenceService {
 
 // ../core/dist/ai-process.js
 var {spawn } = globalThis.Bun;
+import { writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+import { tmpdir } from "os";
 var CLAUDE_BIN = "/opt/homebrew/bin/claude";
+var DEFAULT_TOOLS = ["Read", "Write", "Edit", "Glob", "Grep", "Bash"];
+function getPlaywrightMcpConfigPath() {
+  const configDir = join4(tmpdir(), "stashes-mcp");
+  const configPath = join4(configDir, "playwright.json");
+  if (!existsSync4(configPath)) {
+    mkdirSync3(configDir, { recursive: true });
+    writeFileSync2(configPath, JSON.stringify({
+      mcpServers: {
+        playwright: { command: "npx", args: ["@playwright/mcp@latest"] }
+      }
+    }), "utf-8");
+  }
+  return configPath;
+}
 var processes = new Map;
-function startAiProcess(id, prompt, cwd, resumeSessionId, model) {
-  killAiProcess(id);
-  logger.info("claude", `spawning process: ${id}`, {
-    cwd,
-    promptLength: prompt.length,
-    promptPreview: prompt.substring(0, 100),
-    resumeSessionId,
-    model
+function startAiProcess(idOrOpts, prompt, cwd, resumeSessionId, model) {
+  const opts = typeof idOrOpts === "string" ? { id: idOrOpts, prompt, cwd, resumeSessionId, model } : idOrOpts;
+  const bare = opts.bare ?? true;
+  const tools = opts.tools ?? DEFAULT_TOOLS;
+  killAiProcess(opts.id);
+  logger.info("claude", `spawning process: ${opts.id}`, {
+    cwd: opts.cwd,
+    promptLength: opts.prompt.length,
+    promptPreview: opts.prompt.substring(0, 100),
+    resumeSessionId: opts.resumeSessionId,
+    model: opts.model,
+    bare,
+    tools: bare ? tools.join(",") : "all"
   });
-  const cmd = [CLAUDE_BIN, "-p", prompt, "--output-format=stream-json", "--verbose", "--dangerously-skip-permissions"];
-  if (resumeSessionId) {
-    cmd.push("--resume", resumeSessionId);
+  const cmd = [CLAUDE_BIN, "-p", opts.prompt, "--output-format=stream-json", "--verbose", "--dangerously-skip-permissions"];
+  if (bare) {
+    cmd.push("--bare");
+    if (tools.length > 0) {
+      cmd.push("--tools", tools.join(","));
+    }
+    if (opts.mcpConfigPath) {
+      cmd.push("--mcp-config", opts.mcpConfigPath);
+    }
   }
-  if (model) {
-    cmd.push("--model", model);
+  if (opts.resumeSessionId) {
+    cmd.push("--resume", opts.resumeSessionId);
+  }
+  if (opts.model) {
+    cmd.push("--model", opts.model);
   }
   const proc = spawn({
     cmd,
     stdin: "ignore",
     stdout: "pipe",
     stderr: "pipe",
-    cwd,
+    cwd: opts.cwd,
     env: { ...process.env }
   });
   proc.exited.then((code) => {
-    logger.info("claude", `process exited: ${id}`, { exitCode: code });
+    logger.info("claude", `process exited: ${opts.id}`, { exitCode: code });
   });
-  const aiProcess = { process: proc, id };
-  processes.set(id, aiProcess);
+  const aiProcess = { process: proc, id: opts.id };
+  processes.set(opts.id, aiProcess);
   return aiProcess;
 }
 function killAiProcess(id) {
@@ -574,8 +605,8 @@ function killAiProcess(id) {
   }
   return false;
 }
-var toolNameMap = new Map;
 async function* parseClaudeStream(proc) {
+  const toolNameMap = new Map;
   const stdout = proc.stdout;
   if (!stdout || typeof stdout === "number") {
     throw new Error("Process stdout is not a readable stream");
@@ -671,22 +702,22 @@ async function* parseClaudeStream(proc) {
 }
 
 // ../core/dist/smart-screenshot.js
-import { join as join5 } from "path";
-import { mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+import { mkdirSync as mkdirSync5, existsSync as existsSync6 } from "fs";
 import simpleGit2 from "simple-git";
 
 // ../core/dist/screenshot.js
 var {spawn: spawn2 } = globalThis.Bun;
-import { join as join4 } from "path";
-import { mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
+import { mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
 var SCREENSHOTS_DIR = ".stashes/screenshots";
 async function captureScreenshot(port, projectPath, stashId) {
-  const screenshotsDir = join4(projectPath, SCREENSHOTS_DIR);
-  if (!existsSync4(screenshotsDir)) {
-    mkdirSync3(screenshotsDir, { recursive: true });
+  const screenshotsDir = join5(projectPath, SCREENSHOTS_DIR);
+  if (!existsSync5(screenshotsDir)) {
+    mkdirSync4(screenshotsDir, { recursive: true });
   }
   const filename = `${stashId}.png`;
-  const outputPath = join4(screenshotsDir, filename);
+  const outputPath = join5(screenshotsDir, filename);
   const playwrightScript = `
     const { chromium } = require('playwright');
     (async () => {
@@ -743,14 +774,8 @@ ${truncatedDiff}`;
 }
 function buildScreenshotPrompt(port, diff, screenshotDir, stashId) {
   return [
-    "You are a screenshot assistant. Your ONLY job is to take screenshots of a running web app using Playwright MCP tools.",
-    "",
-    "IMPORTANT RULES:",
-    "- ONLY use these Playwright MCP tools: mcp__playwright__browser_navigate, mcp__playwright__browser_take_screenshot, mcp__playwright__browser_click, mcp__playwright__browser_snapshot",
-    "- Do NOT use any other tools (no Bash, Read, Grep, Agent, ToolSearch, etc.)",
-    "- Do NOT start any sessions or call useai tools",
-    "- Do NOT read or analyze code files \u2014 the diff below tells you everything",
-    "- Be fast \u2014 you have a strict time limit",
+    "You are a screenshot assistant. Take screenshots of a running web app using Playwright MCP tools.",
+    "Be fast \u2014 you have a strict time limit.",
     "",
     `## The app is running at: http://localhost:${port}`,
     "",
@@ -774,7 +799,7 @@ function buildScreenshotPrompt(port, diff, screenshotDir, stashId) {
     "{",
     '  "screenshots": [',
     "    {",
-    `      "path": "${join5(screenshotDir, `${stashId}.png`)}",`,
+    `      "path": "${join6(screenshotDir, `${stashId}.png`)}",`,
     '      "label": "Short description of what is shown",',
     '      "route": "/the-url-path",',
     '      "isPrimary": true',
@@ -815,9 +840,9 @@ async function fallbackScreenshot(port, projectPath, stashId) {
 }
 async function captureSmartScreenshots(opts) {
   const { projectPath, stashId, stashBranch, parentBranch, worktreePath, port, model = "sonnet", timeout = DEFAULT_TIMEOUT } = opts;
-  const screenshotDir = join5(projectPath, SCREENSHOTS_DIR2);
-  if (!existsSync5(screenshotDir)) {
-    mkdirSync4(screenshotDir, { recursive: true });
+  const screenshotDir = join6(projectPath, SCREENSHOTS_DIR2);
+  if (!existsSync6(screenshotDir)) {
+    mkdirSync5(screenshotDir, { recursive: true });
   }
   const diff = await getStashDiff(worktreePath, parentBranch);
   if (!diff) {
@@ -827,7 +852,15 @@ async function captureSmartScreenshots(opts) {
   const processId = `screenshot-ai-${stashId}`;
   const prompt = buildScreenshotPrompt(port, diff, screenshotDir, stashId);
   const modelFlag = model === "sonnet" ? "sonnet" : "haiku";
-  const aiProcess = startAiProcess(processId, prompt, worktreePath, undefined, modelFlag);
+  const aiProcess = startAiProcess({
+    id: processId,
+    prompt,
+    cwd: worktreePath,
+    model: modelFlag,
+    bare: true,
+    tools: [],
+    mcpConfigPath: getPlaywrightMcpConfigPath()
+  });
   let textOutput = "";
   let timedOut = false;
   const timeoutId = setTimeout(() => {
@@ -859,7 +892,7 @@ async function captureSmartScreenshots(opts) {
   let primaryUrl = "";
   for (const shot of result.screenshots) {
     const filename = shot.path.split("/").pop() || "";
-    if (!existsSync5(shot.path)) {
+    if (!existsSync6(shot.path)) {
       logger.warn("smart-screenshot", `Screenshot file not found: ${shot.path}`);
       continue;
     }
@@ -953,8 +986,8 @@ async function generate(opts) {
   const selectedDirectives = directives.slice(0, count);
   let sourceCode = "";
   if (component?.filePath) {
-    const sourceFile = join6(projectPath, component.filePath);
-    if (existsSync6(sourceFile)) {
+    const sourceFile = join7(projectPath, component.filePath);
+    if (existsSync7(sourceFile)) {
       sourceCode = readFileSync2(sourceFile, "utf-8");
     }
   }
@@ -990,7 +1023,12 @@ async function generate(opts) {
     } else {
       stashPrompt = buildFreeformStashPrompt(prompt, directive);
     }
-    const aiProcess = startAiProcess(stashId, stashPrompt, worktree.path);
+    const aiProcess = startAiProcess({
+      id: stashId,
+      prompt: stashPrompt,
+      cwd: worktree.path,
+      bare: false
+    });
     try {
       for await (const chunk of parseClaudeStream(aiProcess.process)) {
         emit(onProgress, {
@@ -999,14 +1037,63 @@ async function generate(opts) {
           content: chunk.content,
           streamType: chunk.type
         });
+        if (chunk.type === "tool_use" && chunk.toolName) {
+          const knownTools = ["Read", "Write", "Edit", "Glob", "Grep", "Bash"];
+          if (knownTools.includes(chunk.toolName)) {
+            const filePath = chunk.toolInput?.file_path ?? chunk.toolInput?.path ?? chunk.toolInput?.command ?? undefined;
+            const lines = chunk.toolInput?.content ? chunk.toolInput.content.split(`
+`).length : undefined;
+            emit(onProgress, {
+              type: "activity",
+              stashId,
+              action: chunk.toolName,
+              file: filePath,
+              lines,
+              timestamp: Date.now()
+            });
+          }
+        } else if (chunk.type === "thinking") {
+          emit(onProgress, {
+            type: "activity",
+            stashId,
+            action: "thinking",
+            content: chunk.content.substring(0, 200),
+            timestamp: Date.now()
+          });
+        } else if (chunk.type === "text") {
+          emit(onProgress, {
+            type: "activity",
+            stashId,
+            action: "text",
+            content: chunk.content.substring(0, 200),
+            timestamp: Date.now()
+          });
+        }
       }
       await aiProcess.process.exited;
       const wtGit = simpleGit3(worktree.path);
+      let hasChanges = false;
       try {
         await wtGit.add("-A");
-        await wtGit.commit(`stashes: stash ${stashId}`);
-      } catch {}
+        const status = await wtGit.status();
+        if (status.staged.length > 0) {
+          await wtGit.commit(`stashes: stash ${stashId}`);
+          hasChanges = true;
+          logger.info("generation", `committed changes for ${stashId}`, { files: status.staged.length });
+        } else {
+          logger.warn("generation", `AI produced no file changes for ${stashId} \u2014 skipping`);
+        }
+      } catch (commitErr) {
+        logger.warn("generation", `commit failed for ${stashId}`, {
+          error: commitErr instanceof Error ? commitErr.message : String(commitErr)
+        });
+      }
       await worktreeManager.removeGeneration(stashId);
+      if (!hasChanges) {
+        persistence.saveStash({ ...stash, status: "error", error: "AI generation produced no file changes" });
+        emit(onProgress, { type: "error", stashId, error: "AI generation produced no file changes" });
+        return;
+      }
       const generatedStash = { ...stash, status: "screenshotting" };
       completedStashes.push(generatedStash);
       persistence.saveStash(generatedStash);
@@ -1137,7 +1224,12 @@ async function vary(opts) {
   persistence.saveStash(stash);
   emit2(onProgress, { type: "generating", stashId, number: stashNumber });
   const varyPrompt = `The user wants to vary the current UI. Apply this change: ${prompt}`;
-  const aiProcess = startAiProcess(stashId, varyPrompt, worktree.path);
+  const aiProcess = startAiProcess({
+    id: stashId,
+    prompt: varyPrompt,
+    cwd: worktree.path,
+    bare: false
+  });
   try {
     for await (const chunk of parseClaudeStream(aiProcess.process)) {
       emit2(onProgress, {
@@ -1149,11 +1241,29 @@ async function vary(opts) {
     }
     await aiProcess.process.exited;
     const wtGit = simpleGit4(worktree.path);
+    let hasChanges = false;
     try {
       await wtGit.add("-A");
-      await wtGit.commit(`stashes: vary ${stashId} from ${sourceStashId}`);
-    } catch {}
+      const status = await wtGit.status();
+      if (status.staged.length > 0) {
+        await wtGit.commit(`stashes: vary ${stashId} from ${sourceStashId}`);
+        hasChanges = true;
+        logger.info("vary", `committed changes for ${stashId}`, { files: status.staged.length });
+      } else {
+        logger.warn("vary", `AI produced no file changes for ${stashId}`);
+      }
+    } catch (commitErr) {
+      logger.warn("vary", `commit failed for ${stashId}`, {
+        error: commitErr instanceof Error ? commitErr.message : String(commitErr)
+      });
+    }
     await worktreeManager.removeGeneration(stashId);
+    if (!hasChanges) {
+      const errorStash = { ...stash, status: "error", error: "AI generation produced no file changes" };
+      persistence.saveStash(errorStash);
+      emit2(onProgress, { type: "error", stashId, error: "AI generation produced no file changes" });
+      return errorStash;
+    }
     persistence.saveStash({ ...stash, status: "screenshotting" });
     emit2(onProgress, { type: "screenshotting", stashId });
     let screenshotPath = "";
@@ -1274,13 +1384,14 @@ async function show(projectPath, stashId) {
   return { stash: found, diff, files };
 }
 // ../mcp/src/tools/generate.ts
+var HONO_PORT = process.env.STASHES_PORT ?? "4000";
 var generateParams = {
   prompt: z.string().describe('What UI changes to generate (e.g. "make the hero section bolder")'),
   count: z.number().min(1).max(5).optional().describe("Number of stashes to generate (1-5, default 3)"),
   filePath: z.string().optional().describe('Optional: scope changes to a specific file (e.g. "src/components/Hero.tsx")'),
   exportName: z.string().optional().describe("Optional: specific component export name within the file")
 };
-async function handleGenerate(args, projectPath) {
+async function handleGenerate(args, projectPath, server) {
   const { prompt, filePath, exportName } = args;
   const count = args.count ?? 3;
   initLogFile(projectPath);
@@ -1298,14 +1409,41 @@ async function handleGenerate(args, projectPath) {
     };
     persistence.saveProject(project);
   }
+  let pendingEvents = [];
+  let flushTimer = null;
+  function flushPending() {
+    if (pendingEvents.length === 0)
+      return;
+    const batch = pendingEvents.splice(0);
+    flushTimer = null;
+    fetch(`http://localhost:${HONO_PORT}/api/stash-activity`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(batch.filter((e) => e.type === "activity"))
+    }).catch(() => {});
+  }
   const stashes = await generate({
     projectPath,
     projectId: project.id,
     prompt,
     count,
     component: filePath ? { filePath, exportName } : undefined,
-    onProgress: () => {}
+    onProgress: (event) => {
+      if (event.type === "activity") {
+        pendingEvents.push(event);
+        if (!flushTimer) {
+          flushTimer = setTimeout(flushPending, 100);
+        }
+      }
+      server.server.sendLoggingMessage({
+        level: "info",
+        data: event
+      }).catch(() => {});
+    }
   });
+  if (flushTimer)
+    clearTimeout(flushTimer);
+  flushPending();
   return {
     content: [{
       type: "text",
@@ -1452,150 +1590,17 @@ async function handleRemove(args, projectPath) {
 // ../server/dist/index.js
 import { Hono as Hono2 } from "hono";
 import { cors } from "hono/cors";
-import { join as join9, dirname as dirname2 } from "path";
+import { join as join11, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync6 } from "fs";
 
 // ../server/dist/routes/api.js
 import { Hono } from "hono";
-import { join as join7, basename } from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
-var app = new Hono;
-app.get("/health", (c) => c.json({ status: "ok", service: "stashes" }));
-app.get("/projects", (c) => {
-  const persistence = getPersistence();
-  const projects = persistence.listProjects();
-  const projectsWithCounts = projects.map((p) => ({
-    ...p,
-    stashCount: persistence.listStashes(p.id).length,
-    recentScreenshots: persistence.listStashes(p.id).filter((s) => s.screenshotUrl).slice(-4).map((s) => s.screenshotUrl)
-  }));
-  return c.json({ data: projectsWithCounts });
-});
-app.post("/projects", async (c) => {
-  const { name, description } = await c.req.json();
-  const project = {
-    id: `proj_${crypto.randomUUID().substring(0, 8)}`,
-    name,
-    description,
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString()
-  };
-  getPersistence().saveProject(project);
-  return c.json({ data: project }, 201);
-});
-app.get("/projects/:id", (c) => {
-  const persistence = getPersistence();
-  const project = persistence.getProject(c.req.param("id"));
-  if (!project)
-    return c.json({ error: "Project not found" }, 404);
-  const stashes = persistence.listStashes(project.id);
-  const chats = persistence.listChats(project.id);
-  return c.json({ data: { ...project, stashes, chats } });
-});
-app.delete("/projects/:id", (c) => {
-  const id = c.req.param("id");
-  getPersistence().deleteProject(id);
-  return c.json({ data: { deleted: id } });
-});
-app.get("/chats", (c) => {
-  const persistence = getPersistence();
-  const project = ensureProject(persistence);
-  const chats = persistence.listChats(project.id);
-  const stashes = persistence.listStashes(project.id);
-  return c.json({ data: { project, chats, stashes } });
-});
-app.post("/chats", async (c) => {
-  const persistence = getPersistence();
-  const project = ensureProject(persistence);
-  const { title, referencedStashIds } = await c.req.json();
-  const chatCount = persistence.listChats(project.id).length;
-  const chat = {
-    id: `chat_${crypto.randomUUID().substring(0, 8)}`,
-    projectId: project.id,
-    title: title?.trim() || `Chat ${chatCount + 1}`,
-    referencedStashIds: referencedStashIds ?? [],
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString()
-  };
-  persistence.saveChat(chat);
-  return c.json({ data: chat }, 201);
-});
-app.patch("/chats/:chatId", async (c) => {
-  const persistence = getPersistence();
-  const project = ensureProject(persistence);
-  const chatId = c.req.param("chatId");
-  const chat = persistence.getChat(project.id, chatId);
-  if (!chat)
-    return c.json({ error: "Chat not found" }, 404);
-  const body = await c.req.json();
-  const updated = {
-    ...chat,
-    ...body.referencedStashIds !== undefined ? { referencedStashIds: body.referencedStashIds } : {},
-    updatedAt: new Date().toISOString()
-  };
-  persistence.saveChat(updated);
-  return c.json({ data: updated });
-});
-app.get("/chats/:chatId", (c) => {
-  const persistence = getPersistence();
-  const project = ensureProject(persistence);
-  const chatId = c.req.param("chatId");
-  const chat = persistence.getChat(project.id, chatId);
-  if (!chat)
-    return c.json({ error: "Chat not found" }, 404);
-  const messages = persistence.getChatMessages(project.id, chatId);
-  const refIds = new Set(chat.referencedStashIds ?? []);
-  const stashes = persistence.listStashes(project.id).filter((s) => s.originChatId === chatId || refIds.has(s.id));
-  return c.json({ data: { ...chat, messages, stashes } });
-});
-app.delete("/chats/:chatId", (c) => {
-  const persistence = getPersistence();
-  const project = ensureProject(persistence);
-  const chatId = c.req.param("chatId");
-  persistence.deleteChat(project.id, chatId);
-  return c.json({ data: { deleted: chatId } });
-});
-app.get("/dev-server-status", async (c) => {
-  const port = serverState.userDevPort;
-  try {
-    const res = await fetch(`http://localhost:${port}`, {
-      method: "HEAD",
-      signal: AbortSignal.timeout(2000)
-    });
-    return c.json({ up: res.status < 500, port });
-  } catch {
-    return c.json({ up: false, port });
-  }
-});
-app.get("/screenshots/:filename", (c) => {
-  const filename = c.req.param("filename");
-  const filePath = join7(serverState.projectPath, ".stashes", "screenshots", filename);
-  if (!existsSync7(filePath))
-    return c.json({ error: "Not found" }, 404);
-  const content = readFileSync3(filePath);
-  return new Response(content, {
-    headers: { "content-type": "image/png", "cache-control": "no-cache" }
-  });
-});
-function ensureProject(persistence) {
-  const projects = persistence.listProjects();
-  if (projects.length > 0)
-    return projects[0];
-  const project = {
-    id: `proj_${crypto.randomUUID().substring(0, 8)}`,
-    name: basename(serverState.projectPath),
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString()
-  };
-  persistence.saveProject(project);
-  persistence.migrateOldChat(project.id);
-  return project;
-}
-var apiRoutes = app;
+import { join as join10, basename } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync5 } from "fs";
 
 // ../server/dist/services/stash-service.js
-import { readFileSync as readFileSync4, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync8 } from "fs";
 import { join as join8 } from "path";
 
 // ../server/dist/services/app-proxy.js
@@ -2079,6 +2084,7 @@ class StashService {
   worktreeManager;
   persistence;
   broadcast;
+  activityStore;
   previewPool;
   selectedComponent = null;
   messageQueue = [];
@@ -2088,11 +2094,12 @@ class StashService {
   stashPollTimer = null;
   knownStashIds = new Set;
   pendingComponentResolve = null;
-  constructor(projectPath, worktreeManager, persistence, broadcast, stashPortStart, stashPortEnd) {
+  constructor(projectPath, worktreeManager, persistence, broadcast, activityStore, stashPortStart, stashPortEnd) {
     this.projectPath = projectPath;
     this.worktreeManager = worktreeManager;
     this.persistence = persistence;
     this.broadcast = broadcast;
+    this.activityStore = activityStore;
     this.previewPool = new PreviewPool(worktreeManager, broadcast, undefined, undefined, stashPortStart, stashPortEnd);
   }
   getActiveChatId() {
@@ -2126,7 +2133,14 @@ class StashService {
       "Reply with ONLY the file path relative to the project root."
     ].join(`
 `);
-    const aiProcess = startAiProcess("resolve-component", prompt, this.projectPath, undefined, "claude-haiku-4-5-20251001");
+    const aiProcess = startAiProcess({
+      id: "resolve-component",
+      prompt,
+      cwd: this.projectPath,
+      model: "claude-haiku-4-5-20251001",
+      bare: true,
+      tools: ["Read", "Grep", "Glob", "Bash"]
+    });
     let resolvedPath = "";
     try {
       for await (const chunk of parseClaudeStream(aiProcess.process)) {
@@ -2189,7 +2203,7 @@ class StashService {
     if (filePath && filePath !== "auto-detect") {
       const sourceFile = join8(this.projectPath, filePath);
       if (existsSync8(sourceFile)) {
-        sourceCode = readFileSync4(sourceFile, "utf-8");
+        sourceCode = readFileSync3(sourceFile, "utf-8");
       }
     }
     let stashContext = "";
@@ -2236,7 +2250,13 @@ ${sourceCode.substring(0, 3000)}
       ].filter(Boolean).join(`
 `);
     }
-    const aiProcess = startAiProcess("chat", chatPrompt, this.projectPath, existingSessionId);
+    const aiProcess = startAiProcess({
+      id: "chat",
+      prompt: chatPrompt,
+      cwd: this.projectPath,
+      resumeSessionId: existingSessionId,
+      bare: false
+    });
     let thinkingBuf = "";
     let textBuf = "";
     const now = new Date().toISOString();
@@ -2312,6 +2332,21 @@ ${sourceCode.substring(0, 3000)}
           }
         } else if (chunk.type === "tool_result") {
           this.stopStashPoll();
+          let stashActivity;
+          const toolNameForSnapshot = chunk.toolName ?? "";
+          if (toolNameForSnapshot.includes("stashes_generate") || toolNameForSnapshot.includes("stashes_vary")) {
+            const projectId2 = this.persistence.listProjects()[0]?.id ?? "";
+            const allStashes = this.persistence.listStashes(projectId2);
+            stashActivity = {};
+            for (const s of allStashes) {
+              if (this.activityStore.has(s.id)) {
+                stashActivity[s.id] = this.activityStore.getSnapshot(s.id);
+                this.activityStore.clear(s.id);
+              }
+            }
+            if (Object.keys(stashActivity).length === 0)
+              stashActivity = undefined;
+          }
           let toolResult = chunk.content;
           let isError = false;
           try {
@@ -2326,6 +2361,7 @@ ${sourceCode.substring(0, 3000)}
             type: "tool_end",
             toolStatus: isError ? "error" : "completed",
             toolResult: toolResult.substring(0, 300),
+            stashActivity,
             createdAt: now
           });
           this.broadcast({
@@ -2515,10 +2551,77 @@ ${refDescriptions.join(`
   }
 }
 
+// ../server/dist/services/activity-store.js
+import { appendFileSync as appendFileSync2, readFileSync as readFileSync4, existsSync as existsSync9, mkdirSync as mkdirSync6, rmSync as rmSync3 } from "fs";
+import { join as join9, dirname as dirname2 } from "path";
+
+class ActivityStore {
+  cache = new Map;
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  jsonlPath(stashId) {
+    return join9(this.projectPath, ".stashes", "activity", `${stashId}.jsonl`);
+  }
+  append(event) {
+    const existing = this.cache.get(event.stashId) ?? [];
+    existing.push(event);
+    this.cache.set(event.stashId, existing);
+    const filePath = this.jsonlPath(event.stashId);
+    const dir = dirname2(filePath);
+    if (!existsSync9(dir))
+      mkdirSync6(dir, { recursive: true });
+    appendFileSync2(filePath, JSON.stringify(event) + `
+`, "utf-8");
+  }
+  getEvents(stashId) {
+    const cached = this.cache.get(stashId);
+    if (cached && cached.length > 0)
+      return cached;
+    const filePath = this.jsonlPath(stashId);
+    if (!existsSync9(filePath))
+      return [];
+    const lines = readFileSync4(filePath, "utf-8").trim().split(`
+`).filter(Boolean);
+    const events = lines.map((line) => JSON.parse(line));
+    this.cache.set(stashId, events);
+    return events;
+  }
+  getSnapshot(stashId) {
+    const actions = this.getEvents(stashId);
+    const fileActions = actions.filter((a) => ["Read", "Write", "Edit", "Glob", "Grep", "Bash"].includes(a.action));
+    const uniqueFiles = new Set(fileActions.filter((a) => a.file).map((a) => a.file));
+    const timestamps = actions.map((a) => a.timestamp);
+    const duration = timestamps.length > 1 ? Math.round((Math.max(...timestamps) - Math.min(...timestamps)) / 1000) : 0;
+    return {
+      actions: [...actions],
+      stats: {
+        filesChanged: uniqueFiles.size,
+        duration,
+        totalActions: actions.length
+      }
+    };
+  }
+  clear(stashId) {
+    this.cache.delete(stashId);
+    const filePath = this.jsonlPath(stashId);
+    if (existsSync9(filePath)) {
+      rmSync3(filePath);
+    }
+  }
+  has(stashId) {
+    if (this.cache.has(stashId) && (this.cache.get(stashId)?.length ?? 0) > 0)
+      return true;
+    return existsSync9(this.jsonlPath(stashId));
+  }
+}
+
 // ../server/dist/services/websocket.js
 var worktreeManager;
 var stashService;
 var persistence;
+var activityStore;
 var clients = new Set;
 function broadcast(event) {
   const data = JSON.stringify(event);
@@ -2529,10 +2632,14 @@ function broadcast(event) {
 function getPersistenceFromWs() {
   return persistence;
 }
+function getActivityStoreFromWs() {
+  return activityStore;
+}
 function createWebSocketHandler(projectPath, userDevPort, appProxyPort, stashPortStart, stashPortEnd) {
   worktreeManager = new WorktreeManager(projectPath);
   persistence = new PersistenceService(projectPath);
-  stashService = new StashService(projectPath, worktreeManager, persistence, broadcast, stashPortStart, stashPortEnd);
+  activityStore = new ActivityStore(projectPath);
+  stashService = new StashService(projectPath, worktreeManager, persistence, broadcast, activityStore, stashPortStart, stashPortEnd);
   return {
     open(ws) {
       clients.add(ws);
@@ -2549,6 +2656,15 @@ function createWebSocketHandler(projectPath, userDevPort, appProxyPort, stashPor
       if (activeChatId) {
         ws.send(JSON.stringify({ type: "processing", chatId: activeChatId }));
       }
+      const allStashes = persistence.listStashes(project.id);
+      for (const stash of allStashes) {
+        if (stash.status === "generating" && activityStore.has(stash.id)) {
+          const events = activityStore.getEvents(stash.id);
+          for (const event of events) {
+            ws.send(JSON.stringify({ type: "stash:activity", stashId: stash.id, event }));
+          }
+        }
+      }
     },
     async message(ws, message) {
       const raw = typeof message === "string" ? message : new TextDecoder().decode(message);
@@ -2628,6 +2744,156 @@ function createWebSocketHandler(projectPath, userDevPort, appProxyPort, stashPor
   };
 }
 
+// ../server/dist/routes/api.js
+var app = new Hono;
+app.get("/health", (c) => c.json({ status: "ok", service: "stashes" }));
+app.get("/projects", (c) => {
+  const persistence2 = getPersistence();
+  const projects = persistence2.listProjects();
+  const projectsWithCounts = projects.map((p) => ({
+    ...p,
+    stashCount: persistence2.listStashes(p.id).length,
+    recentScreenshots: persistence2.listStashes(p.id).filter((s) => s.screenshotUrl).slice(-4).map((s) => s.screenshotUrl)
+  }));
+  return c.json({ data: projectsWithCounts });
+});
+app.post("/projects", async (c) => {
+  const { name, description } = await c.req.json();
+  const project = {
+    id: `proj_${crypto.randomUUID().substring(0, 8)}`,
+    name,
+    description,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  getPersistence().saveProject(project);
+  return c.json({ data: project }, 201);
+});
+app.get("/projects/:id", (c) => {
+  const persistence2 = getPersistence();
+  const project = persistence2.getProject(c.req.param("id"));
+  if (!project)
+    return c.json({ error: "Project not found" }, 404);
+  const stashes = persistence2.listStashes(project.id);
+  const chats = persistence2.listChats(project.id);
+  return c.json({ data: { ...project, stashes, chats } });
+});
+app.delete("/projects/:id", (c) => {
+  const id = c.req.param("id");
+  getPersistence().deleteProject(id);
+  return c.json({ data: { deleted: id } });
+});
+app.get("/chats", (c) => {
+  const persistence2 = getPersistence();
+  const project = ensureProject(persistence2);
+  const chats = persistence2.listChats(project.id);
+  const stashes = persistence2.listStashes(project.id);
+  return c.json({ data: { project, chats, stashes } });
+});
+app.post("/chats", async (c) => {
+  const persistence2 = getPersistence();
+  const project = ensureProject(persistence2);
+  const { title, referencedStashIds } = await c.req.json();
+  const chatCount = persistence2.listChats(project.id).length;
+  const chat = {
+    id: `chat_${crypto.randomUUID().substring(0, 8)}`,
+    projectId: project.id,
+    title: title?.trim() || `Chat ${chatCount + 1}`,
+    referencedStashIds: referencedStashIds ?? [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  persistence2.saveChat(chat);
+  return c.json({ data: chat }, 201);
+});
+app.patch("/chats/:chatId", async (c) => {
+  const persistence2 = getPersistence();
+  const project = ensureProject(persistence2);
+  const chatId = c.req.param("chatId");
+  const chat = persistence2.getChat(project.id, chatId);
+  if (!chat)
+    return c.json({ error: "Chat not found" }, 404);
+  const body = await c.req.json();
+  const updated = {
+    ...chat,
+    ...body.referencedStashIds !== undefined ? { referencedStashIds: body.referencedStashIds } : {},
+    updatedAt: new Date().toISOString()
+  };
+  persistence2.saveChat(updated);
+  return c.json({ data: updated });
+});
+app.get("/chats/:chatId", (c) => {
+  const persistence2 = getPersistence();
+  const project = ensureProject(persistence2);
+  const chatId = c.req.param("chatId");
+  const chat = persistence2.getChat(project.id, chatId);
+  if (!chat)
+    return c.json({ error: "Chat not found" }, 404);
+  const messages = persistence2.getChatMessages(project.id, chatId);
+  const refIds = new Set(chat.referencedStashIds ?? []);
+  const stashes = persistence2.listStashes(project.id).filter((s) => s.originChatId === chatId || refIds.has(s.id));
+  return c.json({ data: { ...chat, messages, stashes } });
+});
+app.delete("/chats/:chatId", (c) => {
+  const persistence2 = getPersistence();
+  const project = ensureProject(persistence2);
+  const chatId = c.req.param("chatId");
+  persistence2.deleteChat(project.id, chatId);
+  return c.json({ data: { deleted: chatId } });
+});
+app.get("/dev-server-status", async (c) => {
+  const port = serverState.userDevPort;
+  try {
+    const res = await fetch(`http://localhost:${port}`, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(2000)
+    });
+    return c.json({ up: res.status < 500, port });
+  } catch {
+    return c.json({ up: false, port });
+  }
+});
+app.get("/screenshots/:filename", (c) => {
+  const filename = c.req.param("filename");
+  const filePath = join10(serverState.projectPath, ".stashes", "screenshots", filename);
+  if (!existsSync10(filePath))
+    return c.json({ error: "Not found" }, 404);
+  const content = readFileSync5(filePath);
+  return new Response(content, {
+    headers: { "content-type": "image/png", "cache-control": "no-cache" }
+  });
+});
+app.post("/stash-activity", async (c) => {
+  const events = await c.req.json();
+  const store = getActivityStoreFromWs();
+  for (const event of events) {
+    store.append(event);
+    broadcast({ type: "stash:activity", stashId: event.stashId, event });
+  }
+  return c.json({ ok: true });
+});
+app.get("/stash-activity/:stashId", (c) => {
+  const stashId = c.req.param("stashId");
+  const store = getActivityStoreFromWs();
+  const events = store.getEvents(stashId);
+  return c.json({ data: events });
+});
+function ensureProject(persistence2) {
+  const projects = persistence2.listProjects();
+  if (projects.length > 0)
+    return projects[0];
+  const project = {
+    id: `proj_${crypto.randomUUID().substring(0, 8)}`,
+    name: basename(serverState.projectPath),
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  persistence2.saveProject(project);
+  persistence2.migrateOldChat(project.id);
+  return project;
+}
+var apiRoutes = app;
+
 // ../server/dist/index.js
 var serverState = {
   projectPath: "",
@@ -2641,14 +2907,14 @@ app2.use("/*", cors());
 app2.route("/api", apiRoutes);
 app2.get("/*", async (c) => {
   const path = c.req.path;
-  const selfDir = dirname2(fileURLToPath(import.meta.url));
-  const bundledWebDir = join9(selfDir, "web");
-  const monorepoWebDir = join9(selfDir, "../../web/dist");
-  const webDistDir = existsSync9(join9(bundledWebDir, "index.html")) ? bundledWebDir : monorepoWebDir;
+  const selfDir = dirname3(fileURLToPath(import.meta.url));
+  const bundledWebDir = join11(selfDir, "web");
+  const monorepoWebDir = join11(selfDir, "../../web/dist");
+  const webDistDir = existsSync11(join11(bundledWebDir, "index.html")) ? bundledWebDir : monorepoWebDir;
   const requestPath = path === "/" ? "/index.html" : path;
-  const filePath = join9(webDistDir, requestPath);
-  if (existsSync9(filePath) && !filePath.includes("..")) {
-    const content = readFileSync5(filePath);
+  const filePath = join11(webDistDir, requestPath);
+  if (existsSync11(filePath) && !filePath.includes("..")) {
+    const content = readFileSync6(filePath);
     const ext = filePath.split(".").pop() || "";
     const contentTypes = {
       html: "text/html; charset=utf-8",
@@ -2666,9 +2932,9 @@ app2.get("/*", async (c) => {
       headers: { "content-type": contentTypes[ext] || "application/octet-stream" }
     });
   }
-  const indexPath = join9(webDistDir, "index.html");
-  if (existsSync9(indexPath)) {
-    const html = readFileSync5(indexPath, "utf-8");
+  const indexPath = join11(webDistDir, "index.html");
+  if (existsSync11(indexPath)) {
+    const html = readFileSync6(indexPath, "utf-8");
     return new Response(html, {
       headers: { "content-type": "text/html; charset=utf-8" }
     });
@@ -2731,11 +2997,11 @@ async function startServer(projectPath, userDevPort, requestedPort = STASHES_POR
 import open from "open";
 
 // ../server/dist/services/detector.js
-import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
+import { join as join12 } from "path";
 function detectFramework(projectPath) {
-  const packageJsonPath = join10(projectPath, "package.json");
-  if (!existsSync10(packageJsonPath)) {
+  const packageJsonPath = join12(projectPath, "package.json");
+  if (!existsSync12(packageJsonPath)) {
     return {
       framework: "unknown",
       devCommand: "npm run dev",
@@ -2743,7 +3009,7 @@ function detectFramework(projectPath) {
       configFile: null
     };
   }
-  const packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
   const deps = {
     ...packageJson.dependencies,
     ...packageJson.devDependencies
@@ -2797,7 +3063,7 @@ function getDevCommand(packageJson, fallback) {
 }
 function findConfig(projectPath, candidates) {
   for (const candidate of candidates) {
-    if (existsSync10(join10(projectPath, candidate))) {
+    if (existsSync12(join12(projectPath, candidate))) {
       return candidate;
     }
   }
@@ -2825,7 +3091,7 @@ var server = new McpServer({
   name: "stashes",
   version: "0.1.0"
 });
-server.tool("stashes_generate", "Generate multiple AI-powered UI design explorations (stashes) for a given prompt. Each stash applies a different creative direction.", generateParams, async (args) => handleGenerate(args, projectPath));
+server.tool("stashes_generate", "Generate multiple AI-powered UI design explorations (stashes) for a given prompt. Each stash applies a different creative direction.", generateParams, async (args) => handleGenerate(args, projectPath, server));
 server.tool("stashes_list", "List all existing stashes in the current project. Shows ID, prompt, status, branch, and screenshot path.", listParams, async (args) => handleList(args, projectPath));
 server.tool("stashes_show", "Show detailed information about a specific stash including its git diff, changed files, prompt, and metadata. Use this to inspect what a stash changed without applying it.", showParams, async (args) => handleShow(args, projectPath));
 server.tool("stashes_apply", "Merge a stash branch into the current git branch. Applies the AI-generated UI changes and cleans up all worktrees. ONLY use when the user explicitly asks to apply or merge.", applyParams, async (args) => handleApply(args, projectPath));