@kody-ade/kody-engine 0.4.471 → 0.4.472

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.471",
+      version: "0.4.472",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -53,7 +53,6 @@ var init_package = __esm({
       dependencies: {
         "@actions/cache": "^6.0.0",
         "@anthropic-ai/claude-agent-sdk": "0.2.119",
-        "@kody-ade/agency-domain": "0.5.1",
         "@kody-ade/engine-contracts": "0.1.0",
         "@modelcontextprotocol/sdk": "^1.29.0",
         ajv: "^8.18.0",
@@ -2059,14 +2058,14 @@ function resolveImplementationCandidates(name, roots = getRuntimeProfileRootsFor
 function listCapabilityActions(projectCapabilitiesRoot = getProjectCapabilitiesRoot()) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  const add2 = (action) => {
+  const add = (action) => {
     if (!isSafeName(action.action) || !isSafeName(action.capability) || !isSafeName(action.implementation)) return;
     if (seen.has(action.action)) return;
     seen.add(action.action);
     out.push(action);
   };
-  for (const action of listFolderCapabilityActions(projectCapabilitiesRoot, "project-folder")) add2(action);
-  for (const action of listBuiltinCapabilityActions(getBuiltinCapabilitiesRoot())) add2(action);
+  for (const action of listFolderCapabilityActions(projectCapabilitiesRoot, "project-folder")) add(action);
+  for (const action of listBuiltinCapabilityActions(getBuiltinCapabilitiesRoot())) add(action);
   return out.sort((a, b) => a.action.localeCompare(b.action));
 }
 function resolveCapabilityAction(action, projectCapabilitiesRoot = getProjectCapabilitiesRoot()) {
@@ -2419,12 +2418,11 @@ var init_kody_api_client = __esm({
 
 // src/state-backend.ts
 import { anyApi } from "convex/server";
-function serializeAgencyDispatchDecision(decision) {
+function serializeLoopDispatchDecision(decision) {
   return {
     kind: decision.kind,
     reason: decision.reason,
-    ...decision.scheduledAt ? { scheduledAt: decision.scheduledAt } : {},
-    ...decision.nextEligibleAt ? { nextEligibleAt: decision.nextEligibleAt } : {}
+    ...decision.scheduledAt ? { scheduledAt: decision.scheduledAt } : {}
   };
 }
 function requireTenant(tenantId2) {
@@ -2539,52 +2537,11 @@ function createStateBackendFromEnv(env = process.env, client) {
         updatedAt
       });
     },
-    async listAgencyDefinitions(tenantId2) {
-      const result = await transport.query(anyApi.agencyModel.listDefinitions, {
-        tenantId: requireTenant(tenantId2)
-      });
-      return Array.isArray(result) ? result : [];
-    },
-    async getAgencyState(tenantId2, kind, definitionId2) {
-      const result = await transport.query(anyApi.agencyModel.getState, {
-        tenantId: requireTenant(tenantId2),
-        kind,
-        definitionId: requireNonEmpty(definitionId2, "definitionId")
-      });
-      return result ?? null;
-    },
-    async putAgencyState(tenantId2, definitionId2, kind, schemaVersion, data, updatedAt) {
-      await transport.mutation(anyApi.agencyModel.putState, {
-        tenantId: requireTenant(tenantId2),
-        definitionId: requireNonEmpty(definitionId2, "definitionId"),
-        kind,
-        schemaVersion,
-        data,
-        updatedAt
-      });
-    },
-    async appendAgencyOutput(tenantId2, recordId, schemaVersion, data) {
-      await transport.mutation(anyApi.agencyModel.appendOutput, {
-        tenantId: requireTenant(tenantId2),
-        envelope: {
-          schemaVersion,
-          recordId: requireNonEmpty(recordId, "recordId"),
-          data
-        }
-      });
-    },
-    async listAgencyOutputs(tenantId2, runId) {
-      const result = await transport.query(anyApi.agencyModel.listOutputs, {
-        tenantId: requireTenant(tenantId2),
-        ...runId ? { runId: requireNonEmpty(runId, "runId") } : {}
-      });
-      return Array.isArray(result) ? result : [];
-    },
-    async reserveAgencyDispatch(tenantId2, reservation) {
+    async reserveLoopDispatch(tenantId2, reservation) {
       const result = await transport.mutation(anyApi.agencyModel.reserveDispatch, {
         tenantId: requireTenant(tenantId2),
         ...reservation,
-        decision: serializeAgencyDispatchDecision(reservation.decision),
+        decision: serializeLoopDispatchDecision(reservation.decision),
         idempotencyKey: requireNonEmpty(reservation.idempotencyKey, "idempotencyKey"),
         loopId: requireNonEmpty(reservation.loopId, "loopId"),
         reservationId: requireNonEmpty(reservation.reservationId, "reservationId"),
@@ -2593,16 +2550,7 @@ function createStateBackendFromEnv(env = process.env, client) {
       });
       return result;
     },
-    async recordSkippedAgencyDispatch(tenantId2, idempotencyKey, loopId, decision, now) {
-      await transport.mutation(anyApi.agencyModel.recordSkippedDispatch, {
-        tenantId: requireTenant(tenantId2),
-        idempotencyKey: requireNonEmpty(idempotencyKey, "idempotencyKey"),
-        loopId: requireNonEmpty(loopId, "loopId"),
-        decision: serializeAgencyDispatchDecision(decision),
-        now
-      });
-    },
-    async finishAgencyDispatch(tenantId2, idempotencyKey, reservationId, status, now, runId) {
+    async finishLoopDispatch(tenantId2, idempotencyKey, reservationId, status, now, runId) {
       await transport.mutation(anyApi.agencyModel.finishDispatch, {
         tenantId: requireTenant(tenantId2),
         idempotencyKey: requireNonEmpty(idempotencyKey, "idempotencyKey"),
@@ -2612,7 +2560,7 @@ function createStateBackendFromEnv(env = process.env, client) {
         ...runId ? { runId: requireNonEmpty(runId, "runId") } : {}
       });
     },
-    async createAgencyModelRun(tenantId2, subjectType, subjectId, run, now) {
+    async createAgencyRun(tenantId2, subjectType, subjectId, run, now) {
       await transport.mutation(anyApi.agencyModel.createRunRecord, {
         tenantId: requireTenant(tenantId2),
         subjectType,
@@ -2621,7 +2569,7 @@ function createStateBackendFromEnv(env = process.env, client) {
         now
       });
     },
-    async finishAgencyModelRun(tenantId2, run, now) {
+    async finishAgencyRun(tenantId2, run, now) {
       await transport.mutation(anyApi.agencyModel.finishRunRecord, {
         tenantId: requireTenant(tenantId2),
         run,
@@ -13086,678 +13034,6 @@ var init_dispatch = __esm({
   }
 });
 
-// src/goal/agencyModelRepository.ts
-import {
-  createAgentDefinition,
-  createCapabilityDefinition,
-  createGoalDefinition,
-  createGoalState,
-  createIntentDefinition,
-  createLoopDefinition,
-  createLoopState,
-  createOperationDefinition,
-  createRunOutput,
-  createWorkflowDefinition,
-  relationshipIssues
-} from "@kody-ade/agency-domain";
-function goalProgressFromOutputs(definition, revision, outputs) {
-  const required2 = definition.objective.requiredEvidence;
-  if (required2.length === 0) return 1;
-  const satisfied = new Set(
-    outputs.filter(
-      (output) => output.kind === "evidence" && output.value === true && output.parentRef?.kind === "goal" && output.parentRef.id === definition.id && output.parentRef.revision === revision
-    ).map((output) => output.key)
-  );
-  return required2.filter((key) => satisfied.has(key)).length / required2.length;
-}
-function definitionId(document) {
-  const data = document.data;
-  if (typeof data.id !== "string" || !data.id.trim()) {
-    throw new Error(`Agency Definition is missing id: ${document.recordId}`);
-  }
-  return data.id;
-}
-function parseState(document, definition, kind) {
-  if (!document) return null;
-  if (document.schemaVersion !== 1) throw new Error(`Unsupported Agency State schema: ${document.schemaVersion}`);
-  if (document.kind !== kind || document.definitionId !== definition.id) {
-    throw new Error(`Agency State does not match Definition: ${definition.id}`);
-  }
-  return document.kind === "goal" ? createGoalState(document.data) : createLoopState(document.data);
-}
-function emptyCatalog() {
-  return {
-    intents: /* @__PURE__ */ new Map(),
-    operations: /* @__PURE__ */ new Map(),
-    goals: /* @__PURE__ */ new Map(),
-    loops: /* @__PURE__ */ new Map(),
-    workflows: /* @__PURE__ */ new Map(),
-    capabilities: /* @__PURE__ */ new Map(),
-    agents: /* @__PURE__ */ new Map()
-  };
-}
-function addDefinition(catalog, document) {
-  if (document.schemaVersion !== 1) throw new Error(`Unsupported Agency Definition schema: ${document.schemaVersion}`);
-  if (document.kind === "intent") add(catalog.intents, createIntentDefinition(document.data), document.recordId);
-  else if (document.kind === "operation")
-    add(catalog.operations, createOperationDefinition(document.data), document.recordId);
-  else if (document.kind === "goal") add(catalog.goals, createGoalDefinition(document.data), document.recordId);
-  else if (document.kind === "loop") add(catalog.loops, createLoopDefinition(document.data), document.recordId);
-  else if (document.kind === "workflow")
-    add(catalog.workflows, createWorkflowDefinition(document.data), document.recordId);
-  else if (document.kind === "capability")
-    add(catalog.capabilities, createCapabilityDefinition(document.data), document.recordId);
-  else add(catalog.agents, createAgentDefinition(document.data), document.recordId);
-}
-function add(collection, definition, revision) {
-  const mutable = collection;
-  mutable.set(definition.id, { definition, revision });
-}
-function validateRelationships(catalog) {
-  const relationshipCatalog = {
-    operations: [...catalog.operations.keys()],
-    goals: [...catalog.goals.keys()],
-    workflows: [...catalog.workflows.keys()],
-    capabilities: [...catalog.capabilities.keys()]
-  };
-  const issues = [...catalog.goals.values(), ...catalog.loops.values()].flatMap(
-    ({ definition }) => relationshipIssues(definition, relationshipCatalog).map((issue2) => `${definition.id}: ${issue2}`)
-  );
-  for (const { definition } of catalog.operations.values()) {
-    for (const intentId of definition.intentIds) {
-      if (!catalog.intents.has(intentId)) issues.push(`${definition.id}: Missing Intent "${intentId}"`);
-    }
-  }
-  for (const { definition } of catalog.workflows.values()) {
-    for (const step of definition.steps) {
-      if (!catalog.capabilities.has(step.capabilityRef.id)) {
-        issues.push(`${definition.id}: Missing Capability "${step.capabilityRef.id}"`);
-      }
-    }
-  }
-  if (issues.length > 0) throw new Error(`Invalid Agency relationships:
-${issues.join("\n")}`);
-}
-var AgencyModelRepository;
-var init_agencyModelRepository = __esm({
-  "src/goal/agencyModelRepository.ts"() {
-    "use strict";
-    AgencyModelRepository = class {
-      constructor(backend, tenantId2) {
-        this.backend = backend;
-        this.tenantId = tenantId2;
-      }
-      backend;
-      tenantId;
-      async listManagedWork(catalog) {
-        const definitions = catalog ?? await this.loadCatalog();
-        const managed = [
-          ...Array.from(definitions.goals.values(), ({ definition, revision }) => ({
-            definition,
-            revision,
-            kind: "goal"
-          })),
-          ...Array.from(definitions.loops.values(), ({ definition, revision }) => ({
-            definition,
-            revision,
-            kind: "loop"
-          }))
-        ];
-        return Promise.all(
-          managed.map(async (record2) => ({
-            definition: record2.definition,
-            revision: record2.revision,
-            state: parseState(
-              await this.backend.getAgencyState(this.tenantId, record2.kind, record2.definition.id),
-              record2.definition,
-              record2.kind
-            )
-          }))
-        );
-      }
-      async loadCatalog() {
-        const documents = await this.backend.listAgencyDefinitions(this.tenantId);
-        const catalog = emptyCatalog();
-        const ordered = [...documents].sort(
-          (left, right) => left.createdAt.localeCompare(right.createdAt) || left.recordId.localeCompare(right.recordId)
-        );
-        const latest = /* @__PURE__ */ new Map();
-        for (const document of ordered) {
-          latest.set(`${document.kind}:${definitionId(document)}`, document);
-        }
-        for (const document of latest.values()) addDefinition(catalog, document);
-        validateRelationships(catalog);
-        return catalog;
-      }
-      async saveState(state, kind, updatedAt) {
-        const data = kind === "goal" ? createGoalState(state) : createLoopState(state);
-        await this.backend.putAgencyState(this.tenantId, state.definitionId, kind, 1, data, updatedAt);
-      }
-      async appendOutput(recordId, output) {
-        await this.backend.appendAgencyOutput(this.tenantId, recordId, 1, createRunOutput(output));
-      }
-      async listOutputs(runId) {
-        const documents = await this.backend.listAgencyOutputs(this.tenantId, runId);
-        return documents.map((document) => {
-          if (document.schemaVersion !== 1) {
-            throw new Error(`Unsupported Agency Output schema: ${document.schemaVersion}`);
-          }
-          const output = createRunOutput(document.data);
-          if (output.runId !== document.runId) throw new Error(`Agency Output does not match Run: ${document.recordId}`);
-          return output;
-        });
-      }
-      async refreshGoalProgress(record2, updatedAt) {
-        if (!("executionRef" in record2.definition)) throw new Error("Only a Goal has progress");
-        const previous = record2.state;
-        if (previous && !("progress" in previous)) throw new Error("Goal Definition has Loop State");
-        const state = createGoalState({
-          definitionId: record2.definition.id,
-          lifecycle: previous?.lifecycle ?? "draft",
-          progress: goalProgressFromOutputs(record2.definition, record2.revision, await this.listOutputs()),
-          blockers: previous?.blockers ?? [],
-          updatedAt
-        });
-        await this.saveState(state, "goal", updatedAt);
-        return state;
-      }
-    };
-  }
-});
-
-// src/goal/policyResolver.ts
-import { createHash as createHash5 } from "crypto";
-function resolveDispatchPolicy(input) {
-  const operation = input.catalog.operations.get(input.owner.definition.operationId);
-  if (!operation) throw new Error(`Dispatch blocked: Operation "${input.owner.definition.operationId}" is unresolved`);
-  if (operation.definition.intentIds.length === 0) {
-    throw new Error(`Dispatch blocked: Operation "${operation.definition.id}" has no Intent`);
-  }
-  const intents = operation.definition.intentIds.map((intentId) => {
-    const intent = input.catalog.intents.get(intentId);
-    if (!intent) throw new Error(`Dispatch blocked: Intent "${intentId}" is unresolved`);
-    return intent;
-  });
-  const policy = mergePolicies(intents.map(({ definition }) => definition.policy));
-  const constraints = intents.flatMap(({ definition }) => definition.constraints);
-  const requiresApproval = assertAuthorized(policy, constraints, input.target);
-  const snapshotValue = { policy, constraints };
-  return {
-    snapshot: {
-      hash: createHash5("sha256").update(stableJson(snapshotValue)).digest("hex"),
-      ...snapshotValue
-    },
-    operation,
-    intents,
-    trace: [pinned("trigger" in input.owner.definition ? "loop" : "goal", input.owner), input.target],
-    requiresApproval
-  };
-}
-function mergePolicies(policies) {
-  const approvalOrder = ["none", "risky-actions", "all-actions"];
-  return {
-    approval: policies.reduce(
-      (strictest, policy) => approvalOrder.indexOf(policy.approval) > approvalOrder.indexOf(strictest) ? policy.approval : strictest,
-      "none"
-    ),
-    authority: {
-      allow: intersect(policies.map(({ authority }) => authority.allow)),
-      deny: unique(policies.flatMap(({ authority }) => authority.deny))
-    },
-    budget: {
-      maxRuns: Math.min(...policies.map(({ budget }) => budget.maxRuns)),
-      maxTokens: Math.min(...policies.map(({ budget }) => budget.maxTokens)),
-      maxCostUsd: Math.min(...policies.map(({ budget }) => budget.maxCostUsd)),
-      maxDurationSeconds: Math.min(...policies.map(({ budget }) => budget.maxDurationSeconds))
-    },
-    maxConcurrentRuns: Math.min(...policies.map(({ maxConcurrentRuns }) => maxConcurrentRuns)),
-    riskyActions: unique(policies.flatMap(({ riskyActions }) => riskyActions))
-  };
-}
-function assertAuthorized(policy, constraints, target) {
-  const action = `${target.kind}:${target.id}`;
-  const matches = (patterns) => patterns.some((pattern) => pattern === "*" || pattern === target.id || pattern === action);
-  if (matches(policy.authority.deny)) throw new Error(`Dispatch blocked: authority denies "${action}"`);
-  if (!matches(policy.authority.allow)) throw new Error(`Dispatch blocked: authority does not allow "${action}"`);
-  const matchingConstraints = constraints.filter(({ actions }) => matches(actions));
-  const denied = matchingConstraints.find(({ effect }) => effect === "deny");
-  if (denied) throw new Error(`Dispatch blocked by constraint "${denied.id}": ${denied.rule}`);
-  const requiresApproval = policy.approval === "all-actions" || policy.approval === "risky-actions" && matches(policy.riskyActions) || matchingConstraints.some(({ effect }) => effect === "require-approval");
-  return requiresApproval;
-}
-function pinned(kind, record2) {
-  return { kind, id: record2.definition.id, revision: record2.revision };
-}
-function intersect(groups) {
-  if (groups.length === 0) return [];
-  if (groups.every((group) => group.includes("*"))) return ["*"];
-  const candidates = unique(groups.flatMap((group) => group.filter((item) => item !== "*")));
-  return candidates.filter((candidate) => groups.every((group) => group.includes("*") || group.includes(candidate)));
-}
-function unique(values) {
-  return [...new Set(values)].sort();
-}
-function stableJson(value) {
-  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
-  if (value && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-var init_policyResolver = __esm({
-  "src/goal/policyResolver.ts"() {
-    "use strict";
-  }
-});
-
-// src/goal/triggerDispatcher.ts
-function decideTrigger(input) {
-  if (!input.state) return { kind: "skip", reason: "loop has no runtime state" };
-  if (input.state.lifecycle !== "active") {
-    return { kind: "skip", reason: `loop is ${input.state.lifecycle}` };
-  }
-  const trigger = input.definition.trigger;
-  if (input.manualRequestId?.trim()) {
-    return {
-      kind: "fire",
-      reason: "manual trigger was requested",
-      scheduledAt: input.now.toISOString(),
-      idempotencyKey: `${input.definition.id}:manual:${input.manualRequestId.trim()}`
-    };
-  }
-  if (trigger.type === "manual") {
-    return { kind: "skip", reason: "manual trigger was not requested" };
-  }
-  if (trigger.type !== "schedule") {
-    return { kind: "skip", reason: `${trigger.type} trigger is not enabled yet` };
-  }
-  const interval = parseInterval(trigger.every);
-  const anchor = input.state.lastFiredAt ? Date.parse(input.state.lastFiredAt) : input.now.getTime() - interval;
-  const dueAt = anchor + interval;
-  if (input.now.getTime() < dueAt) {
-    return { kind: "skip", reason: "scheduled trigger is not due", nextEligibleAt: new Date(dueAt).toISOString() };
-  }
-  const elapsedIntervals = Math.max(1, Math.floor((input.now.getTime() - anchor) / interval));
-  const scheduledAt = new Date(anchor + elapsedIntervals * interval).toISOString();
-  return {
-    kind: "fire",
-    reason: "scheduled trigger is due",
-    scheduledAt,
-    idempotencyKey: `${input.definition.id}:schedule:${scheduledAt}`
-  };
-}
-function parseInterval(value) {
-  const match = value.trim().match(/^(\d+)(m|h|d)$/);
-  if (!match) throw new Error(`Unsupported schedule interval: ${value}`);
-  const amount = Number(match[1]);
-  if (!Number.isSafeInteger(amount) || amount < 1) throw new Error(`Unsupported schedule interval: ${value}`);
-  const unit = match[2] === "m" ? 6e4 : match[2] === "h" ? 36e5 : 864e5;
-  return amount * unit;
-}
-var init_triggerDispatcher = __esm({
-  "src/goal/triggerDispatcher.ts"() {
-    "use strict";
-  }
-});
-
-// src/scripts/dispatchAgencyLoops.ts
-import { randomUUID } from "crypto";
-import {
-  createLoopState as createLoopState2,
-  createRun
-} from "@kody-ade/agency-domain";
-async function dispatchAgencyLoopsWith(input) {
-  const repository = new AgencyModelRepository(input.backend, input.tenantId);
-  const catalog = await repository.loadCatalog();
-  const records = await repository.listManagedWork(catalog);
-  const loops = records.flatMap(
-    (record2) => "trigger" in record2.definition ? [{ ...record2, definition: record2.definition, state: record2.state }] : []
-  );
-  const results = [];
-  for (const record2 of loops) {
-    if (input.manualRequest && record2.definition.id !== input.manualRequest.loopId) {
-      continue;
-    }
-    const decision = decideTrigger({
-      definition: record2.definition,
-      state: record2.state,
-      now: input.now,
-      ...input.manualRequest ? { manualRequestId: input.manualRequest.requestId } : {}
-    });
-    const now = input.now.toISOString();
-    if (decision.kind === "skip") {
-      const key = `${record2.definition.id}:skip:${now}`;
-      await input.backend.recordSkippedAgencyDispatch(input.tenantId, key, record2.definition.id, decision, now);
-      if (record2.state && decision.nextEligibleAt) {
-        await repository.saveState(
-          createLoopState2({ ...record2.state, nextEligibleAt: decision.nextEligibleAt, updatedAt: now }),
-          "loop",
-          now
-        );
-      }
-      results.push({ loopId: record2.definition.id, decision: "skipped", reason: decision.reason });
-      continue;
-    }
-    let target;
-    let policy;
-    try {
-      target = resolveTarget(record2.definition, catalog);
-      policy = resolveDispatchPolicy({
-        catalog,
-        owner: { definition: record2.definition, revision: record2.revision },
-        target: target.reference
-      });
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      await input.backend.recordSkippedAgencyDispatch(
-        input.tenantId,
-        decision.idempotencyKey,
-        record2.definition.id,
-        { kind: "skip", reason, scheduledAt: decision.scheduledAt },
-        now
-      );
-      results.push({ loopId: record2.definition.id, decision: "skipped", reason });
-      continue;
-    }
-    const failurePolicy = record2.definition.reconciliationPolicy.failure;
-    const budget = policy.snapshot.policy.budget;
-    const maxAttempts = Math.min(failurePolicy.maxAttempts, budget.maxRuns);
-    const timeoutSeconds = Math.min(failurePolicy.timeoutSeconds, budget.maxDurationSeconds);
-    const backoffBudgetSeconds = Array.from(
-      { length: Math.max(0, maxAttempts - 1) },
-      (_, index) => failurePolicy.backoffSeconds * 2 ** index
-    ).reduce((sum, seconds) => sum + seconds, 0);
-    const leaseSeconds = Math.min(budget.maxDurationSeconds, maxAttempts * timeoutSeconds + backoffBudgetSeconds);
-    const leaseUntil = new Date(input.now.getTime() + leaseSeconds * 1e3).toISOString();
-    const reservationId = `reservation-${randomUUID()}`;
-    const correlationId = `corr-${randomUUID()}`;
-    const trace = [policy.trace[0], ...target.intermediate, target.reference];
-    const reservation = await input.backend.reserveAgencyDispatch(input.tenantId, {
-      idempotencyKey: decision.idempotencyKey,
-      loopId: record2.definition.id,
-      decision,
-      leaseUntil,
-      reservationId,
-      correlationId,
-      policyHash: policy.snapshot.hash,
-      effectivePolicy: policy.snapshot,
-      definitionRefs: trace,
-      maxConcurrentRuns: policy.snapshot.policy.maxConcurrentRuns,
-      requiresApproval: policy.requiresApproval,
-      approvalScopeKind: "loop",
-      approvalScopeId: record2.definition.id,
-      approvalAction: `${target.reference.kind}:${target.reference.id}`,
-      now
-    });
-    if (!reservation.acquired) {
-      const duplicate = reservation.reason === "duplicate";
-      const reason = reservation.reason === "approval-required" ? "dispatch is waiting for approval" : reservation.reason === "concurrency-limit" ? "dispatch is waiting for policy capacity" : "trigger firing already reserved";
-      results.push({
-        loopId: record2.definition.id,
-        decision: duplicate ? "duplicate" : "skipped",
-        reason
-      });
-      continue;
-    }
-    const runningState = createLoopState2({
-      definitionId: record2.definition.id,
-      lifecycle: record2.state?.lifecycle ?? "active",
-      health: record2.state?.health ?? "unknown",
-      failures: record2.state?.failures ?? 0,
-      lastFiredAt: decision.scheduledAt,
-      updatedAt: now
-    });
-    await repository.saveState(runningState, "loop", now);
-    try {
-      let attempts = 0;
-      let tokens = 0;
-      let costUsd = 0;
-      let succeeded = false;
-      let reason = "target failed";
-      let finalRunId;
-      let finalCapabilityResults = [];
-      const budgetDeadline = Date.now() + budget.maxDurationSeconds * 1e3;
-      for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const remainingMilliseconds = budgetDeadline - Date.now();
-        if (remainingMilliseconds <= 0) {
-          reason = "policy duration budget exhausted";
-          break;
-        }
-        attempts = attempt;
-        const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        const runId = `run-${randomUUID()}`;
-        finalRunId = runId;
-        const activeRun = createRun({
-          id: runId,
-          status: "running",
-          origin: { kind: "loop", id: record2.definition.id, revision: record2.revision },
-          target: target.reference,
-          trace,
-          effectivePolicy: policy.snapshot,
-          correlationId,
-          startedAt
-        });
-        await input.backend.createAgencyModelRun(
-          input.tenantId,
-          target.reference.kind,
-          target.reference.id,
-          activeRun,
-          startedAt
-        );
-        const attemptResult = await runAttempt(
-          input.run,
-          target.job,
-          Math.min(timeoutSeconds, remainingMilliseconds / 1e3)
-        );
-        tokens += attemptResult.usage?.tokens ?? 0;
-        costUsd += attemptResult.usage?.costUsd ?? 0;
-        const finishedAt2 = (/* @__PURE__ */ new Date()).toISOString();
-        succeeded = attemptResult.exitCode === 0;
-        finalCapabilityResults = attemptResult.capabilityResults ?? [];
-        reason = attemptResult.reason ?? (succeeded ? "target dispatched" : "target failed");
-        const usage = {
-          tokens: attemptResult.usage?.tokens ?? 0,
-          costUsd: attemptResult.usage?.costUsd ?? 0,
-          durationSeconds: Math.max(0, (Date.parse(finishedAt2) - Date.parse(startedAt)) / 1e3)
-        };
-        if (tokens > budget.maxTokens || costUsd > budget.maxCostUsd) {
-          succeeded = false;
-          reason = tokens > budget.maxTokens ? "policy token budget exhausted" : "policy cost budget exhausted";
-        }
-        await input.backend.finishAgencyModelRun(
-          input.tenantId,
-          terminalRun(activeRun, succeeded ? "succeeded" : "failed", finishedAt2, usage),
-          finishedAt2
-        );
-        if (tokens > budget.maxTokens || costUsd > budget.maxCostUsd) break;
-        if (succeeded || attempt === maxAttempts) break;
-        const backoffMilliseconds = failurePolicy.backoffSeconds * 2 ** (attempt - 1) * 1e3;
-        if (Date.now() + backoffMilliseconds >= budgetDeadline) {
-          reason = "policy duration budget exhausted during retry backoff";
-          break;
-        }
-        await wait(backoffMilliseconds);
-      }
-      const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const goalRecord = record2.definition.targetRef.kind === "goal" ? records.find(
-        (candidate) => "executionRef" in candidate.definition && candidate.definition.id === record2.definition.targetRef.id
-      ) : void 0;
-      if (succeeded && finalRunId) {
-        await appendCapabilityOutputs(
-          repository,
-          finalRunId,
-          target.reference,
-          goalRecord ? {
-            kind: "goal",
-            id: goalRecord.definition.id,
-            revision: goalRecord.revision
-          } : {
-            kind: "loop",
-            id: record2.definition.id,
-            revision: record2.revision
-          },
-          finalCapabilityResults,
-          finishedAt
-        );
-      }
-      if (succeeded && goalRecord) {
-        await repository.refreshGoalProgress(goalRecord, finishedAt);
-      }
-      await input.backend.finishAgencyDispatch(
-        input.tenantId,
-        decision.idempotencyKey,
-        reservationId,
-        succeeded ? "dispatched" : "dead-letter",
-        finishedAt,
-        finalRunId
-      );
-      await repository.saveState(
-        createLoopState2({
-          ...runningState,
-          health: succeeded ? "healthy" : "degraded",
-          failures: succeeded ? 0 : runningState.failures + 1,
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }),
-        "loop",
-        (/* @__PURE__ */ new Date()).toISOString()
-      );
-      results.push({
-        loopId: record2.definition.id,
-        decision: succeeded ? "dispatched" : "failed",
-        reason: succeeded ? reason : `${reason}; dead-lettered after ${attempts} attempt${attempts === 1 ? "" : "s"}`
-      });
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-      await input.backend.finishAgencyDispatch(
-        input.tenantId,
-        decision.idempotencyKey,
-        reservationId,
-        "dead-letter",
-        finishedAt
-      );
-      results.push({ loopId: record2.definition.id, decision: "failed", reason });
-    }
-  }
-  return results;
-}
-function resolveTarget(loop, catalog) {
-  const goal = loop.targetRef.kind === "goal" ? catalog.goals.get(loop.targetRef.id) : void 0;
-  if (loop.targetRef.kind === "goal" && !goal) throw new Error(`Loop target Goal is missing: ${loop.targetRef.id}`);
-  if (goal && goal.definition.operationId !== loop.operationId) {
-    throw new Error(`Loop and target Goal must belong to the same Operation`);
-  }
-  const target = goal?.definition.executionRef ?? loop.targetRef;
-  if (target.kind === "goal") throw new Error("Nested Goal target is invalid");
-  const record2 = target.kind === "workflow" ? catalog.workflows.get(target.id) : catalog.capabilities.get(target.id);
-  if (!record2) throw new Error(`Loop execution target is missing: ${target.kind}:${target.id}`);
-  const reference = { kind: target.kind, id: target.id, revision: record2.revision };
-  return {
-    reference,
-    intermediate: goal ? [{ kind: "goal", id: goal.definition.id, revision: goal.revision }] : [],
-    job: target.kind === "workflow" ? { workflow: target.id, cliArgs: {}, flavor: "scheduled" } : { capability: target.id, cliArgs: {}, flavor: "scheduled" }
-  };
-}
-function terminalRun(active, status, finishedAt, usage) {
-  return createRun({ ...active, status, finishedAt, usage });
-}
-async function runAttempt(run, job, timeoutSeconds) {
-  const abortController = new AbortController();
-  let timer;
-  try {
-    return await Promise.race([
-      run(job, abortController).catch((error) => ({
-        exitCode: 99,
-        reason: error instanceof Error ? error.message : String(error)
-      })),
-      new Promise((resolve19) => {
-        timer = setTimeout(() => {
-          abortController.abort();
-          resolve19({ exitCode: 124, reason: `target timed out after ${formatSeconds(timeoutSeconds)}s` });
-        }, timeoutSeconds * 1e3);
-      })
-    ]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-async function appendCapabilityOutputs(repository, runId, producer, parentRef, results, createdAt) {
-  for (const result of results) {
-    const outputs = [
-      ...Object.entries(result.facts).map(([key, value]) => ({ kind: "fact", key, value })),
-      ...Object.entries(result.evidence ?? {}).map(([key, value]) => ({
-        kind: "evidence",
-        key,
-        value
-      })),
-      ...result.artifacts.map((artifact, index) => ({
-        kind: "artifact",
-        key: artifact.label || `artifact-${index + 1}`,
-        value: artifact
-      }))
-    ];
-    for (const output of outputs) {
-      await repository.appendOutput(`output-${randomUUID()}`, {
-        ...output,
-        runId,
-        producer: { kind: producer.kind, id: producer.id },
-        parentRef,
-        contract: "capability-result/v1",
-        createdAt
-      });
-    }
-  }
-}
-function formatSeconds(seconds) {
-  return Number.isInteger(seconds) ? String(seconds) : seconds.toFixed(3).replace(/0+$/, "").replace(/\.$/, "");
-}
-async function wait(milliseconds) {
-  if (milliseconds <= 0) return;
-  await new Promise((resolve19) => setTimeout(resolve19, milliseconds));
-}
-function repositoryTenant(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;
-}
-var dispatchAgencyLoops;
-var init_dispatchAgencyLoops = __esm({
-  "src/scripts/dispatchAgencyLoops.ts"() {
-    "use strict";
-    init_agencyModelRepository();
-    init_policyResolver();
-    init_triggerDispatcher();
-    init_job();
-    init_state_backend();
-    dispatchAgencyLoops = async (ctx) => {
-      const tenantId2 = repositoryTenant(ctx.config);
-      if (!tenantId2) throw new Error("Repository identity is required for Agency Loop dispatch");
-      const backend = createStateBackendFromEnv();
-      const requestedLoopId = typeof ctx.args.loop === "string" ? ctx.args.loop.trim() : "";
-      const results = await dispatchAgencyLoopsWith({
-        tenantId: tenantId2,
-        backend,
-        now: /* @__PURE__ */ new Date(),
-        ...requestedLoopId ? {
-          manualRequest: {
-            loopId: requestedLoopId,
-            requestId: process.env.GITHUB_RUN_ID?.trim() || `local-${randomUUID()}`
-          }
-        } : {},
-        run: (job, abortController) => runJob(job, {
-          cwd: ctx.cwd,
-          config: ctx.config,
-          verbose: ctx.verbose,
-          quiet: ctx.quiet,
-          chain: false,
-          abortController
-        })
-      });
-      ctx.data.agencyLoopDispatchResults = results;
-    };
-  }
-});
-
 // src/scripts/dispatchCapabilityFileTicks.ts
 var dispatchCapabilityFileTicks;
 var init_dispatchCapabilityFileTicks = __esm({
@@ -13876,72 +13152,6 @@ var init_dispatchClassified = __esm({
   }
 });
 
-// src/jobIdentity.ts
-function stableJobKey(job) {
-  const capability = job.workflow ?? job.capability ?? job.action;
-  const implementation = job.implementation ?? capability ?? "unknown";
-  if (job.flavor === "scheduled" && job.capability) return `scheduled:${job.capability}:${implementation}`;
-  const target = typeof job.target === "number" ? job.target : targetFromCliArgs(job.cliArgs);
-  const work = capability && implementation && implementation !== capability ? `${capability}:${implementation}` : capability ?? implementation;
-  return target === void 0 ? `${job.flavor}:${work}` : `${job.flavor}:${work}:${target}`;
-}
-function targetFromCliArgs(cliArgs) {
-  if (!cliArgs) return void 0;
-  for (const key of ["issue", "pr", "target", "issue_number"]) {
-    const value = cliArgs[key];
-    if (typeof value === "number" && Number.isFinite(value)) return value;
-  }
-  return void 0;
-}
-var init_jobIdentity = __esm({
-  "src/jobIdentity.ts"() {
-    "use strict";
-  }
-});
-
-// src/scripts/dispatchNextTaskJob.ts
-function taskJobToJob(job, issueArg) {
-  const target = typeof job.target === "number" ? job.target : typeof issueArg === "number" ? issueArg : void 0;
-  return {
-    capability: job.capability ?? job.implementation,
-    implementation: job.implementation,
-    ...job.reason ? { why: job.reason } : {},
-    ...job.agent ? { agent: job.agent } : {},
-    ...job.schedule ? { schedule: job.schedule } : {},
-    ...typeof target === "number" ? { target, cliArgs: { issue: target } } : { cliArgs: {} },
-    flavor: job.flavor ?? "instant"
-  };
-}
-function isJob(input) {
-  if (!input || typeof input !== "object" || Array.isArray(input)) return false;
-  const job = input;
-  return (typeof job.capability === "string" || typeof job.action === "string") && (job.flavor === "instant" || job.flavor === "scheduled") && (!job.cliArgs || typeof job.cliArgs === "object" && !Array.isArray(job.cliArgs));
-}
-var dispatchNextTaskJob;
-var init_dispatchNextTaskJob = __esm({
-  "src/scripts/dispatchNextTaskJob.ts"() {
-    "use strict";
-    init_jobIdentity();
-    init_state();
-    dispatchNextTaskJob = async (ctx, profile) => {
-      const state = ctx.data.taskState ?? emptyState();
-      const ids = Array.isArray(ctx.data.plannedTaskJobIds) ? ctx.data.plannedTaskJobIds.filter((id) => typeof id === "string") : void 0;
-      const next = nextPendingTaskJob(state, ids);
-      ctx.skipAgent = true;
-      if (!next) {
-        ctx.output.exitCode = 0;
-        ctx.output.reason = "all planned task jobs are complete";
-        return;
-      }
-      const plannedJobs = Array.isArray(ctx.data.plannedTaskJobs) ? ctx.data.plannedTaskJobs.filter(isJob) : [];
-      ctx.output.nextJob = plannedJobs.find((job) => stableJobKey(job) === next.id) ?? taskJobToJob(next, ctx.args.issue);
-      if (typeof ctx.args.issue === "number") {
-        ctx.output.afterNextJob = { action: profile.action ?? profile.name, cliArgs: { issue: ctx.args.issue } };
-      }
-    };
-  }
-});
-
 // src/loopDefinitions.ts
 import * as fs36 from "fs";
 import * as path34 from "path";
@@ -13976,15 +13186,15 @@ function readLoopDefinition(cwd, id) {
     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}
+      process.stderr.write(`[kody] invalid Loop definition: ${filePath}
 `);
     } catch {
-      process.stderr.write(`[kody] unreadable simple Loop definition: ${filePath}
+      process.stderr.write(`[kody] unreadable Loop definition: ${filePath}
 `);
     }
   }
   process.stderr.write(
-    `[kody] simple Loop not found: ${id} (${roots.map((root) => path34.join(root, "loops", id, "loop.json")).join(", ")})
+    `[kody] Loop not found: ${id} (${roots.map((root) => path34.join(root, "loops", id, "loop.json")).join(", ")})
 `
   );
   return null;
@@ -14003,7 +13213,7 @@ function listLoopDefinitions(cwd) {
         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}
+        process.stderr.write(`[kody] unreadable Loop definition: ${filePath}
 `);
       }
     }
@@ -14047,11 +13257,81 @@ var init_loopDefinitions = __esm({
   }
 });
 
-// src/scripts/dispatchSimpleLoops.ts
-import { randomUUID as randomUUID2 } from "crypto";
+// src/scripts/dispatchLoops.ts
+import { randomUUID } from "crypto";
+async function dispatchLoopsWith(input) {
+  const results = [];
+  for (const loop of input.loops) {
+    const slot = loopDispatchSlot(loop, input.now, input.force, input.nonce());
+    if (!slot) continue;
+    const reservationId = `reservation-${input.nonce()}`;
+    const idempotencyKey = `${loop.id}:${slot}`;
+    const claimed = await input.backend.reserveLoopDispatch(input.tenantId, {
+      idempotencyKey,
+      loopId: loop.id,
+      decision: {
+        kind: "fire",
+        reason: input.force ? "manual Loop run requested" : "local Loop schedule is due",
+        scheduledAt: slot
+      },
+      leaseUntil: new Date(input.now.getTime() + LOOP_DISPATCH_LEASE_MS).toISOString(),
+      reservationId,
+      correlationId: `corr-${input.nonce()}`,
+      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: input.now.toISOString()
+    });
+    if (!claimed.acquired) {
+      results.push({ loopId: loop.id, status: "skipped", reason: claimed.reason ?? "already claimed" });
+      continue;
+    }
+    const runId = `loop-${loop.id}-${input.nonce()}`;
+    const startedAt = input.now.toISOString();
+    const running = {
+      id: runId,
+      status: "running",
+      target: loop.target,
+      agent: "kody",
+      startedAt
+    };
+    await input.backend.createAgencyRun(input.tenantId, "loop", loop.id, running, startedAt);
+    let exitCode;
+    let reason;
+    try {
+      const result = await input.run(loopJob(loop), runId);
+      exitCode = result.exitCode;
+      reason = result.reason ?? (exitCode === 0 ? "dispatched" : "target failed");
+    } catch (error) {
+      exitCode = 1;
+      reason = error instanceof Error ? error.message : String(error);
+    }
+    const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const succeeded = exitCode === 0;
+    await input.backend.finishAgencyRun(
+      input.tenantId,
+      {
+        ...running,
+        status: succeeded ? "succeeded" : "failed",
+        finishedAt,
+        ...succeeded ? { output: { summary: reason } } : { error: reason }
+      },
+      finishedAt
+    );
+    const status = succeeded ? "dispatched" : "failed";
+    await input.backend.finishLoopDispatch(input.tenantId, idempotencyKey, reservationId, status, finishedAt, runId);
+    results.push({ loopId: loop.id, status, reason });
+  }
+  return results;
+}
 function selectRunnableLoops(loops, now, options) {
   return loops.filter(
-    (loop) => loop.enabled && loop.trigger.type === "schedule" && (!options.loopId || loop.id === options.loopId) && (options.force || dueSlot(loop, now) !== null)
+    (loop) => loop.enabled && (!options.loopId || loop.id === options.loopId) && (options.force || loop.trigger.type === "schedule" && dueSlot(loop, now) !== null)
   );
 }
 function loopDispatchSlot(loop, now, force, nonce) {
@@ -14093,21 +13373,22 @@ function loopJob(loop) {
   );
   return loop.target.kind === "workflow" ? { workflow: loop.target.id, cliArgs, flavor: "scheduled" } : { capability: loop.target.id, cliArgs, flavor: "scheduled" };
 }
-function repositoryTenant2(config) {
+function repositoryTenant(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"() {
+var LOOP_DISPATCH_LEASE_MS, dispatchLoops;
+var init_dispatchLoops = __esm({
+  "src/scripts/dispatchLoops.ts"() {
     "use strict";
     init_job();
     init_loopDefinitions();
     init_state_backend();
-    dispatchSimpleLoops = async (ctx) => {
-      const tenantId2 = repositoryTenant2(ctx.config);
+    LOOP_DISPATCH_LEASE_MS = 6 * 60 * 60 * 1e3;
+    dispatchLoops = async (ctx) => {
+      const tenantId2 = repositoryTenant(ctx.config);
       if (!tenantId2) throw new Error("Repository identity is required for Loop dispatch");
       const now = /* @__PURE__ */ new Date();
       const force = ctx.data.jobForce === true;
@@ -14119,53 +13400,93 @@ var init_dispatchSimpleLoops = __esm({
       process.stdout.write(`\u2192 kody: Loop scheduler found ${due.length} runnable Loop(s)${force ? " (manual)" : ""}
 `);
       const backend = createStateBackendFromEnv();
-      const results = [];
-      for (const loop of due) {
-        const slot = loopDispatchSlot(loop, now, force, randomUUID2());
-        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: force ? "manual Loop run requested" : "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), {
+      const results = await dispatchLoopsWith({
+        loops: due,
+        tenantId: tenantId2,
+        backend,
+        now,
+        force,
+        nonce: randomUUID,
+        run: (job, parentRunId) => runJob(job, {
           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 });
-      }
+          chain: false,
+          preloadedData: { parentRunId }
+        })
+      });
       for (const result of results) {
         process.stdout.write(`\u2192 kody: Loop ${result.loopId} ${result.status}: ${result.reason}
 `);
       }
-      ctx.data.simpleLoopDispatchResults = results;
+      ctx.data.loopDispatchResults = results;
+    };
+  }
+});
+
+// src/jobIdentity.ts
+function stableJobKey(job) {
+  const capability = job.workflow ?? job.capability ?? job.action;
+  const implementation = job.implementation ?? capability ?? "unknown";
+  if (job.flavor === "scheduled" && job.capability) return `scheduled:${job.capability}:${implementation}`;
+  const target = typeof job.target === "number" ? job.target : targetFromCliArgs(job.cliArgs);
+  const work = capability && implementation && implementation !== capability ? `${capability}:${implementation}` : capability ?? implementation;
+  return target === void 0 ? `${job.flavor}:${work}` : `${job.flavor}:${work}:${target}`;
+}
+function targetFromCliArgs(cliArgs) {
+  if (!cliArgs) return void 0;
+  for (const key of ["issue", "pr", "target", "issue_number"]) {
+    const value = cliArgs[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+var init_jobIdentity = __esm({
+  "src/jobIdentity.ts"() {
+    "use strict";
+  }
+});
+
+// src/scripts/dispatchNextTaskJob.ts
+function taskJobToJob(job, issueArg) {
+  const target = typeof job.target === "number" ? job.target : typeof issueArg === "number" ? issueArg : void 0;
+  return {
+    capability: job.capability ?? job.implementation,
+    implementation: job.implementation,
+    ...job.reason ? { why: job.reason } : {},
+    ...job.agent ? { agent: job.agent } : {},
+    ...job.schedule ? { schedule: job.schedule } : {},
+    ...typeof target === "number" ? { target, cliArgs: { issue: target } } : { cliArgs: {} },
+    flavor: job.flavor ?? "instant"
+  };
+}
+function isJob(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return false;
+  const job = input;
+  return (typeof job.capability === "string" || typeof job.action === "string") && (job.flavor === "instant" || job.flavor === "scheduled") && (!job.cliArgs || typeof job.cliArgs === "object" && !Array.isArray(job.cliArgs));
+}
+var dispatchNextTaskJob;
+var init_dispatchNextTaskJob = __esm({
+  "src/scripts/dispatchNextTaskJob.ts"() {
+    "use strict";
+    init_jobIdentity();
+    init_state();
+    dispatchNextTaskJob = async (ctx, profile) => {
+      const state = ctx.data.taskState ?? emptyState();
+      const ids = Array.isArray(ctx.data.plannedTaskJobIds) ? ctx.data.plannedTaskJobIds.filter((id) => typeof id === "string") : void 0;
+      const next = nextPendingTaskJob(state, ids);
+      ctx.skipAgent = true;
+      if (!next) {
+        ctx.output.exitCode = 0;
+        ctx.output.reason = "all planned task jobs are complete";
+        return;
+      }
+      const plannedJobs = Array.isArray(ctx.data.plannedTaskJobs) ? ctx.data.plannedTaskJobs.filter(isJob) : [];
+      ctx.output.nextJob = plannedJobs.find((job) => stableJobKey(job) === next.id) ?? taskJobToJob(next, ctx.args.issue);
+      if (typeof ctx.args.issue === "number") {
+        ctx.output.afterNextJob = { action: profile.action ?? profile.name, cliArgs: { issue: ctx.args.issue } };
+      }
     };
   }
 });
@@ -15892,9 +15213,9 @@ var init_kodyVariables = __esm({
 });
 
 // src/backendVault.ts
-import { createDecipheriv, createHash as createHash6 } from "crypto";
+import { createDecipheriv, createHash as createHash5 } from "crypto";
 function cacheKey(owner, repo, masterKey) {
-  const keyHash = createHash6("sha256").update(masterKey).digest("hex").slice(0, 16);
+  const keyHash = createHash5("sha256").update(masterKey).digest("hex").slice(0, 16);
   return `${owner}/${repo}:${keyHash}`.toLowerCase();
 }
 function decryptVault(payload, masterKey) {
@@ -16681,7 +16002,7 @@ var init_notifyTerminal = __esm({
 });
 
 // src/scripts/openAgencyModelReviewPr.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 function parseAgencyModelProposal(raw) {
   const text2 = raw.trim();
   const jsonText = (text2.match(/^```(?:json)?\s*\n([\s\S]*?)\n```$/i)?.[1] ?? text2).trim();
@@ -16733,7 +16054,7 @@ function normalizeBundleFiles(bundle) {
   });
 }
 function buildProposalId(issueNumber, bundle, sourceLabel) {
-  const digest = createHash7("sha256").update(JSON.stringify({ issueNumber, sourceLabel, title: bundle.title, files: normalizeBundleFiles(bundle) })).digest("hex").slice(0, 16);
+  const digest = createHash6("sha256").update(JSON.stringify({ issueNumber, sourceLabel, title: bundle.title, files: normalizeBundleFiles(bundle) })).digest("hex").slice(0, 16);
   return `issue-${issueNumber}-${digest}`;
 }
 function isDryRun(ctx) {
@@ -19063,9 +18384,9 @@ var init_reviewFlow = __esm({
 });
 
 // src/scripts/previewBuildHelpers.ts
-import { createDecipheriv as createDecipheriv2, createHash as createHash8, hkdfSync as hkdfSync2 } from "crypto";
+import { createDecipheriv as createDecipheriv2, createHash as createHash7, hkdfSync as hkdfSync2 } from "crypto";
 function shortHash(s) {
-  return createHash8("sha256").update(s).digest("hex").slice(0, 6);
+  return createHash7("sha256").update(s).digest("hex").slice(0, 6);
 }
 function previewAppName(repo, pr) {
   const [owner, name] = repo.split("/");
@@ -19098,7 +18419,7 @@ function formatPreviewComment(args) {
   ].join("\n");
 }
 function defaultImageTag(repo, ref) {
-  return createHash8("sha256").update(`${repo}@${ref}`).digest("hex").slice(0, 12);
+  return createHash7("sha256").update(`${repo}@${ref}`).digest("hex").slice(0, 12);
 }
 var init_previewBuildHelpers = __esm({
   "src/scripts/previewBuildHelpers.ts"() {
@@ -20985,12 +20306,11 @@ var init_scripts = __esm({
     init_diagMcp();
     init_discoverQaContext();
     init_dispatch();
-    init_dispatchAgencyLoops();
     init_dispatchCapabilityFileTicks();
     init_dispatchCapabilityTicks();
     init_dispatchClassified();
+    init_dispatchLoops();
     init_dispatchNextTaskJob();
-    init_dispatchSimpleLoops();
     init_ensurePr();
     init_evaluateAgencyBoundaries();
     init_failOnceTaskJob();
@@ -21116,8 +20436,7 @@ var init_scripts = __esm({
       diagMcp,
       warmupMcp,
       dispatchCapabilityTicks,
-      dispatchAgencyLoops,
-      dispatchSimpleLoops,
+      dispatchLoops,
       dispatchCapabilityFileTicks,
       planTaskJobs,
       dispatchNextTaskJob,
@@ -22582,6 +21901,7 @@ async function runJob(job, base) {
       updatedAt: startedAt,
       workflow: workflowIdentity,
       kodyRunId: valid.workflowRunId,
+      parentRunId: typeof base.preloadedData?.parentRunId === "string" ? base.preloadedData.parentRunId : void 0,
       sourceType: "job"
     };
     const persistRun = Boolean(base.config && !base.skipConfig && hasStateBackendConfig());
@@ -24413,6 +23733,7 @@ import { createHash as createHash2 } from "crypto";
 import * as fs16 from "fs";
 import * as path17 from "path";
 var SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+var REPOSITORY_OWNED_NAMESPACES = ["loops"];
 function assertSafeDefinitionPath(filePath) {
   const segments = filePath.split("/");
   if (!filePath || filePath.startsWith("/") || filePath.includes("\\") || filePath.includes("\0") || segments.some((segment) => !segment || segment === "." || segment === "..")) {
@@ -24469,6 +23790,13 @@ function writeDefinition(root, kind, definition) {
   }
   writeBundle(path17.join(root, "capabilities", definition.slug), 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 });
+  }
+}
 async function hydrateDefinitions(options) {
   const root = path17.join(options.cwd, ".kody-engine", "definitions");
   const staging = `${root}.tmp-${process.pid}-${Date.now()}`;
@@ -24507,6 +23835,7 @@ async function hydrateDefinitions(options) {
       writeDefinition(staging, "asset", definition);
       versions[`asset:${definition.slug}`] = definition.version;
     }
+    preserveRepositoryDefinitions(root, staging);
     const manifest = {
       schemaVersion: 1,
       tenantId: options.tenantId,
@@ -26841,7 +26170,7 @@ init_config();
 init_fetchRepoMcp();
 
 // src/servers/mcpHttpServer.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { createServer as createServer4 } from "http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -26850,7 +26179,7 @@ function buildMcpHttpServer(opts) {
   const transports = /* @__PURE__ */ new Map();
   for (const route of opts.routes) {
     const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID3()
+      sessionIdGenerator: () => randomUUID2()
     });
     transports.set(route.path, transport);
     routes.set(route.path, route.name);
@@ -27428,12 +26757,12 @@ import { createServer as createServer5 } from "http";
 
 // src/pool/agency-loop-tick.ts
 function normalizeRepositories(repositories) {
-  const unique2 = /* @__PURE__ */ new Set();
+  const unique = /* @__PURE__ */ new Set();
   for (const raw of repositories) {
     const repo = raw.trim().toLowerCase();
-    if (/^[^/\s]+\/[^/\s]+$/.test(repo)) unique2.add(repo);
+    if (/^[^/\s]+\/[^/\s]+$/.test(repo)) unique.add(repo);
   }
-  return [...unique2].sort();
+  return [...unique].sort();
 }
 async function runAgencyLoopTick(deps) {
   const repositories = normalizeRepositories(await deps.discover());