@kody-ade/kody-engine 0.4.373 → 0.4.374

package/dist/bin/kody.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@kody-ade/kody-engine",
-      version: "0.4.373",
+      version: "0.4.374",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -1064,8 +1064,8 @@ function formatAssistant(msg, _opts) {
   const lines = [];
   for (const block of content) {
     if (block.type === "text") {
-      const text = block.text.trim();
-      if (text) lines.push(text);
+      const text2 = block.text.trim();
+      if (text2) lines.push(text2);
     } else if (block.type === "tool_use") {
       const tu = block;
       lines.push(`\u2192 ${tu.name}${summarizeToolInput(tu.name, tu.input)}`);
@@ -1079,14 +1079,14 @@ function formatUserToolResult(msg, opts) {
   for (const block of content) {
     if (block.type === "tool_result") {
       const tr = block;
-      const text = stringifyToolContent(tr.content);
-      const lineCount = text.split("\n").length;
-      const sizeBytes = text.length;
+      const text2 = stringifyToolContent(tr.content);
+      const lineCount = text2.split("\n").length;
+      const sizeBytes = text2.length;
       const flag = tr.is_error ? " ERROR" : "";
       const summary = `  \u21B3${flag} ${lineCount} lines, ${formatBytes(sizeBytes)}`;
       if (opts.verbose) {
         lines.push(`${summary}
-${truncate2(text, 4e3)}`);
+${truncate2(text2, 4e3)}`);
       } else {
         lines.push(summary);
       }
@@ -1612,7 +1612,7 @@ function cmsHeaders(opts) {
     }
   };
 }
-async function callDashboardCms(opts, path51, init = {}) {
+async function callDashboardCms(opts, path52, init = {}) {
   const baseUrl = dashboardBaseUrl(opts);
   if (!baseUrl) {
     return {
@@ -1624,7 +1624,7 @@ async function callDashboardCms(opts, path51, init = {}) {
   const headerResult = cmsHeaders(opts);
   if (!headerResult.ok) return headerResult;
   try {
-    const res = await fetch(`${baseUrl}${path51}`, {
+    const res = await fetch(`${baseUrl}${path52}`, {
       ...init,
       headers: {
         ...headerResult.headers,
@@ -1696,8 +1696,8 @@ function documentArg(value) {
 function normalizeCmsDocumentIdInput(input) {
   const trimmed = stripWrappingQuotes(input.trim());
   const withoutQuery = trimmed.split(/[?#]/, 1)[0] ?? trimmed;
-  const path51 = parseDocumentPath(withoutQuery);
-  return path51 ?? parseDocumentIdSegment(withoutQuery) ?? withoutQuery;
+  const path52 = parseDocumentPath(withoutQuery);
+  return path52 ?? parseDocumentIdSegment(withoutQuery) ?? withoutQuery;
 }
 function stripWrappingQuotes(value) {
   let current = value;
@@ -1708,9 +1708,9 @@ function stripWrappingQuotes(value) {
   }
 }
 function parseDocumentPath(value) {
-  const path51 = value.startsWith("http://") || value.startsWith("https://") ? urlPathname(value) : value;
-  if (!path51?.includes("/content/entries/")) return null;
-  const parts = path51.split("/").filter(Boolean).map(decodePathPart);
+  const path52 = value.startsWith("http://") || value.startsWith("https://") ? urlPathname(value) : value;
+  if (!path52?.includes("/content/entries/")) return null;
+  const parts = path52.split("/").filter(Boolean).map(decodePathPart);
   const entriesIndex = parts.findIndex((part, index) => part === "content" && parts[index + 1] === "entries");
   const idPart = parts[entriesIndex + 3];
   if (!idPart || idPart === "new") return null;
@@ -1970,7 +1970,12 @@ function stringList(value) {
 function parseCapabilityWorkflow(value) {
   const stepsRaw = Array.isArray(value) ? value : value && typeof value === "object" && Array.isArray(value.steps) ? value.steps : [];
   const steps = stepsRaw.map(parseWorkflowStep).filter((step) => step !== null);
-  return steps.length > 0 ? { steps } : void 0;
+  if (steps.length === 0) return void 0;
+  const startAt = value && typeof value === "object" && !Array.isArray(value) ? stringField(value.startAt) : void 0;
+  return {
+    steps,
+    ...startAt && isSafeSlug(startAt) ? { startAt } : {}
+  };
 }
 function parseWorkflowStep(value) {
   if (typeof value === "string") {
@@ -1982,6 +1987,7 @@ function parseWorkflowStep(value) {
   const capability = stringField(raw.capability ?? raw.action);
   if (!capability || !isSafeSlug(capability)) return null;
   const implementation = stringField(raw.implementation);
+  const id = stringField(raw.id);
   const action = stringField(raw.action);
   const evidence = stringField(raw.evidence);
   const agent = stringField(raw.agent);
@@ -1989,9 +1995,12 @@ function parseWorkflowStep(value) {
   const target = stringField(raw.target);
   const targetFact = stringField(raw.targetFact ?? raw.target_fact);
   const cliArgs = raw.cliArgs;
+  const inputs = parseWorkflowInputs(raw.inputs);
+  const next = parseWorkflowTransitions(raw.next);
   const report = parseReportPublication(raw.report);
   return {
     capability,
+    ...id && isSafeSlug(id) ? { id } : {},
     ...action && isSafeSlug(action) ? { action } : {},
     ...implementation && isSafeSlug(implementation) ? { implementation } : {},
     ...evidence ? { evidence } : {},
@@ -2000,12 +2009,45 @@ function parseWorkflowStep(value) {
     ...agent && isSafeSlug(agent) ? { agent } : {},
     ...reason ? { reason } : {},
     ...cliArgs && typeof cliArgs === "object" && !Array.isArray(cliArgs) ? { cliArgs } : {},
+    ...inputs ? { inputs } : {},
+    ...next ? { next } : {},
     ...isPlainObject(raw.runWhen) ? { runWhen: raw.runWhen } : {},
     ...stringList(raw.continueOn ?? raw.continue_on).length > 0 ? { continueOn: stringList(raw.continueOn ?? raw.continue_on) } : {},
     ...raw.saveReport === true ? { saveReport: true } : {},
     ...report ? { report } : {}
   };
 }
+function parseWorkflowInputs(value) {
+  if (!isPlainObject(value)) return void 0;
+  const inputs = {};
+  for (const [name, raw] of Object.entries(value)) {
+    if (!isSafeSlug(name) || !isPlainObject(raw)) continue;
+    const from = stringField(raw.from);
+    if (!from) continue;
+    inputs[name] = { from };
+  }
+  return Object.keys(inputs).length > 0 ? inputs : void 0;
+}
+function parseWorkflowTransitions(value) {
+  const rawTransitions = Array.isArray(value) ? value : value === void 0 ? [] : [value];
+  const transitions = rawTransitions.map((raw) => {
+    if (typeof raw === "string") {
+      const to2 = raw.trim();
+      return isSafeSlug(to2) ? { to: to2 } : null;
+    }
+    if (!isPlainObject(raw)) return null;
+    const to = stringField(raw.to);
+    if (!to || !isSafeSlug(to)) return null;
+    const maxIterations = typeof raw.maxIterations === "number" && Number.isInteger(raw.maxIterations) && raw.maxIterations > 0 ? raw.maxIterations : void 0;
+    return {
+      to,
+      ...isPlainObject(raw.when) ? { when: raw.when } : {},
+      ...raw.default === true ? { default: true } : {},
+      ...maxIterations ? { maxIterations } : {}
+    };
+  }).filter((transition) => transition !== null);
+  return transitions.length > 0 ? transitions : void 0;
+}
 function parseReportPublication(value) {
   if (!isPlainObject(value)) return void 0;
   const type = stringField(value.type);
@@ -2317,8 +2359,8 @@ function resolveCapabilityFolder(slug, projectCapabilitiesRoot = getProjectCapab
   }
   return null;
 }
-function getCapabilityActionInputs(action) {
-  const resolved = resolveCapabilityAction(action);
+function getCapabilityActionInputs(action, projectCapabilitiesRoot = getProjectCapabilitiesRoot()) {
+  const resolved = resolveCapabilityAction(action, projectCapabilitiesRoot);
   if (!resolved) return null;
   return getProfileInputs(resolved.implementation);
 }
@@ -2637,20 +2679,20 @@ function readLedger(label) {
     const raw = gh(["issue", "list", "--state", "open", "--label", label, "--limit", "5", "--json", "number,body"]);
     const issues = JSON.parse(raw);
     if (issues.length === 0) return { found: false, payload: null };
-    const issue = issues.sort((a, b) => a.number - b.number)[0];
-    const body = issue?.body ?? "";
+    const issue2 = issues.sort((a, b) => a.number - b.number)[0];
+    const body = issue2?.body ?? "";
     const startIdx = body.indexOf(startTag);
     const endIdx = body.indexOf(endTag);
     if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
-      return { found: true, issueNumber: issue?.number, payload: null };
+      return { found: true, issueNumber: issue2?.number, payload: null };
     }
     const between = body.slice(startIdx + startTag.length, endIdx);
     const fenceMatch = between.match(/```json\s*([\s\S]*?)```/);
-    if (!fenceMatch) return { found: true, issueNumber: issue?.number, payload: null };
+    if (!fenceMatch) return { found: true, issueNumber: issue2?.number, payload: null };
     try {
-      return { found: true, issueNumber: issue?.number, payload: JSON.parse(fenceMatch[1]) };
+      return { found: true, issueNumber: issue2?.number, payload: JSON.parse(fenceMatch[1]) };
     } catch {
-      return { found: true, issueNumber: issue?.number, payload: null };
+      return { found: true, issueNumber: issue2?.number, payload: null };
     }
   } catch (err) {
     return { found: false, payload: { error: err instanceof Error ? err.message : String(err) } };
@@ -2698,12 +2740,7 @@ function readCheckRuns(repoSlug, ref, ignoreNames) {
   let rawStatuses = "";
   try {
     rawStatuses = gh(
-      [
-        "api",
-        `repos/${repoSlug}/commits/${sha}/status`,
-        "--jq",
-        ".statuses[] | {context, state, target_url}"
-      ],
+      ["api", `repos/${repoSlug}/commits/${sha}/status`, "--jq", ".statuses[] | {context, state, target_url}"],
       ghOptions
     );
   } catch {
@@ -2745,14 +2782,14 @@ ${marker}`
     return { error: err instanceof Error ? err.message : String(err) };
   }
 }
-function ensureComment(repoSlug, issue, key, body) {
+function ensureComment(repoSlug, issue2, key, body) {
   const marker = commentMarker(key);
   try {
-    const raw = gh(["issue", "view", String(issue), "-R", repoSlug, "--json", "comments"]);
+    const raw = gh(["issue", "view", String(issue2), "-R", repoSlug, "--json", "comments"]);
     const parsed = JSON.parse(raw);
     const already = (parsed.comments ?? []).some((c) => (c.body ?? "").includes(marker));
     if (already) return { posted: false };
-    gh(["issue", "comment", String(issue), "-R", repoSlug, "--body-file", "-"], { input: `${body}
+    gh(["issue", "comment", String(issue2), "-R", repoSlug, "--body-file", "-"], { input: `${body}
 
 ${marker}` });
     return { posted: true };
@@ -2794,9 +2831,9 @@ function dispatchWorkflow(workflowFile, capability, issueNumber, repoSlug, ref)
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
-function startCapability(workflowFile, name, issue, repoSlug, ref) {
+function startCapability(workflowFile, name, issue2, repoSlug, ref) {
   const acceptsIssue = capabilityAcceptsIssue(name);
-  const forwardedIssue = acceptsIssue === false ? void 0 : issue;
+  const forwardedIssue = acceptsIssue === false ? void 0 : issue2;
   return dispatchWorkflow(workflowFile, name, forwardedIssue, repoSlug, ref);
 }
 function capabilityAcceptsIssue(capability) {
@@ -2862,8 +2899,8 @@ function capabilityToolDefinitions(opts) {
     handler: async (args) => {
       const pr = Number(args.pr);
       const result = dispatchVerb(workflowFile, opts.repoSlug, verb, pr);
-      const text = result.ok ? `Dispatched \`${verb}\` on PR #${pr}. The repair runs in its own workflow_dispatch \u2014 wait for the next tick to see the new headSha.` : `Dispatch failed for \`${verb}\` on PR #${pr}: ${result.error}`;
-      return { content: [{ type: "text", text }] };
+      const text2 = result.ok ? `Dispatched \`${verb}\` on PR #${pr}. The repair runs in its own workflow_dispatch \u2014 wait for the next tick to see the new headSha.` : `Dispatch failed for \`${verb}\` on PR #${pr}: ${result.error}`;
+      return { content: [{ type: "text", text: text2 }] };
     }
   });
   const syncTool = makeDispatch(
@@ -2889,8 +2926,8 @@ function capabilityToolDefinitions(opts) {
       const pr = Number(args.pr);
       const body = String(args.body ?? "");
       const result = postRecommendation(opts.repoSlug, pr, opts.operatorMention, body, opts.capabilitySlug);
-      const text = result.ok ? result.posted ? `Recommendation posted on PR #${pr}.` : `Recommendation already exists on PR #${pr}; skipped.` : `Recommendation failed on PR #${pr}: ${result.error}`;
-      return { content: [{ type: "text", text }] };
+      const text2 = result.ok ? result.posted ? `Recommendation posted on PR #${pr}.` : `Recommendation already exists on PR #${pr}; skipped.` : `Recommendation failed on PR #${pr}: ${result.error}`;
+      return { content: [{ type: "text", text: text2 }] };
     }
   };
   const ledgerTool = {
@@ -2964,10 +3001,10 @@ function capabilityToolDefinitions(opts) {
       body: z3.string().min(1).describe("Comment body markdown.")
     },
     handler: async (args) => {
-      const issue = Number(args.issue);
+      const issue2 = Number(args.issue);
       const key = String(args.key ?? "");
       const body = String(args.body ?? "");
-      const result = ensureComment(opts.repoSlug, issue, key, body);
+      const result = ensureComment(opts.repoSlug, issue2, key, body);
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   };
@@ -2982,19 +3019,13 @@ function capabilityToolDefinitions(opts) {
     handler: async (args) => {
       const name = String(args.name ?? "");
       const rawIssue = args.issue ?? args.issueNumber;
-      const issue = rawIssue == null ? void 0 : Number(rawIssue);
-      if (issue !== void 0 && (!Number.isFinite(issue) || issue <= 0)) {
+      const issue2 = rawIssue == null ? void 0 : Number(rawIssue);
+      if (issue2 !== void 0 && (!Number.isFinite(issue2) || issue2 <= 0)) {
         return { content: [{ type: "text", text: "Start failed: `issue` must be a positive number when provided." }] };
       }
-      const result = startCapability(
-        workflowFile,
-        name,
-        issue,
-        opts.repoSlug,
-        opts.defaultBranch
-      );
-      const text = JSON.stringify(result);
-      return { content: [{ type: "text", text }] };
+      const result = startCapability(workflowFile, name, issue2, opts.repoSlug, opts.defaultBranch);
+      const text2 = JSON.stringify(result);
+      return { content: [{ type: "text", text: text2 }] };
     }
   };
   const cmsTools = dashboardCmsToolDefinitions({
@@ -3209,8 +3240,8 @@ function classifySubtype(subtype) {
   if (lower.includes("error")) return "model_error";
   return "generic_failed";
 }
-function isClaudeLoginRequiredText(text) {
-  const normalized = text.toLowerCase();
+function isClaudeLoginRequiredText(text2) {
+  const normalized = text2.toLowerCase();
   return normalized.includes("not logged in") && normalized.includes("/login");
 }
 function resolveTurnTimeoutMs(opts) {
@@ -3549,9 +3580,9 @@ async function runAgent(opts) {
             outcome = "completed";
             outcomeKind = "ok";
             sawTerminalSuccess = true;
-            const text = (typeof m.result === "string" ? m.result : "").trim();
-            if (isClaudeLoginRequiredText(text)) sawLoginRequired = true;
-            if (text) resultTexts.push(text);
+            const text2 = (typeof m.result === "string" ? m.result : "").trim();
+            if (isClaudeLoginRequiredText(text2)) sawLoginRequired = true;
+            if (text2) resultTexts.push(text2);
           } else {
             outcome = "failed";
             outcomeKind = classifySubtype(m.subtype);
@@ -3966,9 +3997,9 @@ var init_agencyBoundaryEval = __esm({
 });
 
 // src/capabilityReport.ts
-function parseCapabilityReportsFromText(text) {
+function parseCapabilityReportsFromText(text2) {
   const reports = [];
-  for (const match of text.matchAll(REPORT_LINE)) {
+  for (const match of text2.matchAll(REPORT_LINE)) {
     const raw = match[1]?.trim();
     if (!raw) continue;
     try {
@@ -4096,9 +4127,9 @@ var init_evidenceState = __esm({
 });
 
 // src/capabilityResult.ts
-function parseCapabilityResultsFromText(text) {
+function parseCapabilityResultsFromText(text2) {
   const results = [];
-  for (const match of text.matchAll(RESULT_LINE)) {
+  for (const match of text2.matchAll(RESULT_LINE)) {
     const raw = match[1]?.trim();
     if (!raw) continue;
     try {
@@ -5419,8 +5450,8 @@ function loadProjectConventions(projectDir) {
   return out;
 }
 function parseAgentResult(finalText) {
-  const text = (finalText || "").trim();
-  if (!text)
+  const text2 = (finalText || "").trim();
+  if (!text2)
     return {
       done: false,
       commitMessage: "",
@@ -5434,7 +5465,7 @@ function parseAgentResult(finalText) {
   const MARKDOWN_PREFIX = "[\\s>*_#`~\\-]*";
   const FAILED_RE = new RegExp(`(?:^|\\n)${MARKDOWN_PREFIX}FAILED${MARKDOWN_PREFIX}\\s*:\\s*(.+?)\\s*$`, "s");
   const DONE_RE = new RegExp(`(?:^|\\n)${MARKDOWN_PREFIX}DONE\\b`);
-  const scanText = stripFencedCodeBlocks(text);
+  const scanText = stripFencedCodeBlocks(text2);
   const failedMatch = scanText.match(FAILED_RE);
   if (failedMatch) {
     return {
@@ -5449,32 +5480,32 @@ function parseAgentResult(finalText) {
     };
   }
   const hasDoneMarker = DONE_RE.test(scanText);
-  const hasCommitMsg = /^[\s>*_#`~-]*COMMIT_MSG\s*:/im.test(text);
-  const hasPrSummary = /^[\s>*_#`~-]*PR_SUMMARY\s*:/im.test(text);
+  const hasCommitMsg = /^[\s>*_#`~-]*COMMIT_MSG\s*:/im.test(text2);
+  const hasPrSummary = /^[\s>*_#`~-]*PR_SUMMARY\s*:/im.test(text2);
   const markerMissing = !hasDoneMarker && !hasCommitMsg && !hasPrSummary;
-  const commitMatch = text.match(/^[\s>*_#`~-]*COMMIT_MSG[\s>*_#`~-]*\s*:\s*(.+)$/im);
+  const commitMatch = text2.match(/^[\s>*_#`~-]*COMMIT_MSG[\s>*_#`~-]*\s*:\s*(.+)$/im);
   const commitMessage = commitMatch ? stripMarkdownEmphasis(commitMatch[1]) : "";
   const feedbackActions = extractBlock(
-    text,
+    text2,
     /(?:^|\n)[ \t]*FEEDBACK_ACTIONS\s*:[ \t]*\n/i,
     /(?:^|\n)[ \t]*(?:PLAN_DEVIATIONS|COMMIT_MSG|PR_SUMMARY|PRIOR_ART)\s*:/i
   );
   let planDeviations = extractBlock(
-    text,
+    text2,
     /(?:^|\n)[ \t]*PLAN_DEVIATIONS\s*:[ \t]*\n/i,
     /(?:^|\n)[ \t]*(?:COMMIT_MSG|PR_SUMMARY|FEEDBACK_ACTIONS|PRIOR_ART)\s*:/i
   );
   if (!planDeviations) {
-    const inline = text.match(/(?:^|\n)[ \t]*PLAN_DEVIATIONS\s*:[ \t]*(.+?)[ \t]*(?:\n|$)/i);
+    const inline = text2.match(/(?:^|\n)[ \t]*PLAN_DEVIATIONS\s*:[ \t]*(.+?)[ \t]*(?:\n|$)/i);
     if (inline) planDeviations = inline[1].trim();
   }
   let priorArt = "";
-  const priorArtInline = text.match(/(?:^|\n)[ \t]*PRIOR_ART\s*:[ \t]*(.+?)[ \t]*(?:\n|$)/i);
+  const priorArtInline = text2.match(/(?:^|\n)[ \t]*PRIOR_ART\s*:[ \t]*(.+?)[ \t]*(?:\n|$)/i);
   if (priorArtInline) priorArt = priorArtInline[1].trim();
-  const summaryStart = text.search(/(^|\n)[ \t]*PR_SUMMARY\s*:[ \t]*\n/i);
+  const summaryStart = text2.search(/(^|\n)[ \t]*PR_SUMMARY\s*:[ \t]*\n/i);
   let prSummary = "";
   if (summaryStart !== -1) {
-    const afterMarker = text.slice(summaryStart).replace(/^[\s\S]*?PR_SUMMARY\s*:[ \t]*\n/i, "");
+    const afterMarker = text2.slice(summaryStart).replace(/^[\s\S]*?PR_SUMMARY\s*:[ \t]*\n/i, "");
     prSummary = afterMarker.replace(/\n\s*```\s*$/g, "").replace(/```\s*$/g, "").trim();
   }
   return {
@@ -5494,10 +5525,10 @@ function stripMarkdownEmphasis(s) {
 function stripFencedCodeBlocks(s) {
   return s.replace(/```[\s\S]*?```/g, "").replace(/~~~[\s\S]*?~~~/g, "");
 }
-function extractBlock(text, startMarker, endMarker) {
-  const startIdx = text.search(startMarker);
+function extractBlock(text2, startMarker, endMarker) {
+  const startIdx = text2.search(startMarker);
   if (startIdx === -1) return "";
-  const afterStart = text.slice(startIdx).replace(startMarker, "");
+  const afterStart = text2.slice(startIdx).replace(startMarker, "");
   const endIdx = afterStart.search(endMarker);
   const body = endIdx === -1 ? afterStart : afterStart.slice(0, endIdx);
   return body.replace(/\n\s*```\s*$/g, "").trim();
@@ -5673,9 +5704,9 @@ function collectPages(memoryAbs) {
 }
 function extractQueryTerms(ctx) {
   const terms = [];
-  const issue = ctx.data.issue;
+  const issue2 = ctx.data.issue;
   const pr = ctx.data.pr;
-  if (issue?.title) terms.push(...tokenize(issue.title));
+  if (issue2?.title) terms.push(...tokenize(issue2.title));
   if (pr?.title) terms.push(...tokenize(pr.title));
   return Array.from(new Set(terms)).slice(0, 20);
 }
@@ -7689,10 +7720,10 @@ var init_state2 = __esm({
     "use strict";
     VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "done"]);
     GoalStateError = class extends Error {
-      constructor(path51, message) {
-        super(`Invalid goal state at ${path51}:
+      constructor(path52, message) {
+        super(`Invalid goal state at ${path52}:
   ${message}`);
-        this.path = path51;
+        this.path = path52;
         this.name = "GoalStateError";
       }
       path;
@@ -7705,9 +7736,9 @@ import * as fs25 from "fs";
 function stageGoalRunLogEvent(data, goalId, event, at = nowIso()) {
   const logs = goalRunLogs(data);
   const existing = logs[goalId];
-  const path51 = existing?.path ?? goalRunLogPath(goalId, data);
+  const path52 = existing?.path ?? goalRunLogPath(goalId, data);
   logs[goalId] = {
-    path: path51,
+    path: path52,
     events: [...existing?.events ?? [], buildGoalRunLogEvent(data, goalId, event, at)]
   };
 }
@@ -8726,6 +8757,290 @@ var init_typeDefinitions = __esm({
   }
 });
 
+// src/workflowValidation.ts
+function validateWorkflow(value, options = {}) {
+  const issues = [];
+  const workflow = asRecord2(value);
+  const rawSteps = Array.isArray(value) ? value : Array.isArray(workflow?.steps) ? workflow.steps : [];
+  const maxSteps = options.maxSteps ?? 100;
+  const maxTransitions = options.maxTransitionsPerStep ?? 20;
+  const maxLoopIterations = options.maxLoopIterations ?? 100;
+  if (rawSteps.length === 0) {
+    issue(issues, "steps_required", "steps", "workflow must contain at least one step");
+    return issues;
+  }
+  if (rawSteps.length > maxSteps) {
+    issue(issues, "too_many_steps", "steps", `workflow has ${rawSteps.length} steps; maximum is ${maxSteps}`);
+  }
+  const graphMode = workflow?.startAt !== void 0 || rawSteps.some((entry) => {
+    const step = asRecord2(entry);
+    return Boolean(step && (step.id !== void 0 || step.next !== void 0 || step.inputs !== void 0));
+  });
+  const steps = rawSteps.map(
+    (entry) => typeof entry === "string" ? { capability: entry } : asRecord2(entry)
+  );
+  const ids = [];
+  steps.forEach((step, index) => {
+    const base = `steps[${index}]`;
+    if (!step) {
+      issue(issues, "invalid_step", base, "workflow step must be a capability name or an object");
+      return;
+    }
+    for (const field of Object.keys(step)) {
+      if (!SUPPORTED_STEP_FIELDS.has(field)) {
+        issue(issues, "unsupported_step_field", `${base}.${field}`, `workflow step field ${field} is not supported`);
+      }
+    }
+    const capability = text(step.capability ?? step.action);
+    if (!capability || !SAFE_NAME.test(capability)) {
+      issue(issues, "invalid_capability", `${base}.capability`, "workflow step must name a valid capability");
+    } else if (options.knownCapabilities && !options.knownCapabilities.has(capability)) {
+      issue(
+        issues,
+        "unknown_capability",
+        `${base}.capability`,
+        `workflow step references unknown capability ${capability}`
+      );
+    }
+    if (graphMode) {
+      const id = text(step.id);
+      if (!id || !SAFE_NAME.test(id)) {
+        issue(issues, "invalid_step_id", `${base}.id`, "graph workflow steps must each have a valid id");
+      } else {
+        ids.push(id);
+      }
+    }
+    validateDataMatch(step.runWhen, `${base}.runWhen`, issues);
+    const inputs = asRecord2(step.inputs);
+    if (step.inputs !== void 0 && !inputs) {
+      issue(issues, "invalid_inputs", `${base}.inputs`, "workflow step inputs must be an object");
+    }
+    if (inputs) {
+      for (const [name, mapping] of Object.entries(inputs)) {
+        const inputPath = `${base}.inputs.${name}`;
+        if (!SAFE_NAME.test(name)) issue(issues, "invalid_input_name", inputPath, `invalid input name ${name}`);
+        const from = text(asRecord2(mapping)?.from);
+        if (!from || !SAFE_DATA_PATH.test(from)) {
+          issue(
+            issues,
+            "invalid_data_path",
+            `${inputPath}.from`,
+            `workflow input ${name} must read from facts, evidence, artifacts, result, workflow, or lastOutcome`
+          );
+        }
+        const declared = capability ? options.capabilityInputs?.get(capability) : void 0;
+        if (declared && !declared.has(name)) {
+          issue(
+            issues,
+            "unknown_capability_input",
+            inputPath,
+            `capability ${capability} does not declare input ${name}`
+          );
+        }
+      }
+    }
+  });
+  if (!graphMode) return issues;
+  const seen = /* @__PURE__ */ new Set();
+  ids.forEach((id, index) => {
+    if (seen.has(id)) issue(issues, "duplicate_step_id", `steps[${index}].id`, `workflow step id ${id} is duplicated`);
+    seen.add(id);
+  });
+  const startAt = text(workflow?.startAt) ?? text(steps[0]?.id);
+  if (!startAt || !seen.has(startAt)) {
+    issue(issues, "missing_start_step", "startAt", `workflow startAt references missing step ${startAt ?? "<none>"}`);
+  }
+  const adjacency = /* @__PURE__ */ new Map();
+  steps.forEach((step, index) => {
+    if (!step) return;
+    const id = text(step.id);
+    if (!id) return;
+    const transitions = transitionList(step.next);
+    adjacency.set(id, []);
+    if (transitions.length > maxTransitions) {
+      issue(
+        issues,
+        "too_many_transitions",
+        `steps[${index}].next`,
+        `workflow step ${id} has ${transitions.length} connections; maximum is ${maxTransitions}`
+      );
+    }
+    const defaults = transitions.filter((transition) => asRecord2(transition)?.default === true);
+    const conditionals = transitions.filter((transition) => asRecord2(transition)?.when !== void 0);
+    const unconditional = transitions.filter((transition) => {
+      const raw = asRecord2(transition);
+      return typeof transition === "string" || Boolean(raw && raw.when === void 0 && raw.default !== true && raw.maxIterations === void 0);
+    });
+    if (defaults.length > 1) {
+      issue(
+        issues,
+        "multiple_default_transitions",
+        `steps[${index}].next`,
+        `workflow step ${id} has more than one default connection`
+      );
+    }
+    if (conditionals.length > 0 && defaults.length !== 1) {
+      issue(
+        issues,
+        "missing_default_transition",
+        `steps[${index}].next`,
+        `workflow step ${id} has conditions and needs one default connection`
+      );
+    }
+    if (unconditional.length > 1 || unconditional.length > 0 && transitions.length > 1) {
+      issue(
+        issues,
+        "ambiguous_transition",
+        `steps[${index}].next`,
+        `workflow step ${id} mixes an unconditional connection with other connections`
+      );
+    }
+    transitions.forEach((transition, transitionIndex) => {
+      const raw = typeof transition === "string" ? { to: transition } : asRecord2(transition);
+      const base = `steps[${index}].next[${transitionIndex}]`;
+      if (!raw) {
+        issue(issues, "invalid_transition", base, "workflow connection must be a step id or an object");
+        return;
+      }
+      for (const field of Object.keys(raw)) {
+        if (!SUPPORTED_TRANSITION_FIELDS.has(field)) {
+          issue(
+            issues,
+            "unsupported_transition_field",
+            `${base}.${field}`,
+            `workflow connection field ${field} is not supported`
+          );
+        }
+      }
+      const target = text(raw.to);
+      if (!target || !SAFE_NAME.test(target)) {
+        issue(issues, "invalid_transition_target", `${base}.to`, "workflow connection must name a valid target step");
+        return;
+      }
+      if (!seen.has(target)) {
+        issue(
+          issues,
+          "missing_transition_target",
+          `${base}.to`,
+          `workflow step ${id} connects to missing step ${target}`
+        );
+      } else {
+        adjacency.get(id)?.push(target);
+      }
+      if (raw.default === true && raw.when !== void 0) {
+        issue(issues, "conflicting_transition", base, "workflow connection cannot be both conditional and default");
+      }
+      if (raw.when !== void 0) validateDataMatch(raw.when, `${base}.when`, issues);
+      const targetIndex = ids.indexOf(target ?? "");
+      const iterations = raw.maxIterations;
+      if (targetIndex >= 0 && targetIndex <= index) {
+        if (!Number.isInteger(iterations) || Number(iterations) < 1) {
+          issue(
+            issues,
+            "unbounded_loop",
+            `${base}.maxIterations`,
+            `workflow loop ${id}->${target} must set maxIterations`
+          );
+        } else if (Number(iterations) > maxLoopIterations) {
+          issue(
+            issues,
+            "loop_limit_too_high",
+            `${base}.maxIterations`,
+            `workflow loop ${id}->${target} exceeds maximum ${maxLoopIterations}`
+          );
+        }
+      } else if (iterations !== void 0 && (!Number.isInteger(iterations) || Number(iterations) < 1)) {
+        issue(issues, "invalid_loop_limit", `${base}.maxIterations`, "maxIterations must be a positive integer");
+      }
+    });
+  });
+  if (startAt && seen.has(startAt)) {
+    const reachable = /* @__PURE__ */ new Set();
+    const pending = [startAt];
+    while (pending.length > 0) {
+      const id = pending.pop();
+      if (reachable.has(id)) continue;
+      reachable.add(id);
+      pending.push(...adjacency.get(id) ?? []);
+    }
+    ids.forEach((id, index) => {
+      if (!reachable.has(id)) issue(issues, "unreachable_step", `steps[${index}]`, `workflow step ${id} is unreachable`);
+    });
+    if (![...reachable].some((id) => (adjacency.get(id) ?? []).length === 0)) {
+      issue(issues, "missing_terminal_step", "steps", "workflow has no reachable final step");
+    }
+  }
+  return issues;
+}
+function formatWorkflowValidationIssues(issues) {
+  return issues.map((entry) => `${entry.path}: ${entry.message}`);
+}
+function validateDataMatch(value, path52, issues) {
+  if (value === void 0) return;
+  const match = asRecord2(value);
+  if (!match || Object.keys(match).length === 0) {
+    issue(issues, "invalid_condition", path52, "workflow condition must contain at least one match");
+    return;
+  }
+  for (const [field, expected] of Object.entries(match)) {
+    if (!SAFE_DATA_PATH.test(field)) {
+      issue(
+        issues,
+        "invalid_data_path",
+        `${path52}.${field}`,
+        `workflow condition must read from facts, evidence, artifacts, result, workflow, or lastOutcome`
+      );
+    }
+    if (!isComparable(expected)) {
+      issue(issues, "invalid_condition_value", `${path52}.${field}`, "workflow condition value must be a JSON scalar");
+    }
+  }
+}
+function transitionList(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function isComparable(value) {
+  if (value === null || ["string", "number", "boolean"].includes(typeof value)) return true;
+  return Array.isArray(value) && value.length > 0 && value.every((item) => isComparable(item) && !Array.isArray(item));
+}
+function issue(issues, code, path52, message) {
+  issues.push({ code, path: path52, message });
+}
+var SAFE_NAME, SAFE_DATA_PATH, SUPPORTED_STEP_FIELDS, SUPPORTED_TRANSITION_FIELDS;
+var init_workflowValidation = __esm({
+  "src/workflowValidation.ts"() {
+    "use strict";
+    SAFE_NAME = /^[a-z][a-z0-9-]*$/;
+    SAFE_DATA_PATH = /^(facts|evidence|artifacts|result|workflow|lastOutcome)(?:\.[A-Za-z_][A-Za-z0-9_-]*)+$/;
+    SUPPORTED_STEP_FIELDS = /* @__PURE__ */ new Set([
+      "id",
+      "capability",
+      "action",
+      "implementation",
+      "evidence",
+      "target",
+      "targetFact",
+      "reason",
+      "agent",
+      "cliArgs",
+      "inputs",
+      "next",
+      "runWhen",
+      "continueOn",
+      "saveReport",
+      "report"
+    ]);
+    SUPPORTED_TRANSITION_FIELDS = /* @__PURE__ */ new Set(["to", "when", "default", "maxIterations"]);
+  }
+});
+
 // src/workflowDefinitions.ts
 import * as fs28 from "fs";
 import * as path26 from "path";
@@ -8742,7 +9057,18 @@ function normalizeWorkflowDefinition(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const raw = value;
   const name = typeof raw.name === "string" ? raw.name.trim() : "";
-  const workflow = parseCapabilityWorkflow({ steps: raw.steps });
+  const hasGraphConnections = Array.isArray(raw.steps) && raw.steps.some(
+    (step) => step && typeof step === "object" && !Array.isArray(step) && (step.next !== void 0 || step.inputs !== void 0)
+  );
+  if (hasGraphConnections) {
+    if (validateWorkflow({ steps: raw.steps, ...raw.startAt !== void 0 ? { startAt: raw.startAt } : {} }).length > 0) {
+      return null;
+    }
+  }
+  const workflow = parseCapabilityWorkflow({
+    steps: raw.steps,
+    startAt: raw.startAt
+  });
   const steps = workflow?.steps;
   const capabilities = steps ? steps.map((step) => step.capability) : normalizeWorkflowCapabilities(raw.capabilities);
   if (!name || capabilities.length === 0) return null;
@@ -8752,6 +9078,7 @@ function normalizeWorkflowDefinition(value) {
     capabilities,
     ...raw.runWithoutApproval === true ? { runWithoutApproval: true } : {},
     ...steps ? { steps } : {},
+    ...workflow?.startAt ? { startAt: workflow.startAt } : {},
     ...typeof raw.createdAt === "string" ? { createdAt: raw.createdAt } : {},
     ...typeof raw.updatedAt === "string" ? { updatedAt: raw.updatedAt } : {}
   };
@@ -8793,7 +9120,8 @@ function normalizeWorkflowCapabilities(value) {
 }
 function workflowDefinitionToConfig(workflow) {
   return {
-    steps: workflow.steps ?? workflow.capabilities.map((capability) => ({ capability }))
+    steps: workflow.steps ?? workflow.capabilities.map((capability) => ({ capability })),
+    ...workflow.startAt ? { startAt: workflow.startAt } : {}
   };
 }
 function readCompanyStoreWorkflowDefinition(id) {
@@ -8817,6 +9145,7 @@ var init_workflowDefinitions = __esm({
     init_capabilityFolders();
     init_companyStore();
     init_stateRepo();
+    init_workflowValidation();
     WORKFLOW_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,79}$/;
     CAPABILITY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,79}$/;
   }
@@ -9639,7 +9968,7 @@ function readSimpleGoalTaskSummary(goalId, cwd) {
   );
   const issues = JSON.parse(raw);
   const total = issues.length;
-  const open = issues.filter((issue) => String(issue.state ?? "").toLowerCase() === "open").length;
+  const open = issues.filter((issue2) => String(issue2.state ?? "").toLowerCase() === "open").length;
   return { total, open };
 }
 function previousDispatchWasTargetInstance(managed, previousScheduleState) {
@@ -9688,7 +10017,7 @@ function findExistingGoalIssue(goalId, cwd) {
   const marker = goalIssueMarker(goalId);
   const raw = gh(["issue", "list", "--state", "all", "--limit", "100", "--json", "number,body"], { cwd });
   const issues = JSON.parse(raw);
-  const match = issues.find((issue) => typeof issue.number === "number" && issue.body?.includes(marker));
+  const match = issues.find((issue2) => typeof issue2.number === "number" && issue2.body?.includes(marker));
   return match?.number ?? null;
 }
 function createGoalIssue(goal, goalId, cwd) {
@@ -10537,13 +10866,13 @@ function ensureNeedsFixIssue(ctx, goalId, state, evidence, evidenceKey) {
   const evidenceState = parseGoalEvidenceState(state.extra.evidenceState);
   const progress = evidenceState[evidenceKey];
   if (progress?.issue) return state;
-  const issue = findExistingNeedsFixIssue(goalId, evidenceKey, ctx.cwd) ?? createNeedsFixIssue(goalId, evidenceKey, evidence, ctx.cwd);
+  const issue2 = findExistingNeedsFixIssue(goalId, evidenceKey, ctx.cwd) ?? createNeedsFixIssue(goalId, evidenceKey, evidence, ctx.cwd);
   const nextEvidenceState = mergeGoalEvidenceProgress(evidenceState, evidenceKey, {
     resultClass: "needsFix",
     attempts: progress?.attempts ?? 1,
     reason: evidence.summary,
-    nextAction: `fix issue #${issue}`,
-    issue,
+    nextAction: `fix issue #${issue2}`,
+    issue: issue2,
     updatedAt: nowIso()
   });
   return {
@@ -10552,7 +10881,7 @@ function ensureNeedsFixIssue(ctx, goalId, state, evidence, evidenceKey) {
       ...state.extra,
       evidenceState: nextEvidenceState,
       reason: evidence.summary,
-      nextAction: `fix issue #${issue}`
+      nextAction: `fix issue #${issue2}`
     }
   };
 }
@@ -10570,7 +10899,7 @@ function findExistingNeedsFixIssue(goalId, evidence, cwd) {
   const marker = needsFixIssueMarker(goalId, evidence);
   const raw = gh(["issue", "list", "--state", "all", "--limit", "100", "--json", "number,body"], { cwd });
   const issues = JSON.parse(raw);
-  const match = issues.find((issue) => typeof issue.number === "number" && issue.body?.includes(marker));
+  const match = issues.find((issue2) => typeof issue2.number === "number" && issue2.body?.includes(marker));
   return match?.number ?? null;
 }
 function createNeedsFixIssue(goalId, evidence, result, cwd) {
@@ -11008,8 +11337,8 @@ var init_classifyByLabel = __esm({
     "use strict";
     VALID_CLASSES = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
     classifyByLabel = async (ctx) => {
-      const issue = ctx.data.issue;
-      const labels = issue?.labels;
+      const issue2 = ctx.data.issue;
+      const labels = issue2?.labels;
       if (!labels || labels.length === 0) return;
       const cfgMap = ctx.config.classify?.labelMap;
       const map = cfgMap ?? defaultLabelMap();
@@ -11535,19 +11864,19 @@ function buildGoalName(scope, verdict) {
   const verdictTag = verdict === "UNKNOWN" ? "REPORT" : verdict;
   return `QA: ${focus} \u2014 ${verdictTag} \u2014 ${todayIso()}`.slice(0, 240);
 }
-function splitReport(text) {
-  const open = text.indexOf(REPORT_JSON_OPEN);
+function splitReport(text2) {
+  const open = text2.indexOf(REPORT_JSON_OPEN);
   if (open < 0) {
-    const fallback = parseFallbackFindingsJson(text);
+    const fallback = parseFallbackFindingsJson(text2);
     if (fallback) return fallback;
-    return { markdown: text.trim(), data: null, jsonError: "no JSON block marker" };
+    return { markdown: text2.trim(), data: null, jsonError: "no JSON block marker" };
   }
-  const closeRel = text.slice(open + REPORT_JSON_OPEN.length).indexOf(REPORT_JSON_CLOSE);
+  const closeRel = text2.slice(open + REPORT_JSON_OPEN.length).indexOf(REPORT_JSON_CLOSE);
   if (closeRel < 0) {
-    return { markdown: text.slice(0, open).trim(), data: null, jsonError: "JSON block not terminated" };
+    return { markdown: text2.slice(0, open).trim(), data: null, jsonError: "JSON block not terminated" };
   }
   const closeAbs = open + REPORT_JSON_OPEN.length + closeRel;
-  const rawJson = text.slice(open + REPORT_JSON_OPEN.length, closeAbs).trim();
+  const rawJson = text2.slice(open + REPORT_JSON_OPEN.length, closeAbs).trim();
   const fenced = rawJson.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/);
   const cleanJson = fenced ? fenced[1].trim() : rawJson;
   let parsed = null;
@@ -11562,11 +11891,11 @@ function splitReport(text) {
   } catch (err) {
     parseError = err instanceof Error ? err.message : String(err);
   }
-  const markdown = text.slice(0, open).trim();
+  const markdown = text2.slice(0, open).trim();
   return { markdown, data: parsed, jsonError: parseError };
 }
-function parseFallbackFindingsJson(text) {
-  const fences = [...text.matchAll(/```(?:json)?\s*([\s\S]*?)\s*```/gi)];
+function parseFallbackFindingsJson(text2) {
+  const fences = [...text2.matchAll(/```(?:json)?\s*([\s\S]*?)\s*```/gi)];
   for (let i = fences.length - 1; i >= 0; i--) {
     const match = fences[i];
     const raw = match[1]?.trim();
@@ -11575,18 +11904,18 @@ function parseFallbackFindingsJson(text) {
       const parsed = JSON.parse(raw);
       if (!parsed || !Array.isArray(parsed.findings)) {
         return {
-          markdown: removeFence(text, match).trim(),
+          markdown: removeFence(text2, match).trim(),
           data: null,
           jsonError: "fallback JSON missing 'findings' array"
         };
       }
       return {
-        markdown: removeFence(text, match).trim(),
+        markdown: removeFence(text2, match).trim(),
         data: { findings: parsed.findings.map((f, idx) => normalizeFallbackFinding(f, idx)) }
       };
     } catch (err) {
       return {
-        markdown: removeFence(text, match).trim(),
+        markdown: removeFence(text2, match).trim(),
         data: null,
         jsonError: err instanceof Error ? err.message : String(err)
       };
@@ -11594,10 +11923,10 @@ function parseFallbackFindingsJson(text) {
   }
   return null;
 }
-function removeFence(text, match) {
+function removeFence(text2, match) {
   const start = match.index ?? -1;
-  if (start < 0) return text;
-  return `${text.slice(0, start)}${text.slice(start + match[0].length)}`;
+  if (start < 0) return text2;
+  return `${text2.slice(0, start)}${text2.slice(start + match[0].length)}`;
 }
 function normalizeFallbackFinding(raw, idx) {
   const finding = raw && typeof raw === "object" ? raw : {};
@@ -11654,9 +11983,9 @@ function loadManifest(cwd) {
     return { number: null, manifest: { version: 1, goals: [] } };
   }
   if (arr.length === 0) return { number: null, manifest: { version: 1, goals: [] } };
-  const issue = arr[0];
-  const manifest = parseManifestBody(issue.body);
-  return { number: issue.number, manifest };
+  const issue2 = arr[0];
+  const manifest = parseManifestBody(issue2.body);
+  return { number: issue2.number, manifest };
 }
 function parseManifestBody(body) {
   if (!body) return { version: 1, goals: [] };
@@ -11882,8 +12211,8 @@ ${markdown}`, ctx.cwd);
   const failed = [];
   for (const f of findings) {
     try {
-      const issue = createTaskIssue(f, goalId, manifestIssueNumber, ctx.cwd);
-      opened.push({ ...issue, severity: f.severity });
+      const issue2 = createTaskIssue(f, goalId, manifestIssueNumber, ctx.cwd);
+      opened.push({ ...issue2, severity: f.severity });
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
       failed.push({ title: f.title, reason });
@@ -12025,8 +12354,8 @@ var init_deriveQaScopeFromIssue = __esm({
       if (!Number.isFinite(issueNumber) || issueNumber <= 0) return;
       let title = "";
       try {
-        const issue = getIssue(issueNumber, ctx.cwd);
-        title = (issue.title ?? "").trim();
+        const issue2 = getIssue(issueNumber, ctx.cwd);
+        title = (issue2.title ?? "").trim();
       } catch (err) {
         process.stderr.write(
           `[kody] deriveQaScopeFromIssue: could not read #${issueNumber}: ${err instanceof Error ? err.message : String(err)}
@@ -12631,28 +12960,28 @@ var init_dispatchCapabilityTicks = __esm({
       process.stdout.write(`[jobs] ticking ${issues.length} issue(s) via ${targetImplementation}
 `);
       const results = [];
-      for (const issue of issues) {
-        process.stdout.write(`[jobs] \u2192 tick #${issue.number}: ${issue.title}
+      for (const issue2 of issues) {
+        process.stdout.write(`[jobs] \u2192 tick #${issue2.number}: ${issue2.title}
 `);
         try {
           const out = await runJob(
             mintScheduledJob({
               capability: targetImplementation,
               implementation: targetImplementation,
-              cliArgs: { [issueArg]: issue.number }
+              cliArgs: { [issueArg]: issue2.number }
             }),
             { cwd: ctx.cwd, config: ctx.config, verbose: ctx.verbose, quiet: ctx.quiet, chain: false }
           );
-          results.push({ issue: issue.number, exitCode: out.exitCode, reason: out.reason });
+          results.push({ issue: issue2.number, exitCode: out.exitCode, reason: out.reason });
           if (out.exitCode !== 0) {
-            process.stderr.write(`[jobs] tick #${issue.number} failed (exit ${out.exitCode}): ${out.reason ?? ""}
+            process.stderr.write(`[jobs] tick #${issue2.number} failed (exit ${out.exitCode}): ${out.reason ?? ""}
 `);
           }
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
-          process.stderr.write(`[jobs] tick #${issue.number} crashed: ${msg}
+          process.stderr.write(`[jobs] tick #${issue2.number} crashed: ${msg}
 `);
-          results.push({ issue: issue.number, exitCode: 99, reason: msg });
+          results.push({ issue: issue2.number, exitCode: 99, reason: msg });
         }
       }
       ctx.data.jobTickResults = results;
@@ -12921,7 +13250,14 @@ function updateExistingPr(existing, body, draft, cwd, preserveBody) {
       const promotedTitle = existing.title?.replace(/^\[WIP\]\s*/, "");
       if (promotedTitle && promotedTitle !== existing.title) {
         gh(
-          ["api", "--method", "PATCH", `repos/${owner}/${repo}/pulls/${existing.number}`, "-f", `title=${promotedTitle}`],
+          [
+            "api",
+            "--method",
+            "PATCH",
+            `repos/${owner}/${repo}/pulls/${existing.number}`,
+            "-f",
+            `title=${promotedTitle}`
+          ],
           { cwd, preferRepoToken: true }
         );
       }
@@ -13067,10 +13403,10 @@ var init_ensurePr = __esm({
       const failureReason = computeFailureReason(ctx);
       const isFailure = failureReason.length > 0;
       const changedFiles = ctx.data.changedFiles ?? [];
-      const issue = ctx.data.issue;
+      const issue2 = ctx.data.issue;
       const pr = ctx.data.pr;
       const targetNumber = Number(ctx.data.commentTargetNumber ?? 0);
-      const title = issue?.title ?? pr?.title ?? `kody changes`;
+      const title = issue2?.title ?? pr?.title ?? `kody changes`;
       const baseBranch = ctx.data.baseBranch;
       try {
         const result = ensurePr({
@@ -13121,12 +13457,12 @@ var init_failOnceTaskJob = __esm({
     init_jobIdentity();
     failOnceTaskJob = async (ctx, profile) => {
       ctx.skipAgent = true;
-      const issue = typeof ctx.args.issue === "number" ? ctx.args.issue : void 0;
+      const issue2 = typeof ctx.args.issue === "number" ? ctx.args.issue : void 0;
       const fallbackJob = {
         capability: profile.action ?? profile.name,
         implementation: profile.name,
         flavor: "instant",
-        ...typeof issue === "number" ? { target: issue, cliArgs: { issue } } : { cliArgs: {} }
+        ...typeof issue2 === "number" ? { target: issue2, cliArgs: { issue: issue2 } } : { cliArgs: {} }
       };
       const jobKey = typeof ctx.data.jobKey === "string" ? ctx.data.jobKey : stableJobKey(fallbackJob);
       const state = ctx.data.taskState;
@@ -14112,13 +14448,13 @@ function companyIntentPath(id) {
   assertIntentId(id);
   return `intents/${id}/intent.json`;
 }
-function normalizeCompanyIntent(path51, raw) {
+function normalizeCompanyIntent(path52, raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new Error(`${path51}: intent must be JSON object`);
+    throw new Error(`${path52}: intent must be JSON object`);
   }
   const input = raw;
   const id = stringField5(input.id);
-  if (!id || !isCompanyIntentId(id)) throw new Error(`${path51}: invalid intent id`);
+  if (!id || !isCompanyIntentId(id)) throw new Error(`${path52}: invalid intent id`);
   const createdAt = stringField5(input.createdAt) || nowIso();
   const updatedAt = stringField5(input.updatedAt) || createdAt;
   const description = stringField5(input.description);
@@ -14158,8 +14494,8 @@ function listCompanyIntents(config, cwd) {
   const records = [];
   for (const entry of entries) {
     if (entry.type !== "dir" || !entry.name || !isCompanyIntentId(entry.name)) continue;
-    const path51 = companyIntentPath(entry.name);
-    const file = readStateText(config, cwd, path51);
+    const path52 = companyIntentPath(entry.name);
+    const file = readStateText(config, cwd, path52);
     if (!file) continue;
     records.push({
       id: entry.name,
@@ -14368,14 +14704,14 @@ var init_loadIssueContext = __esm({
         if (!ctx.data.commentTargetNumber) ctx.data.commentTargetNumber = issueNumber;
         return;
       }
-      const issue = getIssue(issueNumber, ctx.cwd);
+      const issue2 = getIssue(issueNumber, ctx.cwd);
       const cfgCtx = ctx.config.issueContext ?? {};
       const limit = cfgCtx.commentLimit ?? DEFAULT_COMMENT_LIMIT;
       const maxBytes = cfgCtx.commentMaxBytes ?? DEFAULT_COMMENT_MAX_BYTES;
-      const commentsFormatted = formatIssueComments(issue.comments, limit, maxBytes);
-      const labels = issue.labels ?? [];
+      const commentsFormatted = formatIssueComments(issue2.comments, limit, maxBytes);
+      const labels = issue2.labels ?? [];
       const labelsFormatted = labels.length === 0 ? "(no labels)" : labels.map((l) => `\`${l}\``).join(", ");
-      ctx.data.issue = { ...issue, commentsFormatted, labelsFormatted };
+      ctx.data.issue = { ...issue2, commentsFormatted, labelsFormatted };
       ctx.data.commentTargetType = "issue";
       ctx.data.commentTargetNumber = issueNumber;
     };
@@ -14404,11 +14740,11 @@ var init_loadIssueStateComment = __esm({
       if (!owner || !repo) {
         throw new Error("loadIssueStateComment: ctx.config.github.owner/repo must be set");
       }
-      const issue = getIssue(issueNumber, ctx.cwd);
+      const issue2 = getIssue(issueNumber, ctx.cwd);
       const loaded = findStateComment(owner, repo, issueNumber, marker, ctx.cwd);
       ctx.data.stateMarker = marker;
-      ctx.data.issueIntent = issue.body;
-      ctx.data.issueTitle = issue.title;
+      ctx.data.issueIntent = issue2.body;
+      ctx.data.issueTitle = issue2.title;
       ctx.data.issueNumber = String(issueNumber);
       ctx.data.issueStateComment = loaded;
       ctx.data.issueStateJson = loaded ? JSON.stringify(loaded.state, null, 2) : "null";
@@ -14538,15 +14874,15 @@ var init_loadLinkedFinding = __esm({
       if (!pr) return;
       const findingNumber = resolveFindingNumber(pr);
       if (!findingNumber) return;
-      let issue;
+      let issue2;
       try {
-        issue = getIssue(findingNumber, ctx.cwd);
+        issue2 = getIssue(findingNumber, ctx.cwd);
       } catch {
         return;
       }
-      ctx.data.linkedFinding = `Issue #${issue.number}: ${issue.title}
+      ctx.data.linkedFinding = `Issue #${issue2.number}: ${issue2.title}
 
-${truncate(issue.body, FINDING_BODY_MAX_BYTES)}`;
+${truncate(issue2.body, FINDING_BODY_MAX_BYTES)}`;
     };
   }
 });
@@ -14751,8 +15087,8 @@ async function writeGithubStateTextWithConfig(opts) {
     );
   }
 }
-function jsonlLines(text) {
-  return text.split("\n").filter((line) => line.length > 0);
+function jsonlLines(text2) {
+  return text2.split("\n").filter((line) => line.length > 0);
 }
 function renderJsonl(lines) {
   return lines.length > 0 ? `${lines.join("\n")}
@@ -15052,14 +15388,14 @@ var init_loadTaskContext = __esm({
     loadTaskContext = async (ctx) => {
       const runId = resolveRunId();
       const rawIssue = ctx.data.issue;
-      const issue = rawIssue ? {
+      const issue2 = rawIssue ? {
         ...rawIssue,
         commentsFormatted: rawIssue.commentsFormatted ?? "",
         labelsFormatted: rawIssue.labelsFormatted ?? ""
       } : void 0;
       const taskContext = buildTaskContext({
         runId,
-        issue,
+        issue: issue2,
         conventions: ctx.data.conventions,
         priorArt: typeof ctx.data.priorArt === "string" ? ctx.data.priorArt : "",
         memoryContext: typeof ctx.data.memoryContext === "string" ? ctx.data.memoryContext : "",
@@ -15414,6 +15750,12 @@ var init_notifyTerminal = __esm({
 });
 
 // src/scripts/openAgencyModelReviewPr.ts
+function isDryRun(ctx) {
+  const arg = ctx.args.dry_run ?? ctx.args.dryRun;
+  if (arg === true) return true;
+  if (typeof arg === "string" && ["1", "true", "yes"].includes(arg.trim().toLowerCase())) return true;
+  return ["1", "true", "yes"].includes((process.env.KODY_DRY_RUN ?? "").trim().toLowerCase());
+}
 function parseAgencyModelProposal(raw) {
   const jsonText = stripJsonFence(raw);
   let parsed;
@@ -15483,9 +15825,9 @@ function normalizeBundleFiles(ctx, bundle) {
   });
 }
 function stripJsonFence(raw) {
-  const text = raw.trim();
-  const fence = text.match(/^```(?:json)?\s*\n([\s\S]*?)\n```$/i);
-  return (fence ? fence[1] : text).trim();
+  const text2 = raw.trim();
+  const fence = text2.match(/^```(?:json)?\s*\n([\s\S]*?)\n```$/i);
+  return (fence ? fence[1] : text2).trim();
 }
 function readIssueNumber(ctx) {
   const issueNumber = ctx.args.issue;
@@ -15495,9 +15837,9 @@ function readIssueNumber(ctx) {
   return issueNumber;
 }
 function readRequiredJsonString(value, field) {
-  const text = readJsonString(value, field).trim();
-  if (!text) throw new Error(`openAgencyModelReviewPr: ${field} must be a non-empty string`);
-  return text;
+  const text2 = readJsonString(value, field).trim();
+  if (!text2) throw new Error(`openAgencyModelReviewPr: ${field} must be a non-empty string`);
+  return text2;
 }
 function readJsonString(value, field) {
   if (typeof value !== "string") throw new Error(`openAgencyModelReviewPr: ${field} must be a string`);
@@ -15577,6 +15919,16 @@ var init_openAgencyModelReviewPr = __esm({
       const stateRepo = parseStateRepo(ctx.config);
       const baseBranch = "main";
       const branch = buildStatePrBranchName(sourceLabel, issueNumber, bundle.title);
+      if (isDryRun(ctx)) {
+        ctx.data.agencyModelReviewPr = {
+          dryRun: true,
+          repo: `${stateRepo.owner}/${stateRepo.repo}`,
+          branch,
+          base: baseBranch,
+          files: normalizedFiles.map((file) => file.targetPath)
+        };
+        return;
+      }
       const baseRef = ghJson(
         ["api", `/repos/${stateRepo.owner}/${stateRepo.repo}/git/ref/heads/${baseBranch}`],
         ctx.cwd
@@ -15689,10 +16041,10 @@ function ensureLabel2(cwd) {
     return false;
   }
 }
-function markIssueWithReportLabel(issue, cwd) {
+function markIssueWithReportLabel(issue2, cwd) {
   if (!ensureLabel2(cwd)) return;
   try {
-    gh(["issue", "edit", String(issue), "--add-label", QA_LABEL], { cwd });
+    gh(["issue", "edit", String(issue2), "--add-label", QA_LABEL], { cwd });
   } catch {
   }
 }
@@ -15831,13 +16183,13 @@ function isPartialEnvelope(x) {
 function escapeRegex(s) {
   return s.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 }
-function extractFencedBlock(text, label) {
+function extractFencedBlock(text2, label) {
   const re = new RegExp(`\`\`\`${escapeRegex(label)}\\s*\\n([\\s\\S]*?)\\n\`\`\``, "m");
-  const m = re.exec(text);
+  const m = re.exec(text2);
   return m ? m[1].trim() : null;
 }
-function extractNextStateFromText(text, fenceLabel, prevRev) {
-  const inner = extractFencedBlock(text, fenceLabel);
+function extractNextStateFromText(text2, fenceLabel, prevRev) {
+  const inner = extractFencedBlock(text2, fenceLabel);
   if (inner === null) {
     return { error: `missing \`${fenceLabel}\` fenced block` };
   }
@@ -15956,15 +16308,15 @@ var init_parseJobStateFromAgentResult = __esm({
 });
 
 // src/scripts/parseReproOutput.ts
-function extractTestPath(text) {
-  const m = text.match(/^[\s>*_#`~-]*TEST_PATH[\s>*_#`~-]*\s*:\s*(.+?)\s*$/im);
+function extractTestPath(text2) {
+  const m = text2.match(/^[\s>*_#`~-]*TEST_PATH[\s>*_#`~-]*\s*:\s*(.+?)\s*$/im);
   if (!m) return "";
   return stripMarkdownEmphasis2(m[1] ?? "");
 }
-function extractFailureSignatureBlock(text) {
-  const startIdx = text.search(/(?:^|\n)[ \t]*FAILURE_SIGNATURE\s*:[ \t]*/i);
+function extractFailureSignatureBlock(text2) {
+  const startIdx = text2.search(/(?:^|\n)[ \t]*FAILURE_SIGNATURE\s*:[ \t]*/i);
   if (startIdx === -1) return "";
-  const afterMarker = text.slice(startIdx).replace(/^[\s\S]*?FAILURE_SIGNATURE\s*:[ \t]*\n?/i, "");
+  const afterMarker = text2.slice(startIdx).replace(/^[\s\S]*?FAILURE_SIGNATURE\s*:[ \t]*\n?/i, "");
   const stopRe = /(?:^|\n)[ \t]*(?:COMMIT_MSG|PR_SUMMARY|TEST_PATH)\s*:/i;
   const stopIdx = afterMarker.search(stopRe);
   let block = stopIdx === -1 ? afterMarker : afterMarker.slice(0, stopIdx);
@@ -15981,14 +16333,14 @@ function normalizeFailureSignatureBlock(block) {
   const jsonObject = extractFirstJsonObject(s);
   return jsonObject || s;
 }
-function extractFirstJsonObject(text) {
-  const start = text.indexOf("{");
+function extractFirstJsonObject(text2) {
+  const start = text2.indexOf("{");
   if (start === -1) return "";
   let depth = 0;
   let inString = false;
   let escaped = false;
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i];
+  for (let i = start; i < text2.length; i++) {
+    const ch = text2[i];
     if (inString) {
       if (escaped) {
         escaped = false;
@@ -16005,7 +16357,7 @@ function extractFirstJsonObject(text) {
       depth++;
     } else if (ch === "}") {
       depth--;
-      if (depth === 0) return text.slice(start, i + 1).trim();
+      if (depth === 0) return text2.slice(start, i + 1).trim();
     }
   }
   return "";
@@ -16031,9 +16383,9 @@ var init_parseReproOutput = __esm({
     "use strict";
     parseReproOutput = async (ctx, _profile, agentResult) => {
       if (!agentResult || ctx.data.agentDone === false) return;
-      const text = agentResult.finalText ?? "";
-      const testPath = extractTestPath(text);
-      const signatureRaw = extractFailureSignatureBlock(text);
+      const text2 = agentResult.finalText ?? "";
+      const testPath = extractTestPath(text2);
+      const signatureRaw = extractFailureSignatureBlock(text2);
       if (!testPath) {
         downgrade(ctx, "reproduce missing TEST_PATH line in final message");
         return;
@@ -16212,8 +16564,8 @@ var init_planTaskJobs = __esm({
         ctx.output.reason = "planTaskJobs requires --issue";
         return;
       }
-      const issue = ctx.data.issue;
-      const specs = parseTaskJobSpecs(issue?.body ?? "");
+      const issue2 = ctx.data.issue;
+      const specs = parseTaskJobSpecs(issue2?.body ?? "");
       if (specs.length === 0) {
         ctx.skipAgent = true;
         ctx.output.exitCode = 64;
@@ -16543,8 +16895,8 @@ var init_promoteQaGoal = __esm({
       }
       let report;
       try {
-        const issue = getIssue(issueNum, ctx.cwd);
-        const reportComment = [...issue.comments].reverse().find((c) => c.body.includes(REPORT_JSON_OPEN2));
+        const issue2 = getIssue(issueNum, ctx.cwd);
+        const reportComment = [...issue2.comments].reverse().find((c) => c.body.includes(REPORT_JSON_OPEN2));
         if (!reportComment) {
           ctx.output.exitCode = 3;
           ctx.output.reason = `no QA report (${REPORT_JSON_OPEN2} \u2026) found on issue #${issueNum}`;
@@ -16611,9 +16963,9 @@ function latestResult(raw, agentResult) {
 function recordField6(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function resolveDotted(root, path51) {
-  if (!path51) return void 0;
-  return path51.split(".").reduce((value, key) => recordField6(value)?.[key], root);
+function resolveDotted(root, path52) {
+  if (!path52) return void 0;
+  return path52.split(".").reduce((value, key) => recordField6(value)?.[key], root);
 }
 function stringValue4(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
@@ -16655,13 +17007,7 @@ var init_publishReport = __esm({
         ...publication.reviewArea ? { reviewArea: publication.reviewArea } : {}
       });
       const runId = generatedAt.replace(/\.\d{3}Z$/, "Z").replace(/:/g, "-");
-      writeStateText(
-        ctx.config,
-        ctx.cwd,
-        `reports/${slug}/runs/${runId}.md`,
-        markdown,
-        `chore(reports): add ${slug} run`
-      );
+      writeStateText(ctx.config, ctx.cwd, `reports/${slug}/runs/${runId}.md`, markdown, `chore(reports): add ${slug} run`);
     };
   }
 });
@@ -17369,15 +17715,15 @@ var init_runFlow = __esm({
     init_issue();
     runFlow = async (ctx) => {
       const issueNumber = ctx.args.issue;
-      const issue = getIssue(issueNumber, ctx.cwd);
+      const issue2 = getIssue(issueNumber, ctx.cwd);
       const cfgCtx = ctx.config.issueContext ?? {};
       const commentsFormatted = formatIssueComments(
-        issue.comments,
+        issue2.comments,
         cfgCtx.commentLimit ?? DEFAULT_COMMENT_LIMIT,
         cfgCtx.commentMaxBytes ?? DEFAULT_COMMENT_MAX_BYTES
       );
-      ctx.data.issue = { ...issue, commentsFormatted };
-      if (issue.isPullRequest) {
+      ctx.data.issue = { ...issue2, commentsFormatted };
+      if (issue2.isPullRequest) {
         ctx.data.commentTargetType = "pr";
         ctx.data.commentTargetNumber = issueNumber;
         ctx.skipAgent = true;
@@ -17401,7 +17747,7 @@ var init_runFlow = __esm({
       }
       const branchInfo = ensureFeatureBranch(
         issueNumber,
-        issue.title,
+        issue2.title,
         ctx.config.git.defaultBranch,
         ctx.cwd,
         base ?? void 0
@@ -17650,8 +17996,8 @@ async function flyCreateApp(name, orgSlug, token) {
   });
   if (res.status === 422) return;
   if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(`createApp ${name}: ${res.status} ${text.slice(0, 200)}`);
+    const text2 = await res.text().catch(() => "");
+    throw new Error(`createApp ${name}: ${res.status} ${text2.slice(0, 200)}`);
   }
 }
 async function flyAllocateSharedIps(appName, token) {
@@ -17758,9 +18104,9 @@ async function flyCreatePreviewMachine(args, token) {
       const { id } = await res.json();
       return id;
     }
-    const text = await res.text().catch(() => "");
-    lastErr = new Error(`createPreviewMachine ${res.status}: ${text.slice(0, 300)}`);
-    if (!/MANIFEST_UNKNOWN|manifest unknown/i.test(text)) break;
+    const text2 = await res.text().catch(() => "");
+    lastErr = new Error(`createPreviewMachine ${res.status}: ${text2.slice(0, 300)}`);
+    if (!/MANIFEST_UNKNOWN|manifest unknown/i.test(text2)) break;
     await new Promise((r) => setTimeout(r, 2e3 * (attempt + 1)));
   }
   throw lastErr ?? new Error("createPreviewMachine failed (unknown)");
@@ -18199,8 +18545,8 @@ var init_setCommentTarget = __esm({
 
 // src/scripts/setLifecycleLabel.ts
 function resolveTargetNumber(args) {
-  const issue = args.issue;
-  if (typeof issue === "number" && Number.isFinite(issue)) return issue;
+  const issue2 = args.issue;
+  if (typeof issue2 === "number" && Number.isFinite(issue2)) return issue2;
   const pr = args.pr;
   if (typeof pr === "number" && Number.isFinite(pr)) return pr;
   return void 0;
@@ -18415,9 +18761,10 @@ var init_syncFlow = __esm({
 });
 
 // src/scripts/validateAgencyModelProposal.ts
-function validateModelBundle(bundle, expectedKind) {
+import * as path43 from "path";
+function validateModelBundle(bundle, expectedKind, options = {}) {
   const failures = [];
-  validateOneModel(bundle.model, bundle.files, "model", true, failures, expectedKind);
+  validateOneModel(bundle.model, bundle.files, "model", true, failures, expectedKind, options);
   return failures;
 }
 function readExpectedModelKind(args) {
@@ -18427,7 +18774,7 @@ function readExpectedModelKind(args) {
     "validateAgencyModelProposal: with.modelKind must be intent, operation, agent, capability, goal, agentLoop, or workflow"
   );
 }
-function validateOneModel(rawModel, files, label, strictSingleModel, failures, expectedKind) {
+function validateOneModel(rawModel, files, label, strictSingleModel, failures, expectedKind, options = {}) {
   if (!rawModel || typeof rawModel !== "object" || Array.isArray(rawModel)) {
     failures.push(`${label} must be an object`);
     return;
@@ -18445,11 +18792,11 @@ function validateOneModel(rawModel, files, label, strictSingleModel, failures, e
     for (const doc of REQUIRED_DOCS[kind]) {
       if (!docsUsed.includes(doc)) failures.push(`${label} docsUsed missing ${doc}`);
     }
-    validateFilesForKind(kind, slug, files, strictSingleModel, failures);
+    validateFilesForKind(kind, slug, files, strictSingleModel, failures, options);
     validateModelShape(kind, model, files, slug, failures);
   }
 }
-function validateFilesForKind(kind, slug, files, strictSingleModel, failures) {
+function validateFilesForKind(kind, slug, files, strictSingleModel, failures, options) {
   const paths = files.map((file) => normalizeBundlePath(file.path));
   if (paths.some((filePath) => filePath === "implementations" || filePath.startsWith("implementations/"))) {
     failures.push("files must not use obsolete implementation storage");
@@ -18496,6 +18843,7 @@ function validateFilesForKind(kind, slug, files, strictSingleModel, failures) {
   }
   if (kind === "workflow") {
     requirePath(paths, `capabilities/${slug}/profile.json`, "workflow capability profile", failures);
+    requirePath(paths, `capabilities/${slug}/capability.md`, "workflow capability body", failures);
     const profile = parseJsonFile(files, `capabilities/${slug}/profile.json`, failures);
     if (profile) {
       if (profile.capabilityKind !== void 0) {
@@ -18505,6 +18853,30 @@ function validateFilesForKind(kind, slug, files, strictSingleModel, failures) {
       const hasTopLevelSteps = Array.isArray(profile.steps) && profile.steps.length > 0;
       if (!hasWorkflowObject && !hasTopLevelSteps) {
         failures.push("workflow profile must include workflow object or top-level steps");
+      } else {
+        const workflow = hasWorkflowObject ? profile.workflow : { steps: profile.steps, ...profile.startAt !== void 0 ? { startAt: profile.startAt } : {} };
+        const known = options.capabilityRoot ? getCapabilityRoots(options.capabilityRoot).flatMap((root) => listCapabilityFolderSlugs(root)) : [];
+        const uniqueKnown = [...new Set(known)];
+        const capabilityInputs = /* @__PURE__ */ new Map();
+        if (options.capabilityRoot) {
+          for (const capability of uniqueKnown) {
+            const inputs = getCapabilityActionInputs(capability, options.capabilityRoot);
+            if (inputs) {
+              capabilityInputs.set(
+                capability,
+                new Set(inputs.flatMap((input) => [input.name, input.flag.replace(/^--/, "")]))
+              );
+            }
+          }
+        }
+        failures.push(
+          ...formatWorkflowValidationIssues(
+            validateWorkflow(workflow, {
+              ...uniqueKnown.length > 0 ? { knownCapabilities: new Set(uniqueKnown) } : {},
+              ...capabilityInputs.size > 0 ? { capabilityInputs } : {}
+            })
+          )
+        );
       }
     }
   }
@@ -18692,6 +19064,9 @@ var REQUIRED_DOCS, validateAgencyModelProposal;
 var init_validateAgencyModelProposal = __esm({
   "src/scripts/validateAgencyModelProposal.ts"() {
     "use strict";
+    init_capabilityFolders();
+    init_registry();
+    init_workflowValidation();
     init_openAgencyModelReviewPr();
     REQUIRED_DOCS = {
       intent: ["docs/intents.md", "docs/engine-company.md"],
@@ -18707,7 +19082,9 @@ var init_validateAgencyModelProposal = __esm({
       const raw = String(ctx.data.prSummary ?? "");
       const bundle = parseAgencyModelProposal(raw);
       const expectedKind = readExpectedModelKind(args);
-      const failures = validateModelBundle(bundle, expectedKind);
+      const failures = validateModelBundle(bundle, expectedKind, {
+        capabilityRoot: path43.join(ctx.cwd, ".kody", "capabilities")
+      });
       if (failures.length > 0) {
         throw new Error(`validateAgencyModelProposal: ${failures.join("; ")}`);
       }
@@ -19266,9 +19643,9 @@ var init_writeAgentRunSummary = __esm({
       const summaryPath = process.env.GITHUB_STEP_SUMMARY;
       if (!summaryPath) return;
       const implementation = profile.name;
-      const issue = ctx.args.issue;
+      const issue2 = ctx.args.issue;
       const pr = ctx.args.pr;
-      const target = issue ? `issue #${issue}` : pr ? `PR #${pr}` : "(unknown)";
+      const target = issue2 ? `issue #${issue2}` : pr ? `PR #${pr}` : "(unknown)";
       const prUrl = ctx.output.prUrl;
       const exitCode = ctx.output.exitCode ?? 0;
       const reason = ctx.output.reason;
@@ -19608,38 +19985,38 @@ import { execFileSync as execFileSync24 } from "child_process";
 import * as crypto3 from "crypto";
 import * as fs45 from "fs";
 import * as os7 from "os";
-import * as path43 from "path";
+import * as path44 from "path";
 function writeLocalFile(cwd, relativePath, content) {
-  const fullPath = path43.join(cwd, relativePath);
-  fs45.mkdirSync(path43.dirname(fullPath), { recursive: true });
+  const fullPath = path44.join(cwd, relativePath);
+  fs45.mkdirSync(path44.dirname(fullPath), { recursive: true });
   fs45.writeFileSync(fullPath, content);
 }
 function copyPath(source, target) {
   const st = fs45.lstatSync(source);
   fs45.rmSync(target, { recursive: true, force: true });
   if (st.isSymbolicLink()) return;
-  fs45.mkdirSync(path43.dirname(target), { recursive: true });
+  fs45.mkdirSync(path44.dirname(target), { recursive: true });
   fs45.cpSync(source, target, { recursive: true, force: true });
 }
 function overlayDirectoryChildren(cwd, sourceDir, localDir) {
   if (!fs45.existsSync(sourceDir)) return;
   for (const entry of fs45.readdirSync(sourceDir, { withFileTypes: true })) {
-    const source = path43.join(sourceDir, entry.name);
-    const target = path43.join(cwd, localDir, entry.name);
+    const source = path44.join(sourceDir, entry.name);
+    const target = path44.join(cwd, localDir, entry.name);
     copyPath(source, target);
   }
 }
 function hydrateStateWorkspace(config, cwd) {
   if (process.env.VITEST && process.env[TEST_FETCH_ENV] !== "1") return;
   const parsed = parseStateRepo(config);
-  const hydrateKey = `${path43.resolve(cwd)}|${parsed.owner}/${parsed.repo}|${parsed.basePath}|${parsed.branch}`;
+  const hydrateKey = `${path44.resolve(cwd)}|${parsed.owner}/${parsed.repo}|${parsed.basePath}|${parsed.branch}`;
   if (hydratedWorkspaces.has(hydrateKey)) return;
   const snapshotRoot = fetchStateSnapshot(parsed);
   for (const mapping of DIR_MAPPINGS) {
-    overlayDirectoryChildren(cwd, path43.join(snapshotRoot, mapping.stateDir), mapping.localDir);
+    overlayDirectoryChildren(cwd, path44.join(snapshotRoot, mapping.stateDir), mapping.localDir);
   }
   for (const mapping of FILE_MAPPINGS) {
-    const source = path43.join(snapshotRoot, mapping.statePath);
+    const source = path44.join(snapshotRoot, mapping.statePath);
     if (fs45.existsSync(source) && !fs45.lstatSync(source).isSymbolicLink() && fs45.statSync(source).isFile()) {
       writeLocalFile(cwd, mapping.localPath, fs45.readFileSync(source, "utf-8"));
     }
@@ -19647,11 +20024,11 @@ function hydrateStateWorkspace(config, cwd) {
   hydratedWorkspaces.add(hydrateKey);
 }
 function fetchStateSnapshot(parsed) {
-  const cacheDir = path43.join(cacheRoot2(), cacheKey3(parsed));
+  const cacheDir = path44.join(cacheRoot2(), cacheKey3(parsed));
   const url = `https://github.com/${parsed.owner}/${parsed.repo}.git`;
   try {
-    fs45.mkdirSync(path43.dirname(cacheDir), { recursive: true });
-    if (!fs45.existsSync(path43.join(cacheDir, ".git"))) {
+    fs45.mkdirSync(path44.dirname(cacheDir), { recursive: true });
+    if (!fs45.existsSync(path44.join(cacheDir, ".git"))) {
       fs45.rmSync(cacheDir, { recursive: true, force: true });
       runGit3(["clone", "--no-checkout", "--filter=blob:none", url, cacheDir]);
     }
@@ -19667,10 +20044,10 @@ function fetchStateSnapshot(parsed) {
       `stateWorkspace: failed to fetch ${parsed.owner}/${parsed.repo}:${parsed.basePath}@${parsed.branch}: ${msg}`
     );
   }
-  return path43.join(cacheDir, parsed.basePath);
+  return path44.join(cacheDir, parsed.basePath);
 }
 function cacheRoot2() {
-  return process.env[CACHE_ENV2]?.trim() || path43.join(os7.homedir(), ".cache", "kody", "state-repo");
+  return process.env[CACHE_ENV2]?.trim() || path44.join(os7.homedir(), ".cache", "kody", "state-repo");
 }
 function cacheKey3(parsed) {
   return crypto3.createHash("sha256").update(`${parsed.owner}/${parsed.repo}#${parsed.branch}#${parsed.basePath}`).digest("hex").slice(0, 24);
@@ -19710,16 +20087,16 @@ var init_stateWorkspace = __esm({
     "use strict";
     init_stateRepo();
     DIR_MAPPINGS = [
-      { stateDir: "capabilities", localDir: path43.join(".kody", "capabilities") },
-      { stateDir: "agents", localDir: path43.join(".kody", "agents") },
-      { stateDir: "context", localDir: path43.join(".kody", "context") },
-      { stateDir: "memory", localDir: path43.join(".kody", "memory") }
+      { stateDir: "capabilities", localDir: path44.join(".kody", "capabilities") },
+      { stateDir: "agents", localDir: path44.join(".kody", "agents") },
+      { stateDir: "context", localDir: path44.join(".kody", "context") },
+      { stateDir: "memory", localDir: path44.join(".kody", "memory") }
     ];
     FILE_MAPPINGS = [
-      { statePath: "instructions.md", localPath: path43.join(".kody", "instructions.md") },
-      { statePath: "system-prompt.md", localPath: path43.join(".kody", "system-prompt.md") },
-      { statePath: "variables.json", localPath: path43.join(".kody", "variables.json") },
-      { statePath: "secrets.enc", localPath: path43.join(".kody", "secrets.enc") }
+      { statePath: "instructions.md", localPath: path44.join(".kody", "instructions.md") },
+      { statePath: "system-prompt.md", localPath: path44.join(".kody", "system-prompt.md") },
+      { statePath: "variables.json", localPath: path44.join(".kody", "variables.json") },
+      { statePath: "secrets.enc", localPath: path44.join(".kody", "secrets.enc") }
     ];
     CACHE_ENV2 = "KODY_STATE_REPO_CACHE";
     TEST_FETCH_ENV = "KODY_STATE_WORKSPACE_FETCH_FOR_TESTS";
@@ -19795,7 +20172,7 @@ var init_tools = __esm({
 import { spawn as spawn7 } from "child_process";
 import * as fs46 from "fs";
 import * as os8 from "os";
-import * as path44 from "path";
+import * as path45 from "path";
 function isMutatingPostflight(scriptName) {
   return MUTATING_POSTFLIGHTS.has(scriptName ?? "");
 }
@@ -19823,9 +20200,9 @@ function collectShellSideChannels(ctx, stdout) {
   }
 }
 function operatorRequestBlock(why) {
-  const text = why.trim();
-  if (!text) return null;
-  const safe = text.replace(/-{3,}\s*END UNTRUSTED INPUT\s*-{3,}/gi, "[END UNTRUSTED INPUT]");
+  const text2 = why.trim();
+  if (!text2) return null;
+  const safe = text2.replace(/-{3,}\s*END UNTRUSTED INPUT\s*-{3,}/gi, "[END UNTRUSTED INPUT]");
   return [
     "## The request that triggered this run",
     "",
@@ -20018,7 +20395,7 @@ async function runImplementation(profileName, input) {
   const jobWhyBlock = typeof ctx.data.jobWhy === "string" ? operatorRequestBlock(ctx.data.jobWhy) : null;
   const jobRefBlock = jobReferenceBlock(profileName, profile, ctx.data);
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path44.isAbsolute(p) ? p : path44.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path45.isAbsolute(p) ? p : path45.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
@@ -20267,7 +20644,8 @@ async function runImplementation(profileName, input) {
       nextDispatch: ctx.output.nextDispatch,
       nextJob: ctx.output.nextJob,
       afterNextJob: ctx.output.afterNextJob,
-      taskState: ctx.data.taskState
+      taskState: ctx.data.taskState,
+      capabilityResults: Array.isArray(ctx.data.capabilityResults) ? ctx.data.capabilityResults : void 0
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -20455,13 +20833,13 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function resolveProfilePath(profileName) {
   const found = resolveImplementation(profileName);
   if (found) return found;
-  const here = path44.dirname(new URL(import.meta.url).pathname);
+  const here = path45.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path44.join(here, "implementations", profileName, "profile.json"),
+    path45.join(here, "implementations", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path44.join(here, "..", "implementations", profileName, "profile.json"),
+    path45.join(here, "..", "implementations", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/implementations)
-    path44.join(here, "..", "src", "implementations", profileName, "profile.json")
+    path45.join(here, "..", "src", "implementations", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
@@ -20580,7 +20958,7 @@ function resolveShellTimeoutMs(entry) {
 }
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path44.join(profile.dir, shellName);
+  const shellPath = path45.join(profile.dir, shellName);
   if (!fs46.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
@@ -20588,7 +20966,7 @@ async function runShellEntry(entry, ctx, profile) {
     return;
   }
   const positional = entry.with ? Object.values(entry.with).map((v) => String(v)) : [];
-  const outputFile = path44.join(
+  const outputFile = path45.join(
     os8.tmpdir(),
     `kody-shell-output-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
   );
@@ -20756,6 +21134,68 @@ var init_executor = __esm({
   }
 });
 
+// src/workflowRunState.ts
+function workflowRunStatePath(workflowId, runId) {
+  if (!SAFE_ID.test(workflowId)) throw new Error(`invalid workflow id ${workflowId}`);
+  if (!SAFE_ID.test(runId)) throw new Error(`invalid workflow run id ${runId}`);
+  return `workflows/${workflowId}/runs/${runId}.json`;
+}
+function parseWorkflowRunState(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const state = raw;
+  if (state.status !== "running" && state.status !== "blocked" && state.status !== "failed" && state.status !== "done")
+    return null;
+  const completedStepIds = Array.isArray(state.completedStepIds) ? state.completedStepIds.filter((value) => typeof value === "string") : [];
+  const transitionCounts = state.transitionCounts && typeof state.transitionCounts === "object" && !Array.isArray(state.transitionCounts) ? Object.fromEntries(
+    Object.entries(state.transitionCounts).filter(
+      (entry) => typeof entry[1] === "number" && Number.isInteger(entry[1]) && entry[1] >= 0
+    )
+  ) : {};
+  const facts = state.facts && typeof state.facts === "object" && !Array.isArray(state.facts) ? state.facts : {};
+  const evidenceEntries = state.evidence && typeof state.evidence === "object" && !Array.isArray(state.evidence) ? Object.entries(state.evidence).filter((entry) => typeof entry[1] === "boolean") : [];
+  const artifacts = Array.isArray(state.artifacts) ? state.artifacts.filter(
+    (artifact) => !!artifact && typeof artifact === "object" && typeof artifact.label === "string" && (artifact.url === void 0 || typeof artifact.url === "string") && (artifact.path === void 0 || typeof artifact.path === "string")
+  ) : [];
+  return {
+    status: state.status,
+    ...typeof state.currentStepId === "string" ? { currentStepId: state.currentStepId } : {},
+    completedStepIds,
+    transitionCounts,
+    facts: { ...facts },
+    evidence: Object.fromEntries(evidenceEntries),
+    artifacts: artifacts.map((artifact) => ({ ...artifact })),
+    ...typeof state.blocker === "string" ? { blocker: state.blocker } : {}
+  };
+}
+function readWorkflowRunState(config, cwd, workflowId, runId) {
+  const file = readStateText(config, cwd, workflowRunStatePath(workflowId, runId));
+  if (!file) return null;
+  try {
+    return parseWorkflowRunState(JSON.parse(file.content));
+  } catch {
+    return null;
+  }
+}
+function writeWorkflowRunState(config, cwd, workflowId, runId, state) {
+  const path52 = workflowRunStatePath(workflowId, runId);
+  upsertStateText(
+    config,
+    cwd,
+    path52,
+    `${JSON.stringify(state, null, 2)}
+`,
+    `chore(workflows): update ${workflowId} run ${runId}`
+  );
+}
+var SAFE_ID;
+var init_workflowRunState = __esm({
+  "src/workflowRunState.ts"() {
+    "use strict";
+    init_stateRepo();
+    SAFE_ID = /^[a-z0-9][a-z0-9_-]{0,79}$/;
+  }
+});
+
 // src/job.ts
 var job_exports = {};
 __export(job_exports, {
@@ -20768,7 +21208,7 @@ __export(job_exports, {
   stableJobKey: () => stableJobKey,
   validateJob: () => validateJob
 });
-import * as path45 from "path";
+import * as path46 from "path";
 function newJobId(flavor) {
   localJobSeq += 1;
   const runId = process.env.GITHUB_RUN_ID;
@@ -20800,6 +21240,8 @@ function validateJob(input) {
     target: typeof j.target === "number" ? j.target : void 0,
     cliArgs: j.cliArgs ?? {},
     workflowFacts: j.workflowFacts && typeof j.workflowFacts === "object" && !Array.isArray(j.workflowFacts) ? j.workflowFacts : void 0,
+    workflowState: parseWorkflowRunState(j.workflowState) ?? void 0,
+    workflowRunId: typeof j.workflowRunId === "string" && j.workflowRunId.trim() ? j.workflowRunId.trim() : void 0,
     evidence: parseJobEvidence(j),
     flavor: j.flavor,
     force: j.force === true,
@@ -20834,7 +21276,7 @@ function parseJobEvidence(job) {
 async function runJob(job, base) {
   const valid = validateJob(job);
   const action = valid.action ?? valid.capability;
-  const projectCapabilitiesRoot = path45.join(base.cwd, ".kody", "capabilities");
+  const projectCapabilitiesRoot = path46.join(base.cwd, ".kody", "capabilities");
   const resolvedCapability = !valid.workflow && action ? resolveCapabilityAction(action, projectCapabilitiesRoot) : null;
   const capabilityIdentity = valid.capability ?? resolvedCapability?.capability;
   const capabilityContext = valid.workflow ? null : loadCapabilityContext(capabilityIdentity, base.cwd);
@@ -20852,8 +21294,17 @@ async function runJob(job, base) {
   const profileName = explicitImplementation ?? capabilitySelectedImplementation;
   if (workflow && shouldRunCapabilityWorkflow(valid, workflow, workflowIdentity, capabilitySelectedImplementation, base)) {
     const workflowCapability = capabilityContext ?? workflowContext;
-    const workflowJob = workflowContext && !valid.why ? { ...valid, why: workflowContext.body } : valid;
-    return runCapabilityWorkflow(workflowJob, workflow, workflowCapability, base);
+    const persistedState = valid.workflowRunId && workflowIdentity && base.config ? readWorkflowRunState(base.config, base.cwd, workflowIdentity, valid.workflowRunId) : null;
+    const workflowJob = {
+      ...workflowContext && !valid.why ? { ...valid, why: workflowContext.body } : valid,
+      ...valid.workflowState ?? persistedState ? { workflowState: valid.workflowState ?? persistedState ?? void 0 } : {}
+    };
+    const checkpoint = valid.workflowRunId && workflowIdentity && base.config ? (state) => writeWorkflowRunState(base.config, base.cwd, workflowIdentity, valid.workflowRunId, state) : void 0;
+    const result = await runCapabilityWorkflow(workflowJob, workflow, workflowCapability, base, checkpoint);
+    if (valid.workflowRunId && workflowIdentity && base.config && result.workflowState) {
+      writeWorkflowRunState(base.config, base.cwd, workflowIdentity, valid.workflowRunId, result.workflowState);
+    }
+    return result;
   }
   if (!profileName) {
     throw new InvalidJobError(`job capability resolves to no implementation: ${capabilityIdentity ?? action}`);
@@ -20933,7 +21384,22 @@ function shouldRunCapabilityWorkflow(job, workflow, capabilityIdentity, selected
   if (!requestedImplementation) return true;
   return requestedImplementation === selectedImplementation || requestedImplementation === capabilityIdentity || requestedImplementation === job.action;
 }
-async function runCapabilityWorkflow(parent, workflow, capability, base) {
+async function runCapabilityWorkflow(parent, workflow, capability, base, checkpoint) {
+  const invalid = workflowError(workflow, base);
+  if (invalid) {
+    if (isGraphWorkflow(workflow)) {
+      const state = initialWorkflowState(parent, workflow);
+      state.status = "blocked";
+      state.blocker = invalid;
+      checkpoint?.(state);
+      return { exitCode: 64, reason: invalid, workflowState: state };
+    }
+    return { exitCode: 64, reason: invalid };
+  }
+  if (isGraphWorkflow(workflow)) return runGraphCapabilityWorkflow(parent, workflow, capability, base, checkpoint);
+  return runLinearCapabilityWorkflow(parent, workflow, capability, base);
+}
+async function runLinearCapabilityWorkflow(parent, workflow, capability, base) {
   let chainData = {
     ...base.preloadedData ?? {},
     runSubjectType: "workflow",
@@ -20997,6 +21463,200 @@ async function runCapabilityWorkflow(parent, workflow, capability, base) {
   }
   return withWorkflowBoundaryEval(capability, result);
 }
+function isGraphWorkflow(workflow) {
+  return workflow.startAt !== void 0 || workflow.steps.some((step) => step.id !== void 0 || step.next !== void 0 || step.inputs !== void 0);
+}
+function workflowError(workflow, base) {
+  const projectCapabilitiesRoot = path46.join(base.cwd, ".kody", "capabilities");
+  const knownCapabilities = /* @__PURE__ */ new Set();
+  const capabilityInputs = /* @__PURE__ */ new Map();
+  for (const step of workflow.steps) {
+    const action = step.action ?? step.capability;
+    const resolvedAction = resolveCapabilityAction(action, projectCapabilitiesRoot);
+    const resolvedFolder = resolveCapabilityFolder(step.capability, projectCapabilitiesRoot);
+    if (!resolvedAction && !resolvedFolder) continue;
+    knownCapabilities.add(step.capability);
+    const inputs = getCapabilityActionInputs(action, projectCapabilitiesRoot);
+    if (inputs) {
+      capabilityInputs.set(
+        step.capability,
+        new Set(inputs.flatMap((input) => [input.name, input.flag.replace(/^--/, "")]))
+      );
+    }
+  }
+  return formatWorkflowValidationIssues(validateWorkflow(workflow, { knownCapabilities, capabilityInputs }))[0] ?? null;
+}
+function initialWorkflowState(parent, workflow) {
+  const prior = parent.workflowState;
+  if (prior?.status === "done") {
+    return {
+      ...prior,
+      status: "done",
+      completedStepIds: [...prior.completedStepIds],
+      transitionCounts: { ...prior.transitionCounts },
+      facts: { ...prior.facts },
+      evidence: { ...prior.evidence },
+      artifacts: prior.artifacts.map((artifact) => ({ ...artifact }))
+    };
+  }
+  const firstStepId = workflow.startAt ?? workflow.steps[0]?.id;
+  const currentStepId = prior?.currentStepId ?? firstStepId;
+  return {
+    status: "running",
+    ...currentStepId ? { currentStepId } : {},
+    completedStepIds: [...prior?.completedStepIds ?? []],
+    transitionCounts: { ...prior?.transitionCounts ?? {} },
+    facts: { ...parent.workflowFacts ?? {}, ...prior?.facts ?? {} },
+    evidence: { ...prior?.evidence ?? {} },
+    artifacts: (prior?.artifacts ?? []).map((artifact) => ({ ...artifact }))
+  };
+}
+function workflowChainData(parent, capability, base, state) {
+  return {
+    ...base.preloadedData ?? {},
+    runSubjectType: "workflow",
+    runSubjectId: capability.slug,
+    runSubjectLabel: capability.title,
+    runSubjectWorkflow: capability.slug,
+    workflowCapability: capability.slug,
+    workflowTitle: capability.title,
+    workflowStepCount: capability.config.workflow?.steps.length ?? 0,
+    workflowIssueNumber: workflowIssueNumber(parent),
+    workflowFacts: state.facts,
+    workflowEvidence: state.evidence,
+    workflowArtifacts: state.artifacts,
+    workflowStack: [
+      ...Array.isArray(base.preloadedData?.workflowStack) ? base.preloadedData.workflowStack.filter((entry) => typeof entry === "string") : [],
+      capability.slug
+    ]
+  };
+}
+async function runGraphCapabilityWorkflow(parent, workflow, capability, base, checkpoint) {
+  const state = initialWorkflowState(parent, workflow);
+  let chainData = workflowChainData(parent, capability, base, state);
+  let result = { exitCode: 0 };
+  let executedSteps = 0;
+  const maxExecutedSteps = 1e3;
+  while (state.currentStepId) {
+    executedSteps += 1;
+    if (executedSteps > maxExecutedSteps) {
+      const reason = `workflow ${capability.slug} exceeded ${maxExecutedSteps} executed steps`;
+      state.status = "blocked";
+      state.blocker = reason;
+      checkpoint?.(state);
+      return { ...result, exitCode: 64, reason, workflowState: state };
+    }
+    const index = workflow.steps.findIndex((step2) => step2.id === state.currentStepId);
+    const step = workflow.steps[index];
+    if (!step) {
+      const reason = `workflow ${capability.slug} current step ${state.currentStepId} is missing`;
+      state.status = "blocked";
+      state.blocker = reason;
+      checkpoint?.(state);
+      return { ...result, exitCode: 64, reason, workflowState: state };
+    }
+    const label = step.action ?? step.capability;
+    checkpoint?.(state);
+    let child;
+    try {
+      child = workflowStepToJob(step, parent, chainData);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      state.status = "blocked";
+      state.blocker = reason;
+      checkpoint?.(state);
+      return { exitCode: 64, reason, workflowState: state };
+    }
+    process.stdout.write(
+      `\u2192 kody: workflow ${capability.slug} step ${index + 1}/${workflow.steps.length} \u2192 ${label}
+
+`
+    );
+    result = await runJob(child, {
+      ...base,
+      preloadedData: {
+        ...chainData,
+        workflowStep: step.id,
+        workflowStepIndex: index + 1,
+        workflowStepReason: step.reason,
+        workflowContinueOn: step.continueOn ?? []
+      }
+    });
+    mergeWorkflowResults(state, result.capabilityResults);
+    const outcome = workflowOutcome(result);
+    const prUrl = result.prUrl ?? result.taskState?.core.prUrl ?? (typeof chainData.workflowPrUrl === "string" ? chainData.workflowPrUrl : void 0);
+    chainData = {
+      ...workflowChainData(parent, capability, base, state),
+      ...result.taskState ? { taskState: result.taskState } : {},
+      ...outcome ? { workflowLastOutcome: outcome } : {},
+      ...result.capabilityResults?.at(-1) ? { workflowLastResult: result.capabilityResults.at(-1) } : {},
+      ...prUrl ? { workflowPrUrl: prUrl } : {},
+      ...parsePrNumber5(prUrl) ? { workflowPrNumber: parsePrNumber5(prUrl) } : {}
+    };
+    if (!state.completedStepIds.includes(step.id)) state.completedStepIds.push(step.id);
+    if (result.exitCode !== 0 && !canContinueWorkflow(step, outcome)) {
+      state.status = "failed";
+      state.blocker = result.reason ?? `workflow step ${step.id} failed`;
+      checkpoint?.(state);
+      return withWorkflowBoundaryEval(capability, { ...result, workflowState: state });
+    }
+    if (!step.next || step.next.length === 0) {
+      state.status = "done";
+      delete state.currentStepId;
+      delete state.blocker;
+      checkpoint?.(state);
+      return withWorkflowBoundaryEval(capability, { ...result, workflowState: state });
+    }
+    const transition = selectWorkflowTransition(step, chainData, state.transitionCounts);
+    if (!transition) {
+      const reason = `workflow step ${step.id} has no available connection`;
+      state.status = "blocked";
+      state.blocker = reason;
+      checkpoint?.(state);
+      return { ...result, exitCode: 64, reason, workflowState: state };
+    }
+    if (transition.maxIterations !== void 0) {
+      const key = `${step.id}->${transition.to}`;
+      state.transitionCounts[key] = (state.transitionCounts[key] ?? 0) + 1;
+    }
+    state.currentStepId = transition.to;
+    state.status = "running";
+    delete state.blocker;
+    checkpoint?.(state);
+  }
+  state.status = "done";
+  checkpoint?.(state);
+  return withWorkflowBoundaryEval(capability, { ...result, workflowState: state });
+}
+function mergeWorkflowResults(state, results) {
+  for (const result of results ?? []) {
+    Object.assign(state.facts, result.facts);
+    Object.assign(state.evidence, result.evidence ?? {});
+    for (const artifact of result.artifacts) {
+      if (!state.artifacts.some(
+        (existing) => existing.label === artifact.label && existing.url === artifact.url && existing.path === artifact.path
+      )) {
+        state.artifacts.push({ ...artifact });
+      }
+    }
+  }
+}
+function selectWorkflowTransition(step, data, counts) {
+  let fallback = null;
+  for (const transition of step.next ?? []) {
+    const key = `${step.id}->${transition.to}`;
+    if (transition.maxIterations !== void 0 && (counts[key] ?? 0) >= transition.maxIterations) continue;
+    if (transition.default === true) {
+      fallback ??= transition;
+      continue;
+    }
+    if (!transition.when || conditionMatches(transition.when, workflowConditionContext(data))) return transition;
+  }
+  return fallback;
+}
+function conditionMatches(condition, context) {
+  return Object.entries(condition).every(([path52, expected]) => valueMatches(resolveDottedPath2(context, path52), expected));
+}
 function withWorkflowBoundaryEval(capability, result) {
   const capabilityKind = capability.config.capabilityKind;
   if (!capabilityKind) return result;
@@ -21017,8 +21677,18 @@ function withWorkflowBoundaryEval(capability, result) {
 }
 function workflowStepToJob(step, parent, chainData) {
   const action = step.action ?? step.capability;
+  const mappedArgs = {};
+  const conditionContext = workflowConditionContext(chainData);
+  for (const [name, mapping] of Object.entries(step.inputs ?? {})) {
+    const value = resolveDottedPath2(conditionContext, mapping.from);
+    if (value === void 0) {
+      throw new InvalidJobError(`workflow step ${step.id ?? action} needs missing input ${mapping.from}`);
+    }
+    mappedArgs[name] = value;
+  }
   const rawArgs = {
     ...parent.cliArgs,
+    ...mappedArgs,
     ...step.cliArgs ?? {}
   };
   const targetNumber = workflowStepTargetNumber(step, parent, chainData);
@@ -21052,9 +21722,7 @@ function workflowStepToJob(step, parent, chainData) {
 function shouldRunWorkflowStep(step, data) {
   if (!step.runWhen) return true;
   const context = workflowConditionContext(data);
-  return Object.entries(step.runWhen).every(
-    ([path51, expected]) => valueMatches(resolveDottedPath2(context, path51), expected)
-  );
+  return conditionMatches(step.runWhen, context);
 }
 function canContinueWorkflow(step, outcome) {
   if (!outcome || !step.continueOn || step.continueOn.length === 0) return false;
@@ -21065,10 +21733,16 @@ function workflowOutcome(result) {
 }
 function workflowConditionContext(data) {
   const lastOutcome = data.workflowLastOutcome;
+  const lastResult = data.workflowLastResult;
   return {
     ...data,
+    facts: data.workflowFacts ?? {},
+    evidence: data.workflowEvidence ?? {},
+    artifacts: data.workflowArtifacts ?? [],
+    result: lastResult,
     workflow: {
       lastOutcome,
+      lastResult,
       issueNumber: data.workflowIssueNumber,
       prNumber: data.workflowPrNumber,
       prUrl: data.workflowPrUrl
@@ -21136,7 +21810,7 @@ function composeStepWhy(parentWhy, step) {
 }
 function loadCapabilityContext(slug, cwd) {
   if (!slug) return null;
-  return resolveCapabilityFolder(slug, path45.join(cwd, ".kody", "capabilities"));
+  return resolveCapabilityFolder(slug, path46.join(cwd, ".kody", "capabilities"));
 }
 function loadWorkflowContext(slug, base) {
   if (!slug || !base.config || !isWorkflowDefinitionId(slug)) return null;
@@ -21175,6 +21849,8 @@ var init_job = __esm({
     init_executor();
     init_registry();
     init_workflowDefinitions();
+    init_workflowRunState();
+    init_workflowValidation();
     init_jobIdentity();
     init_jobIdentity();
     DEFAULT_INSTANT_AGENT = "kody";
@@ -21297,7 +21973,7 @@ function translateOpenAISseToBrain(opts) {
 // src/servers/brain-serve.ts
 import * as fs49 from "fs";
 import { createServer as createServer2 } from "http";
-import * as path48 from "path";
+import * as path49 from "path";
 
 // src/chat/loop.ts
 init_agent();
@@ -21827,8 +22503,8 @@ async function runOpenAIChatTurn(args) {
       })
     });
     if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      const error = `OpenAI-compatible model request failed ${response.status}${text ? `: ${text.slice(0, 500)}` : ""}`;
+      const text2 = await response.text().catch(() => "");
+      const error = `OpenAI-compatible model request failed ${response.status}${text2 ? `: ${text2.slice(0, 500)}` : ""}`;
       await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
       return { exitCode: 99, error };
     }
@@ -21866,8 +22542,8 @@ function extractOpenAIReply(payload) {
     return content.map((part) => {
       if (typeof part === "string") return part;
       if (part && typeof part === "object" && "text" in part) {
-        const text = part.text;
-        return typeof text === "string" ? text : "";
+        const text2 = part.text;
+        return typeof text2 === "string" ? text2 : "";
       }
       return "";
     }).join("");
@@ -21985,7 +22661,7 @@ init_config();
 // src/kody-cli.ts
 import { execFileSync as execFileSync26 } from "child_process";
 import * as fs47 from "fs";
-import * as path46 from "path";
+import * as path47 from "path";
 
 // src/app-auth.ts
 import { createSign } from "crypto";
@@ -22256,7 +22932,7 @@ function autoDispatch(opts) {
   }
   if (eventName !== "issue_comment") return null;
   const comment = objectValue(event.comment);
-  const issue = objectValue(event.issue);
+  const issue2 = objectValue(event.issue);
   const user = objectValue(comment?.user);
   const rawBody = String(comment?.body ?? "");
   const authorLogin = String(user?.login ?? "");
@@ -22265,8 +22941,8 @@ function autoDispatch(opts) {
   const isBotAuthor = authorLogin === "kody-bot" || authorType === "Bot";
   if (!associationAllowed(event, opts?.config)) return null;
   const body = rawBody;
-  const targetNum = Number(issue?.number ?? 0);
-  const isPr = !!issue?.pull_request;
+  const targetNum = Number(issue2?.number ?? 0);
+  const isPr = !!issue2?.pull_request;
   if (!targetNum) return null;
   const afterTag = extractAfterTag(body);
   const firstTokenRaw = extractSubcommand(afterTag);
@@ -22350,7 +23026,7 @@ function autoDispatchTyped(opts) {
     return { kind: "silent", reason: "GHA event payload unreadable" };
   }
   const comment = objectValue(event.comment);
-  const issue = objectValue(event.issue);
+  const issue2 = objectValue(event.issue);
   const user = objectValue(comment?.user);
   const rawBody = String(comment?.body ?? "");
   const authorLogin = String(user?.login ?? "");
@@ -22358,8 +23034,8 @@ function autoDispatchTyped(opts) {
   if (!hasKodyMention(rawBody)) {
     return { kind: "silent", reason: "comment does not mention @kody" };
   }
-  const targetNum = Number(issue?.number ?? 0);
-  const isPr = !!issue?.pull_request;
+  const targetNum = Number(issue2?.number ?? 0);
+  const isPr = !!issue2?.pull_request;
   if (!targetNum) {
     return { kind: "silent", reason: "comment has no associated issue/PR number" };
   }
@@ -22703,7 +23379,8 @@ function routeRunRequest(request) {
     if (intent !== "run" && intent !== "tick") {
       return { kind: "error", error: `workflow target does not support intent '${intent}'` };
     }
-    return { kind: "action", action: target.id, cliArgs: {} };
+    const workflowRunId = typeof request.input?.runId === "string" && /^[a-z0-9][a-z0-9_-]{0,79}$/.test(request.input.runId) ? request.input.runId : void 0;
+    return { kind: "action", action: target.id, cliArgs: {}, ...workflowRunId ? { workflowRunId } : {} };
   }
   return { kind: "error", error: "unsupported run request target" };
 }
@@ -22782,9 +23459,9 @@ async function resolveAuthToken(env = process.env) {
   return void 0;
 }
 function detectPackageManager2(cwd) {
-  if (fs47.existsSync(path46.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs47.existsSync(path46.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs47.existsSync(path46.join(cwd, "bun.lockb"))) return "bun";
+  if (fs47.existsSync(path47.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs47.existsSync(path47.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs47.existsSync(path47.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shouldChainScheduledWatch(match) {
@@ -22907,7 +23584,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path46.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path47.resolve(args.cwd) : process.cwd();
   try {
     const n = unpackAllSecrets();
     if (n > 0) process.stdout.write(`\u2192 kody: unpacked ${n} secret(s) from ALL_SECRETS
@@ -22931,6 +23608,7 @@ async function runCi(argv) {
   let manualWorkflowDispatch = false;
   let forceRunAction = null;
   let forceRunCliArgs = {};
+  let forceWorkflowRunId;
   let runRequestFanOut = false;
   let runRequestFanOutForce = false;
   const parsedRunRequest = readRunRequestFromEnv();
@@ -22955,6 +23633,7 @@ async function runCi(argv) {
     } else if (route.kind === "action") {
       forceRunAction = route.action;
       forceRunCliArgs = route.cliArgs;
+      forceWorkflowRunId = route.workflowRunId;
     }
   }
   const envForceAction = (process.env.KODY_FORCE_ACTION ?? "").trim();
@@ -23052,6 +23731,7 @@ async function runCi(argv) {
         capability: route.capability,
         workflow: route.workflow,
         implementation: route.implementation,
+        workflowRunId: forceWorkflowRunId,
         cliArgs: { ...route.cliArgs, ...forceRunCliArgs },
         flavor: "instant",
         force: true
@@ -23341,7 +24021,7 @@ init_repoWorkspace();
 // src/scripts/brainTurnLog.ts
 init_runtimePaths();
 import * as fs48 from "fs";
-import * as path47 from "path";
+import * as path48 from "path";
 import posixPath4 from "path/posix";
 var live = /* @__PURE__ */ new Map();
 function brainEventsFilePath(dir, chatId) {
@@ -23391,7 +24071,7 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = brainEventsFilePath(dir, chatId);
-  fs48.mkdirSync(path47.dirname(p), { recursive: true });
+  fs48.mkdirSync(path48.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
@@ -23769,7 +24449,7 @@ async function handleChatTurn(req, res, chatId, opts) {
       );
     }
   }
-  fs49.mkdirSync(path48.dirname(sessionFile), { recursive: true });
+  fs49.mkdirSync(path49.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
     role: "user",
     content: message,
@@ -23844,7 +24524,7 @@ async function handleChatTurn(req, res, chatId, opts) {
 function buildServer(opts) {
   const runTurn = opts.runTurn ?? runChatTurn;
   const cloneRepo = opts.cloneRepo ?? defaultCloneRepo;
-  const reposRoot = opts.reposRoot ?? path48.join(path48.dirname(path48.resolve(opts.cwd)), "repos");
+  const reposRoot = opts.reposRoot ?? path49.join(path49.dirname(path49.resolve(opts.cwd)), "repos");
   return createServer2(async (req, res) => {
     if (!req.method || !req.url) {
       sendJson(res, 400, { error: "bad request" });
@@ -24448,7 +25128,7 @@ async function loadConfigSafe() {
 
 // src/chat-cli.ts
 import * as fs51 from "fs";
-import * as path50 from "path";
+import * as path51 from "path";
 
 // src/chat/inbox.ts
 import { execFileSync as execFileSync27 } from "child_process";
@@ -24521,9 +25201,9 @@ function currentBranch(cwd) {
 // src/chat/state-sync.ts
 init_stateRepo();
 import * as fs50 from "fs";
-import * as path49 from "path";
-function jsonlLines2(text) {
-  return text.split("\n").filter((line) => line.length > 0);
+import * as path50 from "path";
+function jsonlLines2(text2) {
+  return text2.split("\n").filter((line) => line.length > 0);
 }
 function renderJsonl2(lines) {
   return lines.length > 0 ? `${lines.join("\n")}
@@ -24541,7 +25221,7 @@ function syncJsonlFileFromState(opts) {
   const local = fs50.existsSync(opts.localPath) ? fs50.readFileSync(opts.localPath, "utf-8") : "";
   const next = mergeJsonl2(local, remote.content);
   if (next === local) return;
-  fs50.mkdirSync(path49.dirname(opts.localPath), { recursive: true });
+  fs50.mkdirSync(path50.dirname(opts.localPath), { recursive: true });
   fs50.writeFileSync(opts.localPath, next);
 }
 function persistJsonlFileToState(opts) {
@@ -24811,7 +25491,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path50.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path51.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const runRequest = readRunRequestFromEnv();
   if (runRequest && "request" in runRequest) {
@@ -24991,8 +25671,8 @@ var FlyClient = class {
   get fetch() {
     return this.opts.fetchImpl ?? fetch;
   }
-  async call(path51, init = {}) {
-    const res = await this.fetch(`${FLY_API_BASE}${path51}`, {
+  async call(path52, init = {}) {
+    const res = await this.fetch(`${FLY_API_BASE}${path52}`, {
       method: init.method ?? "GET",
       headers: {
         Authorization: `Bearer ${this.opts.token}`,
@@ -25002,8 +25682,8 @@ var FlyClient = class {
     });
     if (res.status === 404 && init.allow404) return null;
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Fly API ${res.status} on ${path51}: ${text.slice(0, 200) || res.statusText}`);
+      const text2 = await res.text().catch(() => "");
+      throw new Error(`Fly API ${res.status} on ${path52}: ${text2.slice(0, 200) || res.statusText}`);
     }
     if (res.status === 204) return null;
     const raw = await res.text();
@@ -26350,11 +27030,11 @@ function envRunMode(env = process.env) {
     return { ...result, command: "ci", ciArgv: [] };
   }
   if (mode === "issue") {
-    const issue = (env.ISSUE_NUMBER ?? "").trim();
-    if (!issue) {
+    const issue2 = (env.ISSUE_NUMBER ?? "").trim();
+    if (!issue2) {
       return { ...result, errors: ["KODY_RUN_MODE=issue requires ISSUE_NUMBER"] };
     }
-    return { ...result, command: "ci", ciArgv: ["--issue", issue] };
+    return { ...result, command: "ci", ciArgv: ["--issue", issue2] };
   }
   return { ...result, errors: [`unknown KODY_RUN_MODE: ${mode}`] };
 }