@kody-ade/kody-engine 0.4.415 → 0.4.417

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.415",
+      version: "0.4.417",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -52,7 +52,7 @@ var init_package = __esm({
       dependencies: {
         "@actions/cache": "^6.0.0",
         "@anthropic-ai/claude-agent-sdk": "0.2.119",
-        "@kody-ade/agency-domain": "0.4.0",
+        "@kody-ade/agency-domain": "0.5.0",
         "@modelcontextprotocol/sdk": "^1.29.0",
         convex: "^1.17.0",
         zod: "^4.0.0"
@@ -2476,14 +2476,15 @@ function createStateBackendFromEnv(env = process.env, client) {
       });
       return Array.isArray(result) ? result : [];
     },
-    async reserveAgencyDispatch(tenantId2, idempotencyKey, loopId, decision, leaseUntil, now) {
+    async reserveAgencyDispatch(tenantId2, reservation) {
       const result = await transport.mutation(anyApi.agencyModel.reserveDispatch, {
         tenantId: requireTenant(tenantId2),
-        idempotencyKey: requireNonEmpty(idempotencyKey, "idempotencyKey"),
-        loopId: requireNonEmpty(loopId, "loopId"),
-        decision,
-        leaseUntil,
-        now
+        ...reservation,
+        idempotencyKey: requireNonEmpty(reservation.idempotencyKey, "idempotencyKey"),
+        loopId: requireNonEmpty(reservation.loopId, "loopId"),
+        reservationId: requireNonEmpty(reservation.reservationId, "reservationId"),
+        correlationId: requireNonEmpty(reservation.correlationId, "correlationId"),
+        policyHash: requireNonEmpty(reservation.policyHash, "policyHash")
       });
       return result;
     },
@@ -2496,10 +2497,11 @@ function createStateBackendFromEnv(env = process.env, client) {
         now
       });
     },
-    async finishAgencyDispatch(tenantId2, idempotencyKey, status, now, runId) {
+    async finishAgencyDispatch(tenantId2, idempotencyKey, reservationId, status, now, runId) {
       await transport.mutation(anyApi.agencyModel.finishDispatch, {
         tenantId: requireTenant(tenantId2),
         idempotencyKey: requireNonEmpty(idempotencyKey, "idempotencyKey"),
+        reservationId: requireNonEmpty(reservationId, "reservationId"),
         status,
         now,
         ...runId ? { runId: requireNonEmpty(runId, "runId") } : {}
@@ -3413,6 +3415,7 @@ async function runAgent(opts) {
   let outcomeKind = "generic_failed";
   let errorMessage2;
   let tokens = { input: 0, output: 0, cacheRead: 0, cacheCreate: 0 };
+  let costUsd = 0;
   let messageCount = 0;
   let finalText = "";
   let getSubmitted;
@@ -3429,6 +3432,7 @@ async function runAgent(opts) {
     outcomeKind = "generic_failed";
     errorMessage2 = void 0;
     tokens = { input: 0, output: 0, cacheRead: 0, cacheCreate: 0 };
+    costUsd = 0;
     messageCount = 0;
     let sawMutatingTool = false;
     let sawTerminalSuccess = false;
@@ -3553,6 +3557,7 @@ async function runAgent(opts) {
         };
       }
       queryOptions.settingSources = opts.settingSources ?? ["project", "local"];
+      if (opts.abortController) queryOptions.abortController = opts.abortController;
       const stableBinary = ensureStableClaudeBinary();
       if (stableBinary) {
         const sdkBinaryPathOption = ["pathToClaudeCode", "Exec", "utable"].join("");
@@ -3681,6 +3686,8 @@ async function runAgent(opts) {
           }
         }
         if (m.type === "result") {
+          const reportedCost = Number(m.total_cost_usd ?? 0);
+          if (Number.isFinite(reportedCost) && reportedCost >= 0) costUsd = reportedCost;
           if (m.subtype === "success") {
             outcome = "completed";
             outcomeKind = "ok";
@@ -3758,6 +3765,7 @@ async function runAgent(opts) {
     ndjsonPath,
     durationMs: Date.now() - startedAt,
     tokens,
+    costUsd,
     messageCount
   };
 }
@@ -13036,7 +13044,6 @@ function addDefinition(catalog, document) {
 }
 function add(collection, definition, revision) {
   const mutable = collection;
-  if (mutable.has(definition.id)) throw new Error(`Duplicate Agency Definition: ${definition.id}`);
   mutable.set(definition.id, { definition, revision });
 }
 function validateRelationships(catalog) {
@@ -13096,7 +13103,10 @@ var init_agencyModelRepository = __esm({
       async loadCatalog() {
         const documents = await this.backend.listAgencyDefinitions(this.tenantId);
         const catalog = emptyCatalog();
-        for (const document of documents) addDefinition(catalog, document);
+        const ordered = [...documents].sort(
+          (left, right) => left.createdAt.localeCompare(right.createdAt) || left.recordId.localeCompare(right.recordId)
+        );
+        for (const document of ordered) addDefinition(catalog, document);
         validateRelationships(catalog);
         return catalog;
       }
@@ -13199,7 +13209,7 @@ function resolveDispatchPolicy(input) {
   });
   const policy = mergePolicies(intents.map(({ definition }) => definition.policy));
   const constraints = intents.flatMap(({ definition }) => definition.constraints);
-  assertAuthorized(policy, constraints, input.target, input.approved === true);
+  const requiresApproval = assertAuthorized(policy, constraints, input.target);
   const snapshotValue = { policy, constraints };
   return {
     snapshot: {
@@ -13211,7 +13221,8 @@ function resolveDispatchPolicy(input) {
     trace: [
       pinned("trigger" in input.owner.definition ? "loop" : "goal", input.owner),
       input.target
-    ]
+    ],
+    requiresApproval
   };
 }
 function mergePolicies(policies) {
@@ -13235,7 +13246,7 @@ function mergePolicies(policies) {
     riskyActions: unique(policies.flatMap(({ riskyActions }) => riskyActions))
   };
 }
-function assertAuthorized(policy, constraints, target, approved) {
+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}"`);
@@ -13244,7 +13255,7 @@ function assertAuthorized(policy, constraints, target, approved) {
   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");
-  if (requiresApproval && !approved) throw new Error(`Dispatch blocked: approval is required for "${action}"`);
+  return requiresApproval;
 }
 function pinned(kind, record2) {
   return { kind, id: record2.definition.id, revision: record2.revision };
@@ -13322,17 +13333,47 @@ async function dispatchAgencyLoopsWith(input) {
       results.push({ loopId: record2.definition.id, decision: "skipped", 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,
+    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) {
-      results.push({ loopId: record2.definition.id, decision: "duplicate", reason: "trigger firing already reserved" });
+      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({
@@ -13344,40 +13385,82 @@ async function dispatchAgencyLoopsWith(input) {
       updatedAt: now
     });
     await repository.saveState(runningState, "loop", now);
-    const runId = `run-${randomUUID()}`;
-    const correlationId = `corr-${randomUUID()}`;
-    const activeRun = createRun({
-      id: runId,
-      status: "running",
-      origin: { kind: "loop", id: record2.definition.id, revision: record2.revision },
-      target: target.reference,
-      trace: [policy.trace[0], ...target.intermediate, target.reference],
-      effectivePolicy: policy.snapshot,
-      correlationId,
-      startedAt: now
-    });
     try {
-      await input.backend.createAgencyModelRun(
-        input.tenantId,
-        target.reference.kind,
-        target.reference.id,
-        activeRun,
-        now
-      );
-      const output = await input.run(target.job);
-      const succeeded = output.exitCode === 0;
+      let attempts = 0;
+      let tokens = 0;
+      let costUsd = 0;
+      let succeeded = false;
+      let reason = "target failed";
+      let finalRunId;
+      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;
+        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();
-      await input.backend.finishAgencyModelRun(
-        input.tenantId,
-        terminalRun(activeRun, succeeded ? "succeeded" : "failed", finishedAt),
-        finishedAt
-      );
       await input.backend.finishAgencyDispatch(
         input.tenantId,
         decision.idempotencyKey,
-        succeeded ? "dispatched" : "failed",
+        reservationId,
+        succeeded ? "dispatched" : "dead-letter",
         finishedAt,
-        runId
+        finalRunId
       );
       await repository.saveState(
         createLoopState2({
@@ -13392,13 +13475,18 @@ async function dispatchAgencyLoopsWith(input) {
       results.push({
         loopId: record2.definition.id,
         decision: succeeded ? "dispatched" : "failed",
-        reason: output.reason ?? (succeeded ? "target dispatched" : "target 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.finishAgencyModelRun(input.tenantId, terminalRun(activeRun, "failed", finishedAt), finishedAt).catch(() => void 0);
-      await input.backend.finishAgencyDispatch(input.tenantId, decision.idempotencyKey, "failed", finishedAt, runId);
+      await input.backend.finishAgencyDispatch(
+        input.tenantId,
+        decision.idempotencyKey,
+        reservationId,
+        "dead-letter",
+        finishedAt
+      );
       results.push({ loopId: record2.definition.id, decision: "failed", reason });
     }
   }
@@ -13421,8 +13509,32 @@ function resolveTarget(loop, catalog) {
     job: target.kind === "workflow" ? { workflow: target.id, cliArgs: {}, flavor: "scheduled" } : { capability: target.id, cliArgs: {}, flavor: "scheduled" }
   };
 }
-function terminalRun(active, status, finishedAt) {
-  return createRun({ ...active, status, finishedAt });
+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),
+      new Promise((resolve17) => {
+        timer = setTimeout(() => {
+          abortController.abort();
+          resolve17({ exitCode: 124, reason: `target timed out after ${formatSeconds(timeoutSeconds)}s` });
+        }, timeoutSeconds * 1e3);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+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((resolve17) => setTimeout(resolve17, milliseconds));
 }
 function repositoryTenant(config) {
   const owner = config.github?.owner?.trim() || process.env.GITHUB_REPOSITORY?.split("/")[0]?.trim();
@@ -13446,7 +13558,14 @@ var init_dispatchAgencyLoops = __esm({
         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 })
+        run: (job, abortController) => runJob(job, {
+          cwd: ctx.cwd,
+          config: ctx.config,
+          verbose: ctx.verbose,
+          quiet: ctx.quiet,
+          chain: false,
+          abortController
+        })
       });
       ctx.data.agencyLoopDispatchResults = results;
     };
@@ -20658,6 +20777,7 @@ async function runImplementation(profileName, input) {
       isBackendHealthy: lm ? () => lm.isHealthy() : void 0,
       verbose: input.verbose,
       quiet: input.quiet,
+      abortController: input.abortController,
       ndjsonDir,
       additionalDirectories: agentTaskArtifacts ? [agentTaskArtifacts.absDir] : void 0,
       allowedToolsOverride: profile.claudeCode.tools,
@@ -20767,6 +20887,10 @@ async function runImplementation(profileName, input) {
           reason: err instanceof Error ? err.message : String(err)
         });
       }
+      ctx.output.usage = {
+        tokens: agentResult.tokens ? agentResult.tokens.input + agentResult.tokens.output + agentResult.tokens.cacheRead + agentResult.tokens.cacheCreate : 0,
+        costUsd: agentResult.costUsd ?? 0
+      };
       emitEvent(input.cwd, {
         implementation: profileName,
         kind: "agent_end",
@@ -21609,6 +21733,7 @@ async function runCapabilityImplementationStep(valid, profileName, capabilityIde
     skipConfig: base.skipConfig,
     verbose: base.verbose,
     quiet: base.quiet,
+    abortController: base.abortController,
     preloadedData: Object.keys(preloadedData).length > 0 ? preloadedData : void 0
   };
   const shouldApplyResolvedCapabilityArgs = valid.implementation === void 0 && resolvedCapability && profileName === resolvedCapability.implementation;

package/dist/implementations/types.ts

@@ -453,6 +453,7 @@ export interface Context {
     exitCode: number
     prUrl?: string
     reason?: string
+    usage?: { tokens: number; costUsd: number }
     /**
      * In-process hand-off to the next stage. A stage (e.g. `classify`) sets
      * this so the orchestrator runs the chosen sub-orchestrator

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.415",
+  "version": "0.4.417",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
   "license": "MIT",
   "type": "module",
@@ -12,32 +12,10 @@
     "templates",
     "kody.config.schema.json"
   ],
-  "scripts": {
-    "kody:run": "tsx bin/kody.ts",
-    "serve": "tsx bin/kody.ts serve",
-    "serve:vscode": "tsx bin/kody.ts serve vscode",
-    "serve:claude": "tsx bin/kody.ts serve claude",
-    "clean:dist": "node scripts/clean-dist.cjs",
-    "build": "pnpm clean:dist && tsup && node scripts/copy-assets.cjs",
-    "check:modularity": "tsx scripts/check-script-modularity.ts",
-    "pretest": "pnpm check:modularity",
-    "test": "vitest run tests/unit tests/int --coverage",
-    "posttest": "tsx scripts/check-coverage-floor.ts",
-    "test:smoke": "vitest run tests/smoke --no-coverage",
-    "test:e2e": "vitest run tests/e2e --no-coverage",
-    "test:all": "vitest run tests --no-coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "biome check",
-    "lint:fix": "biome check --write",
-    "format": "biome format --write",
-    "verify:package": "node scripts/verify-package-tarball.cjs",
-    "brain:publish": "docker buildx build --platform linux/amd64 -f runner/Dockerfile.brain -t ghcr.io/${KODY_BRAIN_GHCR_OWNER:-aharonyaircohen}/kody-brain:latest --push runner",
-    "prepublishOnly": "pnpm typecheck && vitest run tests/unit tests/int --no-coverage && pnpm build && pnpm verify:package"
-  },
   "dependencies": {
     "@actions/cache": "^6.0.0",
     "@anthropic-ai/claude-agent-sdk": "0.2.119",
-    "@kody-ade/agency-domain": "0.4.0",
+    "@kody-ade/agency-domain": "0.5.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "convex": "^1.17.0",
     "zod": "^4.0.0"
@@ -59,5 +37,26 @@
     "url": "git+https://github.com/aharonyaircohen/kody-engine.git"
   },
   "homepage": "https://github.com/aharonyaircohen/kody-engine",
-  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues"
-}
+  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues",
+  "scripts": {
+    "kody:run": "tsx bin/kody.ts",
+    "serve": "tsx bin/kody.ts serve",
+    "serve:vscode": "tsx bin/kody.ts serve vscode",
+    "serve:claude": "tsx bin/kody.ts serve claude",
+    "clean:dist": "node scripts/clean-dist.cjs",
+    "build": "pnpm clean:dist && tsup && node scripts/copy-assets.cjs",
+    "check:modularity": "tsx scripts/check-script-modularity.ts",
+    "pretest": "pnpm check:modularity",
+    "test": "vitest run tests/unit tests/int --coverage",
+    "posttest": "tsx scripts/check-coverage-floor.ts",
+    "test:smoke": "vitest run tests/smoke --no-coverage",
+    "test:e2e": "vitest run tests/e2e --no-coverage",
+    "test:all": "vitest run tests --no-coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "format": "biome format --write",
+    "verify:package": "node scripts/verify-package-tarball.cjs",
+    "brain:publish": "docker buildx build --platform linux/amd64 -f runner/Dockerfile.brain -t ghcr.io/${KODY_BRAIN_GHCR_OWNER:-aharonyaircohen}/kody-brain:latest --push runner"
+  }
+}