@kody-ade/kody-engine 0.4.333 → 0.4.334

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.333",
+      version: "0.4.334",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -18278,7 +18278,7 @@ function validateOneModel(rawModel, files, label, strictSingleModel, failures, e
       if (!docsUsed.includes(doc)) failures.push(`${label} docsUsed missing ${doc}`);
     }
     validateFilesForKind(kind, slug2, files, strictSingleModel, failures);
-    validateModelShape(kind, model, failures);
+    validateModelShape(kind, model, files, slug2, failures);
   }
 }
 function validateFilesForKind(kind, slug2, files, strictSingleModel, failures) {
@@ -18316,7 +18316,7 @@ function validateFilesForKind(kind, slug2, files, strictSingleModel, failures) {
   if (kind === "agentLoop") {
     if (!paths.some((filePath) => filePath.endsWith("/state.json")))
       failures.push("agentLoop must produce a state.json file");
-    if (strictSingleModel) rejectOtherRoots(paths, ["goals/", "loops/"], "agentLoop", failures);
+    if (strictSingleModel) rejectOtherRoots(paths, ["goals/", "loops/", "capabilities/"], "agentLoop", failures);
   }
   if (kind === "workflow") {
     requirePath(paths, `capabilities/${slug2}/profile.json`, "workflow capability profile", failures);
@@ -18344,13 +18344,18 @@ function validateFactoryAssembly(models, failures) {
     const input = model;
     const kind = stringField6(input.kind);
     if (kind === "goal") {
-      for (const capability of stringArray5(input.capabilities)) {
+      for (const capability of capabilityRefs(input)) {
         if (!available.has(`capability:${capability}`)) {
           failures.push(`goal ${stringField6(input.slug)} references missing capability ${capability}`);
         }
       }
     }
     if (kind === "workflow") {
+      for (const capability of stringArray5(input.steps)) {
+        if (!available.has(`capability:${capability}`)) {
+          failures.push(`workflow ${stringField6(input.slug)} references missing capability ${capability}`);
+        }
+      }
       for (const step of arrayObjects(input.steps)) {
         const capability = stringField6(step.capability);
         if (capability && !available.has(`capability:${capability}`)) {
@@ -18359,22 +18364,29 @@ function validateFactoryAssembly(models, failures) {
       }
     }
     if (kind === "agentLoop") {
-      const wakeTarget = input.wakeTarget;
-      if (wakeTarget && typeof wakeTarget === "object" && !Array.isArray(wakeTarget)) {
-        const target = wakeTarget;
-        const type = stringField6(target.type);
-        const slug2 = stringField6(target.slug);
-        const modelKind = type === "loop" ? "agentLoop" : type;
-        if ((modelKind === "goal" || modelKind === "workflow" || modelKind === "capability") && !available.has(`${modelKind}:${slug2}`)) {
-          failures.push(`agentLoop ${stringField6(input.slug)} references missing ${type} ${slug2}`);
+      const target = wakeTarget(input);
+      if (target) {
+        if (!available.has(`${target.kind}:${target.slug}`)) {
+          failures.push(`agentLoop ${stringField6(input.slug)} references missing ${target.kind} ${target.slug}`);
+        }
+      } else {
+        const targetSlug = stringField6(input.target);
+        const targetExists = ["goal", "workflow", "capability"].some(
+          (kindName) => available.has(`${kindName}:${targetSlug}`)
+        );
+        if (targetSlug && !targetExists) {
+          failures.push(`agentLoop ${stringField6(input.slug)} references missing target ${targetSlug}`);
         }
       }
     }
   }
 }
-function validateModelShape(kind, model, failures) {
+function validateModelShape(kind, model, files, slug2, failures) {
   if (kind === "agent") {
-    requireStringArrayIncludes(model.owns, "identity", "agent owns", failures);
+    const agentFile = textFile(files, `agents/${slug2}.md`);
+    if (!stringArray5(model.owns).includes("identity") && !containsWord(agentFile, "identity")) {
+      failures.push("agent owns must include identity");
+    }
     requireStringArrayIncludes(model.doesNotOwn, "tasks", "agent doesNotOwn", failures);
   }
   if (kind === "capability") {
@@ -18389,16 +18401,21 @@ function validateModelShape(kind, model, failures) {
     requireStringArrayIncludes(model.doesNotOwn, "goal progress", "capability doesNotOwn", failures);
   }
   if (kind === "goal") {
-    if (!stringField6(model.outcome)) failures.push("goal model must declare outcome");
-    if (!Array.isArray(model.evidence) || model.evidence.length === 0)
+    const goalState = parseJsonContent(textFile(files, `goals/templates/${slug2}/state.json`));
+    if (!stringField6(model.outcome) && !stringField6(goalState?.outcome))
+      failures.push("goal model must declare outcome");
+    if (evidenceRefs(model).length === 0 && evidenceRefs(goalState).length === 0) {
       failures.push("goal model evidence must be non-empty");
-    if (!Array.isArray(model.capabilities) || model.capabilities.length === 0) {
+    }
+    if (capabilityRefs(model).length === 0 && capabilityRefs(goalState).length === 0) {
       failures.push("goal model capabilities must be non-empty");
     }
   }
   if (kind === "agentLoop") {
     if (!stringField6(model.cadence)) failures.push("agentLoop model must declare cadence");
-    if (!model.wakeTarget || typeof model.wakeTarget !== "object" || Array.isArray(model.wakeTarget)) {
+    const loopState = parseJsonContent(firstStateFile(files, slug2));
+    const hasTarget = Boolean(wakeTarget(model)) || Boolean(stringField6(model.target)) || Boolean(wakeTarget(loopState)) || Boolean(stringField6(loopState?.target)) || Boolean(loopTargetString(loopState));
+    if (!hasTarget) {
       failures.push("agentLoop model must declare wakeTarget object");
     }
   }
@@ -18406,6 +18423,48 @@ function validateModelShape(kind, model, failures) {
     if (!Array.isArray(model.steps) || model.steps.length === 0) failures.push("workflow model steps must be non-empty");
   }
 }
+function capabilityRefs(value) {
+  return [...stringArray5(value?.capabilities), ...stringArray5(value?.allowedCapabilities)];
+}
+function evidenceRefs(value) {
+  if (!value) return [];
+  if (Array.isArray(value.evidence)) return value.evidence.map((item) => String(item).trim()).filter(Boolean);
+  if (value.evidence && typeof value.evidence === "object") return Object.keys(value.evidence);
+  return [];
+}
+function wakeTarget(value) {
+  const raw = value?.wakeTarget;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const target = raw;
+  const type = stringField6(target.type);
+  const slug2 = stringField6(target.slug);
+  if ((type === "goal" || type === "workflow" || type === "capability") && slug2) return { kind: type, slug: slug2 };
+  return null;
+}
+function loopTargetString(value) {
+  const loop = value?.loop;
+  if (!loop || typeof loop !== "object" || Array.isArray(loop)) return "";
+  return stringField6(loop.target);
+}
+function textFile(files, wantedPath) {
+  return files.find((item) => normalizeBundlePath(item.path) === wantedPath)?.content ?? "";
+}
+function firstStateFile(files, slug2) {
+  const normalizedSlug = `${slug2}/state.json`;
+  return files.find((item) => normalizeBundlePath(item.path).endsWith(normalizedSlug))?.content ?? "";
+}
+function parseJsonContent(content) {
+  if (!content.trim()) return null;
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function containsWord(content, word) {
+  return new RegExp(`\\b${word}\\b`, "i").test(content);
+}
 function parseJsonFile(files, wantedPath, failures) {
   const file = files.find((item) => normalizeBundlePath(item.path) === wantedPath);
   if (!file) return null;

package/dist/executables/agent-factory/prompt.md

@@ -51,6 +51,14 @@ Use these exact model kinds and required file shapes:
 Do not use `kind: "loop"`; the loop model kind is `agentLoop`.
 Do not use `agents/<slug>/identity.json`, `goals/<slug>/goal.json`, `workflows/<slug>/workflow.json`, or `executables/<slug>/...`.
 
+Each `models[]` entry must also carry the creator's canonical model metadata:
+
+- Agent models include `"owns": ["identity", "judgment", "boundaries"]` and `doesNotOwn` includes `"tasks"`.
+- Goal models include `"outcome"`, non-empty `"evidence"`, and non-empty `"capabilities"`. Use `"capabilities"`, not only `"allowedCapabilities"`, in `models[]`.
+- Loop models use `"kind": "agentLoop"` and include `"wakeTarget": {"type": "goal|workflow|capability", "slug": "target-slug"}`. Use `"wakeTarget"`, not only `"target"`, in `models[]`.
+- Workflow models include non-empty `"steps"` as objects with a `"capability"` slug.
+- Capability models include `"capabilityKind"`, `"ability"`, `"inputs"`, `"outputs"`, `"allowedActions"`, `"forbiddenActions"`, and `doesNotOwn` includes `"agent identity"` and `"goal progress"`.
+
 Capability files must be shaped by ability, kind, interface, and constraints. Do not include fields or prose that make the capability depend on who asked for it, which workflow calls it, which goal consumes it, which loop wakes it, or which agent may run it.
 
 Use the current Kody vocabulary:

package/package.json

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