@kody-ade/kody-engine 0.4.445 → 0.4.447

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.445",
+      version: "0.4.447",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -1795,11 +1795,11 @@ function parseWorkflowTransitions(value) {
   const transitions = rawTransitions.map((raw) => {
     if (typeof raw === "string") {
       const to2 = raw.trim();
-      return isSafeStepId(to2) ? { to: to2 } : null;
+      return to2 === "$end" || isSafeStepId(to2) ? { to: to2 } : null;
     }
     if (!isPlainObject(raw)) return null;
     const to = stringField(raw.to);
-    if (!to || !isSafeStepId(to)) return null;
+    if (!to || to !== "$end" && !isSafeStepId(to)) return null;
     const maxIterations = typeof raw.maxIterations === "number" && Number.isInteger(raw.maxIterations) && raw.maxIterations > 0 ? raw.maxIterations : void 0;
     return {
       to,
@@ -1862,11 +1862,11 @@ function definitionsRoot(cwd = process.cwd()) {
   const override = process.env.KODY_DEFINITIONS_ROOT?.trim();
   const overrideCwd = process.env.KODY_DEFINITIONS_ROOT_CWD?.trim();
   if (override && overrideCwd && path6.resolve(cwd) === path6.resolve(overrideCwd)) {
-    return path6.resolve(override);
+    return storeCatalogRoot(path6.resolve(override));
   }
   const hydrated = path6.join(cwd, ".kody-engine", "definitions");
   if (fs5.existsSync(hydrated)) return hydrated;
-  return override ? path6.resolve(override) : hydrated;
+  return override ? storeCatalogRoot(path6.resolve(override)) : hydrated;
 }
 function hasExplicitDefinitionsRoot(cwd = process.cwd(), env = process.env) {
   const root = env.KODY_DEFINITIONS_ROOT?.trim();
@@ -1874,13 +1874,36 @@ function hasExplicitDefinitionsRoot(cwd = process.cwd(), env = process.env) {
   return Boolean(root && rootCwd && path6.resolve(cwd) === path6.resolve(rootCwd));
 }
 function capabilitiesRoot(cwd = process.cwd()) {
-  return path6.join(definitionsRoot(cwd), "capabilities");
+  return storeAssetRoot(cwd, "capabilities") ?? path6.join(definitionsRoot(cwd), "capabilities");
 }
 function implementationsRoot(cwd = process.cwd()) {
   return path6.join(definitionsRoot(cwd), "implementations");
 }
 function agentsRoot(cwd = process.cwd()) {
-  return path6.join(definitionsRoot(cwd), "agents");
+  return storeAssetRoot(cwd, "agent") ?? path6.join(definitionsRoot(cwd), "agents");
+}
+function storeCatalogRoot(root) {
+  const manifest = readStoreManifest(root);
+  const roots = ["capabilities", "workflows", "loops"].map((kind) => manifest?.assetRoots?.[kind]).filter((value) => typeof value === "string" && Boolean(value.trim())).map((value) => path6.dirname(value));
+  return roots.length === 3 && new Set(roots).size === 1 ? path6.join(root, roots[0]) : root;
+}
+function storeAssetRoot(cwd, kind) {
+  const override = process.env.KODY_DEFINITIONS_ROOT?.trim();
+  if (!override) return null;
+  const overrideCwd = process.env.KODY_DEFINITIONS_ROOT_CWD?.trim();
+  if (overrideCwd && path6.resolve(cwd) !== path6.resolve(overrideCwd)) return null;
+  const root = path6.resolve(override);
+  const configured = readStoreManifest(root)?.assetRoots?.[kind];
+  return typeof configured === "string" && configured.trim() ? path6.join(root, configured) : null;
+}
+function readStoreManifest(root) {
+  const file = path6.join(root, "kody-store.json");
+  if (!fs5.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs5.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
 }
 var init_definition_paths = __esm({
   "src/definition-paths.ts"() {
@@ -8959,10 +8982,13 @@ function validateWorkflow(value, options = {}) {
         }
       }
       const target = text(raw.to);
-      if (!target || !SAFE_STEP_ID.test(target)) {
+      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 (target === "$end") {
+        return;
+      }
       if (!seen.has(target)) {
         issue(
           issues,
@@ -13798,6 +13824,204 @@ var init_dispatchAgencyLoops = __esm({
   }
 });
 
+// src/loopDefinitions.ts
+import * as fs36 from "fs";
+import * as path34 from "path";
+function normalizeLoopDefinition(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  if (Object.keys(raw).some((key) => !["id", "trigger", "target", "input", "enabled"].includes(key))) return null;
+  if (typeof raw.id !== "string" || !ID.test(raw.id)) return null;
+  if (typeof raw.enabled !== "boolean") return null;
+  if (!isObject(raw.input) || !isObject(raw.trigger) || !isObject(raw.target)) return null;
+  const targetKind = raw.target.kind;
+  const targetId = raw.target.id;
+  if (targetKind !== "workflow" && targetKind !== "capability" || typeof targetId !== "string" || !ID.test(targetId)) {
+    return null;
+  }
+  const trigger = normalizeTrigger(raw.trigger);
+  if (!trigger) return null;
+  return {
+    id: raw.id,
+    trigger,
+    target: { kind: targetKind, id: targetId },
+    input: raw.input,
+    enabled: raw.enabled
+  };
+}
+function readLoopDefinition(cwd, id) {
+  if (!ID.test(id)) return null;
+  const roots = [path34.join(cwd, ".kody-engine", "runtime"), definitionsRoot(cwd)];
+  for (const root of roots) {
+    const filePath = path34.join(root, "loops", id, "loop.json");
+    if (!fs36.existsSync(filePath)) continue;
+    try {
+      const loop = normalizeLoopDefinition(JSON.parse(fs36.readFileSync(filePath, "utf8")));
+      if (loop?.id === id) return loop;
+      process.stderr.write(`[kody] invalid simple Loop definition: ${filePath}
+`);
+    } catch {
+      process.stderr.write(`[kody] unreadable simple Loop definition: ${filePath}
+`);
+    }
+  }
+  process.stderr.write(
+    `[kody] simple Loop not found: ${id} (${roots.map((root) => path34.join(root, "loops", id, "loop.json")).join(", ")})
+`
+  );
+  return null;
+}
+function listLoopDefinitions(cwd) {
+  const roots = [path34.join(cwd, ".kody-engine", "runtime"), definitionsRoot(cwd)];
+  const byId = /* @__PURE__ */ new Map();
+  for (const root of roots.reverse()) {
+    const loopsDir = path34.join(root, "loops");
+    if (!fs36.existsSync(loopsDir)) continue;
+    for (const id of fs36.readdirSync(loopsDir).sort()) {
+      if (!ID.test(id)) continue;
+      const filePath = path34.join(loopsDir, id, "loop.json");
+      if (!fs36.existsSync(filePath)) continue;
+      try {
+        const loop = normalizeLoopDefinition(JSON.parse(fs36.readFileSync(filePath, "utf8")));
+        if (loop?.id === id) byId.set(id, loop);
+      } catch {
+        process.stderr.write(`[kody] unreadable simple Loop definition: ${filePath}
+`);
+      }
+    }
+  }
+  return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+function normalizeTrigger(raw) {
+  if (raw.type === "manual" && Object.keys(raw).length === 1) return { type: "manual" };
+  if (raw.type === "schedule" && typeof raw.every === "string" && /^\d+[mhd]$/.test(raw.every)) {
+    if (raw.at === void 0 && Object.keys(raw).every((key) => key === "type" || key === "every")) {
+      return { type: "schedule", every: raw.every };
+    }
+    if (isObject(raw.at) && typeof raw.at.time === "string" && typeof raw.at.timezone === "string" && Object.keys(raw.at).every((key) => key === "time" || key === "timezone") && Object.keys(raw).every((key) => key === "type" || key === "every" || key === "at")) {
+      return { type: "schedule", every: raw.every, at: { time: raw.at.time, timezone: raw.at.timezone } };
+    }
+  }
+  if ((raw.type === "event" || raw.type === "webhook") && typeof raw.event === "string" && raw.event.trim() && Object.keys(raw).every((key) => key === "type" || key === "event")) {
+    return { type: raw.type, event: raw.event.trim() };
+  }
+  if (raw.type === "condition" && typeof raw.expression === "string" && raw.expression.trim() && Object.keys(raw).every((key) => key === "type" || key === "expression")) {
+    return { type: "condition", expression: raw.expression.trim() };
+  }
+  return null;
+}
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+var ID;
+var init_loopDefinitions = __esm({
+  "src/loopDefinitions.ts"() {
+    "use strict";
+    init_definition_paths();
+    ID = /^[a-z0-9][a-z0-9_-]{0,79}$/;
+  }
+});
+
+// src/scripts/dispatchSimpleLoops.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function dueSlot(loop, now) {
+  if (!loop.enabled || loop.trigger.type !== "schedule") return null;
+  const match = /^(\d+)([mhd])$/.exec(loop.trigger.every);
+  if (!match) return null;
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const milliseconds = amount * (unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5);
+  const slot = Math.floor(now.getTime() / milliseconds) * milliseconds;
+  if (!loop.trigger.at) return new Date(slot).toISOString();
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: loop.trigger.at.timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(now);
+  const hour = parts.find((part) => part.type === "hour")?.value;
+  const minute = parts.find((part) => part.type === "minute")?.value;
+  const [targetHour, targetMinute] = loop.trigger.at.time.split(":").map(Number);
+  const localMinute = Number(hour) * 60 + Number(minute);
+  const targetLocalMinute = Number(targetHour) * 60 + Number(targetMinute);
+  const windowMinutes = Math.max(1, Math.ceil(Number(process.env.KODY_SCHEDULE_WINDOW_SEC || 300) / 60));
+  if (localMinute < targetLocalMinute || localMinute >= targetLocalMinute + windowMinutes) return null;
+  const year = parts.find((part) => part.type === "year")?.value;
+  const month = parts.find((part) => part.type === "month")?.value;
+  const day = parts.find((part) => part.type === "day")?.value;
+  return `${year}-${month}-${day}T${loop.trigger.at.time}[${loop.trigger.at.timezone}]`;
+}
+function loopJob(loop) {
+  const cliArgs = Object.fromEntries(
+    Object.entries(loop.input).map(([key, value]) => [key, typeof value === "string" ? value : JSON.stringify(value)])
+  );
+  return loop.target.kind === "workflow" ? { workflow: loop.target.id, cliArgs, flavor: "scheduled" } : { capability: loop.target.id, cliArgs, flavor: "scheduled" };
+}
+function repositoryTenant2(config) {
+  const [envOwner, envRepo] = (process.env.GITHUB_REPOSITORY ?? "").split("/");
+  const owner = config.github?.owner?.trim() || envOwner?.trim();
+  const repo = config.github?.repo?.trim() || envRepo?.trim();
+  return owner && repo ? `${owner}/${repo}` : null;
+}
+var dispatchSimpleLoops;
+var init_dispatchSimpleLoops = __esm({
+  "src/scripts/dispatchSimpleLoops.ts"() {
+    "use strict";
+    init_loopDefinitions();
+    init_job();
+    init_state_backend();
+    dispatchSimpleLoops = async (ctx) => {
+      const tenantId2 = repositoryTenant2(ctx.config);
+      if (!tenantId2) throw new Error("Repository identity is required for Loop dispatch");
+      const now = /* @__PURE__ */ new Date();
+      const due = listLoopDefinitions(ctx.cwd).filter((loop) => dueSlot(loop, now) !== null);
+      const backend = createStateBackendFromEnv();
+      const results = [];
+      for (const loop of due) {
+        const slot = dueSlot(loop, now);
+        if (!slot) continue;
+        const reservationId = `reservation-${randomUUID2()}`;
+        const idempotencyKey = `${loop.id}:${slot}`;
+        const claimed = await backend.reserveAgencyDispatch(tenantId2, {
+          idempotencyKey,
+          loopId: loop.id,
+          decision: { kind: "fire", reason: "local Loop schedule is due", scheduledAt: slot },
+          leaseUntil: new Date(now.getTime() + 6 * 60 * 60 * 1e3).toISOString(),
+          reservationId,
+          correlationId: `corr-${randomUUID2()}`,
+          policyHash: `loop:${loop.id}`,
+          effectivePolicy: { source: "repository" },
+          definitionRefs: [{ kind: "loop", id: loop.id }],
+          maxConcurrentRuns: 1,
+          requiresApproval: false,
+          approvalScopeKind: "loop",
+          approvalScopeId: loop.id,
+          approvalAction: `${loop.target.kind}:${loop.target.id}`,
+          now: now.toISOString()
+        });
+        if (!claimed.acquired) {
+          results.push({ loopId: loop.id, status: "skipped", reason: claimed.reason ?? "already claimed" });
+          continue;
+        }
+        const result = await runJob(loopJob(loop), {
+          cwd: ctx.cwd,
+          config: ctx.config,
+          verbose: ctx.verbose,
+          quiet: ctx.quiet,
+          chain: false
+        });
+        const status = result.exitCode === 0 ? "dispatched" : "failed";
+        await backend.finishAgencyDispatch(tenantId2, idempotencyKey, reservationId, status, (/* @__PURE__ */ new Date()).toISOString());
+        results.push({ loopId: loop.id, status, reason: result.reason ?? status });
+      }
+      ctx.data.simpleLoopDispatchResults = results;
+    };
+  }
+});
+
 // src/jobIdentity.ts
 function stableJobKey(job) {
   const capability = job.workflow ?? job.capability ?? job.action;
@@ -14818,15 +15042,15 @@ var init_fixFlow = __esm({
 });
 
 // src/workflow-template.ts
-import * as fs36 from "fs";
-import * as path34 from "path";
+import * as fs37 from "fs";
+import * as path35 from "path";
 import { fileURLToPath } from "url";
 function loadKodyWorkflowTemplate() {
-  const here = path34.dirname(fileURLToPath(import.meta.url));
-  const candidates = [path34.resolve(here, "../templates/kody.yml"), path34.resolve(here, "../../templates/kody.yml")];
-  const source = candidates.find((candidate) => fs36.existsSync(candidate));
+  const here = path35.dirname(fileURLToPath(import.meta.url));
+  const candidates = [path35.resolve(here, "../templates/kody.yml"), path35.resolve(here, "../../templates/kody.yml")];
+  const source = candidates.find((candidate) => fs37.existsSync(candidate));
   if (!source) throw new Error(`Kody workflow template is missing: ${KODY_WORKFLOW_TEMPLATE_PATH}`);
-  return fs36.readFileSync(source, "utf8");
+  return fs37.readFileSync(source, "utf8");
 }
 var KODY_WORKFLOW_TEMPLATE_PATH;
 var init_workflow_template = __esm({
@@ -14838,12 +15062,12 @@ var init_workflow_template = __esm({
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync14 } from "child_process";
-import * as fs37 from "fs";
-import * as path35 from "path";
+import * as fs38 from "fs";
+import * as path36 from "path";
 function detectPackageManager(cwd) {
-  if (fs37.existsSync(path35.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs37.existsSync(path35.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs37.existsSync(path35.join(cwd, "bun.lockb"))) return "bun";
+  if (fs38.existsSync(path36.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs38.existsSync(path36.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs38.existsSync(path36.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -14915,22 +15139,22 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path35.join(cwd, "kody.config.json");
-  if (fs37.existsSync(configPath) && !force) {
+  const configPath = path36.join(cwd, "kody.config.json");
+  if (fs38.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs37.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs38.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path35.join(cwd, ".github", "workflows");
-  const workflowPath = path35.join(workflowDir, "kody.yml");
-  if (fs37.existsSync(workflowPath) && !force) {
+  const workflowDir = path36.join(cwd, ".github", "workflows");
+  const workflowPath = path36.join(workflowDir, "kody.yml");
+  if (fs38.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs37.mkdirSync(workflowDir, { recursive: true });
-    fs37.writeFileSync(workflowPath, loadKodyWorkflowTemplate());
+    fs38.mkdirSync(workflowDir, { recursive: true });
+    fs38.writeFileSync(workflowPath, loadKodyWorkflowTemplate());
     wrote.push(".github/workflows/kody.yml");
   }
   for (const exe of listRuntimeProfilesForCwd(cwd)) {
@@ -14941,12 +15165,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path35.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs37.existsSync(target) && !force) {
+    const target = path36.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs38.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs37.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs38.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -15034,7 +15258,7 @@ Nothing to do. All files already present. (Use --force to overwrite.)
 });
 
 // src/scripts/loadAgentAdhoc.ts
-import * as fs38 from "fs";
+import * as fs39 from "fs";
 function resolveMessage(messageArg) {
   const fromComment = readCommentBody();
   if (fromComment) return stripDirective(fromComment);
@@ -15042,9 +15266,9 @@ function resolveMessage(messageArg) {
 }
 function readCommentBody() {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs38.existsSync(eventPath)) return "";
+  if (!eventPath || !fs39.existsSync(eventPath)) return "";
   try {
-    const event = JSON.parse(fs38.readFileSync(eventPath, "utf-8"));
+    const event = JSON.parse(fs39.readFileSync(eventPath, "utf-8"));
     return String(event.comment?.body ?? "");
   } catch {
     return "";
@@ -15098,10 +15322,10 @@ var init_loadAgentAdhoc = __esm({
         throw new Error("loadAgentAdhoc: ctx.args.agent must be a non-empty slug");
       }
       const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
-      if (!fs38.existsSync(agentPath)) {
+      if (!fs39.existsSync(agentPath)) {
         throw new Error(`loadAgentAdhoc: agent identity not found: ${agentPath}`);
       }
-      const { title, body } = parseAgentFile(fs38.readFileSync(agentPath, "utf-8"), agentSlug);
+      const { title, body } = parseAgentFile(fs39.readFileSync(agentPath, "utf-8"), agentSlug);
       const message = resolveMessage(ctx.args.message);
       if (!message) {
         throw new Error(
@@ -15170,8 +15394,8 @@ var init_loadCapabilityState = __esm({
 });
 
 // src/scripts/loadSimpleCapability.ts
-import * as fs39 from "fs";
-import * as path36 from "path";
+import * as fs40 from "fs";
+import * as path37 from "path";
 function parseInput(supplied) {
   if (typeof supplied !== "string") return supplied;
   try {
@@ -15218,14 +15442,14 @@ function capabilityEnvironment(input) {
   return environment;
 }
 function listFiles(root) {
-  if (!fs39.existsSync(root)) return [];
+  if (!fs40.existsSync(root)) return [];
   const files = [];
   const visit = (dir) => {
-    for (const entry of fs39.readdirSync(dir, { withFileTypes: true })) {
-      const absolute = path36.join(dir, entry.name);
+    for (const entry of fs40.readdirSync(dir, { withFileTypes: true })) {
+      const absolute = path37.join(dir, entry.name);
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) visit(absolute);
-      else if (entry.isFile()) files.push(path36.relative(root, absolute));
+      else if (entry.isFile()) files.push(path37.relative(root, absolute));
     }
   };
   visit(root);
@@ -15246,8 +15470,8 @@ var init_loadSimpleCapability = __esm({
       if (!capability) {
         throw new Error(`Capability "${slug}" is not a valid simple capability folder`);
       }
-      const toolRoot = path36.join(capability.dir, "tools");
-      const skillRoot = path36.join(capability.dir, "skills");
+      const toolRoot = path37.join(capability.dir, "tools");
+      const skillRoot = path37.join(capability.dir, "skills");
       const toolFiles = listFiles(toolRoot);
       const skillFiles = listFiles(skillRoot);
       const input = parseInput(ctx.args.input);
@@ -15271,7 +15495,7 @@ var init_loadSimpleCapability = __esm({
           ...skillFiles.flatMap((file) => [
             `### ${file}`,
             "",
-            fs39.readFileSync(path36.join(skillRoot, file), "utf-8"),
+            fs40.readFileSync(path37.join(skillRoot, file), "utf-8"),
             ""
           ])
         ] : [],
@@ -15280,7 +15504,7 @@ var init_loadSimpleCapability = __esm({
           "## Tools",
           "",
           "Inspect or run these capability-owned files when needed:",
-          ...toolFiles.map((file) => `- ${path36.join(toolRoot, file)}`)
+          ...toolFiles.map((file) => `- ${path37.join(toolRoot, file)}`)
         ] : []
       ].join("\n");
     };
@@ -15588,8 +15812,8 @@ var init_loadIssueStateComment = __esm({
 });
 
 // src/scripts/loadJobFromFile.ts
-import * as fs40 from "fs";
-import * as path37 from "path";
+import * as fs41 from "fs";
+import * as path38 from "path";
 function parseJobFile(raw, slug) {
   let stripped = raw;
   if (stripped.startsWith("---\n")) {
@@ -15628,10 +15852,10 @@ var init_loadJobFromFile = __esm({
       if (!slug) {
         throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
       }
-      const capability = resolveCapabilityFolder(slug, path37.resolve(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug, path38.resolve(ctx.cwd, jobsDir));
       if (!capability) {
         throw new Error(
-          `loadJobFromFile: capability folder not found or incomplete: ${path37.resolve(ctx.cwd, jobsDir, slug)}`
+          `loadJobFromFile: capability folder not found or incomplete: ${path38.resolve(ctx.cwd, jobsDir, slug)}`
         );
       }
       const { title, body, config } = capability;
@@ -15641,12 +15865,12 @@ var init_loadJobFromFile = __esm({
       let agentIdentity = "";
       if (agentSlug) {
         const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
-        if (!fs40.existsSync(agentPath)) {
+        if (!fs41.existsSync(agentPath)) {
           throw new Error(
             `loadJobFromFile: capability '${slug}' declares agent '${agentSlug}' but ${agentPath} does not exist`
           );
         }
-        const agentRaw = fs40.readFileSync(agentPath, "utf-8");
+        const agentRaw = fs41.readFileSync(agentPath, "utf-8");
         const parsed = parseJobFile(agentRaw, agentSlug);
         agentTitle = parsed.title;
         agentIdentity = parsed.body;
@@ -15726,13 +15950,13 @@ ${truncate2(issue2.body, FINDING_BODY_MAX_BYTES)}`;
 });
 
 // src/scripts/kodyVariables.ts
-import * as fs41 from "fs";
-import * as path38 from "path";
+import * as fs42 from "fs";
+import * as path39 from "path";
 function readKodyVariables(cwd) {
-  const full = path38.join(cwd, KODY_VARIABLES_REL_PATH);
+  const full = path39.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
-    raw = fs41.readFileSync(full, "utf-8");
+    raw = fs42.readFileSync(full, "utf-8");
   } catch {
     return {};
   }
@@ -15908,8 +16132,8 @@ var init_runtimeSecrets = __esm({
 });
 
 // src/scripts/loadQaContext.ts
-import * as fs42 from "fs";
-import * as path39 from "path";
+import * as fs43 from "fs";
+import * as path40 from "path";
 function parseSlugList(value) {
   const inner = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
   return inner.split(",").map(
@@ -15938,18 +16162,18 @@ function readProfileAgents(raw) {
   return { agent: agent ?? legacy ?? ["kody"], body };
 }
 function readProfile(cwd) {
-  const dir = path39.join(cwd, CONTEXT_DIR_REL_PATH);
-  if (!fs42.existsSync(dir)) return "";
+  const dir = path40.join(cwd, CONTEXT_DIR_REL_PATH);
+  if (!fs43.existsSync(dir)) return "";
   let entries;
   try {
-    entries = fs42.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    entries = fs43.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs42.readFileSync(path39.join(dir, file), "utf-8");
+      const raw = fs43.readFileSync(path40.join(dir, file), "utf-8");
       const { agent, body } = readProfileAgents(raw);
       if (!agent.includes(QA_AGENT) && !agent.includes(ALL_AGENTS)) continue;
       blocks.push(`## ${file}
@@ -15998,8 +16222,8 @@ var init_loadQaContext = __esm({
 });
 
 // src/taskContext.ts
-import * as fs43 from "fs";
-import * as path40 from "path";
+import * as fs44 from "fs";
+import * as path41 from "path";
 function buildTaskContext(args) {
   return {
     schemaVersion: TASK_CONTEXT_SCHEMA_VERSION,
@@ -16015,9 +16239,9 @@ function buildTaskContext(args) {
 function persistTaskContext(cwd, ctx) {
   try {
     const dir = runtimeStatePath(cwd, "agent-runs", ctx.runId);
-    fs43.mkdirSync(dir, { recursive: true });
-    const file = path40.join(dir, "task-context.json");
-    fs43.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    fs44.mkdirSync(dir, { recursive: true });
+    const file = path41.join(dir, "task-context.json");
+    fs44.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -16857,7 +17081,7 @@ function parseSingleJsonCandidate(candidates) {
   }
   return parsed.length === 1 ? { found: true, value: parsed[0] } : { found: false };
 }
-function isObject(value) {
+function isObject2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function stringValue4(value) {
@@ -16875,8 +17099,8 @@ var init_parseSimpleCapabilityOutput = __esm({
         return;
       }
       ctx.data.capabilityOutput = output;
-      const result = isObject(output) ? output : {};
-      const data = isObject(result.data) ? result.data : isObject(output) ? output : { output };
+      const result = isObject2(output) ? output : {};
+      const data = isObject2(result.data) ? result.data : isObject2(output) ? output : { output };
       const summary = typeof result.summary === "string" ? result.summary : "Capability completed";
       const reason = typeof result.reason === "string" ? result.reason : summary;
       const prUrl = stringValue4(data.pullRequestUrl) ?? stringValue4(data.prUrl) ?? stringValue4(result.pullRequestUrl) ?? stringValue4(result.prUrl);
@@ -17467,9 +17691,9 @@ var init_postResearchComment = __esm({
 });
 
 // src/scripts/prepareBrowserAuth.ts
-import * as fs44 from "fs";
+import * as fs45 from "fs";
 import * as os6 from "os";
-import * as path41 from "path";
+import * as path42 from "path";
 function appendAuthMessage(ctx, message) {
   const current = typeof ctx.data.qaAuthBlock === "string" ? ctx.data.qaAuthBlock.trim() : "";
   ctx.data.qaAuthBlock = current ? `${current}
@@ -17508,9 +17732,9 @@ async function githubJson(url, token) {
   return await response.json();
 }
 function writeKodyStorageState(input) {
-  const directory = fs44.mkdtempSync(path41.join(os6.tmpdir(), "kody-browser-auth-"));
-  fs44.chmodSync(directory, 448);
-  const file = path41.join(directory, "storage-state.json");
+  const directory = fs45.mkdtempSync(path42.join(os6.tmpdir(), "kody-browser-auth-"));
+  fs45.chmodSync(directory, 448);
+  const file = path42.join(directory, "storage-state.json");
   const now = Date.now();
   const repoEntry = {
     repoUrl: input.repoUrl,
@@ -17540,7 +17764,7 @@ function writeKodyStorageState(input) {
       }
     ]
   };
-  fs44.writeFileSync(file, JSON.stringify(storageState), { mode: 384 });
+  fs45.writeFileSync(file, JSON.stringify(storageState), { mode: 384 });
   return { directory, file };
 }
 function configurePlaywright(profile, storageStatePath) {
@@ -17622,7 +17846,7 @@ async function prepareMethod(ctx, profile, method) {
     configurePlaywright(profile, state.file);
     const authDirectory = state.directory;
     registerRuntimeCleanup(ctx, () => {
-      fs44.rmSync(authDirectory, { recursive: true, force: true });
+      fs45.rmSync(authDirectory, { recursive: true, force: true });
     });
     appendAuthMessage(
       ctx,
@@ -17630,7 +17854,7 @@ async function prepareMethod(ctx, profile, method) {
     );
     return true;
   } catch (error) {
-    if (state) fs44.rmSync(state.directory, { recursive: true, force: true });
+    if (state) fs45.rmSync(state.directory, { recursive: true, force: true });
     const reason = error instanceof Error ? error.message : String(error);
     appendAuthMessage(
       ctx,
@@ -18729,12 +18953,12 @@ fi
 
 // src/scripts/runPreviewBuild.ts
 import { copyFile, writeFile } from "fs/promises";
-import * as path42 from "path";
+import * as path43 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function bundledDockerfilePath(mode) {
-  const here = path42.dirname(fileURLToPath2(import.meta.url));
+  const here = path43.dirname(fileURLToPath2(import.meta.url));
   const file = mode === "dev" ? "default-Dockerfile.preview.dev" : "default-Dockerfile.preview.prod";
-  return path42.join(here, "preview-build-templates", file);
+  return path43.join(here, "preview-build-templates", file);
 }
 function required(name) {
   const v = (process.env[name] ?? "").trim();
@@ -18969,10 +19193,10 @@ var init_runPreviewBuild = __esm({
         console.log(`[preview-build] vault: ${Object.keys(buildEnv).length} secrets, mode=${buildMode}`);
         if (Object.keys(buildEnv).length > 0) {
           const lines = Object.entries(buildEnv).map(([k, v]) => `${k}=${JSON.stringify(v)}`);
-          await writeFile(path42.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
+          await writeFile(path43.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
 `, "utf8");
         }
-        const consumerDockerfile = path42.join(ctx.cwd, "Dockerfile.preview");
+        const consumerDockerfile = path43.join(ctx.cwd, "Dockerfile.preview");
         const { stat } = await import("fs/promises");
         let hasConsumerDockerfile = false;
         try {
@@ -19156,8 +19380,8 @@ var init_tickShellRunner = __esm({
 });
 
 // src/scripts/runScheduledImplementationTick.ts
-import * as fs45 from "fs";
-import * as path43 from "path";
+import * as fs46 from "fs";
+import * as path44 from "path";
 var runScheduledImplementationTick;
 var init_runScheduledImplementationTick = __esm({
   "src/scripts/runScheduledImplementationTick.ts"() {
@@ -19178,14 +19402,14 @@ var init_runScheduledImplementationTick = __esm({
         ctx.output.reason = `runScheduledImplementationTick: args.slug or ctx.args.${slugArg} must be non-empty capability slug`;
         return;
       }
-      const capability = resolveCapabilityFolder(slug, path43.resolve(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug, path44.resolve(ctx.cwd, jobsDir));
       if (!capability) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledImplementationTick: capability folder not found or incomplete: ${slug} (searched ${jobsDir} and company store)`;
         return;
       }
-      const shellPath = path43.join(profile.dir, shell);
-      if (!fs45.existsSync(shellPath)) {
+      const shellPath = path44.join(profile.dir, shell);
+      if (!fs46.existsSync(shellPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledImplementationTick: shell not found: ${shell} (looked in ${profile.dir})`;
         return;
@@ -19216,8 +19440,8 @@ var init_runScheduledImplementationTick = __esm({
 });
 
 // src/scripts/runTickScript.ts
-import * as fs46 from "fs";
-import * as path44 from "path";
+import * as fs47 from "fs";
+import * as path45 from "path";
 var runTickScript;
 var init_runTickScript = __esm({
   "src/scripts/runTickScript.ts"() {
@@ -19237,10 +19461,10 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
         return;
       }
-      const capability = readCapabilityFolder(path44.resolve(ctx.cwd, jobsDir), slug);
+      const capability = readCapabilityFolder(path45.resolve(ctx.cwd, jobsDir), slug);
       if (!capability) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path44.resolve(ctx.cwd, jobsDir, slug)}`;
+        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path45.resolve(ctx.cwd, jobsDir, slug)}`;
         return;
       }
       const tickScript = capability.config.tickScript;
@@ -19249,8 +19473,8 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: capability ${slug} has no \`tickScript\` in profile.json \u2014 route via capability-tick instead`;
         return;
       }
-      const scriptPath = path44.isAbsolute(tickScript) ? tickScript : path44.join(ctx.cwd, tickScript);
-      if (!fs46.existsSync(scriptPath)) {
+      const scriptPath = path45.isAbsolute(tickScript) ? tickScript : path45.join(ctx.cwd, tickScript);
+      if (!fs47.existsSync(scriptPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
         return;
@@ -19532,7 +19756,7 @@ var init_syncFlow = __esm({
 });
 
 // src/scripts/validateAgencyModelProposal.ts
-import * as path45 from "path";
+import * as path46 from "path";
 function validateModelBundle(bundle, expectedKind, options = {}) {
   const failures = [];
   validateOneModel(bundle.model, bundle.files, "model", true, failures, expectedKind, options);
@@ -19850,7 +20074,7 @@ var init_validateAgencyModelProposal = __esm({
       const bundle = parseAgencyModelProposal(raw);
       const expectedKind = readExpectedModelKind(args);
       const failures = validateModelBundle(bundle, expectedKind, {
-        capabilityRoot: path45.join(ctx.cwd, ".kody", "capabilities")
+        capabilityRoot: path46.join(ctx.cwd, ".kody", "capabilities")
       });
       if (failures.length > 0) {
         throw new Error(`validateAgencyModelProposal: ${failures.join("; ")}`);
@@ -20401,7 +20625,7 @@ var init_warmupMcp = __esm({
 });
 
 // src/scripts/writeAgentRunSummary.ts
-import * as fs47 from "fs";
+import * as fs48 from "fs";
 var writeAgentRunSummary;
 var init_writeAgentRunSummary = __esm({
   "src/scripts/writeAgentRunSummary.ts"() {
@@ -20427,7 +20651,7 @@ var init_writeAgentRunSummary = __esm({
       if (reason) lines.push(`- **Reason:** ${reason}`);
       lines.push("");
       try {
-        fs47.appendFileSync(summaryPath, `${lines.join("\n")}
+        fs48.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
       } catch {
       }
@@ -20564,6 +20788,7 @@ var init_scripts = __esm({
     init_dispatchCapabilityTicks();
     init_dispatchClassified();
     init_dispatchAgencyLoops();
+    init_dispatchSimpleLoops();
     init_dispatchNextTaskJob();
     init_ensurePr();
     init_evaluateAgencyBoundaries();
@@ -20688,6 +20913,7 @@ var init_scripts = __esm({
       warmupMcp,
       dispatchCapabilityTicks,
       dispatchAgencyLoops,
+      dispatchSimpleLoops,
       dispatchCapabilityFileTicks,
       planTaskJobs,
       dispatchNextTaskJob,
@@ -20759,17 +20985,17 @@ var init_scripts = __esm({
 });
 
 // src/stateWorkspace.ts
-import * as fs48 from "fs";
-import * as path46 from "path";
+import * as fs49 from "fs";
+import * as path47 from "path";
 function tenantId(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 writeRuntimeFile(cwd, relativePath, content) {
-  const target = path46.join(cwd, RUNTIME_ROOT, relativePath);
-  fs48.mkdirSync(path46.dirname(target), { recursive: true });
-  fs48.writeFileSync(target, content, "utf8");
+  const target = path47.join(cwd, RUNTIME_ROOT, relativePath);
+  fs49.mkdirSync(path47.dirname(target), { recursive: true });
+  fs49.writeFileSync(target, content, "utf8");
 }
 function record(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -20834,11 +21060,11 @@ async function hydrateStateWorkspace(config, cwd, backendOverride) {
       throw new Error("Kody backend access is required for runtime workspace documents");
     return;
   }
-  const key = `${path46.resolve(cwd)}|${tenant}`;
+  const key = `${path47.resolve(cwd)}|${tenant}`;
   if (hydratedWorkspaces.has(key)) return;
   const backend = backendOverride ?? createStateBackendFromEnv();
-  const root = path46.join(cwd, RUNTIME_ROOT);
-  fs48.rmSync(root, { recursive: true, force: true });
+  const root = path47.join(cwd, RUNTIME_ROOT);
+  fs49.rmSync(root, { recursive: true, force: true });
   await Promise.all([
     hydratePrefix(backend, tenant, cwd, "context:"),
     hydratePrefix(backend, tenant, cwd, "memory:"),
@@ -20854,7 +21080,7 @@ var init_stateWorkspace = __esm({
   "src/stateWorkspace.ts"() {
     "use strict";
     init_state_backend();
-    RUNTIME_ROOT = path46.join(".kody-engine", "runtime");
+    RUNTIME_ROOT = path47.join(".kody-engine", "runtime");
     hydratedWorkspaces = /* @__PURE__ */ new Set();
   }
 });
@@ -20925,9 +21151,9 @@ var init_tools = __esm({
 
 // src/executor.ts
 import { spawn as spawn8 } from "child_process";
-import * as fs49 from "fs";
+import * as fs50 from "fs";
 import * as os7 from "os";
-import * as path47 from "path";
+import * as path48 from "path";
 function isMutatingPostflight(scriptName) {
   return MUTATING_POSTFLIGHTS.has(scriptName ?? "");
 }
@@ -21168,7 +21394,7 @@ async function runImplementation(profileName, input) {
   const jobWhyBlock = typeof ctx.data.jobWhy === "string" ? operatorRequestBlock(ctx.data.jobWhy) : null;
   const jobRefBlock = jobReferenceBlock(profileName, profile, ctx.data);
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path47.isAbsolute(p) ? p : path47.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path48.isAbsolute(p) ? p : path48.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
@@ -21632,17 +21858,17 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function resolveProfilePath(profileName, cwd = process.cwd()) {
   const found = resolveImplementation(profileName, getRuntimeProfileRootsForCwd(cwd));
   if (found) return found;
-  const here = path47.dirname(new URL(import.meta.url).pathname);
+  const here = path48.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path47.join(here, "implementations", profileName, "profile.json"),
+    path48.join(here, "implementations", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path47.join(here, "..", "implementations", profileName, "profile.json"),
+    path48.join(here, "..", "implementations", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/implementations)
-    path47.join(here, "..", "src", "implementations", profileName, "profile.json")
+    path48.join(here, "..", "src", "implementations", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs49.existsSync(c)) return c;
+    if (fs50.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -21757,15 +21983,15 @@ function resolveShellTimeoutMs(entry) {
 }
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path47.join(profile.dir, shellName);
-  if (!fs49.existsSync(shellPath)) {
+  const shellPath = path48.join(profile.dir, shellName);
+  if (!fs50.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
     return;
   }
   const positional = entry.with ? Object.values(entry.with).map((v) => String(v)) : [];
-  const outputFile = path47.join(
+  const outputFile = path48.join(
     os7.tmpdir(),
     `kody-shell-output-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
   );
@@ -21837,9 +22063,9 @@ async function runShellEntry(entry, ctx, profile) {
   }
   let sideChannelText = "";
   try {
-    if (fs49.existsSync(outputFile)) {
-      sideChannelText = fs49.readFileSync(outputFile, "utf-8");
-      fs49.rmSync(outputFile, { force: true });
+    if (fs50.existsSync(outputFile)) {
+      sideChannelText = fs50.readFileSync(outputFile, "utf-8");
+      fs50.rmSync(outputFile, { force: true });
     }
   } catch {
   }
@@ -22011,7 +22237,7 @@ __export(job_exports, {
   stableJobKey: () => stableJobKey,
   validateJob: () => validateJob
 });
-import * as path48 from "path";
+import * as path49 from "path";
 function newJobId(flavor) {
   localJobSeq += 1;
   const runId = process.env.GITHUB_RUN_ID;
@@ -22487,6 +22713,13 @@ async function runGraphCapabilityWorkflow(parent, workflow, capability, base, ch
       const key = `${step.id}->${transition.to}`;
       state.transitionCounts[key] = (state.transitionCounts[key] ?? 0) + 1;
     }
+    if (transition.to === "$end") {
+      state.status = "done";
+      delete state.currentStepId;
+      delete state.blocker;
+      await checkpoint?.(state);
+      return withWorkflowBoundaryEval(capability, { ...result, workflowState: state });
+    }
     state.currentStepId = transition.to;
     state.status = "running";
     delete state.blocker;
@@ -22662,7 +22895,7 @@ function valueMatches(actual, expected) {
 }
 function workflowStepTargetNumber(step, parent, chainData) {
   if (step.target === "pr") return workflowPrNumber(chainData) ?? workflowTargetFactNumber(step, chainData);
-  if (step.target === "issue") return workflowIssueNumber(parent);
+  if (step.target === "issue") return workflowIssueNumber(parent) ?? workflowTargetFactNumber(step, chainData);
   return typeof parent.target === "number" ? parent.target : targetFromCliArgs(parent.cliArgs);
 }
 function workflowResumeStartIndex(steps, evidence) {
@@ -22712,7 +22945,7 @@ function loadCapabilityContext(slug, cwd) {
   return resolveCapabilityFolder(slug, hydratedCapabilitiesRoot(cwd));
 }
 function hydratedCapabilitiesRoot(cwd) {
-  return path48.join(cwd, ".kody-engine", "definitions", "capabilities");
+  return path49.join(cwd, ".kody-engine", "definitions", "capabilities");
 }
 function loadWorkflowContext(slug, base) {
   if (!slug || !isWorkflowDefinitionId(slug)) return null;
@@ -24688,82 +24921,7 @@ function readRunRequestFromEnv(env = process.env) {
 
 // src/kody-cli.ts
 init_runtimePaths();
-
-// src/loopDefinitions.ts
-init_definition_paths();
-import * as fs50 from "fs";
-import * as path49 from "path";
-var ID = /^[a-z0-9][a-z0-9_-]{0,79}$/;
-function normalizeLoopDefinition(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const raw = value;
-  if (Object.keys(raw).some((key) => !["id", "trigger", "target", "input", "enabled"].includes(key))) return null;
-  if (typeof raw.id !== "string" || !ID.test(raw.id)) return null;
-  if (typeof raw.enabled !== "boolean") return null;
-  if (!isObject2(raw.input) || !isObject2(raw.trigger) || !isObject2(raw.target)) return null;
-  const targetKind = raw.target.kind;
-  const targetId = raw.target.id;
-  if (targetKind !== "workflow" && targetKind !== "capability" || typeof targetId !== "string" || !ID.test(targetId)) {
-    return null;
-  }
-  const trigger = normalizeTrigger(raw.trigger);
-  if (!trigger) return null;
-  return {
-    id: raw.id,
-    trigger,
-    target: { kind: targetKind, id: targetId },
-    input: raw.input,
-    enabled: raw.enabled
-  };
-}
-function readLoopDefinition(cwd, id) {
-  if (!ID.test(id)) return null;
-  const roots = [
-    path49.join(cwd, ".kody-engine", "runtime"),
-    definitionsRoot(cwd)
-  ];
-  for (const root of roots) {
-    const filePath = path49.join(root, "loops", id, "loop.json");
-    if (!fs50.existsSync(filePath)) continue;
-    try {
-      const loop = normalizeLoopDefinition(JSON.parse(fs50.readFileSync(filePath, "utf8")));
-      if (loop?.id === id) return loop;
-      process.stderr.write(`[kody] invalid simple Loop definition: ${filePath}
-`);
-    } catch {
-      process.stderr.write(`[kody] unreadable simple Loop definition: ${filePath}
-`);
-    }
-  }
-  process.stderr.write(
-    `[kody] simple Loop not found: ${id} (${roots.map((root) => path49.join(root, "loops", id, "loop.json")).join(", ")})
-`
-  );
-  return null;
-}
-function normalizeTrigger(raw) {
-  if (raw.type === "manual" && Object.keys(raw).length === 1) return { type: "manual" };
-  if (raw.type === "schedule" && typeof raw.every === "string" && /^\d+[mhd]$/.test(raw.every)) {
-    if (raw.at === void 0 && Object.keys(raw).every((key) => key === "type" || key === "every")) {
-      return { type: "schedule", every: raw.every };
-    }
-    if (isObject2(raw.at) && typeof raw.at.time === "string" && typeof raw.at.timezone === "string" && Object.keys(raw.at).every((key) => key === "time" || key === "timezone") && Object.keys(raw).every((key) => key === "type" || key === "every" || key === "at")) {
-      return { type: "schedule", every: raw.every, at: { time: raw.at.time, timezone: raw.at.timezone } };
-    }
-  }
-  if ((raw.type === "event" || raw.type === "webhook") && typeof raw.event === "string" && raw.event.trim() && Object.keys(raw).every((key) => key === "type" || key === "event")) {
-    return { type: raw.type, event: raw.event.trim() };
-  }
-  if (raw.type === "condition" && typeof raw.expression === "string" && raw.expression.trim() && Object.keys(raw).every((key) => key === "type" || key === "expression")) {
-    return { type: "condition", expression: raw.expression.trim() };
-  }
-  return null;
-}
-function isObject2(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-// src/kody-cli.ts
+init_loopDefinitions();
 init_stateWorkspace();
 init_workflowDefinitions();
 var FAILED_DISPATCH_LABEL = {
@@ -26445,7 +26603,7 @@ init_config();
 init_fetchRepoMcp();
 
 // src/servers/mcpHttpServer.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { createServer as createServer4 } from "http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -26454,7 +26612,7 @@ function buildMcpHttpServer(opts) {
   const transports = /* @__PURE__ */ new Map();
   for (const route of opts.routes) {
     const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID2()
+      sessionIdGenerator: () => randomUUID3()
     });
     transports.set(route.path, transport);
     routes.set(route.path, route.name);

package/dist/runtime-services/goal-scheduler/profile.json

@@ -1,8 +1,5 @@
 {
   "internal": true,
-  "role": "watch",
-  "kind": "scheduled",
-  "schedule": "*/5 * * * *",
   "claudeCode": {
     "model": "inherit",
     "permissionMode": "default",
@@ -33,9 +30,6 @@
   "outputArtifacts": [],
   "scripts": {
     "preflight": [
-      {
-        "script": "dispatchAgencyLoops"
-      },
       {
         "shell": "scheduler.sh",
         "timeoutSec": 1800

package/dist/runtime-services/loop-scheduler/profile.json

@@ -0,0 +1,32 @@
+{
+  "internal": true,
+  "role": "watch",
+  "kind": "scheduled",
+  "schedule": "*/5 * * * *",
+  "claudeCode": {
+    "model": "inherit",
+    "permissionMode": "default",
+    "maxTurns": 0,
+    "maxThinkingTokens": null,
+    "systemPromptAppend": null,
+    "tools": [],
+    "hooks": [],
+    "skills": [],
+    "commands": [],
+    "subagents": [],
+    "plugins": [],
+    "mcpServers": []
+  },
+  "cliTools": [],
+  "inputArtifacts": [],
+  "outputArtifacts": [],
+  "scripts": {
+    "preflight": [
+      { "script": "dispatchSimpleLoops" },
+      { "script": "skipAgent" }
+    ],
+    "postflight": []
+  },
+  "inputs": [],
+  "name": "loop-scheduler"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.445",
+  "version": "0.4.447",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
   "license": "MIT",
   "type": "module",