@nutteen/conductor-ui 0.1.0

package/dist/main/index.js

@@ -0,0 +1,1608 @@
+import { app, nativeImage, BrowserWindow, ipcMain, dialog, shell, nativeTheme } from "electron";
+import { fileURLToPath } from "node:url";
+import { readdir, readFile, writeFile, rm, stat, copyFile, chmod, rename, mkdir, open } from "node:fs/promises";
+import { resolve, basename, delimiter, join, dirname } from "node:path";
+import { loadManagedConfig, resolveRuntimeDir, readRuntimeRecords, loadWorkflow, redactSensitive, serializableGraphSpec, buildRunSnapshotsFromLogLines, isProcessRunning, replayWalks, parseRunEventLines, readGraphCheckpoint, buildControlTowerReport, readLogLines, preflightFlows, readRuntimeRecord, watchWorkflow } from "@nutteen/conductor/lib";
+import { execFile } from "node:child_process";
+import { createRequire } from "node:module";
+import { statSync, accessSync, constants, mkdirSync, writeFileSync, readFileSync, watch } from "node:fs";
+import { createHash } from "node:crypto";
+const CHANNELS = {
+  getFlows: "conductor:get-flows",
+  getWorkflow: "conductor:get-workflow",
+  getTickets: "conductor:get-tickets",
+  getTicket: "conductor:get-ticket",
+  getReport: "conductor:get-report",
+  getInitialView: "conductor:get-initial-view",
+  setTheme: "conductor:set-theme",
+  openWorkflowFile: "conductor:open-workflow-file",
+  revealPath: "conductor:reveal-path",
+  subscribe: "conductor:subscribe",
+  pushTickets: "conductor:push-tickets",
+  pushEvents: "conductor:push-events",
+  pushWorkflow: "conductor:push-workflow",
+  // Lifecycle and config. Each one is five mechanical edits — this list, a
+  // request/response type, a `ConductorBridge` method, a preload line and an
+  // `ipcMain.handle` — and because `App.test.tsx` builds a fully typed bridge, a
+  // missing stub is a compile error there rather than an empty panel at runtime.
+  preflight: "conductor:preflight",
+  startFlow: "conductor:start-flow",
+  stopFlow: "conductor:stop-flow",
+  restartFlow: "conductor:restart-flow",
+  getDaemonConfig: "conductor:get-daemon-config",
+  chooseDaemonConfig: "conductor:choose-daemon-config",
+  readFlowsConfig: "conductor:read-flows-config",
+  previewFlowsEdit: "conductor:preview-flows-edit",
+  commitFlowsEdit: "conductor:commit-flows-edit",
+  pushFlows: "conductor:push-flows",
+  pushDaemon: "conductor:push-daemon"
+};
+const LIST_LOG_LIMIT = 4e3;
+const TICKET_LOG_LIMIT = 6e4;
+const STALE_AFTER_MS = 3e5;
+function runtimeDirFor(options = {}) {
+  return resolveRuntimeDir({ cliRuntimeDir: options.runtimeDir ?? null, configRuntimeDir: null });
+}
+async function resolveSourceRuntimeDir(configPath, cliRuntimeDir) {
+  let configRuntimeDir = null;
+  if (configPath) {
+    try {
+      configRuntimeDir = (await loadManagedConfig(configPath)).runtime_dir ?? null;
+    } catch {
+    }
+  }
+  return resolveRuntimeDir({ cliRuntimeDir, configRuntimeDir });
+}
+function flowFromRecord(record) {
+  return {
+    name: record.name,
+    workflow: record.workflow || null,
+    log_file: record.log_file || null,
+    runtime_dir: record.runtime_dir,
+    pid: record.pid,
+    // Liveness, not a precondition: a stopped flow still has a log, and the whole
+    // point of replaying from the log is that the app works with no daemon running.
+    //
+    // `isProcessRunning` alone, deliberately **not** `&& !record.stopped_at`.
+    // `conductor stop` writes `stopped_at` and removes the pid file synchronously
+    // and unconditionally, while the daemon's `shutdown()` aborts in-flight graphs
+    // and awaits them — which can take minutes. A record that says stopped is
+    // therefore routinely a record whose process is still very much alive, still
+    // holding a workspace. `stopped_at` crosses the wire too, but as the thing that
+    // distinguishes a clean stop from a crash, never as liveness.
+    //
+    // `record.pid > 0` is not defensive noise: `isProcessRunning(0)` returns **true**,
+    // because `process.kill(0, sig)` signals the whole process group.
+    running: record.pid > 0 && isProcessRunning(record.pid),
+    started_at: record.started_at || null,
+    stopped_at: record.stopped_at ?? null,
+    assignee: record.assignee ?? null,
+    labels: record.labels ?? []
+  };
+}
+function flowFromDeclaration(flow, runtimeDir) {
+  return {
+    name: flow.name,
+    workflow: flow.workflow,
+    // No record means no log yet. The panels handle this: it is the same state as a
+    // flow whose log has been deleted.
+    log_file: null,
+    runtime_dir: runtimeDir,
+    pid: null,
+    running: false,
+    started_at: null,
+    stopped_at: null,
+    assignee: flow.assignee ?? null,
+    labels: flow.labels ?? []
+  };
+}
+async function declaredFlows(options) {
+  if (!options.configPath) return [];
+  try {
+    return (await loadManagedConfig(options.configPath)).flows;
+  } catch {
+    return [];
+  }
+}
+async function listFlows(options = {}) {
+  const runtimeDir = runtimeDirFor(options);
+  const records = await readRuntimeRecords(runtimeDir);
+  const flows = records.map(flowFromRecord);
+  const known = new Set(flows.map((flow) => flow.name));
+  for (const declared of await declaredFlows(options)) {
+    if (!known.has(declared.name)) flows.push(flowFromDeclaration(declared, runtimeDir));
+  }
+  return flows.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function findRecord(flow, options) {
+  const records = await readRuntimeRecords(runtimeDirFor(options));
+  return records.find((record) => record.name === flow) ?? null;
+}
+function isValidationError(value) {
+  return typeof value === "object" && value !== null && "code" in value && "message" in value;
+}
+function errorMessage$1(err) {
+  if (isValidationError(err)) return `[${err.code}] ${err.message}`;
+  return err instanceof Error ? err.message : String(err);
+}
+function attributeDiagnostic(message, level, knownNodes) {
+  const quoted = [...message.matchAll(/'([^']+)'/g)].map((match) => match[1]);
+  const edgeMatch = /'([^']+)'\s*->\s*'([^']+)'/.exec(message);
+  if (edgeMatch) {
+    return { level, message, node: null, edge: { from: edgeMatch[1], to: edgeMatch[2] } };
+  }
+  const named = quoted.find((name) => knownNodes.includes(name));
+  return { level, message, node: named ?? null, edge: null };
+}
+function agentProfilesFrom(config) {
+  const agents = config["agents"];
+  if (typeof agents !== "object" || agents === null || Array.isArray(agents)) return {};
+  const profiles = {};
+  for (const [name, raw] of Object.entries(agents)) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      profiles[name] = { provider: null, model: null };
+      continue;
+    }
+    const entry = raw;
+    profiles[name] = {
+      provider: typeof entry["provider"] === "string" ? entry["provider"] : null,
+      model: typeof entry["model"] === "string" ? entry["model"] : null
+    };
+  }
+  return profiles;
+}
+async function readWorkflow(input, options = {}) {
+  let path = input.path ? resolve(input.path) : null;
+  let flow = input.flow ?? null;
+  if (!path && flow) {
+    const record = await findRecord(flow, options);
+    const declared = record?.workflow ? null : (await declaredFlows(options)).find((item) => item.name === flow)?.workflow ?? null;
+    if (declared) {
+      path = declared;
+    } else if (!record?.workflow) {
+      return {
+        flow,
+        path: "",
+        graph: null,
+        agent_profiles: {},
+        diagnostics: [
+          {
+            level: "error",
+            message: `Nothing names a workflow file for flow '${flow}': no runtime record, and no matching entry in the selected flows.yaml. Start the flow once, choose a flows.yaml, or open the workflow file directly.`,
+            node: null,
+            edge: null
+          }
+        ],
+        loaded_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } else {
+      path = record.workflow;
+    }
+  }
+  if (!path) {
+    throw new Error("readWorkflow needs either a flow name or a workflow path");
+  }
+  flow ??= basename(path).replace(/\.md$/i, "");
+  try {
+    const definition = await loadWorkflow(path);
+    const knownNodes = definition.graph.nodes.map((node) => node.name);
+    return {
+      flow,
+      path,
+      graph: serializableGraphSpec(definition.graph),
+      agent_profiles: agentProfilesFrom(definition.config),
+      diagnostics: definition.warnings.map(
+        (warning) => attributeDiagnostic(redactSensitive(warning), "warning", knownNodes)
+      ),
+      loaded_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (err) {
+    return {
+      flow,
+      path,
+      graph: null,
+      agent_profiles: {},
+      // No graph loaded means no node list to attribute against, so the message
+      // stands on its own — which is still strictly more than the log gave you.
+      diagnostics: [attributeDiagnostic(redactSensitive(errorMessage$1(err)), "error", [])],
+      loaded_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+async function logLinesFor(flow, limit, options) {
+  const record = await findRecord(flow, options);
+  if (!record) {
+    return { lines: [], record: null, errors: [] };
+  }
+  if (!record.log_file) {
+    return { lines: [], record, errors: [`The runtime record for flow '${flow}' names no log file.`] };
+  }
+  try {
+    return { lines: await readLogLines(record.log_file, { limit }), record, errors: [] };
+  } catch (err) {
+    return { lines: [], record, errors: [redactSensitive(`Cannot read ${record.log_file}: ${errorMessage$1(err)}`)] };
+  }
+}
+async function readTickets(flow, options = {}) {
+  const { lines, record, errors } = await logLinesFor(flow, LIST_LOG_LIMIT, options);
+  const tickets = buildRunSnapshotsFromLogLines(lines, {
+    flowName: flow,
+    logFile: record?.log_file ?? null,
+    processRunning: record ? isProcessRunning(record.pid) : false,
+    now: /* @__PURE__ */ new Date(),
+    staleAfterMs: STALE_AFTER_MS
+  });
+  const walks = {};
+  const runs = {};
+  for (const walk of replayWalks(lines)) {
+    walks[walk.run_id] = walk;
+    (runs[walk.identifier] ??= []).push(walk);
+  }
+  return { flow, tickets, walks, runs, generated_at: (/* @__PURE__ */ new Date()).toISOString(), errors };
+}
+function sortableTime(value) {
+  if (!value) return 0;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function scopeEventsToRun(events, walks, runId) {
+  const chronological = [...walks].sort((a, b) => sortableTime(a.started_at) - sortableTime(b.started_at));
+  const index = chronological.findIndex((walk) => walk.run_id === runId);
+  if (index < 0) return [];
+  const from = sortableTime(chronological[index].started_at);
+  const next = chronological[index + 1];
+  const until = next ? sortableTime(next.started_at) : Number.POSITIVE_INFINITY;
+  return events.filter((event) => {
+    const at = sortableTime(event.ts);
+    return at >= from && at < until;
+  });
+}
+async function readTicket(input, options = {}) {
+  const { flow, identifier } = input;
+  const { lines, record } = await logLinesFor(flow, TICKET_LOG_LIMIT, options);
+  const walks = replayWalks(lines, { identifier });
+  const walk = (input.runId ? walks.find((item) => item.run_id === input.runId) : walks[0]) ?? null;
+  const mine = parseRunEventLines(lines).filter((event) => event.identifier === identifier);
+  const events = walk ? scopeEventsToRun(mine, walks, walk.run_id) : [];
+  const snapshots = buildRunSnapshotsFromLogLines(lines, {
+    flowName: flow,
+    logFile: record?.log_file ?? null,
+    processRunning: record ? isProcessRunning(record.pid) : false,
+    now: /* @__PURE__ */ new Date(),
+    staleAfterMs: STALE_AFTER_MS
+  });
+  const snapshot = snapshots.find(
+    (item) => item.issue_key === identifier && (walk === null || item.attempt === walk.attempt)
+  ) ?? null;
+  const isLatestRun = walk === null || walks[0]?.run_id === walk.run_id;
+  const checkpoint = isLatestRun ? await readGraphCheckpoint(runtimeDirFor(options), flow, identifier) : null;
+  return {
+    flow,
+    identifier,
+    snapshot,
+    walk,
+    source: checkpoint ? "checkpoint" : walk ? "log" : "none",
+    state: checkpoint?.state ?? null,
+    state_updated_at: checkpoint?.updated_at ?? null,
+    checkpoint_cursor: checkpoint?.cursor ?? null,
+    events
+  };
+}
+async function readReport(input, options = {}) {
+  return buildControlTowerReport({
+    configPath: options.configPath ?? null,
+    runtimeDir: options.runtimeDir ?? null,
+    flowName: input.flow ?? null,
+    json: true,
+    recentLimit: 50,
+    staleAfterMs: null
+  });
+}
+const PATH_MARKER_START = "__CONDUCTOR_PATH__";
+const PATH_MARKER_END = "__CONDUCTOR_PATH_END__";
+const GUI_DEFAULT_PATH = "/usr/bin:/bin:/usr/sbin:/sbin";
+const PROBE_TIMEOUT_MS = 5e3;
+function isExecutableFile(candidate) {
+  try {
+    if (!statSync(candidate).isFile()) return false;
+    accessSync(candidate, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runShell(shell2, script, timeoutMs) {
+  return new Promise((resolve2) => {
+    execFile(
+      shell2,
+      // `-lc`, never `-ilc`. Interactive mode can draw a prompt, wait on one, or
+      // source a config that expects a tty — and this probe runs before a window
+      // the user can cancel from.
+      ["-lc", script],
+      { timeout: timeoutMs, maxBuffer: 1024 * 1024, encoding: "utf-8" },
+      (error, stdout, stderr) => {
+        const code = error && typeof error.code === "number" ? error.code : error ? null : 0;
+        resolve2({ code, stdout: String(stdout), stderr: String(stderr) });
+      }
+    );
+  });
+}
+function defaultIo$1() {
+  return { env: process.env, runShell, isExecutableFile };
+}
+function extractMarked(stdout) {
+  const start = stdout.lastIndexOf(PATH_MARKER_START);
+  if (start < 0) return null;
+  const from = start + PATH_MARKER_START.length;
+  const end = stdout.indexOf(PATH_MARKER_END, from);
+  if (end < 0) return null;
+  const value = stdout.slice(from, end).trim();
+  return value === "" ? null : value;
+}
+function resolveBinary(name, path, io2 = { isExecutableFile }) {
+  for (const dir of path.split(delimiter)) {
+    if (dir === "") continue;
+    const candidate = join(dir, name);
+    if (io2.isExecutableFile(candidate)) return candidate;
+  }
+  return null;
+}
+async function probeHostEnv(overrides = {}) {
+  const io2 = { ...defaultIo$1(), ...overrides };
+  const inherited = io2.env["PATH"] ?? "";
+  const settle = (path2, source, note) => ({
+    path: path2,
+    source,
+    note,
+    node: resolveBinary("node", path2, io2),
+    gui_default: path2 === GUI_DEFAULT_PATH
+  });
+  const shell2 = io2.env["SHELL"];
+  if (!shell2) {
+    return settle(inherited, "inherited", "No $SHELL is set, so no login shell could be asked for its PATH.");
+  }
+  let result;
+  try {
+    result = await io2.runShell(
+      shell2,
+      `printf '%s%s%s' '${PATH_MARKER_START}' "$PATH" '${PATH_MARKER_END}'`,
+      PROBE_TIMEOUT_MS
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return settle(inherited, "inherited", `Could not run ${shell2} -lc: ${message}`);
+  }
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || `exit ${String(result.code ?? "timeout")}`;
+    return settle(inherited, "inherited", `${shell2} -lc exited without a PATH (${detail}).`);
+  }
+  const path = extractMarked(result.stdout);
+  if (path === null) {
+    return settle(
+      inherited,
+      "inherited",
+      `${shell2} -lc produced no ${PATH_MARKER_START} marker, so its output could not be trusted as a PATH.`
+    );
+  }
+  return settle(path, "login-shell", null);
+}
+let cached = null;
+function hostEnv() {
+  cached ??= probeHostEnv();
+  return cached;
+}
+function buildDaemonEnv(options) {
+  const env = {};
+  for (const [key, value] of Object.entries(options.base)) {
+    if (value === void 0) continue;
+    if (!options.electronAsNode && key.startsWith("ELECTRON_")) continue;
+    env[key] = value;
+  }
+  env["PATH"] = options.path;
+  if (options.electronAsNode) {
+    env["ELECTRON_RUN_AS_NODE"] = "1";
+  }
+  return env;
+}
+const CLI_TIMEOUT_MS = 6e4;
+const STOP_TIMEOUT_MS = 12e4;
+const POLL_INTERVAL_MS$1 = 250;
+const require$1 = createRequire(import.meta.url);
+function conductorEntry() {
+  return require$1.resolve("@nutteen/conductor/dist/src/index.js");
+}
+function runCommand(command, args, env) {
+  return new Promise((resolve2) => {
+    execFile(
+      command,
+      args,
+      { env, timeout: CLI_TIMEOUT_MS, maxBuffer: 4 * 1024 * 1024, encoding: "utf-8" },
+      (error, stdout, stderr) => {
+        const code = error && typeof error.code === "number" ? error.code : error ? null : 0;
+        resolve2({ code, stdout: String(stdout), stderr: String(stderr) });
+      }
+    );
+  });
+}
+function defaultIo() {
+  return {
+    hostEnv,
+    run: runCommand,
+    isRunning: isProcessRunning,
+    readRecord: readRuntimeRecord,
+    sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
+    now: () => Date.now(),
+    listDirs: async (path) => {
+      try {
+        const entries = await readdir(path, { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+      } catch {
+        return [];
+      }
+    },
+    isExecutableFile
+  };
+}
+function io(overrides) {
+  return { ...defaultIo(), ...overrides };
+}
+function isLivePid(pid, isRunning = isProcessRunning) {
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return false;
+  return isRunning(pid);
+}
+function globalArgs(context) {
+  return [
+    ...context.configPath ? ["--config", context.configPath] : [],
+    ...context.runtimeDir ? ["--runtime-dir", context.runtimeDir] : []
+  ];
+}
+function startArgv(flow, context) {
+  return [...globalArgs(context), "start", flow];
+}
+function stopArgv(flow, context) {
+  return [...globalArgs(context), "stop", flow];
+}
+async function launcher(deps) {
+  const host = await deps.hostEnv();
+  const electronAsNode = host.node === null;
+  return {
+    interpreter: host.node ?? process.execPath,
+    entry: conductorEntry(),
+    env: buildDaemonEnv({ base: process.env, path: host.path, electronAsNode }),
+    host
+  };
+}
+function outcome(argv, result) {
+  return {
+    argv,
+    exit_code: result.code,
+    // Redacted before crossing IPC, so the README's "every rendered string passes
+    // through `redactSensitive` in the main process first" stays true. `argv` is
+    // not — it is the command to paste into a terminal.
+    stdout: redactSensitive(result.stdout.trim()),
+    stderr: redactSensitive(result.stderr.trim())
+  };
+}
+async function runConductor(args, deps) {
+  const { interpreter, entry, env } = await launcher(deps);
+  const result = await deps.run(interpreter, [entry, ...args], env);
+  return { cli: outcome([interpreter, entry, ...args], result), ok: result.code === 0 };
+}
+const CORE_BINARIES = ["ist", "git", "gh"];
+async function agentCommands(workflowPath) {
+  try {
+    const definition = await loadWorkflow(workflowPath);
+    const agents = definition.config["agents"];
+    if (typeof agents !== "object" || agents === null || Array.isArray(agents)) return [];
+    const commands = /* @__PURE__ */ new Set();
+    for (const raw of Object.values(agents)) {
+      if (typeof raw !== "object" || raw === null || Array.isArray(raw)) continue;
+      const command = raw["command"];
+      const provider = raw["provider"];
+      const name = typeof command === "string" ? command : typeof provider === "string" ? provider : null;
+      if (name) commands.add(name);
+    }
+    return [...commands];
+  } catch {
+    return [];
+  }
+}
+function hostEnvCheck(host) {
+  if (host.gui_default) {
+    return {
+      id: "host-env",
+      label: "Host PATH",
+      status: "warn",
+      // The whole reason this module captures a login shell's PATH.
+      detail: `PATH is the bare macOS GUI default (${GUI_DEFAULT_PATH}) — nothing user-installed is on it. A daemon started with this PATH polls forever and dispatches nothing.` + (host.note ? ` ${host.note}` : "")
+    };
+  }
+  if (host.source === "inherited") {
+    return {
+      id: "host-env",
+      label: "Host PATH",
+      status: "warn",
+      detail: `Using this app's own PATH. ${host.note ?? "The login shell could not be asked."}`
+    };
+  }
+  return { id: "host-env", label: "Host PATH", status: "pass", detail: `From your login shell (${host.path})` };
+}
+async function authCheck(env, ist, deps) {
+  if (!ist) {
+    return {
+      id: "ist-auth",
+      label: "ist session",
+      status: "fail",
+      detail: "`ist` is not on the PATH, so the session cannot be checked."
+    };
+  }
+  const result = await deps.run(ist, ["auth", "whoami", "--json"], env);
+  if (result.code === 0) {
+    return {
+      id: "ist-auth",
+      label: "ist session",
+      status: "pass",
+      detail: describeWhoami(result.stdout)
+    };
+  }
+  return {
+    id: "ist-auth",
+    label: "ist session",
+    status: "fail",
+    // An `ist auth` failure is *not* fatal once the daemon is polling — it logs
+    // "Dispatch skipped: ist auth check failed" and keeps going forever, doing
+    // nothing. Catching it here is the entire point of a preflight.
+    detail: `${redactSensitive(result.stderr.trim() || result.stdout.trim()) || `exit ${String(result.code)}`} — run \`ist auth login\` in a terminal, then try again.`
+  };
+}
+function describeWhoami(stdout) {
+  try {
+    const user = JSON.parse(stdout);
+    if (typeof user.email === "string") {
+      const name = typeof user.display_name === "string" ? ` (${user.display_name})` : "";
+      return `Authenticated as ${user.email}${name}`;
+    }
+  } catch {
+  }
+  return redactSensitive(stdout.trim()) || "Authenticated.";
+}
+async function preflightFlow(flow, context, overrides = {}) {
+  const deps = io(overrides);
+  const { interpreter, env, host, entry } = await launcher(deps);
+  const checks = [hostEnvCheck(host)];
+  const report = context.configPath ? await preflightFlows(context.configPath, { runtimeDir: context.runtimeDir }) : null;
+  const entryFlow = report?.flows.find((item) => item.name === flow) ?? null;
+  const needed = [...CORE_BINARIES, ...entryFlow ? await agentCommands(entryFlow.workflow) : []];
+  const resolved = new Map(needed.map((name) => [name, resolveBinary(name, host.path, deps)]));
+  const missing = needed.filter((name) => resolved.get(name) === null);
+  checks.push({
+    id: "binaries",
+    label: "Binaries",
+    status: missing.length === 0 ? "pass" : "fail",
+    detail: missing.length === 0 ? needed.map((name) => `${name} → ${resolved.get(name)}`).join("\n") : `Not on the PATH: ${missing.join(", ")}`
+  });
+  checks.push(await authCheck(env, resolved.get("ist") ?? null, deps));
+  if (!context.configPath) {
+    checks.push({
+      id: "graph",
+      label: "Graph",
+      status: "fail",
+      detail: "No flows.yaml is selected, so there is nothing to start. Choose one from the Config tab."
+    });
+  } else if (!entryFlow) {
+    checks.push({
+      id: "graph",
+      label: "Graph",
+      status: "fail",
+      detail: `${context.configPath} declares no flow named '${flow}'.`
+    });
+  } else {
+    checks.push({
+      id: "graph",
+      label: "Graph",
+      status: entryFlow.error ? "fail" : "pass",
+      detail: entryFlow.error ?? `${entryFlow.workflow} loads.`
+    });
+  }
+  const collisions = report?.collisions ?? [];
+  checks.push({
+    id: "collisions",
+    label: "Flow collisions",
+    status: collisions.length === 0 ? "pass" : "fail",
+    detail: collisions.length === 0 ? "None between the declared flows." : collisions.join("\n")
+  });
+  const workspaceRoot = entryFlow?.scope?.workspace_root ?? null;
+  const dirs = workspaceRoot ? await deps.listDirs(workspaceRoot) : [];
+  return {
+    flow,
+    config_path: context.configPath,
+    runtime_dir: report?.runtime_dir ?? resolveRuntimeDir({ cliRuntimeDir: context.runtimeDir, configRuntimeDir: null }),
+    workspace_root: workspaceRoot,
+    workspace_dirs: dirs.length,
+    interpreter,
+    path: host.path,
+    path_source: host.source,
+    checks,
+    ok: checks.every((check) => check.status !== "fail"),
+    argv: [interpreter, entry, ...startArgv(flow, context)]
+  };
+}
+function failed(message, cli = null) {
+  return { ok: false, message, cli, stop_timed_out: false, waiting_on_pid: null };
+}
+async function startFlow(flow, context, overrides = {}) {
+  const deps = io(overrides);
+  if (!context.configPath) return failed("Starting a flow needs a flows.yaml. Choose one from the Config tab.");
+  const { cli, ok } = await runConductor(startArgv(flow, context), deps);
+  return {
+    ok,
+    message: ok ? cli.stdout || `Started ${flow}.` : cli.stderr || `conductor start ${flow} exited ${String(cli.exit_code)}.`,
+    cli,
+    stop_timed_out: false,
+    waiting_on_pid: null
+  };
+}
+async function stopFlow(flow, context, overrides = {}) {
+  const deps = io(overrides);
+  const { cli, ok } = await runConductor(stopArgv(flow, context), deps);
+  return {
+    ok,
+    message: ok ? cli.stdout || `Stopping ${flow}.` : cli.stderr || `conductor stop ${flow} exited ${String(cli.exit_code)}.`,
+    cli,
+    stop_timed_out: false,
+    waiting_on_pid: null
+  };
+}
+async function waitForExit(pid, timeoutMs, overrides = {}) {
+  const deps = io(overrides);
+  const deadline = deps.now() + timeoutMs;
+  while (isLivePid(pid, deps.isRunning)) {
+    if (deps.now() >= deadline) return false;
+    await deps.sleep(POLL_INTERVAL_MS$1);
+  }
+  return true;
+}
+async function restartFlow(flow, context, overrides = {}) {
+  const deps = io(overrides);
+  if (!context.configPath) return failed("Restarting a flow needs a flows.yaml. Choose one from the Config tab.");
+  const runtimeDir = resolveRuntimeDir({ cliRuntimeDir: context.runtimeDir, configRuntimeDir: null });
+  const record = await deps.readRecord(runtimeDir, flow);
+  const pid = record?.pid ?? null;
+  const stopped = await stopFlow(flow, context, overrides);
+  if (!stopped.ok) return stopped;
+  if (isLivePid(pid, deps.isRunning)) {
+    const exited = await waitForExit(pid, STOP_TIMEOUT_MS, overrides);
+    if (!exited) {
+      return {
+        ok: false,
+        // The daemon logs `Shutdown: waiting for N in-flight run(s) to complete`,
+        // which is exactly the sentence that explains the wait.
+        message: `${flow} (PID ${String(pid)}) is still draining in-flight runs, so nothing was restarted. Its log says how many are left. It will exit on its own; restart again once it has.`,
+        cli: stopped.cli,
+        stop_timed_out: true,
+        waiting_on_pid: pid
+      };
+    }
+  }
+  return startFlow(flow, context, overrides);
+}
+const EMPTY$1 = { theme: null };
+function preferencesPath() {
+  return join(app.getPath("userData"), "preferences.json");
+}
+function readPreferences() {
+  try {
+    const parsed = JSON.parse(readFileSync(preferencesPath(), "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return EMPTY$1;
+    const theme = parsed.theme;
+    return { theme: theme === "dark" || theme === "light" ? theme : null };
+  } catch {
+    return EMPTY$1;
+  }
+}
+function writePreferences(preferences) {
+  try {
+    const path = preferencesPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(preferences, null, 2)}
+`, "utf8");
+  } catch {
+  }
+}
+const FIELD_RE = /^(\s*(?:-\s+)?)([A-Za-z_][A-Za-z0-9_-]*)(:\s*)(.*)$/;
+const DASH_RE = /^(\s*)-\s+/;
+const COMMENT_RE = /^(\s*)#/;
+const BLANK_RE = /^\s*$/;
+const MERGE_KEY_RE = /^\s*(?:-\s+)?<<\s*:/;
+const DOC_MARKER_RE = /^(?:---|\.\.\.)\s*$/;
+const BLOCK_SCALAR_RE = /^[|>][-+0-9]*\s*$/;
+const ANCHOR_RE = /^[&*]\S/;
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+function splitTrailingComment(rest) {
+  const quote = rest[0];
+  if (quote === '"' || quote === "'") {
+    for (let index = 1; index < rest.length; index++) {
+      if (rest[index] === "\\" && quote === '"') {
+        index++;
+        continue;
+      }
+      if (rest[index] === quote) {
+        const after = rest.slice(index + 1);
+        return { value: rest.slice(0, index + 1), trailing: after };
+      }
+    }
+    return { value: rest, trailing: "" };
+  }
+  const match = /\s+#/.exec(rest);
+  if (!match) return { value: rest.trimEnd(), trailing: "" };
+  return { value: rest.slice(0, match.index).trimEnd(), trailing: rest.slice(match.index) };
+}
+function commentsAbove(lines, line, indent, floor) {
+  const found = [];
+  for (let index = line - 1; index >= floor; index--) {
+    const text = lines[index];
+    if (BLANK_RE.test(text)) break;
+    const match = COMMENT_RE.exec(text);
+    if (!match || match[1].length !== indent) break;
+    found.push(index);
+  }
+  return found;
+}
+function scanRefusals(lines) {
+  const refusals = [];
+  const refuse = (index, reason) => {
+    refusals.push({ line: index + 1, text: lines[index], reason });
+  };
+  for (const [index, text] of lines.entries()) {
+    if (BLANK_RE.test(text) || COMMENT_RE.test(text)) continue;
+    if (DOC_MARKER_RE.test(text)) {
+      refuse(index, "a document marker — this editor handles single-document files only");
+      continue;
+    }
+    if (MERGE_KEY_RE.test(text)) {
+      refuse(index, "a merge key (`<<:`) — the effective config is not the lines shown, so a line edit cannot be trusted");
+      continue;
+    }
+    const field = FIELD_RE.exec(text);
+    if (!field) continue;
+    const { value } = splitTrailingComment(field[4]);
+    if (BLOCK_SCALAR_RE.test(value)) {
+      refuse(index, "a block scalar (`|` / `>`) — its body spans lines this editor does not model");
+      continue;
+    }
+    if (ANCHOR_RE.test(value)) {
+      refuse(index, "a YAML anchor or alias — what it resolves to is not on this line");
+    }
+  }
+  return refusals;
+}
+function flowsBlockEnd(lines, from) {
+  for (let index = from; index < lines.length; index++) {
+    const text = lines[index];
+    if (BLANK_RE.test(text) || COMMENT_RE.test(text)) continue;
+    if (indentOf(text) === 0) return index;
+  }
+  return lines.length;
+}
+function trimBlockEnd(lines, start, end) {
+  let last = end;
+  while (last > start && BLANK_RE.test(lines[last - 1])) last--;
+  return last;
+}
+function parseFlowsFile(text) {
+  const crlf = text.includes("\r\n");
+  const bareNewline = text.replace(/\r\n/g, "").includes("\n");
+  const eol = crlf ? "\r\n" : "\n";
+  const raw = text.split(/\r?\n/);
+  const trailingNewline = raw.length > 1 && raw[raw.length - 1] === "";
+  const lines = trailingNewline ? raw.slice(0, -1) : raw;
+  const refusals = scanRefusals(lines);
+  if (crlf && bareNewline) {
+    refusals.push({
+      line: 1,
+      text: lines[0] ?? "",
+      reason: "mixed CRLF and LF line endings — rewriting would normalise every line, not just the edited one"
+    });
+  }
+  const flowsLine = lines.findIndex((line) => /^flows\s*:\s*(#.*)?$/.test(line));
+  const inlineFlows = lines.findIndex((line) => /^flows\s*:\s*\S/.test(line));
+  if (flowsLine < 0) {
+    refusals.push({
+      line: inlineFlows >= 0 ? inlineFlows + 1 : 1,
+      text: inlineFlows >= 0 ? lines[inlineFlows] : "",
+      reason: inlineFlows >= 0 ? "`flows:` has an inline value — this editor handles a block sequence of flows" : "no top-level `flows:` block sequence"
+    });
+    return { lines, eol, trailingNewline, flowsLine: -1, flowsEnd: lines.length, flows: [], refusals };
+  }
+  const flowsEnd = flowsBlockEnd(lines, flowsLine + 1);
+  const starts = [];
+  for (let index = flowsLine + 1; index < flowsEnd; index++) {
+    if (DASH_RE.test(lines[index])) starts.push(index);
+  }
+  const flows = [];
+  for (const [order, start] of starts.entries()) {
+    const end = trimBlockEnd(lines, start, starts[order + 1] ?? flowsEnd);
+    const dashIndent = indentOf(lines[start]);
+    const fields = {};
+    let fieldIndent = dashIndent + 2;
+    for (let index = start; index < end; index++) {
+      const text2 = lines[index];
+      if (BLANK_RE.test(text2) || COMMENT_RE.test(text2)) continue;
+      const match = FIELD_RE.exec(text2);
+      if (!match) {
+        refusals.push({
+          line: index + 1,
+          text: text2,
+          reason: "not a `key: value` line — nested mappings and block sequences inside a flow are not modelled"
+        });
+        continue;
+      }
+      const [, prefix, key, separator, rest] = match;
+      const { value, trailing } = splitTrailingComment(rest);
+      if (index > start) fieldIndent = prefix.length;
+      if (value === "") {
+        refusals.push({
+          line: index + 1,
+          text: text2,
+          reason: `\`${key}:\` has no inline value, so its value spans lines this editor does not model`
+        });
+        continue;
+      }
+      fields[key] = {
+        key,
+        line: index,
+        prefix,
+        separator,
+        value,
+        trailing,
+        comments: commentsAbove(lines, index, prefix.length, start + 1)
+      };
+    }
+    const name = fields["name"] ? unquote$1(fields["name"].value) : "";
+    if (name === "") {
+      refusals.push({ line: start + 1, text: lines[start], reason: "a flow with no `name:` on its first line" });
+    }
+    flows.push({
+      name,
+      start,
+      end,
+      dashIndent,
+      fieldIndent,
+      fields,
+      comments: commentsAbove(lines, start, dashIndent, flowsLine + 1)
+    });
+  }
+  return { lines, eol, trailingNewline, flowsLine, flowsEnd, flows, refusals };
+}
+function unquote$1(value) {
+  if (value.length >= 2 && (value[0] === '"' || value[0] === "'") && value.at(-1) === value[0]) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+const NEEDS_QUOTES = /^$|^\s|\s$|^[-?:,[\]{}#&*!|>'"%@`]|:\s|\s#|^(?:true|false|yes|no|on|off|null|~)$/i;
+function renderScalar(value) {
+  if (NEEDS_QUOTES.test(value) || /^[-+]?\d/.test(value)) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
+function renderValue(value) {
+  return Array.isArray(value) ? `[${value.map(renderScalar).join(", ")}]` : renderScalar(value);
+}
+function applySplices(lines, splices) {
+  const sorted = [...splices].sort((a, b) => a.start - b.start);
+  const out = [];
+  let cursor = 0;
+  for (const splice of sorted) {
+    for (let index = cursor; index < splice.start; index++) out.push(lines[index]);
+    out.push(...splice.insert);
+    cursor = Math.max(cursor, splice.start + splice.deleteCount);
+  }
+  for (let index = cursor; index < lines.length; index++) out.push(lines[index]);
+  return out;
+}
+function renderFlowsFile(lines, eol, trailingNewline) {
+  return lines.join(eol) + (trailingNewline ? eol : "");
+}
+function diffFromSplices(lines, splices, label = "flows.yaml", context = 3) {
+  if (splices.length === 0) return "";
+  const sorted = [...splices].sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const splice of sorted) {
+    const last = merged.at(-1);
+    if (last && splice.start <= last.start + last.deleteCount + context * 2) {
+      const gap = lines.slice(last.start + last.deleteCount, splice.start);
+      last.insert = [...last.insert, ...gap, ...splice.insert];
+      last.deleteCount = splice.start + splice.deleteCount - last.start;
+      continue;
+    }
+    merged.push({ start: splice.start, deleteCount: splice.deleteCount, insert: [...splice.insert] });
+  }
+  const out = [`--- a/${label}`, `+++ b/${label}`];
+  let drift = 0;
+  for (const hunk of merged) {
+    const from = Math.max(0, hunk.start - context);
+    const to = Math.min(lines.length, hunk.start + hunk.deleteCount + context);
+    const before = lines.slice(from, hunk.start);
+    const after = lines.slice(hunk.start + hunk.deleteCount, to);
+    const oldCount = before.length + hunk.deleteCount + after.length;
+    const newCount = before.length + hunk.insert.length + after.length;
+    out.push(
+      `@@ -${String(from + 1)},${String(oldCount)} +${String(from + 1 + drift)},${String(newCount)} @@`
+    );
+    for (const line of before) out.push(` ${line}`);
+    for (const line of lines.slice(hunk.start, hunk.start + hunk.deleteCount)) out.push(`-${line}`);
+    for (const line of hunk.insert) out.push(`+${line}`);
+    for (const line of after) out.push(` ${line}`);
+    drift += hunk.insert.length - hunk.deleteCount;
+  }
+  return out.join("\n");
+}
+function fieldLine(field, value) {
+  return `${field.prefix}${field.key}${field.separator}${renderValue(value)}${field.trailing}`;
+}
+function newFieldLine(flow, key, value) {
+  return `${" ".repeat(flow.fieldIndent)}${key}: ${renderValue(value)}`;
+}
+function insertPointFor(flow) {
+  const lastField = Object.values(flow.fields).reduce((max, field) => Math.max(max, field.line), flow.start);
+  return lastField + 1;
+}
+function renderNewFlow(flow, dashIndent, fieldIndent) {
+  const pad = " ".repeat(fieldIndent);
+  const out = [`${" ".repeat(dashIndent)}- name: ${renderScalar(flow.name)}`, `${pad}workflow: ${renderScalar(flow.workflow)}`];
+  if (flow.workspace_root) out.push(`${pad}workspace_root: ${renderScalar(flow.workspace_root)}`);
+  if (flow.assignee) out.push(`${pad}assignee: ${renderScalar(flow.assignee)}`);
+  if (flow.labels && flow.labels.length > 0) out.push(`${pad}labels: ${renderValue(flow.labels)}`);
+  return out;
+}
+function planFlowsEdit(text, edits, options = {}) {
+  const parsed = parseFlowsFile(text);
+  const label = options.label ?? "flows.yaml";
+  const nothing = (errors2) => ({
+    ok: errors2.length === 0 && parsed.refusals.length === 0,
+    refusals: parsed.refusals,
+    errors: errors2,
+    splices: [],
+    text,
+    diff: "",
+    changed: false
+  });
+  if (parsed.refusals.length > 0) return nothing([]);
+  const errors = [];
+  const splices = [];
+  const byName = new Map(parsed.flows.map((flow) => [flow.name, flow]));
+  const addedNames = /* @__PURE__ */ new Set();
+  const appendAt = parsed.flows.at(-1)?.end ?? parsed.flowsLine + 1;
+  for (const edit of edits) {
+    if (edit.op === "add-flow") {
+      if (byName.has(edit.flow.name) || addedNames.has(edit.flow.name)) {
+        errors.push(`A flow named '${edit.flow.name}' is already declared.`);
+        continue;
+      }
+      const template = parsed.flows.at(-1);
+      const insert = renderNewFlow(edit.flow, template?.dashIndent ?? 2, template?.fieldIndent ?? 4);
+      splices.push({ start: appendAt, deleteCount: 0, insert });
+      addedNames.add(edit.flow.name);
+      continue;
+    }
+    const flow = byName.get(edit.flow);
+    if (!flow) {
+      errors.push(`No flow named '${edit.flow}' in ${label}.`);
+      continue;
+    }
+    if (edit.op === "remove-flow") {
+      const from = flow.comments.length > 0 ? Math.min(...flow.comments) : flow.start;
+      splices.push({ start: from, deleteCount: flow.end - from, insert: [] });
+      continue;
+    }
+    const field = flow.fields[edit.field];
+    if (edit.op === "unset") {
+      if (!field) continue;
+      const from = field.comments.length > 0 ? Math.min(...field.comments) : field.line;
+      splices.push({ start: from, deleteCount: field.line + 1 - from, insert: [] });
+      continue;
+    }
+    if (edit.field === "name") {
+      errors.push("A flow's `name:` is its runtime key — renaming it orphans its record, log and checkpoints.");
+      continue;
+    }
+    if (field) {
+      const next = fieldLine(field, edit.value);
+      if (next === parsed.lines[field.line]) continue;
+      splices.push({ start: field.line, deleteCount: 1, insert: [next] });
+    } else {
+      splices.push({ start: insertPointFor(flow), deleteCount: 0, insert: [newFieldLine(flow, edit.field, edit.value)] });
+    }
+  }
+  if (errors.length > 0) return nothing(errors);
+  if (splices.length === 0) return nothing([]);
+  const lines = applySplices(parsed.lines, splices);
+  return {
+    ok: true,
+    refusals: [],
+    errors: [],
+    splices,
+    text: renderFlowsFile(lines, parsed.eol, parsed.trailingNewline),
+    diff: diffFromSplices(parsed.lines, splices, label),
+    changed: true
+  };
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function unquote(value) {
+  if (value.length >= 2 && (value[0] === '"' || value[0] === "'") && value.at(-1) === value[0]) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+async function readFlowsConfig(context) {
+  const empty = {
+    config_path: context.configPath,
+    runtime_dir: null,
+    text: "",
+    flows: [],
+    refusals: [],
+    errors: [],
+    error: null
+  };
+  if (!context.configPath) {
+    return { ...empty, error: "No flows.yaml is selected. Choose one to see and edit the declared flows." };
+  }
+  let text;
+  try {
+    text = await readFile(context.configPath, "utf-8");
+  } catch (err) {
+    return { ...empty, error: `Cannot read ${context.configPath}: ${errorMessage(err)}` };
+  }
+  const parsed = parseFlowsFile(text);
+  const report = await preflightFlows(context.configPath, { runtimeDir: context.runtimeDir });
+  const running = new Set(
+    (await listFlows({ runtimeDir: context.runtimeDir })).filter((flow) => flow.running).map((flow) => flow.name)
+  );
+  let resolvedByName = /* @__PURE__ */ new Map();
+  try {
+    const config = await loadManagedConfig(context.configPath);
+    resolvedByName = new Map(
+      config.flows.map((flow) => [flow.name, { workflow: flow.workflow, workspace_root: flow.workspace_root ?? null }])
+    );
+  } catch {
+  }
+  const flows = parsed.flows.map((flow) => {
+    const declared = {};
+    const comments = {};
+    for (const [key, field] of Object.entries(flow.fields)) {
+      declared[key] = unquote(field.value);
+      if (field.comments.length > 0) {
+        comments[key] = [...field.comments].reverse().map((line) => parsed.lines[line].trim());
+      }
+    }
+    return {
+      name: flow.name,
+      declared,
+      resolved: resolvedByName.get(flow.name) ?? { workflow: null, workspace_root: null },
+      comments,
+      error: report.flows.find((entry) => entry.name === flow.name)?.error ?? null,
+      running: running.has(flow.name)
+    };
+  });
+  return {
+    config_path: context.configPath,
+    runtime_dir: report.runtime_dir ?? resolveRuntimeDir({ cliRuntimeDir: context.runtimeDir, configRuntimeDir: null }),
+    text,
+    flows,
+    refusals: parsed.refusals,
+    errors: report.errors,
+    error: null
+  };
+}
+const pending = /* @__PURE__ */ new Map();
+function tokenFor(pendingWrite) {
+  const hash = createHash("sha256");
+  hash.update(pendingWrite.configPath);
+  hash.update(" ");
+  hash.update(pendingWrite.before);
+  hash.update(" ");
+  hash.update(pendingWrite.after);
+  return hash.digest("hex");
+}
+async function validateCandidate(configPath, candidate, runtimeDir) {
+  const previewPath = `${configPath}.preview.${String(process.pid)}`;
+  try {
+    await writeFile(previewPath, candidate, "utf-8");
+    const report = await preflightFlows(previewPath, { runtimeDir });
+    return { ok: report.ok, errors: report.errors.map((message) => message.replaceAll(previewPath, configPath)) };
+  } catch (err) {
+    return { ok: false, errors: [`Could not validate the edit: ${errorMessage(err)}`] };
+  } finally {
+    await rm(previewPath, { force: true });
+  }
+}
+async function previewFlowsEdit(context, edits) {
+  const nothing = (problems2) => ({
+    ok: false,
+    changed: false,
+    diff: "",
+    problems: problems2,
+    validation: { ok: false, errors: [] },
+    token: null
+  });
+  if (!context.configPath) return nothing(["No flows.yaml is selected."]);
+  let before;
+  try {
+    before = await readFile(context.configPath, "utf-8");
+  } catch (err) {
+    return nothing([`Cannot read ${context.configPath}: ${errorMessage(err)}`]);
+  }
+  const plan = planFlowsEdit(before, edits, { label: context.configPath });
+  const problems = [
+    ...plan.refusals.map((refusal) => `Line ${String(refusal.line)}: ${refusal.reason} — ${refusal.text.trim()}`),
+    ...plan.errors
+  ];
+  if (!plan.ok) return nothing(problems);
+  if (!plan.changed) {
+    return { ok: true, changed: false, diff: "", problems: [], validation: { ok: true, errors: [] }, token: null };
+  }
+  const validation = await validateCandidate(context.configPath, plan.text, context.runtimeDir);
+  const write = { configPath: context.configPath, before, after: plan.text };
+  const token = validation.ok ? tokenFor(write) : null;
+  if (token) pending.set(token, write);
+  return { ok: true, changed: true, diff: plan.diff, problems, validation, token };
+}
+async function applyEdit(configPath, text) {
+  const backupPath = `${configPath}.bak`;
+  const tempPath = `${configPath}.tmp.${String(process.pid)}`;
+  let mode;
+  try {
+    mode = (await stat(configPath)).mode & 511;
+  } catch {
+    mode = void 0;
+  }
+  try {
+    await copyFile(configPath, backupPath);
+    await writeFile(tempPath, text, "utf-8");
+    if (mode !== void 0) await chmod(tempPath, mode);
+    await rename(tempPath, configPath);
+  } catch (err) {
+    await rm(tempPath, { force: true });
+    return { ok: false, message: `Could not write ${configPath}: ${errorMessage(err)}` };
+  }
+  try {
+    await loadManagedConfig(configPath);
+  } catch (err) {
+    await copyFile(backupPath, configPath);
+    return {
+      ok: false,
+      message: `${configPath} did not load after the edit and has been restored from ${backupPath}: ${errorMessage(err)}`
+    };
+  }
+  return { ok: true, message: `Wrote ${configPath}. The previous version is at ${backupPath}.` };
+}
+async function commitFlowsEdit(token) {
+  const write = pending.get(token);
+  if (!write) {
+    return { ok: false, message: "That edit is no longer pending — preview it again before writing." };
+  }
+  let current;
+  try {
+    current = await readFile(write.configPath, "utf-8");
+  } catch (err) {
+    return { ok: false, message: `Cannot read ${write.configPath}: ${errorMessage(err)}` };
+  }
+  if (current !== write.before) {
+    pending.delete(token);
+    return {
+      ok: false,
+      message: `${write.configPath} changed on disk since this edit was previewed. Nothing was written — preview it again.`
+    };
+  }
+  pending.delete(token);
+  return applyEdit(write.configPath, write.after);
+}
+const EMPTY = { config_path: null };
+function settingsPath(userDataDir2) {
+  return join(userDataDir2, "control-room.json");
+}
+async function readSettings(userDataDir2) {
+  try {
+    const parsed = JSON.parse(await readFile(settingsPath(userDataDir2), "utf-8"));
+    return { config_path: typeof parsed.config_path === "string" ? parsed.config_path : null };
+  } catch {
+    return { ...EMPTY };
+  }
+}
+async function writeSettings(userDataDir2, settings) {
+  const path = settingsPath(userDataDir2);
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(settings, null, 2)}
+`, "utf-8");
+}
+const POLL_INTERVAL_MS = 1e3;
+function tailFile(path, onLines, options = {}) {
+  const debounceMs = options.debounceMs ?? 120;
+  let offset = 0;
+  let carry = "";
+  let inode = null;
+  let stopped = false;
+  let reading = false;
+  let pending2 = null;
+  let watcher = null;
+  let timer = null;
+  const readNew = async () => {
+    if (stopped || reading) return;
+    reading = true;
+    try {
+      const info = await stat(path);
+      if (info.size < offset || inode !== null && info.ino !== inode) {
+        offset = 0;
+        carry = "";
+      }
+      inode = info.ino;
+      if (info.size === offset) return;
+      const handle = await open(path, "r");
+      try {
+        const length = info.size - offset;
+        const buffer = Buffer.allocUnsafe(length);
+        const { bytesRead } = await handle.read(buffer, 0, length, offset);
+        offset += bytesRead;
+        const text = carry + buffer.subarray(0, bytesRead).toString("utf-8");
+        const parts = text.split("\n");
+        carry = parts.pop() ?? "";
+        const lines = parts.filter((line) => line.length > 0);
+        if (lines.length > 0 && !stopped) onLines(lines);
+      } finally {
+        await handle.close();
+      }
+    } catch {
+    } finally {
+      reading = false;
+    }
+  };
+  const schedule = () => {
+    if (stopped || pending2) return;
+    pending2 = setTimeout(() => {
+      pending2 = null;
+      void readNew();
+    }, debounceMs);
+    pending2.unref?.();
+  };
+  void (async () => {
+    try {
+      const info = await stat(path);
+      inode = info.ino;
+      if (options.from !== "start") offset = info.size;
+    } catch {
+      offset = 0;
+      inode = null;
+    }
+    if (stopped) return;
+    try {
+      watcher = watch(path, { persistent: false }, schedule);
+    } catch {
+    }
+    timer = setInterval(schedule, POLL_INTERVAL_MS);
+    timer.unref?.();
+    if (options.from === "start") schedule();
+  })();
+  return {
+    stop: () => {
+      stopped = true;
+      if (pending2) clearTimeout(pending2);
+      if (timer) clearInterval(timer);
+      watcher?.close();
+      watcher = null;
+    },
+    poll: readNew
+  };
+}
+app.name = "Conductor";
+const here = dirname(fileURLToPath(import.meta.url));
+function argValue(flag) {
+  const index = process.argv.indexOf(flag);
+  return index >= 0 ? process.argv[index + 1] ?? null : null;
+}
+function runtimeDirArg() {
+  return argValue("--runtime-dir");
+}
+async function captureAndExit(window, target) {
+  const delay = Number(argValue("--capture-delay") ?? 2500);
+  await new Promise((resolve2) => setTimeout(resolve2, Number.isFinite(delay) ? delay : 2500));
+  const image = await window.webContents.capturePage();
+  await writeFile(target, image.toPNG());
+  process.stdout.write(`captured ${target}
+`);
+  app.exit(0);
+}
+const sourceOptions = {
+  runtimeDir: runtimeDirArg(),
+  configPath: argValue("--config")
+};
+async function syncRuntimeDir() {
+  sourceOptions.runtimeDir = await resolveSourceRuntimeDir(sourceOptions.configPath, runtimeDirArg());
+}
+function userDataDir() {
+  return app.getPath("userData");
+}
+function daemonConfigView(error = null) {
+  return {
+    config_path: sourceOptions.configPath,
+    runtime_dir: resolveRuntimeDir({ cliRuntimeDir: sourceOptions.runtimeDir, configRuntimeDir: null }),
+    error
+  };
+}
+function broadcast(channel, payload) {
+  for (const window of BrowserWindow.getAllWindows()) {
+    if (!window.isDestroyed()) window.webContents.send(channel, payload);
+  }
+}
+const LIVENESS_INTERVAL_MS = 2e3;
+const subscriptions = /* @__PURE__ */ new Map();
+function clearSubscription(windowId) {
+  const existing = subscriptions.get(windowId);
+  if (!existing) return;
+  existing.tail?.stop();
+  existing.workflow?.stop();
+  if (existing.liveness) clearInterval(existing.liveness);
+  subscriptions.delete(windowId);
+}
+async function pushFlows(window, subscription) {
+  const flows = await listFlows(sourceOptions);
+  const json = JSON.stringify(flows);
+  if (json !== subscription.flowsJson) {
+    subscription.flowsJson = json;
+    if (!window.isDestroyed()) window.webContents.send(CHANNELS.pushFlows, flows);
+  }
+  return flows;
+}
+async function refreshFlows(sender) {
+  const window = sender ?? BrowserWindow.getAllWindows()[0] ?? null;
+  if (!window) return;
+  const subscription = subscriptions.get(window.id);
+  if (!subscription) return;
+  await pushFlows(window, subscription);
+}
+async function subscribe(window, request) {
+  clearSubscription(window.id);
+  const subscription = {
+    flow: request.flow,
+    tail: null,
+    workflow: null,
+    liveness: null,
+    flowsJson: ""
+  };
+  subscriptions.set(window.id, subscription);
+  subscription.liveness = setInterval(() => {
+    void pushFlows(window, subscription);
+  }, LIVENESS_INTERVAL_MS);
+  const flows = await listFlows(sourceOptions);
+  const flow = flows.find((item) => item.name === request.flow);
+  const send = (channel, payload) => {
+    if (!window.isDestroyed()) window.webContents.send(channel, payload);
+  };
+  if (flow?.log_file) {
+    subscription.tail = tailFile(flow.log_file, (lines) => {
+      const events = parseRunEventLines(lines);
+      if (events.length > 0) send(CHANNELS.pushEvents, { flow: request.flow, events });
+      void readTickets(request.flow, sourceOptions).then((view) => {
+        send(CHANNELS.pushTickets, view);
+      });
+    });
+  }
+  if (request.watchWorkflow && flow?.workflow) {
+    subscription.workflow = watchWorkflow(flow.workflow, () => {
+      void readWorkflow({ flow: request.flow }, sourceOptions).then((view) => {
+        send(CHANNELS.pushWorkflow, view);
+      });
+    });
+  }
+}
+function registerHandlers() {
+  ipcMain.handle(CHANNELS.getFlows, () => listFlows(sourceOptions));
+  ipcMain.handle(
+    CHANNELS.getWorkflow,
+    (_event, input) => readWorkflow(input, sourceOptions)
+  );
+  ipcMain.handle(
+    CHANNELS.getTickets,
+    (_event, input) => readTickets(input.flow, sourceOptions)
+  );
+  ipcMain.handle(
+    CHANNELS.getTicket,
+    (_event, input) => readTicket(input, sourceOptions)
+  );
+  ipcMain.handle(
+    CHANNELS.getReport,
+    (_event, input) => readReport(input, sourceOptions)
+  );
+  ipcMain.handle(CHANNELS.openWorkflowFile, async (event) => {
+    const window = BrowserWindow.fromWebContents(event.sender);
+    const result = await dialog.showOpenDialog(window ?? void 0, {
+      title: "Open a Conductor workflow",
+      properties: ["openFile"],
+      filters: [{ name: "Workflow", extensions: ["md"] }]
+    });
+    const path = result.filePaths[0];
+    if (result.canceled || !path) return null;
+    return readWorkflow({ path }, sourceOptions);
+  });
+  ipcMain.handle(CHANNELS.getInitialView, () => ({ ticket: initialTicketArg(), tab: initialTabArg() }));
+  ipcMain.handle(CHANNELS.setTheme, (_event, theme) => {
+    writePreferences({ theme: theme === "dark" || theme === "light" ? theme : null });
+  });
+  ipcMain.handle(CHANNELS.revealPath, (_event, path) => {
+    shell.showItemInFolder(path);
+  });
+  ipcMain.handle(CHANNELS.subscribe, async (event, request) => {
+    const window = BrowserWindow.fromWebContents(event.sender);
+    if (window) await subscribe(window, request);
+  });
+  const lifecycleFailure = (err) => ({
+    ok: false,
+    message: err instanceof Error ? err.message : String(err),
+    cli: null,
+    stop_timed_out: false,
+    waiting_on_pid: null
+  });
+  const runLifecycle = async (event, action, flow) => {
+    try {
+      return await action(flow);
+    } catch (err) {
+      return lifecycleFailure(err);
+    } finally {
+      await refreshFlows(BrowserWindow.fromWebContents(event.sender));
+    }
+  };
+  ipcMain.handle(CHANNELS.preflight, async (_event, input) => {
+    try {
+      return await preflightFlow(input.flow, sourceOptions);
+    } catch (err) {
+      return {
+        flow: input.flow,
+        config_path: sourceOptions.configPath,
+        runtime_dir: null,
+        workspace_root: null,
+        workspace_dirs: 0,
+        interpreter: process.execPath,
+        path: process.env["PATH"] ?? "",
+        path_source: "inherited",
+        checks: [
+          {
+            id: "preflight",
+            label: "Preflight",
+            status: "fail",
+            detail: err instanceof Error ? err.message : String(err)
+          }
+        ],
+        ok: false,
+        argv: []
+      };
+    }
+  });
+  ipcMain.handle(
+    CHANNELS.startFlow,
+    (event, input) => runLifecycle(event, (flow) => startFlow(flow, sourceOptions), input.flow)
+  );
+  ipcMain.handle(
+    CHANNELS.stopFlow,
+    (event, input) => runLifecycle(event, (flow) => stopFlow(flow, sourceOptions), input.flow)
+  );
+  ipcMain.handle(
+    CHANNELS.restartFlow,
+    (event, input) => runLifecycle(event, (flow) => restartFlow(flow, sourceOptions), input.flow)
+  );
+  ipcMain.handle(CHANNELS.getDaemonConfig, () => daemonConfigView());
+  ipcMain.handle(CHANNELS.chooseDaemonConfig, async (event) => {
+    const window = BrowserWindow.fromWebContents(event.sender);
+    const result = await dialog.showOpenDialog(window ?? void 0, {
+      title: "Choose a Conductor flows.yaml",
+      properties: ["openFile"],
+      filters: [{ name: "Flows config", extensions: ["yaml", "yml"] }]
+    });
+    const path = result.filePaths[0];
+    if (result.canceled || !path) return daemonConfigView();
+    sourceOptions.configPath = path;
+    await syncRuntimeDir();
+    try {
+      await writeSettings(userDataDir(), { config_path: path });
+    } catch (err) {
+      return daemonConfigView(`Chose ${path}, but it could not be remembered: ${String(err)}`);
+    }
+    const view = daemonConfigView();
+    broadcast(CHANNELS.pushDaemon, view);
+    return view;
+  });
+  ipcMain.handle(CHANNELS.readFlowsConfig, () => readFlowsConfig(sourceOptions));
+  ipcMain.handle(CHANNELS.previewFlowsEdit, async (_event, input) => {
+    try {
+      return await previewFlowsEdit(sourceOptions, input.edits);
+    } catch (err) {
+      return {
+        ok: false,
+        changed: false,
+        diff: "",
+        problems: [err instanceof Error ? err.message : String(err)],
+        validation: { ok: false, errors: [] },
+        token: null
+      };
+    }
+  });
+  ipcMain.handle(CHANNELS.commitFlowsEdit, async (_event, input) => {
+    try {
+      return await commitFlowsEdit(input.token);
+    } catch (err) {
+      return { ok: false, message: err instanceof Error ? err.message : String(err) };
+    }
+  });
+}
+const ICON_PATH = join(dirname(fileURLToPath(import.meta.url)), "../../resources/icon.png");
+const APP_ICON = nativeImage.createFromPath(ICON_PATH);
+function createWindow() {
+  const theme = readPreferences().theme ?? (nativeTheme.shouldUseDarkColors ? "dark" : "light");
+  const window = new BrowserWindow({
+    width: 1440,
+    height: 900,
+    minWidth: 1024,
+    minHeight: 640,
+    title: "Conductor Control Room",
+    icon: APP_ICON,
+    // Painted before any HTML exists, so a fixed colour here is a flash of the wrong
+    // theme on every launch under the other one.
+    backgroundColor: theme === "dark" ? "#0d0e11" : "#f0f0f3",
+    titleBarStyle: process.platform === "darwin" ? "hiddenInset" : "default",
+    webPreferences: {
+      preload: join(here, "../preload/index.cjs"),
+      additionalArguments: [`--conductor-theme=${theme}`],
+      // The renderer gets no Node and no direct access to `~/.conductor`. Everything
+      // it shows arrives over the typed IPC surface in `shared/contract.ts`.
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false
+    }
+  });
+  window.on("closed", () => clearSubscription(window.id));
+  const devServer = process.env["ELECTRON_RENDERER_URL"];
+  if (devServer) {
+    void window.loadURL(devServer);
+  } else {
+    void window.loadFile(join(here, "../renderer/index.html"));
+  }
+  const capture = argValue("--capture");
+  if (capture) {
+    window.webContents.once("did-finish-load", () => {
+      void captureAndExit(window, capture);
+    });
+  }
+}
+function initialTicketArg() {
+  return argValue("--ticket");
+}
+function initialTabArg() {
+  const value = argValue("--tab");
+  return value === "graph" || value === "state" || value === "audit" || value === "config" ? value : null;
+}
+void app.whenReady().then(async () => {
+  if (process.platform === "darwin" && app.dock) {
+    app.dock.setIcon(ICON_PATH);
+  }
+  if (!sourceOptions.configPath) {
+    sourceOptions.configPath = (await readSettings(userDataDir())).config_path;
+  }
+  await syncRuntimeDir();
+  registerHandlers();
+  createWindow();
+  app.on("activate", () => {
+    if (BrowserWindow.getAllWindows().length === 0) createWindow();
+  });
+});
+app.on("window-all-closed", () => {
+  for (const id of [...subscriptions.keys()]) clearSubscription(id);
+  if (process.platform !== "darwin") app.quit();
+});
+export {
+  initialTabArg,
+  initialTicketArg
+};