bitfab-cli 0.2.474 → 0.2.475

package/dist/index.js

@@ -31890,7 +31890,7 @@ async function runUpdate(currentVersion, platform2, mode = "all") {
   }
 }
 
-// ../bitfab-flow/dist/commands.js
+// ../node_modules/.pnpm/@agent-flows+core@0.1.1_zod@4.6.7/node_modules/@agent-flows/core/dist/commands.js
 function defineCommandCatalog(catalog) {
   return {
     defineCommands(defs) {
@@ -31912,239 +31912,12 @@ function defineCommandCatalog(catalog) {
   };
 }
 
-// ../bitfab-flow/dist/shared.js
-var CODEX_RESOLVE_PLUGIN_DIR_BASH = `\`\`\`bash
-if [ -z "$BITFAB_PLUGIN_DIR" ]; then
-  BITFAB_PLUGIN_DIR=$(
-    hit=$(find "\${CODEX_HOME:-$HOME/.codex}/plugins/cache" -maxdepth 6 -type f -name status.js \\
-      \\( -path '*/bitfab-internal/bitfab/local/dist/commands/*' \\
-      -o -path '*/bitfab/bitfab/*/dist/commands/*' \\) 2>/dev/null | head -1)
-    echo "\${hit%/dist/commands/status.js}"
-  )
-  export BITFAB_PLUGIN_DIR
-fi
-test -n "$BITFAB_PLUGIN_DIR" || { echo "ERROR: Bitfab plugin not installed"; exit 1; }
-\`\`\``;
-var AMP_RESOLVE_PLUGIN_DIR_BASH = `\`\`\`bash
-if [ -z "$BITFAB_PLUGIN_DIR" ]; then
-  project_root=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-  for candidate in "$project_root/.amp/plugins/bitfab" "\${XDG_CONFIG_HOME:-$HOME/.config}/amp/plugins/bitfab"; do
-    if [ -f "$candidate/dist/commands/status.js" ]; then
-      BITFAB_PLUGIN_DIR="$candidate"
-      break
-    fi
-  done
-  export BITFAB_PLUGIN_DIR
-fi
-test -n "$BITFAB_PLUGIN_DIR" || { echo "ERROR: Bitfab plugin not installed"; exit 1; }
-\`\`\``;
-
-// ../bitfab-flow/dist/targets.js
-var TARGET_NAMES = ["claude", "cursor", "codex", "amp"];
-var SECTION_TARGETS = {
-  claude: ["claude"],
-  cursor: ["cursor"],
-  codex: ["codex"],
-  amp: ["amp"],
-  "ask-user-question": ["claude", "cursor"],
-  "plugin-dir-lookup": ["codex", "amp"],
-  "exec-polling": ["codex", "amp"],
-  "no-startup-banner": ["codex", "amp"],
-  "web-fetch-tool": ["claude", "cursor"]
-};
-function formatAllowedTools(allowedTools) {
-  return `[${allowedTools.map((t) => JSON.stringify(t)).join(", ")}]`;
-}
-var renderClaudeFrontmatter = ({ description, argumentHint, model, allowedTools }) => {
-  const lines = ["---", `description: ${description}`];
-  if (argumentHint !== void 0) {
-    lines.push(`argument-hint: ${JSON.stringify(argumentHint)}`);
-  }
-  if (model !== void 0) {
-    lines.push(`model: ${model}`);
-  }
-  if (allowedTools !== void 0) {
-    lines.push(`allowed-tools: ${formatAllowedTools(allowedTools)}`);
-  }
-  lines.push("---");
-  return lines.join("\n");
-};
-var renderClaudeSkillFrontmatter = ({ flowId, description, model, allowedTools }) => {
-  const lines = [
-    "---",
-    `name: ${flowId}`,
-    `description: ${description}`,
-    "user-invocable: false"
-  ];
-  if (model !== void 0) {
-    lines.push(`model: ${model}`);
-  }
-  if (allowedTools !== void 0) {
-    lines.push(`allowed-tools: ${formatAllowedTools(allowedTools)}`);
-  }
-  lines.push("---");
-  return lines.join("\n");
-};
-function renderNamedFrontmatter(name, description, usage, usageInBody = false) {
-  const frontmatter = [
-    "---",
-    `name: ${name}`,
-    `description: "${description}${usageInBody ? "" : usage}"`,
-    "---"
-  ].join("\n");
-  return usageInBody && usage !== "" ? `${frontmatter}
-
-${usage.slice(2)}` : frontmatter;
-}
-var renderCursorFrontmatter = ({ flowId, description, argumentHint }) => {
-  const usage = argumentHint !== void 0 ? `. Usage: /bitfab-${flowId} ${argumentHint}` : "";
-  return renderNamedFrontmatter(`bitfab-${flowId}`, description, usage);
-};
-var renderCodexFrontmatter = ({ flowId, description, argumentHint }) => {
-  const usage = argumentHint !== void 0 ? `. Invoke with $bitfab:${flowId} ${argumentHint}.` : "";
-  return renderNamedFrontmatter(flowId, description, usage);
-};
-var renderAmpFrontmatter = ({ flowId, description, argumentHint }) => {
-  const usage = argumentHint !== void 0 ? `. Invoke as bitfab:${flowId} ${argumentHint}.` : "";
-  return renderNamedFrontmatter(flowId, description, usage);
-};
-var renderCursorDevFrontmatter = ({ flowId, description, argumentHint }) => {
-  const usage = argumentHint !== void 0 ? `. Usage: /bitfab-dev-${flowId} ${argumentHint}` : "";
-  return renderNamedFrontmatter(`bitfab-dev-${flowId}`, description, usage, true);
-};
-var renderCodexDevFrontmatter = ({ flowId, description, argumentHint }) => {
-  const usage = argumentHint !== void 0 ? `. Invoke with $bitfab-dev:${flowId} ${argumentHint}.` : "";
-  return renderNamedFrontmatter(flowId, description, usage, true);
-};
-var renderAmpDevFrontmatter = ({ flowId, description, argumentHint }) => {
-  const usage = argumentHint !== void 0 ? `. Invoke as bitfab-dev:${flowId} ${argumentHint}.` : "";
-  return renderNamedFrontmatter(flowId, description, usage, true);
-};
-var ASK_USER_QUESTION_TOKENS = {
-  askUser: "with `AskUserQuestion` ",
-  askVerb: "use `AskUserQuestion`",
-  askVerbCap: "Use `AskUserQuestion`",
-  askNoun: "AskUserQuestion"
-};
-var PLAIN_PROMPT_TOKENS = {
-  askUser: "",
-  askVerb: "ask the user",
-  askVerbCap: "Ask the user",
-  askNoun: "choice prompt"
-};
-var TARGETS = {
-  claude: {
-    name: "claude",
-    tokens: {
-      cmd: "/bitfab:",
-      devCmd: "/bitfab-dev:",
-      editor: "Claude Code",
-      // biome-ignore lint/suspicious/noTemplateCurlyInString: shell variable reference rendered into skill markdown, not a JS template
-      pluginRoot: "${CLAUDE_PLUGIN_ROOT}",
-      pluginDirLookup: "",
-      ...ASK_USER_QUESTION_TOKENS
-    },
-    mcpPrefix: "mcp__plugin_bitfab_Bitfab__",
-    argsToken: "$ARGUMENTS",
-    frontmatter: renderClaudeFrontmatter,
-    subSkillFrontmatter: renderClaudeSkillFrontmatter,
-    subSkillTool: "Skill"
-  },
-  cursor: {
-    name: "cursor",
-    tokens: {
-      cmd: "/bitfab-",
-      devCmd: "/bitfab-dev-",
-      editor: "Cursor",
-      // biome-ignore lint/suspicious/noTemplateCurlyInString: shell variable reference rendered into skill markdown, not a JS template
-      pluginRoot: "${CURSOR_PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT}}",
-      pluginDirLookup: "",
-      ...ASK_USER_QUESTION_TOKENS
-    },
-    mcpPrefix: "mcp__Bitfab__",
-    argsToken: "$ARGUMENTS",
-    frontmatter: renderCursorFrontmatter,
-    subSkillFrontmatter: renderCursorFrontmatter
-  },
-  codex: {
-    name: "codex",
-    tokens: {
-      cmd: "$bitfab:",
-      devCmd: "$bitfab-dev:",
-      editor: "Codex",
-      // biome-ignore lint/suspicious/noTemplateCurlyInString: shell variable reference rendered into skill markdown, not a JS template
-      pluginRoot: "${BITFAB_PLUGIN_DIR}",
-      pluginDirLookup: CODEX_RESOLVE_PLUGIN_DIR_BASH,
-      ...PLAIN_PROMPT_TOKENS
-    },
-    mcpPrefix: "mcp__Bitfab__",
-    argsToken: "$ARGUMENTS",
-    frontmatter: renderCodexFrontmatter,
-    subSkillFrontmatter: renderCodexFrontmatter,
-    dispatchRef: (skillName) => `\`$bitfab:${skillName}\``
-  },
-  amp: {
-    name: "amp",
-    tokens: {
-      cmd: "bitfab:",
-      devCmd: "bitfab-dev:",
-      editor: "Amp",
-      // biome-ignore lint/suspicious/noTemplateCurlyInString: shell variable reference rendered into skill markdown, not a JS template
-      pluginRoot: "${BITFAB_PLUGIN_DIR}",
-      pluginDirLookup: AMP_RESOLVE_PLUGIN_DIR_BASH,
-      ...PLAIN_PROMPT_TOKENS
-    },
-    mcpPrefix: "",
-    argsToken: "the user's request",
-    frontmatter: renderAmpFrontmatter,
-    subSkillFrontmatter: renderAmpFrontmatter,
-    subSkillTool: "skill",
-    dispatchRef: (skillName) => `\`bitfab:${skillName}\``
-  }
-};
-var DEV_TARGETS = {
-  claude: {
-    ...TARGETS.claude,
-    frontmatter: renderClaudeFrontmatter,
-    subSkillFrontmatter: renderClaudeSkillFrontmatter
-  },
-  cursor: {
-    ...TARGETS.cursor,
-    frontmatter: renderCursorDevFrontmatter,
-    subSkillFrontmatter: renderCursorDevFrontmatter
-  },
-  codex: {
-    ...TARGETS.codex,
-    frontmatter: renderCodexDevFrontmatter,
-    subSkillFrontmatter: renderCodexDevFrontmatter,
-    dispatchRef: (skillName) => `\`$bitfab-dev:${skillName}\``
-  },
-  amp: {
-    ...TARGETS.amp,
-    frontmatter: renderAmpDevFrontmatter,
-    subSkillFrontmatter: renderAmpDevFrontmatter,
-    dispatchRef: (skillName) => `\`bitfab-dev:${skillName}\``
-  }
-};
-
-// ../bitfab-flow/dist/schema.js
+// ../node_modules/.pnpm/@agent-flows+core@0.1.1_zod@4.6.7/node_modules/@agent-flows/core/dist/schema.js
 var StepIdRef = external_exports.string().regex(/^[a-z0-9-]+\/[a-z0-9-]+$/, {
   message: "Step references must use the form 'phase-id/step-id'"
 });
 var StepLocalId = external_exports.string().regex(/^[a-z0-9-]+$/);
 var PhaseId = external_exports.string().regex(/^[a-z0-9-]+$/);
-function PerTarget(inner) {
-  const objectForm = external_exports.object({
-    default: inner.optional(),
-    claude: inner.optional(),
-    cursor: inner.optional(),
-    codex: inner.optional(),
-    amp: inner.optional()
-  }).refine((v) => v.default !== void 0 || TARGET_NAMES.every((target) => v[target] !== void 0), {
-    message: `Per-target object must have \`default\` or define all of ${TARGET_NAMES.join("/")}.`
-  });
-  return external_exports.union([inner, objectForm]);
-}
 function resolvePerTarget(value, target) {
   if (typeof value !== "object" || value === null) {
     return value;
@@ -32152,23 +31925,6 @@ function resolvePerTarget(value, target) {
   const map2 = value;
   return map2[target] ?? map2.default;
 }
-var TargetableString = PerTarget(external_exports.string());
-var TargetableNonEmptyString = PerTarget(external_exports.string().min(1));
-var RESERVED_TOKEN_NAMES = [
-  "cmd",
-  "devCmd",
-  "editor",
-  "pluginRoot",
-  "pluginDirLookup",
-  "askUser",
-  "askVerb",
-  "askVerbCap",
-  "askNoun",
-  "argsToken"
-];
-var MUSTACHE_SECTION_NAMES = Object.keys(SECTION_TARGETS);
-var MODE_SECTION_RE = /\{\{([#^])mode:([a-z0-9-]+)\}\}/g;
-var MODE_SECTION_CLOSE_RE = /\{\{\/mode:([a-z0-9-]+)\}\}/g;
 function resolveTargetableString(value, target, label) {
   const resolved = resolvePerTarget(value, target);
   if (resolved === void 0) {
@@ -32176,6 +31932,11 @@ function resolveTargetableString(value, target, label) {
   }
   return resolved;
 }
+var MODE_SECTION_RE = /\{\{([#^])mode:([a-z0-9-]+)\}\}/g;
+var MODE_SECTION_CLOSE_RE = /\{\{\/mode:([a-z0-9-]+)\}\}/g;
+var TOOL_PLACEHOLDER_RE = /\{\{tool:([a-zA-Z][a-zA-Z0-9_-]*)\}\}/g;
+var COMMAND_PLACEHOLDER_RE = /\{\{command:([a-zA-Z][a-zA-Z0-9_-]*)\}\}/g;
+var TABLE_PLACEHOLDER_RE = /\{\{(table|list):([a-zA-Z][a-zA-Z0-9_-]*):([a-zA-Z0-9_,-]+)\}\}/g;
 var NextRef = StepIdRef.nullable();
 var ByModeNext = external_exports.object({
   byMode: external_exports.record(external_exports.string(), NextRef)
@@ -32188,56 +31949,50 @@ var EmitLabel = external_exports.union([
     action: external_exports.enum(["started", "completed"])
   })
 ]);
+var BranchOption = external_exports.object({
+  /** Letter shown in the choice prompt, e.g. "A", "B", "C". */
+  letter: external_exports.string().min(1),
+  /** Bolded option name, e.g. "Update all N outdated workspaces". */
+  label: external_exports.string().min(1),
+  /** Optional explanation that follows the label. */
+  description: external_exports.string().optional()
+});
+var CompileMode = external_exports.enum(["monolith", "split", "split-chain"]);
+function PerTarget(inner) {
+  return external_exports.union([inner, external_exports.record(external_exports.string(), inner)]);
+}
+var TargetableString = PerTarget(external_exports.string());
+var TargetableNonEmptyString = PerTarget(external_exports.string().min(1));
 var Base = external_exports.object({
   id: StepLocalId,
   title: TargetableNonEmptyString,
   /**
    * Concise inline name for cross-phase prose references via
-   * `{{step-ref:phase/id}}`. Falls back to `title` when omitted. Set it when
-   * the header `title` reads clumsily mid-sentence (e.g. title "Mark ready,
-   * then merge" -> refName "merge", so a ref renders "the merge step"). Unlike
+   * `{{step-ref:phase/id}}`. Falls back to `title` when omitted. Unlike
    * `{{step:...}}` (a file-local number), `{{step-ref:...}}` renders a stable
    * name, so it stays meaningful across phases and across split-unit files.
    */
   refName: TargetableNonEmptyString.optional(),
   body: TargetableString,
   /**
-   * Value emitted through the flow-level `emitTemplate` when this step
-   * is reached.
-   *
-   * - String shorthand: display name, action defaults to "started".
-   * - Object form: explicit `displayName` + `action`.
-   *
-   * How the value is rendered is determined by `flow.emitTemplate`.
+   * Value emitted through the flow-level `emitTemplate` when this step is
+   * reached. String shorthand = display name with action "started".
    * Steps with `emit` but no flow-level template are silently ignored.
    */
   emit: EmitLabel.optional(),
   /**
    * Logical ids of tools this step calls (must exist in `flow.tools`). Used
-   * to auto-derive `frontmatter.allowedTools` and to render `{{tool:id}}`
-   * placeholders in the body.
+   * to auto-derive `frontmatter.allowedTools`.
    */
   toolCalls: external_exports.array(external_exports.string()).optional(),
-  /**
-   * Logical ids of commands this step invokes (must exist in `flow.commands`).
-   * Mirrors `toolCalls` for the command registry so consumers don't need to
-   * regex-scan the body for `{{command:id}}` placeholders.
-   */
+  /** Logical ids of commands this step invokes (must exist in `flow.commands`). */
   commandCalls: external_exports.array(external_exports.string()).optional(),
   /**
-   * If true (in a "headers" phase), the step is numbered as "0" instead of
-   * 1-indexed among non-preamble visible steps. Used for setup-style preamble
-   * sections like Codex's "Resolve BITFAB_PLUGIN_DIR" that conceptually sit
-   * before step 1 even though they execute first.
+   * In a "headers" phase, number the step "0" instead of joining the
+   * 1-indexed sequence. For setup-style preambles that sit before step 1.
    */
   preamble: external_exports.boolean().optional(),
-  /**
-   * Optional list of appendix ids this step consults. Available on every step
-   * kind so that an action or branch step can document its references to
-   * appendices (validated against `flow.appendices` at parse time). The
-   * `kind: "reference"` discriminant carries a stricter `min(1)` requirement
-   * since consulting an appendix is its primary purpose.
-   */
+  /** Appendix ids this step consults (validated against `flow.appendices`). */
   refs: external_exports.array(external_exports.string().min(1)).optional(),
   meta: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
 });
@@ -32245,54 +32000,28 @@ var Action = Base.extend({
   kind: external_exports.literal("action"),
   next: Next
 });
-var BranchOption = external_exports.object({
-  /** Letter shown in the AskUserQuestion prompt, e.g. "A", "B", "C". */
-  letter: external_exports.string().min(1),
-  /** Bolded option name, e.g. "Update all N outdated workspaces". */
-  label: external_exports.string().min(1),
-  /** Optional explanation that follows the label after an em dash. */
-  description: external_exports.string().optional()
-});
 var Branch = Base.extend({
   kind: external_exports.literal("branch"),
   branches: external_exports.array(external_exports.object({
     /**
-     * Edge label in the schema diagram. Required for runtime branches
-     * (exit conditions, not user choices). Optional for user-choice
-     * branches - when omitted, the diagram label defaults to
-     * `${option.letter} - ${option.label}`.
+     * Runtime condition (agent decides). Required unless the branch
+     * is a user choice (`option`); also the diagram edge label.
      */
     when: external_exports.string().optional(),
-    /**
-     * Where this branch goes after the user picks it (or after the
-     * runtime condition resolves). Linear `NextRef` form for the common
-     * case where every mode goes to the same place; `byMode` dispatch
-     * for branches that need per-mode targets - e.g. an "exit" option
-     * that hands off to the next phase in `all` mode but terminates in
-     * sub-modes.
-     */
+    /** Where this branch goes; linear or `byMode`. */
     next: Next,
     /** Marks the option the agent should default to. */
     recommended: external_exports.boolean().optional(),
     /**
-     * Tags the prompt this option belongs to when a single step exposes
-     * multiple AskUserQuestion forks. Lets the renderer pick a subset
-     * with `{{branches:prompt-name}}`.
+     * Tags the prompt this option belongs to when one step exposes
+     * several user prompts; render a subset with `{{branches:name}}`.
      */
     prompt: external_exports.string().optional(),
-    /**
-     * Present on user-choice branches - drives the rendered prompt
-     * block via `{{branches}}` and supersedes `when` as the source of
-     * truth for option text. Absent on runtime branches.
-     */
+    /** User-choice option rendered by `{{branches}}`. */
     option: BranchOption.optional(),
     /**
-     * Optional action description for runtime (`when`) branches - the
-     * "what to do" text that appears after the em-dash in the
-     * `{{whens}}` rendering. When omitted, falls back to "stop the
-     * flow" (for `next: null`) or "continue" (for any step ref). Has
-     * no effect on user-choice (`option`) branches; those use
-     * `option.description`.
+     * Action text for runtime (`when`) branches in `{{whens}}`. Falls
+     * back to "stop the flow" (`next: null`) or "continue".
      */
     description: external_exports.string().optional()
   }).strict().refine((b) => b.when !== void 0 || b.option !== void 0, {
@@ -32332,11 +32061,8 @@ var Phase = external_exports.object({
   steps: external_exports.array(Step).min(1),
   outro: TargetableString.optional(),
   /**
-   * How steps inside this phase are rendered.
-   * - "list": phase renders as `## {title}`, intro paragraph, then steps as a `1. ... 2. ...` numbered markdown list.
-   * - "headers": phase title is hidden; each step renders as its own `## {N}. {title}` H2 section with body below.
-   *
-   * In "headers" mode, steps marked `preamble: true` are numbered "0" instead of joining the 1-indexed sequence.
+   * - "list": `## {title}`, intro, then steps as a numbered markdown list.
+   * - "headers": title hidden; each step is its own `## {N}. {title}` section.
    */
   stepStyle: external_exports.enum(["list", "headers"]).default("list")
 });
@@ -32360,143 +32086,83 @@ var Frontmatter = external_exports.object({
   ]).optional(),
   model: external_exports.string().optional(),
   /**
-   * Optional manual override. When omitted and `flow.tools` is non-empty,
-   * the renderer auto-derives the list from the union of step `toolCalls`.
+   * Manual override. When omitted and `flow.tools` is non-empty, the
+   * renderer derives the list from the tools the flow actually calls.
    */
   allowedTools: external_exports.array(external_exports.string()).optional()
 });
 var ToolDef = external_exports.object({
   name: PerTarget(external_exports.string()),
   kind: external_exports.enum(["builtin", "mcp"]),
-  targets: external_exports.array(external_exports.enum(TARGET_NAMES)).nonempty().optional()
+  targets: external_exports.array(external_exports.string()).nonempty().optional()
 });
 var CommandDef = external_exports.object({
   file: external_exports.string().min(1),
   description: external_exports.string().min(1),
   args: external_exports.string().optional()
 });
-var Language = external_exports.object({
-  /** Lowercase id used in tables (typescript, python, ruby, go). */
-  name: external_exports.string().min(1),
-  /** Capitalized name used in bullet lists (TypeScript, Python, Ruby, Go). */
-  displayName: external_exports.string().min(1),
-  /** Markdown snippet used by `{{languages:imports}}`. */
-  imports: external_exports.string().optional(),
-  /** Markdown snippet used by `{{languages:detection}}`. */
-  detection: external_exports.string().optional(),
-  /** Markdown snippet used by `{{languages:outdated}}`. */
-  outdated: external_exports.string().optional(),
-  /** Markdown snippet used by `{{languages:update}}`. */
-  update: external_exports.string().optional()
-});
-var Flow = external_exports.object({
+var Table = external_exports.object({
+  /** Header of the leading key column. */
+  keyHeader: external_exports.string().min(1).default("Name"),
+  /** Column header per field; unset fields fall back to the title-cased field name. */
+  columns: external_exports.record(external_exports.string(), external_exports.string()).default({}),
+  rows: external_exports.array(external_exports.object({
+    key: external_exports.string().min(1),
+    /** Display name for `{{list:...}}`; falls back to `key`. */
+    label: external_exports.string().optional(),
+    cells: external_exports.record(external_exports.string(), external_exports.string())
+  })).min(1)
+});
+var FlowBase = external_exports.object({
   schemaVersion: external_exports.literal(1),
-  id: external_exports.string().min(1),
+  id: external_exports.string().regex(/^[a-z0-9-]+$/),
   title: TargetableNonEmptyString,
   frontmatter: Frontmatter,
   intro: TargetableString.optional(),
   /**
-   * Entry step per invocation mode. Each entry is either a bare step id
-   * (every target enters at the same step) or a per-target object so a
-   * target can start at a different step than the others - for example,
-   * Codex enters at the `resolve-plugin-dir` preamble while Claude and
-   * Cursor enter directly at `run-update-script`.
+   * Entry step per invocation mode: a bare step id, or a per-target map so a
+   * target can start elsewhere (e.g. at a host-specific preamble).
    */
   entries: external_exports.record(external_exports.string(), PerTarget(StepIdRef)),
-  /** Which mode is invoked when the user passes no argument. Must be a key in `entries`. */
+  /** Mode invoked when the user passes no argument. Must be a key in `entries`. */
   defaultMode: external_exports.string().optional(),
   /**
-   * Optional one-line description per mode, keyed by mode name (a subset of
-   * `entries` keys). When a monolith flow has more than one mode, the renderer
-   * emits an auto-generated "Modes" dispatch table at the top of the file so
-   * the agent can map `$ARGUMENTS` to the right mode without hand-authored
-   * routing prose. A mode without a hint falls back to its entry phase's
-   * title. Values are `TargetableString`, so a hint can differ per target
-   * (e.g. editor-specific wording) and standard placeholders resolve normally.
+   * One-line description per mode. Declaring any opts a multi-mode flow
+   * into an auto-generated "Modes" routing table.
    */
   modeHints: external_exports.record(external_exports.string(), TargetableString).default({}),
   /**
-   * Template for rendering step `emit` values into the markdown.
-   * The renderer substitutes `{action}` and `{displayName}` from the
-   * step's `emit` field. All other placeholders (`{{pluginRoot}}`,
-   * Mustache sections, etc.) are resolved by the normal pipeline.
-   *
-   * If absent, steps with `emit` are silently ignored (no output
-   * rendered). This keeps flows that don't need emission from having
-   * to declare a no-op template.
+   * Template rendered for each step `emit`. `{action}` and `{displayName}`
+   * are substituted; every other placeholder resolves normally.
    */
   emitTemplate: TargetableString.optional(),
   phases: external_exports.array(Phase).min(1),
   appendices: external_exports.array(Appendix).default([]),
   invariants: external_exports.array(external_exports.string()).default([]),
-  languages: external_exports.array(Language).default([]),
-  /**
-   * Headers for the columns rendered by `{{languages:FIELD}}` placeholders.
-   * Keyed by Language field name (`imports`, `detection`, `outdated`,
-   * `update`). When unset for a column, the renderer falls back to the
-   * field's title-cased name.
-   */
-  languageColumnHeaders: external_exports.record(external_exports.string(), external_exports.string()).default({}),
-  /**
-   * Tool registry keyed by logical id. `step.toolCalls` references entries
-   * here; `{{tool:id}}` placeholders render the per-target name.
-   */
+  tables: external_exports.record(external_exports.string(), Table).default({}),
   tools: external_exports.record(external_exports.string(), ToolDef).default({}),
-  /**
-   * CLI command registry keyed by logical id. `{{command:id}}` placeholders
-   * in step/intro/appendix text render as the full invocation path. When
-   * non-empty, the renderer emits a reference table after the flow intro.
-   */
   commands: external_exports.record(external_exports.string(), CommandDef).default({}),
   /**
-   * User-defined variables. Each value is either a bare string (applies to
-   * all targets) or a per-target map. Referenced via `{{name}}` placeholders
-   * in any string field. Must not collide with target-level tokens (cmd,
-   * editor, pluginRoot, askUser).
+   * User-defined `{{name}}` variables (bare or per-target). Must not collide
+   * with target token names.
    */
   variables: external_exports.record(external_exports.string(), TargetableString).default({}),
   /**
-   * How this flow compiles to skill files.
-   * - `monolith` (default): one skill file per (flow, target) - today's
-   *   behavior, rendered by `renderMarkdown`.
-   * - `split`: an orchestrator skill plus one menu-hidden, model-invocable
-   *   sub-skill per phase. The orchestrator dispatches call-and-return:
-   *   one section per sub-phase, "invoke X, then return here".
-   *   `inlinePhases` lists phases kept inside the orchestrator (infra
-   *   phases like preamble/cleanup) rather than emitted as their own
-   *   sub-skills.
-   * - `split-chain`: same file layout as `split`, but routing compiles to
-   *   tail-call dispatch. The orchestrator never says "return here";
-   *   instead every step whose outgoing edge crosses a unit boundary
-   *   (orchestrator-with-inline-phases, or a sub-skill) gets a generated
-   *   "Next:" annotation with one line per (target phase, mode set) group,
-   *   mode literals baked in. Cross-phase loops are legal under
-   *   `split-chain` (a dispatch edge back to an earlier sub-skill renders
-   *   like any other), which the sequential `split` orchestrator cannot
-   *   express.
-   *   Codex writes non-inline phases to ordinary `references/<phase>.md`
-   *   files and routes by reading them, keeping phase names out of skill
-   *   discovery. Other targets emit phase sub-skills.
+   * How the flow compiles to files.
+   * - `monolith`: one skill file per target.
+   * - `split`: an orchestrator plus one sub-skill per non-inline phase,
+   *   dispatched call-and-return ("invoke X, then return here").
+   * - `split-chain`: same layout, tail-call routing. Every step whose edge
+   *   crosses a file boundary gets a generated "**Next:**" block with mode
+   *   literals baked in. Targets with `phaseReferences` emit phases as
+   *   reference files instead of discoverable sub-skills.
    *
-   * `mode` is per-target (the standard default-plus-override form), so split
-   * can roll out one target at a time: `{ default: "monolith", claude:
-   * "split" }` splits Claude and leaves Cursor/Codex monolith. A bare
-   * `"split"` / `"monolith"` applies to every target.
-   *
-   * `continuousStepNumbers` (monolith only) numbers step headers 1…N
-   * continuously across phases instead of restarting at 1 per phase. Set it
-   * when the phases run **sequentially** in one file (e.g. preflight then a
-   * run phase): restarting would emit duplicate `## 1.` headers with nothing
-   * to disambiguate them. Leave it off (the default) when phases are
-   * **mutually exclusive** alternatives each gated by "Run only when mode is
-   * X" (e.g. subcommands): there the per-phase restart is correct, since only
-   * one phase is ever followed and its own steps read naturally from 1, and
-   * the mode gate, not the number, is what disambiguates. Split modes ignore
-   * this flag entirely: each phase compiles to its own file and always
-   * restarts at 1.
+   * `mode` is per-target, so split can roll out one host at a time.
+   * `continuousStepNumbers` (monolith only) numbers headers 1…N across
+   * sequential phases instead of restarting per phase.
    */
   compile: external_exports.object({
-    mode: PerTarget(external_exports.enum(["monolith", "split", "split-chain"])).default("monolith"),
+    mode: PerTarget(CompileMode).default("monolith"),
     inlinePhases: external_exports.array(external_exports.string()).default([]),
     continuousStepNumbers: external_exports.boolean().default(false)
   }).default({
@@ -32504,465 +32170,320 @@ var Flow = external_exports.object({
     inlinePhases: [],
     continuousStepNumbers: false
   })
-}).superRefine((flow, ctx) => {
-  const allStepIds = /* @__PURE__ */ new Set();
-  const phaseIds = /* @__PURE__ */ new Set();
-  for (const phase of flow.phases) {
-    if (phaseIds.has(phase.id)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["phases", phase.id],
-        message: `duplicate phase id "${phase.id}"`
-      });
-    }
-    phaseIds.add(phase.id);
-    const localIds = /* @__PURE__ */ new Set();
-    for (const step of phase.steps) {
-      if (localIds.has(step.id)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["phases", phase.id, "steps"],
-          message: `duplicate step id "${step.id}" in phase "${phase.id}"`
-        });
+});
+function createFlowSchema(options) {
+  const targetNames = [...options.targetNames];
+  const reservedTokenNames = /* @__PURE__ */ new Set([
+    ...options.reservedTokenNames ?? [],
+    "argsToken"
+  ]);
+  const allowedKeys = /* @__PURE__ */ new Set(["default", ...targetNames]);
+  return FlowBase.superRefine((flow, ctx) => {
+    const issue2 = (path15, message) => ctx.addIssue({ code: "custom", path: path15, message });
+    for (const { path: path15, value } of targetableFields(flow)) {
+      if (typeof value !== "object" || value === null) {
+        continue;
+      }
+      const map2 = value;
+      for (const key of Object.keys(map2)) {
+        if (!allowedKeys.has(key)) {
+          issue2(path15, `Unknown target "${key}" in per-target object. Known targets: ${targetNames.join(", ")}.`);
+        }
+      }
+      if (map2.default === void 0 && !targetNames.every((target) => map2[target] !== void 0)) {
+        issue2(path15, `Per-target object must have \`default\` or define all of ${targetNames.join("/")}.`);
       }
-      localIds.add(step.id);
-      allStepIds.add(`${phase.id}/${step.id}`);
-    }
-  }
-  for (const phaseId of flow.compile.inlinePhases) {
-    if (!phaseIds.has(phaseId)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["compile", "inlinePhases"],
-        message: `inlinePhases lists unknown phase "${phaseId}"`
-      });
     }
-  }
-  const declaredModes = Object.keys(flow.entries);
-  const declaredModeSet = new Set(declaredModes);
-  const argumentHint = flow.frontmatter.argumentHint;
-  const argumentHintModes = declaredModes.filter((mode) => mode !== "default" || flow.defaultMode !== "default");
-  if (typeof argumentHint === "object" && "deriveFromModes" in argumentHint && argumentHintModes.length === 0) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["frontmatter", "argumentHint"],
-      message: "deriveFromModes requires at least one non-default mode in entries"
-    });
-  }
-  if (flow.defaultMode !== void 0 && !declaredModeSet.has(flow.defaultMode)) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["defaultMode"],
-      message: `defaultMode "${flow.defaultMode}" not declared in entries`
-    });
-  }
-  for (const mode of Object.keys(flow.modeHints)) {
-    if (!declaredModeSet.has(mode)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["modeHints", mode],
-        message: `modeHints key "${mode}" not declared in entries`
-      });
+    const allStepIds = /* @__PURE__ */ new Set();
+    const phaseIds = /* @__PURE__ */ new Set();
+    for (const phase of flow.phases) {
+      if (phaseIds.has(phase.id)) {
+        issue2(["phases", phase.id], `duplicate phase id "${phase.id}"`);
+      }
+      phaseIds.add(phase.id);
+      const localIds = /* @__PURE__ */ new Set();
+      for (const step of phase.steps) {
+        if (localIds.has(step.id)) {
+          issue2(["phases", phase.id, "steps"], `duplicate step id "${step.id}" in phase "${phase.id}"`);
+        }
+        localIds.add(step.id);
+        allStepIds.add(`${phase.id}/${step.id}`);
+      }
     }
-  }
-  const refsFromNext = (next) => {
-    if (next === null) {
-      return [];
+    for (const phaseId of flow.compile.inlinePhases) {
+      if (!phaseIds.has(phaseId)) {
+        issue2(["compile", "inlinePhases"], `inlinePhases lists unknown phase "${phaseId}"`);
+      }
     }
-    if (typeof next === "string") {
-      return [next];
+    const declaredModes = Object.keys(flow.entries);
+    const declaredModeSet = new Set(declaredModes);
+    const argumentHint = flow.frontmatter.argumentHint;
+    const argumentHintModes = declaredModes.filter((mode) => mode !== "default" || flow.defaultMode !== "default");
+    if (typeof argumentHint === "object" && "deriveFromModes" in argumentHint && argumentHintModes.length === 0) {
+      issue2(["frontmatter", "argumentHint"], "deriveFromModes requires at least one non-default mode in entries");
     }
-    return Object.values(next.byMode).filter((v) => typeof v === "string");
-  };
-  const refsFromStep = (s2) => {
-    switch (s2.kind) {
-      case "action":
-      case "reference":
-      case "parallel":
-        return refsFromNext(s2.next);
-      case "branch":
-        return s2.branches.flatMap((b) => refsFromNext(b.next));
-      case "loop":
-        return [s2.backTo, s2.onExit];
+    if (flow.defaultMode !== void 0 && !declaredModeSet.has(flow.defaultMode)) {
+      issue2(["defaultMode"], `defaultMode "${flow.defaultMode}" not declared in entries`);
     }
-  };
-  for (const phase of flow.phases) {
-    for (const step of phase.steps) {
-      for (const ref of refsFromStep(step)) {
-        if (!allStepIds.has(ref)) {
-          ctx.addIssue({
-            code: "custom",
-            path: ["phases", phase.id, "steps", step.id],
-            message: `edge \u2192 unknown step "${ref}"`
-          });
-        }
+    for (const mode of Object.keys(flow.modeHints)) {
+      if (!declaredModeSet.has(mode)) {
+        issue2(["modeHints", mode], `modeHints key "${mode}" not declared in entries`);
       }
-      const validateByMode = (byMode, path15, label) => {
-        for (const mode of Object.keys(byMode)) {
-          if (!declaredModeSet.has(mode)) {
-            ctx.addIssue({
-              code: "custom",
-              path: path15,
-              message: `${label} lists mode "${mode}" not declared in flow.entries`
-            });
+    }
+    for (const phase of flow.phases) {
+      for (const step of phase.steps) {
+        for (const ref of refsFromStep(step)) {
+          if (!allStepIds.has(ref)) {
+            issue2(["phases", phase.id, "steps", step.id], `edge \u2192 unknown step "${ref}"`);
           }
         }
-        const missingModes = declaredModes.filter((m) => !(m in byMode));
-        if (missingModes.length > 0) {
-          ctx.addIssue({
-            code: "custom",
-            path: path15,
-            message: `${label} byMode is missing entries for mode(s): ${missingModes.join(", ")}`
-          });
+        const validateByMode = (byMode, path15, label) => {
+          for (const mode of Object.keys(byMode)) {
+            if (!declaredModeSet.has(mode)) {
+              issue2(path15, `${label} lists mode "${mode}" not declared in flow.entries`);
+            }
+          }
+          const missingModes = declaredModes.filter((m) => !(m in byMode));
+          if (missingModes.length > 0) {
+            issue2(path15, `${label} byMode is missing entries for mode(s): ${missingModes.join(", ")}`);
+          }
+        };
+        if ((step.kind === "action" || step.kind === "reference" || step.kind === "parallel") && typeof step.next === "object" && step.next !== null) {
+          validateByMode(step.next.byMode, ["phases", phase.id, "steps", step.id, "next", "byMode"], `step "${step.id}" next`);
+        }
+        if (step.kind === "branch") {
+          for (const [i, branch] of step.branches.entries()) {
+            if (typeof branch.next === "object" && branch.next !== null) {
+              const branchLabelText = branch.option !== void 0 ? `option "${branch.option.letter}"` : branch.when ?? `branch[${i}]`;
+              validateByMode(branch.next.byMode, [
+                "phases",
+                phase.id,
+                "steps",
+                step.id,
+                "branches",
+                i,
+                "next",
+                "byMode"
+              ], `step "${step.id}" branch ${branchLabelText}`);
+            }
+          }
         }
-      };
-      if ((step.kind === "action" || step.kind === "reference" || step.kind === "parallel") && typeof step.next === "object" && step.next !== null) {
-        validateByMode(step.next.byMode, ["phases", phase.id, "steps", step.id, "next", "byMode"], `step "${step.id}" next`);
       }
-      if (step.kind === "branch") {
-        for (const [i, branch] of step.branches.entries()) {
-          if (typeof branch.next === "object" && branch.next !== null) {
-            const branchLabelText = branch.option !== void 0 ? `option "${branch.option.letter}"` : branch.when ?? `branch[${i}]`;
-            validateByMode(branch.next.byMode, [
-              "phases",
-              phase.id,
-              "steps",
-              step.id,
-              "branches",
-              i,
-              "next",
-              "byMode"
-            ], `step "${step.id}" branch ${branchLabelText}`);
+    }
+    for (const phase of flow.phases) {
+      const preambleCount = phase.steps.filter((s2) => s2.preamble === true).length;
+      if (preambleCount > 1) {
+        issue2(["phases", phase.id, "steps"], `phase "${phase.id}" has ${preambleCount} preamble steps; only one is allowed per phase`);
+      }
+    }
+    const appendixIds = new Set(flow.appendices.map((a) => a.id));
+    for (const phase of flow.phases) {
+      for (const step of phase.steps) {
+        for (const r of step.refs ?? []) {
+          if (!appendixIds.has(r)) {
+            issue2(["phases", phase.id, "steps", step.id, "refs"], `unknown appendix "${r}"`);
           }
         }
       }
     }
-  }
-  for (const phase of flow.phases) {
-    const preambleCount = phase.steps.filter((s2) => s2.preamble === true).length;
-    if (preambleCount > 1) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["phases", phase.id, "steps"],
-        message: `phase "${phase.id}" has ${preambleCount} preamble steps; only one is allowed per phase`
-      });
-    }
-  }
-  const appendixIds = new Set(flow.appendices.map((a) => a.id));
-  for (const phase of flow.phases) {
-    for (const step of phase.steps) {
-      const refs = step.refs ?? [];
-      for (const r of refs) {
-        if (!appendixIds.has(r)) {
-          ctx.addIssue({
-            code: "custom",
-            path: ["phases", phase.id, "steps", step.id, "refs"],
-            message: `unknown appendix "${r}"`
-          });
+    for (const [mode, entry] of Object.entries(flow.entries)) {
+      for (const target of targetNames) {
+        const resolved = resolvePerTarget(entry, target);
+        if (resolved === void 0) {
+          issue2(["entries", mode], `entry for mode "${mode}" has no value for target "${target}" (and no default)`);
+          continue;
+        }
+        if (!allStepIds.has(resolved)) {
+          issue2(["entries", mode], `entry "${mode}" \u2192 "${target}" \u2192 unknown step "${resolved}"`);
         }
       }
     }
-  }
-  const targetNames = ["claude", "cursor", "codex"];
-  for (const [mode, entry] of Object.entries(flow.entries)) {
+    const reachableUnion = /* @__PURE__ */ new Set();
     for (const target of targetNames) {
-      const resolved = resolvePerTarget(entry, target);
-      if (resolved === void 0) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["entries", mode],
-          message: `entry for mode "${mode}" has no value for target "${target}" (and no default)`
-        });
-        continue;
+      for (const id of computeReachableSteps(flow, target)) {
+        reachableUnion.add(id);
       }
-      if (!allStepIds.has(resolved)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["entries", mode],
-          message: `entry "${mode}" \u2192 "${target}" \u2192 unknown step "${resolved}"`
-        });
+    }
+    for (const id of allStepIds) {
+      if (!reachableUnion.has(id)) {
+        issue2(["phases"], `unreachable step "${id}" in any (mode, target) combination`);
       }
     }
-  }
-  const reachableUnion = /* @__PURE__ */ new Set();
-  for (const [mode, entry] of Object.entries(flow.entries)) {
+    const inlinePhaseSet = new Set(flow.compile.inlinePhases);
+    const phaseOf = (ref) => ref.split("/")[0];
     for (const target of targetNames) {
-      const start = resolvePerTarget(entry, target);
-      if (start === void 0) {
+      if (resolvePerTarget(flow.compile.mode, target) !== "split-chain") {
         continue;
       }
-      const queue = [start];
-      const seen = /* @__PURE__ */ new Set();
-      while (queue.length > 0) {
-        const id = queue.shift();
-        if (id === void 0 || seen.has(id)) {
+      for (const [mode, entry] of Object.entries(flow.entries)) {
+        const resolved = resolvePerTarget(entry, target);
+        if (resolved === void 0 || !allStepIds.has(resolved)) {
           continue;
         }
-        seen.add(id);
-        reachableUnion.add(id);
-        const [phaseId, stepId] = id.split("/");
-        const step = flow.phases.find((p9) => p9.id === phaseId)?.steps.find((s2) => s2.id === stepId);
-        if (step === void 0) {
+        const entryPhase = phaseOf(resolved);
+        if (inlinePhaseSet.has(entryPhase)) {
           continue;
         }
-        for (const n of nextRefsForMode(step, mode)) {
-          if (n !== null) {
-            queue.push(n);
-          }
+        const firstStep = flow.phases.find((p9) => p9.id === entryPhase)?.steps[0];
+        if (firstStep !== void 0 && resolved !== `${entryPhase}/${firstStep.id}`) {
+          issue2(["entries", mode], `split-chain: entry "${mode}" \u2192 "${target}" points mid-phase at "${resolved}"; a sub-skill starts at its first step ("${entryPhase}/${firstStep.id}"). Reorder the phase or inline it.`);
         }
       }
-    }
-  }
-  for (const id of allStepIds) {
-    if (reachableUnion.has(id)) {
-      continue;
-    }
-    ctx.addIssue({
-      code: "custom",
-      path: ["phases"],
-      message: `unreachable step "${id}" in any (mode, target) combination`
-    });
-  }
-  const inlinePhaseSet = new Set(flow.compile.inlinePhases);
-  const phaseOf = (ref) => ref.split("/")[0];
-  for (const target of targetNames) {
-    if (resolvePerTarget(flow.compile.mode, target) !== "split-chain") {
-      continue;
-    }
-    for (const [mode, entry] of Object.entries(flow.entries)) {
-      const resolved = resolvePerTarget(entry, target);
-      if (resolved === void 0 || !allStepIds.has(resolved)) {
-        continue;
-      }
-      const entryPhase = phaseOf(resolved);
-      if (inlinePhaseSet.has(entryPhase)) {
-        continue;
-      }
-      const phase = flow.phases.find((p9) => p9.id === entryPhase);
-      const firstStep = phase?.steps[0];
-      if (firstStep !== void 0 && resolved !== `${entryPhase}/${firstStep.id}`) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["entries", mode],
-          message: `split-chain: entry "${mode}" \u2192 "${target}" points mid-phase at "${resolved}"; a sub-skill starts at its first step ("${entryPhase}/${firstStep.id}"). Reorder the phase or inline it.`
-        });
-      }
-    }
-    const reachable = computeReachableSteps(flow, target);
-    for (const phase of flow.phases) {
-      if (inlinePhaseSet.has(phase.id)) {
-        continue;
-      }
-      for (const step of phase.steps) {
-        if (!reachable.has(`${phase.id}/${step.id}`)) {
+      const reachable = computeReachableSteps(flow, target);
+      for (const phase of flow.phases) {
+        if (inlinePhaseSet.has(phase.id)) {
           continue;
         }
-        for (const ref of refsFromStep(step)) {
-          if (inlinePhaseSet.has(phaseOf(ref))) {
-            ctx.addIssue({
-              code: "custom",
-              path: ["phases", phase.id, "steps", step.id],
-              message: `split-chain: step "${phase.id}/${step.id}" routes to "${ref}" in inline phase "${phaseOf(ref)}" (target "${target}"). Sub-skills may not re-enter the orchestrator; make the shared work its own phase.`
-            });
+        for (const step of phase.steps) {
+          if (!reachable.has(`${phase.id}/${step.id}`)) {
+            continue;
+          }
+          for (const ref of refsFromStep(step)) {
+            if (inlinePhaseSet.has(phaseOf(ref))) {
+              issue2(["phases", phase.id, "steps", step.id], `split-chain: step "${phase.id}/${step.id}" routes to "${ref}" in inline phase "${phaseOf(ref)}" (target "${target}"). Sub-skills may not re-enter the orchestrator; make the shared work its own phase.`);
+            }
           }
         }
       }
     }
-  }
-  const toolIds = new Set(Object.keys(flow.tools));
-  for (const phase of flow.phases) {
-    for (const step of phase.steps) {
-      if (step.toolCalls === void 0) {
-        continue;
-      }
-      for (const toolId of step.toolCalls) {
-        if (!toolIds.has(toolId)) {
-          ctx.addIssue({
-            code: "custom",
-            path: ["phases", phase.id, "steps", step.id, "toolCalls"],
-            message: `step "${step.id}" calls tool "${toolId}" not declared in flow.tools`
-          });
-        }
-      }
-    }
-  }
-  const commandIds = new Set(Object.keys(flow.commands));
-  for (const phase of flow.phases) {
-    for (const step of phase.steps) {
-      if (step.commandCalls === void 0) {
-        continue;
-      }
-      for (const cmdId of step.commandCalls) {
-        if (!commandIds.has(cmdId)) {
-          ctx.addIssue({
-            code: "custom",
-            path: ["phases", phase.id, "steps", step.id, "commandCalls"],
-            message: `step "${step.id}" calls command "${cmdId}" not declared in flow.commands`
-          });
+    const toolIds = new Set(Object.keys(flow.tools));
+    const commandIds = new Set(Object.keys(flow.commands));
+    const knownTargets = new Set(targetNames);
+    for (const [toolId, tool] of Object.entries(flow.tools)) {
+      for (const t of tool.targets ?? []) {
+        if (!knownTargets.has(t)) {
+          issue2(["tools", toolId, "targets"], `tool "${toolId}" lists unknown target "${t}"`);
         }
       }
     }
-  }
-  const COMMAND_PLACEHOLDER_RE = /\{\{command:([a-zA-Z][a-zA-Z0-9_-]*)\}\}/g;
-  const scanForCommandRefs = (value) => {
-    const refs = [];
-    const scan = (text2) => {
-      if (!text2) {
-        return;
-      }
-      for (const match of text2.matchAll(COMMAND_PLACEHOLDER_RE)) {
-        refs.push(match[1]);
-      }
-    };
-    if (value === void 0) {
-      return refs;
-    }
-    if (typeof value === "string") {
-      scan(value);
-      return refs;
-    }
-    scan(value.default);
-    scan(value.claude);
-    scan(value.cursor);
-    scan(value.codex);
-    return refs;
-  };
-  if (commandIds.size > 0) {
-    const allCommandRefs = [];
-    for (const ref of scanForCommandRefs(flow.intro)) {
-      allCommandRefs.push({ ref, location: "flow.intro" });
-    }
-    for (const ref of scanForCommandRefs(flow.emitTemplate)) {
-      allCommandRefs.push({ ref, location: "flow.emitTemplate" });
-    }
     for (const phase of flow.phases) {
-      for (const ref of scanForCommandRefs(phase.intro)) {
-        allCommandRefs.push({ ref, location: `phase "${phase.id}" intro` });
-      }
       for (const step of phase.steps) {
-        for (const ref of scanForCommandRefs(step.body)) {
-          allCommandRefs.push({
-            ref,
-            location: `step "${phase.id}/${step.id}"`
-          });
+        for (const toolId of step.toolCalls ?? []) {
+          if (!toolIds.has(toolId)) {
+            issue2(["phases", phase.id, "steps", step.id, "toolCalls"], `step "${step.id}" calls tool "${toolId}" not declared in flow.tools`);
+          }
+        }
+        for (const cmdId of step.commandCalls ?? []) {
+          if (!commandIds.has(cmdId)) {
+            issue2(["phases", phase.id, "steps", step.id, "commandCalls"], `step "${step.id}" calls command "${cmdId}" not declared in flow.commands`);
+          }
         }
       }
     }
-    for (const appendix of flow.appendices) {
-      for (const ref of scanForCommandRefs(appendix.body)) {
-        allCommandRefs.push({
-          ref,
-          location: `appendix "${appendix.id}"`
-        });
+    for (const { location, text: text2 } of flowTexts(flow)) {
+      for (const match of text2.matchAll(COMMAND_PLACEHOLDER_RE)) {
+        if (!commandIds.has(match[1])) {
+          issue2(["commands"], `{{command:${match[1]}}} in ${location} not declared in flow.commands`);
+        }
       }
-    }
-    for (const { ref, location } of allCommandRefs) {
-      if (!commandIds.has(ref)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["commands"],
-          message: `{{command:${ref}}} in ${location} not declared in flow.commands`
-        });
+      for (const match of text2.matchAll(TOOL_PLACEHOLDER_RE)) {
+        if (!toolIds.has(match[1])) {
+          issue2(["tools"], `{{tool:${match[1]}}} in ${location} not declared in flow.tools`);
+        }
       }
-    }
-  }
-  const modeNames = new Set(Object.keys(flow.entries));
-  const scanForModeSections = (value, location) => {
-    const scan = (text2) => {
-      if (!text2) {
-        return;
+      for (const match of text2.matchAll(TABLE_PLACEHOLDER_RE)) {
+        if (flow.tables[match[2]] === void 0) {
+          issue2(["tables"], `{{${match[1]}:${match[2]}:\u2026}} in ${location} names an undeclared table`);
+        }
       }
       for (const match of text2.matchAll(MODE_SECTION_RE)) {
-        const mode = match[2];
-        if (!modeNames.has(mode)) {
-          ctx.addIssue({
-            code: "custom",
-            path: ["phases"],
-            message: `{{${match[1]}mode:${mode}}} in ${location} names a mode that does not exist. Declared modes: ${[...modeNames].sort().join(", ")}.`
-          });
+        if (!declaredModeSet.has(match[2])) {
+          issue2(["phases"], `{{${match[1]}mode:${match[2]}}} in ${location} names a mode that does not exist. Declared modes: ${[...declaredModeSet].sort().join(", ")}.`);
         }
       }
       for (const match of text2.matchAll(MODE_SECTION_CLOSE_RE)) {
-        const mode = match[1];
-        if (!modeNames.has(mode)) {
-          ctx.addIssue({
-            code: "custom",
-            path: ["phases"],
-            message: `{{/mode:${mode}}} in ${location} closes a mode that does not exist. Declared modes: ${[...modeNames].sort().join(", ")}.`
-          });
+        if (!declaredModeSet.has(match[1])) {
+          issue2(["phases"], `{{/mode:${match[1]}}} in ${location} closes a mode that does not exist. Declared modes: ${[...declaredModeSet].sort().join(", ")}.`);
         }
       }
-    };
-    if (value === void 0) {
-      return;
     }
-    if (typeof value === "string") {
-      scan(value);
-      return;
-    }
-    scan(value.default);
-    scan(value.claude);
-    scan(value.cursor);
-    scan(value.codex);
-  };
-  scanForModeSections(flow.intro, "flow.intro");
-  for (const phase of flow.phases) {
-    scanForModeSections(phase.intro, `phase "${phase.id}" intro`);
-    for (const step of phase.steps) {
-      scanForModeSections(step.body, `step "${phase.id}/${step.id}"`);
+    for (const name of Object.keys(flow.variables)) {
+      if (reservedTokenNames.has(name)) {
+        issue2(["variables", name], `variable "${name}" collides with the target token of the same name`);
+      }
     }
+  });
+}
+function refsFromNext(next) {
+  if (next === null) {
+    return [];
   }
-  for (const appendix of flow.appendices) {
-    scanForModeSections(appendix.body, `appendix "${appendix.id}"`);
-  }
-  const reservedNames = new Set(RESERVED_TOKEN_NAMES);
-  for (const name of Object.keys(flow.variables)) {
-    if (reservedNames.has(name)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["variables", name],
-        message: `variable "${name}" collides with the target token of the same name`
-      });
-    }
+  if (typeof next === "string") {
+    return [next];
   }
-});
-var TOOL_PLACEHOLDER_RE = /\{\{tool:([a-zA-Z][a-zA-Z0-9_-]*)\}\}/g;
-function harvestToolRefs(value, out) {
+  return Object.values(next.byMode).filter((v) => typeof v === "string");
+}
+function refsFromStep(s2) {
+  switch (s2.kind) {
+    case "action":
+    case "reference":
+    case "parallel":
+      return refsFromNext(s2.next);
+    case "branch":
+      return s2.branches.flatMap((b) => refsFromNext(b.next));
+    case "loop":
+      return [s2.backTo, s2.onExit];
+  }
+}
+function variants(value) {
   if (value === void 0) {
-    return;
+    return [];
   }
-  const scan = (text2) => {
-    if (!text2) {
-      return;
-    }
-    for (const match of text2.matchAll(TOOL_PLACEHOLDER_RE)) {
-      out.add(match[1]);
+  if (typeof value === "string") {
+    return [value];
+  }
+  return Object.values(value).filter((v) => v !== void 0);
+}
+function flowTexts(flow) {
+  const out = [];
+  const push = (location, value, phaseId) => {
+    for (const text2 of variants(value)) {
+      out.push({ location, text: text2, phaseId });
     }
   };
-  if (typeof value === "string") {
-    scan(value);
-    return;
+  push("flow.intro", flow.intro);
+  push("flow.emitTemplate", flow.emitTemplate);
+  for (const inv of flow.invariants) {
+    push("flow.invariants", inv);
+  }
+  for (const [name, value] of Object.entries(flow.variables)) {
+    push(`variable "${name}"`, value);
+  }
+  for (const phase of flow.phases) {
+    push(`phase "${phase.id}" intro`, phase.intro, phase.id);
+    push(`phase "${phase.id}" outro`, phase.outro, phase.id);
+    for (const step of phase.steps) {
+      const where = `step "${phase.id}/${step.id}"`;
+      push(where, step.body, phase.id);
+      if (step.kind === "branch") {
+        for (const branch of step.branches) {
+          push(where, branch.description, phase.id);
+        }
+      }
+      if (step.kind === "parallel") {
+        for (const branch of step.branches) {
+          push(where, branch.body, phase.id);
+        }
+      }
+    }
+  }
+  for (const appendix of flow.appendices) {
+    push(`appendix "${appendix.id}"`, appendix.body);
   }
-  scan(value.default);
-  scan(value.claude);
-  scan(value.cursor);
-  scan(value.codex);
+  return out;
 }
 function collectCalledToolIds(flow) {
   const called = /* @__PURE__ */ new Set();
-  harvestToolRefs(flow.intro, called);
   for (const phase of flow.phases) {
-    harvestToolRefs(phase.intro, called);
     for (const step of phase.steps) {
       for (const id of step.toolCalls ?? []) {
         called.add(id);
       }
-      harvestToolRefs(step.body, called);
-      if (step.kind === "branch") {
-        for (const branch of step.branches) {
-          harvestToolRefs(branch.description, called);
-        }
-      }
+    }
+  }
+  for (const { text: text2 } of flowTexts(flow)) {
+    for (const match of text2.matchAll(TOOL_PLACEHOLDER_RE)) {
+      called.add(match[1]);
     }
   }
   return Object.keys(flow.tools).filter((id) => called.has(id));
@@ -33036,10 +32557,82 @@ function branchLabel(branch) {
   }
   return "(unlabeled branch)";
 }
+function targetableFields(flow) {
+  const out = [];
+  const push = (path15, value) => {
+    if (value !== void 0) {
+      out.push({ path: path15, value });
+    }
+  };
+  push(["title"], flow.title);
+  push(["intro"], flow.intro);
+  push(["emitTemplate"], flow.emitTemplate);
+  push(["frontmatter", "description"], flow.frontmatter.description);
+  const hint = flow.frontmatter.argumentHint;
+  if (typeof hint === "object" && hint !== null && "deriveFromModes" in hint) {
+    push(["frontmatter", "argumentHint", "suffix"], hint.suffix);
+  } else {
+    push(["frontmatter", "argumentHint"], hint);
+  }
+  push(["compile", "mode"], flow.compile.mode);
+  for (const [mode, entry] of Object.entries(flow.entries)) {
+    push(["entries", mode], entry);
+  }
+  for (const [mode, value] of Object.entries(flow.modeHints)) {
+    push(["modeHints", mode], value);
+  }
+  for (const [name, value] of Object.entries(flow.variables)) {
+    push(["variables", name], value);
+  }
+  for (const [id, tool] of Object.entries(flow.tools)) {
+    push(["tools", id, "name"], tool.name);
+  }
+  for (const phase of flow.phases) {
+    push(["phases", phase.id, "title"], phase.title);
+    push(["phases", phase.id, "intro"], phase.intro);
+    push(["phases", phase.id, "outro"], phase.outro);
+    for (const step of phase.steps) {
+      const base = ["phases", phase.id, "steps", step.id];
+      push([...base, "title"], step.title);
+      push([...base, "refName"], step.refName);
+      push([...base, "body"], step.body);
+    }
+  }
+  for (const appendix of flow.appendices) {
+    push(["appendices", appendix.id, "title"], appendix.title);
+    push(["appendices", appendix.id, "body"], appendix.body);
+  }
+  return out;
+}
 
-// ../bitfab-flow/dist/mermaid.js
-var DIAGRAM_TARGET = "claude";
-function renderMermaid(flow, mode) {
+// ../node_modules/.pnpm/@agent-flows+core@0.1.1_zod@4.6.7/node_modules/@agent-flows/core/dist/mermaid.js
+function diagramValue(value, target) {
+  const resolved = resolvePerTarget(value, target ?? "default");
+  if (resolved !== void 0 || typeof value !== "object" || value === null) {
+    return resolved;
+  }
+  return Object.values(value).find((v) => v !== void 0);
+}
+function diagramString(value, target) {
+  return diagramValue(value, target) ?? "";
+}
+function reachabilityTarget(flow, target) {
+  if (target !== void 0) {
+    return target;
+  }
+  for (const entry of Object.values(flow.entries)) {
+    if (typeof entry === "object" && entry !== null && entry.default === void 0) {
+      const first = Object.keys(entry)[0];
+      if (first !== void 0) {
+        return first;
+      }
+    }
+  }
+  return "default";
+}
+function renderMermaid(flow, options = {}) {
+  const { mode, target } = typeof options === "string" ? { mode: options, target: void 0 } : options;
+  const graphTarget = reachabilityTarget(flow, target);
   const lines = ["flowchart TD"];
   const stepById = /* @__PURE__ */ new Map();
   for (const phase of flow.phases) {
@@ -33050,19 +32643,19 @@ function renderMermaid(flow, mode) {
   const nodeId = (key) => key.replace(/[^a-zA-Z0-9]/g, "_");
   const allModes = Object.keys(flow.entries);
   const activeModes = mode !== void 0 ? [mode] : allModes;
-  const reachable = mode !== void 0 ? new Set([...computeModesPerStep(flow, DIAGRAM_TARGET).entries()].filter(([, modes]) => modes.has(mode)).map(([key]) => key)) : computeReachableSteps(flow, DIAGRAM_TARGET);
+  const reachable = mode !== void 0 ? new Set([...computeModesPerStep(flow, graphTarget).entries()].filter(([, modes]) => modes.has(mode)).map(([key]) => key)) : computeReachableSteps(flow, graphTarget);
   for (const phase of flow.phases) {
     const phaseSteps = phase.steps.filter((s2) => reachable.has(`${phase.id}/${s2.id}`));
     if (phaseSteps.length === 0) {
       continue;
     }
-    const phaseTitle = escapeMermaidLabel(resolveTargetableString(phase.title, DIAGRAM_TARGET, "phase.title"));
+    const phaseTitle = escapeMermaidLabel(diagramString(phase.title, target));
     lines.push(`  subgraph ${nodeId(phase.id)}["${phaseTitle}"]`);
     let counter = 1;
     for (const step of phaseSteps) {
       const stepKey = `${phase.id}/${step.id}`;
       const id = nodeId(stepKey);
-      const baseLabel = escapeMermaidLabel(resolveTargetableString(step.title, DIAGRAM_TARGET, "step.title"));
+      const baseLabel = escapeMermaidLabel(diagramString(step.title, target));
       const num = step.preamble === true ? 0 : counter;
       if (step.preamble !== true) {
         counter += 1;
@@ -33093,18 +32686,18 @@ function renderMermaid(flow, mode) {
           }
         } else {
           for (const m of activeModes) {
-            const target = step.next.byMode[m] ?? null;
-            if (target === null || !isReachable(target)) {
+            const target2 = step.next.byMode[m] ?? null;
+            if (target2 === null || !isReachable(target2)) {
               continue;
             }
             if (mode !== void 0) {
-              const edge = `${src}->${target}`;
+              const edge = `${src}->${target2}`;
               if (!seenLinearEdges.has(edge)) {
                 seenLinearEdges.add(edge);
-                lines.push(`  ${nodeId(src)} --> ${nodeId(target)}`);
+                lines.push(`  ${nodeId(src)} --> ${nodeId(target2)}`);
               }
             } else {
-              lines.push(`  ${nodeId(src)} -->|"${escapeMermaidLabel(m)}"| ${nodeId(target)}`);
+              lines.push(`  ${nodeId(src)} -->|"${escapeMermaidLabel(m)}"| ${nodeId(target2)}`);
             }
           }
         }
@@ -33116,20 +32709,20 @@ function renderMermaid(flow, mode) {
             if (branch.next !== null && !isReachable(branch.next)) {
               continue;
             }
-            const target = branch.next === null ? "flow_end" : nodeId(branch.next);
-            lines.push(`  ${nodeId(src)} -->|"${escapeMermaidLabel(labelWithRec)}"| ${target}`);
+            const target2 = branch.next === null ? "flow_end" : nodeId(branch.next);
+            lines.push(`  ${nodeId(src)} -->|"${escapeMermaidLabel(labelWithRec)}"| ${target2}`);
           } else {
             for (const m of activeModes) {
               const dest = branch.next.byMode[m] ?? null;
               if (dest !== null && !isReachable(dest)) {
                 continue;
               }
-              const target = dest === null ? "flow_end" : nodeId(dest);
+              const target2 = dest === null ? "flow_end" : nodeId(dest);
               if (mode !== void 0) {
-                lines.push(`  ${nodeId(src)} -->|"${escapeMermaidLabel(labelWithRec)}"| ${target}`);
+                lines.push(`  ${nodeId(src)} -->|"${escapeMermaidLabel(labelWithRec)}"| ${target2}`);
               } else {
                 const modeLabel = `${labelWithRec} [${m}]`;
-                lines.push(`  ${nodeId(src)} -->|"${escapeMermaidLabel(modeLabel)}"| ${target}`);
+                lines.push(`  ${nodeId(src)} -->|"${escapeMermaidLabel(modeLabel)}"| ${target2}`);
               }
             }
           }
@@ -33154,7 +32747,7 @@ function renderMermaid(flow, mode) {
     if (entry === void 0) {
       continue;
     }
-    const resolved = resolvePerTarget(entry, DIAGRAM_TARGET);
+    const resolved = diagramValue(entry, target);
     if (resolved === void 0) {
       continue;
     }
@@ -33193,13 +32786,187 @@ function branchForkClass(step) {
 function escapeMermaidLabel(s2) {
   return s2.replace(/"/g, "&quot;").replace(/\|/g, "&#124;");
 }
+function describeFlow(flow, target) {
+  const lines = [];
+  const title = diagramString(flow.title, target);
+  lines.push(`Flow: ${flow.id} (${title})`);
+  if (flow.defaultMode !== void 0) {
+    lines.push(`Default mode: ${flow.defaultMode}`);
+  }
+  lines.push("Entries:");
+  for (const [mode, entry] of Object.entries(flow.entries)) {
+    const resolved = diagramValue(entry, target);
+    lines.push(`  ${mode} \u2192 ${resolved ?? "<no entry for diagram target>"}`);
+  }
+  lines.push("");
+  for (const phase of flow.phases) {
+    lines.push(`Phase: ${phase.id}`);
+    for (const step of phase.steps) {
+      const key = `${phase.id}/${step.id}`;
+      lines.push(`  ${key} [${step.kind}]`);
+      const modes = Object.keys(flow.entries);
+      for (const mode of modes) {
+        const targets = nextRefsForMode(step, mode);
+        const desc = targets.map((t) => t ?? "<end>").join(", ");
+        lines.push(`    ${mode} \u2192 ${desc}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
 
-// ../bitfab-flow/dist/render.js
+// ../node_modules/.pnpm/@agent-flows+core@0.1.1_zod@4.6.7/node_modules/@agent-flows/core/dist/render.js
 function s(value, target, label) {
   return resolveTargetableString(value, target, label);
 }
+function renderFlow(flow, target) {
+  const mode = resolvePerTarget(flow.compile.mode, target.name);
+  if (mode === "split" || mode === "split-chain") {
+    return renderSplit(flow, target, mode === "split-chain");
+  }
+  return [{ slug: "", kind: "monolith", content: renderMarkdown(flow, target) }];
+}
 function usesPhaseReferences(flow, target) {
-  return target.name === "codex" && resolvePerTarget(flow.compile.mode, target.name) === "split-chain";
+  return target.phaseReferences === true && resolvePerTarget(flow.compile.mode, target.name) === "split-chain";
+}
+function makeRenderContext(flow, target) {
+  return {
+    allModes: Object.keys(flow.entries),
+    modesPerStep: computeModesPerStep(flow, target.name),
+    reachable: computeReachableSteps(flow, target.name),
+    emitTemplate: flow.emitTemplate !== void 0 ? s(flow.emitTemplate, target.name, "flow.emitTemplate") : void 0
+  };
+}
+function phaseHasReachableSteps(phase, reachable) {
+  return phase.steps.some((step) => reachable.has(`${phase.id}/${step.id}`));
+}
+function renderSplit(flow, target, chain = false) {
+  const ctx = makeRenderContext(flow, target);
+  const inlineSet = new Set(flow.compile.inlinePhases);
+  const subPhases = flow.phases.filter((phase) => !inlineSet.has(phase.id) && phaseHasReachableSteps(phase, ctx.reachable));
+  const files = [
+    {
+      slug: "",
+      kind: "orchestrator",
+      content: renderOrchestrator(flow, target, ctx, inlineSet, subPhases, chain)
+    }
+  ];
+  for (const phase of subPhases) {
+    files.push({
+      slug: phase.id,
+      kind: usesPhaseReferences(flow, target) ? "reference" : "phase",
+      content: renderSubSkill(flow, target, ctx, phase, chain)
+    });
+  }
+  return files;
+}
+function labeledRefsForMode(step, mode) {
+  switch (step.kind) {
+    case "action":
+    case "reference":
+    case "parallel": {
+      const next = step.next;
+      const ref = next === null || typeof next === "string" ? next : next.byMode[mode] ?? null;
+      return [{ label: null, ref }];
+    }
+    case "branch":
+      return step.branches.map((branch) => {
+        const next = branch.next;
+        const ref = next === null || typeof next === "string" ? next : next.byMode[mode] ?? null;
+        return { label: dispatchBranchLabel(branch), ref };
+      });
+    case "loop":
+      return [
+        { label: step.exitWhen, ref: step.onExit },
+        { label: "otherwise", ref: step.backTo }
+      ];
+  }
+}
+function dispatchBranchLabel(branch) {
+  if (branch.option !== void 0) {
+    return `option ${branch.option.letter} (${branch.option.label})`;
+  }
+  return branch.when ?? "branch";
+}
+function computeDispatchEdges(step, stepKey, unitPhases, ctx) {
+  const stepModeSet = modesForStep(stepKey, ctx.modesPerStep, ctx.allModes);
+  const stepModes = ctx.allModes.filter((m) => stepModeSet.has(m));
+  const groups = /* @__PURE__ */ new Map();
+  const order = [];
+  const labelHasDispatch = /* @__PURE__ */ new Set();
+  for (const mode of stepModes) {
+    for (const { label, ref } of labeledRefsForMode(step, mode)) {
+      let kind = "done";
+      let targetPhase = null;
+      if (ref !== null) {
+        const phaseId = ref.split("/")[0];
+        if (unitPhases.has(phaseId)) {
+          kind = "continue";
+        } else {
+          kind = "dispatch";
+          targetPhase = phaseId;
+        }
+      }
+      const key = `${label ?? "\0"}|${kind}|${targetPhase ?? ""}`;
+      const existing = groups.get(key);
+      if (existing !== void 0) {
+        if (!existing.modes.includes(mode)) {
+          existing.modes.push(mode);
+        }
+      } else {
+        groups.set(key, { label, kind, targetPhase, modes: [mode] });
+        order.push(key);
+      }
+      if (kind === "dispatch") {
+        labelHasDispatch.add(label);
+      }
+    }
+  }
+  return order.map((key) => groups.get(key)).filter((edge) => labelHasDispatch.has(edge.label));
+}
+function renderDispatchSuffix(flow, target, edges, allModes, unitPhases) {
+  if (edges.length === 0) {
+    return null;
+  }
+  const singleMode = allModes.length === 1;
+  const lines = edges.map((edge) => {
+    const modeList = edge.modes.map((m) => `\`${m}\``).join(" or ");
+    let prefix = "";
+    if (edge.label !== null) {
+      prefix = singleMode ? titleCase(edge.label) : `${titleCase(edge.label)} (mode ${modeList})`;
+    } else if (!singleMode) {
+      prefix = `Mode ${modeList}`;
+    }
+    let action;
+    switch (edge.kind) {
+      case "done":
+        action = "stop here.";
+        break;
+      case "continue":
+        action = usesPhaseReferences(flow, target) ? "continue below in this file." : "continue below in this skill.";
+        break;
+      case "dispatch": {
+        if (edge.targetPhase === null) {
+          throw new Error("Dispatch edge is missing its target phase");
+        }
+        const destination = phaseDestination(flow, target, edge.targetPhase, unitPhases);
+        const actionVerb = usesPhaseReferences(flow, target) ? "read and follow" : "invoke";
+        const fwd = `, forwarding \`${target.argsToken}\` minus the leading mode keyword (if the user typed one).`;
+        if (singleMode) {
+          action = `${actionVerb} ${destination}${fwd}`;
+        } else if (edge.modes.length === 1) {
+          action = `${actionVerb} ${destination} with mode \`${edge.modes[0]}\`${fwd}`;
+        } else {
+          action = `${actionVerb} ${destination} with the current mode (${modeList})${fwd}`;
+        }
+        break;
+      }
+    }
+    return prefix.length > 0 ? `- ${prefix}: ${action}` : `- ${titleCase(action)}`;
+  });
+  return `**Next:**
+
+${lines.join("\n")}`;
 }
 function dispatchSkillRef(target, skillName) {
   return target.dispatchRef?.(skillName) ?? `\`${skillName}\``;
@@ -33217,6 +32984,208 @@ function phaseDestination(flow, target, phaseId, unitPhases) {
   const title = s(phase.title, target.name, `phase[${phaseId}].title`);
   return `the [${title}](${prefix}${phaseId}.md) reference`;
 }
+function dispatchSuffixForUnit(flow, target, ctx, unitPhases) {
+  return (step, stepKey) => renderDispatchSuffix(flow, target, computeDispatchEdges(step, stepKey, unitPhases, ctx), ctx.allModes, unitPhases);
+}
+function interactiveDefaultDispatchPointer(flow, target) {
+  const action = usesPhaseReferences(flow, target) ? "read and follow that mode's reference" : "invoke that mode's skill";
+  return `**Next:** once the user picks a mode, ${action} from the \`## Dispatch\` section above, forwarding the arguments the user gave with their pick minus the mode keyword. Ignore the dispatch lines' \`${target.argsToken}\` here: this is the no-argument entry, so it is empty and the user's pick is the only source of those arguments.`;
+}
+function orchestratorDispatchSuffix(flow, target, ctx, inlineSet, hasEntryDispatch) {
+  const base = dispatchSuffixForUnit(flow, target, ctx, inlineSet);
+  const defaultEntry = flow.entries.default === void 0 ? void 0 : resolvePerTarget(flow.entries.default, target.name);
+  return (step, stepKey) => {
+    if (hasEntryDispatch && defaultEntry !== void 0 && stepKey === defaultEntry && "next" in step && step.next === null) {
+      return interactiveDefaultDispatchPointer(flow, target);
+    }
+    return base(step, stepKey);
+  };
+}
+function renderEntryDispatch(flow, target, ctx, inlineSet) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [mode, entry] of Object.entries(flow.entries)) {
+    const resolved = resolvePerTarget(entry, target.name);
+    if (resolved === void 0) {
+      continue;
+    }
+    const phaseId = resolved.split("/")[0];
+    if (inlineSet.has(phaseId)) {
+      continue;
+    }
+    const modes = groups.get(phaseId) ?? [];
+    modes.push(mode);
+    groups.set(phaseId, modes);
+  }
+  if (groups.size === 0) {
+    return null;
+  }
+  const singleMode = ctx.allModes.length === 1;
+  const lines = [...groups.entries()].map(([phaseId, modes]) => {
+    const destination = phaseDestination(flow, target, phaseId, inlineSet);
+    const action = usesPhaseReferences(flow, target) ? "read and follow" : "invoke";
+    const fwd = `, forwarding \`${target.argsToken}\` minus the leading mode keyword (if the user typed one).`;
+    if (singleMode) {
+      return `- ${titleCase(action)} ${destination}${fwd}`;
+    }
+    const modeList = modes.map((m) => `\`${m}\``).join(" or ");
+    const arg = modes.length === 1 ? `mode \`${modes[0]}\`` : `the current mode (${modeList})`;
+    return `- Mode ${modeList}: ${action} ${destination} with ${arg}${fwd}`;
+  });
+  return `## Dispatch
+
+${lines.join("\n")}`;
+}
+function appendicesForUnit(flow, ctx, unitPhases, includeUnreferenced) {
+  const referencingPhases = /* @__PURE__ */ new Map();
+  for (const phase of flow.phases) {
+    for (const step of phase.steps) {
+      if (!ctx.reachable.has(`${phase.id}/${step.id}`)) {
+        continue;
+      }
+      for (const ref of step.refs ?? []) {
+        const phases = referencingPhases.get(ref) ?? /* @__PURE__ */ new Set();
+        phases.add(phase.id);
+        referencingPhases.set(ref, phases);
+      }
+    }
+  }
+  return flow.appendices.filter((appendix) => {
+    const phases = referencingPhases.get(appendix.id);
+    if (phases === void 0) {
+      return includeUnreferenced;
+    }
+    return [...phases].some((id) => unitPhases.has(id));
+  });
+}
+function renderOrchestrator(flow, target, ctx, inlineSet, subPhases, chain) {
+  const inlinePhaseIds = flow.phases.filter((phase) => inlineSet.has(phase.id)).map((phase) => phase.id);
+  const sections = [
+    target.frontmatter({
+      flowId: flow.id,
+      description: s(flow.frontmatter.description, target.name, "flow.frontmatter.description"),
+      argumentHint: resolveArgumentHint(flow, target),
+      model: flow.frontmatter.model,
+      allowedTools: orchestratorAllowedTools(flow, target, inlinePhaseIds, subPhases.length > 0)
+    }),
+    `# ${s(flow.title, target.name, "flow.title")}`
+  ];
+  pushIntro(sections, flow, target);
+  if (usesPhaseReferences(flow, target) && subPhases.length > 0) {
+    sections.push("Load phase references only when routing reaches them. Read and follow the linked file in this same session, retaining the current mode, arguments, shared rules, and prior results. Resolve links relative to the file containing them. If an installed shim redirected you here, use this worktree skill's directory, not the shim directory or shell working directory. References are ordinary instruction files, not separately invocable skills.");
+  }
+  if (Object.keys(flow.commands).length > 0) {
+    sections.push(renderCommandsTable(flow, target));
+  }
+  pushInvariants(sections, flow);
+  const modesDispatch = renderModesDispatch(flow, target, true);
+  if (modesDispatch !== null) {
+    sections.push(modesDispatch);
+  }
+  let hasEntryDispatch = false;
+  if (chain) {
+    const entryDispatch = renderEntryDispatch(flow, target, ctx, inlineSet);
+    if (entryDispatch !== null) {
+      sections.push(entryDispatch);
+      hasEntryDispatch = true;
+    }
+  }
+  const subPhaseIds = new Set(subPhases.map((phase) => phase.id));
+  for (const phase of flow.phases) {
+    if (inlineSet.has(phase.id)) {
+      const rendered = renderPhase(
+        phase,
+        target.name,
+        ctx.allModes,
+        ctx.modesPerStep,
+        ctx.reachable,
+        ctx.emitTemplate,
+        true,
+        chain ? orchestratorDispatchSuffix(flow, target, ctx, inlineSet, hasEntryDispatch) : void 0,
+        destinationRenderer(flow, target, inlineSet),
+        0,
+        // Split-chain orchestrators emit a `## Dispatch` block above the inline
+        // phase; fold a single-mode gate under the first step heading so it can't
+        // be misread as gating the dispatch. Non-chain/monolith keep the float.
+        chain
+      );
+      if (rendered.length > 0) {
+        sections.push(rendered);
+      }
+    } else if (!chain && subPhaseIds.has(phase.id)) {
+      sections.push(renderDispatch(flow, target, ctx, phase));
+    }
+  }
+  pushAppendices(sections, flow, target, chain ? appendicesForUnit(flow, ctx, inlineSet, true) : flow.appendices);
+  return finalize2(sections, flow, target, inlineSet);
+}
+function renderDispatch(flow, target, ctx, phase) {
+  const title = s(phase.title, target.name, `phase[${phase.id}].title`);
+  const stepKeys = phase.steps.map((step) => `${phase.id}/${step.id}`).filter((key) => ctx.reachable.has(key));
+  const { phaseGate } = precomputePhaseAndStepGates(stepKeys, ctx.modesPerStep, ctx.allModes);
+  const blocks = [`## ${title}`];
+  if (phaseGate !== null) {
+    blocks.push(phaseGate);
+  }
+  blocks.push(`Invoke the \`${flow.id}-${phase.id}\` skill, then return here.`);
+  return blocks.join("\n\n");
+}
+function renderSubSkill(flow, target, ctx, phase, chain) {
+  const phaseTitle = s(phase.title, target.name, `phase[${phase.id}].title`);
+  const flowTitle = s(flow.title, target.name, "flow.title");
+  const unitPhases = /* @__PURE__ */ new Set([phase.id]);
+  const reachableSteps = phase.steps.filter((step) => ctx.reachable.has(`${phase.id}/${step.id}`));
+  const hasDispatch = chain && reachableSteps.some((step) => computeDispatchEdges(step, `${phase.id}/${step.id}`, unitPhases, ctx).some((edge) => edge.kind === "dispatch"));
+  const invokedBy = chain ? `Invoked by the ${flow.id} flow; not run directly` : `Invoked by the ${flow.id} orchestrator; not run directly`;
+  const description = `${phaseTitle} phase of the ${flowTitle} flow. ${invokedBy}`;
+  const sections = [];
+  if (!usesPhaseReferences(flow, target)) {
+    sections.push(target.subSkillFrontmatter({
+      flowId: `${flow.id}-${phase.id}`,
+      description,
+      argumentHint: resolveArgumentHint(flow, target),
+      model: flow.frontmatter.model,
+      allowedTools: subSkillAllowedTools(flow, target, phase.id, hasDispatch)
+    }));
+  }
+  sections.push(`# ${flowTitle}: ${phaseTitle}`);
+  if (chain) {
+    const preface = renderModePreface(ctx, phase, reachableSteps);
+    if (preface !== null) {
+      sections.push(preface);
+    }
+  }
+  const rendered = renderPhase(phase, target.name, ctx.allModes, ctx.modesPerStep, ctx.reachable, ctx.emitTemplate, false, chain ? dispatchSuffixForUnit(flow, target, ctx, unitPhases) : void 0, destinationRenderer(flow, target, unitPhases));
+  if (rendered.length > 0) {
+    sections.push(rendered);
+  }
+  if (chain) {
+    pushAppendices(sections, flow, target, appendicesForUnit(flow, ctx, unitPhases, false));
+  }
+  return finalize2(sections, flow, target, unitPhases);
+}
+function renderModePreface(ctx, phase, reachableSteps) {
+  const phaseModes = /* @__PURE__ */ new Set();
+  for (const step of reachableSteps) {
+    for (const mode of modesForStep(`${phase.id}/${step.id}`, ctx.modesPerStep, ctx.allModes)) {
+      phaseModes.add(mode);
+    }
+  }
+  if (phaseModes.size < 2) {
+    return null;
+  }
+  const modeList = ctx.allModes.filter((m) => phaseModes.has(m)).map((m) => `\`${m}\``).join(" or ");
+  return `**Mode:** you were dispatched with a mode (${modeList}); which steps apply and where they route below depend on it.`;
+}
+function subSkillAllowedTools(flow, target, phaseId, hasDispatch) {
+  const tools = resolveAllowedToolsForPhases(flow, target, [phaseId]);
+  if (tools === void 0 || !hasDispatch) {
+    return tools;
+  }
+  if (target.subSkillTool && !tools.includes(target.subSkillTool)) {
+    return [...tools, target.subSkillTool];
+  }
+  return tools;
+}
 function resolveArgumentHint(flow, target) {
   const argumentHint = flow.frontmatter.argumentHint;
   if (argumentHint === void 0) {
@@ -33232,8 +33201,91 @@ function resolveArgumentHint(flow, target) {
   if (argumentHint.suffix === void 0) {
     return modeHint;
   }
-  const suffix = s(argumentHint.suffix, target.name, "frontmatter.argumentHint.suffix");
-  return suffix.length > 0 ? `${modeHint} ${suffix}` : modeHint;
+  const suffix = s(argumentHint.suffix, target.name, "frontmatter.argumentHint.suffix");
+  return suffix.length > 0 ? `${modeHint} ${suffix}` : modeHint;
+}
+function pushIntro(sections, flow, target) {
+  if (flow.intro === void 0) {
+    return;
+  }
+  const introStr = s(flow.intro, target.name, "flow.intro");
+  if (introStr.length > 0) {
+    sections.push(introStr);
+  }
+}
+function pushInvariants(sections, flow) {
+  if (flow.invariants.length > 0) {
+    const items = flow.invariants.map((inv) => `- ${inv}`).join("\n");
+    sections.push(`## Invariants
+
+${items}`);
+  }
+}
+function pushAppendices(sections, flow, target, appendices = flow.appendices) {
+  for (const appendix of appendices) {
+    const title = s(appendix.title, target.name, `appendix[${appendix.id}].title`);
+    const body = s(appendix.body, target.name, `appendix[${appendix.id}].body`);
+    sections.push(`## ${title}
+
+${body}`);
+  }
+}
+function orchestratorAllowedTools(flow, target, inlinePhaseIds, hasSubSkills) {
+  const tools = resolveAllowedToolsForPhases(flow, target, inlinePhaseIds);
+  if (tools === void 0) {
+    return void 0;
+  }
+  if (hasSubSkills && target.subSkillTool && !tools.includes(target.subSkillTool)) {
+    return [...tools, target.subSkillTool];
+  }
+  return tools;
+}
+function resolveAllowedToolsForPhases(flow, target, phaseIds) {
+  if (Object.keys(flow.tools).length === 0) {
+    return flow.frontmatter.allowedTools;
+  }
+  const ids = collectPhaseToolIds(flow, target, phaseIds).filter((id) => toolAvailableOnTarget(flow.tools[id], target.name));
+  if (ids.length === 0) {
+    return void 0;
+  }
+  return ids.map((id) => fullToolName(flow, id, target));
+}
+var HAS_COMMAND_RE = new RegExp(COMMAND_PLACEHOLDER_RE.source);
+function collectPhaseToolIds(flow, target, phaseIds) {
+  const wanted = new Set(phaseIds);
+  const called = /* @__PURE__ */ new Set();
+  const runnerId = Object.entries(flow.tools).find(([, tool]) => tool.kind === "builtin" && resolvePerTarget(tool.name, target.name) === target.commandRunnerTool)?.[0];
+  const emitTemplate = flow.emitTemplate !== void 0 ? s(flow.emitTemplate, target.name, "flow.emitTemplate") : void 0;
+  const emitUsesCommand = emitTemplate !== void 0 && HAS_COMMAND_RE.test(emitTemplate);
+  const scan = (text2) => {
+    if (text2 === void 0) {
+      return;
+    }
+    for (const match of text2.matchAll(TOOL_PLACEHOLDER_RE)) {
+      called.add(match[1]);
+    }
+    if (runnerId !== void 0 && HAS_COMMAND_RE.test(text2)) {
+      called.add(runnerId);
+    }
+  };
+  for (const phase of flow.phases) {
+    if (!wanted.has(phase.id)) {
+      continue;
+    }
+    if (phase.intro !== void 0) {
+      scan(s(phase.intro, target.name, `phase[${phase.id}].intro`));
+    }
+    for (const step of phase.steps) {
+      for (const id of step.toolCalls ?? []) {
+        called.add(id);
+      }
+      if (runnerId !== void 0 && ((step.commandCalls?.length ?? 0) > 0 || step.emit !== void 0 && emitUsesCommand)) {
+        called.add(runnerId);
+      }
+      scan(s(step.body, target.name, `step[${step.id}].body`));
+    }
+  }
+  return Object.keys(flow.tools).filter((id) => called.has(id));
 }
 function renderMarkdown(flow, target) {
   const sections = [];
@@ -33254,7 +33306,7 @@ function renderMarkdown(flow, target) {
     }
   }
   if (Object.keys(flow.commands).length > 0) {
-    sections.push(renderCommandsTable(flow));
+    sections.push(renderCommandsTable(flow, target));
   }
   if (flow.invariants.length > 0) {
     const items = flow.invariants.map((inv) => `- ${inv}`).join("\n");
@@ -33294,7 +33346,7 @@ ${body}`);
 }
 function finalize2(sections, flow, target, unitPhases) {
   const joined = sections.join("\n\n");
-  const afterSections = applyModeSections(applyMustacheSections(joined, target.name), flow, target.name, unitPhases);
+  const afterSections = applyModeSections(applyMustacheSections(joined, target), flow, target.name, unitPhases);
   const withFlowData = applyFlowPlaceholders(afterSections, flow, target, unitPhases);
   const substituted = applyTokens(withFlowData, target, flow);
   return ensureTrailingNewline(substituted);
@@ -33353,16 +33405,11 @@ function applyFlowPlaceholders(text2, flow, target, unitPhases) {
     if (def === void 0) {
       throw new Error(`Command "${commandId}" not declared in flow.commands`);
     }
-    return `node "{{pluginRoot}}/dist/commands/${def.file}"`;
+    return target.invokeCommand(def);
   });
-  result = result.replace(/\{\{languages:([a-z,]+)\}\}/g, (_match, columnsRaw, offset) => {
-    const block = renderLanguagesBlock(flow, columnsRaw.split(","));
-    const lineStart = result.lastIndexOf("\n", offset - 1) + 1;
-    const before = result.slice(lineStart, offset);
-    if (!/^[ \t]*$/.test(before)) {
-      return block;
-    }
-    return block.split("\n").map((line, i) => i === 0 || line.length === 0 ? line : before + line).join("\n");
+  result = result.replace(/\{\{(table|list):([a-zA-Z][a-zA-Z0-9_-]*):([a-zA-Z0-9_,-]+)\}\}/g, (_match, kind, tableName, columnsRaw, offset) => {
+    const block = renderTableBlock(flow, kind, tableName, columnsRaw.split(","));
+    return inheritLineIndent(result, offset, block);
   });
   return result;
 }
@@ -33448,65 +33495,61 @@ function renderModesDispatch(flow, target, dispatches) {
     ...rows
   ].join("\n");
 }
-function renderCommandsTable(flow) {
+function renderCommandsTable(flow, target) {
   const rows = [];
   for (const def of Object.values(flow.commands)) {
     const sig = def.args !== void 0 ? `${def.file} ${def.args}` : def.file;
     rows.push(`| \`${sig}\` | ${def.description} |`);
   }
   return [
-    "**CLI commands** available via Bash (all paths relative to `{{pluginRoot}}/dist/commands/`):",
+    target.commandsTableIntro,
     "",
     "| Command | Description |",
     "|---------|-------------|",
     ...rows
   ].join("\n");
 }
-function renderLanguagesBlock(flow, columns) {
-  if (flow.languages.length === 0) {
-    return "";
+function renderTableBlock(flow, kind, tableName, columns) {
+  const table = flow.tables[tableName];
+  if (table === void 0) {
+    throw new Error(`Table "${tableName}" not declared in flow.tables`);
   }
-  if (columns.length === 1 && columns[0] === "imports") {
-    const lines2 = [];
-    for (const lang of flow.languages) {
-      if (lang.imports !== void 0) {
-        lines2.push(`  - ${lang.displayName}: ${lang.imports}`);
-      }
+  if (kind === "list") {
+    if (columns.length !== 1) {
+      throw new Error(`{{list:${tableName}:\u2026}} takes exactly one column, got ${columns.join(",")}`);
     }
-    return lines2.join("\n");
+    const column = columns[0];
+    return table.rows.filter((row) => row.cells[column] !== void 0).map((row) => `- ${row.label ?? row.key}: ${row.cells[column]}`).join("\n");
   }
-  const headers = ["Language", ...columns.map((c) => columnHeader(flow, c))];
+  const headers = [
+    table.keyHeader,
+    ...columns.map((c) => table.columns[c] ?? titleCase(c))
+  ];
   const lines = [
     `| ${headers.join(" | ")} |`,
     `|${headers.map(() => "---").join("|")}|`
   ];
-  for (const lang of flow.languages) {
-    const cells = columns.map((col) => readLanguageField(lang, col));
+  for (const row of table.rows) {
+    const cells = columns.map((col) => row.cells[col]);
     if (cells.every((c) => c !== void 0)) {
-      lines.push(`| ${lang.name} | ${cells.join(" | ")} |`);
+      lines.push(`| ${row.key} | ${cells.join(" | ")} |`);
     }
   }
   return lines.join("\n");
 }
-function columnHeader(flow, column) {
-  return flow.languageColumnHeaders[column] ?? titleCase(column);
-}
 function titleCase(s2) {
   return s2.charAt(0).toUpperCase() + s2.slice(1);
 }
-function readLanguageField(lang, column) {
-  switch (column) {
-    case "imports":
-      return lang.imports;
-    case "detection":
-      return lang.detection;
-    case "outdated":
-      return lang.outdated;
-    case "update":
-      return lang.update;
-    default:
-      throw new Error(`Unknown languages field "${column}"`);
+function inheritLineIndent(text2, offset, value) {
+  if (!value.includes("\n")) {
+    return value;
+  }
+  const lineStart = text2.lastIndexOf("\n", offset - 1) + 1;
+  const before = text2.slice(lineStart, offset);
+  if (!/^[ \t]*$/.test(before)) {
+    return value;
   }
+  return value.split("\n").map((line, i) => i === 0 || line.length === 0 ? line : before + line).join("\n");
 }
 function destinationRenderer(flow, target, unitPhases) {
   const one = (ref, sourcePhaseId) => {
@@ -33750,14 +33793,13 @@ function indentBody(body) {
   const lines = body.split("\n");
   return lines.map((line, i) => i === 0 ? line : line.length > 0 ? `   ${line}` : line).join("\n");
 }
-function applyMustacheSections(text2, targetName) {
-  const sectionRegex = /\{\{([#^])([a-z][a-z-]*)\}\}([\s\S]*?)\{\{\/\2\}\}/g;
+function applyMustacheSections(text2, target) {
+  const sectionRegex = /\{\{([#^])([a-z][a-z0-9-]*)\}\}([\s\S]*?)\{\{\/\2\}\}/g;
   return text2.replace(sectionRegex, (_match, kind, name, inner) => {
-    const members2 = SECTION_TARGETS[name];
-    if (members2 === void 0) {
-      throw new Error(`Unknown target name "${name}" in Mustache section. Valid names: ${MUSTACHE_SECTION_NAMES.join(", ")}.`);
+    const isMatch = target.sections[name];
+    if (isMatch === void 0) {
+      throw new Error(`Unknown section "${name}". Valid sections: ${Object.keys(target.sections).join(", ")}.`);
     }
-    const isMatch = members2.includes(targetName);
     const include = kind === "#" ? isMatch : !isMatch;
     return include ? inner : "";
   });
@@ -33820,20 +33862,11 @@ function applyTokens(text2, target, flow) {
     if (!Object.hasOwn(pool, key)) {
       throw new Error(`Unresolved placeholder {{${key}}} - not a target token or flow variable. Define it in flow.variables, fix the typo, or remove the placeholder.`);
     }
-    const value = pool[key];
-    if (!value.includes("\n")) {
-      return value;
-    }
-    const lineStart = text2.lastIndexOf("\n", offset - 1) + 1;
-    const before = text2.slice(lineStart, offset);
-    if (!/^[ \t]*$/.test(before)) {
-      return value;
-    }
-    return value.split("\n").map((line, i) => i === 0 || line.length === 0 ? line : before + line).join("\n");
+    return inheritLineIndent(text2, offset, pool[key]);
   });
   const leftovers = result.match(/\{\{[^}]+\}\}/g);
   if (leftovers) {
-    throw new Error(`Unresolved placeholder(s): ${leftovers.join(", ")}. Check spelling and namespace (step:, step-ref:, skill-ref:, dispatch-ref:, tool:, languages:, branches, branches:).`);
+    throw new Error(`Unresolved placeholder(s): ${leftovers.join(", ")}. Check spelling and namespace (step:, step-ref:, skill-ref:, dispatch-ref:, tool:, command:, table:, list:, branches, branches:).`);
   }
   return result;
 }
@@ -33842,27 +33875,318 @@ function ensureTrailingNewline(text2) {
 `;
 }
 
-// ../bitfab-flow/dist/sharedVariables.js
-var SHARED_VARIABLES = {
-  /**
-   * Connector phrase used when describing instrumentation that races (or
-   * sequentially writes, on codex) work in another file. Grammatically
-   * expects a continuation: "writes them {{parallelism}} the X edits."
-   */
-  parallelism: {
-    default: "in parallel with",
-    codex: "in the same cycle as"
-  },
-  /**
-   * Adverbial phrase used in tabular or bullet contexts where the
-   * surrounding grammar doesn't carry over. "(... {{togetherness}} per
-   * workflow)".
-   */
-  togetherness: {
-    default: "in parallel",
-    codex: "together"
+// ../node_modules/.pnpm/@agent-flows+core@0.1.1_zod@4.6.7/node_modules/@agent-flows/core/dist/kit.js
+var NAME_RE = /^[a-z][a-z0-9-]*$/;
+function createFlowKit(config4) {
+  const targetNames = Object.keys(config4.targets);
+  if (targetNames.length === 0) {
+    throw new Error("createFlowKit: at least one target is required");
+  }
+  for (const name of targetNames) {
+    if (!NAME_RE.test(name) || name === "default") {
+      throw new Error(`createFlowKit: invalid target name "${name}" (use lowercase kebab-case; "default" is reserved)`);
+    }
+  }
+  const groups = {};
+  for (const name of targetNames) {
+    groups[name] = [name];
+  }
+  for (const [section, members2] of Object.entries(config4.sections ?? {})) {
+    if (!NAME_RE.test(section)) {
+      throw new Error(`createFlowKit: invalid section name "${section}"`);
+    }
+    if (section in groups) {
+      throw new Error(`createFlowKit: section "${section}" collides with a target name`);
+    }
+    for (const member of members2) {
+      if (!targetNames.includes(member)) {
+        throw new Error(`createFlowKit: section "${section}" lists unknown target "${member}"`);
+      }
+    }
+    groups[section] = members2;
+  }
+  const commands = config4.commands ?? {};
+  const runnerTool = commands.runnerTool ?? "Bash";
+  const targets = {};
+  for (const name of targetNames) {
+    const spec = config4.targets[name];
+    const target = { ...spec, name };
+    const sections = {};
+    for (const [section, members2] of Object.entries(groups)) {
+      sections[section] = members2.includes(name);
+    }
+    const tableIntro = commands.tableIntro;
+    targets[name] = {
+      ...target,
+      sections,
+      invokeCommand: (command) => commands.invoke?.(command, target) ?? command.file,
+      commandsTableIntro: typeof tableIntro === "function" ? tableIntro(target) : tableIntro ?? `**CLI commands** available via \`${runnerTool}\`:`,
+      commandRunnerTool: runnerTool
+    };
+  }
+  const reservedTokenNames = /* @__PURE__ */ new Set();
+  for (const name of targetNames) {
+    for (const token of Object.keys(config4.targets[name].tokens)) {
+      reservedTokenNames.add(token);
+    }
+  }
+  const schemaOptions = {
+    targetNames,
+    reservedTokenNames: [...reservedTokenNames]
+  };
+  const schema = createFlowSchema(schemaOptions);
+  const getTarget = (name) => {
+    const target = targets[name];
+    if (target === void 0) {
+      throw new Error(`Unknown target "${name}". Known targets: ${targetNames.join(", ")}.`);
+    }
+    return target;
+  };
+  return {
+    targetNames,
+    targets,
+    schema,
+    defineFlow(input2) {
+      const result = schema.safeParse(input2);
+      if (!result.success) {
+        const id = typeof input2 === "object" && input2 !== null && "id" in input2 ? String(input2.id) : "<unknown>";
+        throw new Error(`Invalid flow "${id}":
+${external_exports.prettifyError(result.error)}`);
+      }
+      return result.data;
+    },
+    render: (flow, name) => renderFlow(flow, getTarget(name)),
+    renderMarkdown: (flow, name) => renderMarkdown(flow, getTarget(name)),
+    renderProject(projects) {
+      const out = [];
+      for (const { flow, outputs } of projects) {
+        for (const name of targetNames) {
+          const output2 = outputs[name];
+          if (output2 === void 0) {
+            continue;
+          }
+          for (const file2 of renderFlow(flow, getTarget(name))) {
+            out.push({
+              flowId: flow.id,
+              target: name,
+              kind: file2.kind,
+              path: resolveOutputPath(output2, file2),
+              content: file2.content
+            });
+          }
+        }
+      }
+      return out;
+    },
+    renderMermaid,
+    describeFlow
+  };
+}
+function dirname(path15) {
+  const i = path15.lastIndexOf("/");
+  return i === -1 ? "." : path15.slice(0, i);
+}
+function basename(path15) {
+  return path15.slice(path15.lastIndexOf("/") + 1);
+}
+function resolveOutputPath(output2, file2) {
+  const main2 = typeof output2 === "string" ? output2 : output2.main;
+  if (file2.slug === "") {
+    return main2;
+  }
+  if (file2.kind === "reference") {
+    return `${dirname(main2)}/references/${file2.slug}.md`;
+  }
+  if (typeof output2 !== "string") {
+    return output2.phase.replace(/\{phase\}/g, file2.slug);
+  }
+  const skillDir = dirname(main2);
+  if (skillDir === ".") {
+    throw new Error(`Cannot derive a sub-skill path for phase "${file2.slug}" from "${main2}"; use { main, phase } output paths.`);
+  }
+  return `${dirname(skillDir)}/${basename(skillDir)}-${file2.slug}/${basename(main2)}`;
+}
+
+// ../node_modules/.pnpm/@agent-flows+core@0.1.1_zod@4.6.7/node_modules/@agent-flows/core/dist/targets.js
+function formatAllowedTools(allowedTools) {
+  return `[${allowedTools.map((t) => JSON.stringify(t)).join(", ")}]`;
+}
+function claudeFrontmatter({ description, argumentHint, model, allowedTools }) {
+  const lines = ["---", `description: ${description}`];
+  if (argumentHint !== void 0) {
+    lines.push(`argument-hint: ${JSON.stringify(argumentHint)}`);
+  }
+  if (model !== void 0) {
+    lines.push(`model: ${model}`);
+  }
+  if (allowedTools !== void 0) {
+    lines.push(`allowed-tools: ${formatAllowedTools(allowedTools)}`);
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+function claudeSubSkillFrontmatter({ flowId, description, model, allowedTools }) {
+  const lines = [
+    "---",
+    `name: ${flowId}`,
+    `description: ${description}`,
+    "user-invocable: false"
+  ];
+  if (model !== void 0) {
+    lines.push(`model: ${model}`);
+  }
+  if (allowedTools !== void 0) {
+    lines.push(`allowed-tools: ${formatAllowedTools(allowedTools)}`);
   }
+  lines.push("---");
+  return lines.join("\n");
+}
+function namedFrontmatter(name, description, usage, usageInBody = false) {
+  const frontmatter = [
+    "---",
+    `name: ${name}`,
+    `description: "${description}${usageInBody ? "" : usage}"`,
+    "---"
+  ].join("\n");
+  return usageInBody && usage !== "" ? `${frontmatter}
+
+${usage.slice(2)}` : frontmatter;
+}
+var ASK_USER_QUESTION_TOKENS = {
+  askUser: "with `AskUserQuestion` ",
+  askVerb: "use `AskUserQuestion`",
+  askVerbCap: "Use `AskUserQuestion`",
+  askNoun: "AskUserQuestion"
 };
+var PLAIN_PROMPT_TOKENS = {
+  askUser: "",
+  askVerb: "ask the user",
+  askVerbCap: "Ask the user",
+  askNoun: "choice prompt"
+};
+function claudeCode(options) {
+  return {
+    tokens: {
+      cmd: `/${options.plugin}:`,
+      editor: "Claude Code",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: shell variable rendered into skill markdown
+      pluginRoot: "${CLAUDE_PLUGIN_ROOT}",
+      pluginDirLookup: "",
+      ...ASK_USER_QUESTION_TOKENS,
+      ...options.tokens
+    },
+    mcpPrefix: options.mcpPrefix ?? (options.mcpServer !== void 0 ? `mcp__plugin_${options.plugin}_${options.mcpServer}__` : ""),
+    argsToken: "$ARGUMENTS",
+    frontmatter: claudeFrontmatter,
+    subSkillFrontmatter: claudeSubSkillFrontmatter,
+    subSkillTool: "Skill"
+  };
+}
+function cursor(options) {
+  const render = ({ flowId, description, argumentHint }) => {
+    const name = `${options.plugin}-${flowId}`;
+    const usage = argumentHint !== void 0 ? `. Usage: /${name} ${argumentHint}` : "";
+    return namedFrontmatter(name, description, usage, options.usageInBody);
+  };
+  return {
+    tokens: {
+      cmd: `/${options.plugin}-`,
+      editor: "Cursor",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: shell variable rendered into skill markdown
+      pluginRoot: "${CURSOR_PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT}}",
+      pluginDirLookup: "",
+      ...ASK_USER_QUESTION_TOKENS,
+      ...options.tokens
+    },
+    mcpPrefix: options.mcpPrefix ?? (options.mcpServer !== void 0 ? `mcp__${options.mcpServer}__` : ""),
+    argsToken: "$ARGUMENTS",
+    frontmatter: render,
+    subSkillFrontmatter: render
+  };
+}
+function defaultEnvVar(plugin) {
+  return `${plugin.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_PLUGIN_DIR`;
+}
+function codexPluginDirLookup(plugin, { envVar = defaultEnvVar(plugin), markerFile }) {
+  return `\`\`\`bash
+if [ -z "$${envVar}" ]; then
+  ${envVar}=$(
+    hit=$(find "\${CODEX_HOME:-$HOME/.codex}/plugins/cache" -maxdepth 8 -type f \\
+      -path '*/${plugin}/*/${markerFile}' 2>/dev/null | head -1)
+    echo "\${hit%/${markerFile}}"
+  )
+  export ${envVar}
+fi
+test -n "$${envVar}" || { echo "ERROR: ${plugin} plugin not installed"; exit 1; }
+\`\`\``;
+}
+function ampPluginDirLookup(plugin, { envVar = defaultEnvVar(plugin), markerFile }) {
+  return `\`\`\`bash
+if [ -z "$${envVar}" ]; then
+  project_root=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+  for candidate in "$project_root/.amp/plugins/${plugin}" "\${XDG_CONFIG_HOME:-$HOME/.config}/amp/plugins/${plugin}"; do
+    if [ -f "$candidate/${markerFile}" ]; then
+      ${envVar}="$candidate"
+      break
+    fi
+  done
+  export ${envVar}
+fi
+test -n "$${envVar}" || { echo "ERROR: ${plugin} plugin not installed"; exit 1; }
+\`\`\``;
+}
+function pluginDirTokens(plugin, pluginDir, lookup) {
+  if (pluginDir === void 0) {
+    return {};
+  }
+  return {
+    pluginRoot: `\${${pluginDir.envVar ?? defaultEnvVar(plugin)}}`,
+    pluginDirLookup: lookup(plugin, pluginDir)
+  };
+}
+function codex(options) {
+  const render = ({ flowId, description, argumentHint }) => {
+    const usage = argumentHint !== void 0 ? `. Invoke with $${options.plugin}:${flowId} ${argumentHint}.` : "";
+    return namedFrontmatter(flowId, description, usage, options.usageInBody);
+  };
+  return {
+    tokens: {
+      cmd: `$${options.plugin}:`,
+      editor: "Codex",
+      ...pluginDirTokens(options.plugin, options.pluginDir, codexPluginDirLookup),
+      ...PLAIN_PROMPT_TOKENS,
+      ...options.tokens
+    },
+    mcpPrefix: options.mcpPrefix ?? (options.mcpServer !== void 0 ? `mcp__${options.mcpServer}__` : ""),
+    argsToken: "$ARGUMENTS",
+    frontmatter: render,
+    subSkillFrontmatter: render,
+    dispatchRef: (skillName) => `\`$${options.plugin}:${skillName}\``,
+    phaseReferences: options.phaseReferences ?? true
+  };
+}
+function amp(options) {
+  const render = ({ flowId, description, argumentHint }) => {
+    const usage = argumentHint !== void 0 ? `. Invoke as ${options.plugin}:${flowId} ${argumentHint}.` : "";
+    return namedFrontmatter(flowId, description, usage, options.usageInBody);
+  };
+  return {
+    tokens: {
+      cmd: `${options.plugin}:`,
+      editor: "Amp",
+      ...pluginDirTokens(options.plugin, options.pluginDir, ampPluginDirLookup),
+      ...PLAIN_PROMPT_TOKENS,
+      ...options.tokens
+    },
+    // Amp exposes MCP tools under their bare names.
+    mcpPrefix: options.mcpPrefix ?? "",
+    argsToken: "the user's request",
+    frontmatter: render,
+    subSkillFrontmatter: render,
+    subSkillTool: "skill",
+    dispatchRef: (skillName) => `\`${options.plugin}:${skillName}\``
+  };
+}
 
 // ../bitfab-plugin-lib/dist/retiredAssistant.js
 var RETIRED_ASSISTANT_EXAMPLE_REQUESTS = [
@@ -33872,9 +34196,84 @@ var RETIRED_ASSISTANT_EXAMPLE_REQUESTS = [
   "Compare the baseline experiment with the two prompt-variant experiments"
 ];
 
+// ../bitfab-plugin-lib/dist/flows/kit.js
+var BITFAB_PLUGIN = "bitfab";
+var MCP_SERVER = "Bitfab";
+var CODEX_RESOLVE_PLUGIN_DIR_BASH = `\`\`\`bash
+if [ -z "$BITFAB_PLUGIN_DIR" ]; then
+  BITFAB_PLUGIN_DIR=$(
+    hit=$(find "\${CODEX_HOME:-$HOME/.codex}/plugins/cache" -maxdepth 6 -type f -name status.js \\
+      \\( -path '*/bitfab-internal/bitfab/local/dist/commands/*' \\
+      -o -path '*/bitfab/bitfab/*/dist/commands/*' \\) 2>/dev/null | head -1)
+    echo "\${hit%/dist/commands/status.js}"
+  )
+  export BITFAB_PLUGIN_DIR
+fi
+test -n "$BITFAB_PLUGIN_DIR" || { echo "ERROR: Bitfab plugin not installed"; exit 1; }
+\`\`\``;
+var AMP_RESOLVE_PLUGIN_DIR_BASH = `\`\`\`bash
+if [ -z "$BITFAB_PLUGIN_DIR" ]; then
+  project_root=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+  for candidate in "$project_root/.amp/plugins/bitfab" "\${XDG_CONFIG_HOME:-$HOME/.config}/amp/plugins/bitfab"; do
+    if [ -f "$candidate/dist/commands/status.js" ]; then
+      BITFAB_PLUGIN_DIR="$candidate"
+      break
+    fi
+  done
+  export BITFAB_PLUGIN_DIR
+fi
+test -n "$BITFAB_PLUGIN_DIR" || { echo "ERROR: Bitfab plugin not installed"; exit 1; }
+\`\`\``;
+var bitfabKit = createFlowKit({
+  targets: {
+    claude: claudeCode({ plugin: BITFAB_PLUGIN, mcpServer: MCP_SERVER }),
+    cursor: cursor({ plugin: BITFAB_PLUGIN, mcpServer: MCP_SERVER }),
+    codex: codex({
+      plugin: BITFAB_PLUGIN,
+      mcpServer: MCP_SERVER,
+      tokens: {
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: shell variable reference rendered into skill markdown, not a JS template
+        pluginRoot: "${BITFAB_PLUGIN_DIR}",
+        pluginDirLookup: CODEX_RESOLVE_PLUGIN_DIR_BASH
+      }
+    }),
+    amp: amp({
+      plugin: BITFAB_PLUGIN,
+      tokens: {
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: shell variable reference rendered into skill markdown, not a JS template
+        pluginRoot: "${BITFAB_PLUGIN_DIR}",
+        pluginDirLookup: AMP_RESOLVE_PLUGIN_DIR_BASH
+      }
+    })
+  },
+  sections: {
+    "ask-user-question": ["claude", "cursor"],
+    "plugin-dir-lookup": ["codex", "amp"],
+    "exec-polling": ["codex", "amp"],
+    "no-startup-banner": ["codex", "amp"],
+    "web-fetch-tool": ["claude", "cursor"]
+  },
+  commands: {
+    invoke: (command) => `node "{{pluginRoot}}/dist/commands/${command.file}"`,
+    tableIntro: "**CLI commands** available via Bash (all paths relative to `{{pluginRoot}}/dist/commands/`):"
+  }
+});
+var TARGET_NAMES = bitfabKit.targetNames;
+var TARGETS = bitfabKit.targets;
+var SHARED_VARIABLES = {
+  parallelism: {
+    default: "in parallel with",
+    codex: "in the same cycle as"
+  },
+  togetherness: {
+    default: "in parallel",
+    codex: "together"
+  }
+};
+
 // ../bitfab-plugin-lib/dist/flows/assistant.js
 var EXAMPLE_LINES = RETIRED_ASSISTANT_EXAMPLE_REQUESTS.map((request) => `> - "${request}"`).join("\n");
-var assistantFlow = Flow.parse({
+var assistantFlow = bitfabKit.defineFlow({
   schemaVersion: 1,
   id: "assistant",
   title: "Bitfab Assistant (retired)",
@@ -34304,7 +34703,7 @@ var REPLAY_REGISTRY_VARIABLES = {
 };
 
 // ../bitfab-plugin-lib/dist/flows/setup.js
-var setupFlow = Flow.parse({
+var setupFlow = bitfabKit.defineFlow({
   schemaVersion: 1,
   id: "setup",
   title: "Bitfab Setup",
@@ -35995,7 +36394,7 @@ If **zero** valid candidates remain, skip to step {{step:analyze-repo/report}} a
 });
 
 // ../bitfab-plugin-lib/dist/flows/update.js
-var updateFlow = Flow.parse({
+var updateFlow = bitfabKit.defineFlow({
   schemaVersion: 1,
   id: "update",
   title: "Bitfab Update",
@@ -36047,45 +36446,58 @@ var updateFlow = Flow.parse({
     plugin: "Update only the Bitfab plugin to the latest version.",
     sdk: "Update only the Bitfab SDK to the latest version."
   },
-  languageColumnHeaders: {
-    detection: "Detection (from workspace/repo)",
-    outdated: "Command (run from workspace dir)",
-    update: "Command"
-  },
-  languages: [
-    {
-      name: "typescript",
-      displayName: "TypeScript",
-      imports: "`import .* from [\"'](?:@bitfab/sdk|bitfab)[\"']` or `require\\([\"'](?:@bitfab/sdk|bitfab)[\"']\\)`",
-      detection: "`pnpm-lock.yaml` at repo root \u2192 pnpm; `yarn.lock` \u2192 yarn; `bun.lock` \u2192 bun; otherwise npm",
-      outdated: "`pnpm outdated @bitfab/sdk --json` / `npm outdated @bitfab/sdk --json` / `yarn outdated @bitfab/sdk` / `bun outdated @bitfab/sdk`",
-      update: "If `renameFrom` is set (legacy `bitfab` package): remove the old package and add the new one in a single command: `pnpm remove bitfab && pnpm add @bitfab/sdk@latest` / `npm uninstall bitfab && npm install @bitfab/sdk@latest` / `yarn remove bitfab && yarn add @bitfab/sdk@latest` / `bun remove bitfab && bun add @bitfab/sdk@latest`. Then update imports in source files from `bitfab` to `@bitfab/sdk`. If no rename: `pnpm update @bitfab/sdk@latest` / `yarn upgrade @bitfab/sdk@latest` / `bun update @bitfab/sdk` / `npm install @bitfab/sdk@latest`"
-    },
-    {
-      name: "python",
-      displayName: "Python",
-      imports: "`^\\s*(from|import) bitfab\\b`",
-      detection: "`uv.lock` \u2192 uv; `poetry.lock` \u2192 poetry; otherwise pip",
-      outdated: "`uv pip list --outdated --format=json` / `poetry show -o bitfab-py` / `pip list --outdated --format=json`",
-      update: "`uv add bitfab-py@latest` / `poetry add bitfab-py@latest` / `pip install -U bitfab-py` (and bump the pin in `requirements.txt` via Edit)"
-    },
-    {
-      name: "ruby",
-      displayName: "Ruby",
-      imports: "`require ['\"]bitfab['\"]`",
-      detection: "`Gemfile.lock`",
-      outdated: "`bundle outdated bitfab --parseable`",
-      update: "`bundle update bitfab`"
-    },
-    {
-      name: "go",
-      displayName: "Go",
-      imports: '`"github.com/Project-White-Rabbit/bitfab-go"`',
-      detection: "`go.mod`",
-      outdated: "`go list -m -u -json github.com/Project-White-Rabbit/bitfab-go`",
-      update: "`go get github.com/Project-White-Rabbit/bitfab-go@latest && go mod tidy`"
+  tables: {
+    languages: {
+      keyHeader: "Language",
+      columns: {
+        detection: "Detection (from workspace/repo)",
+        outdated: "Command (run from workspace dir)",
+        update: "Command"
+      },
+      rows: [
+        {
+          key: "typescript",
+          label: "TypeScript",
+          cells: {
+            imports: "`import .* from [\"'](?:@bitfab/sdk|bitfab)[\"']` or `require\\([\"'](?:@bitfab/sdk|bitfab)[\"']\\)`",
+            detection: "`pnpm-lock.yaml` at repo root \u2192 pnpm; `yarn.lock` \u2192 yarn; `bun.lock` \u2192 bun; otherwise npm",
+            outdated: "`pnpm outdated @bitfab/sdk --json` / `npm outdated @bitfab/sdk --json` / `yarn outdated @bitfab/sdk` / `bun outdated @bitfab/sdk`",
+            update: "If `renameFrom` is set (legacy `bitfab` package): remove the old package and add the new one in a single command: `pnpm remove bitfab && pnpm add @bitfab/sdk@latest` / `npm uninstall bitfab && npm install @bitfab/sdk@latest` / `yarn remove bitfab && yarn add @bitfab/sdk@latest` / `bun remove bitfab && bun add @bitfab/sdk@latest`. Then update imports in source files from `bitfab` to `@bitfab/sdk`. If no rename: `pnpm update @bitfab/sdk@latest` / `yarn upgrade @bitfab/sdk@latest` / `bun update @bitfab/sdk` / `npm install @bitfab/sdk@latest`"
+          }
+        },
+        {
+          key: "python",
+          label: "Python",
+          cells: {
+            imports: "`^\\s*(from|import) bitfab\\b`",
+            detection: "`uv.lock` \u2192 uv; `poetry.lock` \u2192 poetry; otherwise pip",
+            outdated: "`uv pip list --outdated --format=json` / `poetry show -o bitfab-py` / `pip list --outdated --format=json`",
+            update: "`uv add bitfab-py@latest` / `poetry add bitfab-py@latest` / `pip install -U bitfab-py` (and bump the pin in `requirements.txt` via Edit)"
+          }
+        },
+        {
+          key: "ruby",
+          label: "Ruby",
+          cells: {
+            imports: "`require ['\"]bitfab['\"]`",
+            detection: "`Gemfile.lock`",
+            outdated: "`bundle outdated bitfab --parseable`",
+            update: "`bundle update bitfab`"
+          }
+        },
+        {
+          key: "go",
+          label: "Go",
+          cells: {
+            imports: '`"github.com/Project-White-Rabbit/bitfab-go"`',
+            detection: "`go.mod`",
+            outdated: "`go list -m -u -json github.com/Project-White-Rabbit/bitfab-go`",
+            update: "`go get github.com/Project-White-Rabbit/bitfab-go@latest && go mod tidy`"
+          }
+        }
+      ]
     }
-  ],
+  },
   phases: [
     {
       id: "setup",
@@ -36193,7 +36605,7 @@ If there are **no lines** inside \`<bitfab-sdk-status>\`, the programmatic check
           body: `The programmatic detection is regex-based and only knows the workspace formats we hand-coded (pnpm/npm/yarn workspaces, uv workspaces, go.work). It can miss unusual monorepo layouts, vendored SDKs, or projects using package managers we don't parse. **Always run this verification** before offering updates.
 
 - Grep the project for SDK imports (run these in parallel):
-{{languages:imports}}
+  {{list:languages:imports}}
 - For each import, find its workspace directory by walking up to the nearest \`package.json\` / \`pyproject.toml\` / \`Gemfile\` / \`go.mod\`.
 - Compare that set against the \`workspacePath\` values in \`<bitfab-sdk-status>\`.
 - For each workspace that has imports but **no** corresponding status entry, treat it as a missed detection: ask the user which package manager that workspace uses, then go to step {{step:sdk/agent-fallback}} for it (same flow as \`remoteCheckFailed: true\`).
@@ -36207,7 +36619,7 @@ If there are **no lines** inside \`<bitfab-sdk-status>\`, the programmatic check
           title: "Agent fallback for `remoteCheckFailed` or detection gaps",
           body: `For each entry where \`remoteCheckFailed: true\`, or any workspace discovered only in step {{step:sdk/verify-with-agent}}, run the package manager's native outdated command from the workspace directory. The command is authoritative, it respects private registries, mirrors, and offline caches.
 
-{{languages:detection,outdated}}
+{{table:languages:detection,outdated}}
 
 Use the real latest from the command's output in place of \`latest\` when deciding whether to offer an upgrade.`,
           next: "sdk/ask-batch"
@@ -36291,7 +36703,7 @@ When no outdated workspaces remain, exit and acknowledge.`,
           title: "Run the update for the chosen workspace",
           body: `Detect the package manager from the lockfiles and run the update **from the workspace directory** (not repo root, matters in monorepos):
 
-{{languages:update}}
+{{table:languages:update}}
 
 After the update, Read the manifest to verify the new version and confirm to the user. If a rename was performed (\`renameFrom\` was set), also grep the workspace for old import paths and update them (e.g. \`from "bitfab"\` to \`from "@bitfab/sdk"\`). Then return to the per-workspace prompt for the next workspace.`,
           next: "sdk/ask-per-workspace"
@@ -36303,7 +36715,7 @@ After the update, Read the manifest to verify the new version and confirm to the
           title: "Run updates for every outdated workspace",
           body: `For every workspace with \`updateAvailable: true\`, detect the package manager from the lockfiles and run the update **from each workspace directory** (not repo root):
 
-{{languages:update}}
+{{table:languages:update}}
 
 After each update, Read the manifest to verify the new version and confirm to the user. If a rename was performed (\`renameFrom\` was set), also grep the workspace for old import paths and update them (e.g. \`from "bitfab"\` to \`from "@bitfab/sdk"\`).`,
           next: null
@@ -36513,7 +36925,7 @@ var SUPPORTED_COMMANDS = /* @__PURE__ */ new Set([
   "switchOrg",
   "update"
 ]);
-var setupV2Flow = Flow.parse({
+var setupV2Flow = bitfabKit.defineFlow({
   ...setupFlow,
   id: "setup-v2",
   title: "Bitfab Terminal Setup",
@@ -44575,8 +44987,8 @@ var Protocol = class {
           }
         }
       },
-      listTasks: (cursor) => {
-        return taskStore.listTasks(cursor, sessionId);
+      listTasks: (cursor2) => {
+        return taskStore.listTasks(cursor2, sessionId);
       }
     };
   }
@@ -44866,8 +45278,8 @@ var ExperimentalServerTasks = class {
    *
    * @experimental
    */
-  async listTasks(cursor, options) {
-    return this._server.listTasks(cursor ? { cursor } : void 0, options);
+  async listTasks(cursor2, options) {
+    return this._server.listTasks(cursor2 ? { cursor: cursor2 } : void 0, options);
   }
   /**
    * Cancels a running task.
@@ -48666,7 +49078,7 @@ import * as p8 from "@clack/prompts";
 // src/setupV2Verification.ts
 import { spawnSync as spawnSync4 } from "child_process";
 import { existsSync, readFileSync } from "fs";
-import { basename, relative, resolve as resolve2 } from "path";
+import { basename as basename2, relative, resolve as resolve2 } from "path";
 var MUTATING_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write"]);
 var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".cjs",
@@ -48728,7 +49140,7 @@ function isReplayRuntimeCommand(command, registryPath) {
     return false;
   }
   const displayedPath = registryPath.replaceAll("\\", "/");
-  const registryName = basename(registryPath);
+  const registryName = basename2(registryPath);
   return /(?:^|\s)(?:[^\s]+\s+)*bitfab-replay(?:\s|$)/i.test(command) && /(?:^|\s)--registry(?:\s|=)/.test(command) && (command.includes(displayedPath) || command.includes(registryName));
 }
 function isWorkflowRuntimeCommand(command) {
@@ -48936,7 +49348,7 @@ var SetupV2VerificationGate = class {
           message: "Edited text files must end with exactly one newline."
         });
       }
-      if (/BITFAB_API_KEY\s*=/.test(source) && basename(path15).startsWith(".env") && !/BITFAB_SERVICE_URL\s*=/.test(source)) {
+      if (/BITFAB_API_KEY\s*=/.test(source) && basename2(path15).startsWith(".env") && !/BITFAB_SERVICE_URL\s*=/.test(source)) {
         issues.push({
           code: "missing-service-url",
           path: displayPath(this.cwd, path15),
@@ -49019,7 +49431,7 @@ var SetupV2VerificationGate = class {
         }
       }
       const registryRevision = this.touchedPaths.get(registryPath) ?? 0;
-      const registryName = basename(registryPath);
+      const registryName = basename2(registryPath);
       const registryVerified = this.verificationCommands.some(
         ({ command, revision }) => revision >= registryRevision && (command.includes(registryPath) || command.includes(displayPath(this.cwd, registryPath)) || command.includes(registryName) || /\btsc\b/.test(command) && projectTypecheckCoversRegistry(this.cwd, registryPath))
       );