@mindstudio-ai/remy 0.1.0

package/dist/headless.js

@@ -0,0 +1,2515 @@
+// src/headless.ts
+import { createInterface } from "readline";
+import fs14 from "fs";
+import path7 from "path";
+
+// src/config.ts
+import fs2 from "fs";
+import path from "path";
+import os from "os";
+
+// src/logger.ts
+import fs from "fs";
+var LEVELS = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+var currentLevel = LEVELS.error;
+var writeFn = () => {
+};
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var MAX_VALUE_LENGTH = 200;
+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(" "));
+}
+var 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/config.ts
+var CONFIG_PATH = path.join(
+  os.homedir(),
+  ".mindstudio-local-tunnel",
+  "config.json"
+);
+var DEFAULT_BASE_URL = "https://api.mindstudio.ai";
+function loadConfigFile() {
+  try {
+    const raw = fs2.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(flags) {
+  const file = loadConfigFile();
+  const activeEnv = file.environment || "prod";
+  const env = file.environments?.[activeEnv];
+  const apiKey = flags?.apiKey || process.env.MINDSTUDIO_API_KEY || env?.apiKey || "";
+  const baseUrl = flags?.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 = flags?.apiKey ? "cli flag" : process.env.MINDSTUDIO_API_KEY ? "env var" : "config file";
+  log.info("Config resolved", {
+    baseUrl,
+    keySource,
+    environment: activeEnv
+  });
+  return { apiKey, baseUrl };
+}
+
+// src/prompt/index.ts
+import fs4 from "fs";
+import path3 from "path";
+
+// src/tools/_helpers/lsp.ts
+var lspBaseUrl = null;
+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}`);
+  }
+}
+
+// src/prompt/static/projectContext.ts
+import fs3 from "fs";
+import path2 from "path";
+var 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"
+];
+function loadProjectInstructions() {
+  for (const file of AGENT_INSTRUCTION_FILES) {
+    try {
+      const content = fs3.readFileSync(file, "utf-8").trim();
+      if (content) {
+        return `
+## Project Instructions (${file})
+${content}`;
+      }
+    } catch {
+    }
+  }
+  return "";
+}
+function loadProjectManifest() {
+  try {
+    const manifest = fs3.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 = fs3.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path2.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 = fs3.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 = fs3.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 "";
+  }
+}
+
+// src/prompt/index.ts
+var PROMPT_DIR = import.meta.dirname ?? path3.dirname(new URL(import.meta.url).pathname);
+function requireFile(filePath) {
+  const full = path3.join(PROMPT_DIR, filePath);
+  try {
+    return fs4.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);
+}
+
+// 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 {
+    }
+  }
+}
+
+// src/tools/spec/readSpec.ts
+import fs5 from "fs/promises";
+
+// src/tools/spec/_helpers.ts
+var HEADING_RE = /^(#{1,6})\s+(.+)$/;
+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");
+}
+
+// src/tools/spec/readSpec.ts
+var DEFAULT_MAX_LINES = 500;
+var 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 fs5.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/spec/writeSpec.ts
+import fs6 from "fs/promises";
+import path4 from "path";
+
+// src/tools/_helpers/diff.ts
+var CONTEXT_LINES = 3;
+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");
+}
+
+// src/tools/spec/writeSpec.ts
+var 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 fs6.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 fs6.mkdir(path4.dirname(input.path), { recursive: true });
+      let oldContent = null;
+      try {
+        oldContent = await fs6.readFile(input.path, "utf-8");
+      } catch {
+      }
+      await fs6.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 fs7 from "fs/promises";
+var 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 fs7.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 fs7.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 fs8 from "fs/promises";
+import path5 from "path";
+var 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}`;
+    }
+  }
+};
+async function listRecursive(dir) {
+  const results = [];
+  const entries = await fs8.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 = path5.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(`${fullPath}/`);
+      results.push(...await listRecursive(fullPath));
+    } else {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+// src/tools/spec/setViewMode.ts
+var 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 = {
+  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 = {
+  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 = {
+  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 = {
+  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 = {
+  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 fs9 from "fs/promises";
+var DEFAULT_MAX_LINES2 = 500;
+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 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 fs9.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 fs10 from "fs/promises";
+import path6 from "path";
+var 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 fs10.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 fs10.mkdir(path6.dirname(input.path), { recursive: true });
+      let oldContent = null;
+      try {
+        oldContent = await fs10.readFile(input.path, "utf-8");
+      } catch {
+      }
+      await fs10.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/index.ts
+import fs11 from "fs/promises";
+
+// 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.`;
+}
+
+// src/tools/code/editFile/index.ts
+var 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 fs11.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 fs11.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 fs11.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 fs11.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 = 12e4;
+var DEFAULT_MAX_LINES3 = 500;
+var 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";
+var DEFAULT_MAX = 50;
+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 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 = 200;
+var 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 fs12 from "fs/promises";
+var 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 fs12.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 = {
+  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/code/lspDiagnostics.ts
+var 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 = {
+  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);
+}
+
+// src/session.ts
+import fs13 from "fs";
+var SESSION_FILE = ".remy-session.json";
+function loadSession(state) {
+  try {
+    const raw = fs13.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 {
+    fs13.writeFileSync(
+      SESSION_FILE,
+      JSON.stringify({ messages: state.messages }, null, 2),
+      "utf-8"
+    );
+  } catch {
+  }
+}
+function clearSession(state) {
+  state.messages = [];
+  try {
+    fs13.unlinkSync(SESSION_FILE);
+  } catch {
+  }
+}
+
+// src/parsePartialJson.ts
+var PartialJSON = class extends Error {
+};
+var MalformedJSON = class extends Error {
+};
+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();
+}
+
+// src/agent.ts
+var EXTERNAL_TOOLS = /* @__PURE__ */ new Set([
+  "promptUser",
+  "setViewMode",
+  "clearSyncStatus",
+  "presentSyncPlan",
+  "presentPublishPlan",
+  "presentPlan"
+]);
+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;
+    }
+  }
+}
+
+// src/headless.ts
+var BASE_DIR = import.meta.dirname ?? path7.dirname(new URL(import.meta.url).pathname);
+var ACTIONS_DIR = path7.join(BASE_DIR, "actions");
+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 = (...args) => {
+    process.stderr.write(args.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");
+}
+export {
+  startHeadless
+};