@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-server-7IERLVXE.mjs

@@ -0,0 +1,2925 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  exportWorkflow
+} from "./flow-weaver-chunk-54M4KNEL.mjs";
+import {
+  ERROR_HINTS
+} from "./flow-weaver-chunk-KOEMJHLG.mjs";
+import {
+  loadPackDocTopics
+} from "./flow-weaver-chunk-J7EPZW2I.mjs";
+import {
+  DebugController
+} from "./flow-weaver-chunk-FPPPU2DG.mjs";
+import {
+  ARTIFACT_KINDS,
+  renderArtifact
+} from "./flow-weaver-chunk-Z5ZJPNSY.mjs";
+import {
+  WorkflowDiffer,
+  getImpactReasons
+} from "./flow-weaver-chunk-7ET6N32V.mjs";
+import {
+  buildProcessModel,
+  stepLabel
+} from "./flow-weaver-chunk-HMAKDE55.mjs";
+import {
+  getPackDocTopics,
+  listTopics,
+  readTopic,
+  readTopicStructured,
+  searchDocs
+} from "./flow-weaver-chunk-XG2WKXYZ.mjs";
+import {
+  generateManifest,
+  readManifest
+} from "./flow-weaver-chunk-AA3NATMX.mjs";
+import {
+  validatePackage
+} from "./flow-weaver-chunk-2C7PZCV5.mjs";
+import {
+  RESERVED_PATHS,
+  gateOutputSchemas,
+  isLoopback,
+  planRoutes,
+  workflowParamsSchema
+} from "./flow-weaver-chunk-MHJ4N652.mjs";
+import {
+  answerAgentGate,
+  computeBundleDigest,
+  createFileEffectAdapter,
+  createLocalCoordinator,
+  defaultRunsDir,
+  isAnswering,
+  noteAnswerMisfit,
+  reclaimStaleAgentAnswers,
+  transcriptName,
+  tryProfile
+} from "./flow-weaver-chunk-YLSRZWFK.mjs";
+import "./flow-weaver-chunk-EKWF27G6.mjs";
+import {
+  DEFAULT_MODEL,
+  STARTER_AGENTS_YAML,
+  SUGGESTED_MODELS,
+  agentsFile,
+  keyEnvOf,
+  loadAgentProfiles,
+  readiness,
+  saveAgentProfiles,
+  validateProfile
+} from "./flow-weaver-chunk-TS5P3PIN.mjs";
+import {
+  executeWorkflow
+} from "./flow-weaver-chunk-GBUNNP33.mjs";
+import {
+  getAvailableWorkflows
+} from "./flow-weaver-chunk-NQKKWDGF.mjs";
+import "./flow-weaver-chunk-V6DHWFQG.mjs";
+import {
+  createTargetRegistry
+} from "./flow-weaver-chunk-3MKUQP3D.mjs";
+import {
+  runDoctorChecks
+} from "./flow-weaver-chunk-U3EO3X4B.mjs";
+import {
+  installRoot,
+  isAlive,
+  listServices
+} from "./flow-weaver-chunk-MSI2UJES.mjs";
+import "./flow-weaver-chunk-3BSYCWPL.mjs";
+import {
+  listInstalledPackages,
+  resolveRegistries,
+  searchAllRegistries
+} from "./flow-weaver-chunk-4DVY73ML.mjs";
+import {
+  validateWorkflow
+} from "./flow-weaver-chunk-ZQALO25T.mjs";
+import "./flow-weaver-chunk-DM4BBRRU.mjs";
+import "./flow-weaver-chunk-6ZUJ7LMX.mjs";
+import "./flow-weaver-chunk-A6M5K3W7.mjs";
+import {
+  parseWorkflow
+} from "./flow-weaver-chunk-W3YNK26P.mjs";
+import "./flow-weaver-chunk-BHCC5FE5.mjs";
+import {
+  VERSION
+} from "./flow-weaver-chunk-VXWNLYQU.mjs";
+import "./flow-weaver-chunk-RIWE7YTR.mjs";
+import "./flow-weaver-chunk-IJJ4JXTL.mjs";
+import "./flow-weaver-chunk-55QMUZIA.mjs";
+import "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import {
+  getTopologicalOrder
+} from "./flow-weaver-chunk-Z44JK332.mjs";
+import {
+  hasInPlaceMarkers,
+  httpRouteText,
+  isConnectionCoveredByMacroStatic
+} from "./flow-weaver-chunk-APX6MQ5A.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import "./flow-weaver-chunk-GAQXZHNO.mjs";
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+
+// src/console/server.ts
+import * as http from "node:http";
+import * as fs13 from "node:fs";
+import * as path13 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/console/services.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as path2 from "node:path";
+
+// src/console/cli-run.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var NOT_FROM_CONSOLE = /* @__PURE__ */ new Set([
+  "console",
+  "mcp-server",
+  "mcp-setup",
+  "dev",
+  "watch",
+  "serve"
+]);
+function planFwCommand(argv) {
+  const args = argv[0] === "fw" || argv[0] === "flow-weaver" ? argv.slice(1) : [...argv];
+  if (!args.length) return { ok: false, error: "nothing to run" };
+  if (args.some((a) => typeof a !== "string")) return { ok: false, error: "arguments must be strings" };
+  const command = args[0];
+  if (NOT_FROM_CONSOLE.has(command)) {
+    return { ok: false, error: `\`fw ${command}\` runs outside the console: it is long-lived. Use a terminal.` };
+  }
+  return { ok: true, args };
+}
+function resolveCliEntry(here = path.dirname(fileURLToPath(import.meta.url))) {
+  const built = path.join(here, "..", "cli", "flow-weaver.mjs");
+  if (fs.existsSync(built)) return { exec: process.execPath, prefix: [built] };
+  const source = path.join(here, "..", "cli", "index.ts");
+  if (fs.existsSync(source)) return { exec: process.execPath, prefix: ["--import", "tsx", source] };
+  throw new Error("cannot find the fw CLI beside the console");
+}
+function spawnFw(args, cwd) {
+  const { exec, prefix } = resolveCliEntry();
+  const { NODE_OPTIONS: _flags, ...env } = process.env;
+  return spawn(exec, [...prefix, ...args], {
+    cwd,
+    env: { ...env, FORCE_COLOR: "0", NO_COLOR: "1" },
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+}
+
+// src/console/services.ts
+var DEFAULT_SETTINGS = {
+  serve: { port: 3e3, host: "127.0.0.1", auth: "token", agents: true, trace: true, dev: false, swagger: false, autoStart: false },
+  watch: { autoStart: false }
+};
+var MAX_LINES = 500;
+var STOP_GRACE_MS = 5e3;
+function consoleSettingsDir() {
+  return process.env.FW_CONSOLE_DIR ?? path2.join(os.homedir(), ".fw", "console");
+}
+function spawnFwWith(args, cwd, env) {
+  const { exec, prefix } = resolveCliEntry();
+  return spawn2(exec, [...prefix, ...args], { cwd, env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+}
+var Supervisor = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.projectDir = path2.resolve(opts.projectDir);
+    const dir = opts.settingsDir ?? consoleSettingsDir();
+    this.file = path2.join(dir, `${createHash("sha256").update(real(this.projectDir)).digest("hex").slice(0, 16)}.json`);
+  }
+  opts;
+  children = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  file;
+  cache;
+  projectDir;
+  // ---------------------------------------------------------- settings
+  settings() {
+    if (this.cache) return this.cache;
+    let stored;
+    try {
+      stored = JSON.parse(fs2.readFileSync(this.file, "utf8"));
+    } catch {
+      stored = {};
+    }
+    this.cache = {
+      serve: { ...DEFAULT_SETTINGS.serve, ...stored.serve ?? {} },
+      watch: { ...DEFAULT_SETTINGS.watch, ...stored.watch ?? {} }
+    };
+    return this.cache;
+  }
+  saveSettings(kind, patch) {
+    const current = this.settings();
+    const next = { ...current, [kind]: { ...current[kind], ...patch } };
+    if (kind === "serve") {
+      const s = next.serve;
+      if (!Number.isInteger(s.port) || s.port < 0 || s.port > 65535) throw new Error("port must be a whole number between 0 and 65535");
+      if (!/^[A-Za-z0-9.:[\]-]+$/.test(s.host)) throw new Error("host must be a host name or an address");
+      if (s.auth !== "token" && s.auth !== "open") throw new Error("auth is token or open");
+      if (s.auth === "open" && !["127.0.0.1", "localhost", "::1", "[::1]"].includes(s.host)) throw new Error("a server beyond loopback needs a token: set auth to token, or host to 127.0.0.1");
+    }
+    fs2.mkdirSync(path2.dirname(this.file), { recursive: true });
+    const tmp = `${this.file}.${process.pid}.tmp`;
+    fs2.writeFileSync(tmp, JSON.stringify(next, null, 2));
+    fs2.renameSync(tmp, this.file);
+    this.cache = next;
+    return next;
+  }
+  // ------------------------------------------------------------ control
+  /** Start a service with the saved settings. A running one is left alone. */
+  start(kind) {
+    const existing = this.children.get(kind);
+    if (existing && (existing.state === "running" || existing.state === "starting")) return this.view(kind);
+    const others = this.registryFor(kind);
+    if (kind === "serve" && others.length) throw new Error(`fw serve is already running for this project (pid ${others[0].pid}${others[0].url ? `, ${others[0].url}` : ""}). Stop it first`);
+    const settings = this.settings();
+    const { NODE_OPTIONS: _flags, ...base } = process.env;
+    const env = { ...base, FORCE_COLOR: "0", NO_COLOR: "1" };
+    let args;
+    let token;
+    if (kind === "serve") {
+      const s = settings.serve;
+      args = ["serve", this.projectDir, "--port", String(s.port), "--host", s.host];
+      if (s.auth === "token") {
+        token = randomBytes(24).toString("hex");
+        env.FW_SERVE_TOKEN = token;
+      } else {
+        delete env.FW_SERVE_TOKEN;
+        if (!["127.0.0.1", "localhost", "::1", "[::1]"].includes(s.host)) args.push("--insecure");
+      }
+      if (!s.agents) args.push("--no-agents");
+      if (s.trace) args.push("--trace");
+      if (s.dev) args.push("--dev");
+      if (s.swagger) args.push("--swagger");
+    } else {
+      args = ["watch", this.projectDir];
+    }
+    const proc = (this.opts.spawn ?? spawnFwWith)(args, this.projectDir, env);
+    const child = { kind, proc, state: "starting", startedAt: (/* @__PURE__ */ new Date()).toISOString(), token, lines: [] };
+    this.children.set(kind, child);
+    if (kind === "watch") child.state = "running";
+    const onData = (stream) => (chunk) => {
+      for (const raw of chunk.toString().split(/\r?\n/)) {
+        if (!raw.trim()) continue;
+        const line = { t: Date.now(), stream, text: raw };
+        child.lines.push(line);
+        if (child.lines.length > MAX_LINES) child.lines.splice(0, child.lines.length - MAX_LINES);
+        const listening = /Listening:\s*(https?:\/\/\S+)/.exec(raw);
+        if (listening && child.state === "starting") {
+          child.state = "running";
+          child.url = listening[1];
+          this.opts.onChange?.({ kind, state: "running", url: child.url });
+        }
+        for (const fn of this.listeners.get(kind) ?? []) fn(line);
+        this.opts.onChange?.({ kind, state: child.state, line });
+      }
+    };
+    proc.stdout?.on("data", onData("out"));
+    proc.stderr?.on("data", onData("err"));
+    proc.on("error", (err) => {
+      child.state = "exited";
+      child.error = err.message;
+      this.opts.onChange?.({ kind, state: "exited", error: err.message });
+    });
+    proc.on("close", (code) => {
+      if (child.state === "exited") return;
+      child.state = "exited";
+      child.exitCode = code;
+      const lastErr = [...child.lines].reverse().find((l) => l.stream === "err")?.text;
+      if (code && code !== 0 && !child.stopping) child.error = lastErr ?? `exited with code ${code}`;
+      this.opts.onChange?.({ kind, state: "exited", exitCode: code, error: child.error });
+    });
+    this.opts.onChange?.({ kind, state: child.state });
+    return this.view(kind);
+  }
+  /** Stop our child of this kind, or another process of this kind for the project by pid. */
+  async stop(kind, pid) {
+    const child = this.children.get(kind);
+    if (child && (pid === void 0 || child.proc.pid === pid) && child.state !== "exited") {
+      child.stopping = true;
+      await terminate(child.proc);
+      return this.view(kind);
+    }
+    if (pid !== void 0) {
+      const other = this.registryFor(kind).find((r) => r.pid === pid);
+      if (!other) throw new Error(`no ${kind} with pid ${pid} for this project`);
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch (e) {
+        throw new Error(`could not stop pid ${pid}: ${e.message}`, { cause: e });
+      }
+      const end = Date.now() + STOP_GRACE_MS;
+      while (Date.now() < end && isAlive(pid)) await sleep(100);
+      if (isAlive(pid)) {
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+    return this.view(kind);
+  }
+  async restart(kind) {
+    await this.stop(kind);
+    return this.start(kind);
+  }
+  /** Stop every child; called when the console closes. */
+  async close() {
+    await Promise.all([...this.children.values()].filter((c) => c.state !== "exited").map((c) => {
+      c.stopping = true;
+      return terminate(c.proc);
+    }));
+  }
+  // -------------------------------------------------------------- reading
+  logs(kind) {
+    return [...this.children.get(kind)?.lines ?? []];
+  }
+  /** Every new line as it arrives. Returns the unsubscribe. */
+  onLog(kind, fn) {
+    const set = this.listeners.get(kind) ?? this.listeners.set(kind, /* @__PURE__ */ new Set()).get(kind);
+    set.add(fn);
+    return () => {
+      set.delete(fn);
+    };
+  }
+  view(kind) {
+    const child = this.children.get(kind);
+    const records = this.registryFor(kind);
+    const mine = child && child.state !== "exited" ? records.find((r) => r.pid === child.proc.pid) : void 0;
+    const others = records.filter((r) => r.pid !== child?.proc.pid).map((r) => ({ pid: r.pid, url: r.url, startedAt: r.startedAt, version: r.version, install: r.install }));
+    const activity = (r) => r ? { count: r.activityCount, last: r.activity, at: r.lastActivityAt, version: r.version, install: r.install } : void 0;
+    if (child) {
+      return {
+        kind,
+        state: child.state,
+        owned: true,
+        pid: child.proc.pid,
+        url: child.url ?? mine?.url,
+        startedAt: child.startedAt,
+        exitCode: child.exitCode,
+        error: child.error,
+        lines: child.lines.length,
+        token: child.token,
+        activity: activity(mine),
+        others
+      };
+    }
+    const first = records[0];
+    return first ? { kind, state: "running", owned: false, pid: first.pid, url: first.url, startedAt: first.startedAt, lines: 0, activity: activity(first), others: others.filter((o) => o.pid !== first.pid) } : { kind, state: "stopped", owned: false, lines: 0, others: [] };
+  }
+  list() {
+    return ["serve", "watch"].map((k) => this.view(k));
+  }
+  registryFor(kind) {
+    const here = real(this.projectDir);
+    return listServices(this.opts.registryDir).filter((s) => s.kind === kind && real(s.project ?? s.cwd) === here);
+  }
+};
+var real = (p) => {
+  try {
+    return fs2.realpathSync(p);
+  } catch {
+    return path2.resolve(p);
+  }
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function terminate(proc) {
+  return new Promise((resolve9) => {
+    if (proc.exitCode !== null || proc.signalCode !== null) {
+      resolve9();
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+      }
+    }, STOP_GRACE_MS);
+    proc.once("close", () => {
+      clearTimeout(timer);
+      resolve9();
+    });
+    try {
+      proc.kill("SIGTERM");
+    } catch {
+      clearTimeout(timer);
+      resolve9();
+    }
+  });
+}
+
+// src/console/scan.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+
+// src/console/packs.ts
+function packNamespace(name) {
+  return name.replace(/^@[^/]+\//, "").replace(/^flow-weaver-pack-/, "");
+}
+var posix = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "");
+function packForFile(file, packs) {
+  const f = posix(file);
+  let best = null;
+  for (const p of packs) {
+    const root = posix(p.path);
+    if ((f === root || f.startsWith(`${root}/`)) && (!best || root.length > posix(best.path).length)) best = p;
+  }
+  return best?.name ?? null;
+}
+function packageOfSpecifier(specifier) {
+  const parts = specifier.split("/");
+  if (!parts[0] || parts[0].startsWith(".")) return null;
+  return parts[0].startsWith("@") ? parts[1] ? `${parts[0]}/${parts[1]}` : null : parts[0];
+}
+function packForSpecifier(specifier, packs) {
+  const name = specifier ? packageOfSpecifier(specifier) : null;
+  return name && packs.some((p) => p.name === name) ? name : null;
+}
+var refsCache = /* @__PURE__ */ new Map();
+async function installedRefs(projectDir) {
+  const hit = refsCache.get(projectDir);
+  if (hit && Date.now() - hit.at < 2e3) return hit.refs;
+  const refs = (await listInstalledPackages(projectDir)).map((p) => ({ name: p.name, path: p.path }));
+  refsCache.set(projectDir, { at: Date.now(), refs });
+  return refs;
+}
+var parse = (v) => {
+  const m = v.trim().match(/^v?(\d+)\.(\d+)\.(\d+)/);
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+};
+var cmp = (a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+function engineCompatible(range, version = VERSION) {
+  if (!range || range.trim() === "*") return true;
+  const have = parse(version);
+  const m = range.trim().match(/^(>=|\^|~)?\s*(v?\d+\.\d+\.\d+)$/);
+  const want = m ? parse(m[2]) : null;
+  if (!have || !want) return null;
+  const op = m[1] ?? "";
+  if (op === ">=") return cmp(have, want) >= 0;
+  if (op === "^") return want[0] === 0 ? have[0] === 0 && have[1] === want[1] && have[2] >= want[2] : have[0] === want[0] && cmp(have, want) >= 0;
+  if (op === "~") return have[0] === want[0] && have[1] === want[1] && have[2] >= want[2];
+  return cmp(have, want) === 0;
+}
+var CONTROL = /* @__PURE__ */ new Set(["execute", "onSuccess", "onFailure"]);
+var ports = (map) => Object.entries(map ?? {}).filter(([name]) => !CONTROL.has(name)).map(([name, p]) => ({ name, type: String(p.dataType).toLowerCase(), optional: !!p.optional, description: p.description ?? "" }));
+function describePack(pkg) {
+  const m = pkg.manifest;
+  const namespace = packNamespace(pkg.name);
+  return {
+    name: pkg.name,
+    namespace,
+    version: pkg.version,
+    path: pkg.path,
+    description: m.description ?? "",
+    engineVersion: m.engineVersion ?? null,
+    compatible: engineCompatible(m.engineVersion),
+    nodeTypes: (m.nodeTypes ?? []).map((n) => ({
+      name: n.name,
+      functionName: n.functionName,
+      description: n.description ?? "",
+      inputs: ports(n.inputs),
+      outputs: ports(n.outputs),
+      color: n.visuals?.color ?? null,
+      icon: n.visuals?.icon ?? null
+    })),
+    workflows: (m.workflows ?? []).map((w) => ({ name: w.name, description: w.description ?? "", params: ports(w.startPorts), returns: ports(w.exitPorts), nodes: w.nodeCount })),
+    exportTargets: (m.exportTargets ?? []).map((t) => ({ name: t.name, description: t.description ?? "" })),
+    tagHandlers: (m.tagHandlers ?? []).map((t) => ({ tags: t.tags, namespace: t.namespace, scope: t.scope })),
+    validationRuleSets: (m.validationRuleSets ?? []).map((r) => ({ name: r.name, namespace: r.namespace })),
+    docs: (m.docs ?? []).map((d) => ({ slug: d.slug, name: d.name, description: d.description ?? "" })),
+    // A pack with an entrypoint but no commands contributes none: the CLI skips it.
+    cliCommands: m.cliEntrypoint ? (m.cliCommands ?? []).map((c) => ({
+      name: c.name,
+      description: c.description,
+      usage: ["fw", namespace, c.name, ...c.arguments?.map((a) => a.syntax) ?? (c.usage ? [c.usage] : [])].join(" "),
+      flags: (c.options ?? []).map((o) => ({ flag: o.flags, description: o.description, default: o.default === void 0 ? "" : String(o.default) }))
+    })) : [],
+    mcpTools: m.mcpEntrypoint ? (m.mcpTools ?? []).map((t) => ({ name: t.name, description: t.description })) : []
+  };
+}
+async function describePacks(projectDir) {
+  const installed = await listInstalledPackages(projectDir);
+  return installed.map(describePack).sort((a, b) => a.namespace.localeCompare(b.namespace));
+}
+
+// src/console/scan.ts
+var SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".fw", "coverage"]);
+var toPosix = (p) => p.split(path3.sep).join("/");
+function walk(dir, out) {
+  let entries;
+  try {
+    entries = fs3.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (SKIP.has(entry.name) || entry.name.startsWith(".")) continue;
+    const full = path3.join(dir, entry.name);
+    if (entry.isDirectory()) walk(full, out);
+    else if (entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts") && !entry.name.startsWith(".fw-diff-")) out.push(full);
+  }
+}
+function listOne(file, projectDir, mtimeMs) {
+  let text;
+  try {
+    text = fs3.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  if (!text.includes("@flowWeaver workflow")) return null;
+  const names2 = getAvailableWorkflows(text).map((w) => w.functionName).filter(Boolean);
+  return names2.length ? { file, rel: toPosix(path3.relative(projectDir, file)), names: names2, mtimeMs } : null;
+}
+var checked = /* @__PURE__ */ new Map();
+var listings = /* @__PURE__ */ new Map();
+function invalidateListing(projectDir) {
+  if (projectDir) listings.delete(path3.resolve(projectDir));
+  else listings.clear();
+}
+function listCached(projectDir) {
+  const key = path3.resolve(projectDir);
+  const files = [];
+  walk(key, files);
+  const stats = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    try {
+      stats.set(file, fs3.statSync(file).mtimeMs);
+    } catch {
+    }
+  }
+  const signature = [...stats].map(([f, m]) => `${f}:${m}`).join("|");
+  const hit = listings.get(key);
+  if (hit && hit.signature === signature) return [...hit.byFile.values()];
+  const byFile = /* @__PURE__ */ new Map();
+  for (const [file, mtimeMs] of stats) {
+    const previous = hit?.byFile.get(file);
+    if (previous && previous.mtimeMs === mtimeMs) {
+      byFile.set(file, previous);
+      continue;
+    }
+    const listed = listOne(file, key, mtimeMs);
+    if (listed) byFile.set(file, listed);
+  }
+  listings.set(key, { byFile, signature });
+  return [...byFile.values()];
+}
+async function check(entry, name, packs) {
+  const base = {
+    file: entry.file,
+    rel: entry.rel,
+    name,
+    steps: 0,
+    gates: 0,
+    errors: 0,
+    warnings: 0,
+    checked: true,
+    codes: [],
+    uses: []
+  };
+  try {
+    const parsed = await parseWorkflow(entry.file, { workflowName: name, projectDir: path3.dirname(entry.file) });
+    if (parsed.errors.length || !parsed.ast) return { ...base, errors: Math.max(1, parsed.errors.length) };
+    const ast = parsed.ast;
+    const v = validateWorkflow(ast);
+    const uses = /* @__PURE__ */ new Set();
+    let gates = 0;
+    for (const i of ast.instances) {
+      const nt = ast.nodeTypes.find((n) => n.name === i.nodeType) ?? ast.nodeTypes.find((n) => n.functionName === i.nodeType);
+      if (nt?.durableGate !== void 0) {
+        gates++;
+        uses.add(`gate:${nt.durableGate}`);
+      }
+      if (nt && !nt.functionText) uses.add(`builtin:${nt.functionName}`);
+      const pack = (nt?.sourceLocation?.file ? packForFile(nt.sourceLocation.file, packs) : null) ?? packForSpecifier(nt?.importSource, packs);
+      if (pack) uses.add(`pack:${pack}`);
+      if (nt?.durableEffect) uses.add("effect");
+      if (nt?.durablePure) uses.add("pure");
+      if (nt?.expression) uses.add("expression");
+      if (i.config?.pullExecution !== void 0) uses.add("pull");
+      if (i.config?.portConfigs?.some((c) => c.expression)) uses.add("expr");
+    }
+    if (Object.keys(ast.scopes ?? {}).length) uses.add("scope");
+    const codes = [...new Set([...v.errors, ...v.warnings].map((e) => e.code))];
+    return { ...base, steps: ast.instances.length, gates, errors: v.errors.length, warnings: v.warnings.length, codes, uses: [...uses] };
+  } catch {
+    return { ...base, errors: 1 };
+  }
+}
+var sortSummaries = (rows) => rows.sort((a, b) => a.rel.localeCompare(b.rel) || a.name.localeCompare(b.name));
+function scanWorkflowNames(projectDir) {
+  const rows = [];
+  for (const entry of listCached(projectDir)) {
+    for (const name of entry.names) {
+      const hit = checked.get(`${entry.file}|${name}`);
+      rows.push(hit && hit.mtimeMs === entry.mtimeMs ? hit.summary : { file: entry.file, rel: entry.rel, name, steps: 0, gates: 0, errors: 0, warnings: 0, checked: false, codes: [], uses: [] });
+    }
+  }
+  return sortSummaries(rows);
+}
+async function checkWorkflows(projectDir, onChecked) {
+  const rows = [];
+  const packs = await installedRefs(projectDir);
+  for (const entry of listCached(projectDir)) {
+    for (const name of entry.names) {
+      const key = `${entry.file}|${name}`;
+      const hit = checked.get(key);
+      if (hit && hit.mtimeMs === entry.mtimeMs) {
+        rows.push(hit.summary);
+        continue;
+      }
+      const summary = await check(entry, name, packs);
+      checked.set(key, { mtimeMs: entry.mtimeMs, summary });
+      rows.push(summary);
+      onChecked?.(summary);
+    }
+  }
+  return sortSummaries(rows);
+}
+
+// src/console/runs.ts
+import * as fs8 from "node:fs";
+import * as path7 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// src/console/debug.ts
+import * as fs4 from "node:fs";
+import * as os2 from "node:os";
+import * as path4 from "node:path";
+import { randomUUID } from "node:crypto";
+function latestValues(variables) {
+  const best = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(variables)) {
+    const at2 = key.lastIndexOf(":");
+    const mid = key.lastIndexOf(":", at2 - 1);
+    if (at2 < 0 || mid < 0) continue;
+    const name = `${key.slice(0, mid)}.${key.slice(mid + 1, at2)}`;
+    const index = Number(key.slice(at2 + 1));
+    const cur = best.get(name);
+    if (!cur || index > cur.index) best.set(name, { index, value });
+  }
+  return Object.fromEntries([...best].map(([k, v]) => [k, v.value]));
+}
+function latestKey(variables, node, port) {
+  const prefix = `${node}:${port}:`;
+  let found = null;
+  let top = -1;
+  for (const key of Object.keys(variables)) {
+    if (!key.startsWith(prefix)) continue;
+    const index = Number(key.slice(prefix.length));
+    if (index > top) {
+      top = index;
+      found = key;
+    }
+  }
+  return found;
+}
+var DebugSessions = class {
+  sessions = /* @__PURE__ */ new Map();
+  get(id) {
+    return this.sessions.get(id)?.view;
+  }
+  list() {
+    return [...this.sessions.values()].map((s) => s.view);
+  }
+  /**
+   * Start a session. Resolves at the first pause, or when the run ends
+   * without one. The session is listed from the moment this is called, so
+   * a caller that answers with the id before the pause can show it.
+   */
+  async start(options) {
+    const file = path4.resolve(options.file);
+    const id = options.id ?? randomUUID();
+    const controller = new DebugController({ debug: true, breakpoints: options.breakpoints });
+    const abort = new AbortController();
+    const effectsDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "fw-debug-"));
+    const view = {
+      id,
+      file,
+      name: options.name,
+      params: options.params ?? {},
+      status: "running",
+      startedAt: Date.now(),
+      updatedAt: Date.now(),
+      position: 0,
+      order: [],
+      breakpoints: controller.getBreakpoints(),
+      values: {}
+    };
+    const session = {
+      view,
+      controller,
+      abort,
+      done: Promise.resolve({ kind: "error", error: new Error("not started") }),
+      aborting: false,
+      effectsDir,
+      onChange: options.onChange
+    };
+    this.sessions.set(id, session);
+    const parsed = await parseWorkflow(file, { workflowName: options.name, projectDir: path4.dirname(file) });
+    if (parsed.errors.length) {
+      session.view = { ...view, status: "failed", error: parsed.errors.join("\n"), updatedAt: Date.now() };
+      fs4.rmSync(effectsDir, { recursive: true, force: true });
+      session.onChange?.(session.view);
+      return session.view;
+    }
+    const order = getTopologicalOrder(parsed.ast, { includeScopedChildren: true });
+    controller.setExecutionOrder(order);
+    session.view = { ...session.view, order };
+    let bundleDigest;
+    try {
+      bundleDigest = await computeBundleDigest(file, options.name);
+    } catch {
+    }
+    session.done = executeWorkflow({
+      runId: id,
+      filePath: file,
+      workflowName: options.name,
+      params: options.params,
+      includeTrace: true,
+      onEvent: options.onEvent,
+      debugController: controller,
+      abortSignal: abort.signal,
+      mocks: options.mocks,
+      bundleDigest,
+      effectAdapter: createFileEffectAdapter(effectsDir)
+    }).then((outcome) => ({ kind: "outcome", outcome })).catch((error) => ({ kind: "error", error }));
+    await this.settle(session);
+    return session.view;
+  }
+  /** Run the next node and pause again. */
+  step(id) {
+    return this.act(id, { type: "step" });
+  }
+  /** Run to the end, or to the next breakpoint. */
+  continue(id, toBreakpoint = false) {
+    return this.act(id, { type: toBreakpoint ? "continueToBreakpoint" : "continue" });
+  }
+  /** Stop the session, paused or not. */
+  async abort(id) {
+    const s = this.need(id);
+    s.aborting = true;
+    if (s.view.status === "paused") return this.act(id, { type: "abort" });
+    s.abort.abort();
+    await this.settle(s);
+    return s.view;
+  }
+  /**
+   * Change a value a node produced. Takes effect before the next node runs,
+   * which is how a branch is forced or a bad value patched without a rerun.
+   */
+  setVariable(id, node, port, value) {
+    const s = this.need(id);
+    if (s.view.status !== "paused" || !s.last) throw new Error("the session is not paused");
+    const key = latestKey(s.last.variables, node, port);
+    if (!key) throw new Error(`${node}.${port} has no value yet. It can be set once ${node} has run`);
+    s.controller.setVariable(key, value);
+    s.last.variables[key] = value;
+    s.view = { ...s.view, values: { ...s.view.values, [`${node}.${port}`]: value }, updatedAt: Date.now() };
+    s.onChange?.(s.view);
+    return s.view;
+  }
+  breakpoint(id, action, node) {
+    const s = this.need(id);
+    if (action === "add") s.controller.addBreakpoint(node);
+    else s.controller.removeBreakpoint(node);
+    s.view = { ...s.view, breakpoints: s.controller.getBreakpoints(), updatedAt: Date.now() };
+    s.onChange?.(s.view);
+    return s.view;
+  }
+  need(id) {
+    const s = this.sessions.get(id);
+    if (!s) throw new Error(`no debug session ${id}`);
+    return s;
+  }
+  async act(id, action) {
+    const s = this.need(id);
+    if (s.view.status !== "paused") throw new Error(`the session is ${s.view.status}, not paused`);
+    s.view = { ...s.view, status: "running", node: void 0, phase: void 0, updatedAt: Date.now() };
+    s.onChange?.(s.view);
+    s.controller.resume(action);
+    await this.settle(s);
+    return s.view;
+  }
+  /** Wait for the next pause or the end, and record which it was. */
+  async settle(s) {
+    const paused = s.controller.onPause().then((state) => ({ kind: "paused", state }));
+    const next = await Promise.race([s.done, paused]);
+    const now = Date.now();
+    if (next.kind === "paused") {
+      s.last = next.state;
+      s.view = {
+        ...s.view,
+        status: "paused",
+        node: next.state.currentNodeId,
+        phase: next.state.phase,
+        position: next.state.position,
+        breakpoints: next.state.breakpoints,
+        values: latestValues(next.state.variables),
+        updatedAt: now
+      };
+    } else if (next.kind === "outcome" && next.outcome.kind === "completed") {
+      s.view = { ...s.view, status: "completed", node: void 0, phase: void 0, position: s.view.order.length, result: next.outcome.result, updatedAt: now };
+    } else if (next.kind === "outcome" && next.outcome.kind === "yielded") {
+      const gate = next.outcome.gate.address.nodeId;
+      s.view = {
+        ...s.view,
+        status: "yielded",
+        node: gate,
+        phase: void 0,
+        updatedAt: now,
+        error: `Reached the gate at ${gate}. The debugger cannot hold a gate. Run the workflow without it to answer one.`
+      };
+    } else {
+      const error = next.kind === "error" ? next.error : void 0;
+      const message = getErrorMessage(error);
+      const aborted = s.aborting || s.abort.signal.aborted || /Debug session aborted/.test(message);
+      s.view = { ...s.view, status: aborted ? "aborted" : "failed", node: void 0, phase: void 0, error: aborted ? void 0 : message, updatedAt: now };
+    }
+    if (s.view.status !== "paused" && s.view.status !== "running") fs4.rmSync(s.effectsDir, { recursive: true, force: true });
+    s.onChange?.(s.view);
+  }
+};
+
+// src/console/workflow-view.ts
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// src/console/git.ts
+import { execFile } from "node:child_process";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
+function git(cwd, args) {
+  return new Promise((resolve9, reject) => {
+    execFile("git", args, { cwd, maxBuffer: 16 * 1024 * 1024, windowsHide: true }, (err, stdout) => {
+      if (err) reject(err instanceof Error ? err : new Error(String(err)));
+      else resolve9(String(stdout));
+    });
+  });
+}
+async function repoRoot(file) {
+  try {
+    return (await git(path5.dirname(file), ["rev-parse", "--show-toplevel"])).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function gitPath(root, file) {
+  const real2 = (p) => {
+    try {
+      return fs5.realpathSync(p);
+    } catch {
+      return p;
+    }
+  };
+  return path5.relative(real2(root), real2(file)).split(path5.sep).join("/");
+}
+async function fileHistory(file, limit = 60) {
+  const root = await repoRoot(file);
+  if (!root) return { repo: false, dirty: false, commits: [] };
+  const rel = gitPath(root, file);
+  const [head, status, log] = await Promise.all([
+    git(root, ["rev-parse", "--short", "HEAD"]).then((s) => s.trim()).catch(() => void 0),
+    git(root, ["status", "--porcelain", "--", rel]).catch(() => ""),
+    git(root, ["log", "--follow", `-n${limit}`, "--format=%H%x1f%h%x1f%an%x1f%at%x1f%s", "--", rel]).catch(() => "")
+  ]);
+  const commits = log.split("\n").filter(Boolean).map((line) => {
+    const [sha, short, author, at2, subject] = line.split("");
+    return { sha, short, author, at: Number(at2) * 1e3, subject };
+  });
+  return { repo: true, head, dirty: status.trim().length > 0, commits };
+}
+async function fileAt(file, ref) {
+  const root = await repoRoot(file);
+  if (!root) return void 0;
+  try {
+    return await git(root, ["show", `${ref}:${gitPath(root, file)}`]);
+  } catch {
+    return void 0;
+  }
+}
+async function stamp(file) {
+  const root = await repoRoot(file);
+  if (!root) return void 0;
+  const rel = gitPath(root, file);
+  const [commit, status] = await Promise.all([
+    git(root, ["rev-parse", "--short", "HEAD"]).then((s) => s.trim()).catch(() => void 0),
+    git(root, ["status", "--porcelain", "--", rel]).catch(() => "")
+  ]);
+  return commit ? { commit, dirty: status.trim().length > 0 } : void 0;
+}
+
+// src/console/source.ts
+function findDeclaration(text, fnName) {
+  const re = new RegExp(`\\bexport\\s+(?:async\\s+)?function\\s+${fnName}\\s*[(<]`);
+  return text.search(re);
+}
+function endOfSignature(text, from) {
+  let depth = 0;
+  let closedParams = false;
+  let inReturnType = false;
+  const i0 = text.indexOf("(", from);
+  if (i0 < 0) return -1;
+  let i = i0;
+  for (; i < text.length; i++) {
+    const c = text[i];
+    if (c === "/" && text[i + 1] === "/") {
+      const nl = text.indexOf("\n", i);
+      if (nl < 0) return -1;
+      i = nl;
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      if (end < 0) return -1;
+      i = end + 1;
+      continue;
+    }
+    if (c === "'" || c === '"' || c === "`") {
+      const quote = c;
+      i++;
+      while (i < text.length && text[i] !== quote) {
+        if (text[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (c === ":" && depth === 0 && closedParams) {
+      inReturnType = true;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{" || c === "<") {
+      if (c === "{" && depth === 0 && closedParams && !inReturnType) return i + 1;
+      depth++;
+      continue;
+    }
+    if (c === ")" || c === "]" || c === "}" || c === ">") {
+      if (c === ">" && text[i - 1] === "=") continue;
+      depth--;
+      if (c === ")" && depth === 0) closedParams = true;
+      if (depth === 0 && inReturnType && c !== ")") inReturnType = false;
+      continue;
+    }
+  }
+  return -1;
+}
+function workflowSource(text, fnName) {
+  const declaration = findDeclaration(text, fnName);
+  if (declaration < 0) return { source: "", line: 1 };
+  const bodyStart = endOfSignature(text, declaration);
+  const end = bodyStart < 0 ? text.length : bodyStart;
+  const commentStart = text.lastIndexOf("/**", declaration);
+  const between = commentStart >= 0 ? text.slice(text.indexOf("*/", commentStart) + 2, declaration) : "";
+  const attached = commentStart >= 0 && /^\s*$/.test(between);
+  const from = attached ? commentStart : declaration;
+  return {
+    source: text.slice(from, end).trimEnd(),
+    line: text.slice(0, from).split("\n").length
+  };
+}
+
+// src/console/terminals.ts
+var CONTROL2 = /* @__PURE__ */ new Set(["execute", "onSuccess", "onFailure"]);
+function terminalWiring(ast) {
+  const start = {};
+  const exit = {};
+  for (const c of ast.connections) {
+    if (c.from.node === "Start" && !CONTROL2.has(c.from.port)) {
+      (start[c.from.port] ??= []).push({ node: c.to.node, port: c.to.port });
+    }
+    if (c.to.node === "Exit" && !CONTROL2.has(c.to.port) && !exit[c.to.port]) {
+      exit[c.to.port] = { node: c.from.node, port: c.from.port };
+    }
+  }
+  return { start, exit };
+}
+
+// src/console/workflow-view.ts
+var CONTROL3 = /* @__PURE__ */ new Set(["execute", "onSuccess", "onFailure"]);
+function nodeTypeOf(ast, inst) {
+  return ast.nodeTypes.find((n) => n.name === inst.nodeType) ?? ast.nodeTypes.find((n) => n.functionName === inst.nodeType);
+}
+function ports2(map) {
+  return Object.entries(map ?? {}).filter(([k, p]) => !CONTROL3.has(k) && !p.isControlFlow).map(([k, p]) => ({ name: k, tsType: p.tsType ?? String(p.dataType).toLowerCase(), optional: !!p.optional, description: p.description ?? "" }));
+}
+async function parseOne(file, name) {
+  const p = await parseWorkflow(file, { workflowName: name, projectDir: path6.dirname(file) });
+  return { ast: p.errors.length ? void 0 : p.ast, errors: p.errors };
+}
+function describeIssue(e) {
+  return {
+    severity: e.type,
+    code: e.code,
+    message: e.message,
+    node: e.node ?? null,
+    line: e.location?.line ?? null,
+    hint: ERROR_HINTS[e.code] ? ERROR_HINTS[e.code].replace(/<nodeId>/g, e.node ?? "<nodeId>") : null
+  };
+}
+async function astAt(file, name, ref) {
+  if (ref === "worktree") {
+    const p = await parseOne(file, name);
+    return p.ast ? { ast: p.ast } : { error: p.errors.join("\n") || "the file does not parse" };
+  }
+  const text = await fileAt(file, ref);
+  if (text === void 0) return { error: `${path6.basename(file)} does not exist at ${ref}` };
+  const tmp = path6.join(path6.dirname(file), `.fw-diff-${randomUUID2().slice(0, 8)}-${path6.basename(file)}`);
+  fs6.writeFileSync(tmp, text, "utf8");
+  try {
+    const p = await parseWorkflow(tmp, { workflowName: name, projectDir: path6.dirname(file) });
+    if (p.errors.length) return { error: `${path6.basename(file)} at ${ref} does not parse: ${p.errors[0]}` };
+    return { ast: { ...p.ast, sourceFile: file } };
+  } finally {
+    fs6.rmSync(tmp, { force: true });
+  }
+}
+async function describeWorkflow(projectDir, file, name) {
+  const text = fs6.readFileSync(file, "utf8");
+  const rel = toPosix(path6.relative(projectDir, file));
+  const { ast, errors } = await parseOne(file, name);
+  if (!ast) return { file, rel, name, parseErrors: errors };
+  const v = validateWorkflow(ast);
+  const packs = await installedRefs(projectDir);
+  const nodes = {};
+  for (const inst of ast.instances) {
+    const nt = nodeTypeOf(ast, inst);
+    const nodeFile = nt?.sourceLocation?.file ?? file;
+    nodes[inst.id] = {
+      id: inst.id,
+      type: inst.nodeType,
+      label: stepLabel(inst, nt),
+      description: nt?.description ?? "",
+      builtin: !nt?.functionText,
+      color: inst.config?.color ?? nt?.visuals?.color ?? null,
+      icon: inst.config?.icon ?? nt?.visuals?.icon ?? null,
+      pull: inst.config?.pullExecution !== void 0,
+      source: nt?.functionText ?? "",
+      file: nodeFile,
+      line: nt?.sourceLocation?.line ?? null,
+      gate: nt?.durableGate ?? null,
+      // Where the node type came from, and what a pack's tags said about
+      // this step: the parser resolves both and then shows neither.
+      pack: packForFile(nodeFile, packs) ?? packForSpecifier(nt?.importSource, packs),
+      deploy: Object.keys({ ...nt?.deploy, ...inst.deploy }).length ? { ...nt?.deploy, ...inst.deploy } : null,
+      // What a step can and cannot do is the thing an author gets wrong:
+      // an expression node has no onFailure, so a throw aborts the run,
+      // and only a pure node may re-run when a gated workflow resumes.
+      expression: !!nt?.expression,
+      durablePure: !!nt?.durablePure,
+      effect: !!nt?.durableEffect,
+      async: !!nt?.isAsync,
+      inputs: ports2(nt?.inputs),
+      outputs: ports2(nt?.outputs),
+      outputSchema: nt?.durableGate !== void 0 ? gateOutputSchemas(ast, inst.id, file) : null,
+      expr: (inst.config?.portConfigs ?? []).filter((c) => c.expression).map((c) => ({ port: c.portName, expr: c.expression }))
+    };
+  }
+  const model = buildProcessModel(ast);
+  const stamp2 = (steps) => steps.forEach((s) => {
+    s.label = nodes[s.id]?.label ?? s.label;
+    s.pull = !!nodes[s.id]?.pull;
+    stamp2(s.children);
+  });
+  stamp2(model.steps);
+  const ws = workflowSource(text, ast.functionName);
+  return {
+    file,
+    rel,
+    name: ast.functionName,
+    description: ast.description ?? "",
+    compiled: hasInPlaceMarkers(text),
+    params: ports2(ast.startPorts),
+    paramsSchema: workflowParamsSchema(file, ast.functionName),
+    returns: ports2(ast.exitPorts),
+    // Port level, for the Start and Exit cards: which input each parameter
+    // feeds, and which output becomes each return value.
+    wiring: terminalWiring(ast),
+    model,
+    nodes,
+    issues: [...v.errors, ...v.warnings].map(describeIssue),
+    source: ws.source,
+    sourceLine: ws.line,
+    deploy: ast.options?.deploy && Object.keys(ast.options.deploy).length ? ast.options.deploy : null,
+    // The routes the workflow declares with @http, for the Serve pane.
+    http: ast.options?.http ?? [],
+    reference: referenceOf(ast)
+  };
+}
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+function routeFrom(raw) {
+  if (typeof raw !== "object" || raw === null) return "a route is an object";
+  const r = raw;
+  const method = String(r.method ?? "").toUpperCase();
+  if (!HTTP_METHODS.has(method)) return `method must be one of ${[...HTTP_METHODS].join(", ")}`;
+  const p = String(r.path ?? "").trim();
+  if (!p.startsWith("/") || /\s/.test(p)) return "a path starts with / and has no spaces";
+  if (RESERVED_PATHS.some((x) => p === x || p.startsWith(`${x}/`))) return `${p} is under a reserved path (${RESERVED_PATHS.join(", ")})`;
+  const route = { method, path: p };
+  if (r.mode === "async") route.mode = "async";
+  if (r.auth === "none") route.auth = "none";
+  if (r.callback === true) route.callback = true;
+  return route;
+}
+async function setHttpRoutes(file, name, routes) {
+  const before = fs6.readFileSync(file, "utf8");
+  const ws = workflowSource(before, name);
+  if (!ws.source) return { ok: false, error: `${name} was not found in ${path6.basename(file)}` };
+  const start = before.indexOf(ws.source);
+  const block = ws.source;
+  const marker = block.match(/^([ \t]*\*[ \t]*)@flowWeaver[ \t]+workflow[^\n]*\n/m);
+  if (!marker || marker.index === void 0) return { ok: false, error: `${name} has no @flowWeaver workflow line` };
+  const kept = block.replace(/^[ \t]*\*[ \t]*@http\b[^\n]*\n/gm, "");
+  const at2 = kept.match(/^([ \t]*\*[ \t]*)@flowWeaver[ \t]+workflow[^\n]*\n/m);
+  const insertAt = at2.index + at2[0].length;
+  const lines = routes.map((r) => `${at2[1]}@http ${httpRouteText(r)}
+`).join("");
+  const rewritten = kept.slice(0, insertAt) + lines + kept.slice(insertAt);
+  const after = before.slice(0, start) + rewritten + before.slice(start + block.length);
+  fs6.writeFileSync(file, after, "utf8");
+  const p = await parseOne(file, name);
+  if (!p.ast) {
+    fs6.writeFileSync(file, before, "utf8");
+    return { ok: false, error: `the file no longer parsed, so it was put back: ${p.errors[0] ?? "unknown error"}` };
+  }
+  return { ok: true };
+}
+function referenceOf(ast) {
+  const { deploy: _deploy, ...options } = ast.options ?? {};
+  const macros = ast.macros ?? [];
+  const paths = macros.filter((m) => m.type === "path").map((m) => m.steps);
+  const connects = ast.connections.filter((c) => !c.derived && !(macros.length && isConnectionCoveredByMacroStatic(c, macros))).map((c) => ({ from: { node: c.from.node, port: c.from.port }, to: { node: c.to.node, port: c.to.port } }));
+  const exprs = ast.instances.flatMap((i) => (i.config?.portConfigs ?? []).filter((p) => p.expression).map((p) => ({ node: i.id, port: p.portName, expr: p.expression })));
+  const importsFrom = ast.nodeTypes.filter((nt) => nt.importSource).map((nt) => ({ type: nt.name, from: nt.importSource }));
+  return { options, paths, connects, exprs, importsFrom };
+}
+function crumbsFor(at2) {
+  const { root } = path6.parse(at2);
+  const rest = at2.slice(root.length).split(path6.sep).filter(Boolean);
+  const crumbs = [];
+  let dir = root;
+  for (const name of rest) {
+    dir = path6.join(dir, name);
+    crumbs.push({ name, dir });
+  }
+  return crumbs;
+}
+function errorCodeSection(code) {
+  const section = readTopicStructured("error-codes")?.sections.find((s) => s.heading.includes(code));
+  return section ? { heading: section.heading, content: section.content, codeBlocks: section.codeBlocks } : null;
+}
+
+// src/console/respond.ts
+import * as fs7 from "node:fs";
+function json(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function sse(res) {
+  res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+  res.write(": ok\n\n");
+}
+function send(res, msg) {
+  res.write(`data: ${JSON.stringify(msg)}
+
+`);
+}
+function sendFile(res, file, type) {
+  res.writeHead(200, { "Content-Type": type, "Cache-Control": "no-cache" });
+  res.end(fs7.readFileSync(file));
+}
+var BadRequest = class extends Error {
+};
+var MAX_BODY = 1024 * 1024;
+async function readBody(req) {
+  let s = "";
+  for await (const c of req) {
+    s += c;
+    if (s.length > MAX_BODY) throw new BadRequest(`the body may not exceed ${MAX_BODY} bytes`);
+  }
+  if (!s.trim()) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(s);
+  } catch {
+    throw new BadRequest("the body is not valid JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new BadRequest("the body must be a JSON object");
+  return parsed;
+}
+
+// src/console/runs.ts
+function mocksFrom(b) {
+  const m = b.mocks;
+  if (!m || typeof m !== "object" || Array.isArray(m)) return void 0;
+  const src = m;
+  const out = {};
+  for (const k of ["events", "agents", "invocations", "gates"]) {
+    if (src[k] && typeof src[k] === "object" && !Array.isArray(src[k]) && Object.keys(src[k]).length) out[k] = src[k];
+  }
+  if (src.fast === true) out.fast = true;
+  return Object.keys(out).length ? out : void 0;
+}
+var at = (iso) => Date.parse(iso);
+var DEBUG_STATUS = {
+  running: "running",
+  paused: "running",
+  completed: "completed",
+  failed: "failed",
+  aborted: "cancelled",
+  yielded: "cancelled"
+};
+function debugSnapshot(d, source) {
+  return {
+    id: d.id,
+    file: d.file,
+    name: d.name,
+    params: d.params,
+    source,
+    status: DEBUG_STATUS[d.status],
+    startedAt: d.startedAt,
+    updatedAt: d.updatedAt,
+    result: d.result,
+    error: d.error,
+    traced: true,
+    debug: { status: d.status, node: d.node, phase: d.phase, position: d.position, order: d.order, breakpoints: d.breakpoints }
+  };
+}
+function createRunDriver({ coordinator, broadcast, projectDir, profiles }) {
+  const live = /* @__PURE__ */ new Map();
+  const debug = new DebugSessions();
+  const debugEvents = /* @__PURE__ */ new Map();
+  const debugSource = /* @__PURE__ */ new Map();
+  const agentEvents = /* @__PURE__ */ new Map();
+  const subs = /* @__PURE__ */ new Map();
+  const push = (id, msg) => {
+    for (const res of subs.get(id) ?? []) send(res, msg);
+  };
+  let listed;
+  const storeList = async () => {
+    if (!listed || Date.now() - listed.at > 500) listed = { at: Date.now(), rows: await coordinator.list() };
+    return listed.rows;
+  };
+  let lastCounts = /* @__PURE__ */ new Map();
+  const waitingCounts = async () => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const s of await storeList()) if (s.status === "waiting") counts.set(`${s.filePath}|${s.workflowName}`, (counts.get(`${s.filePath}|${s.workflowName}`) ?? 0) + 1);
+    lastCounts = counts;
+    return counts;
+  };
+  const withWaiting = (w, counts = lastCounts) => ({
+    ...w,
+    waiting: counts.get(`${w.file}|${w.name}`) ?? 0
+  });
+  const asts = /* @__PURE__ */ new Map();
+  async function astFor(file, name) {
+    const key = `${file}|${name}`;
+    let mtimeMs;
+    try {
+      mtimeMs = fs8.statSync(file).mtimeMs;
+    } catch {
+      return void 0;
+    }
+    const hit = asts.get(key);
+    if (hit && hit.mtimeMs === mtimeMs) return hit.ast;
+    const { ast } = await parseOne(file, name);
+    asts.set(key, { mtimeMs, ast });
+    return ast;
+  }
+  async function gateView(rec) {
+    const g = rec.gate;
+    if (!g) return void 0;
+    const ast = await astFor(rec.filePath, rec.workflowName);
+    const inst = ast?.instances.find((i) => i.id === g.node);
+    const nt = ast && inst ? nodeTypeOf(ast, inst) : void 0;
+    return {
+      id: g.id,
+      kind: g.kind,
+      node: g.node,
+      inputs: g.inputs,
+      absent: g.absent,
+      outputs: g.outputs,
+      hasSuccessPort: g.hasSuccessPort,
+      hasFailurePort: g.hasFailurePort,
+      outputTypes: Object.fromEntries(g.outputs.map((o) => [o, nt?.outputs?.[o]?.tsType ?? "unknown"])),
+      outputSchema: ast ? gateOutputSchemas(ast, g.node, rec.filePath) : null,
+      // The words for whoever answers: the gate function's own description,
+      // and each output's label from its @output line. Types alone say what
+      // shape an answer has, not what it means.
+      description: nt?.description ?? "",
+      outputLabels: Object.fromEntries(g.outputs.map((o) => [o, nt?.outputs?.[o]?.label ?? ""])),
+      inputLabels: Object.fromEntries(Object.keys(g.inputs).map((i) => [i, nt?.inputs?.[i]?.label ?? ""]))
+    };
+  }
+  async function snapshot(id) {
+    const d = debug.get(id);
+    if (d) return debugSnapshot(d, debugSource.get(id));
+    const l = live.get(id);
+    const rec = await coordinator.record(id);
+    if (l) return { id, file: l.file, name: l.name, params: l.params, mocks: l.mocks, source: l.source, status: l.status, startedAt: l.startedAt, updatedAt: Date.now(), error: l.error, traced: true, agent: rec?.agent, agents: rec?.agents, origin: rec?.origin ?? "console" };
+    if (!rec) return void 0;
+    return {
+      id,
+      file: rec.filePath,
+      name: rec.workflowName,
+      params: rec.params,
+      mocks: rec.mocks,
+      source: rec.source,
+      status: rec.status,
+      startedAt: at(rec.createdAt),
+      updatedAt: at(rec.updatedAt),
+      gate: rec.gate ? { node: rec.gate.node, kind: rec.gate.kind } : void 0,
+      due: rec.due ? { at: at(rec.due.at), action: rec.due.action } : void 0,
+      result: rec.result,
+      error: rec.error,
+      failedAt: rec.failedNode,
+      traced: !!rec.traced,
+      agent: rec.agent,
+      agents: rec.agents,
+      origin: rec.origin
+    };
+  }
+  async function fullSnapshot(id) {
+    const snap = await snapshot(id);
+    const rec = live.has(id) ? void 0 : await coordinator.record(id);
+    return snap && rec?.gate ? { ...snap, gate: await gateView(rec) } : snap;
+  }
+  async function pushRun(id) {
+    if (!subs.get(id)?.size) return;
+    const run = await fullSnapshot(id);
+    if (run) push(id, { type: "run", run });
+  }
+  async function changed(id) {
+    listed = void 0;
+    if (id) await pushRun(id);
+    broadcast({ type: "runs" });
+  }
+  async function drive(l, segment) {
+    live.set(l.id, l);
+    listed = void 0;
+    broadcast({ type: "runs" });
+    void pushRun(l.id);
+    const onEvent = (ev) => {
+      const entry = { t: ev.timestamp, e: ev.data ?? ev };
+      l.events.push(entry);
+      push(l.id, { type: "event", ...entry });
+    };
+    try {
+      await segment(onEvent);
+      live.delete(l.id);
+    } catch (err) {
+      if (await coordinator.record(l.id)) live.delete(l.id);
+      else {
+        l.status = "failed";
+        l.error = getErrorMessage(err);
+      }
+    }
+    await changed(l.id);
+    void afterSegment(l.id);
+  }
+  async function afterSegment(id, asked = false) {
+    const rec = await coordinator.record(id);
+    if (!rec || rec.status !== "waiting" || rec.gate?.kind !== "agent" || rec.agents === "manual" && !asked) return;
+    const note = () => changed(id);
+    try {
+      if (asked && rec.agents === "manual") await coordinator.setAgent(id, rec.agent);
+      const step = await answerAgentGate(coordinator, id, {
+        projectDir: projectDir(),
+        profiles: profiles(),
+        outputSchema: async (r) => {
+          const g = await gateView(r);
+          return g ? { schema: g.outputSchema ?? null, types: g.outputTypes } : void 0;
+        },
+        onEvent: (e) => {
+          const entry = { t: Date.now(), e };
+          (agentEvents.get(id) ?? agentEvents.set(id, []).get(id)).push(entry);
+          push(id, { ...e, t: entry.t });
+          if (e.phase === "start" || e.phase === "done") void note();
+        }
+      });
+      await note();
+      if (step.kind === "answer") await resume(id, { answer: step.answer });
+      else if (step.kind === "reject") await resume(id, { reject: step.reason });
+    } catch (err) {
+      await noteAnswerMisfit(coordinator, id, err);
+      await note();
+    }
+  }
+  function startDebug(file, name, params, breakpoints, mocks, runTo, source) {
+    const id = randomUUID3();
+    const events = [];
+    debugEvents.set(id, events);
+    if (source) debugSource.set(id, source);
+    void debug.start({
+      id,
+      file,
+      name,
+      params,
+      breakpoints,
+      mocks,
+      onEvent: (ev) => {
+        const entry = { t: ev.timestamp, e: ev.data ?? ev };
+        events.push(entry);
+        push(id, { type: "event", ...entry });
+      },
+      onChange: () => {
+        void pushRun(id);
+        broadcast({ type: "runs" });
+      }
+    }).then((view) => {
+      if (runTo === "breakpoint" && view.status === "paused" && breakpoints.length) return debug.continue(id, true).then(() => void 0);
+    }).catch(() => void 0);
+    broadcast({ type: "runs" });
+    return debugSnapshot(debug.get(id), debugSource.get(id));
+  }
+  async function start(file, name, params, mocks, source, agents) {
+    const ast = await astFor(file, name);
+    if (!ast) throw new Error((await parseOne(file, name)).errors.join("\n"));
+    const id = randomUUID3();
+    const l = { id, file, name, params, mocks, source, startedAt: Date.now(), status: "running", events: [], abort: new AbortController() };
+    void drive(l, (onEvent) => coordinator.start({ filePath: file, workflowName: name, params, runId: id, mocks, source, agents, origin: "console" }, { onEvent, abortSignal: l.abort.signal }));
+    return await snapshot(id);
+  }
+  async function resume(id, input) {
+    if (live.has(id)) throw new Error("run is already resuming");
+    const rec = await coordinator.record(id);
+    if (rec?.gate && isAnswering(rec.agent, rec.gate.id)) throw new Error(`agent profile ${rec.agent.profile} is answering this gate. Wait for it, or cancel the run`);
+    const resolve9 = "reject" in input ? { reject: input.reject ?? "" } : { answer: input.answer };
+    await coordinator.checkResume({ runId: id, input: resolve9 });
+    if (!rec) return;
+    const l = { id, file: rec.filePath, name: rec.workflowName, params: rec.params, startedAt: at(rec.createdAt), status: "running", events: [], abort: new AbortController() };
+    void drive(l, (onEvent) => coordinator.resume({ runId: id, input: resolve9 }, { onEvent, abortSignal: l.abort.signal }));
+  }
+  async function cancel(id) {
+    if (debug.get(id)) {
+      await debug.abort(id).catch(() => void 0);
+      return;
+    }
+    const l = live.get(id);
+    if (l?.status === "running") {
+      l.abort.abort();
+      return;
+    }
+    if ((await coordinator.record(id))?.status === "waiting") {
+      await coordinator.cancel(id);
+      await changed(id);
+    }
+  }
+  async function list(file, name) {
+    const inFlight = [
+      ...debug.list().filter((d) => (!file || d.file === file) && (!name || d.name === name)).map((d) => debugSnapshot(d, debugSource.get(d.id))),
+      ...await Promise.all([...live.values()].filter((l) => (!file || l.file === file) && (!name || l.name === name)).map(async (l) => await snapshot(l.id)))
+    ];
+    const stored = (file ? await coordinator.list({ filePath: file }) : await storeList()).filter((s) => (!name || s.workflowName === name) && !live.has(s.runId)).map((s) => ({
+      id: s.runId,
+      file: s.filePath,
+      name: s.workflowName,
+      status: s.status,
+      params: s.params,
+      mocks: s.mocks,
+      source: s.source,
+      startedAt: at(s.createdAt),
+      updatedAt: at(s.updatedAt),
+      gate: s.gate,
+      failedAt: s.failedNode,
+      origin: s.origin,
+      due: s.due ? { at: at(s.due.at), action: s.due.action } : void 0
+    }));
+    return [...inFlight, ...stored].sort((a, b) => b.startedAt - a.startedAt).filter((r, i) => i < 20 || live.has(r.id) || debug.get(r.id));
+  }
+  async function remove(id) {
+    if (live.has(id) || debug.get(id)) throw new Error("the run is in flight. Cancel it first");
+    await coordinator.remove(id);
+    await changed();
+  }
+  async function watch(id, req, res) {
+    sse(res);
+    send(res, { type: "run", run: await fullSnapshot(id) });
+    const lines = [];
+    for (const entry of [...await coordinator.trace(id), ...live.get(id)?.events ?? [], ...debugEvents.get(id) ?? []]) lines.push({ t: entry.t, line: JSON.stringify({ type: "event", ...entry }) });
+    for (const entry of agentEvents.get(id) ?? []) lines.push({ t: entry.t, line: JSON.stringify({ ...entry.e, t: entry.t }) });
+    lines.sort((a, b) => a.t - b.t);
+    for (const l of lines) res.write(`data: ${l.line}
+
+`);
+    send(res, { type: "synced" });
+    const set = subs.get(id) ?? subs.set(id, /* @__PURE__ */ new Set()).get(id);
+    set.add(res);
+    req.on("close", () => {
+      set.delete(res);
+      if (!set.size) subs.delete(id);
+    });
+  }
+  async function withEvents(id) {
+    return { ...await fullSnapshot(id), events: [...await coordinator.trace(id), ...live.get(id)?.events ?? []] };
+  }
+  async function askAgent(id) {
+    const rec = await coordinator.record(id);
+    if (!rec || rec.status !== "waiting" || rec.gate?.kind !== "agent") return "the run is not waiting at an agent gate";
+    if (isAnswering(rec.agent, rec.gate.id)) return `${rec.agent.profile} is already answering`;
+    void afterSegment(id, true);
+    return void 0;
+  }
+  let storeWatcher;
+  let storePoll;
+  async function follow(opts) {
+    if (opts.watching && opts.runsDir) {
+      fs8.mkdirSync(opts.runsDir, { recursive: true });
+      const chokidar = await import("chokidar");
+      storeWatcher = chokidar.watch(opts.runsDir, { ignoreInitial: true, depth: 1 });
+      storeWatcher.on("all", (_event, file) => {
+        if (typeof file !== "string" || path7.basename(file) !== "run.json") return;
+        void changed(path7.basename(path7.dirname(file)));
+      });
+    } else if (opts.watching) {
+      let seen = /* @__PURE__ */ new Map();
+      storePoll = setInterval(() => {
+        void coordinator.list().then((rows) => {
+          const now = new Map(rows.map((r) => [r.runId, r.updatedAt]));
+          const moved = rows.filter((r) => seen.get(r.runId) !== r.updatedAt).map((r) => r.runId);
+          const gone = [...seen.keys()].some((id) => !now.has(id));
+          seen = now;
+          if (!moved.length && !gone) return;
+          listed = void 0;
+          broadcast({ type: "runs" });
+          for (const id of moved) if (!live.has(id)) void pushRun(id);
+        }).catch(() => void 0);
+      }, 3e3);
+      storePoll.unref?.();
+    }
+  }
+  const clock = setInterval(() => {
+    void coordinator.tick().then(async (moved) => {
+      for (const run of [...moved.woke, ...moved.timedOut]) {
+        await changed(run.runId);
+        void afterSegment(run.runId);
+      }
+    }).catch(() => void 0);
+  }, 3e3);
+  clock.unref?.();
+  return {
+    debug,
+    /** The stored record, as the coordinator has it. */
+    record: (id) => coordinator.record(id),
+    /** A document kept beside the run. */
+    kept: (id, name) => coordinator.kept(id, name),
+    snapshot,
+    list,
+    start,
+    startDebug,
+    resume,
+    cancel,
+    remove,
+    watch,
+    withEvents,
+    askAgent,
+    follow,
+    waitingCounts,
+    withWaiting,
+    /** A value set in a paused session, told to the pages that read values from the trace. */
+    announce: push,
+    /** Keep the run streams open through proxies. */
+    ping() {
+      for (const set of subs.values()) for (const res of set) res.write(": ping\n\n");
+    },
+    async close() {
+      clearInterval(clock);
+      if (storePoll) clearInterval(storePoll);
+      await storeWatcher?.close();
+      for (const set of subs.values()) for (const res of set) res.end();
+    }
+  };
+}
+
+// src/console/routes-agents.ts
+import * as fs9 from "node:fs";
+function createProfileCache(projectDir) {
+  let cache;
+  const get = () => {
+    const dir = projectDir();
+    let mtime;
+    try {
+      mtime = fs9.statSync(agentsFile(dir)).mtimeMs;
+    } catch {
+      mtime = 0;
+    }
+    if (!cache || cache.dir !== dir || cache.mtime !== mtime) cache = { dir, mtime, profiles: loadAgentProfiles(dir) };
+    return cache.profiles;
+  };
+  return {
+    get,
+    save(profiles) {
+      saveAgentProfiles(projectDir(), profiles);
+      cache = void 0;
+    },
+    describe() {
+      const p = get();
+      return {
+        file: p.file,
+        exists: p.exists,
+        default: p.default ?? null,
+        errors: p.errors,
+        gates: p.gates,
+        starter: STARTER_AGENTS_YAML,
+        suggestedModels: SUGGESTED_MODELS,
+        agents: Object.values(p.agents).map((a) => {
+          const r = readiness(a);
+          return { name: a.name, provider: a.provider, model: a.model || DEFAULT_MODEL[a.provider] || null, keyEnv: keyEnvOf(a) ?? null, ready: r.ready, reason: r.reason ?? null, description: a.description ?? null, system: a.system ?? null, maxIterations: a.maxIterations ?? null, baseUrl: a.baseUrl ?? null, bin: a.bin ?? null };
+        })
+      };
+    }
+  };
+}
+function profileFrom(name, b) {
+  const str = (k) => typeof b[k] === "string" && b[k].trim() ? b[k].trim() : void 0;
+  const num = (k) => typeof b[k] === "number" ? b[k] : typeof b[k] === "string" && b[k].trim() ? Number(b[k]) : void 0;
+  return {
+    name,
+    provider: b.provider,
+    model: str("model"),
+    apiKeyEnv: str("apiKeyEnv"),
+    baseUrl: str("baseUrl"),
+    system: typeof b.system === "string" && b.system.trim() ? b.system : void 0,
+    maxIterations: num("maxIterations"),
+    maxTokens: num("maxTokens"),
+    bin: str("bin"),
+    description: str("description")
+  };
+}
+var PROFILE = /^\/api\/agents\/profiles\/([^/]+)$/;
+var TRY = /^\/api\/agents\/try\/([^/]+)$/;
+var nameIn = ({ match }) => decodeURIComponent(match[1] ?? "");
+function agentRoutes(ctx) {
+  const { profiles } = ctx;
+  const describe = (call) => json(call.res, 200, profiles.describe());
+  return [
+    { path: "/api/agents", handle: describe },
+    // Whether an environment variable is set here -- never its value.
+    {
+      path: "/api/agents/env",
+      handle: ({ res, q }) => json(res, 200, { name: q("name"), set: /^[A-Z_][A-Z0-9_]*$/.test(q("name")) && !!process.env[q("name")] })
+    },
+    {
+      method: "PUT",
+      path: "/api/agents/default",
+      handle: async (call) => {
+        const b = await call.body();
+        const p = profiles.get();
+        const name = typeof b.name === "string" && b.name ? b.name : void 0;
+        if (name && !p.agents[name]) return json(call.res, 400, { error: `no profile named ${name}` });
+        profiles.save({ agents: p.agents, default: name, gates: p.gates });
+        return describe(call);
+      }
+    },
+    {
+      method: "PUT",
+      path: "/api/agents/gates",
+      handle: async (call) => {
+        const b = await call.body();
+        const p = profiles.get();
+        const key = typeof b.key === "string" ? b.key.trim() : "";
+        if (!key) return json(call.res, 400, { error: "a gate key is an agentId or workflow/node" });
+        const gates = { ...p.gates };
+        if (typeof b.profile === "string" && b.profile) {
+          if (!p.agents[b.profile]) return json(call.res, 400, { error: `no profile named ${b.profile}` });
+          gates[key] = b.profile;
+        } else delete gates[key];
+        profiles.save({ agents: p.agents, default: p.default, gates });
+        return describe(call);
+      }
+    },
+    {
+      method: "POST",
+      path: TRY,
+      handle: async (call) => {
+        const profile = profiles.get().agents[nameIn(call)];
+        if (!profile) return json(call.res, 404, { error: `no profile named ${nameIn(call)}` });
+        return json(call.res, 200, await tryProfile(profile, process.env, { cwd: ctx.projectDir() }));
+      }
+    },
+    {
+      method: "PUT",
+      path: PROFILE,
+      handle: async (call) => {
+        const name = nameIn(call);
+        const p = profiles.get();
+        const profile = profileFrom(name, await call.body());
+        const problems = validateProfile(profile);
+        if (problems.length) return json(call.res, 400, { error: problems.join("; ") });
+        const agents = { ...p.agents, [name]: profile };
+        const def = p.default && agents[p.default] ? p.default : Object.keys(agents).length === 1 ? name : p.default;
+        profiles.save({ agents, default: def, gates: p.gates });
+        return describe(call);
+      }
+    },
+    {
+      method: "DELETE",
+      path: PROFILE,
+      handle: (call) => {
+        const name = nameIn(call);
+        const p = profiles.get();
+        if (!p.agents[name]) return json(call.res, 404, { error: `no profile named ${name}` });
+        const agents = { ...p.agents };
+        delete agents[name];
+        const gates = Object.fromEntries(Object.entries(p.gates).filter(([, v]) => v !== name));
+        profiles.save({ agents, default: p.default === name ? void 0 : p.default, gates });
+        return describe(call);
+      }
+    }
+  ];
+}
+
+// src/console/routes-project.ts
+import * as fs10 from "node:fs";
+import * as path8 from "node:path";
+
+// src/console/diff-view.ts
+var CONTROL4 = /* @__PURE__ */ new Set(["execute", "onSuccess", "onFailure"]);
+var isControl = (c) => CONTROL4.has(c.from.port) || c.to.port === "execute";
+function typeOf(ast, inst) {
+  return ast.nodeTypes.find((n) => n.name === inst.nodeType) ?? ast.nodeTypes.find((n) => n.functionName === inst.nodeType);
+}
+var portList = (map) => Object.entries(map ?? {}).filter(([k, p]) => !CONTROL4.has(k) && !p.isControlFlow).map(([k, p]) => ({ name: k, tsType: p.tsType ?? String(p.dataType).toLowerCase(), optional: !!p.optional, description: p.description ?? "" }));
+function nodeOf(ast, inst) {
+  const nt = typeOf(ast, inst);
+  return {
+    id: inst.id,
+    type: inst.nodeType,
+    label: stepLabel(inst, nt),
+    description: nt?.description ?? "",
+    builtin: !nt?.functionText,
+    color: inst.config?.color ?? nt?.visuals?.color ?? null,
+    icon: inst.config?.icon ?? nt?.visuals?.icon ?? null,
+    pull: inst.config?.pullExecution !== void 0,
+    gate: nt?.durableGate ?? null,
+    expression: !!nt?.expression,
+    durablePure: !!nt?.durablePure,
+    effect: !!nt?.durableEffect,
+    async: !!nt?.isAsync,
+    inputs: portList(nt?.inputs),
+    outputs: portList(nt?.outputs),
+    source: nt?.functionText ?? "",
+    file: nt?.sourceLocation?.file ?? ast.sourceFile,
+    line: nt?.sourceLocation?.line ?? null,
+    outputSchema: null,
+    expr: (inst.config?.portConfigs ?? []).filter((c) => c.expression).map((c) => ({ port: c.portName, expr: String(c.expression) })),
+    pack: null,
+    deploy: null
+  };
+}
+function instanceDetail(d, typeChanged) {
+  const bits = [];
+  if (d.changes.nodeType) bits.push(`now ${d.changes.nodeType.after}, was ${d.changes.nodeType.before}`);
+  if (d.changes.config?.portConfigs) bits.push("expressions changed");
+  if (d.changes.config?.pullExecution) bits.push(d.changes.config.pullExecution.after ? "now pulled on demand" : "no longer pulled");
+  if (d.changes.parent) {
+    const a = d.changes.parent.after, b = d.changes.parent.before;
+    bits.push(a ? `moved into ${a.id} (${a.scope})` : b ? `moved out of ${b.id} (${b.scope})` : "scope changed");
+  }
+  if (typeChanged) bits.push(typeDetail(typeChanged));
+  return bits.join(", ");
+}
+function typeDetail(d) {
+  const bits = [];
+  const io = (list, word) => {
+    for (const p of list ?? []) bits.push(`${p.type === "ADDED" ? "+" : p.type === "REMOVED" ? "\u2212" : "~"}${word} ${p.portName}`);
+  };
+  io(d.changes.inputs, "in");
+  io(d.changes.outputs, "out");
+  if (d.changes.executeWhen) bits.push("execute-when changed");
+  if (d.changes.isAsync) bits.push(d.changes.isAsync.after ? "now async" : "no longer async");
+  if (d.changes.scope) bits.push("scope changed");
+  if (d.changes.functionName) bits.push(`function ${d.changes.functionName.after}`);
+  return bits.join(", ");
+}
+function buildDiffView(before, after) {
+  const diff = WorkflowDiffer.compare(before, after);
+  const reasons = diff.identical ? [] : getImpactReasons(diff);
+  const beforeInst = new Map(before.instances.map((i) => [i.id, i]));
+  const afterInst = new Map(after.instances.map((i) => [i.id, i]));
+  const label = (id) => {
+    if (id === "Start" || id === "Exit") return id;
+    const inst = afterInst.get(id) ?? beforeInst.get(id);
+    return inst ? stepLabel(inst, typeOf(afterInst.has(id) ? after : before, inst)) : id;
+  };
+  const typeDiffs = new Map(diff.nodeTypes.filter((n) => n.changeType === "MODIFIED").map((n) => [n.name, n]));
+  const steps = [];
+  for (const d of diff.instances) {
+    const inst = afterInst.get(d.id) ?? beforeInst.get(d.id);
+    if (!inst) continue;
+    if (d.changeType === "ADDED") steps.push({ id: d.id, label: label(d.id), change: "added", detail: `${inst.nodeType}` });
+    else if (d.changeType === "REMOVED") steps.push({ id: d.id, label: label(d.id), change: "removed", detail: `${inst.nodeType}` });
+    else {
+      const t = typeDiffs.get(inst.nodeType) ?? [...typeDiffs.values()].find((x) => typeOf(after, inst)?.functionName === x.name);
+      const detail = instanceDetail(d, t);
+      if (detail) steps.push({ id: d.id, label: label(d.id), change: "changed", detail });
+    }
+  }
+  const touched = new Set(steps.map((s) => s.id));
+  for (const inst of after.instances) {
+    if (touched.has(inst.id)) continue;
+    const nt = typeOf(after, inst);
+    const t = typeDiffs.get(inst.nodeType) ?? (nt ? typeDiffs.get(nt.name) : void 0);
+    if (t) {
+      steps.push({ id: inst.id, label: label(inst.id), change: "changed", detail: typeDetail(t) });
+      touched.add(inst.id);
+    }
+  }
+  const wiring = [];
+  const edgesAdded = /* @__PURE__ */ new Map();
+  const edgesRemoved = /* @__PURE__ */ new Map();
+  for (const c of diff.connections) {
+    const change = c.changeType === "ADDED" ? "added" : "removed";
+    const kind = isControl(c) ? c.from.port === "onFailure" ? "fail" : "ok" : "data";
+    const text = kind === "data" ? `${label(c.from.node)}.${c.from.port} \u2192 ${label(c.to.node)}.${c.to.port}` : `${label(c.from.node)}${kind === "fail" ? " on failure" : ""} \u2192 ${label(c.to.node)}`;
+    wiring.push({ change, from: c.from.node, to: c.to.node, fromPort: c.from.port, toPort: c.to.port, kind, label: text });
+    if (kind !== "data") (change === "added" ? edgesAdded : edgesRemoved).set(`${c.from.node}>${c.to.node}`, [c.from.node, c.to.node]);
+  }
+  const contract = [];
+  const ports3 = (side, p) => {
+    for (const x of p.added) contract.push({ side, name: x.name, change: "added", detail: x.definition.tsType ?? String(x.definition.dataType ?? "") });
+    for (const x of p.removed) contract.push({ side, name: x.name, change: "removed", detail: x.definition.tsType ?? String(x.definition.dataType ?? "") });
+    for (const x of p.modified) contract.push({ side, name: x.name, change: "changed", detail: `${x.before.tsType ?? x.before.dataType} \u2192 ${x.after.tsType ?? x.after.dataType}` });
+  };
+  ports3("in", diff.startPorts);
+  ports3("out", diff.exitPorts);
+  const removedInstances = before.instances.filter((i) => !afterInst.has(i.id));
+  const afterTypes = new Set(after.nodeTypes.map((n) => n.name));
+  const unionTypes = [...after.nodeTypes, ...before.nodeTypes.filter((n) => !afterTypes.has(n.name))];
+  const unionIds = new Set([...after.instances, ...removedInstances].map((i) => i.id));
+  const afterConn = new Set(after.connections.map(connKey));
+  const removedConnections = before.connections.filter((c) => !afterConn.has(connKey(c)) && (c.from.node === "Start" || unionIds.has(c.from.node)) && (c.to.node === "Exit" || unionIds.has(c.to.node)));
+  const union = { ...after, nodeTypes: unionTypes, instances: [...after.instances, ...removedInstances], connections: [...after.connections, ...removedConnections] };
+  let model;
+  try {
+    model = buildProcessModel(union);
+  } catch {
+    model = null;
+  }
+  if (model) {
+    const unionInst = new Map(union.instances.map((i) => [i.id, i]));
+    const stampAll = (steps2) => steps2.forEach((s) => {
+      const inst = unionInst.get(s.id);
+      if (inst) {
+        s.label = label(s.id);
+        s.pull = inst.config?.pullExecution !== void 0;
+      }
+      stampAll(s.children);
+    });
+    stampAll(model.steps);
+  }
+  const nodes = {};
+  for (const inst of removedInstances) nodes[inst.id] = nodeOf(before, inst);
+  return {
+    identical: diff.identical,
+    impact: diff.impact,
+    reasons,
+    steps,
+    wiring,
+    contract,
+    marks: {
+      added: steps.filter((s) => s.change === "added").map((s) => s.id),
+      removed: steps.filter((s) => s.change === "removed").map((s) => s.id),
+      changed: steps.filter((s) => s.change === "changed").map((s) => s.id),
+      edgesAdded: [...edgesAdded.values()],
+      edgesRemoved: [...edgesRemoved.values()]
+    },
+    model,
+    nodes
+  };
+}
+var connKey = (c) => `${c.from.node}.${c.from.port}${c.from.scope ? ":" + c.from.scope : ""}>${c.to.node}.${c.to.port}${c.to.scope ? ":" + c.to.scope : ""}`;
+
+// src/console/routes-services.ts
+function describeServe(supervisor) {
+  const s = supervisor.view("serve");
+  return {
+    running: s.state === "running" && s.pid ? { url: s.url ?? null, pid: s.pid, startedAt: s.startedAt, version: s.activity?.version ?? VERSION, install: s.activity?.install ?? "", owned: s.owned, token: s.token ?? null } : null,
+    state: s.state,
+    command: "fw serve --trace"
+  };
+}
+function serviceRoutes(ctx) {
+  const listing = () => ({ services: ctx.supervisor().list(), settings: ctx.supervisor().settings() });
+  return [
+    { path: "/api/serve", handle: ({ res }) => json(res, 200, describeServe(ctx.supervisor())) },
+    // The project's services: what runs, its settings, start and stop, its output.
+    { path: "/api/services", handle: ({ res }) => json(res, 200, listing()) },
+    {
+      path: /^\/api\/services\/(serve|watch)\/(start|stop|restart|settings|logs)$/,
+      handle: async ({ req, res, q, body, match }) => {
+        const kind = match[1];
+        const action = match[2];
+        const supervisor = ctx.supervisor();
+        try {
+          if (action === "logs") {
+            if (q("format") === "json") return json(res, 200, supervisor.logs(kind));
+            sse(res);
+            for (const line of supervisor.logs(kind)) send(res, line);
+            send(res, { synced: true });
+            const off = supervisor.onLog(kind, (line) => send(res, line));
+            req.on("close", off);
+            return;
+          }
+          if (req.method !== "POST" && req.method !== "PUT") return json(res, 405, { error: "POST to start, stop or restart; PUT settings" });
+          const b = await body();
+          if (action === "settings") {
+            supervisor.saveSettings(kind, b);
+            return json(res, 200, listing());
+          }
+          if (action === "start") {
+            if (Object.keys(b).length) supervisor.saveSettings(kind, b);
+            supervisor.start(kind);
+          }
+          if (action === "stop") await supervisor.stop(kind, typeof b.pid === "number" ? b.pid : void 0);
+          if (action === "restart") await supervisor.restart(kind);
+          return json(res, 200, listing());
+        } catch (err) {
+          return json(res, 400, { error: getErrorMessage(err) });
+        }
+      }
+    },
+    {
+      path: "/api/events",
+      handle: ({ req, res }) => {
+        sse(res);
+        ctx.followers.add(res);
+        req.on("close", () => ctx.followers.delete(res));
+      }
+    }
+  ];
+}
+
+// src/console/routes-project.ts
+var OUTSIDE = { error: "file is outside the project" };
+function projectRoutes(ctx) {
+  const here = () => {
+    const dir = ctx.projectDir();
+    return { dir, name: path8.basename(dir), parent: path8.dirname(dir) };
+  };
+  const { pageDir, scriptDir } = ctx.client;
+  return [
+    { path: "/", handle: ({ res }) => sendFile(res, path8.join(pageDir, "index.html"), "text/html") },
+    { path: "/app.js", handle: ({ res }) => sendFile(res, path8.join(scriptDir, "app.js"), "text/javascript") },
+    { path: "/styles.css", handle: ({ res }) => sendFile(res, path8.join(pageDir, "styles.css"), "text/css") },
+    { path: "/synergenius.svg", handle: ({ res }) => sendFile(res, path8.join(pageDir, "assets", "synergenius.svg"), "image/svg+xml") },
+    { method: "GET", path: "/api/project", handle: ({ res }) => json(res, 200, here()) },
+    // Opening another project. The console is a local tool driving a local
+    // engine, so any directory the user can read is fair game -- but it
+    // must exist, and the answer re-points the watcher and the containment
+    // check together so neither is left pointing at the old project.
+    {
+      method: "POST",
+      path: "/api/project",
+      handle: async ({ res, body }) => {
+        const target = path8.resolve(String((await body()).dir ?? ""));
+        if (!fs10.existsSync(target) || !fs10.statSync(target).isDirectory()) {
+          return json(res, 400, { error: `not a directory: ${target}` });
+        }
+        await ctx.openProject(target);
+        return json(res, 200, here());
+      }
+    },
+    // Directories to choose from, so the console can offer a picker
+    // rather than asking someone to type a path.
+    {
+      path: "/api/browse",
+      handle: ({ res, q }) => {
+        const at2 = path8.resolve(q("dir") || ctx.projectDir());
+        try {
+          const entries = fs10.readdirSync(at2, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => ({ name: e.name, dir: path8.join(at2, e.name) })).sort((a, b) => a.name.localeCompare(b.name));
+          return json(res, 200, { dir: at2, parent: path8.dirname(at2), entries, crumbs: crumbsFor(at2) });
+        } catch (err) {
+          return json(res, 400, { error: getErrorMessage(err) });
+        }
+      }
+    },
+    {
+      path: "/api/workflows",
+      handle: async ({ res }) => {
+        const list = scanWorkflowNames(ctx.projectDir());
+        ctx.queueCheck();
+        const counts = await ctx.runs.waitingCounts();
+        return json(res, 200, list.map((w) => ctx.runs.withWaiting(w, counts)));
+      }
+    },
+    // A workflow as something to hand to someone: a brief for people who
+    // will not open the code, or the diagram. Sent as a download,
+    // self-contained.
+    {
+      path: "/api/artifact",
+      handle: async ({ res, q }) => {
+        const target = ctx.inProject(q("file"));
+        if (!target) return json(res, 400, OUTSIDE);
+        const { ast, errors } = await parseOne(target, q("name"));
+        if (!ast) return json(res, 400, { error: errors.join("\n") || "does not parse" });
+        const theme = q("theme") === "dark" ? "dark" : "light";
+        const kind = q("kind");
+        if (!ARTIFACT_KINDS.includes(kind)) return json(res, 400, { error: `unknown artifact ${kind}` });
+        let artifact;
+        try {
+          artifact = await renderArtifact(ast, kind, { theme, subtitle: path8.basename(ctx.projectDir()) });
+        } catch (e) {
+          return json(res, 500, { error: getErrorMessage(e) });
+        }
+        res.writeHead(200, { "Content-Type": artifact.type, "Content-Disposition": `attachment; filename="${ast.functionName}${artifact.extension}"`, "Cache-Control": "no-cache" });
+        return res.end(artifact.body);
+      }
+    },
+    {
+      path: "/api/workflow",
+      handle: async ({ res, q }) => {
+        const file = ctx.inProject(q("file"));
+        if (!file) return json(res, 400, OUTSIDE);
+        return json(res, 200, await describeWorkflow(ctx.projectDir(), file, q("name")));
+      }
+    },
+    // Expose a workflow as an endpoint, or change its routes: the @http
+    // lines are rewritten, nothing else in the file is touched.
+    {
+      method: "PUT",
+      path: "/api/workflow/http",
+      handle: async ({ res, body }) => {
+        const b = await body();
+        const target = ctx.inProject(String(b.file ?? ""));
+        if (!target) return json(res, 400, OUTSIDE);
+        const routes = [];
+        for (const raw of Array.isArray(b.routes) ? b.routes : []) {
+          const r = routeFrom(raw);
+          if (typeof r === "string") return json(res, 400, { error: r });
+          if (routes.some((x) => x.method === r.method && x.path === r.path)) return json(res, 400, { error: `${r.method} ${r.path} is listed twice` });
+          routes.push(r);
+        }
+        const out = await setHttpRoutes(target, String(b.name ?? ""), routes);
+        if (!out.ok) return json(res, 400, { error: out.error });
+        return json(res, 200, await describeWorkflow(ctx.projectDir(), target, String(b.name)));
+      }
+    },
+    // Every route the project declares, as one list: what `fw serve` or
+    // an embedding would mount, and what it would refuse.
+    {
+      path: "/api/endpoints",
+      handle: async ({ res }) => {
+        const names2 = scanWorkflowNames(ctx.projectDir());
+        const parsed = await Promise.all(names2.map(async (w) => {
+          const p = await parseOne(w.file, w.name);
+          const ast = p.ast;
+          const gates = ast ? ast.instances.filter((i) => nodeTypeOf(ast, i)?.durableGate !== void 0).length : 0;
+          return { file: w.file, rel: w.rel, name: w.name, description: ast?.description ?? "", routes: ast?.options?.http ?? [], gates, params: ast ? ports2(ast.startPorts) : [], returns: ast ? ports2(ast.exitPorts) : [], parses: !!ast };
+        }));
+        const plan = planRoutes(parsed.map((w) => ({ name: w.name, routes: w.routes, w })));
+        return json(res, 200, {
+          workflows: parsed.filter((w) => w.routes.length).map(({ routes, ...w }) => ({ ...w, routes: routes.map((r) => ({ ...r, mounted: plan.mounted.some((m) => m.owner.name === w.name && m.route === r) })) })),
+          candidates: parsed.filter((w) => !w.routes.length && w.parses).map(({ routes: _r, ...w }) => w),
+          problems: plan.problems,
+          serve: describeServe(ctx.supervisor())
+        });
+      }
+    },
+    // Version control: the commits that touched a file, and two versions
+    // of a workflow as one marked picture. `from`/`to` are git refs, or
+    // `worktree` for the file as it is now.
+    {
+      path: "/api/git/history",
+      handle: async ({ res, q }) => {
+        const file = ctx.inProject(q("file"));
+        if (!file) return json(res, 400, OUTSIDE);
+        return json(res, 200, await fileHistory(file));
+      }
+    },
+    {
+      path: "/api/diff",
+      handle: async ({ res, q }) => {
+        const file = ctx.inProject(q("file"));
+        if (!file) return json(res, 400, OUTSIDE);
+        const name = q("name"), from = q("from") || "HEAD", to = q("to") || "worktree";
+        const [a, b] = await Promise.all([astAt(file, name, from), astAt(file, name, to)]);
+        if (!a.ast) return json(res, 400, { error: a.error });
+        if (!b.ast) return json(res, 400, { error: b.error });
+        return json(res, 200, { from, to, ...buildDiffView(a.ast, b.ast) });
+      }
+    }
+  ];
+}
+
+// src/console/routes-tools.ts
+import * as path12 from "node:path";
+
+// src/docs/guide.ts
+var GROUPS = [
+  { title: "Getting started", topics: [["orientation"], ["tutorial"], ["console"]] },
+  {
+    title: "Authoring",
+    topics: [
+      ["concepts"],
+      ["jsdoc-grammar"],
+      ["advanced-annotations", { uses: ["pull", "expr", "scope"] }],
+      ["export-interface", { uses: ["scope"] }],
+      ["built-in-nodes", { uses: ["builtin:"] }],
+      ["node-conversion"],
+      ["visual-reference"],
+      ["scaffold"]
+    ]
+  },
+  {
+    title: "Running",
+    topics: [
+      ["library"],
+      ["durable-gates", { uses: ["gate:", "effect", "pure"] }],
+      ["debugging", { codes: true }],
+      ["cancellation"],
+      ["compilation"],
+      ["deployment"]
+    ]
+  },
+  { title: "Tooling", topics: [["cli-reference"], ["mcp-tools"], ["iterative-development"], ["marketplace"]] },
+  { title: "Reference", topics: [["error-codes", { codes: true }]] }
+];
+function guideOutline(topics = listTopics(), packSlugs = /* @__PURE__ */ new Set()) {
+  const byslug = new Map(topics.map((t) => [t.slug, t]));
+  const placed = /* @__PURE__ */ new Set();
+  const groups = [];
+  for (const g of GROUPS) {
+    const entries = [];
+    for (const [slug, related] of g.topics) {
+      const t = byslug.get(slug);
+      if (!t) continue;
+      placed.add(slug);
+      entries.push({ slug, name: t.name || slug, description: t.description, ...related ? { related } : {} });
+    }
+    if (entries.length) groups.push({ title: g.title, topics: entries });
+  }
+  const rest = topics.filter((t) => !placed.has(t.slug));
+  const more = rest.filter((t) => !packSlugs.has(t.slug)).map((t) => ({ slug: t.slug, name: t.name || t.slug, description: t.description }));
+  const packs = rest.filter((t) => packSlugs.has(t.slug)).map((t) => ({ slug: t.slug, name: t.name || t.slug, description: t.description }));
+  if (more.length) groups.push({ title: "More", topics: more });
+  if (packs.length) groups.push({ title: "Packs", topics: packs });
+  return groups;
+}
+
+// src/console/cli-catalog.ts
+var SKIP_GROUPS = /* @__PURE__ */ new Set(["Quick Reference", "Global Flag", "Related Topics"]);
+var cell = (s) => s.trim().replace(/^`|`$/g, "");
+function parseCliReference(markdown) {
+  const out = [];
+  let group = "";
+  let cur;
+  let fence = null;
+  let examplesNext = false;
+  let inFlags = false;
+  let described = false;
+  for (const raw of markdown.split("\n")) {
+    const line = raw.trimEnd();
+    const h2 = line.match(/^## (.+)$/);
+    if (h2) {
+      group = h2[1].trim();
+      cur = void 0;
+      fence = null;
+      continue;
+    }
+    const h3 = line.match(/^### (.+)$/);
+    if (h3) {
+      if (SKIP_GROUPS.has(group)) {
+        cur = void 0;
+        continue;
+      }
+      cur = { name: h3[1].trim(), words: [], group, description: "", usage: "", flags: [], examples: [] };
+      out.push(cur);
+      fence = null;
+      examplesNext = false;
+      inFlags = false;
+      described = false;
+      continue;
+    }
+    if (!cur) continue;
+    if (line.startsWith("```")) {
+      if (fence) {
+        fence = null;
+        continue;
+      }
+      fence = examplesNext ? "examples" : !cur.usage ? "usage" : "other";
+      examplesNext = false;
+      continue;
+    }
+    if (fence === "usage") {
+      if (!cur.usage && /^fw\b/.test(line)) {
+        cur.usage = line;
+        cur.words = line.split(/\s+/).slice(1).filter((w) => !/^[<[-]/.test(w));
+      }
+      continue;
+    }
+    if (fence === "examples") {
+      if (line.trim() && !line.startsWith("#")) cur.examples.push(line.trim());
+      continue;
+    }
+    if (fence) continue;
+    if (/^\*\*Examples:?\*\*/.test(line)) {
+      examplesNext = true;
+      continue;
+    }
+    if (/^\|\s*Flag\s*\|/i.test(line)) {
+      inFlags = true;
+      continue;
+    }
+    if (inFlags) {
+      if (!line.startsWith("|")) {
+        inFlags = false;
+      } else {
+        const cells = line.split("|").slice(1, -1);
+        if (cells.length >= 2 && !/^[\s-:]+$/.test(cells[0])) {
+          cur.flags.push({ flag: cell(cells[0]), description: cells[1].trim(), default: cell(cells[2] ?? "") });
+        }
+        continue;
+      }
+    }
+    if (!described && line.trim() && !line.startsWith("|") && !line.startsWith(">") && !line.startsWith("---")) {
+      cur.description = line.trim();
+      described = true;
+    }
+  }
+  return out.filter((c) => c.usage);
+}
+var cached;
+function cliCatalog() {
+  if (!cached) cached = parseCliReference(readTopic("cli-reference")?.content ?? "");
+  return cached;
+}
+
+// src/console/export.ts
+import * as path9 from "node:path";
+var defaultOutputDir = (file, target) => path9.join(path9.dirname(file), "dist", target);
+async function listTargets(projectDir) {
+  const registry = await createTargetRegistry(projectDir);
+  const packs = await describePacks(projectDir);
+  const owner = /* @__PURE__ */ new Map();
+  for (const p of packs) for (const t of p.exportTargets) owner.set(t.name, p.name);
+  return registry.getNames().map((name) => {
+    const t = registry.get(name);
+    return { name, description: t.description, pack: owner.get(name) ?? null, deploySchema: t.deploySchema ?? null };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+async function runExport(projectDir, req) {
+  const outputDir = path9.resolve(req.outputDir ?? defaultOutputDir(req.file, req.target));
+  const result = await exportWorkflow({
+    target: req.target,
+    input: req.file,
+    output: outputDir,
+    workflow: req.name,
+    dryRun: req.preview,
+    production: true,
+    projectDir
+  });
+  const files = result.files.map((f) => ({ path: path9.relative(outputDir, f.path).split(path9.sep).join("/"), content: f.content }));
+  const registry = await createTargetRegistry(projectDir);
+  const target = registry.get(req.target);
+  let instructions = null;
+  if (target && files.length) {
+    const artifacts = {
+      target: req.target,
+      workflowName: result.workflow,
+      entryPoint: files[0].path,
+      files: files.map((f) => ({ relativePath: f.path, absolutePath: path9.join(outputDir, f.path), content: f.content, type: "other" })),
+      warnings: result.warnings
+    };
+    try {
+      instructions = target.getDeployInstructions(artifacts);
+    } catch {
+      instructions = null;
+    }
+  }
+  return { target: req.target, outputDir, written: !req.preview, files, warnings: result.warnings ?? [], instructions };
+}
+
+// src/console/author.ts
+import * as fs11 from "node:fs";
+import * as path10 from "node:path";
+var PACK_NAME = /^(@[^/]+\/)?flow-weaver-pack-.+$/;
+var PACK_KEYWORD = "flow-weaver-marketplace-pack";
+function detectPackProject(projectDir) {
+  const file = path10.join(projectDir, "package.json");
+  if (!fs11.existsSync(file)) return { isPack: false };
+  try {
+    const pkg = JSON.parse(fs11.readFileSync(file, "utf8"));
+    const isPack = fs11.existsSync(path10.join(projectDir, "flowweaver.manifest.json")) || (pkg.keywords ?? []).includes(PACK_KEYWORD) || typeof pkg.name === "string" && PACK_NAME.test(pkg.name);
+    return isPack ? { isPack, name: pkg.name, version: pkg.version } : { isPack: false };
+  } catch {
+    return { isPack: false };
+  }
+}
+var names = (list) => new Set((list ?? []).map((x) => x.name));
+function manifestChanges(existing, next) {
+  if (!existing) return ["No flowweaver.manifest.json yet. fw market pack writes it."];
+  const out = [];
+  if (existing.version !== next.version) out.push(`version ${existing.version} \u2192 ${next.version}`);
+  if ((existing.description ?? "") !== (next.description ?? "")) out.push("description changed");
+  for (const [label, was, now] of [
+    ["node type", names(existing.nodeTypes), names(next.nodeTypes)],
+    ["workflow", names(existing.workflows), names(next.workflows)]
+  ]) {
+    for (const n of now) if (!was.has(n)) out.push(`${label} ${n} added`);
+    for (const n of was) if (!now.has(n)) out.push(`${label} ${n} removed`);
+  }
+  for (const n of next.nodeTypes ?? []) {
+    const e = (existing.nodeTypes ?? []).find((x) => x.name === n.name);
+    if (e && JSON.stringify({ i: e.inputs, o: e.outputs, d: e.description }) !== JSON.stringify({ i: n.inputs, o: n.outputs, d: n.description })) out.push(`node type ${n.name} changed`);
+  }
+  return out;
+}
+async function checkPackProject(projectDir) {
+  const { manifest, parsedFiles, errors } = await generateManifest({ directory: projectDir });
+  const validation = await validatePackage(projectDir, manifest);
+  const existing = readManifest(projectDir);
+  return {
+    name: manifest.name,
+    version: manifest.version,
+    parsedFiles: parsedFiles.length,
+    parseErrors: errors,
+    valid: validation.valid,
+    issues: validation.issues,
+    manifest: describePack({ name: manifest.name, version: manifest.version, manifest, path: projectDir }),
+    hasManifest: existing !== null,
+    changes: manifestChanges(existing, manifest)
+  };
+}
+
+// src/console/status.ts
+import * as fs12 from "node:fs";
+import * as os3 from "node:os";
+import * as path11 from "node:path";
+var realpath = (p) => {
+  try {
+    return fs12.realpathSync(p);
+  } catch {
+    return path11.resolve(p);
+  }
+};
+function installVerdict(command, args, here = installRoot()) {
+  const all = [command, ...args];
+  if (all.some((a) => /@synergenius\/flow-weaver(@|$)/.test(a)) && /npx|pnpm|yarn|bunx/.test(command)) return { runs: "npm latest" };
+  const pathArg = all.find((a) => /flow-weaver\.mjs$|[\\/]flow-weaver([\\/]|$)/.test(a) && /[\\/]/.test(a));
+  if (!pathArg) return { runs: "unknown" };
+  let install = realpath(pathArg);
+  for (let i = 0; i < 6 && !fs12.existsSync(path11.join(install, "package.json")); i++) install = path11.dirname(install);
+  return { runs: realpath(install) === realpath(here) ? "this install" : "other install", install };
+}
+function readJson(file) {
+  try {
+    return JSON.parse(fs12.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function mcpRegistrations(projectDir, home = os3.homedir(), here = installRoot()) {
+  const out = [];
+  const add = (tool, file, entry) => {
+    if (!entry || typeof entry.command !== "string") return;
+    const args = Array.isArray(entry.args) ? entry.args.map(String) : [];
+    out.push({ tool, file, command: entry.command, args, ...installVerdict(entry.command, args, here) });
+  };
+  const servers = (file, key) => {
+    const cfg = readJson(file);
+    const map = cfg?.[key];
+    return map?.["flow-weaver"];
+  };
+  add("Claude Code (project)", path11.join(projectDir, ".mcp.json"), servers(path11.join(projectDir, ".mcp.json"), "mcpServers"));
+  const claude = readJson(path11.join(home, ".claude.json"));
+  if (claude) {
+    add("Claude Code (user)", path11.join(home, ".claude.json"), claude.mcpServers?.["flow-weaver"]);
+    const projects = claude.projects;
+    const mine = projects?.[projectDir] ?? projects?.[realpath(projectDir)];
+    add("Claude Code (this project)", path11.join(home, ".claude.json"), mine?.mcpServers?.["flow-weaver"]);
+  }
+  add("Cursor", path11.join(projectDir, ".cursor", "mcp.json"), servers(path11.join(projectDir, ".cursor", "mcp.json"), "mcpServers"));
+  add("VS Code", path11.join(projectDir, ".vscode", "mcp.json"), servers(path11.join(projectDir, ".vscode", "mcp.json"), "servers"));
+  add("Windsurf", path11.join(home, ".codeium", "windsurf", "mcp_config.json"), servers(path11.join(home, ".codeium", "windsurf", "mcp_config.json"), "mcpServers"));
+  add("OpenClaw", path11.join(projectDir, "openclaw.json"), servers(path11.join(projectDir, "openclaw.json"), "mcpServers"));
+  return out;
+}
+async function probe(url, init, timeoutMs = 2500) {
+  const started = Date.now();
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { ...init, signal: ctl.signal });
+    return { url, ok: res.ok, status: res.status, ms: Date.now() - started };
+  } catch (err) {
+    return { url, ok: false, ms: Date.now() - started, error: err instanceof Error ? err.name === "AbortError" ? "timed out" : err.message : String(err) };
+  } finally {
+    clearTimeout(t);
+  }
+}
+async function registryStatuses(projectDir, registries = resolveRegistries(projectDir)) {
+  return Promise.all(registries.map(async (r) => {
+    const url = `${r.url}-/whoami`;
+    const started = Date.now();
+    const ctl = new AbortController();
+    const t = setTimeout(() => ctl.abort(), 2500);
+    try {
+      const res = await fetch(url, { headers: r.authorization ? { Authorization: r.authorization } : {}, signal: ctl.signal });
+      let user;
+      if (res.ok) {
+        try {
+          user = (await res.json()).username;
+        } catch {
+        }
+      }
+      const reachable = res.ok || !r.authorization && (res.status === 401 || res.status === 403);
+      return { url: r.url, scopes: r.scopes, authenticated: !!r.authorization, ok: reachable, status: res.status, ms: Date.now() - started, user };
+    } catch (err) {
+      return { url: r.url, scopes: r.scopes, authenticated: !!r.authorization, ok: false, ms: Date.now() - started, error: err instanceof Error ? err.name === "AbortError" ? "timed out" : err.message : String(err) };
+    } finally {
+      clearTimeout(t);
+    }
+  }));
+}
+async function describeStatus(projectDir, info) {
+  const services = listServices().map((s) => ({ ...s, alive: true }));
+  const serve = services.filter((s) => s.kind === "serve" && s.url);
+  const [http2, registries] = await Promise.all([
+    Promise.all(serve.map(async (service) => ({ service, probe: await probe(`${service.url.replace(/\/$/, "")}/health`) }))),
+    registryStatuses(projectDir)
+  ]);
+  return {
+    console: { version: VERSION, install: installRoot(), project: projectDir, url: info.url, watching: info.watching, runsDir: info.runsDir },
+    services,
+    mcp: { registrations: mcpRegistrations(projectDir), running: services.filter((s) => s.kind === "mcp-server") },
+    doctor: runDoctorChecks(projectDir),
+    http: http2,
+    registries,
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/console/routes-tools.ts
+var CLI_TIMEOUT_MS = 5 * 60 * 1e3;
+function toolRoutes(ctx) {
+  return [
+    // An empty or one-letter query matches every topic with an empty
+    // heading and excerpt, which is noise rather than a result list.
+    {
+      path: "/api/docs/search",
+      handle: ({ res, q }) => {
+        const query = q("q").trim();
+        const limit = Math.min(80, Math.max(1, Number(q("limit")) || 12));
+        return json(res, 200, query.length < 2 ? [] : searchDocs(query).filter((r) => r.heading).slice(0, limit));
+      }
+    },
+    { path: "/api/docs/topics", handle: ({ res }) => json(res, 200, listTopics()) },
+    {
+      path: "/api/docs/guide",
+      handle: ({ res }) => json(res, 200, guideOutline(listTopics(), new Set(getPackDocTopics().map((t) => t.slug))))
+    },
+    // The page as markdown for rendering, its sections for the contents
+    // list, and the compact form -- what `fw_docs` hands an assistant --
+    // for copying into a conversation.
+    {
+      path: "/api/docs/topic",
+      handle: ({ res, q }) => {
+        const slug = q("slug");
+        const full = readTopic(slug);
+        if (!full) return json(res, 404, { error: `no topic ${slug}` });
+        const structured = readTopicStructured(slug);
+        return json(res, 200, {
+          slug,
+          name: full.name,
+          description: full.description,
+          sections: structured?.sections.map((s) => ({ heading: s.heading, level: s.level })) ?? [],
+          markdown: full.content,
+          compact: readTopic(slug, true)?.content ?? ""
+        });
+      }
+    },
+    { path: "/api/docs/error", handle: ({ res, q }) => json(res, 200, errorCodeSection(q("code"))) },
+    // Core commands from the reference, then each installed pack's, so
+    // completion knows `fw audio replay` as well as `fw validate`.
+    {
+      path: "/api/cli/commands",
+      handle: async ({ res }) => {
+        const packCommands = (await describePacks(ctx.projectDir())).flatMap((p) => p.cliCommands.map((c) => ({
+          name: `${p.namespace} ${c.name}`,
+          words: [p.namespace, c.name],
+          group: `Pack: ${p.namespace}`,
+          description: c.description,
+          usage: c.usage,
+          flags: c.flags,
+          examples: []
+        })));
+        return json(res, 200, [...cliCatalog(), ...packCommands]);
+      }
+    },
+    // An fw command, run in the project, its output streamed back. The
+    // argument list is spawned as is -- no shell -- and the child goes
+    // when the page lets go of the stream.
+    {
+      method: "POST",
+      path: "/api/cli/run",
+      handle: async ({ req, res, body }) => {
+        const argv = (await body()).argv;
+        const plan = planFwCommand(Array.isArray(argv) ? argv : []);
+        if (!plan.ok) return json(res, 400, { error: plan.error });
+        sse(res);
+        const started = Date.now();
+        const emit = (msg) => send(res, msg);
+        emit({ type: "start", args: plan.args });
+        let child;
+        try {
+          child = spawnFw(plan.args, ctx.projectDir());
+        } catch (err) {
+          emit({ type: "exit", code: null, error: getErrorMessage(err), ms: 0 });
+          res.end();
+          return;
+        }
+        child.stdout?.on("data", (d) => emit({ type: "out", text: d.toString() }));
+        child.stderr?.on("data", (d) => emit({ type: "err", text: d.toString() }));
+        const timer = setTimeout(() => child.kill(), CLI_TIMEOUT_MS);
+        child.on("error", (err) => {
+          emit({ type: "exit", code: null, error: err.message, ms: Date.now() - started });
+          res.end();
+        });
+        child.on("close", (code) => {
+          clearTimeout(timer);
+          emit({ type: "exit", code, ms: Date.now() - started });
+          res.end();
+        });
+        req.on("close", () => {
+          clearTimeout(timer);
+          if (child.exitCode === null) child.kill();
+        });
+      }
+    },
+    { path: "/api/packs", handle: async ({ res }) => json(res, 200, await describePacks(ctx.projectDir())) },
+    { path: "/api/export/targets", handle: async ({ res }) => json(res, 200, await listTargets(ctx.projectDir())) },
+    {
+      method: "POST",
+      path: "/api/export",
+      handle: async ({ res, body }) => {
+        const b = await body();
+        const target = ctx.inProject(String(b.file));
+        if (!target) return json(res, 400, { error: "file is outside the project" });
+        try {
+          return json(res, 200, await runExport(ctx.projectDir(), {
+            file: target,
+            name: String(b.name),
+            target: String(b.target),
+            outputDir: typeof b.outputDir === "string" && b.outputDir ? path12.resolve(ctx.projectDir(), b.outputDir) : void 0,
+            preview: b.preview !== false
+          }));
+        } catch (err) {
+          return json(res, 400, { error: getErrorMessage(err) });
+        }
+      }
+    },
+    // The project as a pack: cheap to detect, slow to check (every source
+    // file is parsed), so the check is a separate call made on request.
+    { path: "/api/pack-project", handle: ({ res }) => json(res, 200, detectPackProject(ctx.projectDir())) },
+    {
+      path: "/api/pack-project/check",
+      handle: async ({ res }) => {
+        if (!detectPackProject(ctx.projectDir()).isPack) return json(res, 400, { error: "the project is not a pack" });
+        try {
+          return json(res, 200, await checkPackProject(ctx.projectDir()));
+        } catch (err) {
+          return json(res, 400, { error: getErrorMessage(err) });
+        }
+      }
+    },
+    // The marketplace is npm: a search goes to the registry, and installing
+    // is `fw market install`, which the command-line pane runs when asked
+    // to. Every registry the project's npm uses is searched, credentials
+    // included: a private pack is on a private registry, and .npmrc says which.
+    {
+      path: "/api/market/search",
+      handle: async ({ res, q }) => json(res, 200, await searchAllRegistries({ query: q("q") || void 0, limit: 30, projectDir: ctx.projectDir() }))
+    },
+    // Everything around the project: services alive, MCP registrations,
+    // the environment and registries. Probes are brief.
+    { path: "/api/status", handle: async ({ res }) => json(res, 200, await describeStatus(ctx.projectDir(), ctx.status())) }
+  ];
+}
+
+// src/console/routes-runs.ts
+async function debugAction(ctx, id, { res, body }) {
+  const { debug } = ctx.runs;
+  const d = debug.get(id);
+  if (!d) return json(res, 404, { error: "not a debug session" });
+  const b = await body();
+  const action = String(b.action);
+  try {
+    if (action === "step" || action === "continue" || action === "toBreakpoint") {
+      if (d.status !== "paused") return json(res, 400, { error: `the session is ${d.status}, not paused` });
+      const move = action === "step" ? debug.step(id) : debug.continue(id, action === "toBreakpoint");
+      move.catch(() => void 0);
+    } else if (action === "abort") {
+      debug.abort(id).catch(() => void 0);
+    } else if (action === "set") {
+      debug.setVariable(id, String(b.node), String(b.port), b.value);
+      ctx.runs.announce(id, { type: "event", t: Date.now(), e: { type: "VARIABLE_SET", identifier: { id: String(b.node), portName: String(b.port) }, value: b.value } });
+    } else if (action === "breakpoint") {
+      debug.breakpoint(id, b.op === "remove" ? "remove" : "add", String(b.node));
+    } else {
+      return json(res, 400, { error: `unknown action ${action}` });
+    }
+    return json(res, 200, await ctx.runs.snapshot(id));
+  } catch (err) {
+    return json(res, 400, { error: getErrorMessage(err) });
+  }
+}
+function runRoutes(ctx) {
+  const { runs } = ctx;
+  return [
+    { method: "GET", path: "/api/runs", handle: async ({ res, q }) => json(res, 200, await runs.list(q("file"), q("name"))) },
+    {
+      method: "POST",
+      path: "/api/runs",
+      handle: async ({ res, body }) => {
+        const b = await body();
+        const target = ctx.inProject(String(b.file));
+        if (!target) return json(res, 400, { error: "file is outside the project" });
+        const mocks = mocksFrom(b);
+        const source = await stamp(target).catch(() => void 0);
+        const params = b.params ?? {};
+        if (b.debug === true) {
+          const bps = Array.isArray(b.breakpoints) ? b.breakpoints.filter((x) => typeof x === "string") : [];
+          return json(res, 200, runs.startDebug(target, String(b.name), params, bps, mocks, b.runTo === "breakpoint" ? "breakpoint" : "first", source));
+        }
+        return json(res, 200, await runs.start(target, String(b.name), params, mocks, source, b.agents === "manual" ? "manual" : "auto"));
+      }
+    },
+    {
+      path: /^\/api\/runs\/([^/]+)(?:\/(events|resolve|cancel|debug|agent))?$/,
+      handle: async (call) => {
+        const { req, res, q, body, match } = call;
+        const id = match[1];
+        const sub = match[2];
+        if (!await runs.snapshot(id)) return json(res, 404, { error: "no such run" });
+        if (!sub && req.method === "DELETE") {
+          try {
+            await runs.remove(id);
+          } catch (err) {
+            return json(res, 409, { error: getErrorMessage(err) });
+          }
+          return json(res, 200, { removed: id });
+        }
+        if (sub === "events") return runs.watch(id, req, res);
+        if (sub === "resolve" && req.method === "POST") {
+          try {
+            await runs.resume(id, await body());
+            return json(res, 200, await runs.snapshot(id));
+          } catch (err) {
+            return json(res, 400, { error: getErrorMessage(err) });
+          }
+        }
+        if (sub === "agent" && req.method === "POST") {
+          const refused = await runs.askAgent(id);
+          if (refused) return json(res, 409, { error: refused });
+          return json(res, 200, await runs.snapshot(id));
+        }
+        if (sub === "agent" && req.method === "GET") {
+          const rec = await ctx.runs.record(id);
+          const gateId = q("gate") || rec?.agent?.gateId;
+          const kept = gateId ? await ctx.runs.kept(id, transcriptName(gateId)) : void 0;
+          if (!kept) return json(res, 404, { error: "no agent has answered this run" });
+          return json(res, 200, kept);
+        }
+        if (sub === "cancel" && req.method === "POST") {
+          await runs.cancel(id);
+          return json(res, 200, await runs.snapshot(id));
+        }
+        if (sub === "debug" && req.method === "POST") return debugAction(ctx, id, call);
+        return json(res, 200, await runs.withEvents(id));
+      }
+    }
+  ];
+}
+
+// src/console/router.ts
+function findRoute(routes, method, pathname) {
+  for (const route of routes) {
+    if (route.method && route.method !== method) continue;
+    if (typeof route.path === "string") {
+      if (route.path === pathname) return { route, match: [] };
+    } else {
+      const match = pathname.match(route.path);
+      if (match) return { route, match };
+    }
+  }
+  return void 0;
+}
+
+// src/console/request-guard.ts
+var SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+function hostName(host) {
+  const bracketed = host.match(/^\[[^\]]*\]/);
+  return (bracketed ? bracketed[0] : host.replace(/:\d*$/, "")).toLowerCase();
+}
+function refusal(req, bound) {
+  const host = typeof req.headers.host === "string" ? req.headers.host : "";
+  if (!host) return "the request has no Host header";
+  if (isLoopback(bound) && !isLoopback(hostName(host))) {
+    return `the console answers only to a loopback Host, not ${host}`;
+  }
+  const origin = req.headers.origin;
+  if (origin === void 0 || SAFE_METHODS.has((req.method ?? "GET").toUpperCase())) return void 0;
+  if (origin !== `http://${host}`) {
+    return `a change is accepted only from the console's own origin, not ${String(origin)}`;
+  }
+  return void 0;
+}
+
+// src/console/server.ts
+function resolveAssets(explicit) {
+  const here = path13.dirname(fileURLToPath2(import.meta.url));
+  const candidates = [explicit, here, path13.join(here, "..", "console"), path13.join(here, "..", "..", "dist", "console")].filter(Boolean);
+  return candidates.find((dir) => fs13.existsSync(path13.join(dir, "index.html")) && fs13.existsSync(path13.join(dir, "app.js")));
+}
+async function devBuild(onRebuilt) {
+  const here = path13.dirname(fileURLToPath2(import.meta.url));
+  const uiDir = path13.join(here, "..", "..", "console-ui");
+  if (!fs13.existsSync(path13.join(uiDir, "src", "main.tsx"))) return void 0;
+  let esbuild;
+  try {
+    esbuild = await import("esbuild");
+  } catch {
+    return void 0;
+  }
+  const out = path13.join(here, "..", "..", "dist", ".console-dev");
+  fs13.mkdirSync(out, { recursive: true });
+  const ctx = await esbuild.context({
+    entryPoints: [path13.join(uiDir, "src", "main.tsx")],
+    bundle: true,
+    outfile: path13.join(out, "app.js"),
+    format: "esm",
+    target: "es2022",
+    jsx: "automatic",
+    jsxImportSource: "preact",
+    sourcemap: "inline",
+    logLevel: "warning",
+    absWorkingDir: uiDir,
+    plugins: [{ name: "reload", setup(b) {
+      b.onEnd((res) => {
+        if (!res.errors.length) onRebuilt();
+      });
+    } }]
+  });
+  await ctx.watch();
+  const chokidar = await import("chokidar");
+  chokidar.watch([path13.join(uiDir, "index.html"), path13.join(uiDir, "styles.css")], { ignoreInitial: true }).on("all", onRebuilt);
+  return { serveFrom: uiDir, scriptFrom: out };
+}
+function within(root, p) {
+  if (!p) return null;
+  const abs = path13.resolve(p);
+  const fold = (x) => path13.sep === "\\" || process.platform === "darwin" ? x.toLowerCase() : x;
+  const a = fold(abs);
+  const r = fold(root);
+  return a === r || a.startsWith(r + path13.sep) ? abs : null;
+}
+async function createConsoleServer(options) {
+  let projectDir = path13.resolve(options.projectDir);
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 4311;
+  const watching = options.watch !== false;
+  const followers = /* @__PURE__ */ new Set();
+  const broadcast = (msg) => {
+    for (const res of followers) send(res, msg);
+  };
+  const runsDir = defaultRunsDir(projectDir);
+  const coordinator = createLocalCoordinator(options.store ? { store: options.store } : { rootDir: runsDir });
+  await reclaimStaleAgentAnswers(coordinator).catch(() => void 0);
+  const profiles = createProfileCache(() => projectDir);
+  const runs = createRunDriver({ coordinator, broadcast, projectDir: () => projectDir, profiles: () => profiles.get() });
+  const superviseFor = (dir) => new Supervisor({
+    projectDir: dir,
+    ...options.services,
+    onChange: (e) => {
+      if (!e.line) broadcast({ type: "services", kind: e.kind, state: e.state, url: e.url ?? null, exitCode: e.exitCode ?? null, error: e.error ?? null });
+    }
+  });
+  let supervisor = superviseFor(projectDir);
+  let checking;
+  function queueCheck() {
+    if (checking) return;
+    const dir = projectDir;
+    checking = checkWorkflows(dir, (summary) => {
+      if (dir === projectDir) broadcast({ type: "checked", workflow: runs.withWaiting(summary) });
+    }).then(() => void 0).catch(() => void 0).finally(() => {
+      checking = void 0;
+    });
+  }
+  let watcher;
+  async function watchProject() {
+    if (!watching) return;
+    await watcher?.close();
+    const chokidar = await import("chokidar");
+    watcher = chokidar.watch(projectDir, {
+      ignoreInitial: true,
+      ignored: (p) => /(^|[\\/])(node_modules|dist|\.git|\.fw)([\\/]|$)/.test(p) || /(^|[\\/])\.fw-diff-/.test(p)
+    });
+    watcher.on("all", (_event, file) => {
+      if (typeof file === "string" && file.endsWith(".ts")) {
+        invalidateListing(projectDir);
+        broadcast({ type: "changed", file });
+      }
+    });
+  }
+  await watchProject();
+  await loadPackDocTopics(projectDir).catch(() => 0);
+  await runs.follow({ watching, runsDir: options.store ? void 0 : runsDir });
+  const heartbeat = setInterval(() => {
+    for (const res of followers) res.write(": ping\n\n");
+    runs.ping();
+  }, 15e3);
+  const dev = options.assetsDir ? void 0 : await devBuild(() => broadcast({ type: "client" }));
+  const built = dev ? void 0 : resolveAssets(options.assetsDir);
+  if (!built && !dev) throw new Error("console client not found: run `npm run build:console`, or pass assetsDir");
+  let actualPort = port;
+  const ctx = {
+    projectDir: () => projectDir,
+    async openProject(dir) {
+      projectDir = dir;
+      invalidateListing(projectDir);
+      await supervisor.close().catch(() => void 0);
+      supervisor = superviseFor(projectDir);
+      await watchProject();
+      await loadPackDocTopics(projectDir).catch(() => 0);
+      options.onProject?.(projectDir);
+      broadcast({ type: "project" });
+    },
+    inProject: (p) => within(projectDir, p),
+    broadcast,
+    followers,
+    queueCheck,
+    supervisor: () => supervisor,
+    profiles,
+    runs,
+    status: () => ({ url: `http://${host}:${actualPort}`, watching, runsDir: options.store ? "a run store of your own" : runsDir }),
+    client: { pageDir: dev?.serveFrom ?? built, scriptDir: dev?.scriptFrom ?? built }
+  };
+  const routes = [...projectRoutes(ctx), ...toolRoutes(ctx), ...agentRoutes(ctx), ...serviceRoutes(ctx), ...runRoutes(ctx)];
+  const handle = async (req, res) => {
+    const refused = refusal(req, host);
+    if (refused) return json(res, 403, { error: refused });
+    let url;
+    try {
+      url = new URL(req.url ?? "/", `http://${host}`);
+    } catch {
+      return json(res, 400, { error: "the request target is not a valid URL" });
+    }
+    try {
+      const found = findRoute(routes, req.method ?? "GET", url.pathname);
+      if (!found) return json(res, 404, { error: "not found" });
+      await found.route.handle({ req, res, url, match: found.match, q: (k) => url.searchParams.get(k) ?? "", body: () => readBody(req) });
+    } catch (err) {
+      if (res.headersSent) {
+        res.destroy();
+        return;
+      }
+      json(res, err instanceof BadRequest ? 400 : 500, { error: getErrorMessage(err) });
+    }
+  };
+  const server = http.createServer((req, res) => {
+    handle(req, res).catch(() => res.destroy());
+  });
+  await new Promise((resolve9, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => resolve9());
+  });
+  const address = server.address();
+  actualPort = typeof address === "object" && address ? address.port : port;
+  for (const kind of ["serve", "watch"]) {
+    if (supervisor.settings()[kind].autoStart) {
+      try {
+        supervisor.start(kind);
+      } catch {
+      }
+    }
+  }
+  return {
+    url: `http://${host}:${actualPort}`,
+    async close() {
+      clearInterval(heartbeat);
+      await supervisor.close().catch(() => void 0);
+      await watcher?.close();
+      await runs.close();
+      for (const res of followers) res.end();
+      await new Promise((resolve9) => server.close(() => resolve9()));
+    }
+  };
+}
+export {
+  createConsoleServer,
+  stepLabel
+};