@runcofactor/cli 0.10.0

package/dist/chunk-B2VISN2V.js

@@ -0,0 +1,2459 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+import {
+  InlineAssertionSchema
+} from "./chunk-SJJW77WN.js";
+
+// ../canary-spec/src/parse.ts
+import yaml from "yaml";
+
+// ../canary-spec/src/grammar.ts
+import { z } from "zod";
+var CredentialRefSchema = z.union([
+  z.object({ kind: z.literal("template"), role: z.string().min(1) }),
+  z.object({ kind: z.literal("credential"), name: z.string().min(1) }),
+  /**
+   * `seed-output <ref>` — the journey runs as a credential that was provisioned
+   * by an upstream seed workflow. The `ref` is the seed's `dataKey`; the
+   * runtime resolves it at suite-prep time via the seed_outputs lookup.
+   */
+  z.object({ kind: z.literal("seedOutput"), ref: z.string().min(1) })
+]);
+var FrontmatterSchema = z.object({
+  name: z.string().min(1),
+  /**
+   * Workflow ID this spec is bound to. Absent on first compile; the
+   * compiler writes it back into the frontmatter after a successful
+   * create. On recompile, the compiler keys the diff on this ID.
+   */
+  workflowId: z.string().uuid().optional(),
+  status: z.enum(["draft", "published"]).optional(),
+  flowType: z.enum(["standard", "setup", "seed", "teardown"]).optional(),
+  /**
+   * Credential the journey runs as. Required for authenticated specs (the
+   * common case); optional for unauthenticated flows, which have no leading
+   * login node to represent.
+   */
+  actor: CredentialRefSchema.optional(),
+  authenticated: z.boolean().default(true),
+  tags: z.array(z.string()).optional(),
+  requirementRef: z.string().optional(),
+  apiOnly: z.boolean().optional(),
+  sandboxTemplate: z.string().optional(),
+  environments: z.union([
+    z.object({ only: z.array(z.string()).min(1) }),
+    z.object({ types: z.array(z.enum(["permanent", "ephemeral", "local"])).min(1) })
+  ]).optional(),
+  /**
+   * Teardown linkage for `flowType: seed` workflows. Two surface forms:
+   *   teardown: cleanup-demo-org              # shorthand, defaults applied
+   *   teardown:
+   *     spec: cleanup-demo-org                # nested for explicit overrides
+   *     snapshotVersion: 3                    # or 'latest' (default)
+   *     enabled: false                        # default true
+   * The DB stores teardownWorkflowId/teardownSnapshotVersion/teardownEnabled
+   * on the seed row; compile resolves spec name → id and PATCHes the seed,
+   * pull reverses (FK → name).
+   */
+  teardown: z.union([
+    z.string().min(1),
+    z.object({
+      spec: z.string().min(1),
+      snapshotVersion: z.union([z.literal("latest"), z.number().int().nonnegative()]).optional(),
+      enabled: z.boolean().optional()
+    })
+  ]).optional()
+}).strict();
+var InputDeclSchema = z.object({
+  name: z.string().min(1),
+  kind: z.enum(["value", "credential"]).default("value"),
+  defaultValue: z.string()
+});
+var ScenarioSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  isDefault: z.boolean().default(false),
+  includeInSuite: z.boolean().default(true),
+  skipReason: z.string().optional(),
+  values: z.record(z.string(), z.string()).default({}),
+  credentials: z.record(z.string(), z.string()).default({})
+});
+var AttachmentDeclSchema = z.object({
+  ref: z.string().min(1),
+  source: z.string().min(1)
+  // path or attachmentId
+});
+var DeclaredOutputSchema = z.object({
+  dataKey: z.string().min(1),
+  label: z.string().min(1).optional(),
+  description: z.string().optional(),
+  propertyName: z.string().optional()
+});
+var NodeBase = z.object({
+  description: z.string().optional(),
+  /**
+   * Workflow node UUID — present after first compile, when the compiler
+   * writes `<!-- @id <uuid> -->` next to the node's lead-in. Drives the
+   * recompile diff.
+   */
+  nodeId: z.string().uuid().optional(),
+  /**
+   * Source line index of the lead-in. Used by the writeback step to
+   * insert `<!-- @id <uuid> -->` after a CREATE without re-finding the
+   * line. Populated by the parser; not user-authored.
+   */
+  sourceLine: z.number().int().nonnegative().optional()
+});
+var PageUrlSchema = z.string().min(1).refine(
+  (s) => {
+    if (s.startsWith("/")) return true;
+    try {
+      const u = new URL(s);
+      return u.protocol === "http:" || u.protocol === "https:";
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: "pageUrl must be a root-relative path (e.g. /dashboard) or an absolute http(s) URL"
+  }
+);
+var NavigateNodeSchema = NodeBase.extend({
+  kind: z.literal("navigate"),
+  pageUrl: PageUrlSchema,
+  openInNewTab: z.boolean().optional()
+});
+var SwitchRoleNodeSchema = NodeBase.extend({
+  kind: z.literal("switchRole"),
+  credentialRef: CredentialRefSchema
+});
+var ActionFieldSchema = z.object({
+  name: z.string().min(1),
+  type: z.string().optional(),
+  value: z.string()
+});
+var ActionNodeSchema = NodeBase.extend({
+  kind: z.literal("action"),
+  title: z.string().min(1),
+  fields: z.array(ActionFieldSchema).default([]),
+  capture: z.array(z.string()).default([]),
+  assertions: z.array(InlineAssertionSchema).default([]),
+  captureAudio: z.boolean().optional(),
+  captureLabel: z.string().optional(),
+  captureExtraMs: z.number().int().nonnegative().optional(),
+  alwaysUseAgent: z.boolean().optional()
+});
+var AssertionNodeSchema = NodeBase.extend({
+  kind: z.literal("assertion"),
+  condition: z.string().min(1),
+  severity: z.enum(["warn", "fail"]).default("warn"),
+  expectedOutcome: z.string().optional(),
+  alwaysUseAgent: z.boolean().optional()
+});
+var SeedNodeSchema = NodeBase.extend({
+  kind: z.literal("seed"),
+  specName: z.string().min(1),
+  version: z.union([z.number().int().nonnegative(), z.literal("latest")]).optional(),
+  onFailure: z.enum(["block", "warn"]).optional(),
+  mode: z.enum(["recommended", "api", "browser"]).optional(),
+  /** Per-request timeout (seconds) for the seed/teardown api_sequence calls (API mode only). */
+  apiTimeoutSeconds: z.number().int().positive().optional(),
+  scope: z.enum(["inline", "suite"]).optional(),
+  runTeardown: z.boolean().optional()
+});
+var SetupNodeSchema = NodeBase.extend({
+  kind: z.literal("setup"),
+  specName: z.string().min(1),
+  version: z.union([z.number().int().nonnegative(), z.literal("latest")]).optional(),
+  mode: z.enum(["inline", "suite"]).optional()
+});
+var WaitNodeSchema = NodeBase.extend({
+  kind: z.literal("wait"),
+  durationSeconds: z.number().int().positive()
+});
+var ConditionNodeSchema = NodeBase.extend({
+  kind: z.literal("condition"),
+  expression: z.string().min(1),
+  hints: z.string().optional(),
+  thenBranch: z.lazy(() => z.array(JourneyNodeSchema)),
+  elseBranch: z.lazy(() => z.array(JourneyNodeSchema))
+});
+var NotificationNodeSchema = NodeBase.extend({
+  kind: z.literal("notification"),
+  channel: z.string().min(1),
+  to: z.string().min(1),
+  subject: z.string().optional(),
+  body: z.string().min(1),
+  attach: z.string().optional()
+});
+var AudioPlayNodeSchema = NodeBase.extend({
+  kind: z.literal("audio"),
+  attachmentRef: z.string().min(1),
+  loop: z.boolean().optional(),
+  waitForCompletion: z.boolean().optional(),
+  label: z.string().optional()
+});
+var AudioAssertionNodeSchema = NodeBase.extend({
+  kind: z.literal("audioAssertion"),
+  label: z.string().min(1),
+  severity: z.enum(["warn", "fail"]).default("fail"),
+  prompt: z.string().optional(),
+  model: z.enum(["gpt-audio", "gemini-2.x"]).optional(),
+  minDurationMs: z.number().int().nonnegative().optional(),
+  maxDurationMs: z.number().int().nonnegative().optional(),
+  minRmsDb: z.number().optional(),
+  silenceFractionMax: z.number().min(0).max(1).optional(),
+  reference: z.string().optional(),
+  envelopeCorrelationMin: z.number().min(-1).max(1).optional()
+});
+var ApiSequenceNodeSchema = NodeBase.extend({
+  kind: z.literal("apiSequence"),
+  title: z.string().min(1),
+  apiEndpointContext: z.string().min(1),
+  credentialInputName: z.string().optional(),
+  /**
+   * Optional sidecar YAML carrying the full ApiSequenceConfig (steps, exports,
+   * validations). Path is resolved relative to the .canary.md file. When set,
+   * compile POSTs the loaded config to `/api-sequences/save` after the node
+   * sync; pull writes the file when an api_sequence row exists. Multiple
+   * api_sequence nodes in the same workflow share one sidecar (the DB has a
+   * unique index on workflow_id), so the path should typically be identical
+   * across nodes — the parser warns when the paths conflict.
+   */
+  sidecar: z.string().min(1).optional()
+});
+var EndNodeSchema = NodeBase.extend({
+  kind: z.literal("end"),
+  outcome: z.enum(["pass", "fail"]).default("pass")
+});
+var JourneyNodeSchema = z.union([
+  NavigateNodeSchema,
+  SwitchRoleNodeSchema,
+  ActionNodeSchema,
+  AssertionNodeSchema,
+  SeedNodeSchema,
+  SetupNodeSchema,
+  WaitNodeSchema,
+  ConditionNodeSchema,
+  NotificationNodeSchema,
+  AudioPlayNodeSchema,
+  AudioAssertionNodeSchema,
+  ApiSequenceNodeSchema,
+  EndNodeSchema
+]);
+var SpecAstSchema = z.object({
+  frontmatter: FrontmatterSchema,
+  spirit: z.string().optional(),
+  preflight: z.string().optional(),
+  cleanup: z.string().optional(),
+  inputs: z.array(InputDeclSchema).default([]),
+  scenarios: z.array(ScenarioSchema).default([]),
+  attachments: z.array(AttachmentDeclSchema).default([]),
+  declaredOutputs: z.array(DeclaredOutputSchema).default([]),
+  journey: z.array(JourneyNodeSchema)
+});
+
+// ../canary-spec/src/parse.ts
+var FRONTMATTER_FENCE = /^---\s*$/;
+function parseSpec(source) {
+  const issues = [];
+  const lines = source.split(/\r?\n/);
+  const fmEnd = findFrontmatterEnd(lines);
+  if (fmEnd === -1) {
+    return fail([{ severity: "error", message: "Spec must begin with `---` frontmatter." }]);
+  }
+  const rawFrontmatter = lines.slice(1, fmEnd).join("\n");
+  let frontmatter;
+  try {
+    const parsed = yaml.parse(rawFrontmatter) ?? {};
+    frontmatter = FrontmatterSchema.parse(normalizeActor(parsed));
+  } catch (err) {
+    return fail([
+      {
+        severity: "error",
+        message: `Frontmatter is invalid: ${err instanceof Error ? err.message : String(err)}`,
+        line: 1
+      }
+    ]);
+  }
+  const bodyStart = fmEnd + 1;
+  const sections = splitH2Sections(lines.slice(bodyStart), bodyStart);
+  let spirit;
+  let preflight;
+  let cleanup;
+  let inputs = [];
+  let scenarios = [];
+  let attachments = [];
+  let declaredOutputs = [];
+  let journey = [];
+  for (const section of sections) {
+    const heading = section.heading.toLowerCase();
+    if (heading.startsWith("spirit")) spirit = stripBlockquoteOrPlain(section.body).trim() || void 0;
+    else if (heading.startsWith("preflight")) preflight = section.body.trim() || void 0;
+    else if (heading.startsWith("cleanup")) cleanup = section.body.trim() || void 0;
+    else if (heading.startsWith("inputs")) inputs = parseInputs(section.body, section.startLine, issues);
+    else if (heading.startsWith("scenarios")) scenarios = parseScenarios(section.body, section.startLine, issues);
+    else if (heading.startsWith("attachments")) attachments = parseAttachments(section.body, section.startLine, issues);
+    else if (heading.startsWith("declared outputs")) declaredOutputs = parseDeclaredOutputs(section.body, section.startLine, issues);
+    else if (heading.startsWith("journey")) journey = parseJourney(section.body, section.startLine, issues);
+    else if (heading.startsWith("metadata")) {
+    } else {
+      issues.push({
+        severity: "warn",
+        message: `Unknown H2 section "${section.heading}" \u2014 ignored.`,
+        line: section.startLine
+      });
+    }
+  }
+  if (journey.length === 0) {
+    issues.push({
+      severity: "error",
+      message: "Spec must include a `## Journey` section with at least one node."
+    });
+  }
+  if (issues.some((i) => i.severity === "error")) return { ok: false, issues };
+  return {
+    ok: true,
+    ast: {
+      frontmatter,
+      spirit,
+      preflight,
+      cleanup,
+      inputs,
+      scenarios,
+      attachments,
+      declaredOutputs,
+      journey
+    }
+  };
+}
+function fail(issues) {
+  return { ok: false, issues };
+}
+function findFrontmatterEnd(lines) {
+  if (!FRONTMATTER_FENCE.test(lines[0] ?? "")) return -1;
+  for (let i = 1; i < lines.length; i++) if (FRONTMATTER_FENCE.test(lines[i])) return i;
+  return -1;
+}
+function parseCredentialRef(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("credential ")) {
+    return { kind: "credential", name: trimmed.slice("credential ".length).trim() };
+  }
+  if (trimmed.startsWith("seed-output ")) {
+    return { kind: "seedOutput", ref: trimmed.slice("seed-output ".length).trim() };
+  }
+  const role = trimmed.startsWith("template ") ? trimmed.slice("template ".length).trim() : trimmed;
+  return { kind: "template", role };
+}
+function normalizeActor(raw) {
+  const a = raw.actor;
+  if (typeof a !== "string") return raw;
+  return { ...raw, actor: parseCredentialRef(a) };
+}
+function splitH2Sections(lines, offset) {
+  const sections = [];
+  let current = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const m = /^##\s+(.+?)\s*$/.exec(line);
+    if (m) {
+      if (current) sections.push({ heading: current.heading, body: current.body.join("\n"), startLine: current.startLine });
+      current = { heading: m[1], body: [], startLine: offset + i + 1 };
+      continue;
+    }
+    if (current) current.body.push(line);
+  }
+  if (current) sections.push({ heading: current.heading, body: current.body.join("\n"), startLine: current.startLine });
+  return sections;
+}
+function stripBlockquoteOrPlain(body) {
+  return body.split("\n").map((l) => l.startsWith("> ") ? l.slice(2) : l.startsWith(">") ? l.slice(1) : l).join("\n");
+}
+function parseInputs(body, startLine, issues) {
+  const out = [];
+  for (const { line, lineNo } of bulletLines(body, startLine)) {
+    const credMatch = /^credential\s+([A-Za-z0-9_-]+)\s*:\s*(.+)$/.exec(line);
+    if (credMatch) {
+      out.push({ name: credMatch[1], kind: "credential", defaultValue: credMatch[2].trim() });
+      continue;
+    }
+    const m = /^([A-Za-z0-9_-]+)\s*:\s*(.+)$/.exec(line);
+    if (!m) {
+      issues.push({ severity: "warn", message: `Could not parse Inputs entry: "${line}"`, line: lineNo });
+      continue;
+    }
+    out.push({ name: m[1], kind: "value", defaultValue: stripQuotes(m[2].trim()) });
+  }
+  return out;
+}
+function parseScenarios(body, startLine, issues) {
+  const out = [];
+  const blocks = splitH3Blocks(body, startLine);
+  for (const block of blocks) {
+    const headingRaw = block.heading;
+    let isDefault = false;
+    let includeInSuite = true;
+    let skipReason;
+    let nameClean = headingRaw;
+    const defaultMatch = /\*\(default\)\*/i.exec(headingRaw);
+    if (defaultMatch) {
+      isDefault = true;
+      nameClean = nameClean.replace(defaultMatch[0], "").trim();
+    }
+    const skipMatch = /\*\(skip(?::\s*([^)]+))?\)\*/i.exec(headingRaw);
+    if (skipMatch) {
+      includeInSuite = false;
+      skipReason = (skipMatch[1] ?? "").trim() || void 0;
+      nameClean = nameClean.replace(skipMatch[0], "").trim();
+    }
+    let bodyYaml = {};
+    try {
+      const content = block.body.split("\n").map((l) => l.replace(/^-\s+/, "")).join("\n");
+      bodyYaml = yaml.parse(content) ?? {};
+    } catch (err) {
+      issues.push({
+        severity: "warn",
+        message: `Could not parse scenario "${nameClean}": ${err instanceof Error ? err.message : String(err)}`,
+        line: block.startLine
+      });
+    }
+    out.push({
+      name: nameClean,
+      description: typeof bodyYaml.description === "string" ? bodyYaml.description : void 0,
+      isDefault,
+      includeInSuite,
+      skipReason,
+      values: bodyYaml.values ?? {},
+      credentials: bodyYaml.credentials ?? {}
+    });
+  }
+  return out;
+}
+function parseAttachments(body, startLine, issues) {
+  const out = [];
+  for (const { line, lineNo } of bulletLines(body, startLine)) {
+    const m = /^([A-Za-z0-9_-]+)\s*:\s*(.+)$/.exec(line);
+    if (!m) {
+      issues.push({ severity: "warn", message: `Could not parse Attachments entry: "${line}"`, line: lineNo });
+      continue;
+    }
+    out.push({ ref: m[1], source: m[2].trim() });
+  }
+  return out;
+}
+function parseDeclaredOutputs(body, startLine, issues) {
+  const out = [];
+  const lines = body.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const m = /^-\s+([A-Za-z0-9_-]+)\s*$/.exec(lines[i].trim());
+    if (!m) {
+      i++;
+      continue;
+    }
+    const dataKey = m[1];
+    const block = [];
+    i++;
+    while (i < lines.length) {
+      const raw = lines[i];
+      if (/^-\s/.test(raw)) break;
+      const sub = /^\s+-\s+(.+)$/.exec(raw);
+      if (sub) block.push(sub[1]);
+      else if (raw.trim() === "") {
+      } else {
+        break;
+      }
+      i++;
+    }
+    let body2 = {};
+    if (block.length > 0) {
+      try {
+        body2 = yaml.parse(block.join("\n")) ?? {};
+      } catch (err) {
+        issues.push({
+          severity: "warn",
+          message: `Could not parse Declared Outputs entry "${dataKey}": ${err instanceof Error ? err.message : String(err)}`,
+          line: startLine
+        });
+      }
+    }
+    out.push({
+      dataKey,
+      label: typeof body2.label === "string" ? body2.label : void 0,
+      // Spec writes `property: <name>`; the AST uses `propertyName` to make
+      // the name-vs-id distinction explicit (sync.ts resolves to id at compile).
+      propertyName: typeof body2.property === "string" ? body2.property : void 0,
+      description: typeof body2.description === "string" ? body2.description : void 0
+    });
+  }
+  return out;
+}
+function parseJourney(body, startLine, issues) {
+  const lines = body.split("\n");
+  return parseJourneyBlock(
+    lines,
+    0,
+    lines.length,
+    /* baseIndent */
+    0,
+    startLine,
+    issues
+  ).nodes;
+}
+function parseJourneyBlock(lines, start, end, baseIndent, startLine, issues) {
+  const nodes = [];
+  let i = start;
+  while (i < end) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (!trimmed) {
+      i++;
+      continue;
+    }
+    const indent = leadingSpaces(raw);
+    if (indent < baseIndent) break;
+    const lineNo = startLine + i;
+    const { stripped, nodeId } = extractNodeId(trimmed);
+    const leadInMatch = /^\*\*([^*]+)\*\*\s*(.*)$/.exec(stripped);
+    if (!leadInMatch) {
+      issues.push({
+        severity: "warn",
+        message: `Unexpected line in Journey: "${trimmed}"`,
+        line: lineNo
+      });
+      i++;
+      continue;
+    }
+    const leadIn = leadInMatch[1].trim();
+    const remainder = leadInMatch[2].trim();
+    const idMeta = {
+      sourceLine: lineNo,
+      ...nodeId ? { nodeId } : {}
+    };
+    const lower = leadIn.toLowerCase();
+    if (lower.startsWith("if")) {
+      let expression = stripPunctuation(leadIn.replace(/^if\b\s*/i, "") + (remainder ? " " + remainder : "")).trim();
+      i++;
+      if (!expression) {
+        const bq = readBlockquote(lines, i, end);
+        if (bq) {
+          expression = bq;
+          i += countBlockquoteLines(lines, i, end);
+        }
+      }
+      const childIndent = baseIndent + 2;
+      let thenBranch = [];
+      let elseBranch = [];
+      while (i < end) {
+        const nextRaw = lines[i];
+        const nextTrim = nextRaw.trim();
+        if (!nextTrim) {
+          i++;
+          continue;
+        }
+        if (leadingSpaces(nextRaw) < baseIndent) break;
+        const branch = /^\*\*(then|else):\*\*\s*$/i.exec(nextTrim);
+        if (!branch) break;
+        i++;
+        const sub = parseJourneyBlock(lines, i, end, childIndent, startLine, issues);
+        if (branch[1].toLowerCase() === "then") thenBranch = sub.nodes;
+        else elseBranch = sub.nodes;
+        i = sub.nextIndex;
+      }
+      nodes.push({ ...idMeta, kind: "condition", expression, thenBranch, elseBranch });
+      continue;
+    }
+    let descScan = i + 1;
+    while (descScan < end && !lines[descScan].trim()) descScan++;
+    const description = readBlockquote(lines, descScan, end);
+    const descLineCount = description ? descScan - (i + 1) + countBlockquoteLines(lines, descScan, end) : 0;
+    let consumedMain = 1 + descLineCount;
+    if (lower.startsWith("navigate to")) {
+      const url = stripPunctuation(remainder);
+      nodes.push({ ...idMeta, kind: "navigate", pageUrl: url || (description ?? "").trim() });
+      i += consumedMain;
+      continue;
+    }
+    if (lower.startsWith("switch role to")) {
+      const stripped2 = leadIn.replace(/^switch role to\s+/i, "").trim();
+      const fromLeadIn = stripped2 && stripped2.toLowerCase() !== "switch role to" ? stripped2 : "";
+      const rest = fromLeadIn || remainder;
+      const credentialRef = parseCredentialRef(stripPunctuation(rest));
+      nodes.push({ ...idMeta, kind: "switchRole", credentialRef });
+      i += consumedMain;
+      continue;
+    }
+    if (lower.startsWith("wait")) {
+      const dur = parseDuration(remainder || leadIn.replace(/^wait\s*/i, ""));
+      if (dur === null) {
+        issues.push({ severity: "error", message: `Could not parse Wait duration: "${remainder}"`, line: lineNo });
+      } else {
+        nodes.push({ ...idMeta, kind: "wait", durationSeconds: dur });
+      }
+      i += consumedMain;
+      continue;
+    }
+    if (lower.startsWith("end")) {
+      const outcome = lower.includes("fail") ? "fail" : "pass";
+      nodes.push({ ...idMeta, kind: "end", outcome });
+      i += consumedMain;
+      continue;
+    }
+    if (lower.startsWith("seed")) {
+      const specName = stripPunctuation(remainder.replace(/^[`"]|[`"]$/g, "")) || stripPunctuation(leadIn.replace(/^seed\s*/i, ""));
+      const subBullets = readBullets(lines, i + 1 + descLineCount, end, baseIndent);
+      consumedMain += subBullets.consumed;
+      const opts = parseKvBullets(subBullets.bullets);
+      nodes.push({
+        ...idMeta,
+        kind: "seed",
+        specName,
+        description,
+        version: opts.version === "latest" || opts.version === void 0 ? opts.version : Number(opts.version),
+        onFailure: opts.onFailure,
+        mode: opts.mode,
+        apiTimeoutSeconds: opts.apiTimeoutSeconds === void 0 ? void 0 : Number(opts.apiTimeoutSeconds),
+        scope: opts.scope,
+        runTeardown: typeof opts.runTeardown === "string" ? opts.runTeardown !== "false" : void 0
+      });
+      i += consumedMain;
+      continue;
+    }
+    if (lower.startsWith("setup")) {
+      const specName = stripPunctuation(remainder.replace(/^[`"]|[`"]$/g, "")) || stripPunctuation(leadIn.replace(/^setup\s*/i, ""));
+      const subBullets = readBullets(lines, i + 1 + descLineCount, end, baseIndent);
+      consumedMain += subBullets.consumed;
+      const opts = parseKvBullets(subBullets.bullets);
+      nodes.push({
+        ...idMeta,
+        kind: "setup",
+        specName,
+        description,
+        version: opts.version === "latest" || opts.version === void 0 ? opts.version : Number(opts.version),
+        mode: opts.mode
+      });
+      i += consumedMain;
+      continue;
+    }
+    if (lower.startsWith("action")) {
+      const title = leadIn.replace(/^action\s*[—-]\s*/i, "").trim() || remainder;
+      const subBullets = readBullets(lines, i + 1 + descLineCount, end, baseIndent);
+      consumedMain += subBullets.consumed;
+      const action = parseActionBullets(subBullets.bullets, lineNo, issues);
+      nodes.push({
+        ...idMeta,
+        kind: "action",
+        title,
+        description,
+        ...action
+      });
+      i += consumedMain;
+      continue;
+    }
+    if (lower.startsWith("assert audio")) {
+      const label = leadIn.replace(/^assert audio\s*/i, "").trim() || remainder;
+      const subBullets = readBullets(lines, i + 1 + descLineCount, end, baseIndent);
+      consumedMain += subBullets.consumed;
+      const opts = parseKvBullets(subBullets.bullets);
+      nodes.push({
+        ...idMeta,
+        kind: "audioAssertion",
+        label,
+        description,
+        severity: opts.severity ?? "fail",
+        prompt: typeof opts.prompt === "string" ? opts.prompt : void 0,
+        model: opts.model,
+        minDurationMs: numOpt(opts.minDurationMs),
+        maxDurationMs: numOpt(opts.maxDurationMs),
+        minRmsDb: numOpt(opts.minRmsDb),
+        silenceFractionMax: numOpt(opts.silenceFractionMax),
+        reference: typeof opts.reference === "string" ? opts.reference : void 0,
+        envelopeCorrelationMin: numOpt(opts.envelopeCorrelationMin)
+      });
+      i += consumedMain;
+      continue;
+    }
+    if (lower.startsWith("assert")) {
+      const condition = leadIn.replace(/^assert\s*/i, "").trim() + (remainder ? " " + remainder : "");
+      const subBullets = readBullets(lines, i + 1 + descLineCount, end, baseIndent);
+      consumedMain += subBullets.consumed;
+      const opts = parseKvBullets(subBullets.bullets);
+      nodes.push({
+        ...idMeta,
+        kind: "assertion",
+        condition: stripPunctuation(condition),
+        description,
+        severity: opts.severity ?? "warn",
+        expectedOutcome: typeof opts.expectedOutcome === "string" ? opts.expectedOutcome : void 0,
+        alwaysUseAgent: opts.alwaysUseAgent === "true" ? true : void 0
+      });
+      i += consumedMain;
+      continue;
+    }
+    if (lower.startsWith("play audio")) {
+      const ref = leadIn.replace(/^play audio\s*/i, "").trim() || remainder;
+      const subBullets = readBullets(lines, i + 1 + descLineCount, end, baseIndent);
+      consumedMain += subBullets.consumed;
+      const opts = parseKvBullets(subBullets.bullets);
+      nodes.push({
+        ...idMeta,
+        kind: "audio",
+        attachmentRef: stripPunctuation(ref),
+        description,
+        loop: opts.loop === "true" ? true : void 0,
+        waitForCompletion: opts.waitForCompletion === "false" ? false : void 0,
+        label: typeof opts.label === "string" ? opts.label : void 0
+      });
+      i += consumedMain;
+      continue;
+    }
+    if (lower.startsWith("notify")) {
+      const m = /^notify\s+([A-Za-z0-9_-]+)\s*:?\s*(.*)$/i.exec(leadIn + (remainder ? " " + remainder : ""));
+      if (!m) {
+        issues.push({ severity: "error", message: `Could not parse Notify lead-in: "${leadIn}"`, line: lineNo });
+      } else {
+        const subBullets = readBullets(lines, i + 1 + descLineCount, end, baseIndent);
+        consumedMain += subBullets.consumed;
+        const opts = parseKvBullets(subBullets.bullets);
+        nodes.push({
+          ...idMeta,
+          kind: "notification",
+          channel: m[1],
+          to: stripPunctuation(stripBackticks(m[2])),
+          subject: typeof opts.subject === "string" ? opts.subject : void 0,
+          body: description ?? "",
+          attach: typeof opts.attach === "string" ? opts.attach : void 0
+        });
+      }
+      i += consumedMain;
+      continue;
+    }
+    if (lower.startsWith("api sequence")) {
+      const title = leadIn.replace(/^api sequence\s*[—-]\s*/i, "").trim();
+      const subBullets = readBullets(lines, i + 1 + descLineCount, end, baseIndent);
+      consumedMain += subBullets.consumed;
+      const opts = parseKvBullets(subBullets.bullets);
+      nodes.push({
+        ...idMeta,
+        kind: "apiSequence",
+        title,
+        apiEndpointContext: description ?? "",
+        credentialInputName: typeof opts.credential === "string" ? opts.credential : void 0,
+        // Sidecar reference (e.g. `- apiSequence: ./sequences/x.yaml`).
+        // Resolved by the CLI at compile/diff time relative to the spec file
+        // path; parse.ts has no filesystem context so we just carry the string.
+        sidecar: typeof opts.apiSequence === "string" ? opts.apiSequence : void 0
+      });
+      i += consumedMain;
+      continue;
+    }
+    issues.push({ severity: "error", message: `Unrecognized lead-in: "${leadIn}"`, line: lineNo });
+    i++;
+  }
+  return { nodes, nextIndex: i };
+}
+function leadingSpaces(s) {
+  let n = 0;
+  while (n < s.length && s[n] === " ") n++;
+  return n;
+}
+function stripPunctuation(s) {
+  return s.replace(/[`"]/g, "").replace(/\.$/, "").trim();
+}
+function stripBackticks(s) {
+  return s.replace(/`/g, "").trim();
+}
+function stripQuotes(s) {
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function parseDuration(s) {
+  const m = /^(\d+(?:\.\d+)?)\s*(s|m|h)?\.?$/i.exec(s.trim());
+  if (!m) return null;
+  const n = Number(m[1]);
+  const unit = (m[2] ?? "s").toLowerCase();
+  const seconds = unit === "h" ? n * 3600 : unit === "m" ? n * 60 : n;
+  return Math.round(seconds);
+}
+function readBlockquote(lines, start, end) {
+  if (start >= end) return void 0;
+  if (!lines[start].trimStart().startsWith(">")) return void 0;
+  const out = [];
+  for (let i = start; i < end; i++) {
+    const t = lines[i].trimStart();
+    if (!t.startsWith(">")) break;
+    out.push(t.replace(/^>\s?/, ""));
+  }
+  return out.join("\n").trim();
+}
+function countBlockquoteLines(lines, start, end) {
+  let n = 0;
+  for (let i = start; i < end; i++) {
+    if (!lines[i].trimStart().startsWith(">")) break;
+    n++;
+  }
+  return n;
+}
+function readBullets(lines, start, end, baseIndent) {
+  const bullets = [];
+  let i = start;
+  while (i < end) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (!trimmed) {
+      i++;
+      continue;
+    }
+    if (!trimmed.startsWith("- ")) break;
+    if (leadingSpaces(raw) < baseIndent) break;
+    bullets.push(trimmed.slice(2).trim());
+    i++;
+  }
+  return { bullets, consumed: i - start };
+}
+function bulletLines(body, startLine) {
+  const out = [];
+  const lines = body.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const t = lines[i].trim();
+    if (t.startsWith("- ")) out.push({ line: t.slice(2).trim(), lineNo: startLine + i });
+  }
+  return out;
+}
+function splitH3Blocks(body, startLine) {
+  const out = [];
+  const lines = body.split("\n");
+  let cur = null;
+  for (let i = 0; i < lines.length; i++) {
+    const m = /^###\s+(.+?)\s*$/.exec(lines[i]);
+    if (m) {
+      if (cur) out.push({ heading: cur.heading, body: cur.body.join("\n"), startLine: cur.startLine });
+      cur = { heading: m[1], body: [], startLine: startLine + i };
+      continue;
+    }
+    if (cur) cur.body.push(lines[i]);
+  }
+  if (cur) out.push({ heading: cur.heading, body: cur.body.join("\n"), startLine: cur.startLine });
+  return out;
+}
+function parseActionBullets(bullets, lineNo, issues) {
+  const fields = [];
+  const capture = [];
+  const assertions = [];
+  let captureAudio;
+  let captureLabel;
+  let captureExtraMs;
+  let alwaysUseAgent;
+  for (const b of bullets) {
+    const fieldM = /^field\s+(?:"([^"]+)"|([A-Za-z0-9_-]+))\s*(?:\(([^)]+)\))?\s*:\s*(.+)$/i.exec(b);
+    if (fieldM) {
+      fields.push({
+        name: fieldM[1] ?? fieldM[2],
+        type: fieldM[3],
+        value: stripQuotes(fieldM[4].trim())
+      });
+      continue;
+    }
+    const capM = /^capture\s*:?\s*(.+)$/i.exec(b);
+    if (capM) {
+      capture.push(stripQuotes(capM[1].trim()));
+      continue;
+    }
+    const assertM = /^assert\s*\(([^)]+)\)\s*:\s*(.+)$/i.exec(b);
+    if (assertM) {
+      const flags = assertM[1].split(",").map((s) => s.trim().toLowerCase());
+      const severity = flags.includes("fail") ? "fail" : "warn";
+      const agentic = flags.includes("agentic") || void 0;
+      assertions.push({ condition: stripQuotes(assertM[2].trim()), severity, agentic });
+      continue;
+    }
+    const kv = /^([A-Za-z][A-Za-z0-9]*)\s*:\s*(.+)$/.exec(b);
+    if (kv) {
+      const key = kv[1];
+      const value = kv[2].trim();
+      if (key === "captureAudio") captureAudio = value === "true";
+      else if (key === "captureLabel") captureLabel = stripQuotes(value);
+      else if (key === "captureExtraMs") captureExtraMs = Number(value);
+      else if (key === "alwaysUseAgent") alwaysUseAgent = value === "true";
+      else issues.push({ severity: "warn", message: `Unknown action option "${key}"`, line: lineNo });
+      continue;
+    }
+    issues.push({ severity: "warn", message: `Could not parse action bullet: "${b}"`, line: lineNo });
+  }
+  return { fields, capture, assertions, captureAudio, captureLabel, captureExtraMs, alwaysUseAgent };
+}
+function parseKvBullets(bullets) {
+  const out = {};
+  for (const b of bullets) {
+    const m = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.+)$/.exec(b);
+    if (!m) continue;
+    out[m[1]] = stripQuotes(m[2].trim());
+  }
+  return out;
+}
+function numOpt(v) {
+  if (v === void 0) return void 0;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+}
+var NODE_ID_RE = /\s*<!--\s*@id\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\s*-->/i;
+function extractNodeId(line) {
+  const m = NODE_ID_RE.exec(line);
+  if (!m) return { stripped: line, nodeId: void 0 };
+  return { stripped: line.replace(NODE_ID_RE, "").trimEnd(), nodeId: m[1].toLowerCase() };
+}
+
+// ../canary-spec/src/lint.ts
+var RESERVED_MACROS = /* @__PURE__ */ new Set([
+  "EMAIL",
+  "UUID",
+  "NOW",
+  "RANDOM_STRING",
+  "RANDOM_INT",
+  "DATE",
+  "TODAY",
+  "TIMESTAMP",
+  "SEQUENCE",
+  "FIRST_NAME",
+  "LAST_NAME",
+  "PHONE",
+  "CREDENTIAL"
+]);
+function lintSpec(ast) {
+  const issues = [];
+  const hasFailAssertion = anyNode(ast.journey, (n) => {
+    if (n.kind === "action") return n.assertions.some((a) => a.severity === "fail");
+    if (n.kind === "assertion") return n.severity === "fail";
+    if (n.kind === "audioAssertion") return n.severity === "fail";
+    return false;
+  });
+  if (!hasFailAssertion) {
+    issues.push({
+      severity: "warn",
+      message: "Spec has no fail-severity assertions \u2014 the case will pass even if the feature is broken.",
+      hint: "Add `- assert (fail): \u2026` under at least one action."
+    });
+  }
+  if (!ast.frontmatter.requirementRef) {
+    issues.push({
+      severity: "warn",
+      message: "`requirementRef` is missing from frontmatter \u2014 untraceable specs rot."
+    });
+  }
+  const declaredInputs = new Set(ast.inputs.map((i) => i.name));
+  const promotedVars = /* @__PURE__ */ new Set();
+  walkNodes(ast.journey, (n) => {
+    if (n.kind === "action") {
+      n.capture.forEach((c) => promotedVars.add(c));
+      n.fields.forEach((f) => promotedVars.add(f.name));
+    }
+  });
+  walkStrings(ast.journey, (s, ctx) => {
+    for (const ref of extractMacroRefs(s)) {
+      if (RESERVED_MACROS.has(ref.split("(")[0])) continue;
+      if (ref.startsWith("var.")) {
+        const name = ref.slice("var.".length);
+        if (!promotedVars.has(name)) {
+          issues.push({
+            severity: "warn",
+            message: `\`$var.${name}\` referenced in ${ctx} but not declared via \`- capture:\` or a field.`,
+            hint: "If this is authored data, add `- capture: " + name + "` to the action that produces it."
+          });
+        }
+      } else if (!declaredInputs.has(ref)) {
+        issues.push({
+          severity: "error",
+          message: `\`$${ref}\` referenced in ${ctx} but not declared in \`## Inputs\`.`
+        });
+      }
+    }
+  });
+  const defaults = ast.scenarios.filter((s) => s.isDefault);
+  if (defaults.length > 1) {
+    issues.push({
+      severity: "error",
+      message: `Multiple scenarios marked default: ${defaults.map((s) => s.name).join(", ")}.`
+    });
+  }
+  for (const s of ast.scenarios) {
+    if (!s.includeInSuite && !s.skipReason) {
+      issues.push({
+        severity: "warn",
+        message: `Scenario "${s.name}" is skipped without a reason. Use *(skip: <ref>)*.`
+      });
+    }
+  }
+  for (const s of ast.scenarios) {
+    for (const key of Object.keys(s.values)) {
+      if (!declaredInputs.has(key)) {
+        issues.push({
+          severity: "warn",
+          message: `Scenario "${s.name}" overrides input "${key}" which is not declared in \`## Inputs\`.`
+        });
+      }
+    }
+  }
+  const declaredAttachments = new Set(ast.attachments.map((a) => a.ref));
+  walkNodes(ast.journey, (n) => {
+    if (n.kind === "audio" && !declaredAttachments.has(n.attachmentRef)) {
+      issues.push({
+        severity: "error",
+        message: `Play audio references unknown attachment "${n.attachmentRef}".`
+      });
+    }
+    if (n.kind === "audioAssertion" && n.reference && !declaredAttachments.has(n.reference)) {
+      issues.push({
+        severity: "error",
+        message: `Audio assertion references unknown attachment "${n.reference}".`
+      });
+    }
+    if (n.kind === "notification" && n.attach && !declaredAttachments.has(n.attach)) {
+      issues.push({
+        severity: "error",
+        message: `Notification attaches unknown attachment "${n.attach}".`
+      });
+    }
+  });
+  walkNodes(ast.journey, (n) => {
+    if (n.kind !== "action") return;
+    const text = (n.description ?? "") + " " + n.title;
+    if (/\bclick\s+(?:the\s+)?["']?\w+/i.test(text) && /,\s*then\s+click/i.test(text)) {
+      issues.push({
+        severity: "warn",
+        message: `Action "${n.title}" reads as click-by-click UI mechanics \u2014 prefer human intent.`
+      });
+    }
+  });
+  return issues;
+}
+function anyNode(nodes, pred) {
+  for (const n of nodes) {
+    if (pred(n)) return true;
+    if (n.kind === "condition") {
+      if (anyNode(n.thenBranch, pred) || anyNode(n.elseBranch, pred)) return true;
+    }
+  }
+  return false;
+}
+function walkNodes(nodes, visit) {
+  for (const n of nodes) {
+    visit(n);
+    if (n.kind === "condition") {
+      walkNodes(n.thenBranch, visit);
+      walkNodes(n.elseBranch, visit);
+    }
+  }
+}
+function walkStrings(nodes, visit) {
+  walkNodes(nodes, (n) => {
+    const ctx = nodeCtx(n);
+    if (n.description) visit(n.description, ctx);
+    if (n.kind === "navigate") visit(n.pageUrl, ctx);
+    if (n.kind === "action") {
+      visit(n.title, ctx);
+      n.fields.forEach((f) => visit(f.value, ctx));
+      n.assertions.forEach((a) => visit(a.condition, ctx));
+    }
+    if (n.kind === "assertion") visit(n.condition, ctx);
+    if (n.kind === "audioAssertion" && n.prompt) visit(n.prompt, ctx);
+    if (n.kind === "notification") {
+      visit(n.to, ctx);
+      visit(n.body, ctx);
+      if (n.subject) visit(n.subject, ctx);
+    }
+    if (n.kind === "condition") visit(n.expression, ctx);
+  });
+}
+function nodeCtx(n) {
+  if (n.kind === "action") return `action "${n.title}"`;
+  if (n.kind === "assertion") return `assertion`;
+  if (n.kind === "navigate") return `navigate`;
+  if (n.kind === "condition") return `condition`;
+  if (n.kind === "notification") return `notification`;
+  if (n.kind === "seed") return `seed "${n.specName}"`;
+  if (n.kind === "setup") return `setup "${n.specName}"`;
+  return n.kind;
+}
+function extractMacroRefs(s) {
+  const out = [];
+  const re = /\$([A-Za-z_][A-Za-z0-9_.]*)/g;
+  let m;
+  while (m = re.exec(s)) {
+    out.push(m[1].replace(/\.+$/, ""));
+  }
+  return out;
+}
+
+// ../canary-spec/src/emit.ts
+function emitSpec(ast, opts = {}) {
+  const { appendDefaultEnd = true } = opts;
+  const nodes = [];
+  for (const n of ast.journey) emitNode(n, nodes);
+  if (ast.frontmatter.authenticated) {
+    let insertAt = 0;
+    while (insertAt < nodes.length && (nodes[insertAt].nodeType === "seed" || nodes[insertAt].nodeType === "setup")) {
+      insertAt++;
+    }
+    nodes.splice(
+      insertAt,
+      0,
+      ast.frontmatter.actor ? loginNode(ast.frontmatter.actor) : bareLoginNode()
+    );
+  }
+  const last = nodes[nodes.length - 1];
+  if (appendDefaultEnd && (!last || last.nodeType !== "end")) {
+    nodes.push({
+      nodeType: "end",
+      configJson: { title: "End", description: "Journey complete", outcome: "pass" }
+    });
+  }
+  return {
+    name: ast.frontmatter.name,
+    description: ast.spirit ?? null,
+    preflight: ast.preflight ?? null,
+    cleanup: ast.cleanup ?? null,
+    status: ast.frontmatter.status,
+    flowType: ast.frontmatter.flowType,
+    apiOnly: ast.frontmatter.apiOnly,
+    // Optional fields are emitted as `undefined` when absent so the diff can
+    // tell "spec doesn't constrain this" (no field-update op) from "spec
+    // explicitly wants the field cleared" (handled per-field in diff.ts).
+    tags: ast.frontmatter.tags,
+    environmentConstraints: toEnvironmentConstraints(ast.frontmatter.environments),
+    sandboxTemplate: ast.frontmatter.sandboxTemplate,
+    ...normalizeTeardown(ast.frontmatter.teardown),
+    seedOutputs: ast.declaredOutputs.length > 0 ? ast.declaredOutputs.map((o) => ({
+      dataKey: o.dataKey,
+      ...o.label ? { label: o.label } : {},
+      ...o.description ? { description: o.description } : {},
+      ...o.propertyName ? { propertyName: o.propertyName } : {}
+    })) : void 0,
+    inputsJson: ast.inputs.map((i) => ({
+      kind: i.kind,
+      name: i.name,
+      defaultValue: i.defaultValue
+    })),
+    scenariosJson: ast.scenarios.map((s) => ({
+      id: crypto.randomUUID(),
+      name: s.name,
+      description: s.description,
+      isDefault: s.isDefault || void 0,
+      includeInSuite: s.includeInSuite,
+      // `skipReason` is a spec-source-only field (no DB column). Emit it so the
+      // round-trip diff doesn't flag it as drift, but sync.ts strips it before
+      // PUT — the API doesn't accept it.
+      ...s.skipReason ? { skipReason: s.skipReason } : {},
+      values: Object.keys(s.values).length > 0 ? s.values : void 0,
+      credentials: Object.keys(s.credentials).length > 0 ? s.credentials : void 0
+    })),
+    attachments: ast.attachments,
+    nodes,
+    workflowId: ast.frontmatter.workflowId
+  };
+}
+function toEnvironmentConstraints(envs) {
+  if (!envs) return void 0;
+  if ("only" in envs) return { mode: "only", environmentNames: envs.only };
+  return { mode: "envTypes", types: envs.types };
+}
+function normalizeTeardown(teardown) {
+  if (!teardown) return {};
+  if (typeof teardown === "string") {
+    return { teardownSpec: teardown, teardownSnapshotVersion: "latest", teardownEnabled: true };
+  }
+  return {
+    teardownSpec: teardown.spec,
+    teardownSnapshotVersion: teardown.snapshotVersion ?? "latest",
+    teardownEnabled: teardown.enabled ?? true
+  };
+}
+function bareLoginNode() {
+  return {
+    nodeType: "login",
+    configJson: { title: "Log in", description: "Authenticate the session", performLogin: true }
+  };
+}
+function loginNode(actor) {
+  return {
+    nodeType: "login",
+    configJson: loginConfig(actor, { titlePrefix: "Log in as" })
+  };
+}
+function loginConfig(ref, opts) {
+  const performLogin = opts.performLogin ?? false;
+  if (ref.kind === "credential") {
+    return {
+      title: `${opts.titlePrefix} ${ref.name}`,
+      description: opts.description ?? `Authenticate using credential "${ref.name}"`,
+      credentialName: ref.name,
+      credentialSource: "static",
+      ...performLogin ? { performLogin: true } : {}
+    };
+  }
+  if (ref.kind === "seedOutput") {
+    return {
+      title: `${opts.titlePrefix} seed-provisioned ${ref.ref}`,
+      description: opts.description ?? `Authenticate using credential from seed output "${ref.ref}"`,
+      credentialSource: "from_seed",
+      // The runtime expects an object ref; sync.ts can enrich with the seed
+      // workflow id once the binding context is known. dataKey is the stable
+      // identifier (matches the seed's declared output key); name mirrors it.
+      seedCredentialRef: { dataKey: ref.ref, name: ref.ref },
+      // from_seed mid-journey switches always perform login; leading login
+      // also performs login on session bootstrap.
+      performLogin: true
+    };
+  }
+  return {
+    title: `${opts.titlePrefix} ${ref.role}`,
+    description: opts.description ?? `Authenticate using credential template "${ref.role}"`,
+    credentialSource: "from_template",
+    credentialTemplateName: ref.role,
+    ...performLogin ? { performLogin: true } : {}
+  };
+}
+function emitNode(n, out) {
+  const meta = {
+    ...n.nodeId ? { nodeId: n.nodeId } : {},
+    ...n.sourceLine !== void 0 ? { sourceLine: n.sourceLine } : {}
+  };
+  switch (n.kind) {
+    case "navigate":
+      out.push({
+        ...meta,
+        nodeType: "navigate",
+        configJson: {
+          title: `Go to ${shortPath(n.pageUrl)}`,
+          description: n.description ?? `Navigate to ${n.pageUrl}`,
+          pageUrl: n.pageUrl,
+          ...n.openInNewTab ? { openInNewTab: true } : {}
+        }
+      });
+      return;
+    case "switchRole": {
+      const ref = n.credentialRef;
+      const fallbackDesc = ref.kind === "credential" ? `Re-authenticate as ${ref.name}` : ref.kind === "seedOutput" ? `Re-authenticate as seed-provisioned ${ref.ref}` : `Re-authenticate as ${ref.role}`;
+      out.push({
+        ...meta,
+        nodeType: "login",
+        configJson: loginConfig(ref, {
+          titlePrefix: "Switch role to",
+          description: n.description ?? fallbackDesc,
+          performLogin: true
+        })
+      });
+      return;
+    }
+    case "action": {
+      const fieldEntries = n.fields.map((f) => ({
+        name: f.name,
+        label: humanizeLabel(f.name),
+        type: f.type ?? "text",
+        value: f.value
+      }));
+      const inputValues = fieldEntries.length > 0 ? Object.fromEntries(
+        fieldEntries.filter((f) => f.value !== void 0 && f.value !== "").map((f) => [f.name, f.value])
+      ) : void 0;
+      out.push({
+        ...meta,
+        nodeType: "action",
+        configJson: {
+          customActionTitle: n.title,
+          actionDescription: n.description ?? n.title,
+          ...fieldEntries.length > 0 ? {
+            formFields: fieldEntries,
+            dataRequirements: fieldEntries.map(({ name, label, type }) => ({
+              name,
+              label,
+              type,
+              required: true
+            })),
+            ...inputValues && Object.keys(inputValues).length > 0 ? { inputValues } : {}
+          } : {},
+          ...n.capture.length > 0 ? { declaredOutputs: n.capture } : {},
+          ...n.assertions.length > 0 ? {
+            inlineAssertions: n.assertions.map((a) => ({
+              condition: a.condition,
+              severity: a.severity,
+              ...a.agentic ? { agentic: true } : {}
+            }))
+          } : {},
+          ...n.captureAudio ? {
+            captureAudio: true,
+            ...n.captureLabel ? { captureLabel: n.captureLabel } : {},
+            ...n.captureExtraMs !== void 0 ? { captureExtraMs: n.captureExtraMs } : {}
+          } : {},
+          ...n.alwaysUseAgent ? { alwaysUseAgent: true } : {}
+        }
+      });
+      return;
+    }
+    case "assertion":
+      out.push({
+        ...meta,
+        nodeType: "assertion",
+        configJson: {
+          title: "Assert",
+          description: n.description ?? n.condition,
+          condition: n.condition,
+          severity: n.severity,
+          ...n.expectedOutcome ? { expectedOutcome: n.expectedOutcome } : {},
+          ...n.alwaysUseAgent ? { alwaysUseAgent: true } : {}
+        }
+      });
+      return;
+    case "seed":
+      out.push({
+        ...meta,
+        nodeType: "seed",
+        configJson: {
+          title: `Seed: ${n.specName}`,
+          description: n.description ?? `Run seed workflow "${n.specName}"`,
+          // Compiler resolves spec-name → seedWorkflowId; placeholder until then.
+          seedWorkflowName: n.specName,
+          // Emit the canonical SeedNodeConfig keys the runtime + UI actually
+          // read (seed-deps.ts, SeedNodeConfig.tsx). The `seed`-prefixed names
+          // are only for the AI builder-tool input schemas, which remap them;
+          // here configJson is stored verbatim, so prefixed keys silently
+          // revert to defaults.
+          ...n.version === "latest" || n.version === void 0 ? { snapshotVersion: null } : { snapshotVersion: n.version },
+          ...n.onFailure ? { onFailure: n.onFailure } : {},
+          ...n.mode ? { executionMode: n.mode } : {},
+          ...n.apiTimeoutSeconds ? { apiTimeoutSeconds: n.apiTimeoutSeconds } : {},
+          ...n.scope ? { scope: n.scope } : {},
+          ...n.runTeardown !== void 0 ? { runTeardown: n.runTeardown } : {}
+        }
+      });
+      return;
+    case "setup":
+      out.push({
+        ...meta,
+        nodeType: "setup",
+        configJson: {
+          title: `Setup: ${n.specName}`,
+          description: n.description ?? `Run setup workflow "${n.specName}"`,
+          setupFlowName: n.specName,
+          ...n.version === "latest" || n.version === void 0 ? { snapshotVersion: null } : { snapshotVersion: n.version },
+          ...n.mode ? { executionMode: n.mode } : {}
+        }
+      });
+      return;
+    case "wait":
+      out.push({
+        ...meta,
+        nodeType: "wait",
+        configJson: {
+          title: `Wait ${n.durationSeconds}s`,
+          description: n.description ?? `Pause for ${n.durationSeconds} seconds`,
+          waitDuration: n.durationSeconds,
+          mode: "delay",
+          delaySeconds: n.durationSeconds
+        }
+      });
+      return;
+    case "condition":
+      out.push({
+        ...meta,
+        nodeType: "condition",
+        configJson: {
+          title: "If",
+          description: n.description ?? n.expression,
+          // Canonical runtime key is `conditionDescription`.
+          conditionDescription: n.expression,
+          ...n.hints ? { evaluationHints: n.hints } : {}
+        }
+      });
+      n.thenBranch.forEach((c) => emitNode(c, out));
+      n.elseBranch.forEach((c) => emitNode(c, out));
+      return;
+    case "notification":
+      out.push({
+        ...meta,
+        nodeType: "notification",
+        configJson: {
+          title: `Notify ${n.to}`,
+          description: n.description ?? n.body,
+          channel: n.channel,
+          to: n.to,
+          body: n.body,
+          ...n.subject ? { subject: n.subject } : {},
+          ...n.attach ? { attachmentRef: n.attach } : {}
+        }
+      });
+      return;
+    case "audio":
+      out.push({
+        ...meta,
+        nodeType: "audio",
+        configJson: {
+          title: n.label ?? `Play ${n.attachmentRef}`,
+          description: n.description ?? `Play audio "${n.attachmentRef}"`,
+          attachmentRef: n.attachmentRef,
+          ...n.loop !== void 0 ? { loop: n.loop } : {},
+          ...n.waitForCompletion !== void 0 ? { waitForCompletion: n.waitForCompletion } : {},
+          ...n.label ? { label: n.label } : {}
+        }
+      });
+      return;
+    case "audioAssertion":
+      out.push({
+        ...meta,
+        nodeType: "audio-assertion",
+        configJson: {
+          title: `Assert audio: ${n.label}`,
+          description: n.description ?? n.label,
+          label: n.label,
+          severity: n.severity,
+          ...n.prompt ? { naturalLanguage: { prompt: n.prompt, ...n.model ? { model: n.model } : {} } } : {},
+          ...hasDeterministicAudioAssertion(n) ? {
+            deterministic: {
+              ...n.minDurationMs !== void 0 ? { minDurationMs: n.minDurationMs } : {},
+              ...n.maxDurationMs !== void 0 ? { maxDurationMs: n.maxDurationMs } : {},
+              ...n.minRmsDb !== void 0 ? { minRmsDb: n.minRmsDb } : {},
+              ...n.silenceFractionMax !== void 0 ? { silenceFractionMax: n.silenceFractionMax } : {},
+              ...n.envelopeCorrelationMin !== void 0 ? { envelopeCorrelationMin: n.envelopeCorrelationMin } : {}
+            }
+          } : {},
+          ...n.reference ? { referenceAttachmentRef: n.reference } : {}
+        }
+      });
+      return;
+    case "apiSequence":
+      out.push({
+        ...meta,
+        nodeType: "api_sequence",
+        configJson: {
+          customActionTitle: n.title,
+          description: n.description ?? n.title,
+          apiEndpointContext: n.apiEndpointContext,
+          ...n.credentialInputName ? { credentialInputName: n.credentialInputName } : {},
+          // Sidecar reference is metadata for the CLI sync layer — runtime
+          // ignores unknown configJson keys, and the node-hash projection
+          // drops it (api_sequence stays opaque at node level; the actual DSL
+          // config is diffed via the sidecar load below).
+          ...n.sidecar ? { __apiSequenceSidecar: n.sidecar } : {}
+        }
+      });
+      return;
+    case "end":
+      out.push({
+        ...meta,
+        nodeType: "end",
+        configJson: {
+          title: n.outcome === "fail" ? "End: fail" : "End",
+          description: n.description ?? "Journey complete",
+          outcome: n.outcome
+        }
+      });
+      return;
+  }
+}
+function hasDeterministicAudioAssertion(n) {
+  return n.minDurationMs !== void 0 || n.maxDurationMs !== void 0 || n.minRmsDb !== void 0 || n.silenceFractionMax !== void 0 || n.reference !== void 0 || n.envelopeCorrelationMin !== void 0;
+}
+function shortPath(url) {
+  if (url.startsWith("/")) return url;
+  try {
+    return new URL(url).pathname || url;
+  } catch {
+    return url;
+  }
+}
+function humanizeLabel(name) {
+  return name.replace(/[_-]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+// ../canary-spec/src/node-hash.ts
+import { createHash } from "crypto";
+function authoredNodeHash(node) {
+  const projection = {
+    nodeType: node.nodeType,
+    ...authoredProjection(node.nodeType, node.configJson)
+  };
+  const stable = JSON.stringify(sortObjectKeys(projection));
+  return createHash("sha256").update(stable).digest("hex").slice(0, 16);
+}
+function authoredProjection(nodeType, raw) {
+  const c = raw ?? {};
+  switch (nodeType) {
+    case "login":
+      return { credential: canon(loginCredentialRef(c)) };
+    case "navigate":
+      return {
+        pageUrl: canon(str(c.pageUrl)),
+        openInNewTab: c.openInNewTab === true
+      };
+    case "action":
+      return {
+        title: authoredActionTitle(c),
+        // emit falls back actionDescription → title; trim because the blockquote
+        // round-trip can't preserve leading/trailing whitespace.
+        description: trimText(str(c.actionDescription) ?? str(c.description)) ?? authoredActionTitle(c),
+        // Authorable name/type/value triples — server-assigned labels are
+        // dropped, and value is sourced from inputValues/formFields alike.
+        fields: authoredActionFields(c),
+        captures: arr(c.declaredOutputs).filter((x) => typeof x === "string"),
+        // Drop assertion `id` (random UUID) — only the semantic content matters.
+        assertions: arr(c.inlineAssertions).map((a) => ({
+          condition: str(prop(a, "condition")) ?? "",
+          severity: str(prop(a, "severity")) ?? "fail",
+          agentic: prop(a, "agentic") === true
+        })),
+        captureAudio: c.captureAudio === true,
+        captureLabel: str(c.captureLabel) ?? null,
+        captureExtraMs: num(c.captureExtraMs) ?? null,
+        alwaysUseAgent: c.alwaysUseAgent === true
+      };
+    case "assertion":
+      return {
+        condition: canon(str(c.condition)),
+        description: canon(str(c.description) ?? str(c.condition)),
+        // Legacy `strict:true` is equivalent to severity 'fail' at runtime; map
+        // it so a strict assertion doesn't silently weaken to 'warn'.
+        severity: str(c.severity) ?? (c.strict === true ? "fail" : "warn"),
+        expectedOutcome: str(c.expectedOutcome) ?? null,
+        alwaysUseAgent: c.alwaysUseAgent === true
+      };
+    case "seed":
+      return {
+        specName: canon(str(c.seedWorkflowName)),
+        snapshotVersion: c.snapshotVersion ?? c.seedSnapshotVersion ?? null,
+        onFailure: str(c.onFailure) ?? str(c.seedOnFailure) ?? null,
+        executionMode: str(c.executionMode) ?? str(c.seedExecutionMode) ?? null,
+        scope: str(c.scope) ?? null,
+        runTeardown: typeof c.runTeardown === "boolean" ? c.runTeardown : null
+      };
+    case "setup":
+      return {
+        specName: canon(str(c.setupFlowName)),
+        snapshotVersion: c.snapshotVersion ?? null,
+        mode: str(c.executionMode) ?? null
+      };
+    case "wait":
+      return { delaySeconds: num(c.delaySeconds) ?? num(c.waitDuration) ?? null };
+    case "condition":
+      return {
+        expression: canon(
+          str(c.conditionDescription) ?? str(c.conditionExpression) ?? str(c.description)
+        ),
+        hints: str(c.evaluationHints) ?? null
+      };
+    case "notification":
+      return {
+        channel: str(c.channel) ?? null,
+        to: str(c.to) ?? null,
+        subject: str(c.subject) ?? null,
+        body: str(c.body) ?? null,
+        attach: str(c.attachmentRef) ?? null
+      };
+    case "audio":
+      return {
+        attachmentRef: str(c.attachmentRef) ?? null,
+        loop: c.loop === true,
+        waitForCompletion: c.waitForCompletion !== false,
+        label: str(c.label) ?? null
+      };
+    case "audio-assertion": {
+      const det = obj(c.deterministic);
+      const nl = obj(c.naturalLanguage);
+      return {
+        label: str(c.label) ?? null,
+        severity: str(c.severity) ?? "fail",
+        prompt: str(nl?.prompt) ?? str(c.prompt) ?? null,
+        model: str(nl?.model) ?? str(c.model) ?? null,
+        minDurationMs: num(det?.minDurationMs) ?? num(c.minDurationMs) ?? null,
+        maxDurationMs: num(det?.maxDurationMs) ?? num(c.maxDurationMs) ?? null,
+        minRmsDb: num(det?.minRmsDb) ?? num(c.minRmsDb) ?? null,
+        silenceFractionMax: num(det?.silenceFractionMax) ?? num(c.silenceFractionMax) ?? null,
+        reference: str(c.referenceAttachmentRef) ?? null,
+        envelopeCorrelationMin: num(det?.envelopeCorrelationMin) ?? num(c.envelopeCorrelationMin) ?? null
+      };
+    }
+    case "api_sequence":
+      return {};
+    case "end":
+      return { outcome: str(c.outcome) ?? "pass" };
+    default:
+      return {};
+  }
+}
+function authoredActionTitle(raw) {
+  const c = raw ?? {};
+  const explicit = str(c.customActionTitle) ?? str(c.title);
+  if (explicit && explicit.trim()) return explicit.trim();
+  const desc = (str(c.actionDescription) ?? "").replace(/\*/g, "").replace(/\s+/g, " ").trim();
+  if (!desc) return "Action";
+  const sentence = desc.split(/(?<=[.!?])\s/)[0] ?? desc;
+  return sentence.slice(0, 80).trim() || "Action";
+}
+function authoredActionFields(raw) {
+  const c = raw ?? {};
+  const inputValues = c.inputValues && typeof c.inputValues === "object" ? c.inputValues : {};
+  const formFields = arr(c.formFields);
+  const formByName = /* @__PURE__ */ new Map();
+  for (const f of formFields) {
+    const n = str(prop(f, "name"));
+    if (n) formByName.set(n, f);
+  }
+  const reqs = arr(c.dataRequirements);
+  const source = reqs.length > 0 ? reqs : formFields;
+  const out = [];
+  for (const s of source) {
+    const name = str(prop(s, "name"));
+    if (!name) continue;
+    const value = str(inputValues[name]) ?? str(prop(formByName.get(name), "value")) ?? "";
+    out.push({ name, type: str(prop(s, "type")) ?? "text", value });
+  }
+  return out;
+}
+function loginCredentialRef(raw) {
+  const c = raw ?? {};
+  const seedRef = c.seedCredentialRef;
+  return str(c.credentialTemplateName) ?? str(c.credentialName) ?? str(c.credentialId) ?? str(c.credentialTemplateId) ?? // For from_seed bindings, `dataKey` is the stable identifier (matches the
+  // seed's declared-output key); `name` is a display label that can drift.
+  // Prefer dataKey so spec round-trip (which uses `seed-output <dataKey>`)
+  // hash-matches the live row regardless of label.
+  str(prop(seedRef, "dataKey")) ?? str(prop(seedRef, "name"));
+}
+function sortObjectKeys(value) {
+  if (Array.isArray(value)) return value.map(sortObjectKeys);
+  if (value !== null && typeof value === "object") {
+    const obj3 = value;
+    return Object.keys(obj3).sort().reduce((acc, k) => {
+      acc[k] = sortObjectKeys(obj3[k]);
+      return acc;
+    }, {});
+  }
+  return value;
+}
+function canon(v) {
+  if (v === void 0) return null;
+  return v.replace(/[`"]/g, "").replace(/\.$/, "").trim();
+}
+function trimText(v) {
+  return v === void 0 ? null : v.trim();
+}
+function str(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function arr(v) {
+  return Array.isArray(v) ? v : [];
+}
+function prop(v, key) {
+  return v && typeof v === "object" ? v[key] : void 0;
+}
+function obj(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+
+// ../canary-spec/src/diff.ts
+var NodeTypeMutationError = class extends Error {
+  constructor(nodeId, fromType, toType) {
+    super(
+      `Node ${nodeId} cannot change type from "${fromType}" to "${toType}". Remove the @id from the spec and let the diff CREATE a fresh node.`
+    );
+    this.nodeId = nodeId;
+    this.name = "NodeTypeMutationError";
+  }
+  nodeId;
+};
+function diffWorkflow(spec, live) {
+  const ops = [];
+  const duplicateSpecIds = [];
+  const orphanedSpecIds = [];
+  const liveById = /* @__PURE__ */ new Map();
+  for (const n of live.nodes) liveById.set(n.id, n);
+  const consumedLiveIds = /* @__PURE__ */ new Set();
+  const seenSpecIds = /* @__PURE__ */ new Set();
+  const pairedOrderIndexes = [];
+  spec.nodes.forEach((specNode, specIndex) => {
+    let pairedLive;
+    if (specNode.nodeId) {
+      if (seenSpecIds.has(specNode.nodeId)) {
+        duplicateSpecIds.push(specNode.nodeId);
+      } else {
+        seenSpecIds.add(specNode.nodeId);
+        const candidate = liveById.get(specNode.nodeId);
+        if (candidate && !consumedLiveIds.has(candidate.id)) {
+          pairedLive = candidate;
+          consumedLiveIds.add(candidate.id);
+        } else {
+          orphanedSpecIds.push(specNode.nodeId);
+        }
+      }
+    } else if (specNode.nodeType === "login") {
+      const liveLogin = live.nodes.find(
+        (n) => n.nodeType === "login" && !consumedLiveIds.has(n.id)
+      );
+      if (liveLogin) {
+        pairedLive = liveLogin;
+        consumedLiveIds.add(liveLogin.id);
+      }
+    }
+    if (pairedLive) {
+      if (pairedLive.nodeType !== specNode.nodeType) {
+        throw new NodeTypeMutationError(pairedLive.id, pairedLive.nodeType, specNode.nodeType);
+      }
+      const configChanged = authoredNodeHash(pairedLive) !== authoredNodeHash({ nodeType: specNode.nodeType, configJson: specNode.configJson });
+      pairedOrderIndexes.push(pairedLive.orderIndex);
+      ops.push({
+        kind: "update",
+        nodeId: pairedLive.id,
+        specIndex,
+        nodeType: specNode.nodeType,
+        configJson: specNode.configJson,
+        orderIndex: specIndex,
+        changes: {
+          // orderChanged is finalized after the pass (needs the full sequence).
+          configChanged,
+          orderChanged: false,
+          fromOrderIndex: pairedLive.orderIndex
+        }
+      });
+    } else {
+      ops.push({
+        kind: "create",
+        specIndex,
+        nodeType: specNode.nodeType,
+        configJson: specNode.configJson,
+        orderIndex: specIndex,
+        sourceLine: specNode.sourceLine
+      });
+    }
+  });
+  const relativeOrderPreserved = pairedOrderIndexes.every(
+    (v, i) => i === 0 || v >= pairedOrderIndexes[i - 1]
+  );
+  if (!relativeOrderPreserved) {
+    for (const op of ops) {
+      if (op.kind === "update") {
+        op.changes.orderChanged = op.changes.fromOrderIndex !== op.orderIndex;
+      }
+    }
+  }
+  for (const liveNode of live.nodes) {
+    if (!consumedLiveIds.has(liveNode.id)) {
+      ops.push({
+        kind: "delete",
+        nodeId: liveNode.id,
+        nodeType: liveNode.nodeType,
+        orderIndex: liveNode.orderIndex
+      });
+    }
+  }
+  const workflowFieldChanges = {};
+  if (spec.description !== live.description) workflowFieldChanges.description = spec.description;
+  if (spec.preflight !== live.preflight) workflowFieldChanges.preflight = spec.preflight;
+  if (spec.cleanup !== live.cleanup) workflowFieldChanges.cleanup = spec.cleanup;
+  if (spec.status !== void 0 && spec.status !== live.status) {
+    workflowFieldChanges.status = spec.status;
+  }
+  if (spec.flowType !== void 0 && spec.flowType !== live.flowType) {
+    workflowFieldChanges.flowType = spec.flowType;
+  }
+  const specApiOnly = spec.apiOnly === true;
+  const liveApiOnly = live.apiOnly === true;
+  if (specApiOnly !== liveApiOnly) workflowFieldChanges.apiOnly = specApiOnly;
+  if (spec.tags !== void 0) {
+    const specSet = [...spec.tags].sort();
+    const liveSet = [...(live.tags ?? []).map((t) => t.name)].sort();
+    if (specSet.length !== liveSet.length || specSet.some((v, i) => v !== liveSet[i])) {
+      workflowFieldChanges.tags = spec.tags;
+    }
+  }
+  if (spec.environmentConstraints !== void 0) {
+    if (!sameEnvConstraints(spec.environmentConstraints, live.environmentConstraints)) {
+      workflowFieldChanges.environmentConstraints = spec.environmentConstraints;
+    }
+  }
+  if (spec.sandboxTemplate !== void 0) {
+    const liveName = live.sandboxTemplate?.name ?? null;
+    if (spec.sandboxTemplate !== liveName) {
+      workflowFieldChanges.sandboxTemplate = spec.sandboxTemplate;
+    }
+  }
+  if (spec.teardownSpec !== void 0) {
+    const liveName = live.teardownWorkflowName ?? null;
+    if (spec.teardownSpec !== liveName) workflowFieldChanges.teardownSpec = spec.teardownSpec;
+  }
+  if (spec.teardownSnapshotVersion !== void 0) {
+    const specVal = spec.teardownSnapshotVersion === "latest" ? null : spec.teardownSnapshotVersion;
+    const liveVal = live.teardownSnapshotVersion ?? null;
+    if (specVal !== liveVal) {
+      workflowFieldChanges.teardownSnapshotVersion = spec.teardownSnapshotVersion;
+    }
+  }
+  if (spec.teardownEnabled !== void 0) {
+    const liveVal = live.teardownEnabled === true;
+    if (spec.teardownEnabled !== liveVal) {
+      workflowFieldChanges.teardownEnabled = spec.teardownEnabled;
+    }
+  }
+  if (spec.seedOutputs !== void 0) {
+    const liveByKey = new Map(
+      (live.seedOutputs ?? []).map((o) => [o.dataKey, o])
+    );
+    const sliced = (live.seedOutputs ?? []).map((o) => ({
+      dataKey: o.dataKey,
+      label: o.displayLabel,
+      description: o.description,
+      propertyName: o.propertyName
+    }));
+    const specSliced = spec.seedOutputs.map((o) => ({
+      dataKey: o.dataKey,
+      label: o.label,
+      description: o.description,
+      propertyName: o.propertyName
+    }));
+    if (!seedOutputsEqual(sliced, specSliced)) {
+      workflowFieldChanges.seedOutputs = spec.seedOutputs.map((o) => {
+        const liveRow = liveByKey.get(o.dataKey);
+        return {
+          dataKey: o.dataKey,
+          label: o.label,
+          description: o.description,
+          propertyName: o.propertyName,
+          ...liveRow?.credentialOutput !== void 0 ? { credentialOutput: liveRow.credentialOutput } : {},
+          ...liveRow?.attributes !== void 0 ? { attributes: liveRow.attributes } : {}
+        };
+      });
+    }
+  }
+  if (!deepEquals(authoredInputs(live.inputsJson), authoredInputs(spec.inputsJson))) {
+    workflowFieldChanges.inputsJson = spec.inputsJson;
+  }
+  if (!deepEquals(authoredScenarios(live.scenariosJson), authoredScenarios(spec.scenariosJson))) {
+    workflowFieldChanges.scenariosJson = spec.scenariosJson;
+  }
+  const nameDrift = spec.name !== live.name ? { from: live.name, to: spec.name } : null;
+  if (nameDrift) workflowFieldChanges.name = spec.name;
+  return { ops, workflowFieldChanges, nameDrift, duplicateSpecIds, orphanedSpecIds };
+}
+function authoredInputs(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const i of raw) {
+    if (!i || typeof i !== "object") continue;
+    const rec = i;
+    if (typeof rec.name !== "string") continue;
+    out.push({
+      kind: rec.kind === "credential" ? "credential" : "value",
+      name: rec.name,
+      defaultValue: typeof rec.defaultValue === "string" ? rec.defaultValue : ""
+    });
+  }
+  return out;
+}
+function authoredScenarios(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const s of raw) {
+    if (!s || typeof s !== "object") continue;
+    const rec = s;
+    if (typeof rec.name !== "string") continue;
+    out.push({
+      name: rec.name,
+      description: typeof rec.description === "string" ? rec.description : "",
+      isDefault: rec.isDefault === true,
+      includeInSuite: rec.includeInSuite !== false,
+      values: strRecord(rec.values),
+      credentials: strRecord(rec.credentials)
+    });
+  }
+  return out;
+}
+function sameEnvConstraints(spec, live) {
+  if (spec === null || spec === void 0) return !live;
+  if (!live) return false;
+  if (spec.mode !== live.mode) return false;
+  if (spec.mode === "only" && live.mode === "only") {
+    const a = [...spec.environmentNames].sort();
+    const b = [...live.environmentNames ?? []].sort();
+    return a.length === b.length && a.every((v, i) => v === b[i]);
+  }
+  if (spec.mode === "envTypes" && live.mode === "envTypes") {
+    const a = [...spec.types].sort();
+    const b = [...live.types].sort();
+    return a.length === b.length && a.every((v, i) => v === b[i]);
+  }
+  return false;
+}
+function seedOutputsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  const sortByKey = (rows) => [...rows].sort((x, y) => x.dataKey.localeCompare(y.dataKey));
+  const xa = sortByKey(a);
+  const xb = sortByKey(b);
+  for (let i = 0; i < xa.length; i++) {
+    if (xa[i].dataKey !== xb[i].dataKey) return false;
+    if ((xa[i].label ?? "") !== (xb[i].label ?? "")) return false;
+    if ((xa[i].description ?? "") !== (xb[i].description ?? "")) return false;
+    if ((xa[i].propertyName ?? "") !== (xb[i].propertyName ?? "")) return false;
+  }
+  return true;
+}
+function strRecord(v) {
+  const out = {};
+  if (v && typeof v === "object") {
+    for (const [k, val] of Object.entries(v)) {
+      if (typeof val === "string") out[k] = val;
+    }
+  }
+  return out;
+}
+function deepEquals(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEquals(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  const ao = a;
+  const bo = b;
+  const ak = Object.keys(ao);
+  const bk = Object.keys(bo);
+  if (ak.length !== bk.length) return false;
+  for (const k of ak) {
+    if (!Object.prototype.hasOwnProperty.call(bo, k)) return false;
+    if (!deepEquals(ao[k], bo[k])) return false;
+  }
+  return true;
+}
+function summarize(diff) {
+  let created = 0;
+  let updated = 0;
+  let deleted = 0;
+  let moved = 0;
+  let unchanged = 0;
+  for (const op of diff.ops) {
+    if (op.kind === "create") created++;
+    else if (op.kind === "delete") deleted++;
+    else if (op.kind === "update") {
+      if (op.changes.configChanged) updated++;
+      if (op.changes.orderChanged) moved++;
+      if (!op.changes.configChanged && !op.changes.orderChanged) unchanged++;
+    }
+  }
+  return { created, updated, deleted, moved, unchanged };
+}
+function hasAnyChange(diff) {
+  if (diff.ops.some((op) => op.kind !== "update" || op.changes.configChanged || op.changes.orderChanged)) return true;
+  return Object.keys(diff.workflowFieldChanges).length > 0;
+}
+function reconcileLinearEdges(finalNodeIds, liveEdges) {
+  const desired = /* @__PURE__ */ new Set();
+  for (let i = 0; i < finalNodeIds.length - 1; i++) {
+    desired.add(`${finalNodeIds[i]}\u2192${finalNodeIds[i + 1]}`);
+  }
+  const ops = [];
+  const haveDefault = /* @__PURE__ */ new Set();
+  for (const e of liveEdges) {
+    if (e.edgeType !== "default") continue;
+    const key = `${e.sourceNodeId}\u2192${e.targetNodeId}`;
+    if (desired.has(key)) {
+      haveDefault.add(key);
+    } else {
+      ops.push({ kind: "delete", edgeId: e.id });
+    }
+  }
+  for (const key of desired) {
+    if (haveDefault.has(key)) continue;
+    const [sourceNodeId, targetNodeId] = key.split("\u2192");
+    ops.push({ kind: "create", sourceNodeId, targetNodeId });
+  }
+  return { ops };
+}
+
+// ../canary-spec/src/pull.ts
+function workflowToSpec(workflow, opts = {}) {
+  const lines = [];
+  const sorted = [...workflow.nodes].sort((a, b) => a.orderIndex - b.orderIndex);
+  let firstNonSeed = 0;
+  while (firstNonSeed < sorted.length && (sorted[firstNonSeed].nodeType === "seed" || sorted[firstNonSeed].nodeType === "setup")) {
+    firstNonSeed++;
+  }
+  const authLogin = sorted[firstNonSeed]?.nodeType === "login" ? sorted[firstNonSeed] : void 0;
+  const authenticated = !!authLogin;
+  const actor = authLogin ? inferActor(authLogin) : null;
+  lines.push("---");
+  lines.push(`name: ${yamlScalar(workflow.name)}`);
+  lines.push(`workflowId: ${workflow.id}`);
+  if (workflow.status === "draft" || workflow.status === "quarantined") {
+    lines.push(`status: ${workflow.status}`);
+  }
+  if (workflow.flowType && workflow.flowType !== "standard") {
+    lines.push(`flowType: ${workflow.flowType}`);
+  }
+  if (actor) lines.push(`actor: ${yamlScalar(actor)}`);
+  lines.push(`authenticated: ${authenticated ? "true" : "false"}`);
+  if (workflow.apiOnly === true) lines.push("apiOnly: true");
+  const tags = (workflow.tags ?? []).map((t) => t.name).filter(Boolean);
+  if (tags.length > 0) lines.push(`tags: [${tags.map(yamlScalar).join(", ")}]`);
+  const envBlock = renderEnvironments(workflow.environmentConstraints);
+  if (envBlock) lines.push(...envBlock);
+  if (workflow.sandboxTemplate?.name) {
+    lines.push(`sandboxTemplate: ${yamlScalar(workflow.sandboxTemplate.name)}`);
+  }
+  const teardownLines = renderTeardown(workflow);
+  if (teardownLines) lines.push(...teardownLines);
+  if (opts.requirementRef) lines.push(`requirementRef: ${yamlScalar(opts.requirementRef)}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${workflow.name}`);
+  lines.push("");
+  if (workflow.description) {
+    lines.push("## Spirit");
+    lines.push(blockquote(workflow.description));
+    lines.push("");
+  }
+  if (workflow.preflight) {
+    lines.push("## Preflight");
+    lines.push(workflow.preflight.trim());
+    lines.push("");
+  }
+  if (workflow.cleanup) {
+    lines.push("## Cleanup");
+    lines.push(workflow.cleanup.trim());
+    lines.push("");
+  }
+  const inputs = readInputs(workflow.inputsJson);
+  if (inputs.length > 0) {
+    lines.push("## Inputs");
+    for (const i of inputs) {
+      const prefix = i.kind === "credential" ? "credential " : "";
+      lines.push(`- ${prefix}${i.name}: ${inputValue(i.defaultValue)}`);
+    }
+    lines.push("");
+  }
+  const scenarios = readScenarios(workflow.scenariosJson);
+  const skipReasons = opts.preserveScenarioSkipReasons ?? {};
+  if (scenarios.length > 0) {
+    lines.push("## Scenarios");
+    lines.push("");
+    for (const s of scenarios) {
+      let heading = `### ${s.name}`;
+      const skipReason = skipReasons[s.name];
+      if (s.isDefault) heading += " *(default)*";
+      else if (!s.includeInSuite) {
+        heading += skipReason ? ` *(skip: ${skipReason})*` : " *(skip)*";
+      }
+      lines.push(heading);
+      if (s.description) lines.push(`- description: ${s.description}`);
+      if (Object.keys(s.values).length > 0) {
+        lines.push("- values:");
+        for (const [k, v] of Object.entries(s.values)) lines.push(`    ${k}: ${yamlScalar(v)}`);
+      }
+      if (Object.keys(s.credentials).length > 0) {
+        lines.push("- credentials:");
+        for (const [k, v] of Object.entries(s.credentials))
+          lines.push(`    ${k}: ${yamlScalar(v)}`);
+      }
+      lines.push("");
+    }
+  }
+  const declaredOutputBlock = renderDeclaredOutputs(workflow.seedOutputs);
+  if (declaredOutputBlock) {
+    lines.push("## Declared Outputs");
+    lines.push("");
+    lines.push(...declaredOutputBlock);
+    lines.push("");
+  }
+  lines.push("## Journey");
+  lines.push("");
+  for (const node of sorted) {
+    if (node === authLogin) continue;
+    const block = renderNode(node);
+    if (block.length === 0) continue;
+    block[0] = `${block[0]}   <!-- @id ${node.id} -->`;
+    lines.push(...block);
+    lines.push("");
+  }
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  lines.push("");
+  return lines.join("\n");
+}
+function renderNode(node) {
+  const c = node.configJson ?? {};
+  switch (node.nodeType) {
+    case "login": {
+      return [`**Switch role to ${renderLoginRef(c)}**`];
+    }
+    case "navigate":
+      return [`**Navigate to** \`${str2(c.pageUrl) ?? "/"}\`.`];
+    case "action": {
+      const title = authoredActionTitle(c);
+      const out = [`**Action \u2014 ${title}**`];
+      const desc = str2(c.actionDescription);
+      if (desc && desc !== title) out.push(blockquote(desc));
+      for (const f of authoredActionFields(c)) {
+        const typeSuffix = f.type && f.type !== "text" ? ` (${f.type})` : "";
+        const name = /^[A-Za-z0-9_-]+$/.test(f.name) ? f.name : `"${f.name}"`;
+        out.push(`- field ${name}${typeSuffix}: ${inputValue(f.value)}`);
+      }
+      for (const cap of arr2(c.declaredOutputs)) {
+        if (typeof cap === "string") out.push(`- capture: ${cap}`);
+      }
+      for (const a of arr2(c.inlineAssertions)) {
+        const cond = str2(prop2(a, "condition"));
+        if (!cond) continue;
+        const sev = str2(prop2(a, "severity")) ?? "fail";
+        const flags = prop2(a, "agentic") === true ? `${sev}, agentic` : sev;
+        out.push(`- assert (${flags}): ${cond}`);
+      }
+      if (c.captureAudio === true) {
+        out.push("- captureAudio: true");
+        if (str2(c.captureLabel)) out.push(`- captureLabel: ${str2(c.captureLabel)}`);
+        if (num2(c.captureExtraMs) !== void 0)
+          out.push(`- captureExtraMs: ${num2(c.captureExtraMs)}`);
+      }
+      if (c.alwaysUseAgent === true) out.push("- alwaysUseAgent: true");
+      return out;
+    }
+    case "assertion": {
+      const cond = str2(c.condition) ?? "?";
+      const out = [`**Assert** ${cond}`];
+      const desc = str2(c.description);
+      if (desc && desc !== cond) out.push(blockquote(desc));
+      const severity = str2(c.severity) ?? (c.strict === true ? "fail" : "warn");
+      out.push(`- severity: ${severity}`);
+      if (str2(c.expectedOutcome)) out.push(`- expectedOutcome: ${str2(c.expectedOutcome)}`);
+      if (c.alwaysUseAgent === true) out.push("- alwaysUseAgent: true");
+      return out;
+    }
+    case "seed": {
+      const name = str2(c.seedWorkflowName) ?? "?";
+      const out = [`**Seed** \`${name}\`.`];
+      const snap = c.snapshotVersion ?? c.seedSnapshotVersion;
+      if (typeof snap === "number") out.push(`- version: ${snap}`);
+      const onFailure = str2(c.onFailure) ?? str2(c.seedOnFailure);
+      if (onFailure) out.push(`- onFailure: ${onFailure}`);
+      const mode = str2(c.executionMode) ?? str2(c.seedExecutionMode);
+      if (mode) out.push(`- mode: ${mode}`);
+      if (str2(c.scope)) out.push(`- scope: ${str2(c.scope)}`);
+      if (typeof c.runTeardown === "boolean") out.push(`- runTeardown: ${c.runTeardown}`);
+      return out;
+    }
+    case "setup": {
+      const name = str2(c.setupFlowName) ?? "?";
+      const out = [`**Setup** \`${name}\`.`];
+      if (typeof c.snapshotVersion === "number") out.push(`- version: ${c.snapshotVersion}`);
+      if (str2(c.executionMode)) out.push(`- mode: ${str2(c.executionMode)}`);
+      return out;
+    }
+    case "wait": {
+      const secs = num2(c.delaySeconds) ?? num2(c.waitDuration) ?? 0;
+      return [`**Wait** ${secs}s.`];
+    }
+    case "condition": {
+      const expr = str2(c.conditionDescription) ?? str2(c.conditionExpression) ?? str2(c.description) ?? "?";
+      return expr.includes("\n") ? ["**If**", blockquote(expr)] : [`**If ${expr}**`];
+    }
+    case "notification": {
+      const channel = str2(c.channel) ?? "email";
+      const to = str2(c.to) ?? "?";
+      const out = [`**Notify ${channel}: ${to}**`];
+      if (str2(c.body)) out.push(blockquote(str2(c.body)));
+      if (str2(c.subject)) out.push(`- subject: ${str2(c.subject)}`);
+      if (str2(c.attachmentRef)) out.push(`- attach: ${str2(c.attachmentRef)}`);
+      return out;
+    }
+    case "audio": {
+      const ref = str2(c.attachmentRef) ?? "?";
+      const out = [`**Play audio** \`${ref}\``];
+      if (c.loop === true) out.push("- loop: true");
+      if (c.waitForCompletion === false) out.push("- waitForCompletion: false");
+      if (str2(c.label)) out.push(`- label: ${str2(c.label)}`);
+      return out;
+    }
+    case "audio-assertion": {
+      const det = obj2(c.deterministic);
+      const nl = obj2(c.naturalLanguage);
+      const prompt = str2(nl?.prompt) ?? str2(c.prompt);
+      const model = str2(nl?.model) ?? str2(c.model);
+      const out = [`**Assert audio** ${str2(c.label) ?? "?"}`];
+      out.push(`- severity: ${str2(c.severity) ?? "fail"}`);
+      if (prompt) out.push(`- prompt: ${prompt}`);
+      if (model) out.push(`- model: ${model}`);
+      for (const [cfgKey, bulletKey] of [
+        ["minDurationMs", "minDurationMs"],
+        ["maxDurationMs", "maxDurationMs"],
+        ["minRmsDb", "minRmsDb"],
+        ["silenceFractionMax", "silenceFractionMax"],
+        ["envelopeCorrelationMin", "envelopeCorrelationMin"]
+      ]) {
+        const value = num2(det?.[cfgKey]) ?? num2(c[cfgKey]);
+        if (value !== void 0) out.push(`- ${bulletKey}: ${value}`);
+      }
+      if (str2(c.referenceAttachmentRef)) out.push(`- reference: ${str2(c.referenceAttachmentRef)}`);
+      return out;
+    }
+    case "api_sequence": {
+      const title = str2(c.customActionTitle) ?? str2(c.title) ?? "API sequence";
+      const out = [`**API sequence \u2014 ${title}**`];
+      if (str2(c.apiEndpointContext)) out.push(blockquote(str2(c.apiEndpointContext)));
+      if (str2(c.credentialInputName)) out.push(`- credential: ${str2(c.credentialInputName)}`);
+      if (str2(c.__apiSequenceSidecar)) {
+        out.push(`- apiSequence: ${str2(c.__apiSequenceSidecar)}`);
+      }
+      return out;
+    }
+    case "end":
+      return [str2(c.outcome) === "fail" ? "**End (fail)**." : "**End**."];
+    default:
+      return [];
+  }
+}
+function extractPreservedFrontmatter(priorSource) {
+  const result = {};
+  const fmMatch = priorSource.match(/^---\n([\s\S]*?)\n---/);
+  if (fmMatch) {
+    const reqMatch = fmMatch[1].match(/^requirementRef:\s*(.+)$/m);
+    if (reqMatch) {
+      const raw = reqMatch[1].trim();
+      const unquoted = raw.startsWith('"') && raw.endsWith('"') ? JSON.parse(raw) : raw;
+      result.requirementRef = unquoted;
+    }
+  }
+  const skipReasons = {};
+  const re = /^###\s+(.+?)\s+\*\(skip:\s*(.+?)\)\*\s*$/gm;
+  let m;
+  while ((m = re.exec(priorSource)) !== null) {
+    const name = m[1].trim();
+    const reason = m[2].trim();
+    if (name && reason) skipReasons[name] = reason;
+  }
+  if (Object.keys(skipReasons).length > 0) {
+    result.preserveScenarioSkipReasons = skipReasons;
+  }
+  return result;
+}
+function renderDeclaredOutputs(outputs) {
+  if (!outputs || outputs.length === 0) return null;
+  const out = [];
+  for (const o of outputs) {
+    out.push(`- ${o.dataKey}`);
+    const label = o.displayLabel ?? o.name;
+    if (label && label !== o.dataKey) out.push(`  - label: ${yamlScalar(label)}`);
+    if (o.propertyName) out.push(`  - property: ${yamlScalar(o.propertyName)}`);
+    if (o.description) out.push(`  - description: ${o.description}`);
+    if (o.credentialOutput !== void 0) {
+      out.push("  <!-- credentialOutput config preserved by the server; edit in UI for now -->");
+    }
+    out.push("");
+  }
+  while (out.length > 0 && out[out.length - 1] === "") out.pop();
+  return out;
+}
+function renderTeardown(workflow) {
+  if (!workflow.teardownWorkflowId) return null;
+  const name = workflow.teardownWorkflowName;
+  if (!name) return null;
+  const snap = workflow.teardownSnapshotVersion;
+  const enabled = workflow.teardownEnabled !== false;
+  if ((snap === null || snap === void 0) && enabled) {
+    return [`teardown: ${yamlScalar(name)}`];
+  }
+  const out = ["teardown:", `  spec: ${yamlScalar(name)}`];
+  if (snap !== null && snap !== void 0) out.push(`  snapshotVersion: ${snap}`);
+  if (!enabled) out.push("  enabled: false");
+  return out;
+}
+function renderEnvironments(constraints) {
+  if (!constraints) return null;
+  if (constraints.mode === "only") {
+    const names = constraints.environmentNames;
+    if (!names || names.length === 0) return null;
+    return ["environments:", `  only: [${names.map(yamlScalar).join(", ")}]`];
+  }
+  return ["environments:", `  types: [${constraints.types.map(yamlScalar).join(", ")}]`];
+}
+function renderLoginRef(c) {
+  if (c.credentialSource === "from_seed") {
+    const seedRef = c.seedCredentialRef;
+    const ref = typeof seedRef?.dataKey === "string" && seedRef.dataKey || typeof seedRef?.name === "string" && seedRef.name;
+    if (ref) return `seed-output ${ref}`;
+  }
+  const role = str2(c.credentialTemplateName);
+  if (role) return role;
+  const cred = loginCredentialRef(c);
+  if (cred) return `credential ${cred}`;
+  return "?";
+}
+function inferActor(login) {
+  const c = login.configJson ?? {};
+  if (c.credentialSource === "from_seed") {
+    const seedRef = c.seedCredentialRef;
+    const ref = typeof seedRef?.dataKey === "string" && seedRef.dataKey || typeof seedRef?.name === "string" && seedRef.name;
+    if (ref) return `seed-output ${ref}`;
+  }
+  const role = str2(c.credentialTemplateName);
+  if (role) return role;
+  const cred = loginCredentialRef(c);
+  if (cred) return `credential ${cred}`;
+  return null;
+}
+function readInputs(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const i of raw) {
+    if (!i || typeof i !== "object") continue;
+    const rec = i;
+    if (typeof rec.name !== "string") continue;
+    out.push({
+      kind: rec.kind === "credential" ? "credential" : "value",
+      name: rec.name,
+      defaultValue: typeof rec.defaultValue === "string" ? rec.defaultValue : ""
+    });
+  }
+  return out;
+}
+function readScenarios(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const s of raw) {
+    if (!s || typeof s !== "object") continue;
+    const rec = s;
+    if (typeof rec.name !== "string") continue;
+    out.push({
+      name: rec.name,
+      description: typeof rec.description === "string" ? rec.description : void 0,
+      isDefault: rec.isDefault === true,
+      includeInSuite: rec.includeInSuite !== false,
+      values: strRecord2(rec.values),
+      credentials: strRecord2(rec.credentials)
+    });
+  }
+  return out;
+}
+function inputValue(v) {
+  return v === "" ? '""' : v;
+}
+function blockquote(text) {
+  return text.trim().split("\n").map((l) => `> ${l}`).join("\n");
+}
+function yamlScalar(s) {
+  if (s === "") return '""';
+  if (/^[A-Za-z0-9 _\-./@]+$/.test(s) && !/^\s|\s$/.test(s)) return s;
+  return JSON.stringify(s);
+}
+function strRecord2(v) {
+  const out = {};
+  if (v && typeof v === "object") {
+    for (const [k, val] of Object.entries(v)) {
+      if (typeof val === "string") out[k] = val;
+    }
+  }
+  return out;
+}
+function str2(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function num2(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function arr2(v) {
+  return Array.isArray(v) ? v : [];
+}
+function prop2(v, key) {
+  return v && typeof v === "object" ? v[key] : void 0;
+}
+function obj2(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+
+// ../canary-spec/src/api-sequence-file.ts
+import { z as z2 } from "zod";
+var ApiSequenceValidationSchema = z2.object({
+  kind: z2.string().min(1).optional()
+}).passthrough();
+var ApiSequenceStepSchema = z2.object({
+  stepId: z2.string().min(1).optional(),
+  apiRequestId: z2.string().min(1),
+  credentialId: z2.string().nullable().optional(),
+  method: z2.string().min(1).optional(),
+  urlTemplate: z2.string().optional(),
+  queryParams: z2.array(z2.object({ key: z2.string().min(1), value: z2.string() })).optional(),
+  bodyTemplate: z2.string().nullable().optional(),
+  headersTemplate: z2.record(z2.string(), z2.string()).nullable().optional(),
+  responseVariableName: z2.string().min(1).optional(),
+  expectedStatusCodes: z2.array(z2.number().int()).optional(),
+  description: z2.string().optional(),
+  validations: z2.array(ApiSequenceValidationSchema).optional()
+});
+var ApiSequenceExportSchema = z2.object({
+  variableName: z2.string().min(1),
+  stepId: z2.string().min(1),
+  responsePath: z2.string().min(1),
+  source: z2.enum(["request", "response"]).optional(),
+  description: z2.string().optional()
+});
+var ApiSequenceFileSchema = z2.object({
+  description: z2.string().optional(),
+  stopOnFailure: z2.boolean().optional(),
+  steps: z2.array(ApiSequenceStepSchema).default([]),
+  exports: z2.array(ApiSequenceExportSchema).default([])
+});
+
+// ../canary-spec/src/writeback.ts
+var FRONTMATTER_FENCE2 = /^---\s*$/;
+function writeWorkflowId(source, workflowId) {
+  const lines = source.split(/\r?\n/);
+  if (!FRONTMATTER_FENCE2.test(lines[0] ?? "")) return source;
+  const end = findFrontmatterEnd2(lines);
+  if (end === -1) return source;
+  for (let i = 1; i < end; i++) {
+    if (/^workflowId\s*:/.test(lines[i])) return source;
+  }
+  let insertAt = end;
+  for (let i = 1; i < end; i++) {
+    if (/^name\s*:/.test(lines[i])) {
+      insertAt = i + 1;
+      break;
+    }
+  }
+  const out = [...lines];
+  out.splice(insertAt, 0, `workflowId: ${workflowId}`);
+  return out.join("\n");
+}
+function writeNodeIds(source, pairs) {
+  const lines = source.split(/\r?\n/);
+  const NODE_ID_RE2 = /<!--\s*@id\s+[0-9a-f-]+\s*-->/i;
+  for (const { sourceLine, nodeId } of pairs) {
+    if (sourceLine < 0 || sourceLine >= lines.length) continue;
+    const line = lines[sourceLine];
+    if (NODE_ID_RE2.test(line)) continue;
+    lines[sourceLine] = `${line.trimEnd()}   <!-- @id ${nodeId} -->`;
+  }
+  return lines.join("\n");
+}
+function findFrontmatterEnd2(lines) {
+  if (!FRONTMATTER_FENCE2.test(lines[0] ?? "")) return -1;
+  for (let i = 1; i < lines.length; i++) if (FRONTMATTER_FENCE2.test(lines[i])) return i;
+  return -1;
+}
+
+export {
+  parseSpec,
+  lintSpec,
+  emitSpec,
+  diffWorkflow,
+  summarize,
+  hasAnyChange,
+  reconcileLinearEdges,
+  workflowToSpec,
+  extractPreservedFrontmatter,
+  ApiSequenceFileSchema,
+  writeWorkflowId,
+  writeNodeIds
+};
+//# sourceMappingURL=chunk-B2VISN2V.js.map