@kody-ade/kody-engine 0.4.412 → 0.4.413

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.412",
+      version: "0.4.413",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -2476,6 +2476,35 @@ function createStateBackendFromEnv(env = process.env, client) {
       });
       return Array.isArray(result) ? result : [];
     },
+    async reserveAgencyDispatch(tenantId2, idempotencyKey, loopId, decision, leaseUntil, now) {
+      const result = await transport.mutation(anyApi.agencyModel.reserveDispatch, {
+        tenantId: requireTenant(tenantId2),
+        idempotencyKey: requireNonEmpty(idempotencyKey, "idempotencyKey"),
+        loopId: requireNonEmpty(loopId, "loopId"),
+        decision,
+        leaseUntil,
+        now
+      });
+      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,
+        now
+      });
+    },
+    async finishAgencyDispatch(tenantId2, idempotencyKey, status, now, runId) {
+      await transport.mutation(anyApi.agencyModel.finishDispatch, {
+        tenantId: requireTenant(tenantId2),
+        idempotencyKey: requireNonEmpty(idempotencyKey, "idempotencyKey"),
+        status,
+        now,
+        ...runId ? { runId: requireNonEmpty(runId, "runId") } : {}
+      });
+    },
     async appendRunEvent(tenantId2, runId, goalId, event, time) {
       await transport.mutation(anyApi.runEvents.append, {
         tenantId: requireTenant(tenantId2),
@@ -12938,6 +12967,277 @@ var init_dispatchClassified = __esm({
   }
 });
 
+// src/goal/agencyModelRepository.ts
+import {
+  createCapabilityDefinition,
+  createGoalDefinition,
+  createGoalState,
+  createIntentDefinition,
+  createLoopDefinition,
+  createLoopState,
+  createOperationDefinition,
+  createRunOutput,
+  createWorkflowDefinition
+} from "@kody-ade/agency-domain";
+function goalProgressFromOutputs(definition, 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).map((output) => output.key)
+  );
+  return required2.filter((key) => satisfied.has(key)).length / required2.length;
+}
+function validateAllDefinitions(documents) {
+  for (const document of documents) {
+    if (document.schemaVersion !== 1) throw new Error(`Unsupported Agency Definition schema: ${document.schemaVersion}`);
+    if (document.kind === "intent") createIntentDefinition(document.data);
+    else if (document.kind === "operation") createOperationDefinition(document.data);
+    else if (document.kind === "goal") createGoalDefinition(document.data);
+    else if (document.kind === "loop") createLoopDefinition(document.data);
+    else if (document.kind === "workflow") createWorkflowDefinition(document.data);
+    else createCapabilityDefinition(document.data);
+  }
+}
+function parseManagedDefinition(document) {
+  return document.kind === "goal" ? createGoalDefinition(document.data) : createLoopDefinition(document.data);
+}
+function parseState(document, definition) {
+  if (!document) return null;
+  if (document.schemaVersion !== 1) throw new Error(`Unsupported Agency State schema: ${document.schemaVersion}`);
+  if (document.kind !== definition.kind || document.definitionId !== definition.recordId) {
+    throw new Error(`Agency State does not match Definition: ${definition.recordId}`);
+  }
+  return document.kind === "goal" ? createGoalState(document.data) : createLoopState(document.data);
+}
+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() {
+        const documents = await this.backend.listAgencyDefinitions(this.tenantId);
+        validateAllDefinitions(documents);
+        const managed = documents.filter(
+          (document) => document.kind === "goal" || document.kind === "loop"
+        );
+        return Promise.all(
+          managed.map(async (document) => ({
+            definition: parseManagedDefinition(document),
+            state: parseState(await this.backend.getAgencyState(this.tenantId, document.recordId), document)
+          }))
+        );
+      }
+      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, await this.listOutputs()),
+          blockers: previous?.blockers ?? [],
+          updatedAt
+        });
+        await this.saveState(state, "goal", updatedAt);
+        return state;
+      }
+    };
+  }
+});
+
+// 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 (trigger.type === "manual") {
+    if (!input.manualRequestId?.trim()) return { kind: "skip", reason: "manual trigger was not requested" };
+    return {
+      kind: "fire",
+      reason: "manual trigger was requested",
+      scheduledAt: input.now.toISOString(),
+      idempotencyKey: `${input.definition.id}:manual:${input.manualRequestId.trim()}`
+    };
+  }
+  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 { createLoopState as createLoopState2 } from "@kody-ade/agency-domain";
+async function dispatchAgencyLoopsWith(input) {
+  const repository = new AgencyModelRepository(input.backend, input.tenantId);
+  const records = await repository.listManagedWork();
+  const loops = records.filter(
+    (record2) => "trigger" in record2.definition
+  );
+  const results = [];
+  for (const record2 of loops) {
+    const decision = decideTrigger({ definition: record2.definition, state: record2.state, now: input.now });
+    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;
+    }
+    const leaseUntil = new Date(input.now.getTime() + 15 * 6e4).toISOString();
+    const reservation = await input.backend.reserveAgencyDispatch(
+      input.tenantId,
+      decision.idempotencyKey,
+      record2.definition.id,
+      decision,
+      leaseUntil,
+      now
+    );
+    if (!reservation.acquired) {
+      results.push({ loopId: record2.definition.id, decision: "duplicate", reason: "trigger firing already reserved" });
+      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 {
+      const output = await input.run(jobForTarget(record2.definition));
+      const succeeded = output.exitCode === 0;
+      await input.backend.finishAgencyDispatch(
+        input.tenantId,
+        decision.idempotencyKey,
+        succeeded ? "dispatched" : "failed",
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+      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: output.reason ?? (succeeded ? "target dispatched" : "target failed")
+      });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      await input.backend.finishAgencyDispatch(input.tenantId, decision.idempotencyKey, "failed", (/* @__PURE__ */ new Date()).toISOString());
+      results.push({ loopId: record2.definition.id, decision: "failed", reason });
+    }
+  }
+  return results;
+}
+function jobForTarget(loop) {
+  if (loop.targetRef.kind === "workflow") {
+    return { workflow: loop.targetRef.id, cliArgs: {}, flavor: "scheduled" };
+  }
+  if (loop.targetRef.kind === "capability") {
+    return { capability: loop.targetRef.id, cliArgs: {}, flavor: "scheduled" };
+  }
+  return {
+    capability: "goal-manager",
+    implementation: "goal-manager",
+    cliArgs: { goal: loop.targetRef.id },
+    flavor: "scheduled"
+  };
+}
+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_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 results = await dispatchAgencyLoopsWith({
+        tenantId: tenantId2,
+        backend,
+        now: /* @__PURE__ */ new Date(),
+        run: (job) => runJob(job, { cwd: ctx.cwd, config: ctx.config, verbose: ctx.verbose, quiet: ctx.quiet, chain: false })
+      });
+      ctx.data.agencyLoopDispatchResults = results;
+    };
+  }
+});
+
 // src/jobIdentity.ts
 function stableJobKey(job) {
   const capability = job.workflow ?? job.capability ?? job.action;
@@ -19526,6 +19826,7 @@ var init_scripts = __esm({
     init_dispatchCapabilityFileTicks();
     init_dispatchCapabilityTicks();
     init_dispatchClassified();
+    init_dispatchAgencyLoops();
     init_dispatchNextTaskJob();
     init_ensurePr();
     init_evaluateAgencyBoundaries();
@@ -19646,6 +19947,7 @@ var init_scripts = __esm({
       diagMcp,
       warmupMcp,
       dispatchCapabilityTicks,
+      dispatchAgencyLoops,
       dispatchCapabilityFileTicks,
       planTaskJobs,
       dispatchNextTaskJob,

package/package.json

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