stack-agent 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,46 +1,484 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as p2 from "@clack/prompts";
+import React6 from "react";
+import { withFullScreen } from "fullscreen-ink";
 
-// src/cli/chat.ts
-import * as p from "@clack/prompts";
-import { Marked } from "marked";
-import { markedTerminal } from "marked-terminal";
-var marked = new Marked(markedTerminal());
-function renderMarkdown(text2) {
-  return marked.parse(text2).trimEnd();
+// src/cli/app.tsx
+import { useState as useState5, useEffect as useEffect2, useCallback } from "react";
+import { Box as Box7, Text as Text7, useApp, useInput as useInput3 } from "ink";
+import { useScreenSize } from "fullscreen-ink";
+
+// src/cli/components/header.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Header({ appName, currentStage, stages, showDots = false }) {
+  const stageName = currentStage?.label ?? "Stack Progress";
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderBottom: false, paddingX: 1, justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs(Box, { gap: 2, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: appName }),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: stageName })
+    ] }),
+    showDots && /* @__PURE__ */ jsx(Box, { gap: 0, children: stages.map((s, i) => /* @__PURE__ */ jsx(StageDot, { stage: s, isCurrent: s.id === currentStage?.id }, s.id)) })
+  ] });
 }
-function intro2() {
-  p.intro("stack-agent");
+function StageDot({ stage, isCurrent }) {
+  if (isCurrent) {
+    return /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u25CF" });
+  }
+  if (stage.status === "complete" && stage.confirmed) {
+    return /* @__PURE__ */ jsx(Text, { color: "green", children: "\u25CF" });
+  }
+  if (stage.status === "complete" && !stage.confirmed) {
+    return /* @__PURE__ */ jsx(Text, { color: "yellow", children: "\u25CF" });
+  }
+  if (stage.status === "skipped") {
+    return /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2013" });
+  }
+  return /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u25CB" });
 }
-function outro2(message) {
-  p.outro(message);
+
+// src/cli/components/footer.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function Footer({ progress, stages, terminalWidth, mode = "decisions" }) {
+  let display;
+  switch (mode) {
+    case "stage_list":
+      display = "\u2191\u2193 navigate \xB7 Enter select \xB7 Esc back";
+      break;
+    case "options":
+      display = "\u2191\u2193 navigate \xB7 Enter select \xB7 Esc stages";
+      break;
+    case "input":
+      display = "Enter submit \xB7 Esc stages";
+      break;
+    default:
+      display = buildDecisionsDisplay(progress, stages, terminalWidth);
+      break;
+  }
+  return /* @__PURE__ */ jsx2(Box2, { borderStyle: "single", borderTop: false, paddingX: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: display }) });
 }
-function renderError(text2) {
-  p.log.error(text2);
+function buildDecisionsDisplay(progress, stages, terminalWidth) {
+  const decisions = [];
+  if (progress.projectName) decisions.push(`Project: ${progress.projectName}`);
+  if (progress.frontend) decisions.push(`Frontend: ${progress.frontend.component}`);
+  if (progress.backend) decisions.push(`Backend: ${progress.backend.component}`);
+  if (progress.database) decisions.push(`DB: ${progress.database.component}`);
+  if (progress.auth) decisions.push(`Auth: ${progress.auth.component}`);
+  if (progress.payments) decisions.push(`Pay: ${progress.payments.component}`);
+  if (progress.ai) decisions.push(`AI: ${progress.ai.component}`);
+  if (progress.deployment) decisions.push(`Deploy: ${progress.deployment.component}`);
+  const nextStage = stages.find((s) => s.status === "pending");
+  const nextText = nextStage ? `Next: ${nextStage.label}` : "";
+  const separator = " \u2502 ";
+  let display = decisions.map((d) => `\u2713 ${d}`).join(separator);
+  if (nextText) {
+    display = display ? `${display}${separator}${nextText}` : nextText;
+  }
+  const maxWidth = terminalWidth - 4;
+  if (display.length > maxWidth) {
+    display = display.slice(0, maxWidth - 1) + "\u2026";
+  }
+  return display;
 }
-function renderPlan(plan) {
-  p.log.info(renderMarkdown(plan));
+
+// src/cli/components/conversation.tsx
+import { useState, useEffect } from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+import { Spinner } from "@inkjs/ui";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function ConversationView({ bridge, maxLines }) {
+  const [text, setText] = useState("");
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [showSpinner, setShowSpinner] = useState(false);
+  useEffect(() => {
+    const unsubs = [
+      bridge.subscribe("spinnerStart", () => {
+        setShowSpinner(true);
+        setIsStreaming(false);
+        setText("");
+      }),
+      bridge.subscribe("streamText", (delta) => {
+        setShowSpinner(false);
+        setIsStreaming(true);
+        setText((prev) => prev + delta);
+      }),
+      bridge.subscribe("streamEnd", () => {
+        setIsStreaming(false);
+      })
+    ];
+    return () => unsubs.forEach((fn) => fn());
+  }, [bridge]);
+  if (showSpinner) {
+    return /* @__PURE__ */ jsx3(Box3, { paddingX: 1, children: /* @__PURE__ */ jsx3(Spinner, { label: "Thinking..." }) });
+  }
+  const lines = text.split("\n");
+  const visible = lines.slice(-maxLines);
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", paddingX: 1, children: visible.map((line, i) => /* @__PURE__ */ jsx3(Text3, { children: line }, i)) });
 }
-async function getUserInput(message, placeholder) {
-  const result = await p.text({
-    message: message ?? "\u203A",
-    placeholder: placeholder ?? "Type your message..."
+
+// src/cli/components/option-select.tsx
+import { useState as useState2 } from "react";
+import { Box as Box4, Text as Text4, useInput } from "ink";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+function OptionSelect({ options, onSelect }) {
+  const [cursor, setCursor] = useState2(0);
+  const [textValue, setTextValue] = useState2("");
+  const totalItems = options.length + 1;
+  const isOnTextField = cursor === options.length;
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setCursor((c) => Math.max(0, c - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setCursor((c) => Math.min(totalItems - 1, c + 1));
+      return;
+    }
+    if (key.return) {
+      if (isOnTextField) {
+        if (textValue.trim()) {
+          onSelect({ kind: "text", value: textValue.trim() });
+        }
+      } else {
+        onSelect({ kind: "select", value: options[cursor].label });
+      }
+      return;
+    }
+    if (isOnTextField) {
+      if (key.backspace || key.delete) {
+        setTextValue((v) => v.slice(0, -1));
+      } else if (input && !key.ctrl && !key.meta && input.length === 1) {
+        setTextValue((v) => v + input);
+      }
+    }
   });
-  if (p.isCancel(result)) {
+  let hasRecommended = false;
+  return /* @__PURE__ */ jsxs2(Box4, { flexDirection: "column", paddingX: 1, children: [
+    options.map((opt, i) => {
+      const isHighlighted = cursor === i;
+      const pointer = isHighlighted ? "\u276F " : "  ";
+      let label = opt.label;
+      if (opt.recommended && !hasRecommended) {
+        label += " (Recommended)";
+        hasRecommended = true;
+      }
+      return /* @__PURE__ */ jsxs2(Box4, { children: [
+        /* @__PURE__ */ jsxs2(Text4, { color: isHighlighted ? "cyan" : void 0, children: [
+          pointer,
+          label
+        ] }),
+        opt.description && /* @__PURE__ */ jsxs2(Text4, { dimColor: true, children: [
+          " \u2014 ",
+          opt.description
+        ] })
+      ] }, opt.label);
+    }),
+    /* @__PURE__ */ jsxs2(Box4, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: isOnTextField ? "cyan" : void 0, children: isOnTextField ? "\u276F " : "  " }),
+      isOnTextField ? /* @__PURE__ */ jsxs2(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: textValue }),
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "\u258A" }),
+        !textValue && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " Type a question or suggestion..." })
+      ] }) : /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Type a question or suggestion..." })
+    ] })
+  ] });
+}
+
+// src/cli/components/stage-list.tsx
+import { useState as useState3 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput2 } from "ink";
+import { ConfirmInput } from "@inkjs/ui";
+
+// src/agent/progress.ts
+function createProgress() {
+  return {
+    projectName: null,
+    description: null,
+    frontend: null,
+    backend: null,
+    database: null,
+    auth: null,
+    payments: null,
+    ai: null,
+    deployment: null,
+    extras: []
+  };
+}
+function setDecision(progress, category, choice) {
+  if (category === "extras") {
+    return { ...progress, extras: [...progress.extras, choice] };
+  }
+  return { ...progress, [category]: choice };
+}
+function clearDecision(progress, category) {
+  if (category === "extras") {
+    return { ...progress, extras: [] };
+  }
+  return { ...progress, [category]: null };
+}
+function clearProjectInfo(progress) {
+  return { ...progress, projectName: null, description: null };
+}
+function isComplete(progress) {
+  return progress.projectName !== null && progress.description !== null && progress.frontend !== null && progress.database !== null && progress.deployment !== null;
+}
+function formatChoice(choice) {
+  if (choice === null) return "not yet decided";
+  return choice.component;
+}
+function serializeProgress(progress) {
+  const lines = [
+    `Project Name: ${progress.projectName ?? "not yet decided"}`,
+    `Description: ${progress.description ?? "not yet decided"}`,
+    `Frontend: ${formatChoice(progress.frontend)}`,
+    `Backend: ${formatChoice(progress.backend)}`,
+    `Database: ${formatChoice(progress.database)}`,
+    `Auth: ${formatChoice(progress.auth)}`,
+    `Payments: ${formatChoice(progress.payments)}`,
+    `AI/LLM: ${formatChoice(progress.ai)}`,
+    `Deployment: ${formatChoice(progress.deployment)}`,
+    `Extras: ${progress.extras.length > 0 ? progress.extras.map((e) => e.component).join(", ") : "not yet decided"}`
+  ];
+  return lines.join("\n");
+}
+function serializeSession(session) {
+  return JSON.stringify(session, null, 2);
+}
+function deserializeSession(json) {
+  try {
+    const data = JSON.parse(json);
+    if (data.version !== 1) return null;
+    if (!data.progress || !Array.isArray(data.stages) || !Array.isArray(data.messages)) return null;
+    return data;
+  } catch {
     return null;
   }
-  return result;
 }
-function createSpinner() {
-  return p.spinner();
+
+// src/cli/components/stage-list.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+function StageListView({ stages, currentStageId, progress, onResult }) {
+  const [showConfirm, setShowConfirm] = useState3(false);
+  const [showWarning, setShowWarning] = useState3("");
+  const [cursor, setCursor] = useState3(0);
+  const canBuild = isComplete(progress);
+  const itemCount = stages.length + 1;
+  useInput2((input, key) => {
+    if (showConfirm) return;
+    if (key.upArrow) {
+      setCursor((c) => Math.max(0, c - 1));
+      setShowWarning("");
+    }
+    if (key.downArrow) {
+      setCursor((c) => Math.min(itemCount - 1, c + 1));
+      setShowWarning("");
+    }
+    if (key.return) {
+      if (cursor < stages.length) {
+        onResult({ kind: "select", stageId: stages[cursor].id });
+      } else {
+        if (canBuild) {
+          setShowConfirm(true);
+        } else {
+          const missing = getMissingDecisions(progress);
+          setShowWarning(`Complete ${missing.join(", ")} first.`);
+        }
+      }
+    }
+    if (key.escape) {
+      onResult({ kind: "cancel" });
+    }
+  });
+  if (showConfirm) {
+    return /* @__PURE__ */ jsxs3(Box5, { flexDirection: "column", paddingX: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Ready to build this stack?" }),
+      /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(
+        ConfirmInput,
+        {
+          defaultChoice: "confirm",
+          onConfirm: () => onResult({ kind: "build" }),
+          onCancel: () => setShowConfirm(false)
+        }
+      ) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Box5, { flexDirection: "column", paddingX: 1, children: [
+    showWarning && /* @__PURE__ */ jsx5(Box5, { marginBottom: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: showWarning }) }),
+    stages.map((stage, i) => {
+      const isHighlighted = cursor === i;
+      const pointer = isHighlighted ? "\u276F " : "  ";
+      return /* @__PURE__ */ jsxs3(Box5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { children: pointer }),
+        /* @__PURE__ */ jsx5(StageLabel, { stage, isCurrent: stage.id === currentStageId })
+      ] }, stage.id);
+    }),
+    /* @__PURE__ */ jsxs3(Box5, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { children: cursor === stages.length ? "\u276F " : "  " }),
+      /* @__PURE__ */ jsx5(Text5, { color: canBuild ? "green" : "yellow", bold: cursor === stages.length, children: "\u2605 Build" }),
+      !canBuild && /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+        " (",
+        requiredRemaining(progress),
+        " remaining)"
+      ] })
+    ] })
+  ] });
+}
+function StageLabel({ stage, isCurrent }) {
+  if (stage.status === "complete" && stage.confirmed) {
+    return /* @__PURE__ */ jsxs3(Text5, { children: [
+      /* @__PURE__ */ jsxs3(Text5, { color: "green", children: [
+        "\u2713 ",
+        stage.label
+      ] }),
+      /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+        " \u2014 ",
+        stage.summary
+      ] })
+    ] });
+  }
+  if (stage.status === "complete" && !stage.confirmed) {
+    return /* @__PURE__ */ jsxs3(Text5, { children: [
+      /* @__PURE__ */ jsxs3(Text5, { color: "yellow", children: [
+        "\u25C6 ",
+        stage.label
+      ] }),
+      /* @__PURE__ */ jsxs3(Text5, { color: "yellow", dimColor: true, children: [
+        " \u2014 ",
+        stage.summary,
+        " (suggested)"
+      ] })
+    ] });
+  }
+  if (stage.status === "skipped") {
+    return /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+      "\u2013 ",
+      stage.label,
+      " \u2014 skipped"
+    ] });
+  }
+  if (isCurrent) {
+    return /* @__PURE__ */ jsxs3(Text5, { children: [
+      /* @__PURE__ */ jsxs3(Text5, { color: "cyan", bold: true, children: [
+        "\u25CF ",
+        stage.label
+      ] }),
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: " \u2190 needs your input" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+    "\u25CB ",
+    stage.label
+  ] });
+}
+function requiredRemaining(progress) {
+  let count = 0;
+  if (!progress.projectName) count++;
+  if (!progress.description) count++;
+  if (!progress.frontend) count++;
+  if (!progress.database) count++;
+  if (!progress.deployment) count++;
+  return count;
 }
-function writeText(text2) {
-  process.stdout.write(text2);
+function getMissingDecisions(progress) {
+  const missing = [];
+  if (!progress.projectName || !progress.description) missing.push("Project Info");
+  if (!progress.frontend) missing.push("Frontend");
+  if (!progress.database) missing.push("Database");
+  if (!progress.deployment) missing.push("Deployment");
+  return missing;
 }
-function writeLine() {
-  process.stdout.write("\n");
+
+// src/cli/app.tsx
+import { TextInput as TextInput2, Spinner as Spinner2 } from "@inkjs/ui";
+
+// src/cli/components/project-info-form.tsx
+import { useState as useState4 } from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+import { TextInput } from "@inkjs/ui";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function ProjectInfoForm({ onSubmit }) {
+  const [field, setField] = useState4("name");
+  const [name, setName] = useState4("");
+  return /* @__PURE__ */ jsxs4(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Let's set up your project" }),
+    /* @__PURE__ */ jsx6(Text6, { children: " " }),
+    field === "name" && /* @__PURE__ */ jsxs4(Box6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "Project name: " }),
+      /* @__PURE__ */ jsx6(
+        TextInput,
+        {
+          placeholder: "my-app",
+          onSubmit: (value) => {
+            if (value.trim()) {
+              setName(value.trim());
+              setField("description");
+            }
+          }
+        }
+      )
+    ] }),
+    field === "description" && /* @__PURE__ */ jsxs4(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Box6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "green", children: "\u2713 Project name: " }),
+        /* @__PURE__ */ jsx6(Text6, { children: name })
+      ] }),
+      /* @__PURE__ */ jsxs4(Box6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "What are you building: " }),
+        /* @__PURE__ */ jsx6(
+          TextInput,
+          {
+            placeholder: "a task management SaaS",
+            onSubmit: (value) => {
+              if (value.trim()) {
+                onSubmit(name, value.trim());
+              }
+            }
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx6(Text6, { children: " " }),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: field === "name" ? "Enter a name for your project" : "Briefly describe what you're building" })
+  ] });
+}
+
+// src/cli/bridge.ts
+function createBridge() {
+  const listeners = /* @__PURE__ */ new Map();
+  let pendingResolve = null;
+  function emit(event, ...args2) {
+    const set = listeners.get(event);
+    if (set) {
+      for (const fn of set) fn(...args2);
+    }
+  }
+  return {
+    onStreamText: (delta) => emit("streamText", delta),
+    onStreamEnd: (fullText) => emit("streamEnd", fullText),
+    onPresentOptions: (options) => emit("presentOptions", options),
+    onSpinnerStart: () => emit("spinnerStart"),
+    onStageComplete: (summary) => emit("stageComplete", summary),
+    onError: (error) => emit("error", error),
+    waitForInput: () => new Promise((resolve2) => {
+      pendingResolve = resolve2;
+    }),
+    resolveInput: (result) => {
+      if (pendingResolve) {
+        const resolve2 = pendingResolve;
+        pendingResolve = null;
+        resolve2(result);
+      }
+    },
+    subscribe: (event, listener) => {
+      if (!listeners.has(event)) listeners.set(event, /* @__PURE__ */ new Set());
+      listeners.get(event).add(listener);
+      return () => {
+        listeners.get(event)?.delete(listener);
+      };
+    }
+  };
 }
 
 // src/agent/loop.ts
@@ -48,6 +486,22 @@ import { join as join2 } from "path";
 
 // src/llm/client.ts
 import Anthropic from "@anthropic-ai/sdk";
+
+// src/util/logger.ts
+import pino from "pino";
+var logger = pino({
+  level: process.env.LOG_LEVEL ?? "info",
+  transport: process.env.NODE_ENV !== "production" ? { target: "pino-pretty", options: { destination: 2 } } : void 0
+}, process.env.NODE_ENV === "production" ? pino.destination(2) : void 0);
+function createLogger(component) {
+  return logger.child({ component });
+}
+
+// src/llm/client.ts
+var log = createLogger("llm");
+function summarizeMessages(messages) {
+  return `${messages.length} messages, last: ${messages.at(-1)?.role ?? "none"}`;
+}
 function getClient() {
   const apiKey = process.env.ANTHROPIC_API_KEY;
   if (!apiKey) {
@@ -66,6 +520,8 @@ function client() {
 }
 async function chat(options) {
   const { system, messages, tools, maxTokens, mcpServers } = options;
+  log.debug({ maxTokens, toolCount: tools?.length ?? 0, messages: summarizeMessages(messages) }, "chat request");
+  let response;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     const mcpServerList = Object.entries(mcpServers).map(([name, config]) => ({
       type: "url",
@@ -75,13 +531,13 @@ async function chat(options) {
         authorization_token: config.apiKey
       }
     }));
-    return client().beta.messages.create(
+    response = await client().beta.messages.create(
       {
         model: "claude-sonnet-4-6",
         max_tokens: maxTokens,
         system,
         messages,
-        tools,
+        ...tools && tools.length > 0 && { tools },
         mcp_servers: mcpServerList
       },
       {
@@ -90,28 +546,43 @@ async function chat(options) {
         }
       }
     );
+  } else {
+    response = await client().messages.create({
+      model: "claude-sonnet-4-6",
+      max_tokens: maxTokens,
+      system,
+      messages,
+      ...tools && tools.length > 0 && { tools }
+    });
   }
-  return client().messages.create({
-    model: "claude-sonnet-4-6",
-    max_tokens: maxTokens,
-    system,
-    messages,
-    tools
-  });
+  log.info({
+    stopReason: response.stop_reason,
+    contentBlocks: response.content.length,
+    usage: response.usage
+  }, "chat response");
+  log.debug({ content: response.content }, "chat response content");
+  return response;
 }
 async function chatStream(options, callbacks) {
   const { system, messages, tools, maxTokens } = options;
+  log.debug({ maxTokens, toolCount: tools?.length ?? 0, messages: summarizeMessages(messages) }, "chatStream request");
   const stream = client().messages.stream({
     model: "claude-sonnet-4-6",
     max_tokens: maxTokens,
     system,
     messages,
-    tools
+    ...tools && tools.length > 0 && { tools }
   });
-  stream.on("text", (text2) => {
-    callbacks.onText(text2);
+  stream.on("text", (text) => {
+    callbacks.onText(text);
   });
   const finalMessage = await stream.finalMessage();
+  log.info({
+    stopReason: finalMessage.stop_reason,
+    contentBlocks: finalMessage.content.length,
+    usage: finalMessage.usage
+  }, "chatStream response");
+  log.debug({ content: finalMessage.content }, "chatStream response content");
   for (const block of finalMessage.content) {
     if (block.type === "tool_use") {
       callbacks.onToolUse(block);
@@ -123,47 +594,6 @@ async function chatStream(options, callbacks) {
   });
 }
 
-// src/agent/progress.ts
-function createProgress() {
-  return {
-    projectName: null,
-    description: null,
-    frontend: null,
-    backend: null,
-    database: null,
-    auth: null,
-    payments: null,
-    ai: null,
-    deployment: null,
-    extras: []
-  };
-}
-function setDecision(progress, category, choice) {
-  if (category === "extras") {
-    return { ...progress, extras: [...progress.extras, choice] };
-  }
-  return { ...progress, [category]: choice };
-}
-function formatChoice(choice) {
-  if (choice === null) return "not yet decided";
-  return choice.component;
-}
-function serializeProgress(progress) {
-  const lines = [
-    `Project Name: ${progress.projectName ?? "not yet decided"}`,
-    `Description: ${progress.description ?? "not yet decided"}`,
-    `Frontend: ${formatChoice(progress.frontend)}`,
-    `Backend: ${formatChoice(progress.backend)}`,
-    `Database: ${formatChoice(progress.database)}`,
-    `Auth: ${formatChoice(progress.auth)}`,
-    `Payments: ${formatChoice(progress.payments)}`,
-    `AI/LLM: ${formatChoice(progress.ai)}`,
-    `Deployment: ${formatChoice(progress.deployment)}`,
-    `Extras: ${progress.extras.length > 0 ? progress.extras.map((e) => e.component).join(", ") : "not yet decided"}`
-  ];
-  return lines.join("\n");
-}
-
 // src/agent/tools.ts
 function conversationToolDefinitions() {
   return [
@@ -185,15 +615,6 @@ function conversationToolDefinitions() {
           reasoning: {
             type: "string",
             description: "Explanation for why this component was chosen."
-          },
-          scaffoldTool: {
-            type: "string",
-            description: "Optional CLI scaffold tool to use (e.g. create-next-app)."
-          },
-          scaffoldArgs: {
-            type: "array",
-            items: { type: "string" },
-            description: "Optional arguments to pass to the scaffold tool."
           }
         },
         required: ["category", "component", "reasoning"]
@@ -236,12 +657,27 @@ function conversationToolDefinitions() {
       }
     },
     {
-      name: "present_plan",
-      description: "Signals that all decisions have been made and the plan is ready to present.",
+      name: "present_options",
+      description: "Presents technology options for the user to choose from. The UI renders these as selectable items.",
       input_schema: {
         type: "object",
-        properties: {},
-        required: []
+        properties: {
+          options: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                label: { type: "string", description: "Short name of the option (max 30 chars)." },
+                description: { type: "string", description: "One-line description (max 80 chars)." },
+                recommended: { type: "boolean", description: "Whether this is recommended. At most one true." }
+              },
+              required: ["label", "description"]
+            },
+            minItems: 2,
+            maxItems: 3
+          }
+        },
+        required: ["options"]
       }
     }
   ];
@@ -288,6 +724,11 @@ function scaffoldToolDefinitions() {
             additionalProperties: { type: "string" },
             description: "Map of package names to versions to install as dev dependencies."
           },
+          scripts: {
+            type: "object",
+            additionalProperties: { type: "string" },
+            description: "Map of script names to commands to merge into package.json scripts."
+          },
           envVars: {
             type: "array",
             items: { type: "string" },
@@ -304,9 +745,7 @@ function executeConversationTool(name, input, progress, _messages) {
     const category = input.category;
     const choice = {
       component: input.component,
-      reasoning: input.reasoning,
-      ...input.scaffoldTool !== void 0 && { scaffoldTool: input.scaffoldTool },
-      ...input.scaffoldArgs !== void 0 && { scaffoldArgs: input.scaffoldArgs }
+      reasoning: input.reasoning
     };
     const updatedProgress = setDecision(progress, category, choice);
     return {
@@ -331,12 +770,8 @@ function executeConversationTool(name, input, progress, _messages) {
       response: input.summary
     };
   }
-  if (name === "present_plan") {
-    return {
-      progress,
-      response: "Plan is ready to present.",
-      signal: "present_plan"
-    };
+  if (name === "present_options") {
+    return { progress, response: "Options presented to user." };
   }
   return {
     progress,
@@ -344,25 +779,65 @@ function executeConversationTool(name, input, progress, _messages) {
   };
 }
 
+// src/agent/stages.ts
+var DEFAULT_STAGES = [
+  { id: "project_info", label: "Project Info", status: "pending", progressKeys: ["projectName", "description"] },
+  { id: "frontend", label: "Frontend", status: "pending", progressKeys: ["frontend"] },
+  { id: "backend", label: "Backend", status: "pending", progressKeys: ["backend"] },
+  { id: "database", label: "Database", status: "pending", progressKeys: ["database"] },
+  { id: "auth", label: "Auth", status: "pending", progressKeys: ["auth"] },
+  { id: "payments", label: "Payments", status: "pending", progressKeys: ["payments"] },
+  { id: "ai", label: "AI/LLM", status: "pending", progressKeys: ["ai"] },
+  { id: "deployment", label: "Deployment", status: "pending", progressKeys: ["deployment"] },
+  { id: "extras", label: "Extras", status: "pending", progressKeys: ["extras"] }
+];
+var STAGE_INSTRUCTIONS = {
+  project_info: "Ask for the project name and a brief description of what the user is building. Call set_project_info to record them.",
+  frontend: "Present 2-3 frontend framework options with trade-offs and your recommendation. Consider the project description when suggesting options.",
+  backend: "Present 2-3 backend/API options. Consider the chosen frontend \u2014 if it has built-in API routes (e.g., Next.js), that may be sufficient. If this stage is not needed, explain why and skip it.",
+  database: "Present 2-3 database options with ORM/query layer recommendations. Consider the chosen frontend and backend when suggesting options.",
+  auth: "Present 2-3 authentication options. If auth is not needed for this project, explain why and skip it.",
+  payments: "Present 2-3 payment processing options. If payments are not needed, explain why and skip it.",
+  ai: "Present 2-3 AI/LLM integration options. If AI is not needed, explain why and skip it.",
+  deployment: "Present 2-3 deployment platform options. Consider the chosen frontend and backend when suggesting options.",
+  extras: "Suggest any additional integrations that would benefit this project (analytics, email, monitoring, etc.). If none are needed, explain why and skip it."
+};
+
 // src/agent/system-prompt.ts
-function buildConversationPrompt(progress) {
+function buildConversationPrompt(progress, stageId, stages) {
+  const stage = stages.find((s) => s.id === stageId);
+  const stageLabel = stage?.label ?? stageId;
+  const instruction = STAGE_INSTRUCTIONS[stageId] ?? `Discuss the ${stageLabel} stage with the user.`;
+  const completedSummaries = stages.filter((s) => s.status === "complete" && s.summary).map((s) => `- ${s.label}: ${s.summary}`).join("\n");
+  const contextSection = completedSummaries ? `
+
+Context from previous stages:
+${completedSummaries}` : "";
   return `You are a senior software architect helping a developer set up a new project.
 
-Your job is to guide the user through selecting their technology stack by having a natural conversation. Work through these categories: frontend, backend, database, auth, payments, ai/llm, deployment, and any extras they might want.
+Current project state:
+${serializeProgress(progress)}
 
-Guidelines:
-- Present 2-3 concrete options per category, plus a "something else" option. Number them (1, 2, 3...) so users can respond quickly.
-- For each set of options, explicitly label your top pick with "(Recommended)" next to it and explain WHY it's the best fit for this specific project. Example: "1. Next.js (Recommended) \u2014 server components, built-in API routes...". Then briefly describe the alternatives and their trade-offs. Be opinionated \u2014 you are a senior architect, not a menu.
-- Keep the conversation focused and friendly. Ask one category at a time.
-- When the user decides on something, call \`set_decision\` to commit that decision before moving on.
-- Start by asking for a project name and a brief description of what they're building. Call \`set_project_info\` to record these before moving to stack decisions.
-- As conversations get long, call \`summarize_stage\` when completing each category to keep context manageable.
-- Once all decisions are made (frontend, database, and deployment are required; backend, auth, payments, and extras are optional), call \`present_plan\` to signal the plan is ready.
+## Current Stage: ${stageLabel}
 
-Do not ask the user to confirm each tool call \u2014 just make the calls naturally as decisions are reached.
+You are currently discussing the ${stageLabel} stage.
+${instruction}
 
-Current project state:
-${serializeProgress(progress)}`;
+Response guidelines:
+- When presenting technology choices, call \`present_options\` with 2-3 options. Do NOT write numbered lists in text.
+- Option labels: max 30 characters (just the name).
+- Option descriptions: max 80 characters (one-line trade-off summary).
+- Mark at most one option as recommended.
+- After a user selects an option, confirm in one short sentence (max 60 chars) and call set_decision immediately.
+- When answering questions, keep responses under 500 characters. Most answers should be 1-2 sentences. Only approach 500 chars for genuinely complex comparisons.
+- Never congratulate or explain why a choice is great. Just confirm and move on.
+${contextSection}
+
+Guidelines:
+- Focus on ${stageLabel}. Do not discuss other undecided stages.
+- When the user has made their choice, call \`set_decision\` to commit it, then call \`summarize_stage\` to summarize what was decided.
+- If this stage is not relevant to the project, briefly explain why and call \`summarize_stage\` to skip it.
+- Do not ask the user to confirm each tool call \u2014 just make the calls naturally as decisions are reached.`;
 }
 function buildScaffoldPrompt(progress) {
   return `You are scaffolding a new software project based on an approved plan.
@@ -375,6 +850,26 @@ Instructions:
 2. After scaffolding, call \`add_integration\` for each integration (database, auth, payments, deployment config, extras) to write necessary files, install dependencies, and declare required environment variables.
 3. Use MCP tools to look up current documentation for any libraries or frameworks you integrate, ensuring you use up-to-date APIs and configuration patterns.
 4. Generate complete, working code \u2014 no stubs, no placeholders, no TODO comments. Every file should be production-ready.
+5. Generate a \`deploy.sh\` script at the project root via \`add_integration\`. The script must:
+   - Start with \`set -euo pipefail\`
+   - Check that the required CLI tool is installed (exit 1 with a helpful message if not)
+   - Check authentication status (exit 1 with auth instructions if not)
+   - Print what it is about to do
+   - Execute the deploy command for the chosen platform
+   - Be 15-30 lines max \u2014 no elaborate bash framework
+   Use the \`scripts\` property of \`add_integration\` to add \`"deploy": "bash deploy.sh"\` to package.json.
+6. As the LAST \`add_integration\` call, generate a comprehensive \`README.md\` with these sections:
+   - **Project title and description**
+   - **Tech stack overview** \u2014 what was chosen and why
+   - **Prerequisites** \u2014 Node.js version, required CLI tools
+   - **Local development setup** \u2014 clone, \`npm install\`, configure \`.env\` from \`.env.example\`, \`npm run dev\`
+   - **Environment variables** \u2014 table with: variable name, what it is for, where to get it, required vs optional. Clearly state that \`.env\` is for local development only.
+   - **Deployment** \u2014 platform-specific instructions:
+     - How to install and authenticate the platform CLI
+     - How to set env vars ON THE PLATFORM (e.g. \`vercel env add\`, \`gcloud run services update --set-env-vars\`, AWS Parameter Store). Production env vars are NOT set via \`.env\` \u2014 they are configured through platform-native tools.
+     - The deploy command: \`npm run deploy\`
+     - Post-deploy verification steps
+   - **Project structure** \u2014 brief description of key directories and files
 
 Do not ask for confirmation. Proceed through all steps automatically.`;
 }
@@ -383,73 +878,7 @@ Do not ask for confirmation. Proceed through all steps automatically.`;
 import { execFileSync } from "child_process";
 import { readdirSync, existsSync } from "fs";
 import { join } from "path";
-var TOOL_ALLOWLIST = /* @__PURE__ */ new Set([
-  "create-next-app",
-  "create-vite",
-  "create-remix",
-  "create-svelte",
-  "create-astro",
-  "nuxi"
-]);
-var TOOL_FLAG_ALLOWLISTS = {
-  "create-next-app": /* @__PURE__ */ new Set([
-    "--typescript",
-    "--js",
-    "--tailwind",
-    "--no-tailwind",
-    "--eslint",
-    "--no-eslint",
-    "--app",
-    "--src-dir",
-    "--no-src-dir",
-    "--import-alias",
-    "--use-npm",
-    "--use-pnpm",
-    "--use-yarn",
-    "--use-bun"
-  ]),
-  "create-vite": /* @__PURE__ */ new Set(["--template"])
-};
-var URL_SCHEME_RE = /https?:|git\+|file:/i;
-var SHELL_META_RE = /[;&|`$(){}[\]<>!#~*?\n\r]/;
-var WHITESPACE_RE = /\s/;
-function validateScaffoldTool(tool, approvedTool) {
-  if (!TOOL_ALLOWLIST.has(tool)) {
-    throw new Error(`Scaffold tool not in allowlist: "${tool}"`);
-  }
-  if (tool !== approvedTool) {
-    throw new Error(`Scaffold tool "${tool}" does not match approved tool "${approvedTool}"`);
-  }
-}
-function validateScaffoldArgs(tool, args) {
-  const strictAllowlist = TOOL_FLAG_ALLOWLISTS[tool];
-  for (const arg of args) {
-    if (URL_SCHEME_RE.test(arg)) {
-      throw new Error(`Scaffold arg contains a URL scheme: "${arg}"`);
-    }
-    if (WHITESPACE_RE.test(arg)) {
-      throw new Error(`Scaffold arg contains whitespace: "${arg}"`);
-    }
-    if (SHELL_META_RE.test(arg)) {
-      throw new Error(`Scaffold arg contains shell metacharacters: "${arg}"`);
-    }
-    if (strictAllowlist !== void 0) {
-      const isFlag = arg.startsWith("--");
-      if (isFlag && !strictAllowlist.has(arg)) {
-        throw new Error(`Scaffold arg "${arg}" is not in the allowlist for tool "${tool}"`);
-      }
-    } else {
-      if (!arg.startsWith("--")) {
-        throw new Error(
-          `Scaffold arg "${arg}" must start with "--" for tool "${tool}"`
-        );
-      }
-    }
-  }
-}
-function runScaffold(tool, args, approvedTool, projectName, cwd) {
-  validateScaffoldTool(tool, approvedTool);
-  validateScaffoldArgs(tool, args);
+function runScaffold(tool, args2, projectName, cwd) {
   const outputDir = join(cwd, projectName);
   if (existsSync(outputDir)) {
     const entries = readdirSync(outputDir);
@@ -459,7 +888,7 @@ function runScaffold(tool, args, approvedTool, projectName, cwd) {
       );
     }
   }
-  const spawnArgs = [`${tool}@latest`, projectName, ...args];
+  const spawnArgs = [`${tool}@latest`, projectName, ...args2];
   const opts = { cwd, stdio: "pipe" };
   execFileSync("npx", spawnArgs, opts);
   return outputDir;
@@ -481,14 +910,14 @@ function validateFilePaths(projectRoot, files) {
   }
 }
 function writeIntegration(projectDir, input) {
-  const { files, dependencies, devDependencies, envVars } = input;
+  const { files, dependencies, devDependencies, scripts, envVars } = input;
   validateFilePaths(projectDir, files);
   for (const [filePath, content] of Object.entries(files)) {
     const fullPath = resolve(projectDir, filePath);
     mkdirSync(dirname(fullPath), { recursive: true });
     writeFileSync(fullPath, content, "utf8");
   }
-  if (dependencies !== void 0 || devDependencies !== void 0) {
+  if (dependencies !== void 0 || devDependencies !== void 0 || scripts !== void 0) {
     const pkgPath = resolve(projectDir, "package.json");
     let pkg = {};
     if (existsSync2(pkgPath)) {
@@ -506,6 +935,12 @@ function writeIntegration(projectDir, input) {
         ...devDependencies
       };
     }
+    if (scripts !== void 0) {
+      pkg.scripts = {
+        ...pkg.scripts,
+        ...scripts
+      };
+    }
     writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
   }
   if (envVars !== void 0 && envVars.length > 0) {
@@ -516,15 +951,20 @@ function writeIntegration(projectDir, input) {
 }
 
 // src/agent/loop.ts
-async function runConversationLoop(mcpServers) {
-  let progress = createProgress();
-  const messages = [];
-  messages.push({ role: "user", content: "I want to start a new project." });
+async function runStageLoop(stage, manager, bridge, mcpServers) {
+  const messages = manager.messages;
+  let progress = manager.progress;
+  if (messages.length === 0) {
+    messages.push({ role: "user", content: "I want to start a new project." });
+  }
+  let hasCalledSetDecision = false;
   while (true) {
-    const system = buildConversationPrompt(progress);
+    const system = buildConversationPrompt(progress, stage.id, manager.stages);
     let contentBlocks = [];
     const collectedToolUse = [];
     let hasText = false;
+    let fullText = "";
+    bridge.onSpinnerStart();
     await chatStream(
       {
         system,
@@ -535,11 +975,9 @@ async function runConversationLoop(mcpServers) {
       },
       {
         onText: (delta) => {
-          if (!hasText) {
-            hasText = true;
-            writeText("\n");
-          }
-          writeText(delta);
+          hasText = true;
+          fullText += delta;
+          bridge.onStreamText(delta);
         },
         onToolUse: (block) => {
           collectedToolUse.push(block);
@@ -550,18 +988,31 @@ async function runConversationLoop(mcpServers) {
       }
     );
     if (hasText) {
-      writeLine();
-      writeLine();
+      bridge.onStreamText("\n");
     }
     const toolUseBlocks = collectedToolUse;
     if (toolUseBlocks.length > 0) {
       messages.push({ role: "assistant", content: contentBlocks });
       const toolResults = [];
-      let hasPresentPlan = false;
       let hasSummarizeStage = false;
       let summarizeSummary = "";
+      let madeDecision = false;
       for (const block of toolUseBlocks) {
         const toolBlock = block;
+        if (toolBlock.name === "present_options") {
+          const options = toolBlock.input.options;
+          bridge.onPresentOptions(options);
+          const input = await bridge.waitForInput();
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: toolBlock.id,
+            content: input.kind === "select" ? `User selected: ${input.value}` : input.kind === "text" ? `User wrote: ${input.value}` : "User cancelled."
+          });
+          if (input.kind === "cancel") {
+            return { outcome: "cancel" };
+          }
+          continue;
+        }
         const result = executeConversationTool(
           toolBlock.name,
           toolBlock.input,
@@ -569,13 +1020,15 @@ async function runConversationLoop(mcpServers) {
           messages
         );
         progress = result.progress;
+        manager.progress = progress;
         toolResults.push({
           type: "tool_result",
           tool_use_id: toolBlock.id,
           content: result.response
         });
-        if (result.signal === "present_plan") {
-          hasPresentPlan = true;
+        if (toolBlock.name === "set_decision" || toolBlock.name === "set_project_info") {
+          madeDecision = true;
+          hasCalledSetDecision = true;
         }
         if (toolBlock.name === "summarize_stage") {
           hasSummarizeStage = true;
@@ -583,36 +1036,45 @@ async function runConversationLoop(mcpServers) {
         }
       }
       messages.push({ role: "user", content: toolResults });
+      if (madeDecision || hasSummarizeStage) {
+        manager.save();
+      }
       if (hasSummarizeStage) {
         const lastAssistant = messages[messages.length - 2];
         const lastUser = messages[messages.length - 1];
         messages.length = 0;
-        messages.push({
-          role: "assistant",
-          content: summarizeSummary
-        });
-        messages.push({
-          role: "user",
-          content: "[Continuing]"
-        });
+        messages.push({ role: "assistant", content: summarizeSummary });
+        messages.push({ role: "user", content: "[Continuing]" });
         messages.push(lastAssistant);
         messages.push(lastUser);
+        manager.messages = messages;
       }
-      if (hasPresentPlan) {
-        renderPlan(serializeProgress(progress));
-        return progress;
+      if (hasSummarizeStage) {
+        if (hasCalledSetDecision || stage.id === "project_info") {
+          return { outcome: "complete", summary: summarizeSummary };
+        }
+        return { outcome: "skipped" };
       }
       continue;
     }
-    const userInput = await getUserInput("Your response");
-    if (userInput === null) return null;
+    bridge.onStreamEnd(fullText);
+    const inputResult = await bridge.waitForInput();
+    if (inputResult.kind === "cancel") return { outcome: "cancel" };
+    if (inputResult.kind === "navigate") return { outcome: "navigate" };
     messages.push({
       role: "assistant",
       content: contentBlocks
     });
-    messages.push({ role: "user", content: userInput });
+    messages.push({ role: "user", content: inputResult.value });
   }
 }
+function createSimpleSpinner() {
+  return {
+    start: (msg) => process.stdout.write(`  ${msg}...`),
+    stop: (msg) => process.stdout.write(` ${msg}
+`)
+  };
+}
 async function runScaffoldLoop(progress, mcpServers) {
   const messages = [];
   const system = buildScaffoldPrompt(progress);
@@ -646,22 +1108,20 @@ async function runScaffoldLoop(progress, mcpServers) {
       const toolBlock = block;
       toolCallCount++;
       if (toolCallCount > maxToolCalls) {
-        renderError(`Tool call limit exceeded (${maxToolCalls}). Stopping scaffold loop.`);
+        console.error(`Tool call limit exceeded (${maxToolCalls}). Stopping scaffold loop.`);
         return false;
       }
-      const spinner2 = createSpinner();
+      const spinner = createSimpleSpinner();
       try {
         if (toolBlock.name === "run_scaffold") {
-          spinner2.start(`Running scaffold: ${toolBlock.input.tool}`);
-          const approvedTool = findApprovedScaffoldTool(progress);
+          spinner.start(`Running scaffold: ${toolBlock.input.tool}`);
           const outputDir = runScaffold(
             toolBlock.input.tool,
             toolBlock.input.args,
-            approvedTool,
             projectName,
             cwd
           );
-          spinner2.stop(`Scaffold complete: ${outputDir}`);
+          spinner.stop(`Scaffold complete: ${outputDir}`);
           toolResults.push({
             type: "tool_result",
             tool_use_id: toolBlock.id,
@@ -671,21 +1131,22 @@ async function runScaffoldLoop(progress, mcpServers) {
           const integrationDesc = Object.keys(
             toolBlock.input.files ?? {}
           ).join(", ");
-          spinner2.start(`Adding integration: ${integrationDesc}`);
+          spinner.start(`Adding integration: ${integrationDesc}`);
           writeIntegration(projectDir, {
             files: toolBlock.input.files ?? {},
             dependencies: toolBlock.input.dependencies,
             devDependencies: toolBlock.input.devDependencies,
+            scripts: toolBlock.input.scripts,
             envVars: toolBlock.input.envVars
           });
-          spinner2.stop("Integration added");
+          spinner.stop("Integration added");
           toolResults.push({
             type: "tool_result",
             tool_use_id: toolBlock.id,
             content: "Integration written successfully."
           });
         } else {
-          spinner2.stop(`Unknown tool: ${toolBlock.name}`);
+          spinner.stop(`Unknown tool: ${toolBlock.name}`);
           toolResults.push({
             type: "tool_result",
             tool_use_id: toolBlock.id,
@@ -695,7 +1156,7 @@ async function runScaffoldLoop(progress, mcpServers) {
         }
       } catch (err) {
         const errorMessage = err instanceof Error ? err.message : String(err);
-        spinner2.stop(`Error: ${errorMessage}`);
+        spinner.stop(`Error: ${errorMessage}`);
         toolResults.push({
           type: "tool_result",
           tool_use_id: toolBlock.id,
@@ -707,59 +1168,841 @@ async function runScaffoldLoop(progress, mcpServers) {
     messages.push({ role: "user", content: toolResults });
   }
 }
-function findApprovedScaffoldTool(progress) {
+
+// src/agent/recommend.ts
+var log2 = createLogger("recommend");
+var RECOMMEND_PROMPT = `You are a senior software architect. Based on the project description, recommend a complete technology stack.
+
+For each category, provide your recommendation as a JSON object. If a category is not needed for this project, set it to null.
+
+Respond with ONLY a JSON object in this exact format:
+{
+  "frontend": { "component": "Next.js", "reasoning": "Best for SaaS with built-in API routes" },
+  "backend": null,
+  "database": { "component": "Postgres + Drizzle", "reasoning": "Relational with great TypeScript support" },
+  "auth": { "component": "Clerk", "reasoning": "Drop-in auth with good DX" },
+  "payments": null,
+  "ai": null,
+  "deployment": { "component": "Vercel", "reasoning": "Native Next.js support" },
+  "extras": null
+}
+
+Rules:
+- Be opinionated. Pick the best option, not the most popular.
+- Set categories to null if they are genuinely not needed for this project.
+- Keep reasoning under 80 characters.
+- component names should be max 30 characters.`;
+async function getRecommendations(projectName, description) {
+  try {
+    const response = await chat({
+      system: RECOMMEND_PROMPT,
+      messages: [{
+        role: "user",
+        content: `Project: "${projectName}"
+Description: ${description}`
+      }],
+      maxTokens: 1024
+    });
+    const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    log2.info({ rawLength: text.length }, "received recommendation response");
+    log2.debug({ rawText: text }, "recommendation raw text");
+    const jsonStr = text.replace(/^```(?:json)?\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+    const parsed = JSON.parse(jsonStr);
+    const categories = Object.keys(parsed).filter((k) => parsed[k] !== null);
+    log2.info({ recommended: categories, skipped: Object.keys(parsed).filter((k) => parsed[k] === null) }, "parsed recommendations");
+    return parsed;
+  } catch (err) {
+    log2.error({ err }, "recommendation pass failed");
+    return {};
+  }
+}
+function applyRecommendations(progress, stages, recommendations) {
+  let updated = { ...progress };
   const categories = [
-    progress.frontend,
-    progress.backend,
-    progress.database,
-    progress.auth,
-    progress.payments,
-    progress.deployment,
-    ...progress.extras
+    "frontend",
+    "backend",
+    "database",
+    "auth",
+    "payments",
+    "ai",
+    "deployment"
   ];
-  for (const choice of categories) {
-    if (choice?.scaffoldTool) {
-      return choice.scaffoldTool;
+  for (const category of categories) {
+    if (!(category in recommendations)) continue;
+    const rec = recommendations[category];
+    const stage = stages.find((s) => s.id === category);
+    if (!stage) continue;
+    if (rec) {
+      updated = setDecision(updated, category, {
+        component: rec.component,
+        reasoning: rec.reasoning
+      });
+      stage.status = "complete";
+      stage.summary = rec.component;
+      stage.confirmed = false;
+    } else {
+      stage.status = "skipped";
+      stage.summary = "not needed";
+      stage.confirmed = false;
     }
   }
-  return "";
+  const extrasStage = stages.find((s) => s.id === "extras");
+  if (extrasStage && !recommendations["extras"]) {
+    extrasStage.status = "skipped";
+    extrasStage.summary = "none suggested";
+    extrasStage.confirmed = false;
+  }
+  return { progress: updated, stages };
+}
+
+// src/cli/app.tsx
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function App({ manager, onBuild, onExit }) {
+  const app = useApp();
+  const { width, height } = useScreenSize();
+  const [view, setView] = useState5(
+    manager.progress.projectName ? "stage_list" : "project_info"
+  );
+  const [bridge] = useState5(() => createBridge());
+  const [currentStage, setCurrentStage] = useState5(manager.currentStage());
+  const [progress, setProgress] = useState5(manager.progress);
+  const [stages, setStages] = useState5([...manager.stages]);
+  const [options, setOptions] = useState5([]);
+  const [errorMsg, setErrorMsg] = useState5("");
+  const syncState = useCallback(() => {
+    setProgress({ ...manager.progress });
+    setStages([...manager.stages]);
+    setCurrentStage(manager.currentStage());
+  }, [manager]);
+  useEffect2(() => {
+    const unsubs = [
+      bridge.subscribe("presentOptions", (opts) => {
+        setOptions(opts);
+        setView("options");
+      }),
+      bridge.subscribe("streamEnd", () => {
+        setView("input");
+      }),
+      bridge.subscribe("spinnerStart", () => {
+        setView("conversation");
+      }),
+      bridge.subscribe("error", (err) => {
+        setErrorMsg(err.message);
+        setView("error");
+      })
+    ];
+    return () => unsubs.forEach((fn) => fn());
+  }, [bridge]);
+  useInput3((_input, key) => {
+    if (key.escape && view !== "stage_list") {
+      bridge.resolveInput({ kind: "cancel" });
+      setView("stage_list");
+      syncState();
+    }
+  }, { isActive: view === "conversation" || view === "error" });
+  const runStage = useCallback(async (stageId) => {
+    const stage = manager.stages.find((s) => s.id === stageId);
+    if (!stage) return;
+    setCurrentStage(stage);
+    setView("conversation");
+    try {
+      const result = await runStageLoop(stage, manager, bridge);
+      switch (result.outcome) {
+        case "complete":
+          manager.completeStage(stageId, result.summary);
+          const completedStage = manager.stages.find((s) => s.id === stageId);
+          if (completedStage) completedStage.confirmed = true;
+          manager.save();
+          break;
+        case "skipped":
+          manager.skipStage(stageId);
+          manager.save();
+          break;
+        case "cancel":
+          manager.restorePendingNavigation();
+          break;
+      }
+    } catch (err) {
+      setErrorMsg(err.message);
+      setView("error");
+      return;
+    }
+    syncState();
+    setView("stage_list");
+  }, [manager, bridge, syncState]);
+  const handleStageResult = useCallback((result) => {
+    if (result.kind === "select") {
+      const stage = manager.stages.find((s) => s.id === result.stageId);
+      if (stage && (stage.status === "complete" || stage.status === "skipped")) {
+        manager.navigateTo(result.stageId);
+        syncState();
+      }
+      runStage(result.stageId);
+    } else if (result.kind === "build") {
+      onBuild();
+      app.exit();
+    } else if (result.kind === "cancel") {
+      manager.save();
+      onExit();
+      app.exit();
+    }
+  }, [manager, runStage, syncState, onBuild, onExit, app]);
+  const handleOptionSelect = useCallback((result) => {
+    setView("conversation");
+    bridge.resolveInput(result);
+  }, [bridge]);
+  const handleTextSubmit = useCallback((value) => {
+    setView("conversation");
+    bridge.resolveInput({ kind: "text", value });
+  }, [bridge]);
+  const handleProjectInfo = useCallback(async (name, description) => {
+    manager.progress = {
+      ...manager.progress,
+      projectName: name,
+      description
+    };
+    const stage = manager.stages.find((s) => s.id === "project_info");
+    if (stage) {
+      stage.status = "complete";
+      stage.confirmed = true;
+      stage.summary = `${name}: ${description}`;
+    }
+    manager.save();
+    syncState();
+    setView("loading");
+    try {
+      const recommendations = await getRecommendations(name, description);
+      const { progress: updatedProgress } = applyRecommendations(
+        manager.progress,
+        manager.stages,
+        recommendations
+      );
+      manager.progress = updatedProgress;
+      manager.save();
+    } catch (err) {
+      console.error("Recommendation pass failed:", err);
+    }
+    syncState();
+    setView("stage_list");
+  }, [manager, syncState]);
+  const footerMode = view === "stage_list" ? "stage_list" : view === "options" ? "options" : view === "input" || view === "project_info" ? "input" : "decisions";
+  const contentHeight = height - 4;
+  return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", width, height, children: [
+    /* @__PURE__ */ jsx7(
+      Header,
+      {
+        appName: "stack-agent",
+        currentStage: view === "stage_list" ? null : currentStage,
+        stages,
+        showDots: view !== "stage_list"
+      }
+    ),
+    /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", height: contentHeight, paddingX: 1, borderStyle: "single", borderTop: false, borderBottom: false, children: [
+      view === "project_info" && /* @__PURE__ */ jsx7(ProjectInfoForm, { onSubmit: handleProjectInfo }),
+      view === "loading" && /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", children: /* @__PURE__ */ jsx7(Spinner2, { label: "Analyzing your project and recommending a stack..." }) }),
+      view === "stage_list" && /* @__PURE__ */ jsx7(
+        StageListView,
+        {
+          stages,
+          currentStageId: currentStage?.id ?? null,
+          progress,
+          onResult: handleStageResult
+        }
+      ),
+      view === "conversation" && /* @__PURE__ */ jsx7(ConversationView, { bridge, maxLines: contentHeight }),
+      view === "input" && /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx7(ConversationView, { bridge, maxLines: contentHeight - 3 }),
+        /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(
+          TextInput2,
+          {
+            placeholder: "Type your response...",
+            onSubmit: handleTextSubmit
+          }
+        ) })
+      ] }),
+      view === "options" && /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx7(ConversationView, { bridge, maxLines: contentHeight - 8 }),
+        /* @__PURE__ */ jsx7(OptionSelect, { options, onSelect: handleOptionSelect })
+      ] }),
+      view === "error" && /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs5(Text7, { color: "red", bold: true, children: [
+          "Error: ",
+          errorMsg
+        ] }),
+        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Press Esc to return to stage list" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx7(
+      Footer,
+      {
+        progress,
+        stages,
+        terminalWidth: width,
+        mode: footerMode
+      }
+    )
+  ] });
+}
+
+// src/agent/stage-manager.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync, unlinkSync, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var SESSION_FILE = ".stack-agent.json";
+var SESSION_VERSION = 1;
+var StageManager = class _StageManager {
+  session;
+  filePath;
+  onInvalidate;
+  pendingNavigation;
+  constructor(session, cwd, onInvalidate) {
+    this.session = session;
+    this.filePath = join3(cwd, SESSION_FILE);
+    this.onInvalidate = onInvalidate;
+  }
+  static start(cwd, onInvalidate) {
+    const session = {
+      version: SESSION_VERSION,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      progress: createProgress(),
+      stages: structuredClone(DEFAULT_STAGES),
+      messages: []
+    };
+    return new _StageManager(session, cwd, onInvalidate);
+  }
+  static resume(cwd, onInvalidate) {
+    const session = _StageManager.detect(cwd);
+    if (!session) return null;
+    return new _StageManager(session, cwd, onInvalidate);
+  }
+  static detect(cwd) {
+    const filePath = join3(cwd, SESSION_FILE);
+    if (!existsSync3(filePath)) return null;
+    try {
+      const json = readFileSync2(filePath, "utf-8");
+      return deserializeSession(json);
+    } catch {
+      return null;
+    }
+  }
+  // --- Stage navigation ---
+  currentStage() {
+    return this.session.stages.find((s) => s.status === "pending") ?? null;
+  }
+  completeStage(id, summary) {
+    const stage = this.session.stages.find((s) => s.id === id);
+    if (!stage) return;
+    stage.status = "complete";
+    stage.summary = summary;
+    this.session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (this.pendingNavigation?.stageId === id) {
+      this.pendingNavigation = void 0;
+    }
+  }
+  skipStage(id) {
+    const stage = this.session.stages.find((s) => s.id === id);
+    if (!stage) return;
+    stage.status = "skipped";
+    this.session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  navigateTo(id) {
+    const stage = this.session.stages.find((s) => s.id === id);
+    if (!stage) return;
+    if (stage.status === "complete") {
+      if (id === "project_info") {
+        this.pendingNavigation = {
+          stageId: id,
+          oldValue: null,
+          oldProjectInfo: {
+            projectName: this.session.progress.projectName,
+            description: this.session.progress.description
+          },
+          oldSummary: stage.summary
+        };
+      } else {
+        const key = stage.progressKeys[0];
+        const oldValue = key === "extras" ? null : this.session.progress[key] ?? null;
+        this.pendingNavigation = {
+          stageId: id,
+          oldValue,
+          oldSummary: stage.summary
+        };
+      }
+    }
+    stage.status = "pending";
+    stage.summary = void 0;
+  }
+  restorePendingNavigation() {
+    if (!this.pendingNavigation) return;
+    const { stageId, oldValue, oldProjectInfo, oldSummary } = this.pendingNavigation;
+    const stage = this.session.stages.find((s) => s.id === stageId);
+    if (!stage) return;
+    if (stageId === "project_info" && oldProjectInfo) {
+      this.session.progress = {
+        ...this.session.progress,
+        projectName: oldProjectInfo.projectName,
+        description: oldProjectInfo.description
+      };
+    } else if (stageId !== "project_info") {
+      const category = stageId;
+      if (oldValue) {
+        this.session.progress = { ...this.session.progress, [category]: oldValue };
+      }
+    }
+    stage.status = "complete";
+    stage.summary = oldSummary;
+    this.pendingNavigation = void 0;
+  }
+  isNavigating() {
+    return this.pendingNavigation !== void 0;
+  }
+  getPendingOldValue() {
+    return this.pendingNavigation?.oldValue ?? null;
+  }
+  // --- Dynamic stages ---
+  addStage(entry, afterId) {
+    const idx = this.session.stages.findIndex((s) => s.id === afterId);
+    if (idx === -1) {
+      this.session.stages.push(entry);
+    } else {
+      this.session.stages.splice(idx + 1, 0, entry);
+    }
+    this.session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  removeStage(id) {
+    this.session.stages = this.session.stages.filter((s) => s.id !== id);
+    this.session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  // --- Cascading invalidation ---
+  async invalidateAfter(changedId, oldValue) {
+    if (!this.onInvalidate) return;
+    const stage = this.session.stages.find((s) => s.id === changedId);
+    if (!stage) return;
+    const key = stage.progressKeys[0];
+    const newValue = key === "extras" || key === "projectName" || key === "description" ? null : this.session.progress[key] ?? null;
+    const result = await this.onInvalidate(
+      changedId,
+      oldValue,
+      newValue,
+      this.session.progress,
+      this.session.stages
+    );
+    const changedIdx = this.session.stages.findIndex((s) => s.id === changedId);
+    for (const clearId of result.clear) {
+      const clearIdx = this.session.stages.findIndex((s) => s.id === clearId);
+      if (clearIdx <= changedIdx) continue;
+      const clearStage = this.session.stages[clearIdx];
+      if (!clearStage) continue;
+      for (const pKey of clearStage.progressKeys) {
+        if (pKey === "projectName" || pKey === "description") {
+          this.session.progress = clearProjectInfo(this.session.progress);
+        } else if (pKey === "extras") {
+          this.session.progress = clearDecision(this.session.progress, "extras");
+        } else {
+          this.session.progress = clearDecision(this.session.progress, pKey);
+        }
+      }
+      clearStage.status = "pending";
+      clearStage.summary = void 0;
+    }
+    for (const removeId of result.remove) {
+      const removeIdx = this.session.stages.findIndex((s) => s.id === removeId);
+      if (removeIdx <= changedIdx) continue;
+      this.removeStage(removeId);
+    }
+    let insertAfterId = changedId;
+    for (const newStage of result.add) {
+      this.addStage(newStage, insertAfterId);
+      insertAfterId = newStage.id;
+    }
+    this.session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  // --- Persistence ---
+  save() {
+    this.session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const json = serializeSession(this.session);
+    if (json.length > 5e5) {
+      console.warn("Warning: session file exceeds 500KB. Consider summarizing more aggressively.");
+    }
+    try {
+      const tmpPath = this.filePath + ".tmp";
+      writeFileSync2(tmpPath, json, "utf-8");
+      renameSync(tmpPath, this.filePath);
+    } catch (err) {
+      console.warn(`Warning: failed to save session: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  cleanup() {
+    try {
+      if (existsSync3(this.filePath)) unlinkSync(this.filePath);
+      const tmpPath = this.filePath + ".tmp";
+      if (existsSync3(tmpPath)) unlinkSync(tmpPath);
+    } catch {
+    }
+  }
+  // --- Accessors ---
+  get progress() {
+    return this.session.progress;
+  }
+  set progress(value) {
+    this.session.progress = value;
+  }
+  get messages() {
+    return this.session.messages;
+  }
+  set messages(value) {
+    this.session.messages = value;
+  }
+  get stages() {
+    return this.session.stages;
+  }
+  get updatedAt() {
+    return this.session.updatedAt;
+  }
+};
+
+// src/cli/chat.ts
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+var marked = new Marked(markedTerminal());
+function renderPostScaffold(projectName, readiness) {
+  const localSteps = [
+    `cd ${projectName}`,
+    "cp .env.example .env   # fill in your values",
+    "npm install",
+    "npm run dev"
+  ];
+  console.log("Local Development\n  " + localSteps.join("\n  "));
+  if (readiness === null) return;
+  const lines = [];
+  if (readiness.cliInstalled && readiness.authenticated === true) {
+    lines.push("\u2713 Ready to deploy");
+    lines.push(`\u2192 ${readiness.deployCmd}`);
+  } else if (!readiness.cliInstalled) {
+    lines.push(`\u2717 ${readiness.cliName || "CLI"} not found`);
+    if (readiness.installCmd) lines.push(`  Install: ${readiness.installCmd}`);
+    if (readiness.authCmd) lines.push(`  Then: ${readiness.authCmd}`);
+    lines.push(`  Then: ${readiness.deployCmd}`);
+  } else {
+    lines.push(`\u2713 ${readiness.cliName} CLI installed`);
+    if (readiness.authenticated === false) {
+      lines.push(`\u2717 Not authenticated`);
+      lines.push(`  Run: ${readiness.authCmd}`);
+    } else {
+      lines.push("? Authentication status unknown");
+      lines.push(`  Try: ${readiness.authCmd}`);
+    }
+    lines.push(`  Then: ${readiness.deployCmd}`);
+  }
+  lines.push("");
+  if (readiness.envVarCmd) {
+    lines.push(`\u2139 Set production env vars with: ${readiness.envVarCmd}`);
+  }
+  lines.push("\u2139 See README.md \u2192 Deployment for full instructions");
+  console.log(`Deployment (${readiness.platform})
+  ${lines.join("\n  ")}`);
+}
+
+// src/deploy/readiness.ts
+import { execFileSync as execFileSync2 } from "child_process";
+var PLATFORMS = [
+  {
+    platform: "AWS Amplify",
+    cliName: "amplify",
+    cliBinary: "amplify",
+    authCheckCmd: ["amplify", "status"],
+    installCmd: "npm i -g @aws-amplify/cli",
+    authCmd: "amplify configure",
+    deployCmd: "npm run deploy",
+    envVarCmd: "See AWS Amplify console for environment variables"
+  },
+  {
+    platform: "AWS CDK",
+    cliName: "cdk",
+    cliBinary: "cdk",
+    authCheckCmd: ["aws", "sts", "get-caller-identity"],
+    installCmd: "npm i -g aws-cdk",
+    authCmd: "aws configure",
+    deployCmd: "npm run deploy",
+    envVarCmd: "aws ssm put-parameter --name KEY --value VAL --type String"
+  },
+  {
+    platform: "AWS SST",
+    cliName: "sst",
+    cliBinary: "npx",
+    authCheckCmd: ["aws", "sts", "get-caller-identity"],
+    installCmd: "(uses npx \u2014 no global install needed)",
+    authCmd: "aws configure",
+    deployCmd: "npm run deploy",
+    envVarCmd: "aws ssm put-parameter --name KEY --value VAL --type String"
+  },
+  {
+    platform: "Vercel",
+    cliName: "vercel",
+    cliBinary: "vercel",
+    authCheckCmd: ["vercel", "whoami"],
+    installCmd: "npm i -g vercel",
+    authCmd: "vercel login",
+    deployCmd: "npm run deploy",
+    envVarCmd: "vercel env add"
+  },
+  {
+    platform: "AWS",
+    cliName: "aws",
+    cliBinary: "aws",
+    authCheckCmd: ["aws", "sts", "get-caller-identity"],
+    installCmd: "See https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html",
+    authCmd: "aws configure",
+    deployCmd: "npm run deploy",
+    envVarCmd: "aws ssm put-parameter --name KEY --value VAL --type String"
+  },
+  {
+    platform: "GCP",
+    cliName: "gcloud",
+    cliBinary: "gcloud",
+    authCheckCmd: ["gcloud", "auth", "print-identity-token"],
+    installCmd: "See https://cloud.google.com/sdk/docs/install",
+    authCmd: "gcloud auth login",
+    deployCmd: "npm run deploy",
+    envVarCmd: "gcloud run services update SERVICE --set-env-vars KEY=VAL"
+  },
+  {
+    platform: "Docker",
+    cliName: "docker",
+    cliBinary: "docker",
+    authCheckCmd: ["docker", "info"],
+    installCmd: "See https://docs.docker.com/get-docker/",
+    authCmd: "docker login",
+    deployCmd: "npm run deploy",
+    envVarCmd: "Set variables in docker-compose.yml or .env"
+  },
+  {
+    platform: "Railway",
+    cliName: "railway",
+    cliBinary: "railway",
+    authCheckCmd: ["railway", "whoami"],
+    installCmd: "npm i -g @railway/cli",
+    authCmd: "railway login",
+    deployCmd: "npm run deploy",
+    envVarCmd: "railway variables set KEY=VAL"
+  },
+  {
+    platform: "Fly.io",
+    cliName: "fly",
+    cliBinary: "fly",
+    authCheckCmd: ["fly", "auth", "whoami"],
+    installCmd: "See https://fly.io/docs/flyctl/install/",
+    authCmd: "fly auth login",
+    deployCmd: "npm run deploy",
+    envVarCmd: "fly secrets set KEY=VAL"
+  }
+];
+var KEYWORD_MATCHERS = (() => {
+  const byPlatform = (name) => PLATFORMS.find((p) => p.platform === name);
+  return [
+    { test: (s) => s.includes("amplify"), platform: byPlatform("AWS Amplify") },
+    { test: (s) => s.includes("cdk"), platform: byPlatform("AWS CDK") },
+    { test: (s) => s.includes("sst"), platform: byPlatform("AWS SST") },
+    { test: (s) => s.includes("vercel"), platform: byPlatform("Vercel") },
+    { test: (s) => s.includes("aws") || s.includes("lambda") || s.includes("ec2"), platform: byPlatform("AWS") },
+    { test: (s) => s.includes("gcp") || s.includes("google cloud") || s.includes("cloud run"), platform: byPlatform("GCP") },
+    { test: (s) => s.includes("docker") || s.includes("container"), platform: byPlatform("Docker") },
+    { test: (s) => s.includes("railway"), platform: byPlatform("Railway") },
+    { test: (s) => s.includes("fly.io") || s === "fly" || s.startsWith("fly "), platform: byPlatform("Fly.io") }
+  ];
+})();
+var FALLBACK_CONFIG = {
+  platform: "Unknown",
+  cliName: "",
+  cliBinary: "",
+  authCheckCmd: [],
+  installCmd: "",
+  authCmd: "",
+  deployCmd: "npm run deploy",
+  envVarCmd: "See README.md for environment variable instructions"
+};
+function normalizePlatform(deploymentComponent) {
+  const lower = deploymentComponent.toLowerCase();
+  for (const matcher of KEYWORD_MATCHERS) {
+    if (matcher.test(lower)) {
+      return matcher.platform;
+    }
+  }
+  return FALLBACK_CONFIG;
+}
+function isCliInstalled(binary) {
+  try {
+    execFileSync2("which", [binary], { stdio: "pipe", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkAuth(cmd) {
+  if (cmd.length === 0) return null;
+  try {
+    execFileSync2(cmd[0], cmd.slice(1), { stdio: "pipe", timeout: 5e3 });
+    return true;
+  } catch (err) {
+    const nodeErr = err;
+    if (nodeErr.code === "ENOENT" || nodeErr.code === "ETIMEDOUT") {
+      return null;
+    }
+    return false;
+  }
+}
+function checkDeployReadiness(deploymentComponent) {
+  const config = normalizePlatform(deploymentComponent);
+  if (config.platform === "Unknown" || config.cliBinary === "") {
+    return {
+      platform: config.platform,
+      cliInstalled: false,
+      cliName: config.cliName,
+      authenticated: null,
+      installCmd: config.installCmd,
+      authCmd: config.authCmd,
+      deployCmd: config.deployCmd,
+      envVarCmd: config.envVarCmd
+    };
+  }
+  const cliInstalled = isCliInstalled(config.cliBinary);
+  let authenticated = null;
+  if (cliInstalled) {
+    authenticated = checkAuth(config.authCheckCmd);
+  }
+  return {
+    platform: config.platform,
+    cliInstalled,
+    cliName: config.cliName,
+    authenticated,
+    installCmd: config.installCmd,
+    authCmd: config.authCmd,
+    deployCmd: config.deployCmd,
+    envVarCmd: config.envVarCmd
+  };
 }
 
 // src/index.ts
-async function main() {
-  intro2();
-  const progress = await runConversationLoop();
-  if (!progress) {
-    outro2("Setup cancelled.");
-    return;
-  }
-  const confirmed = await p2.confirm({
-    message: "Ready to build this stack?"
+var INVALIDATION_PROMPT = `You are evaluating whether changing a technology stack decision affects other decisions.
+
+The user changed their decision. Given the current state of all decisions, determine which OTHER decisions (if any) are now invalid and should be reconsidered.
+
+Rules:
+- Only include stages that are GENUINELY affected by the change.
+- Only affect stages AFTER the changed stage in the ordered list.
+- Consider whether each decision was dependent on the changed decision.
+- If nothing needs to change, return empty arrays.
+
+Examples:
+
+Changed frontend from Next.js to Astro (backend was "Next.js API routes"):
+{"clear":["backend"],"add":[],"remove":[]}
+Reason: Backend was tied to Next.js. If backend had been "Express" (independent), it would NOT be cleared.
+
+Changed auth from Clerk to Auth.js:
+{"clear":[],"add":[],"remove":[]}
+Reason: Swapping auth providers doesn't affect other decisions.
+
+Changed frontend from Next.js to static HTML:
+{"clear":["backend","auth","ai"],"add":[],"remove":["payments"]}
+Reason: Static site fundamentally changes what's viable.
+
+Respond with ONLY a JSON object: {"clear": [...], "add": [...], "remove": [...]}
+`;
+function createInvalidationFn() {
+  return async (changedId, oldValue, newValue, progress, stages) => {
+    const stageList = stages.map((s) => `${s.id} (${s.status}): ${s.summary ?? "no decision"}`).join("\n");
+    const userPrompt = `The user changed "${changedId}" from "${oldValue?.component ?? "none"}" to "${newValue?.component ?? "none"}".
+
+Current decisions:
+${serializeProgress(progress)}
+
+Current stages:
+${stageList}
+
+What needs to change?`;
+    try {
+      const response = await chat({
+        system: INVALIDATION_PROMPT,
+        messages: [{ role: "user", content: userPrompt }],
+        maxTokens: 1024
+      });
+      const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const parsed = JSON.parse(text);
+      return {
+        clear: Array.isArray(parsed.clear) ? parsed.clear : [],
+        add: Array.isArray(parsed.add) ? parsed.add : [],
+        remove: Array.isArray(parsed.remove) ? parsed.remove : []
+      };
+    } catch {
+      return { clear: [], add: [], remove: [] };
+    }
+  };
+}
+async function main(fresh = false) {
+  const cwd = process.cwd();
+  const invalidationFn = createInvalidationFn();
+  process.on("SIGINT", () => {
+    process.exit(0);
   });
-  if (p2.isCancel(confirmed) || !confirmed) {
-    outro2("No problem \u2014 run stack-agent again to start over.");
-    return;
-  }
-  const success = await runScaffoldLoop(progress);
-  if (success) {
-    const nextSteps = [`cd ${progress.projectName}`];
-    nextSteps.push("cp .env.example .env  # fill in your values");
-    nextSteps.push("npm run dev");
-    p2.log.step("Next steps:\n  " + nextSteps.join("\n  "));
-    outro2("Happy building!");
+  if (fresh) {
+    const tempManager = StageManager.resume(cwd);
+    tempManager?.cleanup();
+    console.log("Session cleared. Starting fresh.\n");
+  }
+  let manager;
+  const existingSession = fresh ? null : StageManager.detect(cwd);
+  if (existingSession) {
+    console.log(`
+Found saved progress for "${existingSession.progress.projectName ?? "unnamed"}"`);
+    console.log("Run with --fresh to start over.\n");
+    const resumed = StageManager.resume(cwd, invalidationFn);
+    if (!resumed) {
+      console.log("Could not restore session. Starting fresh.");
+      manager = StageManager.start(cwd, invalidationFn);
+    } else {
+      manager = resumed;
+    }
   } else {
-    renderError("Scaffolding encountered errors. Check the output above.");
-    outro2("You may need to fix issues manually.");
+    manager = StageManager.start(cwd, invalidationFn);
+  }
+  let shouldBuild = false;
+  const ink = withFullScreen(
+    React6.createElement(App, {
+      manager,
+      onBuild: () => {
+        shouldBuild = true;
+      },
+      onExit: () => {
+        shouldBuild = false;
+      }
+    })
+  );
+  await ink.start();
+  await ink.waitUntilExit();
+  if (shouldBuild) {
+    console.log("\nScaffolding your project...\n");
+    const success = await runScaffoldLoop(manager.progress);
+    if (success) {
+      const readiness = manager.progress.deployment ? checkDeployReadiness(manager.progress.deployment.component) : null;
+      renderPostScaffold(manager.progress.projectName, readiness);
+      manager.cleanup();
+      console.log("\nHappy building!\n");
+    } else {
+      console.error("\nScaffolding encountered errors. Check the output above.\n");
+    }
   }
 }
-var command = process.argv[2];
-if (!command || command === "init") {
-  main().catch((err) => {
+var args = process.argv.slice(2);
+var command = args[0];
+var isFresh = args.includes("--fresh");
+if (!command || command === "init" || command === "--fresh") {
+  main(isFresh).catch((err) => {
     console.error(err);
     process.exit(1);
   });
 } else {
   console.error(`Unknown command: ${command}`);
-  console.error("Usage: stack-agent [init]");
+  console.error("Usage: stack-agent [init] [--fresh]");
   process.exit(1);
 }