@strayl/agent 0.1.2 → 0.1.4

package/skills/web-application-creation/SKILL.md

@@ -0,0 +1,231 @@
+---
+name: web-application-creation
+description: Initialize a new web application from the Strayl template using npx create-strayl-app. Handles project scaffolding, dependency installation, and dev server startup. Use when the user wants a full-featured app with multiple routes, forms, auth, database, or any complex logic.
+---
+
+# Web Application Creation
+
+## When to Use
+
+- User asks to create, start, or scaffold a new web application
+- User wants to build a new project from scratch
+- The workspace repository is empty and needs a project initialized
+- User says "create an app", "start a new project", "build me an app"
+- User needs multiple routes, forms, auth, database, dashboards, CRUD
+
+## When NOT to Use (use `landing-creation` instead)
+
+- User wants a single-page landing, marketing page, or promotional site
+- User says "make me a website", "create a homepage", "build a landing page"
+- User's request implies a simple static site without complex backend logic
+
+## Workflow
+
+1. **Ask the user for the app name** before running any commands. The name will be used as the project directory name.
+2. **Run the scaffolding command** in the repository root:
+   ```
+   npx -y create-strayl-app@latest --name {app-name}
+   ```
+3. **Install dependencies:**
+   ```
+   cd {app-name} && npm install
+   ```
+4. **Start the dev server** in background mode:
+   ```
+   cd {app-name} && npm run dev
+   ```
+5. **Check logs** to confirm the server started successfully (look for "ready" or "listening on port 3000").
+6. **Show preview** to the user with `showPreview`.
+7. **Continue building** based on user's request. Common next steps:
+   - Need user accounts? → Read `/skills/authentication/SKILL.md`
+   - Need a database? → Read `/skills/database-management/SKILL.md`
+   - Need API endpoints / server logic? → Read `/skills/api-creation/SKILL.md`
+   - Need UI/UX design, styling, or visual polish? → Read `/skills/frontend-design/SKILL.md`
+
+## Template Stack
+
+| Layer | Technology | Version |
+|-------|------------|---------|
+| Framework | React + TanStack Start | React 19, Start 1.x |
+| Bundler | Vite | 7.x |
+| Language | TypeScript (strict) | 5.7+ |
+| Routing | TanStack Router (file-based) | 1.x |
+| Styling | Tailwind CSS + CSS custom properties | 4.x |
+| UI Components | shadcn/ui (install as needed) | latest |
+| Icons | Lucide React | 0.475+ |
+| Theming | next-themes (light/dark + system) | 0.4.x |
+| Font | Geist (fontsource) | — |
+| Server | Nitro (SSR + server functions) | nightly |
+
+## Project Structure
+
+```
+{app-name}/
+├── public/
+│   └── favicon.ico
+├── src/
+│   ├── components/
+│   │   ├── theme-provider.tsx       # next-themes wrapper
+│   │   └── ui/                      # Minimal starter components (button, input, label, textarea)
+│   ├── hooks/
+│   │   └── use-mobile.ts           # useIsMobile() — viewport < 768px
+│   ├── lib/
+│   │   └── utils.ts                 # cn() — clsx + tailwind-merge
+│   ├── routes/
+│   │   ├── __root.tsx               # Root layout (HTML shell, Geist font, ThemeProvider)
+│   │   ├── index.tsx                # Home page ("STRAYL" + theme toggle)
+│   │   └── routeTree.gen.ts         # Auto-generated route tree (DO NOT EDIT)
+│   ├── router.tsx                   # Router config (empty context, scroll restoration)
+│   └── styles.css                   # Tailwind 4 theme (colors, fonts, radius)
+├── components.json                  # shadcn/ui config (style: new-york)
+├── package.json
+├── tsconfig.json
+└── vite.config.ts                   # Vite + Nitro + TanStack Start + Tailwind plugins
+```
+
+## Critical Files — Know Before Editing
+
+### `src/routes/__root.tsx` — App Shell
+
+Uses `shellComponent` (NOT `component`) to define the HTML document structure:
+
+```typescript
+import { HeadContent, Scripts, createRootRoute } from '@tanstack/react-router'
+import '@fontsource-variable/geist'
+import { ThemeProvider } from '../components/theme-provider'
+import appCss from '../styles.css?url'
+
+export const Route = createRootRoute({
+  head: () => ({
+    meta: [
+      { charSet: 'utf-8' },
+      { name: 'viewport', content: 'width=device-width, initial-scale=1' },
+      { title: 'Strayl' },
+    ],
+    links: [
+      { rel: 'stylesheet', href: appCss },
+      { rel: 'icon', href: '/favicon.ico' },
+    ],
+  }),
+  shellComponent: RootDocument,
+})
+
+function RootDocument({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en" suppressHydrationWarning>
+      <head><HeadContent /></head>
+      <body>
+        <ThemeProvider>{children}</ThemeProvider>
+        <Scripts />
+      </body>
+    </html>
+  )
+}
+```
+
+**To add auth context**, add `beforeLoad` — it works alongside `shellComponent`:
+```typescript
+export const Route = createRootRoute({
+  beforeLoad: async () => {
+    const user = await getUser();
+    return { user };
+  },
+  head: () => ({ ... }),
+  shellComponent: RootDocument,
+})
+```
+
+### `src/router.tsx` — Router Instance
+
+```typescript
+export const getRouter = () => {
+  const router = createRouter({
+    routeTree,
+    context: {},           // ← empty by default; auth adds user here
+    scrollRestoration: true,
+    defaultPreloadStaleTime: 0,
+  })
+  return router
+}
+```
+
+### `vite.config.ts` — Plugin Order Matters
+
+```typescript
+plugins: [
+  nitro(),                 // SSR / server functions
+  viteTsConfigPaths(),     // @/* path aliases
+  tailwindcss(),           // Tailwind CSS 4
+  tanstackStart(),         // TanStack Start framework
+  viteReact(),             // React Fast Refresh
+]
+```
+
+**Do NOT rewrite this file.** Use `edit_file` to add plugins if needed.
+
+### `src/styles.css` — Tailwind CSS 4 Theme
+
+Uses `@theme inline {}` directive (NOT `tailwind.config.js`):
+
+```css
+@import "tailwindcss";
+@import "tw-animate-css";
+
+@custom-variant dark (&:is(.dark *));
+@variant dark (&:where(.dark, .dark *));
+
+@theme inline {
+  --color-background: var(--background);
+  --color-primary: var(--primary);
+  --font-sans: "Geist Variable", ui-sans-serif, system-ui, sans-serif;
+  /* ... radius, animations */
+}
+
+:root { /* light theme colors */ }
+.dark { /* dark theme colors */ }
+```
+
+**To add custom colors**, edit the `:root` and `.dark` blocks. To add font families, add `@theme inline {}` entries.
+
+## UI Components
+
+The template ships with only **4 minimal starter components** in `src/components/ui/`: `button`, `input`, `label`, `textarea`. These are simple, unstyled wrappers — just enough to get started.
+
+### Adding More Components
+
+Use **shadcn/ui** to add any components you need:
+
+```bash
+npx shadcn@latest add card dialog sheet select badge separator scroll-area tabs accordion dropdown-menu
+```
+
+You can add any shadcn/ui component this way. Always install components as needed rather than building custom ones from scratch.
+
+### Important
+
+- **Do NOT hardcode a fixed set of UI components into every app.** Each app should have components appropriate for its purpose.
+- **Design each app's UI uniquely** — use different layouts, color schemes, and component combinations. Avoid repeating the same card/dialog/sheet pattern everywhere.
+- Use Tailwind CSS utility classes directly for custom layouts. Not everything needs a component wrapper.
+- For complex components (data tables, charts, calendars, etc.), install them via shadcn: `npx shadcn@latest add table chart calendar`
+
+## Protected Files — Edit Only, Never Rewrite
+
+- `package.json` — use `npm install <pkg>`, use `edit_file` for scripts
+- `tsconfig.json` — edit specific fields only
+- `vite.config.ts` — edit, don't rewrite (plugin order matters)
+- `src/styles.css` — append or edit (Tailwind @theme config)
+- `src/routes/__root.tsx` — edit carefully (fonts, providers, beforeLoad)
+- `src/routeTree.gen.ts` — NEVER edit (auto-generated by TanStack Router)
+
+## Best Practices
+
+- **Do NOT** use `npm create`, `npx create-vite`, or other scaffolding tools
+- Always use the `--name` flag to specify the project name
+- After creation, work inside the `{app-name}/` directory for all file edits
+- Start editing from `src/routes/index.tsx` and create new routes as files in `src/routes/`
+- Add UI components via `npx shadcn@latest add <component>` as needed — do NOT install alternative UI libraries (no MUI, Chakra, Ant Design, etc.)
+- New routes auto-register via TanStack Router file-based routing (the `routeTree.gen.ts` regenerates on dev server restart)
+- For protected routes, use the `_authed.tsx` layout pattern (see `authentication` skill)
+- For server-side logic, use `createServerFn` (see `api-creation` skill)
+- **Run `npm run build` after your first server function + route are written.** Build errors surface immediately when the codebase is small and easy to fix. Catching import/bundling errors early prevents hours of debugging later.
+- **NEVER use `await import()` for server functions in components.** Always static imports + `useServerFn()` for mutations. See `api-creation` skill for correct patterns.

package/src/agent.ts

@@ -1,465 +0,0 @@
-import type { AgentConfig, ToolCall, ToolContext, Middleware, Message, AgentMode, ActivityType } from "./types.js";
-import { Emitter } from "./emitter.js";
-import { LLMClient } from "./llm/client.js";
-import { getModelLimits, resolveModel } from "./llm/models.js";
-import { ContextManager } from "./context/manager.js";
-import { ToolRegistry } from "./tools/registry.js";
-import { executeTool } from "./tools/executor.js";
-import { HITLManager } from "./hitl/manager.js";
-import { SubAgentManager } from "./subagents/manager.js";
-import { TodoManager } from "./todos/manager.js";
-import { buildSystemPrompt } from "./prompts/system.js";
-import { loadSkills } from "./skills/loader.js";
-import { StdinListener } from "./stdin-listener.js";
-import { CheckpointManager } from "./checkpoints/manager.js";
-
-// Builtin tools
-import { execTool, getLogsTool } from "./tools/builtin/exec.js";
-import { readFileTool } from "./tools/builtin/read.js";
-import { writeFileTool } from "./tools/builtin/write.js";
-import { editFileTool } from "./tools/builtin/edit.js";
-import { lsTool } from "./tools/builtin/ls.js";
-import { grepTool } from "./tools/builtin/grep.js";
-import { globTool } from "./tools/builtin/glob.js";
-import { deleteFileTool } from "./tools/builtin/delete.js";
-import { moveFileTool } from "./tools/builtin/move.js";
-
-// External tools
-import { webSearchTool } from "./tools/external/web-search.js";
-import { webFetchTool } from "./tools/external/web-fetch.js";
-import { previewTool } from "./tools/external/preview.js";
-import { waitTool } from "./tools/external/wait.js";
-import { generateImageTool } from "./tools/external/generate-image.js";
-import { createTaskTool } from "./tools/external/task.js";
-import { enterPlanModeTool } from "./tools/external/enter-plan-mode.js";
-import { askUserTool, writePlanTool, requestEnvVarTool } from "./tools/external/hitl-tools.js";
-import { createDatabaseTool, listDatabasesTool, runDatabaseQueryTool, prepareDatabaseMigrationTool, completeDatabaseMigrationTool } from "./tools/external/database.js";
-
-// Middleware
-import { forbiddenPackagesMiddleware } from "./middleware/forbidden-packages.js";
-import { toolCompressionMiddleware } from "./middleware/tool-compression.js";
-import { createToolFilterMiddleware } from "./middleware/tool-filter.js";
-import { createPromptCachingMiddleware } from "./middleware/prompt-caching.js";
-import { credentialScrubbingMiddleware } from "./middleware/credential-scrubbing.js";
-import { createPlanModeMiddleware, resetContextForImplementation } from "./middleware/plan-mode.js";
-
-export async function runAgent(config: AgentConfig): Promise<void> {
-  const emitter = new Emitter();
-  const stdin = new StdinListener();
-  stdin.start();
-  const modelName = resolveModel(config.model);
-  const limits = getModelLimits(modelName);
-
-  // Mode state — mutable, changes on enterPlanMode tool or confirm-plan stdin command
-  let currentMode: AgentMode = config.mode ?? "normal";
-
-  const client = new LLMClient({
-    modelTier: config.model,
-    env: config.env,
-    sessionId: config.sessionId,
-  });
-
-  const context = new ContextManager({
-    maxInputTokens: limits.maxInputTokens,
-    summarizationThreshold: config.summarizationThreshold,
-    preSummarizationRatio: config.preSummarizationRatio,
-    previousSummary: config.previousSummary,
-  });
-
-  const registry = new ToolRegistry();
-  const hitl = new HITLManager(config.hitlDir);
-  await hitl.init();
-  const subAgentManager = new SubAgentManager(emitter);
-  const todoManager = new TodoManager(emitter);
-  const checkpoints = new CheckpointManager(config.workDir, config.sessionId);
-  await checkpoints.init();
-
-  // Register all tools
-  const builtinTools = [execTool, getLogsTool, readFileTool, writeFileTool, editFileTool, lsTool, grepTool, globTool, deleteFileTool, moveFileTool];
-  const databaseTools = [createDatabaseTool, listDatabasesTool, runDatabaseQueryTool, prepareDatabaseMigrationTool, completeDatabaseMigrationTool];
-  const externalTools = [webSearchTool, webFetchTool, previewTool, waitTool, generateImageTool, enterPlanModeTool, ...databaseTools];
-  const hitlTools = [askUserTool, writePlanTool, requestEnvVarTool];
-
-  for (const tool of [...builtinTools, ...externalTools, ...hitlTools]) {
-    registry.register(tool);
-  }
-  registry.register(createTaskTool(subAgentManager));
-  for (const tool of todoManager.createTools()) {
-    registry.register(tool);
-  }
-
-  // Build middleware
-  const middleware: Middleware[] = [
-    toolCompressionMiddleware,
-    forbiddenPackagesMiddleware,
-    credentialScrubbingMiddleware,
-    createToolFilterMiddleware(config.blockedTools ?? []),
-    createPlanModeMiddleware(() => currentMode),
-    createPromptCachingMiddleware(modelName),
-  ];
-
-  emitter.emit({ type: "session-start", model: modelName, session_id: config.sessionId });
-
-  // Load skills and build system prompt
-  const skills = await loadSkills(config.skillsDir ?? "./skills");
-  const systemPrompt = buildSystemPrompt({
-    workDir: config.workDir,
-    skills,
-    systemPromptExtra: config.systemPromptExtra,
-    mode: currentMode,
-  });
-
-  let iteration = 0;
-  const maxIterations = config.maxIterations ?? 200;
-
-  // Restore from checkpoint or start fresh
-  if (config.restoreCheckpoint) {
-    const cp = config.restoreCheckpoint;
-    context.restoreMessages(cp.messages);
-    todoManager.restore(cp.todos);
-    iteration = cp.iteration;
-    emitter.emit({ type: "checkpoint-restored", id: cp.id, iteration: cp.iteration });
-
-    // Inject new user message as continuation
-    context.addUser(config.userMessage);
-  } else {
-    context.addSystem(systemPrompt);
-    context.addUser(config.userMessage, config.images);
-  }
-
-  while (iteration < maxIterations) {
-    iteration++;
-
-    // Process stdin commands (inject, cancel, hitl-response, rollback)
-    for (const cmd of stdin.drain()) {
-      switch (cmd.type) {
-        case "inject":
-          context.addUser(cmd.text, cmd.images);
-          emitter.emit({ type: "inject-received", text: cmd.text });
-          break;
-        case "hitl-response":
-          // Forward to file-based HITL (stdin is an alternative transport)
-          await hitl.writeResponse(cmd.id, { decision: cmd.decision, data: cmd.data });
-          break;
-        case "confirm-plan": {
-          if (currentMode !== "plan") break;
-          const prevMode = currentMode;
-          currentMode = "implement";
-
-          // Context reset: extract plan, clear planning messages, inject plan as system context
-          const { newMessages, planContent } = resetContextForImplementation(context.messages());
-          context.restoreMessages(newMessages);
-
-          // Save confirmed plan to disk
-          if (planContent) {
-            const planDir = `${config.workDir}/.strayl/plans`;
-            const fs = await import("node:fs/promises");
-            const path = await import("node:path");
-            await fs.mkdir(planDir, { recursive: true });
-            const planFile = path.join(planDir, `${config.sessionId}-${Date.now()}.md`);
-            await fs.writeFile(planFile, planContent);
-            emitter.emit({ type: "plan-confirmed", plan: planContent });
-          }
-
-          emitter.emit({ type: "mode-changed", from: prevMode, to: currentMode });
-
-          // Inject implementation mode prompt into context
-          const { IMPLEMENTATION_MODE_PROMPT } = await import("./prompts/system.js");
-          context.addUser(`[System] The plan has been confirmed. Switch to implementation mode.\n\n${IMPLEMENTATION_MODE_PROMPT}`);
-          break;
-        }
-        case "rollback": {
-          const cp = cmd.checkpoint_id
-            ? checkpoints.get(cmd.checkpoint_id)
-            : cmd.iteration != null
-              ? checkpoints.getByIteration(cmd.iteration)
-              : checkpoints.latest();
-          if (cp) {
-            context.restoreMessages(cp.messages);
-            todoManager.restore(cp.todos);
-            iteration = cp.iteration;
-            emitter.emit({ type: "checkpoint-restored", id: cp.id, iteration: cp.iteration });
-          } else {
-            emitter.emit({ type: "error", message: "Checkpoint not found", recoverable: true });
-          }
-          break;
-        }
-      }
-    }
-
-    // Check cancellation (stdin or file-based)
-    if (stdin.isCancelled() || await hitl.isCancelled()) {
-      stdin.stop();
-      emitter.emit({ type: "session-end", usage: context.totalUsage(), exit_reason: "cancelled" });
-      return;
-    }
-
-    // Pre-summarization (non-blocking)
-    context.maybeTriggerPreSummarization(client, emitter);
-
-    // Apply pending summary if ready
-    await context.applyPendingSummary(emitter);
-
-    // Hard summarization (blocking)
-    if (context.shouldSummarize()) {
-      emitter.emit({
-        type: "summarizing",
-        token_count: context.estimateTokens(),
-        threshold: config.summarizationThreshold ?? 140_000,
-      });
-      await context.summarize(client, emitter);
-    }
-
-    // Hard trim if still over limit
-    if (context.estimateTokens() > context.maxInputTokens) {
-      context.applyTrim();
-    }
-
-    // Prepare messages + tools
-    let messages = context.messages();
-    let tools = registry.toOpenAITools(new Set(config.blockedTools));
-
-    // Apply middleware
-    for (const mw of middleware) {
-      if (mw.beforeModel) messages = mw.beforeModel(messages);
-      if (mw.filterTools) tools = mw.filterTools(tools);
-    }
-
-    // Stream LLM response
-    let assistantText = "";
-    const completedToolCalls: ToolCall[] = [];
-    const partialArgs = new Map<number, { id: string; name: string; args: string }>();
-
-    let cancelledDuringStream = false;
-    try {
-      for await (const chunk of client.stream(messages, tools)) {
-        // Check for cancellation during LLM streaming
-        if (stdin.isCancelled()) {
-          cancelledDuringStream = true;
-          break;
-        }
-
-        switch (chunk.type) {
-          case "text":
-            assistantText += chunk.text;
-            emitter.emit({ type: "text-delta", text: chunk.text });
-            break;
-
-          case "reasoning":
-            emitter.emit({ type: "reasoning-delta", text: chunk.text });
-            break;
-
-          case "tool_call_delta": {
-            const partial = partialArgs.get(chunk.index) ?? { id: "", name: "", args: "" };
-            if (chunk.id) partial.id = chunk.id;
-            if (chunk.name) partial.name = chunk.name;
-            partial.args += chunk.arguments;
-            partialArgs.set(chunk.index, partial);
-            break;
-          }
-
-          case "tool_call_complete":
-            completedToolCalls.push({
-              id: chunk.id,
-              type: "function",
-              function: { name: chunk.name, arguments: chunk.arguments },
-            });
-            break;
-
-          case "usage": {
-            context.recordUsage(chunk);
-            const used = context.estimateTokens();
-            const max = context.maxInputTokens;
-            const leftPercent = Math.max(0, Math.round((1 - used / max) * 100));
-            emitter.emit({
-              type: "usage-update",
-              input_tokens: chunk.input_tokens,
-              output_tokens: chunk.output_tokens,
-              cost: chunk.cost,
-              peak_input_tokens: context.peakInputTokens(),
-              context_left_percent: leftPercent,
-            });
-            break;
-          }
-        }
-      }
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      emitter.emit({ type: "error", message: `LLM error: ${msg}`, recoverable: true });
-
-      // Add error as assistant message so loop can continue
-      context.addAssistant(`[Error communicating with model: ${msg}]`);
-      continue;
-    }
-
-    // If cancelled during stream, exit immediately
-    if (cancelledDuringStream) {
-      if (assistantText) {
-        context.addAssistant(assistantText);
-      }
-      stdin.stop();
-      emitter.emit({ type: "session-end", usage: context.totalUsage(), exit_reason: "cancelled" });
-      return;
-    }
-
-    // Add assistant message to context
-    context.addAssistant(assistantText, completedToolCalls.length > 0 ? completedToolCalls : undefined);
-
-    // Emit context status after each LLM call
-    {
-      const used = context.estimateTokens();
-      const max = context.maxInputTokens;
-      const leftPercent = Math.max(0, Math.round((1 - used / max) * 100));
-      const usage = context.totalUsage();
-      emitter.emit({
-        type: "usage-update",
-        input_tokens: usage.input_tokens,
-        output_tokens: usage.output_tokens,
-        cost: usage.cost,
-        peak_input_tokens: context.peakInputTokens(),
-        context_left_percent: leftPercent,
-      });
-    }
-
-    // No tool calls = agent is done
-    if (completedToolCalls.length === 0) break;
-
-    // Execute tool calls
-    for (const tc of completedToolCalls) {
-      // Check cancellation between tool executions
-      if (stdin.isCancelled()) {
-        // Add cancelled tool results so context stays valid
-        context.addToolResult(tc.id, tc.function.name, JSON.stringify({ error: "Cancelled by user." }));
-        emitter.emit({ type: "tool-result", id: tc.id, name: tc.function.name, output: "Cancelled by user.", error: "Cancelled by user." });
-        break;
-      }
-
-      let parsedArgs: unknown;
-      try {
-        parsedArgs = JSON.parse(tc.function.arguments);
-      } catch {
-        parsedArgs = {};
-      }
-
-      // Emit semantic activity for UI indicators
-      const activity = toolToActivity(tc.function.name, parsedArgs);
-      if (activity) {
-        emitter.emit({ type: "activity", ...activity });
-      }
-
-      emitter.emit({ type: "tool-call-start", id: tc.id, name: tc.function.name, args: parsedArgs });
-
-      // HITL interrupt check
-      const toolDef = registry.get(tc.function.name);
-      if (toolDef?.hitl) {
-        emitter.emit({ type: "hitl-request", id: tc.id, safe_id: hitl.safeId(tc.id), tool: tc.function.name, args: parsedArgs });
-        const response = await hitl.waitForResponse(tc.id);
-
-        if (response.decision === "reject") {
-          const rejectResult = JSON.stringify({ error: "User rejected this action." });
-          emitter.emit({ type: "tool-result", id: tc.id, name: tc.function.name, output: rejectResult });
-          context.addToolResult(tc.id, tc.function.name, rejectResult);
-          continue;
-        }
-
-        if (response.decision === "edit" && response.data && typeof response.data === "object") {
-          parsedArgs = { ...(parsedArgs as Record<string, unknown>), ...(response.data as Record<string, unknown>) };
-        }
-
-        emitter.emit({ type: "hitl-response", id: tc.id, decision: response.decision, data: response.data });
-      }
-
-      // Execute with middleware chain
-      const toolCtx: ToolContext = {
-        emitter,
-        workDir: config.workDir,
-        env: config.env,
-        sessionId: config.sessionId,
-        toolCallId: tc.id,
-      };
-
-      const modifiedTc: ToolCall = {
-        ...tc,
-        function: { ...tc.function, arguments: JSON.stringify(parsedArgs) },
-      };
-
-      const result = await executeTool(registry, modifiedTc, toolCtx, middleware);
-
-      emitter.emit({ type: "tool-result", id: tc.id, name: tc.function.name, output: result });
-      context.addToolResult(tc.id, tc.function.name, result);
-
-      // Mode transition: enterPlanMode tool → switch to plan mode
-      if (tc.function.name === "enterPlanMode" && currentMode === "normal") {
-        const prevMode = currentMode;
-        currentMode = "plan";
-        emitter.emit({ type: "mode-changed", from: prevMode, to: currentMode });
-      }
-    }
-
-    // Save checkpoint after each complete iteration (LLM response + all tool results)
-    await checkpoints.save(iteration, context.messages(), todoManager.read(), context.totalUsage(), emitter);
-  }
-
-  if (iteration >= maxIterations) {
-    emitter.emit({
-      type: "error",
-      message: `Agent exceeded maximum iterations (${maxIterations})`,
-      recoverable: false,
-    });
-  }
-
-  stdin.stop();
-  emitter.emit({
-    type: "session-end",
-    usage: context.totalUsage(),
-    exit_reason: iteration >= maxIterations ? "max_iterations" : "complete",
-  });
-}
-
-/** Map tool name → semantic activity for UI indicators */
-function toolToActivity(
-  name: string,
-  args: unknown,
-): { activity: ActivityType; message?: string } | null {
-  const a = args as Record<string, unknown> | undefined;
-  switch (name) {
-    case "write_todos": {
-      const todos = a?.todos as unknown[] | undefined;
-      if (!todos || todos.length === 0) return { activity: "clearing-todos" };
-      return { activity: "creating-todos" };
-    }
-    case "update_todo":
-      return { activity: "updating-todos" };
-    case "askUser":
-      return { activity: "asking-user", message: a?.question as string };
-    case "writePlan":
-      return { activity: "planning", message: a?.title as string };
-    case "enterPlanMode":
-      return { activity: "planning", message: a?.reason as string };
-    case "create_database":
-      return { activity: "creating-database", message: a?.name as string };
-    case "run_database_query":
-      return { activity: "running-query" };
-    case "prepare_database_migration":
-    case "complete_database_migration":
-      return { activity: "running-migration" };
-    case "web_search":
-      return { activity: "searching-web", message: a?.query as string };
-    case "web_fetch":
-      return { activity: "fetching-page", message: a?.url as string };
-    case "generate_image":
-      return { activity: "generating-image" };
-    case "read_file":
-      return { activity: "reading-file", message: a?.path as string };
-    case "write_file":
-      return { activity: "writing-file", message: a?.path as string };
-    case "edit_file":
-      return { activity: "editing-file", message: a?.path as string };
-    case "exec":
-      return { activity: "running-command", message: (a?.command as string)?.slice(0, 80) };
-    case "task":
-      return { activity: "delegating-task", message: a?.description as string };
-    default:
-      return null;
-  }
-}