@kody-ade/kody-engine 0.4.498 → 0.4.500

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.498",
+      version: "0.4.500",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -4117,521 +4117,916 @@ var init_task_artifacts = __esm({
   }
 });
 
-// src/gha.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import * as fs18 from "fs";
-function getRunUrl() {
-  const server = process.env.GITHUB_SERVER_URL;
-  const repo = process.env.GITHUB_REPOSITORY;
-  const runId = process.env.GITHUB_RUN_ID;
-  if (!server || !repo || !runId) return "";
-  return `${server}/${repo}/actions/runs/${runId}`;
-}
-function reactToTriggerComment(cwd) {
-  if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
-  const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs18.existsSync(eventPath)) return;
-  let event = null;
-  try {
-    event = JSON.parse(fs18.readFileSync(eventPath, "utf-8"));
-  } catch {
-    return;
-  }
-  const commentId = event?.comment?.id;
-  const repo = process.env.GITHUB_REPOSITORY;
-  if (!commentId || !repo) return;
-  const token = process.env.KODY_TOKEN?.trim() || process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
-  const args = [
-    "api",
-    "-X",
-    "POST",
-    "-H",
-    "Accept: application/vnd.github+json",
-    `/repos/${repo}/issues/comments/${commentId}/reactions`,
-    "-f",
-    "content=eyes"
-  ];
-  const opts = {
-    cwd,
-    env: { ...process.env, GH_TOKEN: token ?? process.env.GH_TOKEN ?? "" },
-    stdio: "pipe",
-    timeout: 15e3
-  };
-  let lastErr = null;
-  for (let attempt = 0; attempt < 3; attempt++) {
-    if (attempt > 0) sleepMs(attempt === 1 ? 500 : 1500);
-    try {
-      execFileSync2("gh", args, opts);
-      return;
-    } catch (err) {
-      lastErr = err;
-    }
-  }
-  process.stderr.write(
-    `[kody] \u{1F440} reaction failed after 3 attempts on comment ${commentId}: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}
-`
-  );
-}
-function sleepMs(ms) {
-  try {
-    execFileSync2("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
-  } catch {
-  }
-}
-var init_gha = __esm({
-  "src/gha.ts"() {
-    "use strict";
-  }
-});
-
-// src/agencyBoundaryEval.ts
-function evaluateAgencyBoundaries(input) {
-  const findings = [];
-  const results = input.results ?? [];
-  findings.push(evaluateObserveBoundary(input.capabilityKind, results));
-  findings.push(evaluateVerifyBoundary(input.capabilityKind, results));
-  findings.push(evaluateGoalOwnershipBoundary(results));
-  return {
-    version: 1,
-    status: findings.some((finding) => finding.status === "fail") ? "fail" : "pass",
-    ...input.capability ? { capability: input.capability } : {},
-    ...input.capabilityKind ? { capabilityKind: input.capabilityKind } : {},
-    findings
-  };
-}
-function evaluateObserveBoundary(capabilityKind, results) {
-  if (capabilityKind !== "observe") {
-    return pass("observe-does-not-act", "capability is not observe", { capabilityKind });
+// src/workflowValidation.ts
+function validateWorkflow(value, options = {}) {
+  const issues = [];
+  const workflow = asRecord(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;
   }
-  const actionResults = results.filter(resultLooksLikeAction);
-  if (actionResults.length === 0) {
-    return pass("observe-does-not-act", "observe capability reported facts without action output", {
-      resultCount: results.length
-    });
+  if (rawSteps.length > maxSteps) {
+    issue(issues, "too_many_steps", "steps", `workflow has ${rawSteps.length} steps; maximum is ${maxSteps}`);
   }
-  return fail("observe-does-not-act", "observe capability returned action-shaped output", {
-    resultCount: results.length,
-    actionResults: actionResults.map(resultSummary)
+  const graphMode = workflow?.startAt !== void 0 || rawSteps.some((entry) => {
+    const step = asRecord(entry);
+    return Boolean(step && (step.id !== void 0 || step.next !== void 0));
   });
-}
-function evaluateVerifyBoundary(capabilityKind, results) {
-  if (capabilityKind !== "verify") {
-    return pass("verify-does-not-fix", "capability is not verify", { capabilityKind });
-  }
-  const actionResults = results.filter(resultLooksLikeAction);
-  if (actionResults.length === 0) {
-    return pass("verify-does-not-fix", "verify capability returned verdict evidence without action output", {
-      resultCount: results.length
-    });
-  }
-  return fail("verify-does-not-fix", "verify capability returned fix/change output", {
-    resultCount: results.length,
-    actionResults: actionResults.map(resultSummary)
+  const steps = rawSteps.map(
+    (entry) => typeof entry === "string" ? { capability: entry } : asRecord(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_STEP_ID.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);
+    if (step.delivery !== void 0 && step.delivery !== "pull-request") {
+      issue(issues, "invalid_delivery", `${base}.delivery`, "workflow step delivery must be pull-request");
+    }
+    if (step.input !== void 0 && !isJsonValue(step.input)) {
+      issue(issues, "invalid_input", `${base}.input`, "workflow step input must be one JSON value");
+    }
   });
-}
-function evaluateGoalOwnershipBoundary(results) {
-  const targetBearing = results.filter((result) => result.target?.type === "goal");
-  if (targetBearing.length === 0) {
-    return pass("capability-does-not-own-goal-progress", "capability output is parent-neutral", {
-      resultCount: results.length
-    });
-  }
-  return fail("capability-does-not-own-goal-progress", "capability output names a goal target", {
-    resultCount: results.length,
-    targetBearingResults: targetBearing.map(resultSummary)
+  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);
   });
-}
-function resultLooksLikeAction(result) {
-  if (result.status === "changed") return true;
-  return Object.keys(result.facts).some((key) => ACTION_FACT_KEYS.has(key));
-}
-function resultSummary(result) {
-  return {
-    status: result.status,
-    summary: result.summary,
-    target: result.target,
-    actionFactKeys: Object.keys(result.facts).filter((key) => ACTION_FACT_KEYS.has(key))
-  };
-}
-function pass(rule, message, evidence) {
-  return { rule, status: "pass", message, evidence };
-}
-function fail(rule, message, evidence) {
-  return { rule, status: "fail", message, evidence };
-}
-var ACTION_FACT_KEYS;
-var init_agencyBoundaryEval = __esm({
-  "src/agencyBoundaryEval.ts"() {
-    "use strict";
-    ACTION_FACT_KEYS = /* @__PURE__ */ new Set(["changedResources", "createdResources", "actionResult"]);
-  }
-});
-
-// src/agency/capability-contract-validation.ts
-import Ajv from "ajv";
-function validateCapabilityContractValue(boundary, schema, value) {
-  const validate = validator.compile(schema);
-  if (!validate(value)) {
-    throw new CapabilityContractValidationError(boundary, validate.errors ?? []);
-  }
-}
-function capabilityContractInput(inputs, args, capabilityId, contractProperties = []) {
-  const isGenericRunnerInput = inputs.some((input) => input.name === "input") && Object.hasOwn(args, "input");
-  if (!isGenericRunnerInput) {
-    const isParameterlessGenericRunner = (inputs.some((input) => input.name === "capability") || args.capability === capabilityId || !contractProperties.includes("capability")) && Object.hasOwn(args, "capability");
-    if (!isParameterlessGenericRunner) return args;
-    const { capability: _routingCapability, ...businessArgs } = args;
-    return businessArgs;
-  }
-  const value = args.input;
-  if (typeof value !== "string") return value;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
+  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>"}`);
   }
-}
-var validator, CapabilityContractValidationError;
-var init_capability_contract_validation = __esm({
-  "src/agency/capability-contract-validation.ts"() {
-    "use strict";
-    validator = new Ajv({
-      allErrors: true,
-      strict: true,
-      validateFormats: false
+  const adjacency = /* @__PURE__ */ new Map();
+  const explicitEndSources = /* @__PURE__ */ new Set();
+  steps.forEach((step, index) => {
+    if (!step) return;
+    const id = text(step.id);
+    if (!id) return;
+    const sourceCapability = text(step.capability ?? step.action);
+    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) => asRecord(transition)?.default === true);
+    const conditionals = transitions.filter((transition) => asRecord(transition)?.when !== void 0);
+    const unconditional = transitions.filter((transition) => {
+      const raw = asRecord(transition);
+      return typeof transition === "string" || Boolean(raw && raw.when === void 0 && raw.default !== true && raw.maxIterations === void 0);
     });
-    CapabilityContractValidationError = class extends Error {
-      constructor(boundary, errors) {
-        const details = errors.map((error) => {
-          const location = error.instancePath || "$";
-          const property = error.keyword === "additionalProperties" && typeof error.params.additionalProperty === "string" ? ` (${error.params.additionalProperty})` : "";
-          return `${location}: ${error.message ?? error.keyword}${property}`;
-        }).join("; ");
-        super(
-          `Capability ${boundary} does not match its declared contract: ${details}`
+    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 } : asRecord(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 || target !== "$end" && !SAFE_STEP_ID.test(target)) {
+        issue(issues, "invalid_transition_target", `${base}.to`, "workflow connection must name a valid target step");
+        return;
+      }
+      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) {
+        const outputPaths = options.capabilityOutputs?.get(sourceCapability ?? "");
+        validateDataMatch(raw.when, `${base}.when`, issues, outputPaths);
+      }
+      if (target === "$end") {
+        explicitEndSources.add(id);
+        return;
+      }
+      if (!seen.has(target)) {
+        issue(
+          issues,
+          "missing_transition_target",
+          `${base}.to`,
+          `workflow step ${id} connects to missing step ${target}`
         );
-        this.boundary = boundary;
-        this.errors = errors;
-        this.name = "CapabilityContractValidationError";
+      } else {
+        adjacency.get(id)?.push(target);
       }
-      boundary;
-      errors;
-    };
+      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 || explicitEndSources.has(id))) {
+      issue(issues, "missing_terminal_step", "steps", "workflow has no reachable final step");
+    }
   }
-});
-
-// src/capabilityReport.ts
-function parseCapabilityReportsFromText(text2) {
-  const reports = [];
-  for (const match of text2.matchAll(REPORT_LINE)) {
-    const raw = match[1]?.trim();
-    if (!raw) continue;
-    try {
-      const parsed = parseCapabilityReport(JSON.parse(raw));
-      if (parsed) reports.push(parsed);
-    } catch {
+  return issues;
+}
+function formatWorkflowValidationIssues(issues) {
+  return issues.map((entry) => `${entry.path}: ${entry.message}`);
+}
+function validateDataMatch(value, path53, issues, capabilityOutputs) {
+  if (value === void 0) return;
+  const match = asRecord(value);
+  if (!match || Object.keys(match).length === 0) {
+    issue(issues, "invalid_condition", path53, "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",
+        `${path53}.${field}`,
+        `workflow condition must read from facts, evidence, artifacts, result, workflow, or lastOutcome`
+      );
+    }
+    if (capabilityOutputs && field.startsWith("result.") && !capabilityOutputs.has(field)) {
+      issue(
+        issues,
+        "undeclared_result_path",
+        `${path53}.${field}`,
+        `workflow condition reads ${field}, but the source capability does not declare it`
+      );
+    }
+    if (!isComparable(expected)) {
+      issue(issues, "invalid_condition_value", `${path53}.${field}`, "workflow condition value must be a JSON scalar");
     }
   }
-  return reports;
 }
-function parseCapabilityReport(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const obj = raw;
-  const target = parseCapabilityReportTarget(obj.target);
-  if (!target) return null;
-  const evidence = parseCapabilityReportEvidence(obj.evidence);
-  const facts = parseFacts(obj.facts);
-  if (!evidence && !facts) return null;
-  return {
-    target,
-    ...evidence ? { evidence } : {},
-    ...facts ? { facts } : {}
-  };
+function transitionList(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
 }
-function parseCapabilityReportTarget(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const target = raw;
-  if (target.type !== "goal" && target.type !== "task" && target.type !== "capability") return null;
-  if (typeof target.id !== "string" || target.id.trim().length === 0) return null;
-  return { type: target.type, id: target.id.trim() };
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function parseCapabilityReportEvidence(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const out = {};
-  for (const [key, value] of Object.entries(raw)) {
-    if (typeof key !== "string" || key.length === 0 || typeof value !== "boolean") return null;
-    out[key] = value;
-  }
-  return out;
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function parseFacts(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const out = {};
-  for (const [key, value] of Object.entries(raw)) {
-    if (typeof key !== "string" || key.length === 0) return null;
-    if (CONTROL_FACT_KEYS.has(key)) continue;
-    out[key] = value;
-  }
-  return out;
+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));
 }
-var REPORT_LINE, CONTROL_FACT_KEYS;
-var init_capabilityReport = __esm({
-  "src/capabilityReport.ts"() {
+function isJsonValue(value) {
+  if (value === null || ["string", "number", "boolean"].includes(typeof value)) return true;
+  if (Array.isArray(value)) return value.every(isJsonValue);
+  if (!value || typeof value !== "object") return false;
+  return Object.values(value).every(isJsonValue);
+}
+function issue(issues, code, path53, message) {
+  issues.push({ code, path: path53, message });
+}
+var SAFE_NAME, SAFE_STEP_ID, SAFE_DATA_PATH, SUPPORTED_STEP_FIELDS, SUPPORTED_TRANSITION_FIELDS;
+var init_workflowValidation = __esm({
+  "src/workflowValidation.ts"() {
     "use strict";
-    REPORT_LINE = /^KODY_(?:CAPABILITY|CAPABILITY)_REPORT=(.+)$/gm;
-    CONTROL_FACT_KEYS = /* @__PURE__ */ new Set(["blockers", "destination", "capabilities", "route", "stage", "state"]);
+    SAFE_NAME = /^[a-z][a-z0-9-]*$/;
+    SAFE_STEP_ID = /^[A-Za-z][A-Za-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",
+      "input",
+      "action",
+      "evidence",
+      "target",
+      "delivery",
+      "targetFact",
+      "reason",
+      "next",
+      "runWhen",
+      "continueOn",
+      "saveReport",
+      "report"
+    ]);
+    SUPPORTED_TRANSITION_FIELDS = /* @__PURE__ */ new Set(["to", "when", "default", "maxIterations"]);
   }
 });
 
-// src/goal/evidenceState.ts
-function parseGoalEvidenceState(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
-  const out = {};
-  for (const [evidence, value] of Object.entries(raw)) {
-    const progress = parseGoalEvidenceProgress(value);
-    if (progress) out[evidence] = progress;
-  }
-  return out;
-}
-function mergeGoalEvidenceProgress(state, evidence, update) {
-  const prior = state[evidence];
-  const next = {
-    resultClass: update.resultClass,
-    attempts: update.attempts ?? prior?.attempts ?? 0,
-    ...prior?.reason ? { reason: prior.reason } : {},
-    ...prior?.nextAction ? { nextAction: prior.nextAction } : {},
-    ...prior?.nextRetryAt ? { nextRetryAt: prior.nextRetryAt } : {},
-    ...prior?.issue ? { issue: prior.issue } : {},
-    ...prior?.updatedAt ? { updatedAt: prior.updatedAt } : {},
-    ...definedProgressFields(update)
-  };
-  return {
-    ...state,
-    [evidence]: next
-  };
+// src/workflowDefinitions.ts
+import * as fs16 from "fs";
+import * as path17 from "path";
+function isWorkflowDefinitionId(value) {
+  return WORKFLOW_ID_PATTERN.test(value);
 }
-function isGoalEvidenceResultClass(value) {
-  return value === "succeeded" || value === "pending" || value === "retryable" || value === "needsFix" || value === "fatal";
+function workflowDefinitionPath(id) {
+  if (!isWorkflowDefinitionId(id)) {
+    throw new Error(`Invalid workflow id "${id}"`);
+  }
+  return `workflows/${id}/workflow.json`;
 }
-function parseGoalEvidenceProgress(value) {
+function normalizeWorkflowDefinition(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const raw = value;
-  if (!isGoalEvidenceResultClass(raw.resultClass)) return null;
-  const attempts = typeof raw.attempts === "number" && raw.attempts >= 0 ? Math.floor(raw.attempts) : 0;
+  const name = typeof raw.name === "string" ? raw.name.trim() : "";
+  const requestedAgent = typeof raw.agent === "string" ? raw.agent.trim() : "";
+  const agent = /^[a-z][a-z0-9-]*$/.test(requestedAgent) ? requestedAgent : "kody";
+  if (Array.isArray(raw.steps)) {
+    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;
   return {
-    resultClass: raw.resultClass,
-    attempts,
-    ...stringField2(raw.reason) ? { reason: stringField2(raw.reason) } : {},
-    ...stringField2(raw.nextAction) ? { nextAction: stringField2(raw.nextAction) } : {},
-    ...stringField2(raw.nextRetryAt) ? { nextRetryAt: stringField2(raw.nextRetryAt) } : {},
-    ...positiveInteger(raw.issue) ? { issue: positiveInteger(raw.issue) } : {},
-    ...stringField2(raw.updatedAt) ? { updatedAt: stringField2(raw.updatedAt) } : {}
+    name,
+    agent,
+    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 } : {}
   };
 }
-function definedProgressFields(update) {
-  const out = {};
-  if (update.reason !== void 0) out.reason = update.reason;
-  if (update.nextAction !== void 0) out.nextAction = update.nextAction;
-  if (update.nextRetryAt !== void 0) out.nextRetryAt = update.nextRetryAt;
-  if (update.issue !== void 0) out.issue = update.issue;
-  if (update.updatedAt !== void 0) out.updatedAt = update.updatedAt;
-  return out;
+function readWorkflowDefinition(_config, cwd, id) {
+  const root = cwd ?? process.cwd();
+  const relativePath = workflowDefinitionPath(id);
+  const candidates = [
+    path17.join(root, ".kody-engine", "runtime", relativePath),
+    path17.join(definitionsRoot(root), relativePath)
+  ];
+  for (const filePath of candidates) {
+    if (!fs16.existsSync(filePath)) continue;
+    const workflow = parseWorkflowDefinition(fs16.readFileSync(filePath, "utf8"));
+    if (workflow) return workflow;
+  }
+  return null;
 }
-function stringField2(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+function workflowDefinitionToCapabilityFolder(id, workflow, source = workflowDefinitionPath(id)) {
+  return {
+    slug: id,
+    dir: path17.dirname(source),
+    profilePath: source,
+    bodyPath: source,
+    title: workflow.name,
+    body: "",
+    rawBody: "",
+    rawProfile: { name: id, workflow },
+    config: {
+      action: id,
+      workflow: workflowDefinitionToConfig(workflow),
+      describe: workflow.name,
+      agent: workflow.agent
+    }
+  };
 }
-function positiveInteger(value) {
-  if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
-  return void 0;
+function normalizeWorkflowCapabilities(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const capabilities = [];
+  for (const item of value) {
+    if (typeof item !== "string") continue;
+    const slug = item.trim();
+    if (!CAPABILITY_ID_PATTERN.test(slug) || seen.has(slug)) continue;
+    seen.add(slug);
+    capabilities.push(slug);
+  }
+  return capabilities;
 }
-var init_evidenceState = __esm({
-  "src/goal/evidenceState.ts"() {
+function workflowDefinitionToConfig(workflow) {
+  return {
+    steps: workflow.steps ?? workflow.capabilities.map((capability) => ({ capability })),
+    ...workflow.startAt ? { startAt: workflow.startAt } : {}
+  };
+}
+function parseWorkflowDefinition(content) {
+  try {
+    return normalizeWorkflowDefinition(JSON.parse(content));
+  } catch {
+    return null;
+  }
+}
+var WORKFLOW_ID_PATTERN, CAPABILITY_ID_PATTERN;
+var init_workflowDefinitions = __esm({
+  "src/workflowDefinitions.ts"() {
     "use strict";
+    init_capabilityFolders();
+    init_definition_paths();
+    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}$/;
   }
 });
 
-// src/capabilityResult.ts
-function parseCapabilityResultsFromText(text2) {
-  const results = [];
-  for (const match of text2.matchAll(RESULT_LINE)) {
-    const raw = match[1]?.trim();
-    if (!raw) continue;
+// src/gha.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import * as fs19 from "fs";
+function getRunUrl() {
+  const server = process.env.GITHUB_SERVER_URL;
+  const repo = process.env.GITHUB_REPOSITORY;
+  const runId = process.env.GITHUB_RUN_ID;
+  if (!server || !repo || !runId) return "";
+  return `${server}/${repo}/actions/runs/${runId}`;
+}
+function reactToTriggerComment(cwd) {
+  if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventPath || !fs19.existsSync(eventPath)) return;
+  let event = null;
+  try {
+    event = JSON.parse(fs19.readFileSync(eventPath, "utf-8"));
+  } catch {
+    return;
+  }
+  const commentId = event?.comment?.id;
+  const repo = process.env.GITHUB_REPOSITORY;
+  if (!commentId || !repo) return;
+  const token = process.env.KODY_TOKEN?.trim() || process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+  const args = [
+    "api",
+    "-X",
+    "POST",
+    "-H",
+    "Accept: application/vnd.github+json",
+    `/repos/${repo}/issues/comments/${commentId}/reactions`,
+    "-f",
+    "content=eyes"
+  ];
+  const opts = {
+    cwd,
+    env: { ...process.env, GH_TOKEN: token ?? process.env.GH_TOKEN ?? "" },
+    stdio: "pipe",
+    timeout: 15e3
+  };
+  let lastErr = null;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    if (attempt > 0) sleepMs(attempt === 1 ? 500 : 1500);
     try {
-      const parsed = parseCapabilityResult(JSON.parse(raw));
-      if (parsed) results.push(parsed);
-    } catch {
+      execFileSync2("gh", args, opts);
+      return;
+    } catch (err) {
+      lastErr = err;
     }
   }
-  return results;
+  process.stderr.write(
+    `[kody] \u{1F440} reaction failed after 3 attempts on comment ${commentId}: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}
+`
+  );
 }
-function parseCapabilityResult(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const obj = raw;
-  if (obj.version !== 1) return null;
-  if (!isCapabilityResultStatus(obj.status)) return null;
-  const summary = typeof obj.summary === "string" ? obj.summary.trim() : "";
-  if (!summary) return null;
-  const target = obj.target === void 0 ? void 0 : parseCapabilityReportTarget(obj.target);
-  if (obj.target !== void 0 && !target) return null;
-  const evidence = obj.evidence === void 0 ? void 0 : parseCapabilityReportEvidence(obj.evidence);
-  if (obj.evidence !== void 0 && !evidence) return null;
-  const facts = parseFacts2(obj.facts);
-  if (!facts) return null;
-  const artifacts = parseArtifacts(obj.artifacts);
-  if (!artifacts) return null;
-  const missingEvidence = parseOptionalStringArray(obj.missingEvidence);
-  if (!missingEvidence) return null;
-  const blockers = parseOptionalStringArray(obj.blockers);
-  if (!blockers) return null;
+function sleepMs(ms) {
+  try {
+    execFileSync2("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
+  } catch {
+  }
+}
+var init_gha = __esm({
+  "src/gha.ts"() {
+    "use strict";
+  }
+});
+
+// src/agencyBoundaryEval.ts
+function evaluateAgencyBoundaries(input) {
+  const findings = [];
+  const results = input.results ?? [];
+  findings.push(evaluateObserveBoundary(input.capabilityKind, results));
+  findings.push(evaluateVerifyBoundary(input.capabilityKind, results));
+  findings.push(evaluateGoalOwnershipBoundary(results));
   return {
     version: 1,
-    ...target ? { target } : {},
-    status: obj.status,
-    ...isGoalEvidenceResultClass(obj.resultClass) ? { resultClass: obj.resultClass } : {},
-    summary,
-    ...evidence ? { evidence } : {},
-    facts,
-    artifacts,
-    missingEvidence,
-    blockers
+    status: findings.some((finding) => finding.status === "fail") ? "fail" : "pass",
+    ...input.capability ? { capability: input.capability } : {},
+    ...input.capabilityKind ? { capabilityKind: input.capabilityKind } : {},
+    findings
   };
 }
-function isCapabilityResultStatus(value) {
-  return typeof value === "string" && STATUSES.has(value);
-}
-function parseFacts2(raw) {
-  if (raw === void 0) return {};
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const facts = {};
-  for (const [key, value] of Object.entries(raw)) {
-    if (!key.trim()) return null;
-    if (CONTROL_FACT_KEYS2.has(key)) continue;
-    facts[key] = value;
+function evaluateObserveBoundary(capabilityKind, results) {
+  if (capabilityKind !== "observe") {
+    return pass("observe-does-not-act", "capability is not observe", { capabilityKind });
   }
-  return facts;
-}
-function parseStringArray(raw) {
-  if (!Array.isArray(raw)) return null;
-  const out = [];
-  for (const item of raw) {
-    if (typeof item !== "string") return null;
-    out.push(item);
+  const actionResults = results.filter(resultLooksLikeAction);
+  if (actionResults.length === 0) {
+    return pass("observe-does-not-act", "observe capability reported facts without action output", {
+      resultCount: results.length
+    });
   }
-  return out;
+  return fail("observe-does-not-act", "observe capability returned action-shaped output", {
+    resultCount: results.length,
+    actionResults: actionResults.map(resultSummary)
+  });
 }
-function parseOptionalStringArray(raw) {
-  if (raw === void 0) return [];
-  return parseStringArray(raw);
+function evaluateVerifyBoundary(capabilityKind, results) {
+  if (capabilityKind !== "verify") {
+    return pass("verify-does-not-fix", "capability is not verify", { capabilityKind });
+  }
+  const actionResults = results.filter(resultLooksLikeAction);
+  if (actionResults.length === 0) {
+    return pass("verify-does-not-fix", "verify capability returned verdict evidence without action output", {
+      resultCount: results.length
+    });
+  }
+  return fail("verify-does-not-fix", "verify capability returned fix/change output", {
+    resultCount: results.length,
+    actionResults: actionResults.map(resultSummary)
+  });
 }
-function parseArtifacts(raw) {
-  if (raw === void 0) return [];
-  if (!Array.isArray(raw)) return null;
-  const artifacts = [];
-  for (const item of raw) {
-    if (!item || typeof item !== "object" || Array.isArray(item)) return null;
-    const rawArtifact = item;
-    const label = typeof rawArtifact.label === "string" ? rawArtifact.label.trim() : "";
-    const url = typeof rawArtifact.url === "string" ? rawArtifact.url.trim() : "";
-    const artifactPath = typeof rawArtifact.path === "string" ? rawArtifact.path.trim() : "";
-    if (!label || !url && !artifactPath) return null;
-    artifacts.push({
-      label,
-      ...url ? { url } : {},
-      ...artifactPath ? { path: artifactPath } : {}
+function evaluateGoalOwnershipBoundary(results) {
+  const targetBearing = results.filter((result) => result.target?.type === "goal");
+  if (targetBearing.length === 0) {
+    return pass("capability-does-not-own-goal-progress", "capability output is parent-neutral", {
+      resultCount: results.length
     });
   }
-  return artifacts;
+  return fail("capability-does-not-own-goal-progress", "capability output names a goal target", {
+    resultCount: results.length,
+    targetBearingResults: targetBearing.map(resultSummary)
+  });
 }
-var RESULT_LINE, STATUSES, CONTROL_FACT_KEYS2;
-var init_capabilityResult = __esm({
-  "src/capabilityResult.ts"() {
+function resultLooksLikeAction(result) {
+  if (result.status === "changed") return true;
+  return Object.keys(result.facts).some((key) => ACTION_FACT_KEYS.has(key));
+}
+function resultSummary(result) {
+  return {
+    status: result.status,
+    summary: result.summary,
+    target: result.target,
+    actionFactKeys: Object.keys(result.facts).filter((key) => ACTION_FACT_KEYS.has(key))
+  };
+}
+function pass(rule, message, evidence) {
+  return { rule, status: "pass", message, evidence };
+}
+function fail(rule, message, evidence) {
+  return { rule, status: "fail", message, evidence };
+}
+var ACTION_FACT_KEYS;
+var init_agencyBoundaryEval = __esm({
+  "src/agencyBoundaryEval.ts"() {
     "use strict";
-    init_capabilityReport();
-    init_evidenceState();
-    RESULT_LINE = /^KODY_(?:CAPABILITY|CAPABILITY)_RESULT=(.+)$/gm;
-    STATUSES = /* @__PURE__ */ new Set(["pass", "fail", "blocked", "changed", "noop"]);
-    CONTROL_FACT_KEYS2 = /* @__PURE__ */ new Set(["blockers", "destination", "capabilities", "route", "stage", "state"]);
+    ACTION_FACT_KEYS = /* @__PURE__ */ new Set(["changedResources", "createdResources", "actionResult"]);
   }
 });
 
-// src/profile-error.ts
-var ProfileError;
-var init_profile_error = __esm({
-  "src/profile-error.ts"() {
+// src/agency/capability-contract-validation.ts
+import Ajv from "ajv";
+function validateCapabilityContractValue(boundary, schema, value) {
+  const validate = validator.compile(schema);
+  if (!validate(value)) {
+    throw new CapabilityContractValidationError(boundary, validate.errors ?? []);
+  }
+}
+function capabilityContractInput(inputs, args, capabilityId, contractProperties = []) {
+  const isGenericRunnerInput = inputs.some((input) => input.name === "input") && Object.hasOwn(args, "input");
+  if (!isGenericRunnerInput) {
+    const isParameterlessGenericRunner = (inputs.some((input) => input.name === "capability") || args.capability === capabilityId || !contractProperties.includes("capability")) && Object.hasOwn(args, "capability");
+    if (!isParameterlessGenericRunner) return args;
+    const { capability: _routingCapability, ...businessArgs } = args;
+    return businessArgs;
+  }
+  const value = args.input;
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+var validator, CapabilityContractValidationError;
+var init_capability_contract_validation = __esm({
+  "src/agency/capability-contract-validation.ts"() {
     "use strict";
-    ProfileError = class extends Error {
-      constructor(profilePath, message) {
-        super(`Invalid profile at ${profilePath}:
-  ${message}`);
-        this.profilePath = profilePath;
-        this.name = "ProfileError";
+    validator = new Ajv({
+      allErrors: true,
+      strict: true,
+      validateFormats: false
+    });
+    CapabilityContractValidationError = class extends Error {
+      constructor(boundary, errors) {
+        const details = errors.map((error) => {
+          const location = error.instancePath || "$";
+          const property = error.keyword === "additionalProperties" && typeof error.params.additionalProperty === "string" ? ` (${error.params.additionalProperty})` : "";
+          return `${location}: ${error.message ?? error.keyword}${property}`;
+        }).join("; ");
+        super(
+          `Capability ${boundary} does not match its declared contract: ${details}`
+        );
+        this.boundary = boundary;
+        this.errors = errors;
+        this.name = "CapabilityContractValidationError";
       }
-      profilePath;
+      boundary;
+      errors;
     };
   }
 });
 
-// src/lifecycles/prBranch.ts
-function prBranchLifecycle(profile, profilePath) {
-  const cfg = validateConfig(profile.lifecycleConfig, profilePath);
-  const before = [];
-  if (cfg.sync) before.push({ script: "syncFlow" });
-  before.push({
-    script: "setLifecycleLabel",
-    with: {
-      label: cfg.label.name,
-      color: cfg.label.color,
-      description: cfg.label.description
-    }
-  });
-  const contextBundle = buildContextBundle(cfg.context, cfg.contextExtras);
-  const afterPreflight = cfg.context === "minimal" && cfg.contextExtras.length === 0 ? [{ script: "composePrompt" }] : [...contextBundle, { script: "composePrompt" }];
-  profile.scripts.preflight = [...before, ...profile.scripts.preflight, ...afterPreflight];
-  const beforePostflight = [{ script: "parseAgentResult" }];
-  const verifyChain = cfg.verify ? [{ script: "verifyWithRetry" }, { script: "checkCoverageWithRetry" }, { script: "abortUnfinishedGitOps" }] : [];
-  const tail = [
-    ...verifyChain,
-    { script: "commitAndPush" },
-    { script: "requireDeliveryArtifacts" },
-    { script: "ensurePr" },
-    { script: "postIssueComment" },
-    { script: "writeAgentRunSummary" },
-    { script: "saveTaskState" }
-  ];
-  if (cfg.mirrorState) tail.push({ script: "mirrorStateToPr" });
-  if (cfg.advance) tail.push({ script: "advanceFlow" });
-  if (cfg.finalize) tail.push({ script: "finalizeTerminal" });
-  profile.scripts.postflight = [...beforePostflight, ...profile.scripts.postflight, ...tail];
-}
-function buildContextBundle(context, extras) {
-  const base = CONTEXT_BUNDLES[context] ?? [];
-  if (base.length === 0 && extras.length === 0) return [];
-  const out = [];
-  let extrasInserted = false;
-  for (const name of base) {
-    out.push({ script: name });
-    if (name === "loadTaskState" && extras.length > 0) {
-      for (const e of extras) out.push({ script: e });
-      extrasInserted = true;
+// src/capabilityReport.ts
+function parseCapabilityReportsFromText(text2) {
+  const reports = [];
+  for (const match of text2.matchAll(REPORT_LINE)) {
+    const raw = match[1]?.trim();
+    if (!raw) continue;
+    try {
+      const parsed = parseCapabilityReport(JSON.parse(raw));
+      if (parsed) reports.push(parsed);
+    } catch {
     }
   }
-  if (!extrasInserted && extras.length > 0) {
-    out.unshift(...extras.map((e) => ({ script: e })));
+  return reports;
+}
+function parseCapabilityReport(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const obj = raw;
+  const target = parseCapabilityReportTarget(obj.target);
+  if (!target) return null;
+  const evidence = parseCapabilityReportEvidence(obj.evidence);
+  const facts = parseFacts(obj.facts);
+  if (!evidence && !facts) return null;
+  return {
+    target,
+    ...evidence ? { evidence } : {},
+    ...facts ? { facts } : {}
+  };
+}
+function parseCapabilityReportTarget(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const target = raw;
+  if (target.type !== "goal" && target.type !== "task" && target.type !== "capability") return null;
+  if (typeof target.id !== "string" || target.id.trim().length === 0) return null;
+  return { type: target.type, id: target.id.trim() };
+}
+function parseCapabilityReportEvidence(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof key !== "string" || key.length === 0 || typeof value !== "boolean") return null;
+    out[key] = value;
   }
   return out;
 }
-function validateConfig(raw, profilePath) {
-  if (!raw) {
-    throw new ProfileError(profilePath, `lifecycle "pr-branch" requires "lifecycleConfig" with a "label" object`);
+function parseFacts(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof key !== "string" || key.length === 0) return null;
+    if (CONTROL_FACT_KEYS.has(key)) continue;
+    out[key] = value;
   }
-  const label = raw.label;
-  if (!label || typeof label !== "object" || Array.isArray(label)) {
-    throw new ProfileError(profilePath, `lifecycle "pr-branch": lifecycleConfig.label must be an object`);
+  return out;
+}
+var REPORT_LINE, CONTROL_FACT_KEYS;
+var init_capabilityReport = __esm({
+  "src/capabilityReport.ts"() {
+    "use strict";
+    REPORT_LINE = /^KODY_(?:CAPABILITY|CAPABILITY)_REPORT=(.+)$/gm;
+    CONTROL_FACT_KEYS = /* @__PURE__ */ new Set(["blockers", "destination", "capabilities", "route", "stage", "state"]);
   }
-  const lbl = label;
-  for (const k of ["name", "color", "description"]) {
-    if (typeof lbl[k] !== "string" || lbl[k].length === 0) {
-      throw new ProfileError(
+});
+
+// src/goal/evidenceState.ts
+function parseGoalEvidenceState(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const out = {};
+  for (const [evidence, value] of Object.entries(raw)) {
+    const progress = parseGoalEvidenceProgress(value);
+    if (progress) out[evidence] = progress;
+  }
+  return out;
+}
+function mergeGoalEvidenceProgress(state, evidence, update) {
+  const prior = state[evidence];
+  const next = {
+    resultClass: update.resultClass,
+    attempts: update.attempts ?? prior?.attempts ?? 0,
+    ...prior?.reason ? { reason: prior.reason } : {},
+    ...prior?.nextAction ? { nextAction: prior.nextAction } : {},
+    ...prior?.nextRetryAt ? { nextRetryAt: prior.nextRetryAt } : {},
+    ...prior?.issue ? { issue: prior.issue } : {},
+    ...prior?.updatedAt ? { updatedAt: prior.updatedAt } : {},
+    ...definedProgressFields(update)
+  };
+  return {
+    ...state,
+    [evidence]: next
+  };
+}
+function isGoalEvidenceResultClass(value) {
+  return value === "succeeded" || value === "pending" || value === "retryable" || value === "needsFix" || value === "fatal";
+}
+function parseGoalEvidenceProgress(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  if (!isGoalEvidenceResultClass(raw.resultClass)) return null;
+  const attempts = typeof raw.attempts === "number" && raw.attempts >= 0 ? Math.floor(raw.attempts) : 0;
+  return {
+    resultClass: raw.resultClass,
+    attempts,
+    ...stringField2(raw.reason) ? { reason: stringField2(raw.reason) } : {},
+    ...stringField2(raw.nextAction) ? { nextAction: stringField2(raw.nextAction) } : {},
+    ...stringField2(raw.nextRetryAt) ? { nextRetryAt: stringField2(raw.nextRetryAt) } : {},
+    ...positiveInteger(raw.issue) ? { issue: positiveInteger(raw.issue) } : {},
+    ...stringField2(raw.updatedAt) ? { updatedAt: stringField2(raw.updatedAt) } : {}
+  };
+}
+function definedProgressFields(update) {
+  const out = {};
+  if (update.reason !== void 0) out.reason = update.reason;
+  if (update.nextAction !== void 0) out.nextAction = update.nextAction;
+  if (update.nextRetryAt !== void 0) out.nextRetryAt = update.nextRetryAt;
+  if (update.issue !== void 0) out.issue = update.issue;
+  if (update.updatedAt !== void 0) out.updatedAt = update.updatedAt;
+  return out;
+}
+function stringField2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function positiveInteger(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+  return void 0;
+}
+var init_evidenceState = __esm({
+  "src/goal/evidenceState.ts"() {
+    "use strict";
+  }
+});
+
+// src/capabilityResult.ts
+function parseCapabilityResultsFromText(text2) {
+  const results = [];
+  for (const match of text2.matchAll(RESULT_LINE)) {
+    const raw = match[1]?.trim();
+    if (!raw) continue;
+    try {
+      const parsed = parseCapabilityResult(JSON.parse(raw));
+      if (parsed) results.push(parsed);
+    } catch {
+    }
+  }
+  return results;
+}
+function parseCapabilityResult(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const obj = raw;
+  if (obj.version !== 1) return null;
+  if (!isCapabilityResultStatus(obj.status)) return null;
+  const summary = typeof obj.summary === "string" ? obj.summary.trim() : "";
+  if (!summary) return null;
+  const target = obj.target === void 0 ? void 0 : parseCapabilityReportTarget(obj.target);
+  if (obj.target !== void 0 && !target) return null;
+  const evidence = obj.evidence === void 0 ? void 0 : parseCapabilityReportEvidence(obj.evidence);
+  if (obj.evidence !== void 0 && !evidence) return null;
+  const facts = parseFacts2(obj.facts);
+  if (!facts) return null;
+  const artifacts = parseArtifacts(obj.artifacts);
+  if (!artifacts) return null;
+  const missingEvidence = parseOptionalStringArray(obj.missingEvidence);
+  if (!missingEvidence) return null;
+  const blockers = parseOptionalStringArray(obj.blockers);
+  if (!blockers) return null;
+  return {
+    version: 1,
+    ...target ? { target } : {},
+    status: obj.status,
+    ...isGoalEvidenceResultClass(obj.resultClass) ? { resultClass: obj.resultClass } : {},
+    summary,
+    ...evidence ? { evidence } : {},
+    facts,
+    artifacts,
+    missingEvidence,
+    blockers
+  };
+}
+function isCapabilityResultStatus(value) {
+  return typeof value === "string" && STATUSES.has(value);
+}
+function parseFacts2(raw) {
+  if (raw === void 0) return {};
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const facts = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (!key.trim()) return null;
+    if (CONTROL_FACT_KEYS2.has(key)) continue;
+    facts[key] = value;
+  }
+  return facts;
+}
+function parseStringArray(raw) {
+  if (!Array.isArray(raw)) return null;
+  const out = [];
+  for (const item of raw) {
+    if (typeof item !== "string") return null;
+    out.push(item);
+  }
+  return out;
+}
+function parseOptionalStringArray(raw) {
+  if (raw === void 0) return [];
+  return parseStringArray(raw);
+}
+function parseArtifacts(raw) {
+  if (raw === void 0) return [];
+  if (!Array.isArray(raw)) return null;
+  const artifacts = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+    const rawArtifact = item;
+    const label = typeof rawArtifact.label === "string" ? rawArtifact.label.trim() : "";
+    const url = typeof rawArtifact.url === "string" ? rawArtifact.url.trim() : "";
+    const artifactPath = typeof rawArtifact.path === "string" ? rawArtifact.path.trim() : "";
+    if (!label || !url && !artifactPath) return null;
+    artifacts.push({
+      label,
+      ...url ? { url } : {},
+      ...artifactPath ? { path: artifactPath } : {}
+    });
+  }
+  return artifacts;
+}
+var RESULT_LINE, STATUSES, CONTROL_FACT_KEYS2;
+var init_capabilityResult = __esm({
+  "src/capabilityResult.ts"() {
+    "use strict";
+    init_capabilityReport();
+    init_evidenceState();
+    RESULT_LINE = /^KODY_(?:CAPABILITY|CAPABILITY)_RESULT=(.+)$/gm;
+    STATUSES = /* @__PURE__ */ new Set(["pass", "fail", "blocked", "changed", "noop"]);
+    CONTROL_FACT_KEYS2 = /* @__PURE__ */ new Set(["blockers", "destination", "capabilities", "route", "stage", "state"]);
+  }
+});
+
+// src/profile-error.ts
+var ProfileError;
+var init_profile_error = __esm({
+  "src/profile-error.ts"() {
+    "use strict";
+    ProfileError = class extends Error {
+      constructor(profilePath, message) {
+        super(`Invalid profile at ${profilePath}:
+  ${message}`);
+        this.profilePath = profilePath;
+        this.name = "ProfileError";
+      }
+      profilePath;
+    };
+  }
+});
+
+// src/lifecycles/prBranch.ts
+function prBranchLifecycle(profile, profilePath) {
+  const cfg = validateConfig(profile.lifecycleConfig, profilePath);
+  const before = [];
+  if (cfg.sync) before.push({ script: "syncFlow" });
+  before.push({
+    script: "setLifecycleLabel",
+    with: {
+      label: cfg.label.name,
+      color: cfg.label.color,
+      description: cfg.label.description
+    }
+  });
+  const contextBundle = buildContextBundle(cfg.context, cfg.contextExtras);
+  const afterPreflight = cfg.context === "minimal" && cfg.contextExtras.length === 0 ? [{ script: "composePrompt" }] : [...contextBundle, { script: "composePrompt" }];
+  profile.scripts.preflight = [...before, ...profile.scripts.preflight, ...afterPreflight];
+  const beforePostflight = [{ script: "parseAgentResult" }];
+  const verifyChain = cfg.verify ? [{ script: "verifyWithRetry" }, { script: "checkCoverageWithRetry" }, { script: "abortUnfinishedGitOps" }] : [];
+  const tail = [
+    ...verifyChain,
+    { script: "commitAndPush" },
+    { script: "requireDeliveryArtifacts" },
+    { script: "ensurePr" },
+    { script: "postIssueComment" },
+    { script: "writeAgentRunSummary" },
+    { script: "saveTaskState" }
+  ];
+  if (cfg.mirrorState) tail.push({ script: "mirrorStateToPr" });
+  if (cfg.advance) tail.push({ script: "advanceFlow" });
+  if (cfg.finalize) tail.push({ script: "finalizeTerminal" });
+  profile.scripts.postflight = [...beforePostflight, ...profile.scripts.postflight, ...tail];
+}
+function buildContextBundle(context, extras) {
+  const base = CONTEXT_BUNDLES[context] ?? [];
+  if (base.length === 0 && extras.length === 0) return [];
+  const out = [];
+  let extrasInserted = false;
+  for (const name of base) {
+    out.push({ script: name });
+    if (name === "loadTaskState" && extras.length > 0) {
+      for (const e of extras) out.push({ script: e });
+      extrasInserted = true;
+    }
+  }
+  if (!extrasInserted && extras.length > 0) {
+    out.unshift(...extras.map((e) => ({ script: e })));
+  }
+  return out;
+}
+function validateConfig(raw, profilePath) {
+  if (!raw) {
+    throw new ProfileError(profilePath, `lifecycle "pr-branch" requires "lifecycleConfig" with a "label" object`);
+  }
+  const label = raw.label;
+  if (!label || typeof label !== "object" || Array.isArray(label)) {
+    throw new ProfileError(profilePath, `lifecycle "pr-branch": lifecycleConfig.label must be an object`);
+  }
+  const lbl = label;
+  for (const k of ["name", "color", "description"]) {
+    if (typeof lbl[k] !== "string" || lbl[k].length === 0) {
+      throw new ProfileError(
         profilePath,
         `lifecycle "pr-branch": lifecycleConfig.label.${k} must be a non-empty string`
       );
@@ -4715,31 +5110,31 @@ var init_lifecycles = __esm({
 });
 
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs19 from "fs";
+import * as fs20 from "fs";
 import * as os3 from "os";
-import * as path18 from "path";
+import * as path19 from "path";
 function getPluginsCatalogRoot() {
-  const here = path18.dirname(new URL(import.meta.url).pathname);
+  const here = path19.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path18.join(here, "..", "plugins"),
+    path19.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path18.join(here, "..", "..", "plugins"),
+    path19.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path18.join(here, "..", "..", "src", "plugins")
+    path19.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs19.existsSync(c) && fs19.statSync(c).isDirectory()) return c;
+    if (fs20.existsSync(c) && fs20.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function copyDir(src, dst) {
-  fs19.mkdirSync(dst, { recursive: true });
-  for (const ent of fs19.readdirSync(src, { withFileTypes: true })) {
-    const s = path18.join(src, ent.name);
-    const d = path18.join(dst, ent.name);
+  fs20.mkdirSync(dst, { recursive: true });
+  for (const ent of fs20.readdirSync(src, { withFileTypes: true })) {
+    const s = path19.join(src, ent.name);
+    const d = path19.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs19.copyFileSync(s, d);
+    else if (ent.isFile()) fs20.copyFileSync(s, d);
   }
 }
 var buildSyntheticPlugin;
@@ -4752,47 +5147,47 @@ var init_buildSyntheticPlugin = __esm({
       if (!needsSynthetic) return;
       const catalog = getPluginsCatalogRoot();
       const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      const root = path18.join(os3.tmpdir(), `kody-synth-${runId}`);
-      fs19.mkdirSync(path18.join(root, ".claude-plugin"), { recursive: true });
+      const root = path19.join(os3.tmpdir(), `kody-synth-${runId}`);
+      fs20.mkdirSync(path19.join(root, ".claude-plugin"), { recursive: true });
       const resolvePart = (bucket, entry) => {
-        const local = path18.join(profile.dir, bucket, entry);
-        if (fs19.existsSync(local)) return local;
-        const shared = path18.resolve(profile.dir, "..", "..", "shared", bucket, entry);
-        if (fs19.existsSync(shared)) return shared;
-        const central = path18.join(catalog, bucket, entry);
-        if (fs19.existsSync(central)) return central;
+        const local = path19.join(profile.dir, bucket, entry);
+        if (fs20.existsSync(local)) return local;
+        const shared = path19.resolve(profile.dir, "..", "..", "shared", bucket, entry);
+        if (fs20.existsSync(shared)) return shared;
+        const central = path19.join(catalog, bucket, entry);
+        if (fs20.existsSync(central)) return central;
         throw new Error(
-          `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in implementation dir (${profile.dir}/${bucket}/), Store shared assets (${path18.dirname(shared)}/), or catalog (${catalog}/${bucket}/)`
+          `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in implementation dir (${profile.dir}/${bucket}/), Store shared assets (${path19.dirname(shared)}/), or catalog (${catalog}/${bucket}/)`
         );
       };
       if (cc.skills.length > 0) {
-        const dst = path18.join(root, "skills");
-        fs19.mkdirSync(dst, { recursive: true });
+        const dst = path19.join(root, "skills");
+        fs20.mkdirSync(dst, { recursive: true });
         for (const name of cc.skills) {
-          copyDir(resolvePart("skills", name), path18.join(dst, name));
+          copyDir(resolvePart("skills", name), path19.join(dst, name));
         }
       }
       if (cc.commands.length > 0) {
-        const dst = path18.join(root, "commands");
-        fs19.mkdirSync(dst, { recursive: true });
+        const dst = path19.join(root, "commands");
+        fs20.mkdirSync(dst, { recursive: true });
         for (const name of cc.commands) {
-          fs19.copyFileSync(resolvePart("commands", `${name}.md`), path18.join(dst, `${name}.md`));
+          fs20.copyFileSync(resolvePart("commands", `${name}.md`), path19.join(dst, `${name}.md`));
         }
       }
       if (cc.hooks.length > 0) {
-        const dst = path18.join(root, "hooks");
-        fs19.mkdirSync(dst, { recursive: true });
+        const dst = path19.join(root, "hooks");
+        fs20.mkdirSync(dst, { recursive: true });
         const merged = { hooks: {} };
         for (const name of cc.hooks) {
           const src = resolvePart("hooks", `${name}.json`);
-          const parsed = JSON.parse(fs19.readFileSync(src, "utf-8"));
+          const parsed = JSON.parse(fs20.readFileSync(src, "utf-8"));
           for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
             if (!Array.isArray(entries)) continue;
             if (!merged.hooks[event]) merged.hooks[event] = [];
             merged.hooks[event].push(...entries);
           }
         }
-        fs19.writeFileSync(path18.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+        fs20.writeFileSync(path19.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
       }
       const manifest = {
@@ -4802,7 +5197,7 @@ var init_buildSyntheticPlugin = __esm({
       };
       if (cc.skills.length > 0) manifest.skills = ["./skills/"];
       if (cc.commands.length > 0) manifest.commands = ["./commands/"];
-      fs19.writeFileSync(path18.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+      fs20.writeFileSync(path19.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
       ctx.data.syntheticPluginPath = root;
     };
@@ -4810,8 +5205,8 @@ var init_buildSyntheticPlugin = __esm({
 });
 
 // src/subagents.ts
-import * as fs20 from "fs";
-import * as path19 from "path";
+import * as fs21 from "fs";
+import * as path20 from "path";
 function splitFrontmatter(raw) {
   const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(raw);
   if (!match) return { fm: {}, body: raw.trim() };
@@ -4824,12 +5219,12 @@ function splitFrontmatter(raw) {
   return { fm, body: (match[2] ?? "").trim() };
 }
 function resolveAgentFile2(profileDir, name) {
-  const local = path19.join(profileDir, "agents", `${name}.md`);
-  if (fs20.existsSync(local)) return local;
-  const shared = path19.resolve(profileDir, "..", "..", "shared", "agents", `${name}.md`);
-  if (fs20.existsSync(shared)) return shared;
-  const central = path19.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
-  if (fs20.existsSync(central)) return central;
+  const local = path20.join(profileDir, "agents", `${name}.md`);
+  if (fs21.existsSync(local)) return local;
+  const shared = path20.resolve(profileDir, "..", "..", "shared", "agents", `${name}.md`);
+  if (fs21.existsSync(shared)) return shared;
+  const central = path20.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
+  if (fs21.existsSync(central)) return central;
   throw new Error(
     `loadSubagents: agent '${name}' not found in ${profileDir}/agents/, hydrated shared assets, or engine catalog`
   );
@@ -4840,7 +5235,7 @@ function captureSubagentTemplates(profile) {
   const out = {};
   for (const name of names) {
     try {
-      out[name] = fs20.readFileSync(resolveAgentFile2(profile.dir, name), "utf-8");
+      out[name] = fs21.readFileSync(resolveAgentFile2(profile.dir, name), "utf-8");
     } catch {
     }
   }
@@ -4851,7 +5246,7 @@ function loadSubagents(profile) {
   if (!names || names.length === 0) return void 0;
   const agents = {};
   for (const name of names) {
-    const raw = profile.subagentTemplates?.[name] ?? fs20.readFileSync(resolveAgentFile2(profile.dir, name), "utf-8");
+    const raw = profile.subagentTemplates?.[name] ?? fs21.readFileSync(resolveAgentFile2(profile.dir, name), "utf-8");
     const { fm, body } = splitFrontmatter(raw);
     if (!body) throw new Error(`loadSubagents: agent '${name}' has an empty prompt body`);
     const def = {
@@ -4876,15 +5271,15 @@ var init_subagents = __esm({
 
 // src/profile.ts
 import { createHash as createHash3 } from "crypto";
-import * as fs21 from "fs";
-import * as path20 from "path";
+import * as fs22 from "fs";
+import * as path21 from "path";
 function loadProfile(profilePath) {
-  if (!fs21.existsSync(profilePath)) {
+  if (!fs22.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs21.readFileSync(profilePath, "utf-8"));
+    raw = JSON.parse(fs22.readFileSync(profilePath, "utf-8"));
   } catch (err) {
     throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -4896,7 +5291,7 @@ function loadProfile(profilePath) {
   const unknownKeys = Object.keys(r).filter((k) => !KNOWN_PROFILE_KEYS.has(k));
   if (unknownKeys.length > 0) {
     process.stderr.write(
-      `[kody profile] ${path20.basename(path20.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
+      `[kody profile] ${path21.basename(path21.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
 `
     );
   }
@@ -4906,7 +5301,7 @@ function loadProfile(profilePath) {
     if (!refPath) {
       throw new ProfileError(profilePath, `capability references unknown implementation '${execRef}'`);
     }
-    if (path20.resolve(refPath) === path20.resolve(profilePath)) {
+    if (path21.resolve(refPath) === path21.resolve(profilePath)) {
     } else {
       const base = loadProfile(refPath);
       return {
@@ -5004,8 +5399,8 @@ function loadProfile(profilePath) {
     // Phase 5 in-process handoff opt-in. Default false; containers
     // flip to true after end-to-end verification.
     preloadContext: r.preloadContext === true,
-    dir: path20.dirname(profilePath),
-    promptTemplates: readPromptTemplates(path20.dirname(profilePath))
+    dir: path21.dirname(profilePath),
+    promptTemplates: readPromptTemplates(path21.dirname(profilePath))
   };
   if (lifecycle) {
     applyLifecycle(profile, profilePath);
@@ -5040,19 +5435,19 @@ function loadProfile(profilePath) {
   return profile;
 }
 function compileRuntimeDocument(runtimePath, document) {
-  if (path20.basename(runtimePath) !== "runtime.json") return document;
+  if (path21.basename(runtimePath) !== "runtime.json") return document;
   if (document.adapter !== "kody-engine-profile") {
     throw new ProfileError(runtimePath, "unsupported runtime adapter document");
   }
-  const implementationDir = path20.dirname(runtimePath);
-  const implementation = readJsonObject(path20.join(implementationDir, "definition.json"), "Implementation definition");
-  const definitionsRoot2 = path20.dirname(path20.dirname(implementationDir));
+  const implementationDir = path21.dirname(runtimePath);
+  const implementation = readJsonObject(path21.join(implementationDir, "definition.json"), "Implementation definition");
+  const definitionsRoot2 = path21.dirname(path21.dirname(implementationDir));
   const capabilityId = implementation.capabilityRef && typeof implementation.capabilityRef === "object" && !Array.isArray(implementation.capabilityRef) ? implementation.capabilityRef.id : void 0;
   if (typeof capabilityId !== "string" || !capabilityId) {
     throw new ProfileError(runtimePath, "Implementation capabilityRef is invalid");
   }
   const capability = readJsonObject(
-    path20.join(definitionsRoot2, "capabilities", capabilityId, "definition.json"),
+    path21.join(definitionsRoot2, "capabilities", capabilityId, "definition.json"),
     "Capability definition"
   );
   const {
@@ -5091,7 +5486,7 @@ function canonical(value) {
 }
 function readJsonObject(filePath, label) {
   try {
-    const value = JSON.parse(fs21.readFileSync(filePath, "utf-8"));
+    const value = JSON.parse(fs22.readFileSync(filePath, "utf-8"));
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       throw new Error("must be an object");
     }
@@ -5109,17 +5504,17 @@ function readPromptTemplates(dir) {
   const out = {};
   const read = (p) => {
     try {
-      out[p] = fs21.readFileSync(p, "utf-8");
+      out[p] = fs22.readFileSync(p, "utf-8");
     } catch {
     }
   };
-  read(path20.join(dir, "prompt.md"));
-  read(path20.join(dir, "capability.md"));
-  read(path20.join(dir, "capability.md"));
+  read(path21.join(dir, "prompt.md"));
+  read(path21.join(dir, "capability.md"));
+  read(path21.join(dir, "capability.md"));
   try {
-    const promptsDir = path20.join(dir, "prompts");
-    for (const ent of fs21.readdirSync(promptsDir)) {
-      if (ent.endsWith(".md")) read(path20.join(promptsDir, ent));
+    const promptsDir = path21.join(dir, "prompts");
+    for (const ent of fs22.readdirSync(promptsDir)) {
+      if (ent.endsWith(".md")) read(path21.join(promptsDir, ent));
     }
   } catch {
   }
@@ -5894,16 +6289,16 @@ var init_state = __esm({
 });
 
 // src/prompt.ts
-import * as fs22 from "fs";
-import * as path21 from "path";
+import * as fs23 from "fs";
+import * as path22 from "path";
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path21.join(projectDir, rel);
-    if (!fs22.existsSync(abs)) continue;
+    const abs = path22.join(projectDir, rel);
+    if (!fs23.existsSync(abs)) continue;
     let content;
     try {
-      content = fs22.readFileSync(abs, "utf-8");
+      content = fs23.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -6138,8 +6533,8 @@ var loadMemoryContext_exports = {};
 __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
-import * as fs23 from "fs";
-import * as path22 from "path";
+import * as fs24 from "fs";
+import * as path23 from "path";
 function formatBlockFromBackend(docs) {
   const pages = docs.flatMap((record2) => {
     if (!record2.doc || typeof record2.doc !== "object") return [];
@@ -6162,21 +6557,21 @@ function collectPages(memoryAbs) {
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs23.statSync(file);
+      stat = fs24.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs23.readFileSync(file, "utf-8");
+      raw = fs24.readFileSync(file, "utf-8");
     } catch {
       return;
     }
     const fm = raw.match(/^---\s*\n([\s\S]*?)\n---/);
-    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path22.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path23.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path22.relative(memoryAbs, file),
+      relPath: path23.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX2 : raw,
@@ -6244,16 +6639,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs23.readdirSync(dir);
+      names = fs24.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path22.join(dir, name);
+      const full = path23.join(dir, name);
       let stat;
       try {
-        stat = fs23.statSync(full);
+        stat = fs24.statSync(full);
       } catch {
         continue;
       }
@@ -6288,8 +6683,8 @@ var init_loadMemoryContext = __esm({
         }
         return;
       }
-      const memoryAbs = path22.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-      if (!fs23.existsSync(memoryAbs)) {
+      const memoryAbs = path23.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+      if (!fs24.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
       }
@@ -6333,11 +6728,11 @@ var init_loadCoverageRules = __esm({
 
 // src/container.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs24.existsSync(profilePath)) return null;
+    if (!fs25.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -6801,10 +7196,10 @@ var init_lifecycleLabels = __esm({
 
 // src/litellm.ts
 import { execFileSync as execFileSync4, spawn as spawn4 } from "child_process";
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 import * as net from "net";
 import * as os4 from "os";
-import * as path23 from "path";
+import * as path24 from "path";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -6874,7 +7269,7 @@ function locateLitellmScript() {
 }
 function resolveLitellmCommand() {
   const imageScript = "/opt/venv/bin/litellm";
-  if (fs25.existsSync(imageScript)) return imageScript;
+  if (fs26.existsSync(imageScript)) return imageScript;
   try {
     execFileSync4("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
     return "litellm";
@@ -6914,13 +7309,13 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   const spawnProxy = () => {
     const portMatch = activeUrl.match(/:(\d+)/);
     const port = portMatch ? portMatch[1] : "4000";
-    const configPath = path23.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
-    fs25.writeFileSync(configPath, generateLitellmConfigYaml(model));
+    const configPath = path24.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
+    fs26.writeFileSync(configPath, generateLitellmConfigYaml(model));
     const args = ["--config", configPath, "--port", port];
-    const nextLogPath = path23.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.log`);
-    const outFd = fs25.openSync(nextLogPath, "w");
+    const nextLogPath = path24.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.log`);
+    const outFd = fs26.openSync(nextLogPath, "w");
     child = spawn4(cmd, args, { stdio: ["ignore", outFd, outFd], detached: true, env: childEnv });
-    fs25.closeSync(outFd);
+    fs26.closeSync(outFd);
     logPath = nextLogPath;
   };
   const waitForHealth = async () => {
@@ -6934,7 +7329,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   const readLogTail = () => {
     if (!logPath) return "";
     try {
-      return fs25.readFileSync(logPath, "utf-8").slice(-2e3);
+      return fs26.readFileSync(logPath, "utf-8").slice(-2e3);
     } catch {
       return "";
     }
@@ -7017,10 +7412,10 @@ function canListen(port, host) {
   });
 }
 function readDotenvApiKeys(projectDir) {
-  const dotenvPath = path23.join(projectDir, ".env");
-  if (!fs25.existsSync(dotenvPath)) return {};
+  const dotenvPath = path24.join(projectDir, ".env");
+  if (!fs26.existsSync(dotenvPath)) return {};
   const result = {};
-  for (const rawLine of fs25.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  for (const rawLine of fs26.readFileSync(dotenvPath, "utf-8").split("\n")) {
     const line = rawLine.trim();
     if (!line || line.startsWith("#")) continue;
     const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
@@ -7672,8 +8067,8 @@ var init_pushWithRetry = __esm({
 
 // src/commit.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import * as fs26 from "fs";
-import * as path24 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 function isGitHubYamlPath(filePath) {
   const normalized = filePath.replace(/^\.\/+/, "");
   return normalized.startsWith(".github/") && /\.ya?ml$/i.test(normalized);
@@ -7715,18 +8110,18 @@ function ensureGitIdentity(cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path24.join(cwd ?? process.cwd(), ".git");
-  if (!fs26.existsSync(gitDir)) return aborted;
-  if (fs26.existsSync(path24.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path25.join(cwd ?? process.cwd(), ".git");
+  if (!fs27.existsSync(gitDir)) return aborted;
+  if (fs27.existsSync(path25.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs26.existsSync(path24.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs27.existsSync(path25.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs26.existsSync(path24.join(gitDir, "REVERT_HEAD"))) {
+  if (fs27.existsSync(path25.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs26.existsSync(path24.join(gitDir, "rebase-merge")) || fs26.existsSync(path24.join(gitDir, "rebase-apply"))) {
+  if (fs27.existsSync(path25.join(gitDir, "rebase-merge")) || fs27.existsSync(path25.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -7783,7 +8178,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs26.existsSync(path24.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs27.existsSync(path25.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -8273,7 +8668,7 @@ function asStringArray(value) {
   if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) return null;
   return [...value];
 }
-function asRecord(value) {
+function asRecord2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   return { ...value };
 }
@@ -8286,7 +8681,7 @@ function asRoute(value) {
     if (typeof raw.evidence !== "string" || typeof raw.stage !== "string" || typeof raw.capability !== "string") {
       return null;
     }
-    const args = raw.args === void 0 ? void 0 : asRecord(raw.args);
+    const args = raw.args === void 0 ? void 0 : asRecord2(raw.args);
     if (raw.args !== void 0 && !args) return null;
     route.push({
       evidence: raw.evidence,
@@ -8305,7 +8700,7 @@ function asRoutePolicy(value) {
   if (typeof value === "string") {
     return isRoutePolicyAction(value) ? { action: value } : void 0;
   }
-  const raw = asRecord(value);
+  const raw = asRecord2(value);
   if (!raw || !isRoutePolicyAction(raw.action)) return void 0;
   const maxAttempts = typeof raw.maxAttempts === "number" && Number.isInteger(raw.maxAttempts) && raw.maxAttempts > 0 ? raw.maxAttempts : void 0;
   const retryAfterSeconds = typeof raw.retryAfterSeconds === "number" && raw.retryAfterSeconds >= 0 ? Math.floor(raw.retryAfterSeconds) : void 0;
@@ -8319,24 +8714,24 @@ function isRoutePolicyAction(value) {
   return value === "wait" || value === "retry" || value === "block" || value === "issue";
 }
 function asPreferredRunTime(value) {
-  const raw = asRecord(value);
+  const raw = asRecord2(value);
   if (!raw) return void 0;
   if (typeof raw.time !== "string" || !/^([01]\d|2[0-3]):[0-5]\d$/.test(raw.time)) return void 0;
   if (typeof raw.timezone !== "string" || raw.timezone.trim().length === 0) return void 0;
   return { time: raw.time, timezone: raw.timezone };
 }
 function asLoopTarget(value) {
-  const raw = asRecord(value);
+  const raw = asRecord2(value);
   if (!raw) return void 0;
   if (raw.type !== "goal" && raw.type !== "capability" && raw.type !== "workflow") return void 0;
   if (typeof raw.id !== "string" || raw.id.trim().length === 0) return void 0;
   return { type: raw.type, id: raw.id };
 }
 function asWorkflowRef(value) {
-  const raw = asRecord(value);
+  const raw = asRecord2(value);
   if (!raw) return void 0;
   if (typeof raw.id !== "string" || raw.id.trim().length === 0) return void 0;
-  const args = raw.args === void 0 ? void 0 : asRecord(raw.args);
+  const args = raw.args === void 0 ? void 0 : asRecord2(raw.args);
   if (raw.args !== void 0 && !args) return void 0;
   return {
     id: raw.id.trim(),
@@ -8347,11 +8742,11 @@ function asWorkflowRef(value) {
 }
 function managedGoalFromState(state) {
   const extra = state.extra;
-  const destination = asRecord(extra.destination);
+  const destination = asRecord2(extra.destination);
   const evidence = asStringArray(destination?.evidence);
   const capabilities = asStringArray(extra.capabilities);
   const route = asRoute(extra.route);
-  const facts = asRecord(extra.facts);
+  const facts = asRecord2(extra.facts);
   const blockers = asStringArray(extra.blockers);
   if (typeof extra.type !== "string" || !destination || typeof destination.outcome !== "string" || !evidence || !capabilities || !route || !facts || !blockers) {
     return null;
@@ -8423,7 +8818,7 @@ var init_state2 = __esm({
 });
 
 // src/goal/runLog.ts
-import * as fs27 from "fs";
+import * as fs28 from "fs";
 function stageGoalRunLogEvent(data, goalId, event, at = nowIso()) {
   const logs = goalRunLogs(data);
   const existing = logs[goalId];
@@ -8765,8 +9160,8 @@ function readGithubEvent() {
   const eventPath = process.env.GITHUB_EVENT_PATH;
   if (!eventPath) return null;
   try {
-    if (!fs27.existsSync(eventPath)) return null;
-    const parsed = JSON.parse(fs27.readFileSync(eventPath, "utf-8"));
+    if (!fs28.existsSync(eventPath)) return null;
+    const parsed = JSON.parse(fs28.readFileSync(eventPath, "utf-8"));
     return recordValue3(parsed);
   } catch {
     return null;
@@ -8796,782 +9191,387 @@ function recordValue3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function stringArrayValue(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string") ? [...value] : null;
-}
-function numberValue(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function pickRecord(input, keys) {
-  const out = {};
-  for (const key of keys) {
-    if (input[key] !== void 0 && input[key] !== "") out[key] = input[key];
-  }
-  return out;
-}
-function pruneUndefined2(input) {
-  for (const key of Object.keys(input)) {
-    if (input[key] === void 0) delete input[key];
-  }
-  return input;
-}
-function truncateString(value, max) {
-  if (!value) return void 0;
-  return value.length > max ? `${value.slice(0, max)}...` : value;
-}
-function stringValue2(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-function safePathSegment(value) {
-  const safe = value.trim().replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "");
-  return safe || "unknown";
-}
-var LOGS_KEY, LOG_RUN_KEY, LOG_STARTED_KEY;
-var init_runLog = __esm({
-  "src/goal/runLog.ts"() {
-    "use strict";
-    init_runIndex();
-    init_state_backend();
-    init_state2();
-    LOGS_KEY = "__goalRunLogs";
-    LOG_RUN_KEY = "__goalRunLogRunId";
-    LOG_STARTED_KEY = "__goalRunLogStartedAt";
-  }
-});
-
-// src/goal/stateStore.ts
-function backendTenant(config) {
-  const owner = config.github?.owner?.trim() || process.env.GITHUB_REPOSITORY?.split("/")[0]?.trim();
-  const repo = config.github?.repo?.trim() || process.env.GITHUB_REPOSITORY?.split("/")[1]?.trim();
-  return owner && repo ? `${owner}/${repo}` : null;
-}
-function decodeGoal(doc) {
-  if (!doc?.state || typeof doc.state !== "object" || Array.isArray(doc.state)) return null;
-  const state = doc.state;
-  if (typeof state.state !== "string" || !state.extra || typeof state.extra !== "object") return null;
-  return state;
-}
-async function fetchGoalStateAsync(config, goalId, _cwd) {
-  const tenantId2 = backendTenant(config);
-  if (!tenantId2) throw new Error("Repository identity is required for goal state");
-  return decodeGoal(await createStateBackendFromEnv().getGoal(tenantId2, goalId));
-}
-async function putGoalStateAsync(config, goalId, state, _message = `chore(goals): update ${goalId}`, _cwd) {
-  const tenantId2 = backendTenant(config);
-  if (!tenantId2) throw new Error("Repository identity is required for goal state");
-  const backend = createStateBackendFromEnv();
-  const previous = await backend.getGoal(tenantId2, goalId);
-  await backend.saveGoal(tenantId2, goalId, state, state.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(), previous?.updatedAt);
-}
-async function listGoalStateIdsAsync(config, _cwd) {
-  const tenantId2 = backendTenant(config);
-  if (!tenantId2) throw new Error("Repository identity is required for goal state");
-  const docs = await createStateBackendFromEnv().listGoals(tenantId2);
-  return docs.map((doc) => doc.goalId).filter(Boolean).sort();
-}
-var init_stateStore = __esm({
-  "src/goal/stateStore.ts"() {
-    "use strict";
-    init_state_backend();
-  }
-});
-
-// src/goal/targetLoopResolution.ts
-import * as fs28 from "fs";
-import * as path25 from "path";
-async function resolveActiveGoalLoopTarget(config, cwd, loopGoalId, loopGoal) {
-  const targetId = loopGoal.loopTarget?.id.trim() ?? "";
-  assertSafeGoalId(targetId, "loop target");
-  const activeInstance = await findActiveTargetInstance(config, cwd, loopGoalId, targetId);
-  if (activeInstance) {
-    return {
-      targetId: activeInstance.id,
-      templateId: targetId,
-      reason: "active target instance"
-    };
-  }
-  const directTarget = await fetchGoalStateAsync(config, targetId, cwd);
-  if (directTarget?.state === "active") {
-    return { targetId, templateId: targetId, reason: "active target goal" };
-  }
-  return null;
-}
-async function resolveGoalLoopTarget(config, cwd, loopGoalId, loopGoal, now) {
-  const targetId = loopGoal.loopTarget?.id.trim() ?? "";
-  assertSafeGoalId(targetId, "loop target");
-  const activeTarget = await resolveActiveGoalLoopTarget(config, cwd, loopGoalId, loopGoal);
-  if (activeTarget) return activeTarget;
-  const directTarget = await fetchGoalStateAsync(config, targetId, cwd);
-  const template = loadGoalTemplate(cwd, targetId);
-  if (!template) {
-    if (directTarget) {
-      throw new Error(`goal target ${targetId} is ${directTarget.state}; no active instance or template found`);
-    }
-    return { targetId, templateId: targetId, reason: "literal target; no target state or template found" };
-  }
-  const instanceId = await chooseTargetInstanceId(config, cwd, targetId, loopGoal.preferredRunTime?.timezone, now);
-  const instance = buildGoalTargetInstance(template, targetId, now);
-  await putGoalStateAsync(config, instanceId, instance, `chore(goals): create ${instanceId}`, cwd);
-  return {
-    targetId: instanceId,
-    templateId: targetId,
-    reason: "created target instance from template",
-    created: true
-  };
-}
-function goalLoopNow() {
-  const value = process.env.KODY_GOAL_LOOP_NOW?.trim();
-  if (value) {
-    const date = new Date(value);
-    if (!Number.isNaN(date.getTime())) return date;
-  }
-  return /* @__PURE__ */ new Date();
-}
-async function findActiveTargetInstance(config, cwd, loopGoalId, targetId) {
-  const candidates = [];
-  for (const entryId of await listGoalStateIdsAsync(config, cwd)) {
-    const id = entryId.trim();
-    if (!id || id === loopGoalId || id === targetId || !id.startsWith(`${targetId}-`)) continue;
-    assertSafeGoalId(id, "goal instance");
-    const state = await fetchGoalStateAsync(config, id, cwd);
-    if (!state || state.state !== "active") continue;
-    if (!isTargetInstanceState(id, state, targetId)) continue;
-    candidates.push({ id, state });
-  }
-  candidates.sort(compareGoalInstanceAge);
-  return candidates[0] ?? null;
-}
-function isTargetInstanceState(id, state, targetId) {
-  if (id.startsWith(`${targetId}-`)) return true;
-  return ["template", "sourceTemplate", "templateId", "type"].some((key) => state.extra[key] === targetId);
-}
-function compareGoalInstanceAge(a, b) {
-  const byTime = goalInstanceTime(a.state) - goalInstanceTime(b.state);
-  return byTime === 0 ? a.id.localeCompare(b.id) : byTime;
-}
-function goalInstanceTime(state) {
-  const value = state.createdAt ?? state.startedAt ?? state.updatedAt;
-  if (!value) return 0;
-  const parsed = Date.parse(value);
-  return Number.isNaN(parsed) ? 0 : parsed;
-}
-function loadGoalTemplate(cwd, targetId) {
-  return readJsonObject2(path25.join(cwd, ".kody-engine", "definitions", "goals", targetId, "state.json"));
-}
-function readJsonObject2(filePath) {
-  if (!fs28.existsSync(filePath)) return null;
-  const parsed = JSON.parse(fs28.readFileSync(filePath, "utf8"));
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`goal template ${filePath} must be a JSON object`);
-  }
-  return parsed;
-}
-async function chooseTargetInstanceId(config, cwd, targetId, timezone, now) {
-  const base = `${targetId}-${zonedDate(now, timezone ?? "UTC")}`;
-  for (let index = 1; index <= 20; index += 1) {
-    const id = index === 1 ? base : `${base}-${index}`;
-    assertSafeGoalId(id, "goal instance");
-    const existing = await fetchGoalStateAsync(config, id, cwd);
-    if (!existing || existing.state === "active") return id;
-  }
-  throw new Error(`could not allocate goal target instance id for ${targetId}`);
-}
-function buildGoalTargetInstance(template, targetId, now) {
-  const extra = { ...template };
-  for (const key of ["state", "createdAt", "updatedAt", "startedAt"]) {
-    delete extra[key];
-  }
-  extra.kind = "instance";
-  extra.template = targetId;
-  extra.sourceTemplate = targetId;
-  extra.templateId = targetId;
-  if (!isPlainObject3(extra.facts)) extra.facts = {};
-  if (!Array.isArray(extra.blockers)) extra.blockers = [];
-  const at = isoNoMs(now);
-  return {
-    state: "active",
-    createdAt: at,
-    updatedAt: at,
-    extra
-  };
-}
-function isPlainObject3(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function assertSafeGoalId(value, label) {
-  if (!/^[A-Za-z0-9_.-]+$/.test(value)) {
-    throw new Error(`${label} id must contain only letters, numbers, dot, underscore, or dash: ${value}`);
-  }
-}
-function zonedDate(date, timezone) {
-  try {
-    const parts = new Intl.DateTimeFormat("en-CA", {
-      timeZone: timezone,
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit"
-    }).formatToParts(date);
-    const get = (type) => parts.find((part) => part.type === type)?.value;
-    const year = get("year");
-    const month = get("month");
-    const day = get("day");
-    if (year && month && day) return `${year}-${month}-${day}`;
-  } catch {
-  }
-  return date.toISOString().slice(0, 10);
-}
-function isoNoMs(date) {
-  return date.toISOString().replace(/\.\d{3}Z$/, "Z");
-}
-var init_targetLoopResolution = __esm({
-  "src/goal/targetLoopResolution.ts"() {
-    "use strict";
-    init_stateStore();
-  }
-});
-
-// src/goal/typeDefinitions.ts
-function cloneRoute(route) {
-  return route.map((step) => ({
-    stage: step.stage,
-    evidence: step.evidence,
-    capability: step.capability,
-    ...step.implementation ? { implementation: step.implementation } : {},
-    ...step.args ? { args: structuredClone(step.args) } : {}
-  }));
-}
-function stringArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : null;
-}
-function routeArray(value) {
-  if (!Array.isArray(value)) return null;
-  const route = [];
-  for (const item of value) {
-    if (!item || typeof item !== "object" || Array.isArray(item)) return null;
-    const raw = item;
-    if (typeof raw.stage !== "string" || typeof raw.evidence !== "string" || typeof raw.capability !== "string")
-      return null;
-    route.push({
-      stage: raw.stage,
-      evidence: raw.evidence,
-      capability: raw.capability,
-      implementation: typeof raw.implementation === "string" ? raw.implementation : void 0,
-      args: raw.args && typeof raw.args === "object" && !Array.isArray(raw.args) ? { ...raw.args } : void 0
-    });
-  }
-  return route;
-}
-function managedGoalTypeDefinition(type) {
-  return Object.hasOwn(GOAL_TYPE_DEFINITIONS, type) ? GOAL_TYPE_DEFINITIONS[type] : null;
-}
-function expandManagedGoalState(state) {
-  const type = typeof state.extra.type === "string" ? state.extra.type : "";
-  const definition = managedGoalTypeDefinition(type);
-  if (!definition) return state;
-  const destination = state.extra.destination && typeof state.extra.destination === "object" && !Array.isArray(state.extra.destination) ? { ...state.extra.destination } : {};
-  const outcome = typeof destination.outcome === "string" ? destination.outcome : "";
-  const evidence = stringArray(destination.evidence);
-  const capabilities = stringArray(state.extra.capabilities);
-  const route = routeArray(state.extra.route);
-  const facts = state.extra.facts && typeof state.extra.facts === "object" && !Array.isArray(state.extra.facts) ? { ...state.extra.facts } : {};
-  const blockers = stringArray(state.extra.blockers);
-  return {
-    ...state,
-    extra: {
-      ...state.extra,
-      type: definition.type,
-      destination: {
-        ...destination,
-        outcome,
-        evidence: evidence && evidence.length > 0 ? evidence : [...definition.evidence]
-      },
-      capabilities: capabilities && capabilities.length > 0 ? capabilities : [...definition.capabilities],
-      route: route && route.length > 0 ? route : cloneRoute(definition.route),
-      facts,
-      blockers: blockers ?? []
-    }
-  };
-}
-var GOAL_TYPE_DEFINITIONS;
-var init_typeDefinitions = __esm({
-  "src/goal/typeDefinitions.ts"() {
-    "use strict";
-    GOAL_TYPE_DEFINITIONS = {
-      improve: {
-        type: "improve",
-        evidence: ["planReady", "changeImplemented", "changeVerified"],
-        capabilities: ["plan", "fix", "review"],
-        route: [
-          { stage: "plan", evidence: "planReady", capability: "plan", implementation: "plan" },
-          {
-            stage: "implement",
-            evidence: "changeImplemented",
-            capability: "fix",
-            implementation: "fix"
-          },
-          {
-            stage: "review",
-            evidence: "changeVerified",
-            capability: "review",
-            implementation: "review"
-          }
-        ]
-      },
-      maintain: {
-        type: "maintain",
-        evidence: [],
-        capabilities: [
-          "cleanup",
-          "code-health",
-          "docs-health",
-          "documentation-maintenance",
-          "memory-compaction",
-          "repo-graph",
-          "skills-research"
-        ],
-        route: []
-      },
-      monitor: {
-        type: "monitor",
-        evidence: [],
-        capabilities: ["health-check", "pr-health-triage", "qa-sweep"],
-        route: []
-      },
-      release: {
-        type: "release",
-        evidence: ["releasePrExists", "mainMerged", "productionDeployed"],
-        capabilities: ["release", "release-merge", "vercel-production-deploy"],
-        route: [
-          {
-            stage: "release",
-            evidence: "releasePrExists",
-            capability: "release",
-            implementation: "release-prepare",
-            args: { issue: { fact: "issue" }, goal: { fact: "goalId" } }
-          },
-          {
-            stage: "merge",
-            evidence: "mainMerged",
-            capability: "release-merge",
-            implementation: "release-merge",
-            args: { pr: { fact: "releasePr" }, issue: { fact: "issue" }, goal: { fact: "goalId" } }
-          },
-          {
-            stage: "publish",
-            evidence: "productionDeployed",
-            capability: "vercel-production-deploy",
-            implementation: "vercel-production-deploy"
-          }
-        ]
-      },
-      checklist: {
-        type: "checklist",
-        evidence: ["checklistComplete"],
-        capabilities: ["task-verifier"],
-        route: [
-          {
-            stage: "verify",
-            evidence: "checklistComplete",
-            capability: "task-verifier",
-            implementation: "task-verifier"
-          }
-        ]
-      }
-    };
-  }
-});
-
-// 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));
-  });
-  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_STEP_ID.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);
-    if (step.delivery !== void 0 && step.delivery !== "pull-request") {
-      issue(issues, "invalid_delivery", `${base}.delivery`, "workflow step delivery must be pull-request");
-    }
-    if (step.input !== void 0 && !isJsonValue(step.input)) {
-      issue(issues, "invalid_input", `${base}.input`, "workflow step input must be one JSON value");
-    }
-  });
-  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();
-  const explicitEndSources = /* @__PURE__ */ new Set();
-  steps.forEach((step, index) => {
-    if (!step) return;
-    const id = text(step.id);
-    if (!id) return;
-    const sourceCapability = text(step.capability ?? step.action);
-    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 || target !== "$end" && !SAFE_STEP_ID.test(target)) {
-        issue(issues, "invalid_transition_target", `${base}.to`, "workflow connection must name a valid target step");
-        return;
-      }
-      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) {
-        const outputPaths = options.capabilityOutputs?.get(sourceCapability ?? "");
-        validateDataMatch(raw.when, `${base}.when`, issues, outputPaths);
-      }
-      if (target === "$end") {
-        explicitEndSources.add(id);
-        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);
-      }
-      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 || explicitEndSources.has(id))) {
-      issue(issues, "missing_terminal_step", "steps", "workflow has no reachable final step");
-    }
-  }
-  return issues;
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? [...value] : null;
 }
-function formatWorkflowValidationIssues(issues) {
-  return issues.map((entry) => `${entry.path}: ${entry.message}`);
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function validateDataMatch(value, path53, issues, capabilityOutputs) {
-  if (value === void 0) return;
-  const match = asRecord2(value);
-  if (!match || Object.keys(match).length === 0) {
-    issue(issues, "invalid_condition", path53, "workflow condition must contain at least one match");
-    return;
+function pickRecord(input, keys) {
+  const out = {};
+  for (const key of keys) {
+    if (input[key] !== void 0 && input[key] !== "") out[key] = input[key];
   }
-  for (const [field, expected] of Object.entries(match)) {
-    if (!SAFE_DATA_PATH.test(field)) {
-      issue(
-        issues,
-        "invalid_data_path",
-        `${path53}.${field}`,
-        `workflow condition must read from facts, evidence, artifacts, result, workflow, or lastOutcome`
-      );
-    }
-    if (capabilityOutputs && field.startsWith("result.") && !capabilityOutputs.has(field)) {
-      issue(
-        issues,
-        "undeclared_result_path",
-        `${path53}.${field}`,
-        `workflow condition reads ${field}, but the source capability does not declare it`
-      );
-    }
-    if (!isComparable(expected)) {
-      issue(issues, "invalid_condition_value", `${path53}.${field}`, "workflow condition value must be a JSON scalar");
-    }
+  return out;
+}
+function pruneUndefined2(input) {
+  for (const key of Object.keys(input)) {
+    if (input[key] === void 0) delete input[key];
   }
+  return input;
 }
-function transitionList(value) {
-  if (value === void 0) return [];
-  return Array.isArray(value) ? value : [value];
+function truncateString(value, max) {
+  if (!value) return void 0;
+  return value.length > max ? `${value.slice(0, max)}...` : value;
 }
-function asRecord2(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+function stringValue2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
-function text(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+function safePathSegment(value) {
+  const safe = value.trim().replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "");
+  return safe || "unknown";
 }
-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));
+var LOGS_KEY, LOG_RUN_KEY, LOG_STARTED_KEY;
+var init_runLog = __esm({
+  "src/goal/runLog.ts"() {
+    "use strict";
+    init_runIndex();
+    init_state_backend();
+    init_state2();
+    LOGS_KEY = "__goalRunLogs";
+    LOG_RUN_KEY = "__goalRunLogRunId";
+    LOG_STARTED_KEY = "__goalRunLogStartedAt";
+  }
+});
+
+// src/goal/stateStore.ts
+function backendTenant(config) {
+  const owner = config.github?.owner?.trim() || process.env.GITHUB_REPOSITORY?.split("/")[0]?.trim();
+  const repo = config.github?.repo?.trim() || process.env.GITHUB_REPOSITORY?.split("/")[1]?.trim();
+  return owner && repo ? `${owner}/${repo}` : null;
 }
-function isJsonValue(value) {
-  if (value === null || ["string", "number", "boolean"].includes(typeof value)) return true;
-  if (Array.isArray(value)) return value.every(isJsonValue);
-  if (!value || typeof value !== "object") return false;
-  return Object.values(value).every(isJsonValue);
+function decodeGoal(doc) {
+  if (!doc?.state || typeof doc.state !== "object" || Array.isArray(doc.state)) return null;
+  const state = doc.state;
+  if (typeof state.state !== "string" || !state.extra || typeof state.extra !== "object") return null;
+  return state;
 }
-function issue(issues, code, path53, message) {
-  issues.push({ code, path: path53, message });
+async function fetchGoalStateAsync(config, goalId, _cwd) {
+  const tenantId2 = backendTenant(config);
+  if (!tenantId2) throw new Error("Repository identity is required for goal state");
+  return decodeGoal(await createStateBackendFromEnv().getGoal(tenantId2, goalId));
 }
-var SAFE_NAME, SAFE_STEP_ID, SAFE_DATA_PATH, SUPPORTED_STEP_FIELDS, SUPPORTED_TRANSITION_FIELDS;
-var init_workflowValidation = __esm({
-  "src/workflowValidation.ts"() {
+async function putGoalStateAsync(config, goalId, state, _message = `chore(goals): update ${goalId}`, _cwd) {
+  const tenantId2 = backendTenant(config);
+  if (!tenantId2) throw new Error("Repository identity is required for goal state");
+  const backend = createStateBackendFromEnv();
+  const previous = await backend.getGoal(tenantId2, goalId);
+  await backend.saveGoal(tenantId2, goalId, state, state.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(), previous?.updatedAt);
+}
+async function listGoalStateIdsAsync(config, _cwd) {
+  const tenantId2 = backendTenant(config);
+  if (!tenantId2) throw new Error("Repository identity is required for goal state");
+  const docs = await createStateBackendFromEnv().listGoals(tenantId2);
+  return docs.map((doc) => doc.goalId).filter(Boolean).sort();
+}
+var init_stateStore = __esm({
+  "src/goal/stateStore.ts"() {
     "use strict";
-    SAFE_NAME = /^[a-z][a-z0-9-]*$/;
-    SAFE_STEP_ID = /^[A-Za-z][A-Za-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",
-      "input",
-      "action",
-      "evidence",
-      "target",
-      "delivery",
-      "targetFact",
-      "reason",
-      "next",
-      "runWhen",
-      "continueOn",
-      "saveReport",
-      "report"
-    ]);
-    SUPPORTED_TRANSITION_FIELDS = /* @__PURE__ */ new Set(["to", "when", "default", "maxIterations"]);
+    init_state_backend();
   }
 });
 
-// src/workflowDefinitions.ts
+// src/goal/targetLoopResolution.ts
 import * as fs29 from "fs";
 import * as path26 from "path";
-function isWorkflowDefinitionId(value) {
-  return WORKFLOW_ID_PATTERN.test(value);
+async function resolveActiveGoalLoopTarget(config, cwd, loopGoalId, loopGoal) {
+  const targetId = loopGoal.loopTarget?.id.trim() ?? "";
+  assertSafeGoalId(targetId, "loop target");
+  const activeInstance = await findActiveTargetInstance(config, cwd, loopGoalId, targetId);
+  if (activeInstance) {
+    return {
+      targetId: activeInstance.id,
+      templateId: targetId,
+      reason: "active target instance"
+    };
+  }
+  const directTarget = await fetchGoalStateAsync(config, targetId, cwd);
+  if (directTarget?.state === "active") {
+    return { targetId, templateId: targetId, reason: "active target goal" };
+  }
+  return null;
 }
-function workflowDefinitionPath(id) {
-  if (!isWorkflowDefinitionId(id)) {
-    throw new Error(`Invalid workflow id "${id}"`);
+async function resolveGoalLoopTarget(config, cwd, loopGoalId, loopGoal, now) {
+  const targetId = loopGoal.loopTarget?.id.trim() ?? "";
+  assertSafeGoalId(targetId, "loop target");
+  const activeTarget = await resolveActiveGoalLoopTarget(config, cwd, loopGoalId, loopGoal);
+  if (activeTarget) return activeTarget;
+  const directTarget = await fetchGoalStateAsync(config, targetId, cwd);
+  const template = loadGoalTemplate(cwd, targetId);
+  if (!template) {
+    if (directTarget) {
+      throw new Error(`goal target ${targetId} is ${directTarget.state}; no active instance or template found`);
+    }
+    return { targetId, templateId: targetId, reason: "literal target; no target state or template found" };
+  }
+  const instanceId = await chooseTargetInstanceId(config, cwd, targetId, loopGoal.preferredRunTime?.timezone, now);
+  const instance = buildGoalTargetInstance(template, targetId, now);
+  await putGoalStateAsync(config, instanceId, instance, `chore(goals): create ${instanceId}`, cwd);
+  return {
+    targetId: instanceId,
+    templateId: targetId,
+    reason: "created target instance from template",
+    created: true
+  };
+}
+function goalLoopNow() {
+  const value = process.env.KODY_GOAL_LOOP_NOW?.trim();
+  if (value) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) return date;
+  }
+  return /* @__PURE__ */ new Date();
+}
+async function findActiveTargetInstance(config, cwd, loopGoalId, targetId) {
+  const candidates = [];
+  for (const entryId of await listGoalStateIdsAsync(config, cwd)) {
+    const id = entryId.trim();
+    if (!id || id === loopGoalId || id === targetId || !id.startsWith(`${targetId}-`)) continue;
+    assertSafeGoalId(id, "goal instance");
+    const state = await fetchGoalStateAsync(config, id, cwd);
+    if (!state || state.state !== "active") continue;
+    if (!isTargetInstanceState(id, state, targetId)) continue;
+    candidates.push({ id, state });
+  }
+  candidates.sort(compareGoalInstanceAge);
+  return candidates[0] ?? null;
+}
+function isTargetInstanceState(id, state, targetId) {
+  if (id.startsWith(`${targetId}-`)) return true;
+  return ["template", "sourceTemplate", "templateId", "type"].some((key) => state.extra[key] === targetId);
+}
+function compareGoalInstanceAge(a, b) {
+  const byTime = goalInstanceTime(a.state) - goalInstanceTime(b.state);
+  return byTime === 0 ? a.id.localeCompare(b.id) : byTime;
+}
+function goalInstanceTime(state) {
+  const value = state.createdAt ?? state.startedAt ?? state.updatedAt;
+  if (!value) return 0;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function loadGoalTemplate(cwd, targetId) {
+  return readJsonObject2(path26.join(cwd, ".kody-engine", "definitions", "goals", targetId, "state.json"));
+}
+function readJsonObject2(filePath) {
+  if (!fs29.existsSync(filePath)) return null;
+  const parsed = JSON.parse(fs29.readFileSync(filePath, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`goal template ${filePath} must be a JSON object`);
+  }
+  return parsed;
+}
+async function chooseTargetInstanceId(config, cwd, targetId, timezone, now) {
+  const base = `${targetId}-${zonedDate(now, timezone ?? "UTC")}`;
+  for (let index = 1; index <= 20; index += 1) {
+    const id = index === 1 ? base : `${base}-${index}`;
+    assertSafeGoalId(id, "goal instance");
+    const existing = await fetchGoalStateAsync(config, id, cwd);
+    if (!existing || existing.state === "active") return id;
+  }
+  throw new Error(`could not allocate goal target instance id for ${targetId}`);
+}
+function buildGoalTargetInstance(template, targetId, now) {
+  const extra = { ...template };
+  for (const key of ["state", "createdAt", "updatedAt", "startedAt"]) {
+    delete extra[key];
+  }
+  extra.kind = "instance";
+  extra.template = targetId;
+  extra.sourceTemplate = targetId;
+  extra.templateId = targetId;
+  if (!isPlainObject3(extra.facts)) extra.facts = {};
+  if (!Array.isArray(extra.blockers)) extra.blockers = [];
+  const at = isoNoMs(now);
+  return {
+    state: "active",
+    createdAt: at,
+    updatedAt: at,
+    extra
+  };
+}
+function isPlainObject3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function assertSafeGoalId(value, label) {
+  if (!/^[A-Za-z0-9_.-]+$/.test(value)) {
+    throw new Error(`${label} id must contain only letters, numbers, dot, underscore, or dash: ${value}`);
   }
-  return `workflows/${id}/workflow.json`;
 }
-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 requestedAgent = typeof raw.agent === "string" ? raw.agent.trim() : "";
-  const agent = /^[a-z][a-z0-9-]*$/.test(requestedAgent) ? requestedAgent : "kody";
-  if (Array.isArray(raw.steps)) {
-    if (validateWorkflow({ steps: raw.steps, ...raw.startAt !== void 0 ? { startAt: raw.startAt } : {} }).length > 0) {
-      return null;
-    }
+function zonedDate(date, timezone) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    }).formatToParts(date);
+    const get = (type) => parts.find((part) => part.type === type)?.value;
+    const year = get("year");
+    const month = get("month");
+    const day = get("day");
+    if (year && month && day) return `${year}-${month}-${day}`;
+  } catch {
   }
-  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;
-  return {
-    name,
-    agent,
-    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 } : {}
-  };
+  return date.toISOString().slice(0, 10);
 }
-function readWorkflowDefinition(_config, cwd, id) {
-  const root = cwd ?? process.cwd();
-  const relativePath = workflowDefinitionPath(id);
-  const candidates = [
-    path26.join(root, ".kody-engine", "runtime", relativePath),
-    path26.join(definitionsRoot(root), relativePath)
-  ];
-  for (const filePath of candidates) {
-    if (!fs29.existsSync(filePath)) continue;
-    const workflow = parseWorkflowDefinition(fs29.readFileSync(filePath, "utf8"));
-    if (workflow) return workflow;
+function isoNoMs(date) {
+  return date.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+var init_targetLoopResolution = __esm({
+  "src/goal/targetLoopResolution.ts"() {
+    "use strict";
+    init_stateStore();
   }
-  return null;
+});
+
+// src/goal/typeDefinitions.ts
+function cloneRoute(route) {
+  return route.map((step) => ({
+    stage: step.stage,
+    evidence: step.evidence,
+    capability: step.capability,
+    ...step.implementation ? { implementation: step.implementation } : {},
+    ...step.args ? { args: structuredClone(step.args) } : {}
+  }));
 }
-function workflowDefinitionToCapabilityFolder(id, workflow, source = workflowDefinitionPath(id)) {
-  return {
-    slug: id,
-    dir: path26.dirname(source),
-    profilePath: source,
-    bodyPath: source,
-    title: workflow.name,
-    body: "",
-    rawBody: "",
-    rawProfile: { name: id, workflow },
-    config: {
-      action: id,
-      workflow: workflowDefinitionToConfig(workflow),
-      describe: workflow.name,
-      agent: workflow.agent
-    }
-  };
+function stringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : null;
 }
-function normalizeWorkflowCapabilities(value) {
-  if (!Array.isArray(value)) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const capabilities = [];
+function routeArray(value) {
+  if (!Array.isArray(value)) return null;
+  const route = [];
   for (const item of value) {
-    if (typeof item !== "string") continue;
-    const slug = item.trim();
-    if (!CAPABILITY_ID_PATTERN.test(slug) || seen.has(slug)) continue;
-    seen.add(slug);
-    capabilities.push(slug);
+    if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+    const raw = item;
+    if (typeof raw.stage !== "string" || typeof raw.evidence !== "string" || typeof raw.capability !== "string")
+      return null;
+    route.push({
+      stage: raw.stage,
+      evidence: raw.evidence,
+      capability: raw.capability,
+      implementation: typeof raw.implementation === "string" ? raw.implementation : void 0,
+      args: raw.args && typeof raw.args === "object" && !Array.isArray(raw.args) ? { ...raw.args } : void 0
+    });
   }
-  return capabilities;
+  return route;
 }
-function workflowDefinitionToConfig(workflow) {
+function managedGoalTypeDefinition(type) {
+  return Object.hasOwn(GOAL_TYPE_DEFINITIONS, type) ? GOAL_TYPE_DEFINITIONS[type] : null;
+}
+function expandManagedGoalState(state) {
+  const type = typeof state.extra.type === "string" ? state.extra.type : "";
+  const definition = managedGoalTypeDefinition(type);
+  if (!definition) return state;
+  const destination = state.extra.destination && typeof state.extra.destination === "object" && !Array.isArray(state.extra.destination) ? { ...state.extra.destination } : {};
+  const outcome = typeof destination.outcome === "string" ? destination.outcome : "";
+  const evidence = stringArray(destination.evidence);
+  const capabilities = stringArray(state.extra.capabilities);
+  const route = routeArray(state.extra.route);
+  const facts = state.extra.facts && typeof state.extra.facts === "object" && !Array.isArray(state.extra.facts) ? { ...state.extra.facts } : {};
+  const blockers = stringArray(state.extra.blockers);
   return {
-    steps: workflow.steps ?? workflow.capabilities.map((capability) => ({ capability })),
-    ...workflow.startAt ? { startAt: workflow.startAt } : {}
+    ...state,
+    extra: {
+      ...state.extra,
+      type: definition.type,
+      destination: {
+        ...destination,
+        outcome,
+        evidence: evidence && evidence.length > 0 ? evidence : [...definition.evidence]
+      },
+      capabilities: capabilities && capabilities.length > 0 ? capabilities : [...definition.capabilities],
+      route: route && route.length > 0 ? route : cloneRoute(definition.route),
+      facts,
+      blockers: blockers ?? []
+    }
   };
 }
-function parseWorkflowDefinition(content) {
-  try {
-    return normalizeWorkflowDefinition(JSON.parse(content));
-  } catch {
-    return null;
-  }
-}
-var WORKFLOW_ID_PATTERN, CAPABILITY_ID_PATTERN;
-var init_workflowDefinitions = __esm({
-  "src/workflowDefinitions.ts"() {
+var GOAL_TYPE_DEFINITIONS;
+var init_typeDefinitions = __esm({
+  "src/goal/typeDefinitions.ts"() {
     "use strict";
-    init_capabilityFolders();
-    init_definition_paths();
-    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}$/;
+    GOAL_TYPE_DEFINITIONS = {
+      improve: {
+        type: "improve",
+        evidence: ["planReady", "changeImplemented", "changeVerified"],
+        capabilities: ["plan", "fix", "review"],
+        route: [
+          { stage: "plan", evidence: "planReady", capability: "plan", implementation: "plan" },
+          {
+            stage: "implement",
+            evidence: "changeImplemented",
+            capability: "fix",
+            implementation: "fix"
+          },
+          {
+            stage: "review",
+            evidence: "changeVerified",
+            capability: "review",
+            implementation: "review"
+          }
+        ]
+      },
+      maintain: {
+        type: "maintain",
+        evidence: [],
+        capabilities: [
+          "cleanup",
+          "code-health",
+          "docs-health",
+          "documentation-maintenance",
+          "memory-compaction",
+          "repo-graph",
+          "skills-research"
+        ],
+        route: []
+      },
+      monitor: {
+        type: "monitor",
+        evidence: [],
+        capabilities: ["health-check", "pr-health-triage", "qa-sweep"],
+        route: []
+      },
+      release: {
+        type: "release",
+        evidence: ["releasePrExists", "mainMerged", "productionDeployed"],
+        capabilities: ["release", "release-merge", "vercel-production-deploy"],
+        route: [
+          {
+            stage: "release",
+            evidence: "releasePrExists",
+            capability: "release",
+            implementation: "release-prepare",
+            args: { issue: { fact: "issue" }, goal: { fact: "goalId" } }
+          },
+          {
+            stage: "merge",
+            evidence: "mainMerged",
+            capability: "release-merge",
+            implementation: "release-merge",
+            args: { pr: { fact: "releasePr" }, issue: { fact: "issue" }, goal: { fact: "goalId" } }
+          },
+          {
+            stage: "publish",
+            evidence: "productionDeployed",
+            capability: "vercel-production-deploy",
+            implementation: "vercel-production-deploy"
+          }
+        ]
+      },
+      checklist: {
+        type: "checklist",
+        evidence: ["checklistComplete"],
+        capabilities: ["task-verifier"],
+        route: [
+          {
+            stage: "verify",
+            evidence: "checklistComplete",
+            capability: "task-verifier",
+            implementation: "task-verifier"
+          }
+        ]
+      }
+    };
   }
 });
 
@@ -22249,7 +22249,11 @@ async function runCapabilityImplementationStep(valid, profileName, capabilityIde
   const shouldApplyResolvedCapabilityArgs = valid.implementation === void 0 && resolvedCapability && profileName === resolvedCapability.implementation;
   input.cliArgs = shouldApplyResolvedCapabilityArgs ? { ...resolvedCapability.cliArgs, ...input.cliArgs } : input.cliArgs;
   if (simpleCapabilityRuntime && profileName === simpleCapabilityRuntime.implementation && capabilityIdentity) {
-    const capabilityInput = Object.keys(valid.cliArgs).length > 0 ? genericInputFromArgs(valid.cliArgs) : void 0;
+    const businessArgs = { ...valid.cliArgs };
+    if (businessArgs.capability === capabilityIdentity) {
+      delete businessArgs.capability;
+    }
+    const capabilityInput = Object.keys(businessArgs).length > 0 ? genericInputFromArgs(businessArgs) : void 0;
     input.cliArgs = simpleCapabilityRuntimeArgs(simpleCapabilityRuntime, capabilityIdentity, capabilityInput);
   }
   const run = base.chain === false ? runImplementation : runImplementationChain;
@@ -23980,9 +23984,10 @@ init_config();
 
 // src/definition-hydration.ts
 init_state_backend();
+init_workflowDefinitions();
 import { createHash as createHash2 } from "crypto";
-import * as fs16 from "fs";
-import * as path17 from "path";
+import * as fs17 from "fs";
+import * as path18 from "path";
 var SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,127}$/;
 var REPOSITORY_OWNED_NAMESPACES = ["loops"];
 function assertSafeDefinitionPath(filePath) {
@@ -24014,9 +24019,9 @@ function verifyDefinition(definition) {
 }
 function writeBundle(root, bundle) {
   for (const [filePath, contents] of Object.entries(bundle.files)) {
-    const target = path17.join(root, filePath);
-    fs16.mkdirSync(path17.dirname(target), { recursive: true });
-    fs16.writeFileSync(target, contents, "utf8");
+    const target = path18.join(root, filePath);
+    fs17.mkdirSync(path18.dirname(target), { recursive: true });
+    fs17.writeFileSync(target, contents, "utf8");
   }
 }
 function writeDefinition(root, kind, definition) {
@@ -24024,46 +24029,59 @@ function writeDefinition(root, kind, definition) {
   if (kind === "agent") {
     const raw = bundle.files["agent.md"];
     if (typeof raw !== "string") throw new Error(`agent definition ${definition.slug} is missing agent.md`);
-    fs16.writeFileSync(path17.join(root, "agents", `${definition.slug}.md`), raw, "utf8");
+    fs17.writeFileSync(path18.join(root, "agents", `${definition.slug}.md`), raw, "utf8");
     return;
   }
   if (kind === "goal") {
-    writeBundle(path17.join(root, "goals", definition.slug), bundle);
+    writeBundle(path18.join(root, "goals", definition.slug), bundle);
     return;
   }
   if (kind === "implementation") {
-    writeBundle(path17.join(root, "implementations", definition.slug), bundle);
+    writeBundle(path18.join(root, "implementations", definition.slug), bundle);
     return;
   }
   if (kind === "asset") {
-    writeBundle(path17.join(root, "shared"), bundle);
+    writeBundle(path18.join(root, "shared"), bundle);
     return;
   }
-  writeBundle(path17.join(root, "capabilities", definition.slug), bundle);
+  writeBundle(path18.join(root, "capabilities", definition.slug), bundle);
+}
+function writeWorkflow(root, document) {
+  const workflow = normalizeWorkflowDefinition(document.definition);
+  if (!workflow) throw new Error(`invalid workflow definition: ${document.workflowId}`);
+  const contents = `${JSON.stringify(workflow, null, 2)}
+`;
+  const bundle = { schemaVersion: 1, files: { "workflow.json": contents } };
+  const target = path18.join(root, workflowDefinitionPath(document.workflowId));
+  fs17.mkdirSync(path18.dirname(target), { recursive: true });
+  fs17.writeFileSync(target, contents, "utf8");
+  return definitionVersion(bundle);
 }
 function preserveRepositoryDefinitions(root, staging) {
   for (const namespace of REPOSITORY_OWNED_NAMESPACES) {
-    const source = path17.join(root, namespace);
-    if (!fs16.existsSync(source)) continue;
-    fs16.cpSync(source, path17.join(staging, namespace), { recursive: true });
+    const source = path18.join(root, namespace);
+    if (!fs17.existsSync(source)) continue;
+    fs17.cpSync(source, path18.join(staging, namespace), { recursive: true });
   }
 }
 async function hydrateDefinitions(options) {
-  const root = path17.join(options.cwd, ".kody-engine", "definitions");
+  const root = path18.join(options.cwd, ".kody-engine", "definitions");
   const staging = `${root}.tmp-${process.pid}-${Date.now()}`;
-  fs16.rmSync(staging, { recursive: true, force: true });
-  fs16.mkdirSync(path17.join(staging, "agents"), { recursive: true });
-  fs16.mkdirSync(path17.join(staging, "capabilities"), { recursive: true });
-  fs16.mkdirSync(path17.join(staging, "goals"), { recursive: true });
-  fs16.mkdirSync(path17.join(staging, "implementations"), { recursive: true });
-  fs16.mkdirSync(path17.join(staging, "shared"), { recursive: true });
+  fs17.rmSync(staging, { recursive: true, force: true });
+  fs17.mkdirSync(path18.join(staging, "agents"), { recursive: true });
+  fs17.mkdirSync(path18.join(staging, "capabilities"), { recursive: true });
+  fs17.mkdirSync(path18.join(staging, "goals"), { recursive: true });
+  fs17.mkdirSync(path18.join(staging, "implementations"), { recursive: true });
+  fs17.mkdirSync(path18.join(staging, "shared"), { recursive: true });
+  fs17.mkdirSync(path18.join(staging, "workflows"), { recursive: true });
   try {
-    const [capabilities, agents, goals, implementations, assets] = await Promise.all([
+    const [capabilities, agents, goals, implementations, assets, workflows] = await Promise.all([
       options.backend.listDefinitions(options.tenantId, "capability"),
       options.backend.listDefinitions(options.tenantId, "agent"),
       options.backend.listDefinitions(options.tenantId, "goal"),
       options.backend.listDefinitions(options.tenantId, "implementation"),
-      options.backend.listDefinitions(options.tenantId, "asset")
+      options.backend.listDefinitions(options.tenantId, "asset"),
+      options.backend.listWorkflows?.(options.tenantId) ?? Promise.resolve([])
     ]);
     const versions = {};
     for (const definition of capabilities) {
@@ -24086,6 +24104,9 @@ async function hydrateDefinitions(options) {
       writeDefinition(staging, "asset", definition);
       versions[`asset:${definition.slug}`] = definition.version;
     }
+    for (const workflow of workflows) {
+      versions[`workflow:${workflow.workflowId}`] = writeWorkflow(staging, workflow);
+    }
     preserveRepositoryDefinitions(root, staging);
     const manifest = {
       schemaVersion: 1,
@@ -24093,13 +24114,13 @@ async function hydrateDefinitions(options) {
       hydratedAt: (/* @__PURE__ */ new Date()).toISOString(),
       versions: Object.fromEntries(Object.entries(versions).sort(([left], [right]) => left.localeCompare(right)))
     };
-    fs16.writeFileSync(path17.join(staging, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    fs17.writeFileSync(path18.join(staging, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-    fs16.rmSync(root, { recursive: true, force: true });
-    fs16.renameSync(staging, root);
+    fs17.rmSync(root, { recursive: true, force: true });
+    fs17.renameSync(staging, root);
     return { root, tenantId: options.tenantId, versions: manifest.versions };
   } catch (error) {
-    fs16.rmSync(staging, { recursive: true, force: true });
+    fs17.rmSync(staging, { recursive: true, force: true });
     throw error;
   }
 }
@@ -24251,7 +24272,7 @@ init_definition_paths();
 
 // src/dispatch.ts
 init_config();
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 
 // src/cron-match.ts
 var FIELD_BOUNDS = [
@@ -24358,10 +24379,10 @@ function autoDispatch(opts) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs17.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs18.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs17.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs18.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -24485,7 +24506,7 @@ function autoDispatchTyped(opts) {
   if (legacy) return { kind: "route", ...legacy };
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs17.existsSync(eventPath)) {
+  if (!eventName || !eventPath || !fs18.existsSync(eventPath)) {
     return { kind: "silent", reason: "no GHA event context" };
   }
   if (eventName !== "issue_comment") {
@@ -24493,7 +24514,7 @@ function autoDispatchTyped(opts) {
   }
   let event = {};
   try {
-    event = JSON.parse(fs17.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs18.readFileSync(eventPath, "utf-8"));
   } catch {
     return { kind: "silent", reason: "GHA event payload unreadable" };
   }
@@ -24547,7 +24568,7 @@ function dispatchScheduledWatches(opts) {
   for (const exe of listRuntimeProfilesForCwd(opts?.cwd ?? process.cwd())) {
     let raw;
     try {
-      raw = fs17.readFileSync(exe.profilePath, "utf-8");
+      raw = fs18.readFileSync(exe.profilePath, "utf-8");
     } catch {
       continue;
     }