@kody-ade/kody-engine 0.4.413 → 0.4.415

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.413",
+      version: "0.4.415",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -50,9 +50,9 @@ var init_package = __esm({
         prepublishOnly: "pnpm typecheck && vitest run tests/unit tests/int --no-coverage && pnpm build && pnpm verify:package"
       },
       dependencies: {
-        "@kody-ade/agency-domain": "0.1.1",
         "@actions/cache": "^6.0.0",
         "@anthropic-ai/claude-agent-sdk": "0.2.119",
+        "@kody-ade/agency-domain": "0.4.0",
         "@modelcontextprotocol/sdk": "^1.29.0",
         convex: "^1.17.0",
         zod: "^4.0.0"
@@ -1990,14 +1990,14 @@ function resolveImplementationCandidates(name, roots = getImplementationRoots())
 function listCapabilityActions(projectCapabilitiesRoot = getProjectCapabilitiesRoot()) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  const add = (action) => {
+  const add2 = (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")) add(action);
-  for (const action of listBuiltinCapabilityActions(getBuiltinCapabilitiesRoot())) add(action);
+  for (const action of listFolderCapabilityActions(projectCapabilitiesRoot, "project-folder")) add2(action);
+  for (const action of listBuiltinCapabilityActions(getBuiltinCapabilitiesRoot())) add2(action);
   return out.sort((a, b) => a.action.localeCompare(b.action));
 }
 function resolveCapabilityAction(action, projectCapabilitiesRoot = getProjectCapabilitiesRoot()) {
@@ -2505,6 +2505,22 @@ function createStateBackendFromEnv(env = process.env, client) {
         ...runId ? { runId: requireNonEmpty(runId, "runId") } : {}
       });
     },
+    async createAgencyModelRun(tenantId2, subjectType, subjectId, run, now) {
+      await transport.mutation(anyApi.agencyModel.createRunRecord, {
+        tenantId: requireTenant(tenantId2),
+        subjectType,
+        subjectId: requireNonEmpty(subjectId, "subjectId"),
+        run,
+        now
+      });
+    },
+    async finishAgencyModelRun(tenantId2, run, now) {
+      await transport.mutation(anyApi.agencyModel.finishRunRecord, {
+        tenantId: requireTenant(tenantId2),
+        run,
+        now
+      });
+    },
     async appendRunEvent(tenantId2, runId, goalId, event, time) {
       await transport.mutation(anyApi.runEvents.append, {
         tenantId: requireTenant(tenantId2),
@@ -12969,6 +12985,7 @@ var init_dispatchClassified = __esm({
 
 // src/goal/agencyModelRepository.ts
 import {
+  createAgentDefinition,
   createCapabilityDefinition,
   createGoalDefinition,
   createGoalState,
@@ -12977,7 +12994,8 @@ import {
   createLoopState,
   createOperationDefinition,
   createRunOutput,
-  createWorkflowDefinition
+  createWorkflowDefinition,
+  relationshipIssues
 } from "@kody-ade/agency-domain";
 function goalProgressFromOutputs(definition, outputs) {
   const required2 = definition.objective.requiredEvidence;
@@ -12987,28 +13005,65 @@ function goalProgressFromOutputs(definition, outputs) {
   );
   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) {
+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 !== definition.kind || document.definitionId !== definition.recordId) {
-    throw new Error(`Agency State does not match Definition: ${definition.recordId}`);
+  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;
+  if (mutable.has(definition.id)) throw new Error(`Duplicate Agency Definition: ${definition.id}`);
+  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"() {
@@ -13020,19 +13075,31 @@ var init_agencyModelRepository = __esm({
       }
       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"
-        );
+      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 (document) => ({
-            definition: parseManagedDefinition(document),
-            state: parseState(await this.backend.getAgencyState(this.tenantId, document.recordId), document)
+          managed.map(async (record2) => ({
+            definition: record2.definition,
+            revision: record2.revision,
+            state: parseState(
+              await this.backend.getAgencyState(this.tenantId, record2.definition.id),
+              record2.definition,
+              record2.kind
+            )
           }))
         );
       }
+      async loadCatalog() {
+        const documents = await this.backend.listAgencyDefinitions(this.tenantId);
+        const catalog = emptyCatalog();
+        for (const document of documents) 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);
@@ -13117,13 +13184,105 @@ var init_triggerDispatcher = __esm({
   }
 });
 
+// src/goal/policyResolver.ts
+import { createHash as createHash2 } 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);
+  assertAuthorized(policy, constraints, input.target, input.approved === true);
+  const snapshotValue = { policy, constraints };
+  return {
+    snapshot: {
+      hash: createHash2("sha256").update(stableJson(snapshotValue)).digest("hex"),
+      ...snapshotValue
+    },
+    operation,
+    intents,
+    trace: [
+      pinned("trigger" in input.owner.definition ? "loop" : "goal", input.owner),
+      input.target
+    ]
+  };
+}
+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, approved) {
+  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");
+  if (requiresApproval && !approved) throw new Error(`Dispatch blocked: approval is required for "${action}"`);
+}
+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/scripts/dispatchAgencyLoops.ts
-import { createLoopState as createLoopState2 } from "@kody-ade/agency-domain";
+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 records = await repository.listManagedWork();
-  const loops = records.filter(
-    (record2) => "trigger" in record2.definition
+  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) {
@@ -13142,6 +13301,27 @@ async function dispatchAgencyLoopsWith(input) {
       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 leaseUntil = new Date(input.now.getTime() + 15 * 6e4).toISOString();
     const reservation = await input.backend.reserveAgencyDispatch(
       input.tenantId,
@@ -13164,14 +13344,40 @@ 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 {
-      const output = await input.run(jobForTarget(record2.definition));
+      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;
+      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",
-        (/* @__PURE__ */ new Date()).toISOString()
+        finishedAt,
+        runId
       );
       await repository.saveState(
         createLoopState2({
@@ -13190,26 +13396,34 @@ async function dispatchAgencyLoopsWith(input) {
       });
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
-      await input.backend.finishAgencyDispatch(input.tenantId, decision.idempotencyKey, "failed", (/* @__PURE__ */ new Date()).toISOString());
+      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);
       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" };
-  }
+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 {
-    capability: "goal-manager",
-    implementation: "goal-manager",
-    cliArgs: { goal: loop.targetRef.id },
-    flavor: "scheduled"
+    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) {
+  return createRun({ ...active, status, finishedAt });
+}
 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();
@@ -13221,6 +13435,7 @@ var init_dispatchAgencyLoops = __esm({
     "use strict";
     init_agencyModelRepository();
     init_triggerDispatcher();
+    init_policyResolver();
     init_job();
     init_state_backend();
     dispatchAgencyLoops = async (ctx) => {
@@ -15079,9 +15294,9 @@ var init_kodyVariables = __esm({
 });
 
 // src/backendVault.ts
-import { createDecipheriv, createHash as createHash2 } from "crypto";
+import { createDecipheriv, createHash as createHash3 } from "crypto";
 function cacheKey(owner, repo, masterKey) {
-  const keyHash = createHash2("sha256").update(masterKey).digest("hex").slice(0, 16);
+  const keyHash = createHash3("sha256").update(masterKey).digest("hex").slice(0, 16);
   return `${owner}/${repo}:${keyHash}`.toLowerCase();
 }
 function decryptVault(payload, masterKey) {
@@ -15730,7 +15945,7 @@ var init_notifyTerminal = __esm({
 });
 
 // src/scripts/openAgencyModelReviewPr.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function parseAgencyModelProposal(raw) {
   const text2 = raw.trim();
   const jsonText = (text2.match(/^```(?:json)?\s*\n([\s\S]*?)\n```$/i)?.[1] ?? text2).trim();
@@ -15782,7 +15997,7 @@ function normalizeBundleFiles(bundle) {
   });
 }
 function buildProposalId(issueNumber, bundle, sourceLabel) {
-  const digest = createHash3("sha256").update(JSON.stringify({ issueNumber, sourceLabel, title: bundle.title, files: normalizeBundleFiles(bundle) })).digest("hex").slice(0, 16);
+  const digest = createHash4("sha256").update(JSON.stringify({ issueNumber, sourceLabel, title: bundle.title, files: normalizeBundleFiles(bundle) })).digest("hex").slice(0, 16);
   return `issue-${issueNumber}-${digest}`;
 }
 function isDryRun(ctx) {
@@ -17854,9 +18069,9 @@ var init_runFlow = __esm({
 });
 
 // src/scripts/previewBuildHelpers.ts
-import { createDecipheriv as createDecipheriv2, createHash as createHash4, hkdfSync as hkdfSync2 } from "crypto";
+import { createDecipheriv as createDecipheriv2, createHash as createHash5, hkdfSync as hkdfSync2 } from "crypto";
 function shortHash(s) {
-  return createHash4("sha256").update(s).digest("hex").slice(0, 6);
+  return createHash5("sha256").update(s).digest("hex").slice(0, 6);
 }
 function previewAppName(repo, pr) {
   const [owner, name] = repo.split("/");
@@ -17889,7 +18104,7 @@ function formatPreviewComment(args) {
   ].join("\n");
 }
 function defaultImageTag(repo, ref) {
-  return createHash4("sha256").update(`${repo}@${ref}`).digest("hex").slice(0, 12);
+  return createHash5("sha256").update(`${repo}@${ref}`).digest("hex").slice(0, 12);
 }
 var init_previewBuildHelpers = __esm({
   "src/scripts/previewBuildHelpers.ts"() {
@@ -25314,7 +25529,7 @@ init_config();
 init_fetchRepoMcp();
 
 // src/servers/mcpHttpServer.ts
-import { randomUUID } 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";
@@ -25323,7 +25538,7 @@ function buildMcpHttpServer(opts) {
   const transports = /* @__PURE__ */ new Map();
   for (const route of opts.routes) {
     const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID()
+      sessionIdGenerator: () => randomUUID2()
     });
     transports.set(route.path, transport);
     routes.set(route.path, route.name);
@@ -25895,7 +26110,7 @@ init_config();
 
 // src/definition-hydration.ts
 init_state_backend();
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import * as fs50 from "fs";
 import * as path51 from "path";
 var SLUG_RE2 = /^[a-z0-9][a-z0-9_-]{0,63}$/;
@@ -25916,7 +26131,7 @@ function normalizeDefinitionBundle(bundle) {
   return { schemaVersion: 1, files };
 }
 function definitionVersion(bundle) {
-  return `sha256:${createHash5("sha256").update(JSON.stringify(normalizeDefinitionBundle(bundle))).digest("hex")}`;
+  return `sha256:${createHash6("sha256").update(JSON.stringify(normalizeDefinitionBundle(bundle))).digest("hex")}`;
 }
 function verifyDefinition(definition) {
   if (!SLUG_RE2.test(definition.slug)) throw new Error(`invalid definition slug: ${definition.slug}`);
@@ -26017,12 +26232,12 @@ import { createServer as createServer5 } from "http";
 
 // src/pool/agency-loop-tick.ts
 function normalizeRepositories(repositories) {
-  const unique = /* @__PURE__ */ new Set();
+  const unique2 = /* @__PURE__ */ new Set();
   for (const raw of repositories) {
     const repo = raw.trim().toLowerCase();
-    if (/^[^/\s]+\/[^/\s]+$/.test(repo)) unique.add(repo);
+    if (/^[^/\s]+\/[^/\s]+$/.test(repo)) unique2.add(repo);
   }
-  return [...unique].sort();
+  return [...unique2].sort();
 }
 async function runAgencyLoopTick(deps) {
   const repositories = normalizeRepositories(await deps.discover());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.413",
+  "version": "0.4.415",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
   "license": "MIT",
   "type": "module",
@@ -35,9 +35,9 @@
     "prepublishOnly": "pnpm typecheck && vitest run tests/unit tests/int --no-coverage && pnpm build && pnpm verify:package"
   },
   "dependencies": {
-    "@kody-ade/agency-domain": "0.1.1",
     "@actions/cache": "^6.0.0",
     "@anthropic-ai/claude-agent-sdk": "0.2.119",
+    "@kody-ade/agency-domain": "0.4.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "convex": "^1.17.0",
     "zod": "^4.0.0"