@mir-code/specs-platform 1.0.1

package/dist/chunk-SOOETS3N.js

@@ -0,0 +1,3490 @@
+#!/usr/bin/env node
+
+// ../../internal/toolkit-core/src/log.ts
+import pc from "picocolors";
+var log = {
+  title: (msg) => console.log(pc.bold(pc.cyan(msg))),
+  step: (msg) => console.log(`${pc.cyan("\u2192")} ${msg}`),
+  added: (msg) => console.log(pc.green(`  + ${msg}`)),
+  kept: (msg) => console.log(pc.dim(`  \xB7 ${msg}`)),
+  removed: (msg) => console.log(pc.yellow(`  - ${msg}`)),
+  warn: (msg) => console.log(pc.yellow(`  ! ${msg}`)),
+  success: (msg) => console.log(pc.bold(pc.green(`\u2713 ${msg}`))),
+  error: (msg) => console.error(pc.red(`\u2717 ${msg}`)),
+  blank: () => console.log("")
+};
+
+// ../../internal/toolkit-core/src/tool.ts
+function defineTool(tool) {
+  return tool;
+}
+
+// ../../internal/toolkit-core/src/fs.ts
+import { constants } from "fs";
+import {
+  access,
+  cp,
+  lstat,
+  mkdir,
+  readFile,
+  readlink,
+  rm,
+  symlink,
+  writeFile
+} from "fs/promises";
+import path from "path";
+async function exists(p2) {
+  try {
+    await access(p2, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyReplacing(src, dest) {
+  await mkdir(path.dirname(dest), { recursive: true });
+  await rm(dest, { recursive: true, force: true });
+  await cp(src, dest, { recursive: true });
+}
+async function copyIfAbsent(src, dest, force = false) {
+  if (!force && await exists(dest)) return false;
+  await copyReplacing(src, dest);
+  return true;
+}
+async function ensureSymlink(target, linkPath) {
+  await mkdir(path.dirname(linkPath), { recursive: true });
+  let result = "created";
+  try {
+    const stat3 = await lstat(linkPath);
+    if (stat3.isSymbolicLink()) {
+      if (await readlink(linkPath) === target) return "unchanged";
+      await rm(linkPath);
+    } else {
+      const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\D/g, "").slice(0, 14);
+      await cp(linkPath, `${linkPath}.bak-${stamp}`, { recursive: true });
+      await rm(linkPath, { recursive: true, force: true });
+      result = "backed-up";
+    }
+  } catch {
+  }
+  await symlink(target, linkPath);
+  return result;
+}
+async function ensureGitignore(projectRoot, header, entries) {
+  const file = path.join(projectRoot, ".gitignore");
+  const current = await exists(file) ? await readFile(file, "utf8") : "";
+  const lines = new Set(current.split(/\r?\n/).map((l) => l.trim().replace(/\/$/, "")));
+  const missing = entries.filter((e) => !lines.has(e.replace(/\/$/, "")));
+  if (missing.length === 0) return [];
+  const prefix = current === "" || current.endsWith("\n\n") ? "" : current.endsWith("\n") ? "\n" : "\n\n";
+  await writeFile(file, `${current}${prefix}# ${header}
+${missing.join("\n")}
+`, "utf8");
+  return missing;
+}
+
+// ../../internal/toolkit-core/src/package-root.ts
+import { existsSync } from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function findPackageRoot(importMetaUrl) {
+  let dir = path2.dirname(fileURLToPath(importMetaUrl));
+  for (; ; ) {
+    if (existsSync(path2.join(dir, "package.json"))) return dir;
+    const parent = path2.dirname(dir);
+    if (parent === dir) throw new Error(`package.json n\xE3o encontrado a partir de ${importMetaUrl}`);
+    dir = parent;
+  }
+}
+
+// src/commands/install.ts
+import { spawn } from "child_process";
+import { readFile as readFile2, readdir, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
+
+// src/paths.ts
+import path3 from "path";
+var packageRoot = findPackageRoot(import.meta.url);
+var templateDir = path3.join(packageRoot, "assets", "template");
+var uiDir = path3.join(packageRoot, "dist", "ui");
+var cliEntry = path3.join(packageRoot, "dist", "cli.js");
+var statuslineScript = path3.join(packageRoot, "assets", "specs-usage-statusline.sh");
+function runDir(projectRoot) {
+  return path3.join(projectRoot, ".specs", ".run");
+}
+
+// src/commands/install.ts
+async function runInstall(opts) {
+  const { projectRoot, force = false } = opts;
+  const src = (...p2) => path4.join(templateDir, ...p2);
+  const dest = (...p2) => path4.join(projectRoot, ...p2);
+  const fresh = !await exists(dest(".specs", "specs", "meta.json"));
+  log.title(`specs install \u2014 ${projectRoot}`);
+  log.kept(
+    fresh ? "modo: instala\xE7\xE3o" : force ? "modo: for\xE7a (sobrescreve customiza\xE7\xF5es)" : "modo: atualiza\xE7\xE3o"
+  );
+  log.blank();
+  log.step("Agentes e skills (.agents/)");
+  for (const kind of ["agents", "skills", "scripts"]) {
+    for (const entry of await readdir(src(".agents", kind))) {
+      await copyReplacing(src(".agents", kind, entry), dest(".agents", kind, entry));
+      log.added(`.agents/${kind}/${entry}`);
+    }
+  }
+  for (const file of ["README.md", "RUNTIME.md"]) {
+    await copyReplacing(src(".agents", file), dest(".agents", file));
+    log.added(`.agents/${file}`);
+  }
+  await installCustomizable(
+    src(".agents", "project.md"),
+    dest(".agents", "project.md"),
+    ".agents/project.md",
+    force
+  );
+  for (const legacy of [
+    dest(".agents", "agents", "specs-runner.md"),
+    dest(".claude", "agents", "specs-runner.md")
+  ]) {
+    if (await exists(legacy)) {
+      await rm2(legacy);
+      log.removed(`${path4.relative(projectRoot, legacy)} (descontinuado)`);
+    }
+  }
+  for (const consumer of [".claude", ".cursor"]) {
+    for (const kind of ["agents", "skills"]) {
+      const result = await ensureSymlink(`../.agents/${kind}`, dest(consumer, kind));
+      const label = `${consumer}/${kind} \u2192 .agents/${kind}`;
+      if (result === "backed-up") log.warn(`${label} (diret\xF3rio real movido para ${kind}.bak-*)`);
+      else if (result === "created") log.added(label);
+      else log.kept(label);
+    }
+  }
+  log.blank();
+  log.step("Scaffold (.specs/)");
+  const configPath = dest(".specs", "config.json");
+  if (await copyIfAbsent(src(".specs", "config.json"), configPath, force)) {
+    const terminal = await detectDefaultTerminal();
+    await setOpenTerminal(configPath, terminal);
+    log.added(`.specs/config.json (openTerminal: ${terminal})`);
+  } else {
+    log.kept(".specs/config.json (preservado)");
+  }
+  for (const dir of ["specs", "discoveries", "drawings"]) {
+    await installCustomizable(
+      src(".specs", dir, "meta.json"),
+      dest(".specs", dir, "meta.json"),
+      `.specs/${dir}/meta.json`,
+      force
+    );
+  }
+  for (const tpl of await readdir(src(".specs", "specs", "_templates"))) {
+    await installCustomizable(
+      src(".specs", "specs", "_templates", tpl),
+      dest(".specs", "specs", "_templates", tpl),
+      `.specs/specs/_templates/${tpl}`,
+      force
+    );
+  }
+  if (fresh || force) {
+    await copyReplacing(src(".specs", "specs", "exemplo"), dest(".specs", "specs", "exemplo"));
+    log.added(".specs/specs/exemplo/ (feature exemplo)");
+  }
+  await installCustomizable(src("SPECS.md"), dest("SPECS.md"), "SPECS.md", force);
+  if (!force && (await readFile2(dest("SPECS.md"), "utf8")).includes("install-here.sh")) {
+    log.warn(
+      "SPECS.md \xE9 da vers\xE3o antiga (fala de .specs/app/ e specs:run). Apague-o e rode de novo para regenerar."
+    );
+  }
+  log.blank();
+  log.step(".gitignore");
+  const added = await ensureGitignore(
+    projectRoot,
+    "Specs Platform \u2014 estado local da m\xE1quina, n\xE3o do projeto",
+    [".specs/.jobs.json", ".specs/.run/"]
+  );
+  if (added.length > 0) log.added(`.gitignore (${added.join(", ")})`);
+  else log.kept(".gitignore j\xE1 cobre o estado local");
+  const legacyAppDir = await exists(dest(".specs", "app"));
+  if (legacyAppDir) {
+    log.blank();
+    if (opts.cleanLegacy) {
+      await rm2(dest(".specs", "app"), { recursive: true, force: true });
+      log.removed(".specs/app/ (runtime antigo \u2014 agora a plataforma roda do pacote npm)");
+    } else {
+      log.warn(
+        ".specs/app/ \xE9 de uma instala\xE7\xE3o antiga e n\xE3o \xE9 mais usado. Remova com `specs install --clean-legacy`."
+      );
+    }
+  }
+  log.blank();
+  log.success(`Specs Platform ${fresh ? "instalada" : "atualizada"} em ${projectRoot}`);
+  console.log("  Pr\xF3ximo passo: preencha .agents/project.md e rode `specs start`.");
+  return { fresh, legacyAppDir };
+}
+async function installCustomizable(src, dest, label, force) {
+  if (await copyIfAbsent(src, dest, force)) log.added(label);
+  else log.kept(`${label} (preservado)`);
+}
+async function setOpenTerminal(configPath, terminal) {
+  const config = JSON.parse(await readFile2(configPath, "utf8"));
+  if (config.agent && typeof config.agent === "object") config.agent.openTerminal = terminal;
+  await writeFile2(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+async function detectDefaultTerminal() {
+  if (process.platform === "darwin") return "osascript";
+  if (process.platform !== "linux") return "none";
+  const which = (bin) => new Promise((resolve) => {
+    const child = spawn("which", [bin], { stdio: "ignore" });
+    child.on("exit", (code) => resolve(code === 0));
+    child.on("error", () => resolve(false));
+  });
+  if (process.env.KITTY_WINDOW_ID || await which("kitty")) return "kitty";
+  if (process.env.WEZTERM_PANE || await which("wezterm")) return "wezterm";
+  if (await which("gnome-terminal")) return "gnome-terminal";
+  return "none";
+}
+
+// src/commands/start.ts
+import { spawn as spawn5 } from "child_process";
+import { openSync } from "fs";
+import { mkdir as mkdir3, readFile as readFile9, rm as rm4, writeFile as writeFile4 } from "fs/promises";
+import net from "net";
+import path15 from "path";
+
+// ../../internal/specs-server/src/start-server.ts
+import path14 from "path";
+import { readFile as readFile8, rm as rm3, unlink } from "fs/promises";
+import Fastify from "fastify";
+import fastifyCors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import { z as z2 } from "zod";
+
+// ../../internal/specs-server/src/config-defaults.ts
+var DEFAULT_INPUT_PROMPT_PATTERNS = [
+  "\\?\\s*$",
+  "\\((?:y\\/n|Y\\/n|y\\/N|Y\\/N)\\)",
+  "press\\s+(?:enter|any key)",
+  "Do you want to",
+  "Would you like to",
+  "waiting for input",
+  "\u276F\\s*$"
+];
+var DEFAULT_REVIEW_OPEN_COMMAND = "cursor --goto {path}:{line}";
+var DEFAULT_CLAUDE_COMMAND = 'claude {model} {effort} --agent feature-runner "{prompt}"';
+var DEFAULT_CURSOR_COMMAND = 'cursor-agent {model} "Use the feature-runner subagent. {prompt}"';
+var DEFAULT_MODELS_COMMAND = {
+  cursor: "cursor-agent --list-models"
+};
+var DEFAULT_STATIC_MODELS = {
+  claude: ["opus", "sonnet", "haiku", "fable"]
+};
+var DEFAULT_PROTOTYPE_OPEN_COMMAND = {
+  pencil: "open -a Pencil {file}",
+  "claude-design": "open {url}"
+};
+function normalizePrototype(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const p2 = raw;
+  if (p2.tool !== "claude-design" && p2.tool !== "pencil") return null;
+  if (p2.tool === "claude-design" && !p2.url) return null;
+  if (p2.tool === "pencil" && !p2.file) return null;
+  return {
+    tool: p2.tool,
+    ...p2.title ? { title: p2.title } : {},
+    ...p2.url ? { url: p2.url } : {},
+    ...p2.file ? { file: p2.file } : {},
+    ...p2.designDir ? { designDir: p2.designDir } : {},
+    ...Array.isArray(p2.artboards) ? { artboards: p2.artboards.map(String) } : {},
+    ...Array.isArray(p2.nodeIds) ? { nodeIds: p2.nodeIds.map(String) } : {},
+    ...p2.openCommand ? { openCommand: p2.openCommand } : {},
+    ...p2.snapshot ? { snapshot: p2.snapshot } : {}
+  };
+}
+function applyDefaults(partial) {
+  const agent = partial.agent ?? {};
+  const scopes = agent.scopes ?? {};
+  const userCommands = agent.commands ?? {};
+  const commands = {
+    claude: userCommands.claude ?? agent.command ?? DEFAULT_CLAUDE_COMMAND,
+    cursor: userCommands.cursor ?? DEFAULT_CURSOR_COMMAND,
+    ...userCommands
+  };
+  const cli = agent.cli && commands[agent.cli] ? agent.cli : "claude";
+  const modelsCommand = {
+    ...DEFAULT_MODELS_COMMAND,
+    ...agent.modelsCommand ?? {}
+  };
+  const models = {
+    ...DEFAULT_STATIC_MODELS,
+    ...agent.models ?? {}
+  };
+  return {
+    agent: {
+      cli,
+      commands,
+      modelsCommand,
+      models,
+      command: agent.command ?? commands[cli] ?? DEFAULT_CLAUDE_COMMAND,
+      openTerminal: agent.openTerminal ?? (process.platform === "darwin" ? "osascript" : "none"),
+      cwd: agent.cwd ?? ".",
+      scopes: {
+        feature: scopes.feature ?? 'Execute a feature "{featureTitle}" ({featurePath}). Se houver task em progresso, continue de onde parou; sen\xE3o, escolha a pr\xF3xima task em pages[] do meta.json.',
+        featureNoPause: scopes.featureNoPause ?? 'Execute a feature "{featureTitle}" ({featurePath}) por inteiro, sem pausar entre tasks. Continue executando cada pr\xF3xima task pendente do meta.json automaticamente at\xE9 completar todas. Os testes E2E e a solicita\xE7\xE3o de code review devem ser feitos apenas ao final de todas as tasks.',
+        task: scopes.task ?? "Execute a task {featurePath}{task}.md. Se j\xE1 houver trabalho em progresso nela, continue de onde parou."
+      },
+      defaultExecutionMode: agent.defaultExecutionMode ?? "inline",
+      sound: agent.sound ?? true,
+      inputPromptPatterns: agent.inputPromptPatterns && agent.inputPromptPatterns.length > 0 ? agent.inputPromptPatterns : DEFAULT_INPUT_PROMPT_PATTERNS,
+      bufferBytesCap: agent.bufferBytesCap ?? 2e6
+    },
+    prototype: normalizePrototype(partial.prototype),
+    review: {
+      openCommand: partial.review?.openCommand ?? DEFAULT_REVIEW_OPEN_COMMAND
+    },
+    theme: "dark",
+    warnBelowWidth: partial.warnBelowWidth ?? 1024,
+    featuresDir: partial.featuresDir ?? ".specs/specs",
+    discoveriesDir: partial.discoveriesDir ?? ".specs/discoveries",
+    drawingsDir: partial.drawingsDir ?? ".specs/drawings",
+    port: partial.port ?? 4321
+  };
+}
+
+// ../../internal/specs-server/src/claude-usage.ts
+import { readFile as readFile3, stat } from "fs/promises";
+import os from "os";
+import path5 from "path";
+var HOUR_MS = 36e5;
+var FIVE_HOURS_MS = 5 * HOUR_MS;
+var SEVEN_DAYS_MS = 7 * 24 * HOUR_MS;
+function desktopHistoryPath(home = os.homedir()) {
+  return path5.join(home, "Library", "Application Support", "Claude", "plan-usage-history.json");
+}
+function cliCachePath(home = os.homedir()) {
+  return path5.join(home, ".claude", "rate-limits-cache.json");
+}
+function statuslineSnapshotPath(home = os.homedir()) {
+  return path5.join(home, ".claude", "specs-usage.json");
+}
+function parseSamples(raw) {
+  if (typeof raw !== "object" || raw === null) return [];
+  const list = raw.samples;
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const item of list) {
+    if (typeof item !== "object" || item === null) continue;
+    const { t, u } = item;
+    if (typeof t !== "number" || !Number.isFinite(t)) continue;
+    if (typeof u !== "object" || u === null) continue;
+    const { fh, sd } = u;
+    if (typeof fh !== "number" || typeof sd !== "number") continue;
+    out.push({ t, fh, sd });
+  }
+  return out.sort((a, b) => a.t - b.t);
+}
+function dropIntervals(samples, key) {
+  const out = [];
+  for (let i = 1; i < samples.length; i += 1) {
+    const prev = samples[i - 1];
+    const cur = samples[i];
+    if (!prev || !cur) continue;
+    if (cur[key] < prev[key]) out.push({ from: prev.t, to: cur.t });
+  }
+  return out;
+}
+function hourBoundariesIn(from, to) {
+  const out = [];
+  let h = Math.floor(from / HOUR_MS) * HOUR_MS + HOUR_MS;
+  while (h <= to) {
+    out.push(h);
+    h += HOUR_MS;
+  }
+  return out;
+}
+function inferSessionReset(samples, now) {
+  const drops = dropIntervals(samples, "fh");
+  const last = drops[drops.length - 1];
+  if (!last) return null;
+  if (last.to - last.from > HOUR_MS) return null;
+  const boundaries = hourBoundariesIn(last.from, last.to);
+  const anchor = boundaries.length === 1 ? boundaries[0] : void 0;
+  if (anchor === void 0) return null;
+  const reset = anchor + FIVE_HOURS_MS;
+  return reset > now ? reset : null;
+}
+function inferPeriodicReset(samples, key, periodMs, now) {
+  const drops = dropIntervals(samples, key);
+  const lastDrop = drops[drops.length - 1];
+  if (!lastDrop) return null;
+  const base = Math.floor(lastDrop.to / HOUR_MS) * HOUR_MS;
+  const slots = Math.round(periodMs / HOUR_MS);
+  let best = null;
+  let bestScore = -1;
+  for (let h = 0; h < slots; h += 1) {
+    const candidate = base - h * HOUR_MS;
+    let score = 0;
+    for (const drop of drops) {
+      const k = Math.floor((drop.to - candidate) / periodMs);
+      const instant = candidate + k * periodMs;
+      if (instant > drop.from && instant <= drop.to) {
+        score += HOUR_MS / Math.max(drop.to - drop.from, HOUR_MS);
+      }
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      best = candidate;
+    }
+  }
+  if (best === null || bestScore <= 0) return null;
+  let reset = best;
+  while (reset <= now) reset += periodMs;
+  return reset;
+}
+function windowFrom(percentage, resetMs, estimated) {
+  return {
+    usedPercentage: Math.max(0, Math.min(100, percentage)),
+    resetsAt: resetMs === null ? null : Math.round(resetMs / 1e3),
+    resetEstimated: estimated
+  };
+}
+async function readDesktopHistory(home, now) {
+  try {
+    const samples = parseSamples(JSON.parse(await readFile3(desktopHistoryPath(home), "utf8")));
+    const latest = samples[samples.length - 1];
+    if (!latest) return null;
+    return {
+      fiveHour: windowFrom(latest.fh, inferSessionReset(samples, now), true),
+      sevenDay: windowFrom(latest.sd, inferPeriodicReset(samples, "sd", SEVEN_DAYS_MS, now), true),
+      measuredAt: latest.t,
+      source: "desktop-history"
+    };
+  } catch {
+    return null;
+  }
+}
+function parseCliWindow(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const { used_percentage: used, resets_at: resets } = raw;
+  if (typeof used !== "number" || !Number.isFinite(used)) return null;
+  const resetsAt = typeof resets === "number" && Number.isFinite(resets) ? resets * 1e3 : null;
+  return windowFrom(used, resetsAt, false);
+}
+async function readStatuslineSnapshot(home) {
+  try {
+    const parsed = JSON.parse(await readFile3(statuslineSnapshotPath(home), "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const record = parsed;
+    const fiveHour = parseCliWindow(record.five_hour);
+    const sevenDay = parseCliWindow(record.seven_day);
+    if (!fiveHour && !sevenDay) return null;
+    const measuredAt = typeof record.measuredAt === "number" && Number.isFinite(record.measuredAt) ? record.measuredAt : 0;
+    if (measuredAt <= 0) return null;
+    return { fiveHour, sevenDay, measuredAt, source: "statusline" };
+  } catch {
+    return null;
+  }
+}
+async function readCliCache(home) {
+  const file = cliCachePath(home);
+  try {
+    const [raw, info] = await Promise.all([readFile3(file, "utf8"), stat(file)]);
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const record = parsed;
+    const fiveHour = parseCliWindow(record.five_hour);
+    const sevenDay = parseCliWindow(record.seven_day);
+    if (!fiveHour && !sevenDay) return null;
+    return { fiveHour, sevenDay, measuredAt: info.mtimeMs, source: "cli-cache" };
+  } catch {
+    return null;
+  }
+}
+async function readClaudeUsage(home = os.homedir(), now = Date.now()) {
+  const candidates = await Promise.all([
+    readDesktopHistory(home, now),
+    readCliCache(home),
+    readStatuslineSnapshot(home)
+  ]);
+  let best = null;
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    if (!best || candidate.measuredAt > best.measuredAt) best = candidate;
+  }
+  return best;
+}
+
+// ../../internal/specs-server/src/specs-watcher.ts
+import { watch } from "fs";
+import path6 from "path";
+function segments(relPath) {
+  return relPath.split(path6.sep).filter((s) => s.length > 0 && s !== ".");
+}
+function isUnder(relPath, dir) {
+  const base = segments(dir);
+  const parts = segments(relPath);
+  if (parts.length <= base.length) return null;
+  for (let i = 0; i < base.length; i += 1) {
+    if (parts[i] !== base[i]) return null;
+  }
+  return parts.slice(base.length).join("/");
+}
+function classifyPath(relPath, dirs) {
+  const normalized = relPath.split(path6.sep).join("/");
+  const name = normalized.split("/").pop() ?? "";
+  if (name.startsWith(".") || name.endsWith("~")) return [];
+  if (normalized === ".specs/config.json") return [{ type: "config" }];
+  const inFeatures = isUnder(relPath, dirs.featuresDir);
+  if (inFeatures !== null) {
+    const parts = inFeatures.split("/");
+    if (parts.length === 1 && parts[0] === "meta.json") return [{ type: "tree" }];
+    const [feature, file] = parts;
+    if (!feature || !file || parts.length !== 2) return [{ type: "tree" }];
+    if (file === "meta.json") return [{ type: "tree" }];
+    if (file.endsWith(".md")) {
+      const task = file.slice(0, -3);
+      return [{ type: "content", feature, task }, { type: "tree" }];
+    }
+    return [];
+  }
+  const inDiscoveries = isUnder(relPath, dirs.discoveriesDir);
+  if (inDiscoveries !== null) {
+    const parts = inDiscoveries.split("/");
+    if (parts.length !== 1) return [];
+    const file = parts[0] ?? "";
+    if (file === "meta.json") return [{ type: "tree" }];
+    if (file.endsWith(".md")) {
+      return [{ type: "discovery", slug: file.slice(0, -3) }, { type: "tree" }];
+    }
+    return [];
+  }
+  const inDrawings = isUnder(relPath, dirs.drawingsDir);
+  if (inDrawings !== null) {
+    const parts = inDrawings.split("/");
+    if (parts.length !== 1) return [];
+    const file = parts[0] ?? "";
+    if (file === "meta.json") return [{ type: "tree" }];
+    if (file.endsWith(".md")) {
+      return [{ type: "drawing", slug: file.slice(0, -3) }, { type: "tree" }];
+    }
+    return [];
+  }
+  return [];
+}
+function eventKey(event) {
+  switch (event.type) {
+    case "content":
+      return `content:${event.feature}/${event.task}`;
+    case "discovery":
+      return `discovery:${event.slug}`;
+    case "drawing":
+      return `drawing:${event.slug}`;
+    default:
+      return event.type;
+  }
+}
+var REARM_RETRY_MS = 5e3;
+function watchFileRearming(file, onChange) {
+  let current = null;
+  let retry = null;
+  let stopped = false;
+  function scheduleRetry() {
+    if (stopped || retry) return;
+    retry = setTimeout(() => {
+      retry = null;
+      arm();
+    }, REARM_RETRY_MS);
+    retry.unref?.();
+  }
+  function arm() {
+    if (stopped) return;
+    try {
+      current = watch(file, { persistent: false }, () => {
+        onChange();
+        try {
+          current?.close();
+        } catch {
+        }
+        current = null;
+        arm();
+      });
+    } catch {
+      current = null;
+      scheduleRetry();
+    }
+  }
+  arm();
+  return () => {
+    stopped = true;
+    if (retry) clearTimeout(retry);
+    try {
+      current?.close();
+    } catch {
+    }
+    current = null;
+  };
+}
+function createSpecsWatcher(opts) {
+  const {
+    projectRoot,
+    featuresDir,
+    discoveriesDir,
+    drawingsDir,
+    extraFiles = [],
+    debounceMs = 150
+  } = opts;
+  const listeners = /* @__PURE__ */ new Set();
+  const watchers = [];
+  const fileWatchers = [];
+  const pending = /* @__PURE__ */ new Map();
+  let timer = null;
+  let watching = false;
+  function flush() {
+    timer = null;
+    if (pending.size === 0) return;
+    const batch = [...pending.values()];
+    pending.clear();
+    for (const listener of listeners) listener(batch);
+  }
+  function queue(events) {
+    if (events.length === 0) return;
+    for (const event of events) pending.set(eventKey(event), event);
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(flush, debounceMs);
+  }
+  const specsRoot = path6.join(projectRoot, ".specs");
+  try {
+    watchers.push(
+      watch(specsRoot, { recursive: true, persistent: false }, (_event, filename) => {
+        if (!filename) return;
+        const rel = path6.join(".specs", filename.toString());
+        queue(classifyPath(rel, { featuresDir, discoveriesDir, drawingsDir }));
+      })
+    );
+    watching = true;
+  } catch {
+    watching = false;
+  }
+  for (const { file, event } of extraFiles) {
+    fileWatchers.push(watchFileRearming(file, () => queue([event])));
+  }
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    get watching() {
+      return watching;
+    },
+    close() {
+      if (timer) clearTimeout(timer);
+      for (const w of watchers) {
+        try {
+          w.close();
+        } catch {
+        }
+      }
+      for (const stop of fileWatchers) stop();
+      listeners.clear();
+    }
+  };
+}
+
+// ../../internal/specs-server/src/fs-utils.ts
+import { constants as constants2 } from "fs";
+import { access as access2, readFile as readFile4, rename, stat as stat2, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+import path7 from "path";
+var SLUG_REGEX = /^[a-z0-9][a-z0-9-]*$/;
+function assertInsideProject(absPath, projectRoot) {
+  const rel = path7.relative(projectRoot, absPath);
+  if (rel.startsWith("..") || path7.isAbsolute(rel)) {
+    throw new Error(`Path ${absPath} fora do projectRoot ${projectRoot}.`);
+  }
+}
+async function fileExists(p2) {
+  try {
+    await access2(p2, constants2.F_OK);
+    const s = await stat2(p2);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+async function dirExists(p2) {
+  try {
+    const s = await stat2(p2);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function readText(p2) {
+  return readFile4(p2, "utf8");
+}
+function detectEOL(content) {
+  const sample = content.length > 4096 ? content.slice(0, 4096) : content;
+  return sample.includes("\r\n") ? "\r\n" : "\n";
+}
+async function atomicWrite(finalPath, content) {
+  const dir = path7.dirname(finalPath);
+  await mkdir2(dir, { recursive: true });
+  const tmp = `${finalPath}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile3(tmp, content, "utf8");
+  await rename(tmp, finalPath);
+}
+
+// ../../internal/specs-server/src/tree-builder.ts
+import path8 from "path";
+import { readFile as readFile5 } from "fs/promises";
+
+// ../../internal/specs-server/src/frontmatter.ts
+import matter from "gray-matter";
+var VALID_STATUS = ["pending", "in-progress", "completed", "blocked"];
+function isValidStatus(s) {
+  return typeof s === "string" && VALID_STATUS.includes(s);
+}
+var VALID_DISCOVERY_TYPE = ["rfc", "spike", "adr", "note"];
+function isValidDiscoveryType(s) {
+  return typeof s === "string" && VALID_DISCOVERY_TYPE.includes(s);
+}
+var VALID_DRAWING_TYPE = [
+  "architecture",
+  "flow",
+  "sequence",
+  "data",
+  "state"
+];
+function isValidDrawingType(s) {
+  return typeof s === "string" && VALID_DRAWING_TYPE.includes(s);
+}
+function toIsoDate(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString().slice(0, 10);
+  }
+  return void 0;
+}
+function parseFrontmatter(raw) {
+  const parsed = matter(raw);
+  return { data: parsed.data, body: parsed.content };
+}
+function patchStatusInFrontmatter(raw, newStatus) {
+  const eol = detectEOL(raw);
+  const leading = raw.slice(0, 4);
+  if (!leading.startsWith("---")) return raw;
+  const startIdx = raw.indexOf(`---${eol}`);
+  if (startIdx !== 0) return raw;
+  const afterStart = raw.slice(3 + eol.length);
+  const endIdx = afterStart.indexOf(`${eol}---`);
+  if (endIdx < 0) return raw;
+  const yamlBlock = afterStart.slice(0, endIdx);
+  const rest = afterStart.slice(endIdx);
+  const statusLineRegex = /^status:[ \t]*.*$/m;
+  let newYaml;
+  if (statusLineRegex.test(yamlBlock)) {
+    newYaml = yamlBlock.replace(statusLineRegex, `status: ${newStatus}`);
+  } else {
+    const trimmedEnd = yamlBlock.endsWith(eol) ? yamlBlock : `${yamlBlock}${eol}`;
+    newYaml = `${trimmedEnd}status: ${newStatus}`;
+  }
+  return `---${eol}${newYaml}${rest}`;
+}
+function extractFrontmatterFields(data) {
+  const title = typeof data.title === "string" ? data.title : void 0;
+  const description = typeof data.description === "string" ? data.description : void 0;
+  const rawStatus = data.status;
+  const status = isValidStatus(rawStatus) ? rawStatus : "pending";
+  return { title, description, status };
+}
+function extractDiscoveryFrontmatterFields(data) {
+  const title = typeof data.title === "string" ? data.title : void 0;
+  const rawType = data.type;
+  const type = isValidDiscoveryType(rawType) ? rawType : "note";
+  const date = toIsoDate(data.date);
+  return { title, type, date };
+}
+function extractDrawingFrontmatterFields(data) {
+  const title = typeof data.title === "string" ? data.title : void 0;
+  const rawType = data.type;
+  const type = isValidDrawingType(rawType) ? rawType : "architecture";
+  const date = toIsoDate(data.date);
+  return { title, type, date };
+}
+
+// ../../internal/specs-server/src/tree-builder.ts
+function aggregateStatus(children) {
+  if (children.length === 0) return "pending";
+  if (children.some((s) => s === "blocked")) return "blocked";
+  if (children.every((s) => s === "completed")) return "completed";
+  if (children.some((s) => s === "in-progress" || s === "completed")) return "in-progress";
+  return "pending";
+}
+async function buildTree(projectRoot, featuresDir, discoveriesDir, drawingsDir) {
+  const featuresAbs = path8.join(projectRoot, featuresDir);
+  const rootMetaPath = path8.join(featuresAbs, "meta.json");
+  if (!await fileExists(rootMetaPath)) {
+    throw new Error("no_features_dir");
+  }
+  const rootRaw = await readFile5(rootMetaPath, "utf8");
+  const rootMeta = JSON.parse(rootRaw);
+  const rootPages = Array.isArray(rootMeta.pages) ? rootMeta.pages : [];
+  const features = [];
+  for (const slugUnknown of rootPages) {
+    if (typeof slugUnknown !== "string") continue;
+    const slug = slugUnknown;
+    const featureDir = path8.join(featuresAbs, slug);
+    const featureMetaPath = path8.join(featureDir, "meta.json");
+    if (!await dirExists(featureDir) || !await fileExists(featureMetaPath)) {
+      console.warn(
+        `[tree] feature "${slug}" listada em ${featuresDir}/meta.json mas sem pasta/meta \u2014 ignorando conte\xFAdo.`
+      );
+      features.push({
+        slug,
+        title: slug,
+        status: "pending",
+        tasks: []
+      });
+      continue;
+    }
+    let featureMeta;
+    try {
+      featureMeta = JSON.parse(await readText(featureMetaPath));
+    } catch (err) {
+      console.warn(`[tree] meta.json inv\xE1lido em ${featureMetaPath}: ${err.message}`);
+      featureMeta = {};
+    }
+    const title = typeof featureMeta.title === "string" ? featureMeta.title : slug;
+    const description = typeof featureMeta.description === "string" ? featureMeta.description : void 0;
+    const icon = typeof featureMeta.icon === "string" ? featureMeta.icon : void 0;
+    const pages = Array.isArray(featureMeta.pages) ? featureMeta.pages : [];
+    const tasks = [];
+    for (const pageUnknown of pages) {
+      if (typeof pageUnknown !== "string") continue;
+      const pageSlug = pageUnknown;
+      const taskFile = path8.join(featureDir, `${pageSlug}.md`);
+      if (!await fileExists(taskFile)) {
+        console.warn(
+          `[tree] task "${pageSlug}" listada em ${slug}/meta.json mas sem arquivo \u2014 omitindo.`
+        );
+        continue;
+      }
+      let raw;
+      try {
+        raw = await readText(taskFile);
+      } catch {
+        continue;
+      }
+      const parsed = parseFrontmatter(raw);
+      const {
+        title: taskTitle,
+        description: taskDescription,
+        status
+      } = extractFrontmatterFields(parsed.data);
+      tasks.push({
+        slug: pageSlug,
+        title: taskTitle ?? pageSlug,
+        description: taskDescription,
+        status,
+        file: path8.relative(projectRoot, taskFile)
+      });
+    }
+    features.push({
+      slug,
+      title,
+      description,
+      icon,
+      status: aggregateStatus(tasks.map((t) => t.status)),
+      tasks
+    });
+  }
+  const discoveries = await buildDiscoveries(projectRoot, discoveriesDir);
+  const drawings = await buildDrawings(projectRoot, drawingsDir);
+  return { features, discoveries, drawings };
+}
+async function buildFlatSection(projectRoot, dir, kind, toNode) {
+  const abs = path8.join(projectRoot, dir);
+  const metaPath = path8.join(abs, "meta.json");
+  if (!await dirExists(abs) || !await fileExists(metaPath)) {
+    return [];
+  }
+  let meta;
+  try {
+    meta = JSON.parse(await readText(metaPath));
+  } catch (err) {
+    console.warn(`[tree] meta.json inv\xE1lido em ${metaPath}: ${err.message}`);
+    return [];
+  }
+  const pages = Array.isArray(meta.pages) ? meta.pages : [];
+  const nodes = [];
+  for (const pageUnknown of pages) {
+    if (typeof pageUnknown !== "string") continue;
+    const pageSlug = pageUnknown;
+    const file = path8.join(abs, `${pageSlug}.md`);
+    if (!await fileExists(file)) {
+      console.warn(
+        `[tree] ${kind} "${pageSlug}" listada em ${dir}/meta.json mas sem arquivo \u2014 omitindo.`
+      );
+      continue;
+    }
+    let raw;
+    try {
+      raw = await readText(file);
+    } catch {
+      continue;
+    }
+    const parsed = parseFrontmatter(raw);
+    nodes.push(toNode(pageSlug, parsed.data, path8.relative(projectRoot, file)));
+  }
+  return nodes;
+}
+async function buildDiscoveries(projectRoot, discoveriesDir) {
+  return buildFlatSection(projectRoot, discoveriesDir, "discovery", (slug, data, file) => {
+    const { title, type, date } = extractDiscoveryFrontmatterFields(data);
+    return { slug, title: title ?? slug, type, date, file };
+  });
+}
+async function buildDrawings(projectRoot, drawingsDir) {
+  return buildFlatSection(projectRoot, drawingsDir, "desenho", (slug, data, file) => {
+    const { title, type, date } = extractDrawingFrontmatterFields(data);
+    return { slug, title: title ?? slug, type, date, file };
+  });
+}
+
+// ../../internal/specs-server/src/headings.ts
+import GithubSlugger from "github-slugger";
+function extractHeadings(body) {
+  const slugger = new GithubSlugger();
+  const lines = body.split(/\r?\n/);
+  const out = [];
+  let inFence = false;
+  for (const line of lines) {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    const match = /^(#{1,6})\s+(.+)$/.exec(line);
+    if (!match) continue;
+    const level = match[1].length;
+    const text2 = match[2].replace(/\s+#+\s*$/, "").trim();
+    const id = slugger.slug(text2);
+    out.push({ id, text: text2, level });
+  }
+  return out;
+}
+
+// ../../internal/specs-server/src/run-agent.ts
+import { spawn as spawn2 } from "child_process";
+import path9 from "path";
+import { readFile as readFile6 } from "fs/promises";
+function resolveCommand(config, cli) {
+  const key = cli && config.agent.commands?.[cli] ? cli : config.agent.cli;
+  return config.agent.commands?.[key] ?? config.agent.command;
+}
+function injectModel(template, model, quote) {
+  const flag = model ? `--model ${quote(model)}` : "";
+  if (template.includes("{model}")) return template.replaceAll("{model}", flag);
+  if (!flag) return template;
+  return template.replace(/^(\s*\S+)/, `$1 ${flag}`);
+}
+var EFFORT_MODE = {
+  claude: "flag",
+  cursor: "model-param"
+};
+function effortMode(cli) {
+  return EFFORT_MODE[cli ?? "claude"] ?? "flag";
+}
+function withEffortParam(model, effort) {
+  if (/\[.*effort=/.test(model)) return model;
+  const match = /^([^[]+)\[(.+)\]$/.exec(model);
+  if (match) return `${match[1]}[${match[2]},effort=${effort}]`;
+  return `${model}[effort=${effort}]`;
+}
+function injectEffort(template, effort, quote) {
+  const flag = effort ? `--effort ${quote(effort)}` : "";
+  if (template.includes("{effort}")) {
+    return flag ? template.replaceAll("{effort}", flag) : template.replace(/ ?\{effort\}/g, "");
+  }
+  if (!flag) return template;
+  return template.replace(/^(\s*\S+)/, `$1 ${flag}`);
+}
+function buildCommand(config, cli, model, effort, quote) {
+  const mode = effortMode(cli);
+  const effectiveModel = mode === "model-param" && model && effort ? withEffortParam(model, effort) : model;
+  const withModel = injectModel(resolveCommand(config, cli), effectiveModel, quote);
+  return mode === "flag" ? injectEffort(withModel, effort, quote) : withModel;
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", String.raw`'\''`)}'`;
+}
+async function readFeatureTitle(metaPath, fallback) {
+  try {
+    const raw = await readFile6(metaPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.title === "string" && parsed.title.trim().length > 0) {
+      return parsed.title.trim();
+    }
+  } catch {
+  }
+  return fallback;
+}
+function resolvePrompt(template, ctx) {
+  return template.replaceAll("{feature}", ctx.feature).replaceAll("{task}", ctx.task ?? "").replaceAll("{featureTitle}", ctx.featureTitle).replaceAll("{featurePath}", ctx.featurePath);
+}
+function buildTerminalCommand(terminal, cwd, shellCommand) {
+  switch (terminal) {
+    case "osascript": {
+      const quotedCwd = shellQuote(cwd);
+      const fullShell = `cd ${quotedCwd} && ${shellCommand}`;
+      const appleScript = [
+        'tell application "Terminal"',
+        "  activate",
+        `  do script ${JSON.stringify(fullShell)}`,
+        "end tell"
+      ].join("\n");
+      return { file: "osascript", args: ["-e", appleScript] };
+    }
+    case "gnome-terminal":
+      return {
+        file: "gnome-terminal",
+        args: ["--", "bash", "-c", `cd ${shellQuote(cwd)} && ${shellCommand}; exec bash`]
+      };
+    case "kitty":
+      return {
+        file: "kitty",
+        args: ["--hold", "bash", "-c", `cd ${shellQuote(cwd)} && ${shellCommand}`]
+      };
+    case "wezterm":
+      return {
+        file: "wezterm",
+        args: ["start", "--cwd", cwd, "--", "bash", "-c", shellCommand]
+      };
+    case "none":
+      return null;
+  }
+}
+function spawnInTerminal(config, projectRoot, shellCommand) {
+  const terminal = config.agent.openTerminal;
+  if (terminal === "none") {
+    return {
+      ok: false,
+      status: 501,
+      error: "terminal_disabled",
+      hint: "Ajuste agent.openTerminal no .specs/config.json"
+    };
+  }
+  const cwd = path9.resolve(projectRoot, config.agent.cwd ?? ".");
+  const termCmd = buildTerminalCommand(terminal, cwd, shellCommand);
+  if (!termCmd) {
+    return {
+      ok: false,
+      status: 501,
+      error: "terminal_disabled",
+      hint: "openTerminal n\xE3o reconhecido."
+    };
+  }
+  try {
+    const child = spawn2(termCmd.file, termCmd.args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.on("error", (err) => {
+      console.error(`[run-agent] spawn error: ${err.message}`);
+    });
+    child.unref();
+    return { ok: true };
+  } catch (err) {
+    return {
+      ok: false,
+      status: 500,
+      error: "spawn_failed",
+      detail: err.message
+    };
+  }
+}
+function parseInlineCommand(baseCommand, agentName, prompt) {
+  const tokens = baseCommand.match(/"[^"]*"|'[^']*'|\S+/g);
+  if (!tokens || tokens.length === 0) return null;
+  const cleaned = tokens.map((t) => {
+    const unquoted = t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'") ? t.slice(1, -1) : t;
+    return unquoted.includes("feature-runner") ? unquoted.replaceAll("feature-runner", agentName) : unquoted;
+  });
+  const promptIdx = cleaned.findIndex((t) => t.includes("{prompt}"));
+  if (promptIdx === -1) {
+    cleaned.push(prompt);
+  } else {
+    cleaned[promptIdx] = (cleaned[promptIdx] ?? "").replaceAll("{prompt}", prompt);
+  }
+  const [file, ...args] = cleaned;
+  if (!file) return null;
+  return { file, args };
+}
+async function buildAgentInlineCommand(input, config, projectRoot) {
+  const { scope, feature, task, cli, model, effort } = input;
+  const featuresDir = config.featuresDir ?? "features";
+  const featureMetaPath = path9.join(projectRoot, featuresDir, feature, "meta.json");
+  const featureTitle = await readFeatureTitle(featureMetaPath, feature);
+  const promptTemplate = config.agent.scopes[scope] ?? "";
+  const prompt = resolvePrompt(promptTemplate, {
+    feature,
+    task,
+    featureTitle,
+    featurePath: `${featuresDir}/${feature}/`
+  });
+  const command = buildCommand(config, cli, model, effort, (s) => s);
+  const parsed = parseInlineCommand(command, "feature-runner", prompt);
+  if (!parsed) return null;
+  const cwd = path9.resolve(projectRoot, config.agent.cwd ?? ".");
+  const label = scope === "task" && task ? `${featureTitle} \u2014 ${task}` : `${featureTitle} (${scope})`;
+  return { file: parsed.file, args: parsed.args, cwd, label };
+}
+function buildNamedAgentInlineCommand(agentName, userPrompt, config, projectRoot, label, cli, model, effort) {
+  const command = buildCommand(config, cli, model, effort, (s) => s);
+  const parsed = parseInlineCommand(command, agentName, userPrompt);
+  if (!parsed) return null;
+  const cwd = path9.resolve(projectRoot, config.agent.cwd ?? ".");
+  return { file: parsed.file, args: parsed.args, cwd, label };
+}
+function stripAgentFlag(template) {
+  return template.replace(/\s--agent(?:=|\s+)[^\s"']+/g, "").replace(/Use the feature-runner subagent\.\s*/g, "").replace(/\s+/g, " ").trim();
+}
+function buildDesignInlineCommand(prompt, config, projectRoot, label, cli, model, effort) {
+  const command = stripAgentFlag(buildCommand(config, cli, model, effort, (s) => s));
+  const parsed = parseInlineCommand(command, "design", prompt);
+  if (!parsed) return null;
+  const cwd = path9.resolve(projectRoot, config.agent.cwd ?? ".");
+  return { file: parsed.file, args: parsed.args, cwd, label };
+}
+function runDesign(prompt, config, projectRoot, cli, model, effort) {
+  const command = stripAgentFlag(buildCommand(config, cli, model, effort, shellQuote));
+  const shellCommand = command.replaceAll("{prompt}", shellQuote(prompt));
+  return spawnInTerminal(config, projectRoot, shellCommand);
+}
+async function runAgent(input, config, projectRoot) {
+  const { scope, feature, task, cli, model, effort } = input;
+  const featuresDir = config.featuresDir ?? "features";
+  const featureMetaPath = path9.join(projectRoot, featuresDir, feature, "meta.json");
+  const featureTitle = await readFeatureTitle(featureMetaPath, feature);
+  const scopeKey = scope;
+  const promptTemplate = config.agent.scopes[scopeKey] ?? "";
+  const prompt = resolvePrompt(promptTemplate, {
+    feature,
+    task,
+    featureTitle,
+    featurePath: `${featuresDir}/${feature}/`
+  });
+  const commandTemplate = buildCommand(config, cli, model, effort, shellQuote);
+  const shellCommand = commandTemplate.replaceAll("{prompt}", shellQuote(prompt));
+  return spawnInTerminal(config, projectRoot, shellCommand);
+}
+function runRefinement(userPrompt, config, projectRoot, cli, model, effort) {
+  return runNamedAgent("refinement", userPrompt, config, projectRoot, cli, model, effort);
+}
+function runDrawingAgent(userPrompt, config, projectRoot, cli, model, effort) {
+  return runNamedAgent("drawing-agent", userPrompt, config, projectRoot, cli, model, effort);
+}
+function runRefinementRunner(userPrompt, config, projectRoot, cli, model, effort) {
+  return runNamedAgent("refinement-runner", userPrompt, config, projectRoot, cli, model, effort);
+}
+function runDiscoveryAgent(userPrompt, config, projectRoot, cli, model, effort) {
+  return runNamedAgent("discovery-agent", userPrompt, config, projectRoot, cli, model, effort);
+}
+function runNamedAgent(agentName, userPrompt, config, projectRoot, cli, model, effort) {
+  const baseCommand = buildCommand(config, cli, model, effort, shellQuote);
+  const command = baseCommand.includes("feature-runner") ? baseCommand.replaceAll("feature-runner", agentName) : `claude --agent ${agentName} "{prompt}"`;
+  const shellCommand = command.replaceAll("{prompt}", shellQuote(userPrompt));
+  return spawnInTerminal(config, projectRoot, shellCommand);
+}
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+var MODEL_LINE_RE = /^([A-Za-z0-9][A-Za-z0-9._\-/:]*)\s+-\s+(.+)$/;
+var MODEL_BARE_RE = /^[A-Za-z0-9][A-Za-z0-9._\-/:]*$/;
+function parseModelsOutput(output) {
+  const seen = /* @__PURE__ */ new Set();
+  const models = [];
+  for (const raw of output.replace(ANSI_RE, "").split("\n")) {
+    const line = raw.trim().replace(/^[-*•]\s+/, "");
+    if (!line) continue;
+    const matched = line.match(MODEL_LINE_RE);
+    let id;
+    let label;
+    if (matched) {
+      id = matched[1];
+      label = (matched[2] ?? "").trim();
+    } else if (MODEL_BARE_RE.test(line)) {
+      id = line;
+      label = line;
+    }
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    models.push({ id, label: label ?? id });
+    if (models.length >= 200) break;
+  }
+  return models;
+}
+function runForStdout(file, args, cwd, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    const child = spawn2(file, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error("timeout"));
+    }, timeoutMs);
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve(stdout);
+      else reject(new Error(stderr.trim() || `exit ${code}`));
+    });
+  });
+}
+async function listAgentModels(config, projectRoot, cli) {
+  const cwd = path9.resolve(projectRoot, config.agent.cwd ?? ".");
+  const staticList = (config.agent.models?.[cli] ?? []).map((id) => ({ id, label: id }));
+  const command = config.agent.modelsCommand?.[cli];
+  if (command) {
+    const tokens = command.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+    const cleaned = tokens.map(
+      (t) => t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'") ? t.slice(1, -1) : t
+    );
+    const [file, ...args] = cleaned;
+    if (file) {
+      try {
+        const out = await runForStdout(file, args, cwd, 2e4);
+        const models = parseModelsOutput(out);
+        if (models.length > 0) return { models, source: "dynamic" };
+      } catch (err) {
+        if (staticList.length > 0) {
+          return { models: staticList, source: "static", error: err.message };
+        }
+        return { models: [], source: "none", error: err.message };
+      }
+    }
+  }
+  if (staticList.length > 0) return { models: staticList, source: "static" };
+  return { models: [], source: "none" };
+}
+
+// ../../internal/specs-server/src/review.ts
+import { execFile } from "child_process";
+import path10 from "path";
+import { promisify } from "util";
+var run = promisify(execFile);
+var MAX_DIFF_LINES = 1500;
+var GENERATED_PATTERNS = [
+  /(^|\/)pnpm-lock\.yaml$/,
+  /(^|\/)package-lock\.json$/,
+  /(^|\/)yarn\.lock$/,
+  /\.snap$/,
+  /(^|\/)dist\//,
+  /(^|\/)node_modules\//,
+  /(^|\/)migrations?\/.+\.sql$/
+];
+function isGenerated(file) {
+  return GENERATED_PATTERNS.some((re) => re.test(file));
+}
+function statusFromCode(code) {
+  if (code === "??") return "untracked";
+  const flags = code.replace(/\s/g, "");
+  if (flags.includes("R")) return "renamed";
+  if (flags.includes("D")) return "deleted";
+  if (flags.includes("A")) return "added";
+  return "modified";
+}
+async function git(cwd, args) {
+  try {
+    const { stdout } = await run("git", args, { cwd, maxBuffer: 64 * 1024 * 1024 });
+    return stdout;
+  } catch (err) {
+    const withStdout = err;
+    if (typeof withStdout.stdout === "string" && withStdout.stdout.length > 0) {
+      return withStdout.stdout;
+    }
+    throw err;
+  }
+}
+function parseStatus(raw) {
+  const parts = raw.split("\0").filter((p2) => p2.length > 0);
+  const out = [];
+  for (let i = 0; i < parts.length; i += 1) {
+    const entry = parts[i];
+    const code = entry.slice(0, 2);
+    const file = entry.slice(3);
+    if (code.includes("R") || code.includes("C")) {
+      const previous = parts[i + 1];
+      i += 1;
+      out.push({ code, file, previous });
+      continue;
+    }
+    out.push({ code, file });
+  }
+  return out;
+}
+function parseNumstat(raw) {
+  const out = /* @__PURE__ */ new Map();
+  const parts = raw.split("\0").filter((p2) => p2.length > 0);
+  for (let i = 0; i < parts.length; i += 1) {
+    const entry = parts[i];
+    const match = /^(\d+|-)\t(\d+|-)\t?(.*)$/.exec(entry);
+    if (!match) continue;
+    const additions = match[1] === "-" ? 0 : Number(match[1]);
+    const deletions = match[2] === "-" ? 0 : Number(match[2]);
+    let file = match[3] ?? "";
+    if (!file) {
+      i += 1;
+      file = parts[i + 1] ?? parts[i] ?? "";
+      i += 1;
+    }
+    if (file) out.set(file, { additions, deletions });
+  }
+  return out;
+}
+async function countUntracked(projectRoot, file) {
+  try {
+    const { readFile: readFile10 } = await import("fs/promises");
+    const content = await readFile10(path10.resolve(projectRoot, file), "utf8");
+    if (content === "") return 0;
+    return content.split("\n").length;
+  } catch {
+    return 0;
+  }
+}
+function truncate(diff) {
+  const lines = diff.split("\n");
+  if (lines.length <= MAX_DIFF_LINES) return { diff, truncated: false };
+  return { diff: lines.slice(0, MAX_DIFF_LINES).join("\n"), truncated: true };
+}
+async function resolveUpstream(projectRoot, branch) {
+  const tracked = await git(projectRoot, [
+    "rev-parse",
+    "--abbrev-ref",
+    "--symbolic-full-name",
+    "@{u}"
+  ]).then((out) => out.trim()).catch(() => "");
+  if (tracked) return tracked;
+  const fallback = `origin/${branch}`;
+  const exists2 = await git(projectRoot, ["rev-parse", "--verify", "--quiet", fallback]).then((out) => out.trim().length > 0).catch(() => false);
+  return exists2 ? fallback : null;
+}
+function parseShowNumstat(raw) {
+  const files = [];
+  for (const line of raw.split("\n")) {
+    const match = /^(\d+|-)\t(\d+|-)\t(.+)$/.exec(line.trim());
+    if (!match) continue;
+    const file = match[3];
+    files.push({
+      path: file,
+      status: "modified",
+      additions: match[1] === "-" ? 0 : Number(match[1]),
+      deletions: match[2] === "-" ? 0 : Number(match[2]),
+      generated: isGenerated(file),
+      binary: match[1] === "-" && match[2] === "-"
+    });
+  }
+  return files;
+}
+async function collectLocalCommits(projectRoot, upstream) {
+  if (!upstream) return [];
+  const log2 = await git(projectRoot, [
+    "log",
+    "--reverse",
+    "--format=%H%x1f%h%x1f%s%x1f%aI",
+    `${upstream}..HEAD`
+  ]).catch(() => "");
+  const commits = [];
+  for (const line of log2.split("\n")) {
+    if (!line.trim()) continue;
+    const [hash, shortHash, subject, date] = line.split("");
+    if (!hash) continue;
+    const files = parseShowNumstat(
+      await git(projectRoot, ["show", "--numstat", "--format=", hash]).catch(() => "")
+    );
+    commits.push({
+      hash,
+      shortHash: shortHash ?? hash.slice(0, 7),
+      subject: subject ?? "",
+      date: date ?? "",
+      files,
+      additions: files.reduce((sum, f) => sum + f.additions, 0),
+      deletions: files.reduce((sum, f) => sum + f.deletions, 0)
+    });
+  }
+  return commits;
+}
+async function diffForFile(projectRoot, file, status) {
+  if (status === "untracked") {
+    return git(projectRoot, ["diff", "--no-index", "--unified=3", "--", "/dev/null", file]);
+  }
+  return git(projectRoot, ["diff", "HEAD", "--unified=3", "--", file]);
+}
+async function collectChanges(projectRoot) {
+  const branch = (await git(projectRoot, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+  const upstream = await resolveUpstream(projectRoot, branch);
+  const commits = await collectLocalCommits(projectRoot, upstream);
+  const status = parseStatus(
+    await git(projectRoot, ["status", "--porcelain=v1", "--untracked-files=all", "-z"])
+  );
+  const numstat = parseNumstat(await git(projectRoot, ["diff", "--numstat", "-z", "HEAD"]));
+  const files = [];
+  for (const entry of status) {
+    const fileStatus = statusFromCode(entry.code);
+    const counted = numstat.get(entry.file);
+    const additions = counted?.additions ?? (fileStatus === "untracked" ? await countUntracked(projectRoot, entry.file) : 0);
+    files.push({
+      path: entry.file,
+      previousPath: entry.previous,
+      status: fileStatus,
+      additions,
+      deletions: counted?.deletions ?? 0,
+      generated: isGenerated(entry.file),
+      binary: false
+    });
+  }
+  files.sort((a, b) => {
+    if (a.generated !== b.generated) return a.generated ? 1 : -1;
+    return a.path.localeCompare(b.path);
+  });
+  return {
+    branch,
+    upstream,
+    commits,
+    files,
+    totals: {
+      files: files.length,
+      additions: files.reduce((sum, f) => sum + f.additions, 0),
+      deletions: files.reduce((sum, f) => sum + f.deletions, 0)
+    }
+  };
+}
+async function fileDiff(projectRoot, file, commit) {
+  const absolute = path10.resolve(projectRoot, file);
+  const relative = path10.relative(projectRoot, absolute);
+  if (relative.startsWith("..") || path10.isAbsolute(relative)) {
+    throw new Error("invalid_path");
+  }
+  if (commit) {
+    if (!/^[0-9a-f]{7,40}$/i.test(commit)) throw new Error("invalid_commit");
+    const raw2 = await git(projectRoot, [
+      "show",
+      "--format=",
+      "--unified=3",
+      commit,
+      "--",
+      file
+    ]).catch(() => "");
+    const { diff: diff2, truncated: truncated2 } = truncate(raw2);
+    return { path: file, binary: raw2.includes("Binary files"), truncated: truncated2, diff: diff2 };
+  }
+  const tracked = await git(projectRoot, ["ls-files", "--error-unmatch", "--", file]).then(() => true).catch(() => false);
+  const raw = await diffForFile(projectRoot, file, tracked ? "modified" : "untracked").catch(
+    () => ""
+  );
+  const { diff, truncated } = truncate(raw);
+  return { path: file, binary: raw.includes("Binary files"), truncated, diff };
+}
+async function openInEditor(projectRoot, template, file, line) {
+  const absolute = path10.resolve(projectRoot, file);
+  const relative = path10.relative(projectRoot, absolute);
+  if (relative.startsWith("..") || path10.isAbsolute(relative)) {
+    return { ok: false, error: "invalid_path" };
+  }
+  const filled = template.replaceAll("{path}", absolute).replaceAll("{line}", String(line ?? 1)).trim();
+  const [bin, ...args] = filled.split(/\s+/);
+  if (!bin) return { ok: false, error: "spawn_failed", detail: "comando vazio" };
+  try {
+    await run(bin, args, { cwd: projectRoot });
+    return { ok: true, command: filled };
+  } catch (err) {
+    return { ok: false, error: "spawn_failed", detail: err.message };
+  }
+}
+
+// ../../internal/specs-server/src/prototype.ts
+import path11 from "path";
+import { spawn as spawn3 } from "child_process";
+import { readFile as readFile7 } from "fs/promises";
+async function resolvePrototype(projectRoot, config, feature) {
+  let resolved = config.prototype ? { ...config.prototype, source: "config" } : null;
+  if (feature) {
+    const metaPath = path11.resolve(projectRoot, config.featuresDir, feature, "meta.json");
+    try {
+      assertInsideProject(metaPath, projectRoot);
+      if (await fileExists(metaPath)) {
+        const meta = JSON.parse(await readFile7(metaPath, "utf8"));
+        const override = normalizePrototype(meta.prototype);
+        if (override) resolved = { ...override, source: "feature", feature };
+      }
+    } catch {
+    }
+  }
+  if (!resolved) return null;
+  resolved = await withSnapshot(projectRoot, resolved);
+  if (resolved.tool === "pencil" && resolved.file) {
+    const filePath = path11.resolve(projectRoot, resolved.file);
+    try {
+      assertInsideProject(filePath, projectRoot);
+      return { ...resolved, filePath, fileExists: await fileExists(filePath) };
+    } catch {
+      return { ...resolved, fileExists: false };
+    }
+  }
+  return resolved;
+}
+async function withSnapshot(projectRoot, prototype) {
+  const candidate = prototype.snapshot ?? (prototype.designDir ? `${prototype.designDir.replace(/\/$/, "")}/canvas.html` : void 0);
+  if (!candidate) return prototype;
+  try {
+    const abs = path11.resolve(projectRoot, candidate);
+    assertInsideProject(abs, projectRoot);
+    return { ...prototype, snapshotPath: candidate, snapshotExists: await fileExists(abs) };
+  } catch {
+    return { ...prototype, snapshotPath: candidate, snapshotExists: false };
+  }
+}
+function snapshotAbsolutePath(projectRoot, prototype) {
+  if (!prototype.snapshotPath || !prototype.snapshotExists) return null;
+  try {
+    const abs = path11.resolve(projectRoot, prototype.snapshotPath);
+    assertInsideProject(abs, projectRoot);
+    return abs;
+  } catch {
+    return null;
+  }
+}
+function buildSnapshotPrompt(prototype) {
+  const target = prototype.snapshotPath ?? "design/prototipo/canvas.html";
+  if (prototype.tool === "claude-design") {
+    return `Atualize o snapshot local do prot\xF3tipo: leia o canvas ${prototype.url} com a tool Artifact (action "read") e grave o HTML completo devolvido em ${target} (crie o diret\xF3rio se n\xE3o existir, e sobrescreva o arquivo se j\xE1 houver um). N\xE3o altere o canvas nem outros arquivos do reposit\xF3rio; ao terminar, diga o tamanho do arquivo gravado.`;
+  }
+  return `Atualize o snapshot local do prot\xF3tipo Pencil ${prototype.file}: exporte a vis\xE3o atual do arquivo e grave-a em ${target}. Se o Pencil MCP n\xE3o permitir exportar, diga isso em vez de improvisar, e informe qual export manual o usu\xE1rio precisa fazer.`;
+}
+function buildDesignPrompt(prototype, request, ctx = {}, intent = "change") {
+  if (intent === "snapshot") return buildSnapshotPrompt(prototype);
+  const context = [];
+  if (ctx.featureTitle || ctx.feature) {
+    context.push(`Feature: ${ctx.featureTitle ?? ctx.feature}`);
+  }
+  if (ctx.task) context.push(`Task: ${ctx.task}`);
+  if (ctx.specPath) context.push(`Spec: ${ctx.specPath}`);
+  const suffix = context.length > 0 ? `
+
+Contexto \u2014 ${context.join(" \xB7 ")}.` : "";
+  if (prototype.tool === "claude-design") {
+    const target = [
+      prototype.title ? `"${prototype.title}"` : null,
+      prototype.url ? `(${prototype.url})` : null
+    ].filter(Boolean).join(" ");
+    const dir = prototype.designDir ? ` As notas do prot\xF3tipo est\xE3o em ${prototype.designDir}/README.md \u2014 atualize-as se a mudan\xE7a alterar as decis\xF5es descritas l\xE1.` : "";
+    return `/design Atualize o prot\xF3tipo ${target} do canvas existente: ${request}. Mantenha os artboards j\xE1 publicados e o sistema de tokens atual; re-seed apenas o que a mudan\xE7a exigir.${dir}${suffix}`;
+  }
+  const file = prototype.file ?? "(arquivo .pen n\xE3o declarado)";
+  return `Altere o prot\xF3tipo Pencil ${file}: ${request}. Use as tools do Pencil MCP (o .pen \xE9 encriptado \u2014 nunca leia com Read/Grep): confirme o estado do editor, localize os n\xF3s alvo, aplique a mudan\xE7a e devolva os node IDs afetados com o antes/depois de cada um.${suffix}`;
+}
+function openPrototype(projectRoot, prototype) {
+  if (prototype.tool !== "pencil" || !prototype.filePath) {
+    return { ok: false, status: 400, error: "not_openable" };
+  }
+  if (prototype.fileExists === false) {
+    return { ok: false, status: 404, error: "prototype_file_not_found", detail: prototype.file };
+  }
+  const template = prototype.openCommand ?? DEFAULT_PROTOTYPE_OPEN_COMMAND[prototype.tool] ?? "";
+  const command = template.replaceAll("{file}", prototype.filePath).replaceAll("{url}", prototype.url ?? "");
+  const tokens = command.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+  const cleaned = tokens.map(
+    (t) => t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'") ? t.slice(1, -1) : t
+  );
+  const [file, ...args] = cleaned;
+  if (!file) return { ok: false, status: 400, error: "invalid_open_command" };
+  try {
+    const child = spawn3(file, args, { cwd: projectRoot, detached: true, stdio: "ignore" });
+    child.on("error", (err) => {
+      console.error(`[prototype] open error: ${err.message}`);
+    });
+    child.unref();
+    return { ok: true, command };
+  } catch (err) {
+    return { ok: false, status: 500, error: "spawn_failed", detail: err.message };
+  }
+}
+
+// ../../internal/specs-server/src/job-manager.ts
+import { EventEmitter } from "events";
+import * as pty from "node-pty";
+import { nanoid } from "nanoid";
+
+// ../../internal/specs-server/src/job-store.ts
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import path12 from "path";
+var MAX_PERSISTED_JOBS = 30;
+var MAX_PERSISTED_BUFFER = 64 * 1024;
+function jobStorePath(projectRoot) {
+  return path12.join(projectRoot, ".specs", ".jobs.json");
+}
+function isJobStatus(v) {
+  return v === "running" || v === "needs-input" || v === "done" || v === "failed" || v === "cancelled";
+}
+function isJobKind(v) {
+  return v === "agent" || v === "refinement" || v === "discovery-agent" || v === "drawing-agent" || v === "design";
+}
+function reviveJob(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const r = raw;
+  if (typeof r.id !== "string" || r.id.length === 0) return null;
+  if (typeof r.label !== "string") return null;
+  if (!isJobKind(r.kind)) return null;
+  if (typeof r.startedAt !== "number" || !Number.isFinite(r.startedAt)) return null;
+  const status = isJobStatus(r.status) ? r.status : "cancelled";
+  const wasActive = status === "running" || status === "needs-input";
+  const buffer = typeof r.buffer === "string" ? r.buffer.slice(-MAX_PERSISTED_BUFFER) : "";
+  return {
+    id: r.id,
+    kind: r.kind,
+    label: r.label,
+    feature: typeof r.feature === "string" ? r.feature : void 0,
+    task: typeof r.task === "string" ? r.task : void 0,
+    status: wasActive ? "cancelled" : status,
+    pid: typeof r.pid === "number" ? r.pid : 0,
+    startedAt: r.startedAt,
+    // Um job que estava vivo não tem fim registrado — o servidor caiu antes.
+    // Sem `endedAt`, a duração exibida cresceria para sempre.
+    endedAt: typeof r.endedAt === "number" ? r.endedAt : wasActive ? typeof r.lastSeenAt === "number" ? r.lastSeenAt : r.startedAt : void 0,
+    exitCode: typeof r.exitCode === "number" ? r.exitCode : void 0,
+    bufferBytes: buffer.length,
+    needsInputHint: typeof r.needsInputHint === "string" ? r.needsInputHint : void 0,
+    buffer,
+    restored: true
+  };
+}
+function loadJobHistory(projectRoot) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(jobStorePath(projectRoot), "utf8"));
+  } catch {
+    return [];
+  }
+  if (typeof parsed !== "object" || parsed === null) return [];
+  const file = parsed;
+  if (file.version !== 1 || !Array.isArray(file.jobs)) return [];
+  const out = [];
+  for (const raw of file.jobs) {
+    const job = reviveJob(raw);
+    if (job) out.push(job);
+  }
+  return out.sort((a, b) => b.startedAt - a.startedAt).slice(0, MAX_PERSISTED_JOBS);
+}
+function saveJobHistory(projectRoot, jobs2) {
+  const trimmed = jobs2.slice().sort((a, b) => b.startedAt - a.startedAt).slice(0, MAX_PERSISTED_JOBS).map((job) => ({ ...job, buffer: job.buffer.slice(-MAX_PERSISTED_BUFFER) }));
+  const finalPath = jobStorePath(projectRoot);
+  const tmpPath = `${finalPath}.tmp`;
+  const payload = { version: 1, jobs: trimmed };
+  try {
+    mkdirSync(path12.dirname(finalPath), { recursive: true });
+    writeFileSync(tmpPath, `${JSON.stringify(payload)}
+`, "utf8");
+    renameSync(tmpPath, finalPath);
+  } catch (err) {
+    console.error(`[job-store] falha ao gravar hist\xF3rico: ${err.message}`);
+  }
+}
+
+// ../../internal/specs-server/src/job-manager.ts
+var OSC_REGEX = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\|$)/g;
+var CSI_REGEX = /\x1b\[[0-9;?]*[ -\/]*[@-~]/g;
+var SIMPLE_ESC_REGEX = /\x1b[()#][0-9A-Za-z]|\x1b[0-9A-Za-z=><]/g;
+var CONTROL_REGEX = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
+var HINT_MAX_CHARS = 160;
+var DEFAULT_COLS = 120;
+var DEFAULT_ROWS = 30;
+var INACTIVITY_MS = 2500;
+var DEBOUNCE_MS = 200;
+var STOP_SIGTERM_DELAY_MS = 2e3;
+var STOP_SIGKILL_DELAY_MS = 2e3;
+var INPUT_GRACE_MS = 3e3;
+var PERSIST_DEBOUNCE_MS = 800;
+function stripAnsi(s) {
+  return s.replace(OSC_REGEX, "").replace(CSI_REGEX, "").replace(SIMPLE_ESC_REGEX, "").replace(CONTROL_REGEX, "");
+}
+function trimHint(text2) {
+  const clean = text2.replace(/\s+/g, " ").trim();
+  if (clean.length <= HINT_MAX_CHARS) return clean;
+  const cut = clean.slice(0, HINT_MAX_CHARS);
+  const space = cut.lastIndexOf(" ");
+  return `${(space > 40 ? cut.slice(0, space) : cut).trimEnd()}\u2026`;
+}
+function lastNonEmptyLine(text2, limitLines = 8) {
+  const plain = stripAnsi(text2);
+  const lines = plain.split(/\r?\n/).slice(-limitLines);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const t = lines[i]?.trim() ?? "";
+    if (t.length > 0) return t;
+  }
+  return "";
+}
+var jobs = /* @__PURE__ */ new Map();
+function createJobManager(options = {}) {
+  const { projectRoot } = options;
+  let persistTimer = null;
+  function toStorable(job) {
+    return { ...summarize(job), buffer: job.buffer, lastSeenAt: job.lastChunkAt };
+  }
+  function persistNow() {
+    if (!projectRoot) return;
+    if (persistTimer) {
+      clearTimeout(persistTimer);
+      persistTimer = null;
+    }
+    saveJobHistory(projectRoot, Array.from(jobs.values()).map(toStorable));
+  }
+  function schedulePersist() {
+    if (!projectRoot || persistTimer) return;
+    persistTimer = setTimeout(() => {
+      persistTimer = null;
+      persistNow();
+    }, PERSIST_DEBOUNCE_MS);
+    persistTimer.unref?.();
+  }
+  if (projectRoot) {
+    for (const persisted of loadJobHistory(projectRoot)) {
+      if (jobs.has(persisted.id)) continue;
+      const emitter = new EventEmitter();
+      emitter.setMaxListeners(32);
+      jobs.set(persisted.id, {
+        ...persisted,
+        buffer: persisted.buffer,
+        bufferBytes: persisted.buffer.length,
+        emitter,
+        lastChunkAt: persisted.endedAt ?? persisted.startedAt,
+        promptPatterns: [],
+        bufferBytesCap: Math.max(persisted.buffer.length, 1),
+        restored: true
+      });
+    }
+  }
+  function summarize(job) {
+    return {
+      id: job.id,
+      kind: job.kind,
+      label: job.label,
+      feature: job.feature,
+      task: job.task,
+      status: job.status,
+      pid: job.pid,
+      startedAt: job.startedAt,
+      endedAt: job.endedAt,
+      exitCode: job.exitCode,
+      bufferBytes: job.bufferBytes,
+      needsInputHint: job.needsInputHint,
+      restored: job.restored
+    };
+  }
+  function setStatus(job, next, extra) {
+    if (job.status === next && extra?.exitCode === void 0) return;
+    job.status = next;
+    if (extra?.exitCode !== void 0) job.exitCode = extra.exitCode;
+    job.emitter.emit("event", {
+      type: "status",
+      payload: {
+        status: next,
+        exitCode: job.exitCode,
+        needsInputHint: job.needsInputHint
+      }
+    });
+    schedulePersist();
+  }
+  function matchPrompt(job) {
+    const tail = job.buffer.slice(-8e3);
+    const last = lastNonEmptyLine(tail);
+    if (!last) return null;
+    for (const re of job.promptPatterns) {
+      if (re.test(last)) return last;
+    }
+    return null;
+  }
+  function evaluateNeedsInput(job, trigger) {
+    if (job.status === "done" || job.status === "failed" || job.status === "cancelled") return;
+    if (job.status === "needs-input") return;
+    if (job.graceUntil && Date.now() < job.graceUntil) return;
+    const match = matchPrompt(job);
+    const quietLongEnough = Date.now() - job.lastChunkAt >= INACTIVITY_MS;
+    const shouldFlag = Boolean(match) || trigger === "inactivity" && quietLongEnough;
+    if (shouldFlag) {
+      job.needsInputHint = trimHint(match ?? lastNonEmptyLine(job.buffer.slice(-2e3)));
+      setStatus(job, "needs-input");
+    }
+  }
+  function scheduleInactivity(job) {
+    if (job.inactivityTimer) clearTimeout(job.inactivityTimer);
+    job.inactivityTimer = setTimeout(() => {
+      evaluateNeedsInput(job, "inactivity");
+    }, INACTIVITY_MS + 100);
+  }
+  function appendToBuffer(job, chunk) {
+    job.buffer += chunk;
+    if (job.buffer.length > job.bufferBytesCap) {
+      job.buffer = job.buffer.slice(job.buffer.length - job.bufferBytesCap);
+    }
+    job.bufferBytes = job.buffer.length;
+    job.lastChunkAt = Date.now();
+    schedulePersist();
+  }
+  function startJob(input) {
+    const id = nanoid(10);
+    const cols = input.cols ?? DEFAULT_COLS;
+    const rows = input.rows ?? DEFAULT_ROWS;
+    const env = {
+      ...process.env,
+      ...input.env,
+      TERM: "xterm-256color",
+      COLORTERM: "truecolor",
+      FORCE_COLOR: "1"
+    };
+    const ptyProc = pty.spawn(input.file, input.args, {
+      name: "xterm-256color",
+      cwd: input.cwd,
+      cols,
+      rows,
+      env
+    });
+    const emitter = new EventEmitter();
+    emitter.setMaxListeners(32);
+    const job = {
+      id,
+      kind: input.kind,
+      label: input.label,
+      feature: input.feature,
+      task: input.task,
+      status: "running",
+      pid: ptyProc.pid,
+      startedAt: Date.now(),
+      buffer: "",
+      bufferBytes: 0,
+      pty: ptyProc,
+      emitter,
+      lastChunkAt: Date.now(),
+      promptPatterns: input.promptPatterns,
+      bufferBytesCap: input.bufferBytesCap
+    };
+    jobs.set(id, job);
+    ptyProc.onData((chunk) => {
+      appendToBuffer(job, chunk);
+      emitter.emit("event", { type: "chunk", payload: chunk });
+      if (job.debounceTimer) clearTimeout(job.debounceTimer);
+      job.debounceTimer = setTimeout(() => {
+        evaluateNeedsInput(job, "chunk");
+      }, DEBOUNCE_MS);
+      scheduleInactivity(job);
+    });
+    ptyProc.onExit(({ exitCode, signal }) => {
+      if (job.inactivityTimer) clearTimeout(job.inactivityTimer);
+      if (job.debounceTimer) clearTimeout(job.debounceTimer);
+      job.endedAt = Date.now();
+      if (signal !== void 0 && signal !== 0 && job.status === "cancelled") {
+        setStatus(job, "cancelled", { exitCode });
+      } else if (exitCode === 0) {
+        setStatus(job, "done", { exitCode });
+      } else {
+        setStatus(job, "failed", { exitCode });
+      }
+    });
+    scheduleInactivity(job);
+    schedulePersist();
+    return summarize(job);
+  }
+  function writeInput(jobId, data) {
+    const job = jobs.get(jobId);
+    if (!job || !job.pty) return false;
+    if (job.status === "done" || job.status === "failed" || job.status === "cancelled") {
+      return false;
+    }
+    job.pty.write(data);
+    job.graceUntil = Date.now() + INPUT_GRACE_MS;
+    if (job.status === "needs-input") {
+      job.needsInputHint = void 0;
+      setStatus(job, "running");
+    }
+    return true;
+  }
+  function resize(jobId, cols, rows) {
+    const job = jobs.get(jobId);
+    if (!job || !job.pty) return false;
+    if (job.status === "done" || job.status === "failed" || job.status === "cancelled") {
+      return false;
+    }
+    try {
+      job.pty.resize(Math.max(1, cols | 0), Math.max(1, rows | 0));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function stopJob(jobId) {
+    const job = jobs.get(jobId);
+    if (!job) return false;
+    if (job.status === "done" || job.status === "failed" || job.status === "cancelled") {
+      return true;
+    }
+    if (!job.pty) return true;
+    try {
+      job.pty.kill("SIGINT");
+    } catch {
+    }
+    setStatus(job, "cancelled");
+    const pty1 = job.pty;
+    const t1 = setTimeout(() => {
+      if (job.status === "cancelled" && job.endedAt === void 0) {
+        try {
+          pty1.kill("SIGTERM");
+        } catch {
+        }
+      }
+    }, STOP_SIGTERM_DELAY_MS);
+    const t2 = setTimeout(() => {
+      if (job.status === "cancelled" && job.endedAt === void 0) {
+        try {
+          pty1.kill("SIGKILL");
+        } catch {
+        }
+      }
+    }, STOP_SIGTERM_DELAY_MS + STOP_SIGKILL_DELAY_MS);
+    job.stopTimers = [t1, t2];
+    return true;
+  }
+  function deleteJob(jobId) {
+    const job = jobs.get(jobId);
+    if (!job) return false;
+    if (job.status === "running" || job.status === "needs-input") return false;
+    if (job.stopTimers) job.stopTimers.forEach(clearTimeout);
+    if (job.inactivityTimer) clearTimeout(job.inactivityTimer);
+    if (job.debounceTimer) clearTimeout(job.debounceTimer);
+    job.emitter.removeAllListeners();
+    jobs.delete(jobId);
+    schedulePersist();
+    return true;
+  }
+  function listJobs() {
+    return Array.from(jobs.values()).sort((a, b) => b.startedAt - a.startedAt).map(summarize);
+  }
+  function getJob(jobId) {
+    const job = jobs.get(jobId);
+    if (!job) return null;
+    return { ...summarize(job), buffer: job.buffer };
+  }
+  function subscribe(jobId, handler) {
+    const job = jobs.get(jobId);
+    if (!job) return () => {
+    };
+    job.emitter.on("event", handler);
+    return () => {
+      job.emitter.off("event", handler);
+    };
+  }
+  async function shutdownAll() {
+    persistNow();
+    for (const job of jobs.values()) {
+      if (job.inactivityTimer) clearTimeout(job.inactivityTimer);
+      if (job.debounceTimer) clearTimeout(job.debounceTimer);
+      if (job.stopTimers) job.stopTimers.forEach(clearTimeout);
+      try {
+        if (job.pty && (job.status === "running" || job.status === "needs-input")) {
+          job.pty.kill("SIGKILL");
+        }
+      } catch {
+      }
+      job.emitter.removeAllListeners();
+    }
+    jobs.clear();
+  }
+  return {
+    startJob,
+    writeInput,
+    resize,
+    stopJob,
+    deleteJob,
+    listJobs,
+    getJob,
+    subscribe,
+    shutdownAll
+  };
+}
+function compilePromptPatterns(patterns) {
+  const compiled = [];
+  for (const p2 of patterns) {
+    try {
+      compiled.push(new RegExp(p2, "i"));
+    } catch (err) {
+      console.error(`[job-manager] invalid prompt pattern "${p2}": ${err.message}`);
+    }
+  }
+  return compiled;
+}
+
+// ../../internal/specs-server/src/job-routes.ts
+import path13 from "path";
+import { z } from "zod";
+
+// ../../internal/specs-server/src/types.ts
+var AGENT_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+
+// ../../internal/specs-server/src/job-routes.ts
+var slugSchema = z.string().regex(SLUG_REGEX);
+var cliSchema = z.string().min(1).max(40).regex(/^[a-z0-9-]+$/).optional();
+var modelSchema = z.string().min(1).max(80).regex(/^[A-Za-z0-9][A-Za-z0-9._\-/:]*$/).optional();
+var effortSchema = z.enum(AGENT_EFFORTS).optional();
+var createJobBodySchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("agent"),
+    mode: z.enum(["inline", "external"]).default("inline"),
+    cli: cliSchema,
+    model: modelSchema,
+    effort: effortSchema,
+    scope: z.enum(["feature", "featureNoPause", "task"]),
+    feature: slugSchema,
+    task: slugSchema.optional(),
+    cols: z.number().int().min(20).max(400).optional(),
+    rows: z.number().int().min(5).max(200).optional()
+  }),
+  z.object({
+    kind: z.literal("refinement"),
+    mode: z.enum(["inline", "external"]).default("inline"),
+    cli: cliSchema,
+    model: modelSchema,
+    effort: effortSchema,
+    prompt: z.string().min(1).max(1e4),
+    cols: z.number().int().min(20).max(400).optional(),
+    rows: z.number().int().min(5).max(200).optional()
+  }),
+  z.object({
+    kind: z.literal("refinement-runner"),
+    mode: z.enum(["inline", "external"]).default("inline"),
+    cli: cliSchema,
+    model: modelSchema,
+    effort: effortSchema,
+    prompt: z.string().min(1).max(1e4),
+    cols: z.number().int().min(20).max(400).optional(),
+    rows: z.number().int().min(5).max(200).optional()
+  }),
+  z.object({
+    kind: z.literal("design"),
+    mode: z.enum(["inline", "external"]).default("inline"),
+    cli: cliSchema,
+    model: modelSchema,
+    effort: effortSchema,
+    /** Pedido de alteração escrito pelo usuário no painel de protótipo. */
+    prompt: z.string().min(1).max(1e4),
+    /** `snapshot` regrava a cópia local usada no iframe; `change` (default) altera o design. */
+    intent: z.enum(["change", "snapshot"]).default("change"),
+    feature: slugSchema.optional(),
+    task: slugSchema.optional(),
+    cols: z.number().int().min(20).max(400).optional(),
+    rows: z.number().int().min(5).max(200).optional()
+  }),
+  z.object({
+    kind: z.literal("discovery-agent"),
+    mode: z.enum(["inline", "external"]).default("inline"),
+    cli: cliSchema,
+    model: modelSchema,
+    effort: effortSchema,
+    prompt: z.string().min(1).max(1e4),
+    cols: z.number().int().min(20).max(400).optional(),
+    rows: z.number().int().min(5).max(200).optional()
+  }),
+  z.object({
+    kind: z.literal("drawing-agent"),
+    mode: z.enum(["inline", "external"]).default("inline"),
+    cli: cliSchema,
+    model: modelSchema,
+    effort: effortSchema,
+    prompt: z.string().min(1).max(1e4),
+    cols: z.number().int().min(20).max(400).optional(),
+    rows: z.number().int().min(5).max(200).optional()
+  })
+]);
+var jobIdParamSchema = z.object({ id: z.string().min(1).max(64) });
+var inputBodySchema = z.object({ data: z.string().max(1e4) });
+var resizeBodySchema = z.object({
+  cols: z.number().int().min(20).max(400),
+  rows: z.number().int().min(5).max(200)
+});
+function sseEvent(ev) {
+  return `event: ${ev.type}
+data: ${JSON.stringify(ev.payload)}
+
+`;
+}
+function registerJobRoutes(fastify, jobs2, getConfig, projectRoot) {
+  fastify.post("/api/jobs", async (req, reply) => {
+    const parsed = createJobBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", detail: parsed.error.message });
+    }
+    const config = await getConfig();
+    const body = parsed.data;
+    let designPrompt = null;
+    let designLabel = "";
+    if (body.kind === "design") {
+      const prototype = await resolvePrototype(projectRoot, config, body.feature);
+      if (!prototype) {
+        return reply.code(400).send({
+          error: "no_prototype",
+          detail: "Nenhum prot\xF3tipo declarado em .specs/config.json nem no meta.json da feature."
+        });
+      }
+      designPrompt = buildDesignPrompt(
+        prototype,
+        body.prompt,
+        {
+          feature: body.feature,
+          task: body.task,
+          specPath: body.feature && body.task ? `${config.featuresDir}/${body.feature}/${body.task}.md` : body.feature ? `${config.featuresDir}/${body.feature}/` : void 0
+        },
+        body.intent
+      );
+      designLabel = body.intent === "snapshot" ? "Design: sincronizar snapshot" : `Design: ${body.prompt.slice(0, 60)}${body.prompt.length > 60 ? "\u2026" : ""}`;
+    }
+    if (body.mode === "external") {
+      if (body.kind === "agent") {
+        const result2 = await runAgent(
+          {
+            scope: body.scope,
+            feature: body.feature,
+            task: body.task,
+            cli: body.cli,
+            model: body.model,
+            effort: body.effort
+          },
+          config,
+          projectRoot
+        );
+        if (result2.ok) return { ok: true, mode: "external" };
+        return reply.code(result2.status).send({
+          error: result2.error,
+          ..."detail" in result2 ? { detail: result2.detail } : {},
+          ..."hint" in result2 ? { hint: result2.hint } : {}
+        });
+      }
+      if (body.kind === "refinement") {
+        const result2 = runRefinement(
+          body.prompt,
+          config,
+          projectRoot,
+          body.cli,
+          body.model,
+          body.effort
+        );
+        if (result2.ok) return { ok: true, mode: "external" };
+        return reply.code(result2.status).send({
+          error: result2.error,
+          ..."detail" in result2 ? { detail: result2.detail } : {},
+          ..."hint" in result2 ? { hint: result2.hint } : {}
+        });
+      }
+      if (body.kind === "refinement-runner") {
+        const result2 = runRefinementRunner(
+          body.prompt,
+          config,
+          projectRoot,
+          body.cli,
+          body.model,
+          body.effort
+        );
+        if (result2.ok) return { ok: true, mode: "external" };
+        return reply.code(result2.status).send({
+          error: result2.error,
+          ..."detail" in result2 ? { detail: result2.detail } : {},
+          ..."hint" in result2 ? { hint: result2.hint } : {}
+        });
+      }
+      if (body.kind === "design") {
+        const result2 = runDesign(
+          designPrompt,
+          config,
+          projectRoot,
+          body.cli,
+          body.model,
+          body.effort
+        );
+        if (result2.ok) return { ok: true, mode: "external" };
+        return reply.code(result2.status).send({
+          error: result2.error,
+          ..."detail" in result2 ? { detail: result2.detail } : {},
+          ..."hint" in result2 ? { hint: result2.hint } : {}
+        });
+      }
+      if (body.kind === "drawing-agent") {
+        const result2 = runDrawingAgent(
+          body.prompt,
+          config,
+          projectRoot,
+          body.cli,
+          body.model,
+          body.effort
+        );
+        if (result2.ok) return { ok: true, mode: "external" };
+        return reply.code(result2.status).send({
+          error: result2.error,
+          ..."detail" in result2 ? { detail: result2.detail } : {},
+          ..."hint" in result2 ? { hint: result2.hint } : {}
+        });
+      }
+      const result = runDiscoveryAgent(
+        body.prompt,
+        config,
+        projectRoot,
+        body.cli,
+        body.model,
+        body.effort
+      );
+      if (result.ok) return { ok: true, mode: "external" };
+      return reply.code(result.status).send({
+        error: result.error,
+        ..."detail" in result ? { detail: result.detail } : {},
+        ..."hint" in result ? { hint: result.hint } : {}
+      });
+    }
+    const patterns = compilePromptPatterns(config.agent.inputPromptPatterns);
+    const cwd = path13.resolve(projectRoot, config.agent.cwd ?? ".");
+    let inline = null;
+    if (body.kind === "agent") {
+      inline = await buildAgentInlineCommand(
+        {
+          scope: body.scope,
+          feature: body.feature,
+          task: body.task,
+          cli: body.cli,
+          model: body.model,
+          effort: body.effort
+        },
+        config,
+        projectRoot
+      );
+    } else if (body.kind === "refinement") {
+      inline = buildNamedAgentInlineCommand(
+        "refinement",
+        body.prompt,
+        config,
+        projectRoot,
+        `Refinement: ${body.prompt.slice(0, 60)}${body.prompt.length > 60 ? "\u2026" : ""}`,
+        body.cli,
+        body.model,
+        body.effort
+      );
+    } else if (body.kind === "refinement-runner") {
+      inline = buildNamedAgentInlineCommand(
+        "refinement-runner",
+        body.prompt,
+        config,
+        projectRoot,
+        `Refinar + executar: ${body.prompt.slice(0, 60)}${body.prompt.length > 60 ? "\u2026" : ""}`,
+        body.cli,
+        body.model,
+        body.effort
+      );
+    } else if (body.kind === "design") {
+      inline = buildDesignInlineCommand(
+        designPrompt,
+        config,
+        projectRoot,
+        designLabel,
+        body.cli,
+        body.model,
+        body.effort
+      );
+    } else if (body.kind === "drawing-agent") {
+      inline = buildNamedAgentInlineCommand(
+        "drawing-agent",
+        body.prompt,
+        config,
+        projectRoot,
+        `Desenho: ${body.prompt.slice(0, 60)}${body.prompt.length > 60 ? "\u2026" : ""}`,
+        body.cli,
+        body.model,
+        body.effort
+      );
+    } else {
+      inline = buildNamedAgentInlineCommand(
+        "discovery-agent",
+        body.prompt,
+        config,
+        projectRoot,
+        `Discovery: ${body.prompt.slice(0, 60)}${body.prompt.length > 60 ? "\u2026" : ""}`,
+        body.cli,
+        body.model,
+        body.effort
+      );
+    }
+    if (!inline) {
+      return reply.code(500).send({
+        error: "inline_build_failed",
+        detail: "N\xE3o foi poss\xEDvel montar o comando para execu\xE7\xE3o inline."
+      });
+    }
+    try {
+      const summary = jobs2.startJob({
+        kind: body.kind,
+        label: inline.label,
+        file: inline.file,
+        args: inline.args,
+        cwd: inline.cwd ?? cwd,
+        feature: body.kind === "agent" || body.kind === "design" ? body.feature : void 0,
+        task: body.kind === "agent" || body.kind === "design" ? body.task : void 0,
+        cols: body.cols,
+        rows: body.rows,
+        promptPatterns: patterns,
+        bufferBytesCap: config.agent.bufferBytesCap
+      });
+      return { ok: true, mode: "inline", jobId: summary.id, job: summary };
+    } catch (err) {
+      return reply.code(500).send({
+        error: "spawn_failed",
+        detail: err.message
+      });
+    }
+  });
+  fastify.get("/api/jobs", async () => ({ jobs: jobs2.listJobs() }));
+  const modelsQuerySchema = z.object({
+    cli: z.string().min(1).max(40).regex(/^[a-z0-9-]+$/)
+  });
+  fastify.get("/api/agent-models", async (req, reply) => {
+    const parsed = modelsQuerySchema.safeParse(req.query);
+    if (!parsed.success) return reply.code(400).send({ error: "invalid_query" });
+    const config = await getConfig();
+    const result = await listAgentModels(config, projectRoot, parsed.data.cli);
+    return result;
+  });
+  fastify.get("/api/jobs/:id", async (req, reply) => {
+    const parsed = jobIdParamSchema.safeParse(req.params);
+    if (!parsed.success) return reply.code(400).send({ error: "invalid_id" });
+    const job = jobs2.getJob(parsed.data.id);
+    if (!job) return reply.code(404).send({ error: "job_not_found" });
+    return job;
+  });
+  fastify.post("/api/jobs/:id/input", async (req, reply) => {
+    const idParsed = jobIdParamSchema.safeParse(req.params);
+    if (!idParsed.success) return reply.code(400).send({ error: "invalid_id" });
+    const bodyParsed = inputBodySchema.safeParse(req.body);
+    if (!bodyParsed.success) return reply.code(400).send({ error: "invalid_body" });
+    const ok = jobs2.writeInput(idParsed.data.id, bodyParsed.data.data);
+    if (!ok) return reply.code(404).send({ error: "job_not_found_or_terminated" });
+    return { ok: true };
+  });
+  fastify.post("/api/jobs/:id/resize", async (req, reply) => {
+    const idParsed = jobIdParamSchema.safeParse(req.params);
+    if (!idParsed.success) return reply.code(400).send({ error: "invalid_id" });
+    const bodyParsed = resizeBodySchema.safeParse(req.body);
+    if (!bodyParsed.success) return reply.code(400).send({ error: "invalid_body" });
+    const ok = jobs2.resize(idParsed.data.id, bodyParsed.data.cols, bodyParsed.data.rows);
+    if (!ok) return reply.code(404).send({ error: "job_not_found_or_terminated" });
+    return { ok: true };
+  });
+  fastify.post("/api/jobs/:id/stop", async (req, reply) => {
+    const parsed = jobIdParamSchema.safeParse(req.params);
+    if (!parsed.success) return reply.code(400).send({ error: "invalid_id" });
+    const ok = jobs2.stopJob(parsed.data.id);
+    if (!ok) return reply.code(404).send({ error: "job_not_found" });
+    return { ok: true };
+  });
+  fastify.delete("/api/jobs/:id", async (req, reply) => {
+    const parsed = jobIdParamSchema.safeParse(req.params);
+    if (!parsed.success) return reply.code(400).send({ error: "invalid_id" });
+    const ok = jobs2.deleteJob(parsed.data.id);
+    if (!ok) return reply.code(409).send({ error: "job_still_running_or_not_found" });
+    return { ok: true };
+  });
+  fastify.get("/api/jobs/:id/stream", async (req, reply) => {
+    const parsed = jobIdParamSchema.safeParse(req.params);
+    if (!parsed.success) return reply.code(400).send({ error: "invalid_id" });
+    const jobId = parsed.data.id;
+    const snapshot = jobs2.getJob(jobId);
+    if (!snapshot) return reply.code(404).send({ error: "job_not_found" });
+    reply.raw.setHeader("content-type", "text/event-stream");
+    reply.raw.setHeader("cache-control", "no-cache, no-transform");
+    reply.raw.setHeader("connection", "keep-alive");
+    reply.raw.setHeader("x-accel-buffering", "no");
+    reply.raw.flushHeaders?.();
+    if (snapshot.buffer.length > 0) {
+      reply.raw.write(sseEvent({ type: "chunk", payload: snapshot.buffer }));
+    }
+    reply.raw.write(
+      sseEvent({
+        type: "status",
+        payload: {
+          status: snapshot.status,
+          exitCode: snapshot.exitCode,
+          needsInputHint: snapshot.needsInputHint
+        }
+      })
+    );
+    const keepAlive = setInterval(() => {
+      reply.raw.write(": ping\n\n");
+    }, 15e3);
+    const unsubscribe = jobs2.subscribe(jobId, (event) => {
+      reply.raw.write(sseEvent(event));
+    });
+    req.raw.on("close", () => {
+      clearInterval(keepAlive);
+      unsubscribe();
+    });
+    return reply;
+  });
+}
+
+// ../../internal/specs-server/src/start-server.ts
+var statusSchema = z2.enum(["pending", "in-progress", "completed", "blocked"]);
+var slugSchema2 = z2.string().regex(SLUG_REGEX);
+var contentQuerySchema = z2.object({
+  feature: slugSchema2,
+  task: slugSchema2
+});
+var reviewDiffQuerySchema = z2.object({
+  path: z2.string().min(1).max(1024),
+  commit: z2.string().regex(/^[0-9a-f]{7,40}$/i).optional()
+});
+var openEditorBodySchema = z2.object({
+  path: z2.string().min(1).max(1024),
+  line: z2.number().int().positive().optional()
+});
+var statusBodySchema = z2.object({
+  feature: slugSchema2,
+  task: slugSchema2,
+  status: statusSchema
+});
+var reorderFeaturesBodySchema = z2.object({
+  pages: z2.array(slugSchema2)
+});
+var reorderTasksBodySchema = z2.object({
+  feature: slugSchema2,
+  pages: z2.array(slugSchema2)
+});
+var runAgentBodySchema = z2.object({
+  scope: z2.enum(["feature", "featureNoPause", "task"]),
+  feature: slugSchema2,
+  task: slugSchema2.optional()
+});
+var deleteTaskQuerySchema = z2.object({
+  feature: slugSchema2,
+  task: slugSchema2
+});
+var deleteFeatureQuerySchema = z2.object({
+  feature: slugSchema2
+});
+var updateContentBodySchema = z2.object({
+  feature: slugSchema2,
+  task: slugSchema2,
+  body: z2.string().max(1e6)
+  // 1MB — bem mais que o necessário para um .md de task
+});
+var runRefinementBodySchema = z2.object({
+  prompt: z2.string().min(1).max(1e4)
+});
+var discoveryContentQuerySchema = z2.object({
+  slug: slugSchema2
+});
+var updateDiscoveryContentBodySchema = z2.object({
+  slug: slugSchema2,
+  body: z2.string().max(1e6)
+});
+var deleteDiscoveryQuerySchema = z2.object({
+  slug: slugSchema2
+});
+var reorderDiscoveriesBodySchema = z2.object({
+  pages: z2.array(slugSchema2)
+});
+var prototypeQuerySchema = z2.object({
+  feature: slugSchema2.optional()
+});
+var runDiscoveryAgentBodySchema = z2.object({
+  prompt: z2.string().min(1).max(1e4)
+});
+var drawingContentQuerySchema = z2.object({
+  slug: slugSchema2
+});
+var updateDrawingContentBodySchema = z2.object({
+  slug: slugSchema2,
+  body: z2.string().max(1e6)
+});
+var deleteDrawingQuerySchema = z2.object({
+  slug: slugSchema2
+});
+var reorderDrawingsBodySchema = z2.object({
+  pages: z2.array(slugSchema2)
+});
+var runDrawingAgentBodySchema = z2.object({
+  prompt: z2.string().min(1).max(1e4)
+});
+function logLine(method, url, startMs, status) {
+  const dur = Date.now() - startMs;
+  const stamp = (/* @__PURE__ */ new Date()).toISOString();
+  console.log(`[${stamp}] ${method} ${url} ${dur}ms -> ${status}`);
+}
+async function readConfigFile(projectRoot) {
+  const configPath = path14.join(projectRoot, ".specs", "config.json");
+  if (!await fileExists(configPath)) {
+    return applyDefaults({});
+  }
+  try {
+    const raw = await readFile8(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return applyDefaults(parsed);
+  } catch (err) {
+    throw new Error(`invalid_config: ${err.message}`);
+  }
+}
+function setTaskPath(projectRoot, featuresDir, feature, task) {
+  const taskPath = path14.resolve(projectRoot, featuresDir, feature, `${task}.md`);
+  assertInsideProject(taskPath, projectRoot);
+  return taskPath;
+}
+function setMetaPath(projectRoot, featuresDir, feature) {
+  const p2 = feature ? path14.resolve(projectRoot, featuresDir, feature, "meta.json") : path14.resolve(projectRoot, featuresDir, "meta.json");
+  assertInsideProject(p2, projectRoot);
+  return p2;
+}
+function setDiscoveryPath(projectRoot, discoveriesDir, slug) {
+  const p2 = path14.resolve(projectRoot, discoveriesDir, `${slug}.md`);
+  assertInsideProject(p2, projectRoot);
+  return p2;
+}
+function setDiscoveryMetaPath(projectRoot, discoveriesDir) {
+  const p2 = path14.resolve(projectRoot, discoveriesDir, "meta.json");
+  assertInsideProject(p2, projectRoot);
+  return p2;
+}
+function setDrawingPath(projectRoot, drawingsDir, slug) {
+  const p2 = path14.resolve(projectRoot, drawingsDir, `${slug}.md`);
+  assertInsideProject(p2, projectRoot);
+  return p2;
+}
+function setDrawingMetaPath(projectRoot, drawingsDir) {
+  const p2 = path14.resolve(projectRoot, drawingsDir, "meta.json");
+  assertInsideProject(p2, projectRoot);
+  return p2;
+}
+async function startServer(userConfig, opts) {
+  const { projectRoot } = opts;
+  const config = applyDefaults(userConfig);
+  const featuresDir = config.featuresDir;
+  const discoveriesDir = config.discoveriesDir;
+  const drawingsDir = config.drawingsDir;
+  const rootMetaPath = path14.join(projectRoot, featuresDir, "meta.json");
+  if (!await fileExists(rootMetaPath)) {
+    throw new Error(
+      `${featuresDir}/meta.json n\xE3o encontrado em ${projectRoot}. Rode 'specs install' antes de 'specs start'.`
+    );
+  }
+  const fastify = Fastify({ logger: false });
+  await fastify.register(fastifyCors, {
+    origin: (origin, cb) => {
+      if (!origin) return cb(null, true);
+      try {
+        const url = new URL(origin);
+        if (url.hostname === "localhost" || url.hostname === "127.0.0.1") {
+          return cb(null, true);
+        }
+      } catch {
+      }
+      return cb(new Error("cors_blocked"), false);
+    }
+  });
+  if (opts.uiDir && await dirExists(opts.uiDir)) {
+    await fastify.register(fastifyStatic, {
+      root: opts.uiDir,
+      prefix: "/"
+    });
+    fastify.setNotFoundHandler((req, reply) => {
+      if (req.method !== "GET" || req.url.startsWith("/api")) {
+        return reply.code(404).send({ error: "not_found" });
+      }
+      return reply.sendFile("index.html");
+    });
+  }
+  fastify.addHook("onRequest", async (req) => {
+    ;
+    req._startMs = Date.now();
+  });
+  fastify.addHook("onResponse", async (req, reply) => {
+    const startMs = req._startMs ?? Date.now();
+    logLine(req.method, req.url, startMs, reply.statusCode);
+  });
+  const jobManager = createJobManager({ projectRoot });
+  registerJobRoutes(
+    fastify,
+    jobManager,
+    () => readConfigFile(projectRoot).catch(() => config),
+    projectRoot
+  );
+  const watcher = createSpecsWatcher({
+    projectRoot,
+    featuresDir,
+    discoveriesDir,
+    drawingsDir,
+    extraFiles: [
+      { file: desktopHistoryPath(), event: { type: "usage" } },
+      { file: cliCachePath(), event: { type: "usage" } },
+      { file: statuslineSnapshotPath(), event: { type: "usage" } }
+    ]
+  });
+  fastify.get("/api/tree", async (_req, reply) => {
+    try {
+      const tree = await buildTree(projectRoot, featuresDir, discoveriesDir, drawingsDir);
+      return tree;
+    } catch (err) {
+      const msg = err.message;
+      if (msg === "no_features_dir") {
+        return reply.code(500).send({ error: "no_features_dir" });
+      }
+      return reply.code(500).send({ error: "internal", detail: msg });
+    }
+  });
+  fastify.get("/api/content", async (req, reply) => {
+    const parsed = contentQuerySchema.safeParse(req.query);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_query" });
+    }
+    const { feature, task } = parsed.data;
+    let taskPath;
+    try {
+      taskPath = setTaskPath(projectRoot, featuresDir, feature, task);
+    } catch {
+      return reply.code(400).send({ error: "invalid_path" });
+    }
+    if (!await fileExists(taskPath)) {
+      return reply.code(404).send({ error: "task_not_found" });
+    }
+    const raw = await readText(taskPath);
+    const { data, body } = parseFrontmatter(raw);
+    const frontmatter = {
+      ...data,
+      ...extractFrontmatterFields(data)
+    };
+    const headings = extractHeadings(body);
+    return { frontmatter, body, headings, raw };
+  });
+  fastify.get("/api/review/changes", async (_req, reply) => {
+    try {
+      return await collectChanges(projectRoot);
+    } catch (err) {
+      return reply.code(500).send({ error: "git_failed", detail: err.message });
+    }
+  });
+  fastify.get("/api/review/diff", async (req, reply) => {
+    const parsed = reviewDiffQuerySchema.safeParse(req.query);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_query" });
+    }
+    try {
+      return await fileDiff(projectRoot, parsed.data.path, parsed.data.commit);
+    } catch (err) {
+      const message = err.message;
+      const status = message === "invalid_path" ? 400 : 500;
+      return reply.code(status).send({ error: message });
+    }
+  });
+  fastify.post("/api/review/open", async (req, reply) => {
+    const parsed = openEditorBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body" });
+    }
+    const current = await readConfigFile(projectRoot).catch(() => config);
+    const result = await openInEditor(
+      projectRoot,
+      current.review.openCommand,
+      parsed.data.path,
+      parsed.data.line
+    );
+    if (!result.ok) {
+      const status = result.error === "invalid_path" ? 400 : 500;
+      return reply.code(status).send(result);
+    }
+    return result;
+  });
+  fastify.post("/api/status", async (req, reply) => {
+    const parsed = statusBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", detail: parsed.error.message });
+    }
+    const { feature, task, status } = parsed.data;
+    let taskPath;
+    try {
+      taskPath = setTaskPath(projectRoot, featuresDir, feature, task);
+    } catch {
+      return reply.code(400).send({ error: "invalid_path" });
+    }
+    if (!await fileExists(taskPath)) {
+      return reply.code(404).send({ error: "task_not_found" });
+    }
+    const raw = await readText(taskPath);
+    const next = patchStatusInFrontmatter(raw, status);
+    if (next !== raw) {
+      await atomicWrite(taskPath, next);
+    }
+    return { ok: true, status };
+  });
+  fastify.post("/api/reorder-features", async (req, reply) => {
+    const parsed = reorderFeaturesBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body" });
+    }
+    const { pages } = parsed.data;
+    const metaPath = setMetaPath(projectRoot, featuresDir);
+    const raw = await readText(metaPath);
+    let meta;
+    try {
+      meta = JSON.parse(raw);
+    } catch {
+      return reply.code(500).send({ error: "invalid_meta" });
+    }
+    const currentSet = new Set(Array.isArray(meta.pages) ? meta.pages : []);
+    const newSet = new Set(pages);
+    if (currentSet.size !== newSet.size || [...currentSet].some((s) => !newSet.has(s))) {
+      return reply.code(400).send({ error: "invalid_pages" });
+    }
+    meta.pages = pages;
+    await atomicWrite(metaPath, `${JSON.stringify(meta, null, 2)}
+`);
+    return { ok: true };
+  });
+  fastify.post("/api/reorder-tasks", async (req, reply) => {
+    const parsed = reorderTasksBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body" });
+    }
+    const { feature, pages } = parsed.data;
+    const metaPath = setMetaPath(projectRoot, featuresDir, feature);
+    if (!await fileExists(metaPath)) {
+      return reply.code(404).send({ error: "feature_not_found" });
+    }
+    const raw = await readText(metaPath);
+    let meta;
+    try {
+      meta = JSON.parse(raw);
+    } catch {
+      return reply.code(500).send({ error: "invalid_meta" });
+    }
+    const currentSet = new Set(Array.isArray(meta.pages) ? meta.pages : []);
+    const newSet = new Set(pages);
+    if (currentSet.size !== newSet.size || [...currentSet].some((s) => !newSet.has(s))) {
+      return reply.code(400).send({ error: "invalid_pages" });
+    }
+    meta.pages = pages;
+    await atomicWrite(metaPath, `${JSON.stringify(meta, null, 2)}
+`);
+    return { ok: true };
+  });
+  fastify.post("/api/run-agent", async (req, reply) => {
+    const parsed = runAgentBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body" });
+    }
+    const fresh = await readConfigFile(projectRoot).catch(() => config);
+    const result = await runAgent(parsed.data, fresh, projectRoot);
+    if (result.ok) return { ok: true };
+    return reply.code(result.status).send({
+      error: result.error,
+      ..."detail" in result ? { detail: result.detail } : {},
+      ..."hint" in result ? { hint: result.hint } : {}
+    });
+  });
+  fastify.post("/api/run-refinement", async (req, reply) => {
+    const parsed = runRefinementBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", detail: parsed.error.message });
+    }
+    const fresh = await readConfigFile(projectRoot).catch(() => config);
+    const result = runRefinement(parsed.data.prompt, fresh, projectRoot);
+    if (result.ok) return { ok: true };
+    return reply.code(result.status).send({
+      error: result.error,
+      ..."detail" in result ? { detail: result.detail } : {},
+      ..."hint" in result ? { hint: result.hint } : {}
+    });
+  });
+  fastify.post("/api/run-discovery-agent", async (req, reply) => {
+    const parsed = runDiscoveryAgentBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", detail: parsed.error.message });
+    }
+    const fresh = await readConfigFile(projectRoot).catch(() => config);
+    const result = runDiscoveryAgent(parsed.data.prompt, fresh, projectRoot);
+    if (result.ok) return { ok: true };
+    return reply.code(result.status).send({
+      error: result.error,
+      ..."detail" in result ? { detail: result.detail } : {},
+      ..."hint" in result ? { hint: result.hint } : {}
+    });
+  });
+  fastify.post("/api/run-drawing-agent", async (req, reply) => {
+    const parsed = runDrawingAgentBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", detail: parsed.error.message });
+    }
+    const fresh = await readConfigFile(projectRoot).catch(() => config);
+    const result = runDrawingAgent(parsed.data.prompt, fresh, projectRoot);
+    if (result.ok) return { ok: true };
+    return reply.code(result.status).send({
+      error: result.error,
+      ..."detail" in result ? { detail: result.detail } : {},
+      ..."hint" in result ? { hint: result.hint } : {}
+    });
+  });
+  fastify.put("/api/content", async (req, reply) => {
+    const parsed = updateContentBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", detail: parsed.error.message });
+    }
+    const { feature, task, body } = parsed.data;
+    let taskPath;
+    try {
+      taskPath = setTaskPath(projectRoot, featuresDir, feature, task);
+    } catch {
+      return reply.code(400).send({ error: "invalid_path" });
+    }
+    if (!await fileExists(taskPath)) {
+      return reply.code(404).send({ error: "task_not_found" });
+    }
+    await atomicWrite(taskPath, body);
+    return { ok: true };
+  });
+  fastify.delete("/api/task", async (req, reply) => {
+    const parsed = deleteTaskQuerySchema.safeParse(req.query);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_query" });
+    }
+    const { feature, task } = parsed.data;
+    let taskPath;
+    let featureMetaPath;
+    try {
+      taskPath = setTaskPath(projectRoot, featuresDir, feature, task);
+      featureMetaPath = setMetaPath(projectRoot, featuresDir, feature);
+    } catch {
+      return reply.code(400).send({ error: "invalid_path" });
+    }
+    if (await fileExists(taskPath)) {
+      await unlink(taskPath);
+    }
+    if (await fileExists(featureMetaPath)) {
+      const raw = await readText(featureMetaPath);
+      try {
+        const meta = JSON.parse(raw);
+        if (Array.isArray(meta.pages)) {
+          const filtered = meta.pages.filter((p2) => p2 !== task);
+          if (filtered.length !== meta.pages.length) {
+            meta.pages = filtered;
+            await atomicWrite(featureMetaPath, `${JSON.stringify(meta, null, 2)}
+`);
+          }
+        }
+      } catch {
+      }
+    }
+    return { ok: true };
+  });
+  fastify.delete("/api/feature", async (req, reply) => {
+    const parsed = deleteFeatureQuerySchema.safeParse(req.query);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_query" });
+    }
+    const { feature } = parsed.data;
+    const featureDir = path14.resolve(projectRoot, featuresDir, feature);
+    try {
+      assertInsideProject(featureDir, projectRoot);
+    } catch {
+      return reply.code(400).send({ error: "invalid_path" });
+    }
+    if (await dirExists(featureDir)) {
+      await rm3(featureDir, { recursive: true, force: true });
+    }
+    const rootMetaPath2 = setMetaPath(projectRoot, featuresDir);
+    if (await fileExists(rootMetaPath2)) {
+      const raw = await readText(rootMetaPath2);
+      try {
+        const meta = JSON.parse(raw);
+        if (Array.isArray(meta.pages)) {
+          const filtered = meta.pages.filter((p2) => p2 !== feature);
+          if (filtered.length !== meta.pages.length) {
+            meta.pages = filtered;
+            await atomicWrite(rootMetaPath2, `${JSON.stringify(meta, null, 2)}
+`);
+          }
+        }
+      } catch {
+      }
+    }
+    return { ok: true };
+  });
+  fastify.get("/api/discovery/content", async (req, reply) => {
+    const parsed = discoveryContentQuerySchema.safeParse(req.query);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_query" });
+    }
+    const { slug } = parsed.data;
+    let discoveryPath;
+    try {
+      discoveryPath = setDiscoveryPath(projectRoot, discoveriesDir, slug);
+    } catch {
+      return reply.code(400).send({ error: "invalid_path" });
+    }
+    if (!await fileExists(discoveryPath)) {
+      return reply.code(404).send({ error: "discovery_not_found" });
+    }
+    const raw = await readText(discoveryPath);
+    const { data, body } = parseFrontmatter(raw);
+    const frontmatter = {
+      ...data,
+      ...extractDiscoveryFrontmatterFields(data)
+    };
+    const headings = extractHeadings(body);
+    return { frontmatter, body, headings, raw };
+  });
+  fastify.put("/api/discovery/content", async (req, reply) => {
+    const parsed = updateDiscoveryContentBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", detail: parsed.error.message });
+    }
+    const { slug, body } = parsed.data;
+    let discoveryPath;
+    try {
+      discoveryPath = setDiscoveryPath(projectRoot, discoveriesDir, slug);
+    } catch {
+      return reply.code(400).send({ error: "invalid_path" });
+    }
+    if (!await fileExists(discoveryPath)) {
+      return reply.code(404).send({ error: "discovery_not_found" });
+    }
+    await atomicWrite(discoveryPath, body);
+    return { ok: true };
+  });
+  fastify.delete("/api/discovery", async (req, reply) => {
+    const parsed = deleteDiscoveryQuerySchema.safeParse(req.query);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_query" });
+    }
+    const { slug } = parsed.data;
+    let discoveryPath;
+    let discoveryMetaPath;
+    try {
+      discoveryPath = setDiscoveryPath(projectRoot, discoveriesDir, slug);
+      discoveryMetaPath = setDiscoveryMetaPath(projectRoot, discoveriesDir);
+    } catch {
+      return reply.code(400).send({ error: "invalid_path" });
+    }
+    if (await fileExists(discoveryPath)) {
+      await unlink(discoveryPath);
+    }
+    if (await fileExists(discoveryMetaPath)) {
+      const raw = await readText(discoveryMetaPath);
+      try {
+        const meta = JSON.parse(raw);
+        if (Array.isArray(meta.pages)) {
+          const filtered = meta.pages.filter((p2) => p2 !== slug);
+          if (filtered.length !== meta.pages.length) {
+            meta.pages = filtered;
+            await atomicWrite(discoveryMetaPath, `${JSON.stringify(meta, null, 2)}
+`);
+          }
+        }
+      } catch {
+      }
+    }
+    return { ok: true };
+  });
+  fastify.post("/api/reorder-discoveries", async (req, reply) => {
+    const parsed = reorderDiscoveriesBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body" });
+    }
+    const { pages } = parsed.data;
+    const metaPath = setDiscoveryMetaPath(projectRoot, discoveriesDir);
+    if (!await fileExists(metaPath)) {
+      return reply.code(404).send({ error: "discoveries_meta_not_found" });
+    }
+    const raw = await readText(metaPath);
+    let meta;
+    try {
+      meta = JSON.parse(raw);
+    } catch {
+      return reply.code(500).send({ error: "invalid_meta" });
+    }
+    const currentSet = new Set(Array.isArray(meta.pages) ? meta.pages : []);
+    const newSet = new Set(pages);
+    if (currentSet.size !== newSet.size || [...currentSet].some((s) => !newSet.has(s))) {
+      return reply.code(400).send({ error: "invalid_pages" });
+    }
+    meta.pages = pages;
+    await atomicWrite(metaPath, `${JSON.stringify(meta, null, 2)}
+`);
+    return { ok: true };
+  });
+  fastify.get("/api/drawing/content", async (req, reply) => {
+    const parsed = drawingContentQuerySchema.safeParse(req.query);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_query" });
+    }
+    let drawingPath;
+    try {
+      drawingPath = setDrawingPath(projectRoot, drawingsDir, parsed.data.slug);
+    } catch {
+      return reply.code(400).send({ error: "invalid_path" });
+    }
+    if (!await fileExists(drawingPath)) {
+      return reply.code(404).send({ error: "drawing_not_found" });
+    }
+    const raw = await readText(drawingPath);
+    const { data, body } = parseFrontmatter(raw);
+    const frontmatter = {
+      ...data,
+      ...extractDrawingFrontmatterFields(data)
+    };
+    const headings = extractHeadings(body);
+    return { frontmatter, body, headings, raw };
+  });
+  fastify.put("/api/drawing/content", async (req, reply) => {
+    const parsed = updateDrawingContentBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body", detail: parsed.error.message });
+    }
+    const { slug, body } = parsed.data;
+    let drawingPath;
+    try {
+      drawingPath = setDrawingPath(projectRoot, drawingsDir, slug);
+    } catch {
+      return reply.code(400).send({ error: "invalid_path" });
+    }
+    if (!await fileExists(drawingPath)) {
+      return reply.code(404).send({ error: "drawing_not_found" });
+    }
+    await atomicWrite(drawingPath, body);
+    return { ok: true };
+  });
+  fastify.delete("/api/drawing", async (req, reply) => {
+    const parsed = deleteDrawingQuerySchema.safeParse(req.query);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_query" });
+    }
+    const { slug } = parsed.data;
+    let drawingPath;
+    let drawingMetaPath;
+    try {
+      drawingPath = setDrawingPath(projectRoot, drawingsDir, slug);
+      drawingMetaPath = setDrawingMetaPath(projectRoot, drawingsDir);
+    } catch {
+      return reply.code(400).send({ error: "invalid_path" });
+    }
+    if (await fileExists(drawingPath)) {
+      await unlink(drawingPath);
+    }
+    if (await fileExists(drawingMetaPath)) {
+      const raw = await readText(drawingMetaPath);
+      try {
+        const meta = JSON.parse(raw);
+        if (Array.isArray(meta.pages)) {
+          const filtered = meta.pages.filter((p2) => p2 !== slug);
+          if (filtered.length !== meta.pages.length) {
+            meta.pages = filtered;
+            await atomicWrite(drawingMetaPath, `${JSON.stringify(meta, null, 2)}
+`);
+          }
+        }
+      } catch {
+      }
+    }
+    return { ok: true };
+  });
+  fastify.post("/api/reorder-drawings", async (req, reply) => {
+    const parsed = reorderDrawingsBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body" });
+    }
+    const { pages } = parsed.data;
+    const metaPath = setDrawingMetaPath(projectRoot, drawingsDir);
+    if (!await fileExists(metaPath)) {
+      return reply.code(404).send({ error: "drawings_meta_not_found" });
+    }
+    const raw = await readText(metaPath);
+    let meta;
+    try {
+      meta = JSON.parse(raw);
+    } catch {
+      return reply.code(500).send({ error: "invalid_meta" });
+    }
+    const currentSet = new Set(Array.isArray(meta.pages) ? meta.pages : []);
+    const newSet = new Set(pages);
+    if (currentSet.size !== newSet.size || [...currentSet].some((s) => !newSet.has(s))) {
+      return reply.code(400).send({ error: "invalid_pages" });
+    }
+    meta.pages = pages;
+    await atomicWrite(metaPath, `${JSON.stringify(meta, null, 2)}
+`);
+    return { ok: true };
+  });
+  fastify.get("/api/prototype", async (req, reply) => {
+    const parsed = prototypeQuerySchema.safeParse(req.query);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_query" });
+    }
+    const fresh = await readConfigFile(projectRoot).catch(() => config);
+    const prototype = await resolvePrototype(projectRoot, fresh, parsed.data.feature);
+    return { prototype };
+  });
+  fastify.get("/api/prototype/frame", async (req, reply) => {
+    const parsed = prototypeQuerySchema.safeParse(req.query);
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_query" });
+    }
+    const fresh = await readConfigFile(projectRoot).catch(() => config);
+    const prototype = await resolvePrototype(projectRoot, fresh, parsed.data.feature);
+    if (!prototype) return reply.code(404).send({ error: "no_prototype" });
+    const abs = snapshotAbsolutePath(projectRoot, prototype);
+    if (!abs) return reply.code(404).send({ error: "no_snapshot" });
+    const html = await readText(abs);
+    return reply.type("text/html; charset=utf-8").header("cache-control", "no-store").send(html);
+  });
+  fastify.post("/api/prototype/open", async (req, reply) => {
+    const parsed = prototypeQuerySchema.safeParse(req.body ?? {});
+    if (!parsed.success) {
+      return reply.code(400).send({ error: "invalid_body" });
+    }
+    const fresh = await readConfigFile(projectRoot).catch(() => config);
+    const prototype = await resolvePrototype(projectRoot, fresh, parsed.data.feature);
+    if (!prototype) return reply.code(404).send({ error: "no_prototype" });
+    const result = openPrototype(projectRoot, prototype);
+    if (result.ok) return result;
+    return reply.code(result.status).send(result);
+  });
+  fastify.get("/api/events", async (req, reply) => {
+    reply.raw.setHeader("content-type", "text/event-stream");
+    reply.raw.setHeader("cache-control", "no-cache, no-transform");
+    reply.raw.setHeader("connection", "keep-alive");
+    reply.raw.setHeader("x-accel-buffering", "no");
+    reply.raw.flushHeaders?.();
+    reply.raw.write(`data: ${JSON.stringify({ type: "hello", watching: watcher.watching })}
+
+`);
+    const keepAlive = setInterval(() => {
+      reply.raw.write(": ping\n\n");
+    }, 15e3);
+    const unsubscribe = watcher.subscribe((events) => {
+      reply.raw.write(`data: ${JSON.stringify({ type: "change", events })}
+
+`);
+    });
+    req.raw.on("close", () => {
+      clearInterval(keepAlive);
+      unsubscribe();
+    });
+    return reply;
+  });
+  fastify.get("/api/usage", async (_req, reply) => {
+    return reply.send({ usage: await readClaudeUsage() });
+  });
+  fastify.get("/api/config", async (_req, reply) => {
+    try {
+      const fresh = await readConfigFile(projectRoot);
+      return { config: fresh, projectRoot };
+    } catch (err) {
+      return reply.code(500).send({ error: "invalid_config", detail: err.message });
+    }
+  });
+  fastify.get("/health", async () => ({ ok: true }));
+  const host = "127.0.0.1";
+  const port = config.port;
+  await fastify.listen({ host, port });
+  return {
+    url: `http://localhost:${port}`,
+    port,
+    close: async () => {
+      watcher.close();
+      await jobManager.shutdownAll();
+      await fastify.close();
+    }
+  };
+}
+
+// src/commands/start.ts
+import open from "open";
+import pc2 from "picocolors";
+var stateFile = (projectRoot) => path15.join(runDir(projectRoot), "specs.json");
+var logFile = (projectRoot) => path15.join(runDir(projectRoot), "specs.log");
+async function runStart(opts) {
+  const config = await readConfig(opts.projectRoot);
+  const port = opts.port ?? config.port ?? 4321;
+  const url = `http://localhost:${port}`;
+  if (opts.foreground) {
+    await startForeground(opts, { ...config, port }, url);
+    return;
+  }
+  const running = await readRunningState(opts.projectRoot);
+  if (running) {
+    log.success(`specs j\xE1 est\xE1 rodando (pid ${running.pid})`);
+    printUrls(running.url, opts.projectRoot);
+    return;
+  }
+  if (await isPortInUse(port)) {
+    throw new Error(
+      `a porta ${port} j\xE1 est\xE1 em uso (outra inst\xE2ncia? veja \`lsof -i :${port}\`). Use \`specs start -p <porta>\`.`
+    );
+  }
+  await mkdir3(runDir(opts.projectRoot), { recursive: true });
+  const out = openSync(logFile(opts.projectRoot), "w");
+  const args = [cliEntry, "start", "--foreground", "--no-open", "--port", String(port)];
+  if (opts.apiOnly) args.push("--api-only");
+  const child = spawn5(process.execPath, args, {
+    cwd: opts.projectRoot,
+    detached: true,
+    stdio: ["ignore", out, out]
+  });
+  child.unref();
+  if (!child.pid) throw new Error("n\xE3o foi poss\xEDvel iniciar o processo em background.");
+  const state = { pid: child.pid, url, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeFile4(stateFile(opts.projectRoot), `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  const ready = await waitForPort(port, 15e3, () => isAlive(state.pid));
+  if (!ready) {
+    await rm4(stateFile(opts.projectRoot), { force: true });
+    const tail = (await readFile9(logFile(opts.projectRoot), "utf8")).split("\n").slice(-30).join("\n");
+    throw new Error(`o servidor n\xE3o subiu. \xDAltimas linhas do log:
+${tail}`);
+  }
+  log.success(`specs iniciado em background (pid ${state.pid})`);
+  printUrls(url, opts.projectRoot);
+  if (opts.openBrowser && !opts.apiOnly) await open(url).catch(() => {
+  });
+}
+async function runStop(projectRoot) {
+  const state = await readState(projectRoot);
+  if (!state) {
+    log.kept("specs n\xE3o est\xE1 rodando em background neste projeto.");
+    return;
+  }
+  if (isAlive(state.pid)) {
+    process.kill(state.pid, "SIGTERM");
+    for (let i = 0; i < 50 && isAlive(state.pid); i++) await sleep(100);
+    if (isAlive(state.pid)) process.kill(state.pid, "SIGKILL");
+  }
+  await rm4(stateFile(projectRoot), { force: true });
+  log.success(`specs parado (pid ${state.pid})`);
+}
+async function runStatus(projectRoot) {
+  const running = await readRunningState(projectRoot);
+  if (!running) {
+    log.kept("specs n\xE3o est\xE1 rodando em background neste projeto.");
+    return;
+  }
+  log.success(`specs rodando (pid ${running.pid}, desde ${running.startedAt})`);
+  printUrls(running.url, projectRoot);
+}
+async function startForeground(opts, config, url) {
+  const server = await startServer(config, {
+    projectRoot: opts.projectRoot,
+    uiDir: opts.apiOnly ? void 0 : uiDir
+  });
+  log.title(`specs \u2014 ${opts.projectRoot}`);
+  console.log(
+    `${pc2.green("\u2713")} ${opts.apiOnly ? "API" : "UI + API"}: ${pc2.bold(pc2.cyan(server.url))}`
+  );
+  console.log(pc2.dim("Pressione Ctrl+C para encerrar."));
+  if (opts.openBrowser && !opts.apiOnly) await open(url).catch(() => {
+  });
+  let closing = false;
+  const shutdown = async () => {
+    if (closing) return;
+    closing = true;
+    await server.close().catch(() => {
+    });
+    process.exit(0);
+  };
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(signal, () => void shutdown());
+  }
+}
+async function readConfig(projectRoot) {
+  const configPath = path15.join(projectRoot, ".specs", "config.json");
+  if (!await exists(configPath)) {
+    throw new Error(
+      ".specs/config.json n\xE3o encontrado. Rode `specs install` na raiz do projeto antes."
+    );
+  }
+  return JSON.parse(await readFile9(configPath, "utf8"));
+}
+async function readState(projectRoot) {
+  try {
+    return JSON.parse(await readFile9(stateFile(projectRoot), "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function readRunningState(projectRoot) {
+  const state = await readState(projectRoot);
+  if (!state) return null;
+  if (isAlive(state.pid)) return state;
+  await rm4(stateFile(projectRoot), { force: true });
+  return null;
+}
+function printUrls(url, projectRoot) {
+  console.log(`  UI:   ${pc2.cyan(url)}`);
+  console.log(
+    `  logs: ${path15.relative(process.cwd(), logFile(projectRoot)) || logFile(projectRoot)}`
+  );
+  console.log("  stop: specs stop");
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function tryConnect(host, port) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ host, port });
+    const finish = (ok) => {
+      socket.destroy();
+      resolve(ok);
+    };
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    socket.setTimeout(1e3, () => finish(false));
+  });
+}
+async function waitForPort(port, timeoutMs, alive) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs && alive()) {
+    if (await isPortInUse(port)) return true;
+    await sleep(250);
+  }
+  return false;
+}
+async function isPortInUse(port) {
+  const [v4, v6] = await Promise.all([tryConnect("127.0.0.1", port), tryConnect("::1", port)]);
+  return v4 || v6;
+}
+
+// src/tool.ts
+import { readFileSync as readFileSync2 } from "fs";
+import path16 from "path";
+import * as p from "@clack/prompts";
+var pkg = JSON.parse(readFileSync2(path16.join(packageRoot, "package.json"), "utf8"));
+function register(cmd) {
+  cmd.command("install").alias("update").description(
+    "Instala ou atualiza a Specs Platform no projeto (.agents/, .specs/, symlinks, SPECS.md)."
+  ).argument("[dir]", "Raiz do projeto.", ".").option("-f, --force", "Sobrescreve tamb\xE9m config, project.md, SPECS.md e scaffolds.", false).option("--clean-legacy", "Remove o .specs/app/ de instala\xE7\xF5es antigas.", false).action(async (dir, opts) => {
+    await runInstall({
+      projectRoot: path16.resolve(dir),
+      force: opts.force,
+      cleanLegacy: opts.cleanLegacy
+    });
+  });
+  cmd.command("start").description("Sobe a UI + API (background por default) e abre o browser.").option("-f, --foreground", "Roda em foreground (Ctrl+C para parar).", false).option("-p, --port <port>", "Porta (default: `port` do .specs/config.json).").option("--no-open", "N\xE3o abre o browser.").option("--api-only", "S\xF3 a API, sem a UI (para desenvolver a UI com o Vite).", false).action(
+    async (opts) => {
+      await runStart({
+        projectRoot: process.cwd(),
+        foreground: opts.foreground,
+        port: opts.port ? Number.parseInt(opts.port, 10) : void 0,
+        openBrowser: opts.open,
+        apiOnly: opts.apiOnly
+      });
+    }
+  );
+  cmd.command("stop").description("Para a inst\xE2ncia em background deste projeto.").action(() => runStop(process.cwd()));
+  cmd.command("status").description("Mostra se a inst\xE2ncia em background deste projeto est\xE1 rodando.").action(() => runStatus(process.cwd()));
+  cmd.command("statusline").description("Mostra como plugar o medidor de uso do plano no statusLine do Claude Code.").action(() => printStatusline());
+}
+function printStatusline() {
+  console.log(
+    "Adicione em ~/.claude/settings.json (troque o argumento pelo seu statusLine atual, ou remova):\n"
+  );
+  console.log(
+    JSON.stringify(
+      {
+        statusLine: {
+          type: "command",
+          command: `bash ${statuslineScript} ~/.claude/statusline-command.sh`
+        }
+      },
+      null,
+      2
+    )
+  );
+}
+async function interactiveInstall(cwd) {
+  const dir = await p.text({ message: "Diret\xF3rio do projeto", initialValue: cwd });
+  if (p.isCancel(dir)) return;
+  const projectRoot = path16.resolve(dir);
+  let force = false;
+  if (await exists(path16.join(projectRoot, ".specs", "config.json"))) {
+    const mode = await p.select({
+      message: "A Specs Platform j\xE1 est\xE1 instalada aqui. O que fazer?",
+      options: [
+        {
+          value: "update",
+          label: "Atualizar",
+          hint: "regrava agents/skills, preserva suas customiza\xE7\xF5es"
+        },
+        {
+          value: "force",
+          label: "Reinstalar do zero",
+          hint: "sobrescreve config, project.md e SPECS.md"
+        }
+      ]
+    });
+    if (p.isCancel(mode)) return;
+    force = mode === "force";
+  }
+  let cleanLegacy = false;
+  if (await exists(path16.join(projectRoot, ".specs", "app"))) {
+    const answer = await p.confirm({
+      message: "Encontrei .specs/app/ de uma instala\xE7\xE3o antiga (n\xE3o \xE9 mais usado). Remover?"
+    });
+    if (p.isCancel(answer)) return;
+    cleanLegacy = answer;
+  }
+  await runInstall({ projectRoot, force, cleanLegacy });
+}
+var specsPlatformTool = defineTool({
+  id: "specs-platform",
+  packageName: pkg.name,
+  title: "Specs Platform",
+  description: pkg.description,
+  version: pkg.version,
+  register,
+  actions: [
+    {
+      id: "install",
+      label: "Instalar / atualizar no projeto",
+      run: ({ cwd }) => interactiveInstall(cwd)
+    },
+    {
+      id: "start",
+      label: "Subir a UI",
+      hint: "background",
+      run: ({ cwd }) => runStart({ projectRoot: cwd, foreground: false, openBrowser: true })
+    },
+    { id: "stop", label: "Parar a UI", run: ({ cwd }) => runStop(cwd) },
+    {
+      id: "statusline",
+      label: "Configurar medidor de uso do Claude",
+      run: async () => printStatusline()
+    }
+  ]
+});
+
+export {
+  log,
+  runInstall,
+  runStart,
+  runStop,
+  runStatus,
+  specsPlatformTool
+};
+//# sourceMappingURL=chunk-SOOETS3N.js.map