@mindstudio-ai/remy 0.1.0

package/dist/index.js

@@ -0,0 +1,3164 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/logger.ts
+import fs from "fs";
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function truncateValues(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "string" && value.length > MAX_VALUE_LENGTH) {
+      result[key] = value.slice(0, MAX_VALUE_LENGTH) + `... (${value.length} chars)`;
+    } else if (Array.isArray(value) && value.length > 5) {
+      result[key] = `[${value.length} items]`;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function write(level, msg, data) {
+  if (LEVELS[level] > currentLevel) {
+    return;
+  }
+  const parts = [`[${timestamp()}]`, level.toUpperCase().padEnd(5), msg];
+  if (data) {
+    parts.push(JSON.stringify(truncateValues(data)));
+  }
+  writeFn(parts.join(" "));
+}
+function initLoggerHeadless(level = "info") {
+  currentLevel = LEVELS[level];
+  writeFn = (line) => {
+    process.stderr.write(line + "\n");
+  };
+}
+function initLoggerInteractive(level = "error") {
+  currentLevel = LEVELS[level];
+  let fd = null;
+  writeFn = (line) => {
+    try {
+      if (fd === null) {
+        fd = fs.openSync(".remy-debug.log", "a");
+      }
+      fs.writeSync(fd, line + "\n");
+    } catch {
+    }
+  };
+}
+var LEVELS, currentLevel, writeFn, MAX_VALUE_LENGTH, log;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    LEVELS = {
+      error: 0,
+      warn: 1,
+      info: 2,
+      debug: 3
+    };
+    currentLevel = LEVELS.error;
+    writeFn = () => {
+    };
+    MAX_VALUE_LENGTH = 200;
+    log = {
+      error(msg, data) {
+        write("error", msg, data);
+      },
+      warn(msg, data) {
+        write("warn", msg, data);
+      },
+      info(msg, data) {
+        write("info", msg, data);
+      },
+      debug(msg, data) {
+        write("debug", msg, data);
+      }
+    };
+  }
+});
+
+// src/api.ts
+async function* streamChat(params) {
+  const { baseUrl, apiKey, signal, ...body } = params;
+  const url = `${baseUrl}/_internal/v2/agent/chat`;
+  const startTime = Date.now();
+  const messagesWithAttachments = body.messages.filter(
+    (m) => m.attachments && m.attachments.length > 0
+  );
+  log.info("POST agent/chat", {
+    url,
+    model: body.model,
+    messageCount: body.messages.length,
+    toolCount: body.tools.length,
+    ...messagesWithAttachments.length > 0 && {
+      attachments: messagesWithAttachments.map((m) => ({
+        role: m.role,
+        attachmentCount: m.attachments.length,
+        urls: m.attachments.map((a) => a.url)
+      }))
+    }
+  });
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+  } catch (err) {
+    if (signal?.aborted) {
+      log.info("Request aborted by signal");
+      throw err;
+    }
+    log.error("Network error", { error: err.message });
+    yield { type: "error", error: `Network error: ${err.message}` };
+    return;
+  }
+  const ttfb = Date.now() - startTime;
+  log.info(`Response ${res.status}`, { ttfb: `${ttfb}ms` });
+  if (!res.ok) {
+    let errorMessage = `HTTP ${res.status}`;
+    try {
+      const body2 = await res.json();
+      if (body2.error) {
+        errorMessage = body2.error;
+      }
+      if (body2.errorMessage) {
+        errorMessage = body2.errorMessage;
+      }
+    } catch {
+    }
+    log.error("API error", { status: res.status, error: errorMessage });
+    yield { type: "error", error: errorMessage };
+    return;
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) {
+        continue;
+      }
+      try {
+        const event = JSON.parse(line.slice(6));
+        if (event.type === "done") {
+          const elapsed = Date.now() - startTime;
+          log.info("Stream complete", {
+            elapsed: `${elapsed}ms`,
+            stopReason: event.stopReason,
+            inputTokens: event.usage.inputTokens,
+            outputTokens: event.usage.outputTokens
+          });
+        }
+        yield event;
+      } catch {
+      }
+    }
+  }
+  if (buffer.startsWith("data: ")) {
+    try {
+      yield JSON.parse(buffer.slice(6));
+    } catch {
+    }
+  }
+}
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/tools/spec/_helpers.ts
+function parseHeadings(content) {
+  const lines = content.split("\n");
+  const headings = [];
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(HEADING_RE);
+    if (match) {
+      headings.push({
+        level: match[1].length,
+        text: match[2].trim(),
+        startLine: i,
+        contentStart: i + 1,
+        contentEnd: lines.length
+        // placeholder — resolved below
+      });
+    }
+  }
+  for (let i = 0; i < headings.length; i++) {
+    const current = headings[i];
+    let end = lines.length;
+    for (let j = i + 1; j < headings.length; j++) {
+      if (headings[j].level <= current.level) {
+        end = headings[j].startLine;
+        break;
+      }
+    }
+    current.contentEnd = end;
+  }
+  return headings;
+}
+function resolveHeadingPath(content, headingPath) {
+  const lines = content.split("\n");
+  const headings = parseHeadings(content);
+  if (headingPath === "") {
+    const firstHeadingLine = headings.length > 0 ? headings[0].startLine : lines.length;
+    return {
+      startLine: 0,
+      contentStart: 0,
+      contentEnd: firstHeadingLine
+    };
+  }
+  const segments = headingPath.split(">").map((s) => s.trim());
+  let searchStart = 0;
+  let searchEnd = lines.length;
+  let resolved = null;
+  for (let si = 0; si < segments.length; si++) {
+    const segment = segments[si].toLowerCase();
+    const candidates = headings.filter(
+      (h) => h.startLine >= searchStart && h.startLine < searchEnd && h.text.toLowerCase() === segment
+    );
+    if (candidates.length === 0) {
+      const available = headings.filter((h) => h.startLine >= searchStart && h.startLine < searchEnd).map((h) => `${"#".repeat(h.level)} ${h.text}`).join("\n");
+      const searchedPath = segments.slice(0, si + 1).join(" > ");
+      throw new Error(
+        `Heading not found: "${searchedPath}"
+
+Available headings:
+${available || "(none)"}`
+      );
+    }
+    resolved = candidates[0];
+    searchStart = resolved.contentStart;
+    searchEnd = resolved.contentEnd;
+  }
+  return {
+    startLine: resolved.startLine,
+    contentStart: resolved.contentStart,
+    contentEnd: resolved.contentEnd
+  };
+}
+function validateSpecPath(filePath) {
+  if (!filePath.startsWith("src/")) {
+    throw new Error(`Spec tool paths must start with src/. Got: "${filePath}"`);
+  }
+  return filePath;
+}
+function getHeadingTree(content) {
+  const headings = parseHeadings(content);
+  if (headings.length === 0) {
+    return "(no headings)";
+  }
+  return headings.map((h) => `${"#".repeat(h.level)} ${h.text}`).join("\n");
+}
+var HEADING_RE;
+var init_helpers = __esm({
+  "src/tools/spec/_helpers.ts"() {
+    "use strict";
+    HEADING_RE = /^(#{1,6})\s+(.+)$/;
+  }
+});
+
+// src/tools/spec/readSpec.ts
+import fs2 from "fs/promises";
+var DEFAULT_MAX_LINES, readSpecTool;
+var init_readSpec = __esm({
+  "src/tools/spec/readSpec.ts"() {
+    "use strict";
+    init_helpers();
+    DEFAULT_MAX_LINES = 500;
+    readSpecTool = {
+      definition: {
+        name: "readSpec",
+        description: "Read a spec file from src/ with line numbers. Always read a spec file before editing it. Paths are relative to the project root and must start with src/ (e.g., src/app.md, src/interfaces/web.md).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "File path relative to project root, must start with src/ (e.g., src/app.md)."
+            },
+            offset: {
+              type: "number",
+              description: "Line number to start reading from (1-indexed). Use a negative number to read from the end. Defaults to 1."
+            },
+            maxLines: {
+              type: "number",
+              description: "Maximum number of lines to return. Defaults to 500. Set to 0 for no limit."
+            }
+          },
+          required: ["path"]
+        }
+      },
+      async execute(input) {
+        try {
+          validateSpecPath(input.path);
+        } catch (err) {
+          return `Error: ${err.message}`;
+        }
+        try {
+          const content = await fs2.readFile(input.path, "utf-8");
+          const allLines = content.split("\n");
+          const totalLines = allLines.length;
+          const maxLines = input.maxLines === 0 ? Infinity : input.maxLines || DEFAULT_MAX_LINES;
+          let startIdx;
+          if (input.offset && input.offset < 0) {
+            startIdx = Math.max(0, totalLines + input.offset);
+          } else {
+            startIdx = Math.max(0, (input.offset || 1) - 1);
+          }
+          const sliced = allLines.slice(startIdx, startIdx + maxLines);
+          const numbered = sliced.map((line, i) => `${String(startIdx + i + 1).padStart(4)} ${line}`).join("\n");
+          let result = numbered;
+          const endLine = startIdx + sliced.length;
+          const displayStart = startIdx + 1;
+          if (endLine < totalLines) {
+            result += `
+
+(showing lines ${displayStart}\u2013${endLine} of ${totalLines} \u2014 use offset and maxLines to read more)`;
+          }
+          return result;
+        } catch (err) {
+          return `Error reading file: ${err.message}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/_helpers/diff.ts
+function unifiedDiff(filePath, oldText, newText) {
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  let firstDiff = 0;
+  while (firstDiff < oldLines.length && firstDiff < newLines.length && oldLines[firstDiff] === newLines[firstDiff]) {
+    firstDiff++;
+  }
+  let oldEnd = oldLines.length - 1;
+  let newEnd = newLines.length - 1;
+  while (oldEnd > firstDiff && newEnd > firstDiff && oldLines[oldEnd] === newLines[newEnd]) {
+    oldEnd--;
+    newEnd--;
+  }
+  const ctxStart = Math.max(0, firstDiff - CONTEXT_LINES);
+  const ctxOldEnd = Math.min(oldLines.length - 1, oldEnd + CONTEXT_LINES);
+  const ctxNewEnd = Math.min(newLines.length - 1, newEnd + CONTEXT_LINES);
+  const lines = [];
+  lines.push(`--- ${filePath}`);
+  lines.push(`+++ ${filePath}`);
+  lines.push(
+    `@@ -${ctxStart + 1},${ctxOldEnd - ctxStart + 1} +${ctxStart + 1},${ctxNewEnd - ctxStart + 1} @@`
+  );
+  for (let i = ctxStart; i < firstDiff; i++) {
+    lines.push(` ${oldLines[i]}`);
+  }
+  for (let i = firstDiff; i <= oldEnd; i++) {
+    lines.push(`-${oldLines[i]}`);
+  }
+  for (let i = firstDiff; i <= newEnd; i++) {
+    lines.push(`+${newLines[i]}`);
+  }
+  for (let i = oldEnd + 1; i <= ctxOldEnd; i++) {
+    lines.push(` ${oldLines[i]}`);
+  }
+  return lines.join("\n");
+}
+var CONTEXT_LINES;
+var init_diff = __esm({
+  "src/tools/_helpers/diff.ts"() {
+    "use strict";
+    CONTEXT_LINES = 3;
+  }
+});
+
+// src/tools/spec/writeSpec.ts
+import fs3 from "fs/promises";
+import path from "path";
+var writeSpecTool;
+var init_writeSpec = __esm({
+  "src/tools/spec/writeSpec.ts"() {
+    "use strict";
+    init_helpers();
+    init_diff();
+    writeSpecTool = {
+      definition: {
+        name: "writeSpec",
+        description: "Create a new spec file or completely overwrite an existing one in src/. Parent directories are created automatically. Use this for new spec files or full rewrites. For targeted changes to existing specs, use editSpec instead.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "File path relative to project root, must start with src/ (e.g., src/app.md)."
+            },
+            content: {
+              type: "string",
+              description: "The full MSFM markdown content to write."
+            }
+          },
+          required: ["path", "content"]
+        }
+      },
+      streaming: {
+        transform: async (partial) => {
+          const oldContent = await fs3.readFile(partial.path, "utf-8").catch(() => "");
+          const lineCount = partial.content.split("\n").length;
+          return `Writing ${partial.path} (${lineCount} lines)
+${unifiedDiff(partial.path, oldContent, partial.content)}`;
+        }
+      },
+      async execute(input) {
+        try {
+          validateSpecPath(input.path);
+        } catch (err) {
+          return `Error: ${err.message}`;
+        }
+        try {
+          await fs3.mkdir(path.dirname(input.path), { recursive: true });
+          let oldContent = null;
+          try {
+            oldContent = await fs3.readFile(input.path, "utf-8");
+          } catch {
+          }
+          await fs3.writeFile(input.path, input.content, "utf-8");
+          const lineCount = input.content.split("\n").length;
+          const label = oldContent !== null ? "Wrote" : "Created";
+          return `${label} ${input.path} (${lineCount} lines)
+${unifiedDiff(input.path, oldContent ?? "", input.content)}`;
+        } catch (err) {
+          return `Error writing file: ${err.message}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/spec/editSpec.ts
+import fs4 from "fs/promises";
+var editSpecTool;
+var init_editSpec = __esm({
+  "src/tools/spec/editSpec.ts"() {
+    "use strict";
+    init_helpers();
+    init_diff();
+    editSpecTool = {
+      definition: {
+        name: "editSpec",
+        description: 'Make targeted edits to a spec file by heading path. This is the primary tool for modifying existing specs. Each edit targets a section by its heading hierarchy (e.g., "Vendors > Approval Flow") and applies an operation. Multiple edits are applied in order.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "File path relative to project root, must start with src/ (e.g., src/app.md)."
+            },
+            edits: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  heading: {
+                    type: "string",
+                    description: 'Heading path using " > " to separate nesting levels (e.g., "Vendors > Approval Flow"). Empty string targets the preamble (content before the first heading).'
+                  },
+                  operation: {
+                    type: "string",
+                    enum: ["replace", "insert_after", "insert_before", "delete"],
+                    description: "replace: swap content under this heading (keeps the heading line). insert_after: add content after this section. insert_before: add content before this heading. delete: remove this heading and all its content."
+                  },
+                  content: {
+                    type: "string",
+                    description: "MSFM markdown content for replace/insert operations. Not needed for delete."
+                  }
+                },
+                required: ["heading", "operation"]
+              },
+              description: "Array of edits to apply in order."
+            }
+          },
+          required: ["path", "edits"]
+        }
+      },
+      async execute(input) {
+        try {
+          validateSpecPath(input.path);
+        } catch (err) {
+          return `Error: ${err.message}`;
+        }
+        let originalContent;
+        try {
+          originalContent = await fs4.readFile(input.path, "utf-8");
+        } catch (err) {
+          return `Error reading file: ${err.message}`;
+        }
+        let content = originalContent;
+        for (const edit of input.edits) {
+          let range;
+          try {
+            range = resolveHeadingPath(content, edit.heading);
+          } catch (err) {
+            const tree = getHeadingTree(content);
+            return `Error: ${err.message}
+
+Document structure:
+${tree}`;
+          }
+          const lines = content.split("\n");
+          switch (edit.operation) {
+            case "replace": {
+              if (edit.content == null) {
+                return 'Error: "content" is required for replace operations.';
+              }
+              const contentLines = edit.content.split("\n");
+              lines.splice(
+                range.contentStart,
+                range.contentEnd - range.contentStart,
+                ...contentLines
+              );
+              break;
+            }
+            case "insert_after": {
+              if (edit.content == null) {
+                return 'Error: "content" is required for insert_after operations.';
+              }
+              const contentLines = edit.content.split("\n");
+              lines.splice(range.contentEnd, 0, ...contentLines);
+              break;
+            }
+            case "insert_before": {
+              if (edit.content == null) {
+                return 'Error: "content" is required for insert_before operations.';
+              }
+              const contentLines = edit.content.split("\n");
+              lines.splice(range.startLine, 0, ...contentLines);
+              break;
+            }
+            case "delete": {
+              lines.splice(range.startLine, range.contentEnd - range.startLine);
+              break;
+            }
+            default:
+              return `Error: Unknown operation "${edit.operation}". Use replace, insert_after, insert_before, or delete.`;
+          }
+          content = lines.join("\n");
+        }
+        try {
+          await fs4.writeFile(input.path, content, "utf-8");
+        } catch (err) {
+          return `Error writing file: ${err.message}`;
+        }
+        return unifiedDiff(input.path, originalContent, content);
+      }
+    };
+  }
+});
+
+// src/tools/spec/listSpecFiles.ts
+import fs5 from "fs/promises";
+import path2 from "path";
+async function listRecursive(dir) {
+  const results = [];
+  const entries = await fs5.readdir(dir, { withFileTypes: true });
+  entries.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory()) {
+      return -1;
+    }
+    if (!a.isDirectory() && b.isDirectory()) {
+      return 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(`${fullPath}/`);
+      results.push(...await listRecursive(fullPath));
+    } else {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+var listSpecFilesTool;
+var init_listSpecFiles = __esm({
+  "src/tools/spec/listSpecFiles.ts"() {
+    "use strict";
+    listSpecFilesTool = {
+      definition: {
+        name: "listSpecFiles",
+        description: "List all files in the src/ directory (spec files, brand guidelines, interface specs, references). Use this to understand what spec files exist before reading or editing them.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      async execute() {
+        try {
+          const entries = await listRecursive("src");
+          if (entries.length === 0) {
+            return "src/ is empty \u2014 no spec files yet.";
+          }
+          return entries.join("\n");
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            return "Error: src/ directory does not exist.";
+          }
+          return `Error listing spec files: ${err.message}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/spec/setViewMode.ts
+var setViewModeTool;
+var init_setViewMode = __esm({
+  "src/tools/spec/setViewMode.ts"() {
+    "use strict";
+    setViewModeTool = {
+      definition: {
+        name: "setViewMode",
+        description: 'Switch the IDE view mode. Use this to navigate the user to the right context. When transitioning from intake to spec, write the first spec file BEFORE calling this \u2014 the user needs something to see when the spec editor opens. Switch to "code" during code generation, then to "preview" when done so the user sees the result.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            mode: {
+              type: "string",
+              enum: [
+                "intake",
+                "preview",
+                "spec",
+                "code",
+                "databases",
+                "scenarios",
+                "logs"
+              ],
+              description: "The view mode to switch to."
+            }
+          },
+          required: ["mode"]
+        }
+      },
+      async execute() {
+        return "View mode updated.";
+      }
+    };
+  }
+});
+
+// src/tools/spec/promptUser.ts
+var promptUserTool;
+var init_promptUser = __esm({
+  "src/tools/spec/promptUser.ts"() {
+    "use strict";
+    promptUserTool = {
+      definition: {
+        name: "promptUser",
+        description: 'Ask the user structured questions. Choose type first: "form" for structured intake (5+ questions, takes over screen), "inline" for quick clarifications or confirmations. Blocks until the user responds. Result contains `_dismissed: true` if the user dismisses without answering.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["form", "inline"],
+              description: "Choose this first, before writing questions. form: full form for structured intake with many questions. inline: compact in-chat display."
+            },
+            questions: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  id: {
+                    type: "string",
+                    description: "Unique identifier for this question. Used as the key in the response object."
+                  },
+                  question: {
+                    type: "string",
+                    description: "The question to ask."
+                  },
+                  type: {
+                    type: "string",
+                    enum: ["select", "text", "confirm", "file", "color"],
+                    description: "select: pick from options. text: free-form input. confirm: yes/no. file: file/image upload \u2014 returns CDN URL(s) that can be referenced directly or curled onto disk. color: color picker (returns hex)."
+                  },
+                  helpText: {
+                    type: "string",
+                    description: "Optional detail rendered below the question as a subtitle."
+                  },
+                  required: {
+                    type: "boolean",
+                    description: "Whether the user must answer this question. Defaults to false."
+                  },
+                  options: {
+                    type: "array",
+                    items: {
+                      oneOf: [
+                        { type: "string" },
+                        {
+                          type: "object",
+                          properties: {
+                            label: {
+                              type: "string",
+                              description: "The option text."
+                            },
+                            description: {
+                              type: "string",
+                              description: "Optional detail shown below the label."
+                            }
+                          },
+                          required: ["label"]
+                        }
+                      ]
+                    },
+                    description: "Options for select type. Each can be a string or { label, description }."
+                  },
+                  multiple: {
+                    type: "boolean",
+                    description: "For select: allow picking multiple options (returns array). For file: allow multiple uploads (returns array of URLs). Defaults to false."
+                  },
+                  allowOther: {
+                    type: "boolean",
+                    description: 'For select type: adds an "Other" option with a free-form text input. Defaults to false.'
+                  },
+                  format: {
+                    type: "string",
+                    enum: ["email", "url", "phone", "number"],
+                    description: "For text type: adds input validation and mobile keyboard hints."
+                  },
+                  placeholder: {
+                    type: "string",
+                    description: "For text type: placeholder hint text."
+                  },
+                  accept: {
+                    type: "string",
+                    description: 'For file type: comma-separated mime types, like HTML input accept (e.g. "image/*", "image/*,video/*", "application/pdf"). Omit to accept all file types.'
+                  }
+                },
+                required: ["id", "question", "type"]
+              },
+              description: "One or more questions to present."
+            }
+          },
+          required: ["type", "questions"]
+        }
+      },
+      streaming: {
+        partialInput: (partial, lastCount) => {
+          const questions = partial.questions;
+          if (!Array.isArray(questions) || questions.length === 0) {
+            return null;
+          }
+          const hasType = typeof partial.type === "string";
+          if (!hasType && questions.length < 3) {
+            return null;
+          }
+          const confirmed = questions.length > 1 ? questions.slice(0, -1) : [];
+          if (confirmed.length <= lastCount) {
+            return null;
+          }
+          return {
+            input: {
+              ...partial,
+              type: partial.type ?? "inline",
+              questions: confirmed
+            },
+            emittedCount: confirmed.length
+          };
+        }
+      },
+      async execute(input) {
+        const questions = input.questions;
+        const lines = questions.map((q) => {
+          let line = `- ${q.question}`;
+          if (q.type === "select") {
+            const opts = (q.options || []).map(
+              (o) => typeof o === "string" ? o : o.label
+            );
+            line += q.multiple ? ` (pick one or more: ${opts.join(" / ")})` : ` (${opts.join(" / ")})`;
+          } else if (q.type === "confirm") {
+            line += " (yes / no)";
+          } else if (q.type === "file") {
+            line += " (upload file)";
+          } else if (q.type === "color") {
+            line += " (pick a color)";
+          }
+          return line;
+        });
+        return `Please answer these questions:
+${lines.join("\n")}`;
+      }
+    };
+  }
+});
+
+// src/tools/spec/clearSyncStatus.ts
+var clearSyncStatusTool;
+var init_clearSyncStatus = __esm({
+  "src/tools/spec/clearSyncStatus.ts"() {
+    "use strict";
+    clearSyncStatusTool = {
+      definition: {
+        name: "clearSyncStatus",
+        description: "Clear the sync status flags after syncing spec and code. Call this after finishing a sync operation.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      async execute() {
+        return "ok";
+      }
+    };
+  }
+});
+
+// src/tools/spec/presentSyncPlan.ts
+var presentSyncPlanTool;
+var init_presentSyncPlan = __esm({
+  "src/tools/spec/presentSyncPlan.ts"() {
+    "use strict";
+    presentSyncPlanTool = {
+      definition: {
+        name: "presentSyncPlan",
+        description: "Present a structured sync plan to the user for approval. Write a clear markdown summary of what changed and what you intend to update. The user will see this in a full-screen view and can approve or dismiss. Call this BEFORE making any sync edits.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "Markdown plan describing what changed and what will be updated."
+            }
+          },
+          required: ["content"]
+        }
+      },
+      streaming: {},
+      async execute() {
+        return "approved";
+      }
+    };
+  }
+});
+
+// src/tools/spec/presentPublishPlan.ts
+var presentPublishPlanTool;
+var init_presentPublishPlan = __esm({
+  "src/tools/spec/presentPublishPlan.ts"() {
+    "use strict";
+    presentPublishPlanTool = {
+      definition: {
+        name: "presentPublishPlan",
+        description: "Present a publish changelog to the user for approval. Write a clear markdown summary of what changed since the last deploy. The user will see this in a full-screen view and can approve or dismiss. Call this BEFORE committing or pushing.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "Markdown changelog describing what changed and what will be deployed."
+            }
+          },
+          required: ["content"]
+        }
+      },
+      streaming: {},
+      async execute() {
+        return "approved";
+      }
+    };
+  }
+});
+
+// src/tools/spec/presentPlan.ts
+var presentPlanTool;
+var init_presentPlan = __esm({
+  "src/tools/spec/presentPlan.ts"() {
+    "use strict";
+    presentPlanTool = {
+      definition: {
+        name: "presentPlan",
+        description: "Present an implementation plan for user approval before making changes. Use this only for large, multi-step changes or when the user explicitly asks to see a plan. Most work should be done autonomously without a plan. Write a clear markdown summary of what you intend to do in plain language \u2014 describe the changes from the user's perspective, not as a list of files and code paths. If the user rejects with feedback, revise and present again.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "Markdown plan describing what you intend to do."
+            }
+          },
+          required: ["content"]
+        }
+      },
+      streaming: {},
+      async execute() {
+        return "approved";
+      }
+    };
+  }
+});
+
+// src/tools/code/readFile.ts
+import fs6 from "fs/promises";
+function isBinary(buffer) {
+  const sample = buffer.subarray(0, 8192);
+  for (let i = 0; i < sample.length; i++) {
+    if (sample[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+var DEFAULT_MAX_LINES2, readFileTool;
+var init_readFile = __esm({
+  "src/tools/code/readFile.ts"() {
+    "use strict";
+    DEFAULT_MAX_LINES2 = 500;
+    readFileTool = {
+      definition: {
+        name: "readFile",
+        description: "Read a file's contents with line numbers. Always read a file before editing it \u2014 never guess at contents. For large files, consider using symbols first to identify the relevant section, then use offset and maxLines to read just that section. Line numbers in the output correspond to what editFile expects. Defaults to first 500 lines. Use a negative offset to read from the end of the file (e.g., offset: -50 reads the last 50 lines).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "The file path to read, relative to the project root."
+            },
+            offset: {
+              type: "number",
+              description: "Line number to start reading from (1-indexed). Use a negative number to read from the end (e.g., -50 reads the last 50 lines). Defaults to 1."
+            },
+            maxLines: {
+              type: "number",
+              description: "Maximum number of lines to return. Defaults to 500. Set to 0 for no limit."
+            }
+          },
+          required: ["path"]
+        }
+      },
+      async execute(input) {
+        try {
+          const buffer = await fs6.readFile(input.path);
+          if (isBinary(buffer)) {
+            const size = buffer.length;
+            const unit = size > 1024 * 1024 ? `${(size / (1024 * 1024)).toFixed(1)}MB` : `${(size / 1024).toFixed(1)}KB`;
+            return `Error: ${input.path} appears to be a binary file (${unit}). Use bash to inspect it if needed.`;
+          }
+          const content = buffer.toString("utf-8");
+          const allLines = content.split("\n");
+          const totalLines = allLines.length;
+          const maxLines = input.maxLines === 0 ? Infinity : input.maxLines || DEFAULT_MAX_LINES2;
+          let startIdx;
+          if (input.offset && input.offset < 0) {
+            startIdx = Math.max(0, totalLines + input.offset);
+          } else {
+            startIdx = Math.max(0, (input.offset || 1) - 1);
+          }
+          const sliced = allLines.slice(startIdx, startIdx + maxLines);
+          const numbered = sliced.map((line, i) => `${String(startIdx + i + 1).padStart(4)} ${line}`).join("\n");
+          let result = numbered;
+          const endLine = startIdx + sliced.length;
+          const displayStart = startIdx + 1;
+          if (endLine < totalLines) {
+            result += `
+
+(showing lines ${displayStart}\u2013${endLine} of ${totalLines} \u2014 use offset and maxLines to read more)`;
+          }
+          return result;
+        } catch (err) {
+          return `Error reading file: ${err.message}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/code/writeFile.ts
+import fs7 from "fs/promises";
+import path3 from "path";
+var writeFileTool;
+var init_writeFile = __esm({
+  "src/tools/code/writeFile.ts"() {
+    "use strict";
+    init_diff();
+    writeFileTool = {
+      definition: {
+        name: "writeFile",
+        description: "Create a new file or completely overwrite an existing one. Parent directories are created automatically. Use this for new files or full rewrites. For targeted changes to existing files, use editFile instead \u2014 it preserves the parts you don't want to change and avoids errors from forgetting to include unchanged code.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "The file path to write, relative to the project root."
+            },
+            content: {
+              type: "string",
+              description: "The full content to write to the file."
+            }
+          },
+          required: ["path", "content"]
+        }
+      },
+      streaming: {
+        transform: async (partial) => {
+          const oldContent = await fs7.readFile(partial.path, "utf-8").catch(() => "");
+          const lineCount = partial.content.split("\n").length;
+          return `Writing ${partial.path} (${lineCount} lines)
+${unifiedDiff(partial.path, oldContent, partial.content)}`;
+        }
+      },
+      async execute(input) {
+        try {
+          await fs7.mkdir(path3.dirname(input.path), { recursive: true });
+          let oldContent = null;
+          try {
+            oldContent = await fs7.readFile(input.path, "utf-8");
+          } catch {
+          }
+          await fs7.writeFile(input.path, input.content, "utf-8");
+          const lineCount = input.content.split("\n").length;
+          const label = oldContent !== null ? "Wrote" : "Created";
+          return `${label} ${input.path} (${lineCount} lines)
+${unifiedDiff(input.path, oldContent ?? "", input.content)}`;
+        } catch (err) {
+          return `Error writing file: ${err.message}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/code/editFile/_helpers.ts
+function buildLineOffsets(content) {
+  const offsets = [0];
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "\n") {
+      offsets.push(i + 1);
+    }
+  }
+  return offsets;
+}
+function lineAtOffset(offsets, charIndex) {
+  let lo = 0;
+  let hi = offsets.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (offsets[mid] <= charIndex) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return lo + 1;
+}
+function findOccurrences(content, searchString) {
+  if (!searchString) {
+    return [];
+  }
+  const offsets = buildLineOffsets(content);
+  const results = [];
+  let pos = 0;
+  while (pos <= content.length - searchString.length) {
+    const idx = content.indexOf(searchString, pos);
+    if (idx === -1) {
+      break;
+    }
+    results.push({ index: idx, line: lineAtOffset(offsets, idx) });
+    pos = idx + 1;
+  }
+  return results;
+}
+function flexibleMatch(content, searchString) {
+  const contentLines = content.split("\n");
+  const searchLines = searchString.split("\n").map((l) => l.trimStart());
+  if (searchLines.length === 0) {
+    return null;
+  }
+  const matches = [];
+  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+    let allMatch = true;
+    for (let j = 0; j < searchLines.length; j++) {
+      if (contentLines[i + j].trimStart() !== searchLines[j]) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      matches.push(i);
+    }
+  }
+  if (matches.length !== 1) {
+    return null;
+  }
+  const startIdx = matches[0];
+  const matchedText = contentLines.slice(startIdx, startIdx + searchLines.length).join("\n");
+  const offsets = buildLineOffsets(content);
+  return {
+    matchedText,
+    index: offsets[startIdx],
+    line: startIdx + 1
+    // 1-based
+  };
+}
+function replaceAt(content, index, oldLength, newString) {
+  return content.slice(0, index) + newString + content.slice(index + oldLength);
+}
+function formatOccurrenceError(count, lines, filePath) {
+  return `old_string found ${count} times in ${filePath} (at lines ${lines.join(", ")}) \u2014 must be unique. Include more surrounding context to disambiguate, or use replace_all to replace every occurrence.`;
+}
+var init_helpers2 = __esm({
+  "src/tools/code/editFile/_helpers.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/code/editFile/index.ts
+import fs8 from "fs/promises";
+var editFileTool;
+var init_editFile = __esm({
+  "src/tools/code/editFile/index.ts"() {
+    "use strict";
+    init_diff();
+    init_helpers2();
+    editFileTool = {
+      definition: {
+        name: "editFile",
+        description: "Replace a string in a file. old_string must appear exactly once (minor indentation differences are handled automatically). Set replace_all to true to replace every occurrence at once. For bulk mechanical substitutions (renaming a variable, swapping colors), prefer replace_all. Always read the file first so you know the exact text to match.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "The file path to edit, relative to the project root."
+            },
+            old_string: {
+              type: "string",
+              description: "The exact string to find and replace. Must be unique in the file unless replace_all is true."
+            },
+            new_string: {
+              type: "string",
+              description: "The replacement string."
+            },
+            replace_all: {
+              type: "boolean",
+              description: "If true, replace every occurrence of old_string in the file. Defaults to false."
+            }
+          },
+          required: ["path", "old_string", "new_string"]
+        }
+      },
+      async execute(input) {
+        try {
+          const content = await fs8.readFile(input.path, "utf-8");
+          const { old_string, new_string, replace_all } = input;
+          const occurrences = findOccurrences(content, old_string);
+          if (replace_all) {
+            if (occurrences.length === 0) {
+              return `Error: old_string not found in ${input.path}.`;
+            }
+            let updated = content;
+            for (let i = occurrences.length - 1; i >= 0; i--) {
+              updated = replaceAt(
+                updated,
+                occurrences[i].index,
+                old_string.length,
+                new_string
+              );
+            }
+            await fs8.writeFile(input.path, updated, "utf-8");
+            return `Replaced ${occurrences.length} occurrence${occurrences.length > 1 ? "s" : ""} in ${input.path}
+${unifiedDiff(input.path, content, updated)}`;
+          }
+          if (occurrences.length === 1) {
+            const updated = replaceAt(
+              content,
+              occurrences[0].index,
+              old_string.length,
+              new_string
+            );
+            await fs8.writeFile(input.path, updated, "utf-8");
+            return `Updated ${input.path}
+${unifiedDiff(input.path, content, updated)}`;
+          }
+          if (occurrences.length > 1) {
+            const lines = occurrences.map((o) => o.line);
+            return `Error: ${formatOccurrenceError(occurrences.length, lines, input.path)}`;
+          }
+          const flex = flexibleMatch(content, old_string);
+          if (flex) {
+            const updated = replaceAt(
+              content,
+              flex.index,
+              flex.matchedText.length,
+              new_string
+            );
+            await fs8.writeFile(input.path, updated, "utf-8");
+            return `Updated ${input.path} (matched with flexible whitespace at line ${flex.line})
+${unifiedDiff(input.path, content, updated)}`;
+          }
+          return `Error: old_string not found in ${input.path}. Make sure you've read the file first and copied the exact text.`;
+        } catch (err) {
+          return `Error editing file: ${err.message}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/code/bash.ts
+import { exec } from "child_process";
+var DEFAULT_TIMEOUT_MS, DEFAULT_MAX_LINES3, bashTool;
+var init_bash = __esm({
+  "src/tools/code/bash.ts"() {
+    "use strict";
+    DEFAULT_TIMEOUT_MS = 12e4;
+    DEFAULT_MAX_LINES3 = 500;
+    bashTool = {
+      definition: {
+        name: "bash",
+        description: "Run a shell command and return stdout + stderr. 120-second timeout by default (configurable). Use for: npm install/build/test, git operations, tsc --noEmit, or any CLI tool. Prefer dedicated tools over bash when available (use grep instead of bash + rg, readFile instead of bash + cat). Output is truncated to 500 lines by default.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            command: {
+              type: "string",
+              description: "The shell command to execute."
+            },
+            cwd: {
+              type: "string",
+              description: "Working directory to run the command in. Defaults to the project root."
+            },
+            timeout: {
+              type: "number",
+              description: "Timeout in seconds. Defaults to 120. Use higher values for long-running commands like builds or test suites."
+            },
+            maxLines: {
+              type: "number",
+              description: "Maximum number of output lines to return. Defaults to 500. Set to 0 for no limit."
+            }
+          },
+          required: ["command"]
+        }
+      },
+      async execute(input) {
+        const maxLines = input.maxLines === 0 ? Infinity : input.maxLines || DEFAULT_MAX_LINES3;
+        const timeoutMs = input.timeout ? input.timeout * 1e3 : DEFAULT_TIMEOUT_MS;
+        return new Promise((resolve) => {
+          exec(
+            input.command,
+            {
+              timeout: timeoutMs,
+              maxBuffer: 2 * 1024 * 1024,
+              ...input.cwd ? { cwd: input.cwd } : {},
+              env: { ...process.env, FORCE_COLOR: "1" }
+            },
+            (err, stdout, stderr) => {
+              let result = "";
+              if (stdout) {
+                result += stdout;
+              }
+              if (stderr) {
+                result += (result ? "\n" : "") + stderr;
+              }
+              if (err && !stdout && !stderr) {
+                result = `Error: ${err.message}`;
+              }
+              if (!result) {
+                resolve("(no output)");
+                return;
+              }
+              const lines = result.split("\n");
+              if (lines.length > maxLines) {
+                resolve(
+                  lines.slice(0, maxLines).join("\n") + `
+
+(truncated at ${maxLines} lines of ${lines.length} total \u2014 increase maxLines to see more)`
+                );
+              } else {
+                resolve(result);
+              }
+            }
+          );
+        });
+      }
+    };
+  }
+});
+
+// src/tools/code/grep.ts
+import { exec as exec2 } from "child_process";
+function formatResults(stdout, max) {
+  const lines = stdout.trim().split("\n");
+  let result = lines.join("\n");
+  if (lines.length >= max) {
+    result += `
+
+(truncated at ${max} results \u2014 increase maxResults to see more)`;
+  }
+  return result;
+}
+var DEFAULT_MAX, grepTool;
+var init_grep = __esm({
+  "src/tools/code/grep.ts"() {
+    "use strict";
+    DEFAULT_MAX = 50;
+    grepTool = {
+      definition: {
+        name: "grep",
+        description: "Search file contents for a regex pattern. Returns matching lines with file paths and line numbers (default 50 results). Use this to find where something is used, locate function definitions, or search for patterns across the codebase. For finding a symbol's definition precisely, prefer the definition tool if LSP is available. Automatically excludes node_modules and .git.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pattern: {
+              type: "string",
+              description: "The search pattern (regex supported)."
+            },
+            path: {
+              type: "string",
+              description: "Directory or file to search in. Defaults to current directory."
+            },
+            glob: {
+              type: "string",
+              description: 'File glob to filter (e.g., "*.ts"). Only used with ripgrep.'
+            },
+            maxResults: {
+              type: "number",
+              description: "Maximum number of matching lines to return. Defaults to 50. Increase if you need more comprehensive results."
+            }
+          },
+          required: ["pattern"]
+        }
+      },
+      async execute(input) {
+        const searchPath = input.path || ".";
+        const max = input.maxResults || DEFAULT_MAX;
+        const globFlag = input.glob ? ` --glob '${input.glob}'` : "";
+        const escaped = input.pattern.replace(/'/g, "'\\''");
+        const rgCmd = `rg -n --no-heading --max-count=${max}${globFlag} '${escaped}' ${searchPath}`;
+        const grepCmd = `grep -rn --max-count=${max} '${escaped}' ${searchPath} --include='*.ts' --include='*.tsx' --include='*.js' --include='*.json' --include='*.md'`;
+        return new Promise((resolve) => {
+          exec2(rgCmd, { maxBuffer: 512 * 1024 }, (err, stdout) => {
+            if (stdout?.trim()) {
+              resolve(formatResults(stdout, max));
+              return;
+            }
+            exec2(grepCmd, { maxBuffer: 512 * 1024 }, (_err, grepStdout) => {
+              if (grepStdout?.trim()) {
+                resolve(formatResults(grepStdout, max));
+              } else {
+                resolve("No matches found.");
+              }
+            });
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/tools/code/glob.ts
+import fg from "fast-glob";
+var DEFAULT_MAX2, globTool;
+var init_glob = __esm({
+  "src/tools/code/glob.ts"() {
+    "use strict";
+    DEFAULT_MAX2 = 200;
+    globTool = {
+      definition: {
+        name: "glob",
+        description: 'Find files matching a glob pattern. Returns matching file paths sorted alphabetically (default 200 results). Use this to discover project structure, find files by name or extension, or check if a file exists. Common patterns: "**/*.ts" (all TypeScript files), "src/**/*.tsx" (React components in src), "*.json" (root-level JSON files). Automatically excludes node_modules and .git.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            pattern: {
+              type: "string",
+              description: 'Glob pattern (e.g., "**/*.ts", "src/**/*.tsx", "*.json").'
+            },
+            maxResults: {
+              type: "number",
+              description: "Maximum number of file paths to return. Defaults to 200. Increase if you need the complete list."
+            }
+          },
+          required: ["pattern"]
+        }
+      },
+      async execute(input) {
+        try {
+          const max = input.maxResults || DEFAULT_MAX2;
+          const files = await fg(input.pattern, {
+            ignore: ["**/node_modules/**", "**/.git/**"],
+            dot: false
+          });
+          if (files.length === 0) {
+            return "No files found.";
+          }
+          const sorted = files.sort();
+          const truncated = sorted.slice(0, max);
+          let result = truncated.join("\n");
+          if (sorted.length > max) {
+            result += `
+
+(showing ${max} of ${sorted.length} matches \u2014 increase maxResults to see all)`;
+          }
+          return result;
+        } catch (err) {
+          return `Error: ${err.message}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/code/listDir.ts
+import fs9 from "fs/promises";
+var listDirTool;
+var init_listDir = __esm({
+  "src/tools/code/listDir.ts"() {
+    "use strict";
+    listDirTool = {
+      definition: {
+        name: "listDir",
+        description: "List the contents of a directory. Shows entries with / suffix for directories, sorted directories-first then alphabetically. Use this for a quick overview of a directory's contents. For finding files across the whole project, use glob instead.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: 'Directory path to list, relative to project root. Defaults to ".".'
+            }
+          }
+        }
+      },
+      async execute(input) {
+        const dirPath = input.path || ".";
+        try {
+          const entries = await fs9.readdir(dirPath, { withFileTypes: true });
+          const lines = entries.filter((e) => e.name !== ".git" && e.name !== "node_modules").sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory()) {
+              return -1;
+            }
+            if (!a.isDirectory() && b.isDirectory()) {
+              return 1;
+            }
+            return a.name.localeCompare(b.name);
+          }).map((e) => e.isDirectory() ? `${e.name}/` : e.name);
+          return lines.join("\n") || "(empty directory)";
+        } catch (err) {
+          return `Error listing directory: ${err.message}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/code/editsFinished.ts
+var editsFinishedTool;
+var init_editsFinished = __esm({
+  "src/tools/code/editsFinished.ts"() {
+    "use strict";
+    editsFinishedTool = {
+      definition: {
+        name: "editsFinished",
+        description: "Signal that file edits are complete. Call this after you finish writing/editing files so the live preview updates cleanly. The preview is paused while you edit to avoid showing broken intermediate states \u2014 this unpauses it. If you forget to call this, the preview updates when your turn ends.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      async execute() {
+        return "Preview updated.";
+      }
+    };
+  }
+});
+
+// src/tools/_helpers/lsp.ts
+function setLspBaseUrl(url) {
+  lspBaseUrl = url;
+  log.info("LSP configured", { url });
+}
+function isLspConfigured() {
+  return lspBaseUrl !== null;
+}
+async function lspRequest(endpoint, body) {
+  if (!lspBaseUrl) {
+    throw new Error("LSP not available");
+  }
+  const url = `${lspBaseUrl}${endpoint}`;
+  log.debug("LSP request", { endpoint, body });
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      log.error("LSP sidecar error", { endpoint, status: res.status });
+      throw new Error(`LSP sidecar error: ${res.status}`);
+    }
+    return res.json();
+  } catch (err) {
+    if (err.message.startsWith("LSP sidecar")) {
+      throw err;
+    }
+    log.error("LSP connection error", { endpoint, error: err.message });
+    throw new Error(`LSP connection error: ${err.message}`);
+  }
+}
+var lspBaseUrl;
+var init_lsp = __esm({
+  "src/tools/_helpers/lsp.ts"() {
+    "use strict";
+    init_logger();
+    lspBaseUrl = null;
+  }
+});
+
+// src/tools/code/lspDiagnostics.ts
+var lspDiagnosticsTool;
+var init_lspDiagnostics = __esm({
+  "src/tools/code/lspDiagnostics.ts"() {
+    "use strict";
+    init_lsp();
+    lspDiagnosticsTool = {
+      definition: {
+        name: "lspDiagnostics",
+        description: "Get TypeScript diagnostics (type errors, warnings) for a file, with suggested fixes when available. Use this after editing a file to check for errors.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file: {
+              type: "string",
+              description: "File path relative to workspace root."
+            }
+          },
+          required: ["file"]
+        }
+      },
+      async execute(input) {
+        const data = await lspRequest("/diagnostics", { file: input.file });
+        const diags = data.diagnostics || [];
+        if (diags.length === 0) {
+          return "No diagnostics \u2014 file is clean.";
+        }
+        const lines = [];
+        for (const d of diags) {
+          let line = `${d.severity}: ${d.file}:${d.line}:${d.column} \u2014 ${d.message}`;
+          try {
+            const actionsData = await lspRequest("/code-actions", {
+              file: d.file,
+              startLine: d.line,
+              startColumn: d.column,
+              endLine: d.endLine ?? d.line,
+              endColumn: d.endColumn ?? d.column,
+              diagnostics: [d]
+            });
+            const actions = actionsData.actions || [];
+            if (actions.length > 0) {
+              const fixes = actions.map((a) => a.title).join("; ");
+              line += `
+  Quick fixes: ${fixes}`;
+            }
+          } catch {
+          }
+          lines.push(line);
+        }
+        return lines.join("\n");
+      }
+    };
+  }
+});
+
+// src/tools/code/restartProcess.ts
+var restartProcessTool;
+var init_restartProcess = __esm({
+  "src/tools/code/restartProcess.ts"() {
+    "use strict";
+    init_lsp();
+    restartProcessTool = {
+      definition: {
+        name: "restartProcess",
+        description: "Restart a managed sandbox process. Use this after running npm install or changing package.json to restart the dev server so it picks up new dependencies.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: 'Process name to restart. Currently supported: "devServer".'
+            }
+          },
+          required: ["name"]
+        }
+      },
+      async execute(input) {
+        const data = await lspRequest("/restart-process", { name: input.name });
+        if (data.ok) {
+          return `Restarted ${input.name}.`;
+        }
+        return `Error: unexpected response: ${JSON.stringify(data)}`;
+      }
+    };
+  }
+});
+
+// src/tools/index.ts
+function getSpecTools() {
+  return [readSpecTool, writeSpecTool, editSpecTool, listSpecFilesTool];
+}
+function getCodeTools() {
+  const tools = [
+    readFileTool,
+    writeFileTool,
+    editFileTool,
+    bashTool,
+    grepTool,
+    globTool,
+    listDirTool,
+    editsFinishedTool
+  ];
+  if (isLspConfigured()) {
+    tools.push(lspDiagnosticsTool, restartProcessTool);
+  }
+  return tools;
+}
+function getTools(projectHasCode) {
+  if (projectHasCode) {
+    return [
+      setViewModeTool,
+      promptUserTool,
+      clearSyncStatusTool,
+      presentSyncPlanTool,
+      presentPublishPlanTool,
+      presentPlanTool,
+      ...getSpecTools(),
+      ...getCodeTools()
+    ];
+  }
+  return [
+    setViewModeTool,
+    promptUserTool,
+    clearSyncStatusTool,
+    presentSyncPlanTool,
+    presentPublishPlanTool,
+    ...getSpecTools()
+  ];
+}
+function getToolDefinitions(projectHasCode) {
+  return getTools(projectHasCode).map((t) => t.definition);
+}
+function getToolByName(name) {
+  const allTools = [
+    setViewModeTool,
+    promptUserTool,
+    clearSyncStatusTool,
+    presentSyncPlanTool,
+    presentPublishPlanTool,
+    presentPlanTool,
+    ...getSpecTools(),
+    ...getCodeTools()
+  ];
+  return allTools.find((t) => t.definition.name === name);
+}
+function executeTool(name, input) {
+  const tool = getToolByName(name);
+  if (!tool) {
+    return Promise.resolve(`Error: Unknown tool "${name}"`);
+  }
+  return tool.execute(input);
+}
+var init_tools = __esm({
+  "src/tools/index.ts"() {
+    "use strict";
+    init_readSpec();
+    init_writeSpec();
+    init_editSpec();
+    init_listSpecFiles();
+    init_setViewMode();
+    init_promptUser();
+    init_clearSyncStatus();
+    init_presentSyncPlan();
+    init_presentPublishPlan();
+    init_presentPlan();
+    init_readFile();
+    init_writeFile();
+    init_editFile();
+    init_bash();
+    init_grep();
+    init_glob();
+    init_listDir();
+    init_editsFinished();
+    init_lsp();
+    init_lspDiagnostics();
+    init_restartProcess();
+  }
+});
+
+// src/session.ts
+import fs10 from "fs";
+function loadSession(state) {
+  try {
+    const raw = fs10.readFileSync(SESSION_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    if (Array.isArray(data.messages) && data.messages.length > 0) {
+      state.messages = sanitizeMessages(data.messages);
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function sanitizeMessages(messages) {
+  const result = [];
+  for (let i = 0; i < messages.length; i++) {
+    result.push(messages[i]);
+    const msg = messages[i];
+    if (msg.role !== "assistant" || !msg.toolCalls?.length) {
+      continue;
+    }
+    const resultIds = /* @__PURE__ */ new Set();
+    for (let j = i + 1; j < messages.length; j++) {
+      const next = messages[j];
+      if (next.role === "user" && next.toolCallId) {
+        resultIds.add(next.toolCallId);
+      } else {
+        break;
+      }
+    }
+    for (const tc of msg.toolCalls) {
+      if (!resultIds.has(tc.id)) {
+        result.push({
+          role: "user",
+          content: "Error: tool result lost (session recovered)",
+          toolCallId: tc.id,
+          isToolError: true
+        });
+      }
+    }
+  }
+  return result;
+}
+function saveSession(state) {
+  try {
+    fs10.writeFileSync(
+      SESSION_FILE,
+      JSON.stringify({ messages: state.messages }, null, 2),
+      "utf-8"
+    );
+  } catch {
+  }
+}
+function clearSession(state) {
+  state.messages = [];
+  try {
+    fs10.unlinkSync(SESSION_FILE);
+  } catch {
+  }
+}
+var SESSION_FILE;
+var init_session = __esm({
+  "src/session.ts"() {
+    "use strict";
+    SESSION_FILE = ".remy-session.json";
+  }
+});
+
+// src/parsePartialJson.ts
+function parsePartialJson(jsonString) {
+  const length = jsonString.length;
+  let index = 0;
+  const markPartial = (msg) => {
+    throw new PartialJSON(`${msg} at position ${index}`);
+  };
+  const throwMalformed = (msg) => {
+    throw new MalformedJSON(`${msg} at position ${index}`);
+  };
+  const skipBlank = () => {
+    while (index < length && " \n\r	".includes(jsonString[index])) {
+      index++;
+    }
+  };
+  const parseAny = () => {
+    skipBlank();
+    if (index >= length) {
+      markPartial("Unexpected end of input");
+    }
+    const ch = jsonString[index];
+    if (ch === '"') {
+      return parseStr();
+    }
+    if (ch === "{") {
+      return parseObj();
+    }
+    if (ch === "[") {
+      return parseArr();
+    }
+    if (jsonString.substring(index, index + 4) === "null" || length - index < 4 && "null".startsWith(jsonString.substring(index))) {
+      index += 4;
+      return null;
+    }
+    if (jsonString.substring(index, index + 4) === "true" || length - index < 4 && "true".startsWith(jsonString.substring(index))) {
+      index += 4;
+      return true;
+    }
+    if (jsonString.substring(index, index + 5) === "false" || length - index < 5 && "false".startsWith(jsonString.substring(index))) {
+      index += 5;
+      return false;
+    }
+    return parseNum();
+  };
+  const parseStr = () => {
+    const start = index;
+    let escape = false;
+    index++;
+    while (index < length && (jsonString[index] !== '"' || escape && jsonString[index - 1] === "\\")) {
+      escape = jsonString[index] === "\\" ? !escape : false;
+      index++;
+    }
+    if (jsonString.charAt(index) === '"') {
+      try {
+        return JSON.parse(
+          jsonString.substring(start, ++index - Number(escape))
+        );
+      } catch (e) {
+        return throwMalformed(String(e));
+      }
+    }
+    try {
+      return JSON.parse(
+        jsonString.substring(start, index - Number(escape)) + '"'
+      );
+    } catch {
+      return JSON.parse(
+        jsonString.substring(start, jsonString.lastIndexOf("\\")) + '"'
+      );
+    }
+  };
+  const parseObj = () => {
+    index++;
+    skipBlank();
+    const obj = {};
+    try {
+      while (jsonString[index] !== "}") {
+        skipBlank();
+        if (index >= length) {
+          return obj;
+        }
+        const key = parseStr();
+        skipBlank();
+        index++;
+        try {
+          obj[key] = parseAny();
+        } catch {
+          return obj;
+        }
+        skipBlank();
+        if (jsonString[index] === ",") {
+          index++;
+        }
+      }
+    } catch {
+      return obj;
+    }
+    index++;
+    return obj;
+  };
+  const parseArr = () => {
+    index++;
+    const arr = [];
+    try {
+      while (jsonString[index] !== "]") {
+        arr.push(parseAny());
+        skipBlank();
+        if (jsonString[index] === ",") {
+          index++;
+        }
+      }
+    } catch {
+      return arr;
+    }
+    index++;
+    return arr;
+  };
+  const parseNum = () => {
+    if (index === 0) {
+      if (jsonString === "-") {
+        throwMalformed("Not sure what '-' is");
+      }
+      try {
+        return JSON.parse(jsonString);
+      } catch (e) {
+        try {
+          return JSON.parse(
+            jsonString.substring(0, jsonString.lastIndexOf("e"))
+          );
+        } catch {
+        }
+        throwMalformed(String(e));
+      }
+    }
+    const start = index;
+    if (jsonString[index] === "-") {
+      index++;
+    }
+    while (jsonString[index] && ",]}".indexOf(jsonString[index]) === -1) {
+      index++;
+    }
+    try {
+      return JSON.parse(jsonString.substring(start, index));
+    } catch (e) {
+      if (jsonString.substring(start, index) === "-") {
+        markPartial("Not sure what '-' is");
+      }
+      try {
+        return JSON.parse(
+          jsonString.substring(start, jsonString.lastIndexOf("e"))
+        );
+      } catch {
+        throwMalformed(String(e));
+      }
+    }
+  };
+  return parseAny();
+}
+var PartialJSON, MalformedJSON;
+var init_parsePartialJson = __esm({
+  "src/parsePartialJson.ts"() {
+    "use strict";
+    PartialJSON = class extends Error {
+    };
+    MalformedJSON = class extends Error {
+    };
+  }
+});
+
+// src/agent.ts
+function createAgentState() {
+  return { messages: [] };
+}
+async function runTurn(params) {
+  const {
+    state,
+    userMessage,
+    attachments,
+    apiConfig,
+    system,
+    model,
+    projectHasCode,
+    signal,
+    onEvent,
+    resolveExternalTool,
+    hidden
+  } = params;
+  const tools = getToolDefinitions(projectHasCode);
+  log.info("Turn started", {
+    messageLength: userMessage.length,
+    toolCount: tools.length,
+    tools: tools.map((t) => t.name),
+    ...attachments && attachments.length > 0 && {
+      attachmentCount: attachments.length,
+      attachmentUrls: attachments.map((a) => a.url)
+    }
+  });
+  onEvent({ type: "turn_started" });
+  const userMsg = { role: "user", content: userMessage };
+  if (hidden) {
+    userMsg.hidden = true;
+  }
+  if (attachments && attachments.length > 0) {
+    userMsg.attachments = attachments;
+    log.debug("Attachments added to user message", {
+      count: attachments.length,
+      urls: attachments.map((a) => a.url)
+    });
+  }
+  state.messages.push(userMsg);
+  while (true) {
+    let getOrCreateAccumulator2 = function(id, name) {
+      let acc = toolInputAccumulators.get(id);
+      if (!acc) {
+        acc = { name, json: "", started: false, lastEmittedCount: 0 };
+        toolInputAccumulators.set(id, acc);
+      }
+      return acc;
+    };
+    var getOrCreateAccumulator = getOrCreateAccumulator2;
+    if (signal?.aborted) {
+      onEvent({ type: "turn_cancelled" });
+      saveSession(state);
+      return;
+    }
+    let assistantText = "";
+    const toolCalls = [];
+    const toolInputAccumulators = /* @__PURE__ */ new Map();
+    let stopReason = "end_turn";
+    async function handlePartialInput(acc, id, name, partial) {
+      const tool = getToolByName(name);
+      if (!tool?.streaming) {
+        return;
+      }
+      const {
+        contentField = "content",
+        transform,
+        partialInput
+      } = tool.streaming;
+      if (partialInput) {
+        const result = partialInput(partial, acc.lastEmittedCount);
+        if (!result) {
+          return;
+        }
+        acc.lastEmittedCount = result.emittedCount;
+        acc.started = true;
+        log.debug("Streaming partial tool_start", {
+          id,
+          name,
+          emittedCount: result.emittedCount
+        });
+        onEvent({
+          type: "tool_start",
+          id,
+          name,
+          input: result.input,
+          partial: true
+        });
+        return;
+      }
+      const content = partial[contentField];
+      if (typeof content !== "string") {
+        return;
+      }
+      if (!acc.started) {
+        acc.started = true;
+        log.debug("Streaming content tool: emitting early tool_start", {
+          id,
+          name
+        });
+        onEvent({ type: "tool_start", id, name, input: partial });
+      }
+      if (transform) {
+        const result = await transform(partial);
+        log.debug("Streaming content tool: emitting tool_input_delta", {
+          id,
+          name,
+          resultLength: result.length
+        });
+        onEvent({ type: "tool_input_delta", id, name, result });
+      } else {
+        log.debug("Streaming content tool: emitting tool_input_delta", {
+          id,
+          name,
+          contentLength: content.length
+        });
+        onEvent({ type: "tool_input_delta", id, name, result: content });
+      }
+    }
+    try {
+      for await (const event of streamChat({
+        ...apiConfig,
+        model,
+        system,
+        messages: state.messages,
+        tools,
+        signal
+      })) {
+        if (signal?.aborted) {
+          break;
+        }
+        switch (event.type) {
+          case "text":
+            assistantText += event.text;
+            onEvent({ type: "text", text: event.text });
+            break;
+          case "thinking":
+            onEvent({ type: "thinking", text: event.text });
+            break;
+          case "tool_input_delta": {
+            const acc = getOrCreateAccumulator2(event.id, event.name);
+            acc.json += event.delta;
+            log.debug("Received tool_input_delta", {
+              id: event.id,
+              name: event.name,
+              deltaLength: event.delta.length,
+              accumulatedLength: acc.json.length
+            });
+            try {
+              const partial = parsePartialJson(acc.json);
+              await handlePartialInput(acc, event.id, event.name, partial);
+            } catch {
+            }
+            break;
+          }
+          case "tool_input_args": {
+            const acc = getOrCreateAccumulator2(event.id, event.name);
+            log.debug("Received tool_input_args", {
+              id: event.id,
+              name: event.name,
+              keys: Object.keys(event.args)
+            });
+            await handlePartialInput(acc, event.id, event.name, event.args);
+            break;
+          }
+          case "tool_use": {
+            toolCalls.push({
+              id: event.id,
+              name: event.name,
+              input: event.input
+            });
+            const acc = toolInputAccumulators.get(event.id);
+            const tool = getToolByName(event.name);
+            const wasStreamed = acc?.started ?? false;
+            const isInputStreaming = !!tool?.streaming?.partialInput;
+            log.debug("Received tool_use", {
+              id: event.id,
+              name: event.name,
+              wasStreamed,
+              isInputStreaming
+            });
+            if (!wasStreamed || isInputStreaming) {
+              onEvent({
+                type: "tool_start",
+                id: event.id,
+                name: event.name,
+                input: event.input
+              });
+            }
+            break;
+          }
+          case "done":
+            stopReason = event.stopReason;
+            break;
+          case "error":
+            onEvent({ type: "error", error: event.error });
+            return;
+        }
+      }
+    } catch (err) {
+      if (signal?.aborted) {
+      } else {
+        throw err;
+      }
+    }
+    if (signal?.aborted) {
+      if (assistantText) {
+        state.messages.push({
+          role: "assistant",
+          content: assistantText + "\n\n(cancelled)",
+          toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+        });
+      }
+      onEvent({ type: "turn_cancelled" });
+      saveSession(state);
+      return;
+    }
+    state.messages.push({
+      role: "assistant",
+      content: assistantText,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+    });
+    if (stopReason !== "tool_use" || toolCalls.length === 0) {
+      saveSession(state);
+      onEvent({ type: "turn_done" });
+      return;
+    }
+    log.info("Executing tools", {
+      count: toolCalls.length,
+      tools: toolCalls.map((tc) => tc.name)
+    });
+    const results = await Promise.all(
+      toolCalls.map(async (tc) => {
+        if (signal?.aborted) {
+          return {
+            id: tc.id,
+            result: "Error: cancelled",
+            isError: true
+          };
+        }
+        const toolStart = Date.now();
+        try {
+          let result;
+          if (EXTERNAL_TOOLS.has(tc.name) && resolveExternalTool) {
+            saveSession(state);
+            log.debug("Waiting for external tool result", {
+              name: tc.name,
+              id: tc.id
+            });
+            result = await resolveExternalTool(tc.id, tc.name, tc.input);
+          } else {
+            result = await executeTool(tc.name, tc.input);
+          }
+          const isError = result.startsWith("Error");
+          log.debug("Tool completed", {
+            name: tc.name,
+            elapsed: `${Date.now() - toolStart}ms`,
+            isError,
+            resultLength: result.length
+          });
+          onEvent({
+            type: "tool_done",
+            id: tc.id,
+            name: tc.name,
+            result,
+            isError
+          });
+          return { id: tc.id, result, isError };
+        } catch (err) {
+          const errorMsg = `Error: ${err.message}`;
+          onEvent({
+            type: "tool_done",
+            id: tc.id,
+            name: tc.name,
+            result: errorMsg,
+            isError: true
+          });
+          return { id: tc.id, result: errorMsg, isError: true };
+        }
+      })
+    );
+    for (const r of results) {
+      state.messages.push({
+        role: "user",
+        content: r.result,
+        toolCallId: r.id,
+        isToolError: r.isError
+      });
+    }
+    if (signal?.aborted) {
+      onEvent({ type: "turn_cancelled" });
+      saveSession(state);
+      return;
+    }
+  }
+}
+var EXTERNAL_TOOLS;
+var init_agent = __esm({
+  "src/agent.ts"() {
+    "use strict";
+    init_api();
+    init_tools();
+    init_session();
+    init_logger();
+    init_parsePartialJson();
+    EXTERNAL_TOOLS = /* @__PURE__ */ new Set([
+      "promptUser",
+      "setViewMode",
+      "clearSyncStatus",
+      "presentSyncPlan",
+      "presentPublishPlan",
+      "presentPlan"
+    ]);
+  }
+});
+
+// src/prompt/static/projectContext.ts
+import fs11 from "fs";
+import path4 from "path";
+function loadProjectInstructions() {
+  for (const file of AGENT_INSTRUCTION_FILES) {
+    try {
+      const content = fs11.readFileSync(file, "utf-8").trim();
+      if (content) {
+        return `
+## Project Instructions (${file})
+${content}`;
+      }
+    } catch {
+    }
+  }
+  return "";
+}
+function loadProjectManifest() {
+  try {
+    const manifest = fs11.readFileSync("mindstudio.json", "utf-8");
+    return `
+## Project Manifest (mindstudio.json)
+\`\`\`json
+${manifest}
+\`\`\``;
+  } catch {
+    return "";
+  }
+}
+function loadSpecFileMetadata() {
+  try {
+    const files = walkMdFiles("src");
+    if (files.length === 0) {
+      return "";
+    }
+    const entries = [];
+    for (const filePath of files) {
+      const { name, description } = parseFrontmatter(filePath);
+      let line = `- ${filePath}`;
+      if (name) {
+        line += ` \u2014 "${name}"`;
+      }
+      if (description) {
+        line += ` \u2014 ${description}`;
+      }
+      entries.push(line);
+    }
+    return `
+## Spec Files
+${entries.join("\n")}`;
+  } catch {
+    return "";
+  }
+}
+function walkMdFiles(dir) {
+  const results = [];
+  try {
+    const entries = fs11.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...walkMdFiles(full));
+      } else if (entry.name.endsWith(".md")) {
+        results.push(full);
+      }
+    }
+  } catch {
+  }
+  return results.sort();
+}
+function parseFrontmatter(filePath) {
+  try {
+    const content = fs11.readFileSync(filePath, "utf-8");
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) {
+      return { name: "", description: "" };
+    }
+    const fm = match[1];
+    const name = fm.match(/^name:\s*(.+)$/m)?.[1]?.trim() ?? "";
+    const description = fm.match(/^description:\s*(.+)$/m)?.[1]?.trim() ?? "";
+    return { name, description };
+  } catch {
+    return { name: "", description: "" };
+  }
+}
+function loadProjectFileListing() {
+  try {
+    const entries = fs11.readdirSync(".", { withFileTypes: true });
+    const listing = entries.filter((e) => e.name !== ".git" && e.name !== "node_modules").sort((a, b) => {
+      if (a.isDirectory() && !b.isDirectory()) {
+        return -1;
+      }
+      if (!a.isDirectory() && b.isDirectory()) {
+        return 1;
+      }
+      return a.name.localeCompare(b.name);
+    }).map((e) => e.isDirectory() ? `${e.name}/` : e.name).join("\n");
+    return `
+## Project Files
+\`\`\`
+${listing}
+\`\`\``;
+  } catch {
+    return "";
+  }
+}
+var AGENT_INSTRUCTION_FILES;
+var init_projectContext = __esm({
+  "src/prompt/static/projectContext.ts"() {
+    "use strict";
+    AGENT_INSTRUCTION_FILES = [
+      "CLAUDE.md",
+      "claude.md",
+      ".claude/instructions.md",
+      "AGENTS.md",
+      "agents.md",
+      ".agents.md",
+      "COPILOT.md",
+      "copilot.md",
+      ".copilot-instructions.md",
+      ".github/copilot-instructions.md",
+      "REMY.md",
+      "remy.md",
+      ".cursorrules",
+      ".cursorules"
+    ];
+  }
+});
+
+// src/prompt/index.ts
+import fs12 from "fs";
+import path5 from "path";
+function requireFile(filePath) {
+  const full = path5.join(PROMPT_DIR, filePath);
+  try {
+    return fs12.readFileSync(full, "utf-8").trim();
+  } catch {
+    throw new Error(`Required prompt file missing: ${full}`);
+  }
+}
+function resolveIncludes(template) {
+  const result = template.replace(
+    /\{\{([^}]+)\}\}/g,
+    (_, filePath) => requireFile(filePath.trim())
+  );
+  return result.replace(/\n{3,}/g, "\n\n").trim();
+}
+function buildSystemPrompt(projectHasCode, viewContext) {
+  const projectContext = [
+    loadProjectInstructions(),
+    loadProjectManifest(),
+    loadSpecFileMetadata(),
+    loadProjectFileListing()
+  ].filter(Boolean).join("\n");
+  const now = (/* @__PURE__ */ new Date()).toLocaleString("en-US", {
+    dateStyle: "full",
+    timeStyle: "long"
+  });
+  const template = `
+{{static/identity.md}}
+
+The current date is ${now}.
+
+<platform_docs>
+  <platform>
+  {{compiled/platform.md}}
+  </platform>
+
+  <manifest>
+  {{compiled/manifest.md}}
+  </manifest>
+
+  <tables>
+  {{compiled/tables.md}}
+  </tables>
+
+  <methods>
+  {{compiled/methods.md}}
+  </methods>
+
+  <auth>
+  {{compiled/auth.md}}
+  </auth>
+
+  <dev_and_deploy>
+  {{compiled/dev-and-deploy.md}}
+  </dev_and_deploy>
+
+  <design>
+  {{compiled/design.md}}
+  </design>
+
+  <media_cdn>
+  {{compiled/media-cdn.md}}
+  </media_cdn>
+
+  <interfaces>
+  {{compiled/interfaces.md}}
+  </interfaces>
+
+  <scenarios>
+  {{compiled/scenarios.md}}
+  </scenarios>
+</platform_docs>
+
+<mindstudio_agent_sdk_docs>
+  {{compiled/sdk-actions.md}}
+</mindstudio_agent_sdk_docs>
+
+<mindstudio_flavored_markdown_spec_docs>
+  {{compiled/msfm.md}}
+</mindstudio_flavored_markdown_spec_docs>
+
+<project_context>
+${projectContext}
+</project_context>
+
+${isLspConfigured() ? `<lsp>
+{{static/lsp.md}}
+</lsp>` : ""}
+
+{{static/intake.md}}
+
+{{static/authoring.md}}
+
+{{static/instructions.md}}
+
+<current_authoring_mode>
+${projectHasCode ? "Project has code - keep code and spec in sync." : "Project does not have code yet - focus on writing the spec."}
+</current_authoring_mode>
+
+<view_context>
+The user is currently in ${viewContext?.mode ?? "code"} mode.
+${viewContext?.activeFile ? `Active file: ${viewContext.activeFile}` : ""}
+</view_context>
+`;
+  return resolveIncludes(template);
+}
+var PROMPT_DIR;
+var init_prompt = __esm({
+  "src/prompt/index.ts"() {
+    "use strict";
+    init_lsp();
+    init_projectContext();
+    PROMPT_DIR = import.meta.dirname ?? path5.dirname(new URL(import.meta.url).pathname);
+  }
+});
+
+// src/config.ts
+import fs13 from "fs";
+import path6 from "path";
+import os from "os";
+function loadConfigFile() {
+  try {
+    const raw = fs13.readFileSync(CONFIG_PATH, "utf-8");
+    log.debug("Loaded config file", { path: CONFIG_PATH });
+    return JSON.parse(raw);
+  } catch (err) {
+    log.debug("No config file found", {
+      path: CONFIG_PATH,
+      error: err.message
+    });
+    return {};
+  }
+}
+function resolveConfig(flags2) {
+  const file = loadConfigFile();
+  const activeEnv = file.environment || "prod";
+  const env = file.environments?.[activeEnv];
+  const apiKey = flags2?.apiKey || process.env.MINDSTUDIO_API_KEY || env?.apiKey || "";
+  const baseUrl = flags2?.baseUrl || process.env.MINDSTUDIO_BASE_URL || env?.apiBaseUrl || DEFAULT_BASE_URL;
+  if (!apiKey) {
+    log.error("No API key found");
+    throw new Error(
+      "No API key found. Set MINDSTUDIO_API_KEY or configure ~/.mindstudio-local-tunnel/config.json."
+    );
+  }
+  const keySource = flags2?.apiKey ? "cli flag" : process.env.MINDSTUDIO_API_KEY ? "env var" : "config file";
+  log.info("Config resolved", {
+    baseUrl,
+    keySource,
+    environment: activeEnv
+  });
+  return { apiKey, baseUrl };
+}
+var CONFIG_PATH, DEFAULT_BASE_URL;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_logger();
+    CONFIG_PATH = path6.join(
+      os.homedir(),
+      ".mindstudio-local-tunnel",
+      "config.json"
+    );
+    DEFAULT_BASE_URL = "https://api.mindstudio.ai";
+  }
+});
+
+// src/headless.ts
+var headless_exports = {};
+__export(headless_exports, {
+  startHeadless: () => startHeadless
+});
+import { createInterface } from "readline";
+import fs14 from "fs";
+import path7 from "path";
+function loadActionPrompt(name) {
+  return fs14.readFileSync(path7.join(ACTIONS_DIR, `${name}.md`), "utf-8").trim();
+}
+function emit(event, data) {
+  process.stdout.write(JSON.stringify({ event, ...data }) + "\n");
+}
+async function startHeadless(opts = {}) {
+  const stderrWrite = (...args2) => {
+    process.stderr.write(args2.map(String).join(" ") + "\n");
+  };
+  console.log = stderrWrite;
+  console.warn = stderrWrite;
+  console.info = stderrWrite;
+  if (opts.lspUrl) {
+    setLspBaseUrl(opts.lspUrl);
+  }
+  const config = resolveConfig({
+    apiKey: opts.apiKey,
+    baseUrl: opts.baseUrl
+  });
+  const state = createAgentState();
+  const resumed = loadSession(state);
+  if (resumed) {
+    emit("session_restored", {
+      messageCount: state.messages.length
+    });
+  }
+  let running = false;
+  let currentAbort = null;
+  const externalToolPromises = /* @__PURE__ */ new Map();
+  function onEvent(e) {
+    switch (e.type) {
+      case "text":
+        emit("text", { text: e.text });
+        break;
+      case "thinking":
+        emit("thinking", { text: e.text });
+        break;
+      case "tool_input_delta":
+        emit("tool_input_delta", { id: e.id, name: e.name, result: e.result });
+        break;
+      case "tool_start": {
+        emit("tool_start", {
+          id: e.id,
+          name: e.name,
+          input: e.input,
+          ...e.partial && { partial: true }
+        });
+        if (!e.partial && !externalToolPromises.has(e.id)) {
+          let resolve;
+          const promise = new Promise((r) => {
+            resolve = r;
+          });
+          externalToolPromises.set(e.id, { promise, resolve });
+        }
+        break;
+      }
+      case "tool_done":
+        emit("tool_done", {
+          id: e.id,
+          name: e.name,
+          result: e.result,
+          isError: e.isError
+        });
+        break;
+      case "turn_started":
+        emit("turn_started");
+        break;
+      case "turn_done":
+        emit("turn_done");
+        break;
+      case "turn_cancelled":
+        emit("turn_cancelled");
+        break;
+      case "error":
+        emit("error", { error: e.error });
+        break;
+    }
+  }
+  function resolveExternalTool(id, _name, _input) {
+    const entry = externalToolPromises.get(id);
+    if (entry) {
+      return entry.promise;
+    }
+    let resolve;
+    const promise = new Promise((r) => {
+      resolve = r;
+    });
+    externalToolPromises.set(id, { promise, resolve });
+    return promise;
+  }
+  const rl = createInterface({ input: process.stdin });
+  rl.on("line", async (line) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      emit("error", { error: "Invalid JSON on stdin" });
+      return;
+    }
+    if (parsed.action === "tool_result" && parsed.id) {
+      const entry = externalToolPromises.get(parsed.id);
+      if (entry) {
+        externalToolPromises.delete(parsed.id);
+        entry.resolve(parsed.result ?? "");
+      }
+      return;
+    }
+    if (parsed.action === "get_history") {
+      emit("history", {
+        messages: state.messages
+      });
+      return;
+    }
+    if (parsed.action === "clear") {
+      clearSession(state);
+      emit("session_cleared");
+      return;
+    }
+    if (parsed.action === "cancel") {
+      if (currentAbort) {
+        currentAbort.abort();
+      }
+      for (const [id, entry] of externalToolPromises) {
+        entry.resolve("Error: cancelled");
+        externalToolPromises.delete(id);
+      }
+      return;
+    }
+    if (parsed.action === "message" && (parsed.text || parsed.runCommand)) {
+      if (running) {
+        emit("error", { error: "Agent is already processing a message" });
+        return;
+      }
+      running = true;
+      currentAbort = new AbortController();
+      if (parsed.attachments?.length) {
+        console.warn(
+          `[headless] Message has ${parsed.attachments.length} attachment(s):`,
+          parsed.attachments.map((a) => a.url)
+        );
+      }
+      let userMessage = parsed.text ?? "";
+      const isCommand = !!parsed.runCommand;
+      if (parsed.runCommand === "sync") {
+        userMessage = loadActionPrompt("sync");
+      } else if (parsed.runCommand === "publish") {
+        userMessage = loadActionPrompt("publish");
+      }
+      const projectHasCode = parsed.projectHasCode ?? true;
+      const system = buildSystemPrompt(projectHasCode, parsed.viewContext);
+      try {
+        await runTurn({
+          state,
+          userMessage,
+          attachments: parsed.attachments,
+          apiConfig: config,
+          system,
+          model: opts.model,
+          projectHasCode,
+          signal: currentAbort.signal,
+          onEvent,
+          resolveExternalTool,
+          hidden: isCommand
+        });
+      } catch (err) {
+        emit("error", { error: err.message });
+      }
+      currentAbort = null;
+      running = false;
+    }
+  });
+  rl.on("close", () => {
+    emit("stopping");
+    emit("stopped");
+    process.exit(0);
+  });
+  function shutdown() {
+    emit("stopping");
+    emit("stopped");
+    process.exit(0);
+  }
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  emit("ready");
+}
+var BASE_DIR, ACTIONS_DIR;
+var init_headless = __esm({
+  "src/headless.ts"() {
+    "use strict";
+    init_config();
+    init_prompt();
+    init_lsp();
+    init_agent();
+    init_session();
+    BASE_DIR = import.meta.dirname ?? path7.dirname(new URL(import.meta.url).pathname);
+    ACTIONS_DIR = path7.join(BASE_DIR, "actions");
+  }
+});
+
+// src/index.tsx
+import { render } from "ink";
+import os2 from "os";
+import fs15 from "fs";
+import path8 from "path";
+
+// src/tui/App.tsx
+import { useState as useState2, useCallback, useRef } from "react";
+import { Box as Box4, Text as Text5, useApp, useInput } from "ink";
+
+// src/tui/InputPrompt.tsx
+import { useState } from "react";
+import { Box, Text } from "ink";
+import TextInput from "ink-text-input";
+import { jsx, jsxs } from "react/jsx-runtime";
+function InputPrompt({ onSubmit, disabled }) {
+  const [value, setValue] = useState("");
+  if (disabled) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "> " }),
+    /* @__PURE__ */ jsx(
+      TextInput,
+      {
+        value,
+        onChange: setValue,
+        onSubmit: (v) => {
+          if (v.trim()) {
+            onSubmit(v.trim());
+            setValue("");
+          }
+        }
+      }
+    )
+  ] });
+}
+
+// src/tui/MessageList.tsx
+import { Box as Box3, Text as Text4 } from "ink";
+
+// src/tui/ToolCall.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import Spinner from "ink-spinner";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function summarizeInput(name, input) {
+  switch (name) {
+    case "readFile":
+    case "writeFile":
+    case "editFile":
+      return input.path || "";
+    case "bash":
+      return input.command || "";
+    case "grep":
+      return input.pattern || "";
+    case "glob":
+      return input.pattern || "";
+    case "listDir":
+      return input.path || ".";
+    default:
+      return JSON.stringify(input).slice(0, 60);
+  }
+}
+function summarizeResult(name, result) {
+  if (result.startsWith("Error")) {
+    return result.split("\n")[0];
+  }
+  const lines = result.split("\n").length;
+  switch (name) {
+    case "readFile":
+      return `${lines} lines`;
+    case "writeFile":
+      return result;
+    case "editFile":
+      return result;
+    case "bash":
+      return lines > 3 ? `${lines} lines of output` : result.trim();
+    case "grep":
+      return `${lines} matches`;
+    case "glob":
+      return `${lines} files`;
+    case "listDir":
+      return `${lines} entries`;
+    default:
+      return `${lines} lines`;
+  }
+}
+function ToolCall({ name, input, status, result }) {
+  const summary = summarizeInput(name, input);
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { children: " " }),
+    status === "running" ? /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: /* @__PURE__ */ jsx2(Spinner, { type: "dots" }) }) : status === "error" ? /* @__PURE__ */ jsx2(Text2, { color: "red", children: "\u2717" }) : /* @__PURE__ */ jsx2(Text2, { color: "green", children: "\u27E1" }),
+    /* @__PURE__ */ jsx2(Text2, { children: " " }),
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: name }),
+    summary ? /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      " ",
+      summary
+    ] }) : null,
+    result && status !== "running" ? /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      " \u2192 ",
+      summarizeResult(name, result)
+    ] }) : null
+  ] });
+}
+
+// src/tui/ThinkingBlock.tsx
+import { Text as Text3 } from "ink";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function ThinkingBlock({ text }) {
+  if (!text) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx3(Text3, { dimColor: true, italic: true, children: text });
+}
+
+// src/tui/MessageList.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function MessageList({ turns }) {
+  return /* @__PURE__ */ jsx4(Box3, { flexDirection: "column", gap: 1, children: turns.map((turn, i) => /* @__PURE__ */ jsx4(Box3, { flexDirection: "column", children: turn.role === "user" ? /* @__PURE__ */ jsxs3(Text4, { children: [
+    /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "> " }),
+    turn.text
+  ] }) : /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    turn.thinking ? /* @__PURE__ */ jsx4(ThinkingBlock, { text: turn.thinking }) : null,
+    turn.toolCalls.map((tc) => /* @__PURE__ */ jsx4(
+      ToolCall,
+      {
+        name: tc.name,
+        input: tc.input,
+        status: tc.status,
+        result: tc.result
+      },
+      tc.id
+    )),
+    turn.text ? /* @__PURE__ */ jsx4(Box3, { marginTop: turn.toolCalls.length > 0 ? 1 : 0, children: /* @__PURE__ */ jsx4(Text4, { children: turn.text }) }) : null
+  ] }) }, i)) });
+}
+
+// src/tui/App.tsx
+init_agent();
+init_prompt();
+init_session();
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function App({ apiConfig, model }) {
+  const { exit } = useApp();
+  const [turns, setTurns] = useState2([]);
+  const [isRunning, setIsRunning] = useState2(false);
+  const abortRef = useRef(null);
+  const [agentState] = useState2(() => {
+    const s = createAgentState();
+    loadSession(s);
+    return s;
+  });
+  const [sessionRestored] = useState2(() => agentState.messages.length > 0);
+  const [system] = useState2(() => buildSystemPrompt());
+  useInput((input, key) => {
+    if (key.escape && isRunning && abortRef.current) {
+      abortRef.current.abort();
+    }
+  });
+  const updateAssistant = useCallback(
+    (updater) => {
+      setTurns((prev) => {
+        const copy = [...prev];
+        const last = copy[copy.length - 1];
+        if (last?.role === "assistant") {
+          copy[copy.length - 1] = updater(last);
+        }
+        return copy;
+      });
+    },
+    []
+  );
+  const handleSubmit = useCallback(
+    async (message) => {
+      if (message === "/clear") {
+        clearSession(agentState);
+        setTurns([]);
+        return;
+      }
+      setTurns((prev) => [
+        ...prev,
+        {
+          role: "user",
+          text: message,
+          thinking: "",
+          toolCalls: [],
+          done: true
+        },
+        {
+          role: "assistant",
+          text: "",
+          thinking: "",
+          toolCalls: [],
+          done: false
+        }
+      ]);
+      setIsRunning(true);
+      const abort = new AbortController();
+      abortRef.current = abort;
+      try {
+        await runTurn({
+          state: agentState,
+          userMessage: message,
+          apiConfig,
+          system,
+          model,
+          projectHasCode: true,
+          signal: abort.signal,
+          onEvent: (event) => {
+            switch (event.type) {
+              case "text":
+                updateAssistant((t) => ({
+                  ...t,
+                  text: t.text + event.text
+                }));
+                break;
+              case "thinking":
+                updateAssistant((t) => ({
+                  ...t,
+                  thinking: t.thinking + event.text
+                }));
+                break;
+              case "tool_start":
+                updateAssistant((t) => ({
+                  ...t,
+                  toolCalls: [
+                    ...t.toolCalls,
+                    {
+                      id: event.id,
+                      name: event.name,
+                      input: event.input,
+                      status: "running"
+                    }
+                  ]
+                }));
+                break;
+              case "tool_done":
+                updateAssistant((t) => ({
+                  ...t,
+                  toolCalls: t.toolCalls.map(
+                    (tc) => tc.id === event.id ? {
+                      ...tc,
+                      status: event.isError ? "error" : "done",
+                      result: event.result
+                    } : tc
+                  )
+                }));
+                break;
+              case "turn_done":
+                updateAssistant((t) => ({ ...t, done: true }));
+                break;
+              case "turn_cancelled":
+                updateAssistant((t) => ({
+                  ...t,
+                  text: t.text + "\n(cancelled)",
+                  done: true
+                }));
+                break;
+              case "error":
+                updateAssistant((t) => ({
+                  ...t,
+                  text: t.text + `
+Error: ${event.error}`,
+                  done: true
+                }));
+                break;
+            }
+          }
+        });
+      } catch (err) {
+        updateAssistant((t) => ({
+          ...t,
+          text: t.text + `
+Error: ${err.message}`,
+          done: true
+        }));
+      }
+      abortRef.current = null;
+      setIsRunning(false);
+    },
+    [agentState, apiConfig, system, model, updateAssistant]
+  );
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxs4(Text5, { bold: true, color: "magenta", children: [
+      "Remy ",
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "v0.1.0 \u2014 MindStudio coding agent" })
+    ] }),
+    sessionRestored && /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+      "Session restored (",
+      agentState.messages.length,
+      " messages). Delete .remy-session.json to start fresh."
+    ] }),
+    /* @__PURE__ */ jsx5(MessageList, { turns }),
+    isRunning ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Press Escape to cancel" }) : /* @__PURE__ */ jsx5(InputPrompt, { onSubmit: handleSubmit, disabled: isRunning })
+  ] });
+}
+
+// src/index.tsx
+init_config();
+init_logger();
+import { jsx as jsx6 } from "react/jsx-runtime";
+var args = process.argv.slice(2);
+var flags = {};
+var headless = false;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--api-key" && args[i + 1]) {
+    flags.apiKey = args[++i];
+  } else if (args[i] === "--base-url" && args[i + 1]) {
+    flags.baseUrl = args[++i];
+  } else if (args[i] === "--model" && args[i + 1]) {
+    flags.model = args[++i];
+  } else if (args[i] === "--lsp-url" && args[i + 1]) {
+    flags.lspUrl = args[++i];
+  } else if (args[i] === "--log-level" && args[i + 1]) {
+    flags.logLevel = args[++i];
+  } else if (args[i] === "--headless") {
+    headless = true;
+  }
+}
+function printDebugInfo(config) {
+  const pkg = JSON.parse(
+    fs15.readFileSync(
+      path8.join(import.meta.dirname, "..", "package.json"),
+      "utf-8"
+    )
+  );
+  const keyPreview = config.apiKey ? `${config.apiKey.slice(0, 8)}...${config.apiKey.slice(-4)}` : "(none)";
+  console.log("");
+  console.log("remy debug info");
+  console.log("\u2500".repeat(40));
+  console.log(`  version:    ${pkg.version}`);
+  console.log(`  node:       ${process.version}`);
+  console.log(`  platform:   ${os2.platform()} ${os2.arch()}`);
+  console.log(`  os:         ${os2.type()} ${os2.release()}`);
+  console.log(`  cwd:        ${process.cwd()}`);
+  console.log(`  bin:        ${process.argv[1]}`);
+  console.log(`  model:      ${flags.model || "(default)"}`);
+  console.log(`  base url:   ${config.baseUrl}`);
+  console.log(`  api key:    ${keyPreview}`);
+  console.log(
+    `  key source: ${flags.apiKey ? "cli flag" : process.env.MINDSTUDIO_API_KEY ? "env var" : "config file"}`
+  );
+  console.log("\u2500".repeat(40));
+  console.log("");
+}
+var logLevel = flags.logLevel || void 0;
+if (headless) {
+  initLoggerHeadless(logLevel);
+  const { startHeadless: startHeadless2 } = await Promise.resolve().then(() => (init_headless(), headless_exports));
+  startHeadless2({
+    apiKey: flags.apiKey,
+    baseUrl: flags.baseUrl,
+    model: flags.model,
+    lspUrl: flags.lspUrl
+  }).catch((err) => {
+    console.error(err.message);
+    process.exit(1);
+  });
+} else {
+  initLoggerInteractive(logLevel);
+  try {
+    const config = resolveConfig({
+      apiKey: flags.apiKey,
+      baseUrl: flags.baseUrl
+    });
+    printDebugInfo(config);
+    const { waitUntilExit } = render(
+      /* @__PURE__ */ jsx6(
+        App,
+        {
+          apiConfig: { baseUrl: config.baseUrl, apiKey: config.apiKey },
+          model: flags.model
+        }
+      ),
+      { exitOnCtrlC: true }
+    );
+    await waitUntilExit();
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+}