@kody-ade/kody-engine 0.4.332 → 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.332",
+      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) {
@@ -18296,8 +18296,12 @@ function validateFilesForKind(kind, slug2, files, strictSingleModel, failures) {
     if (strictSingleModel) rejectOtherRoots(paths, [`capabilities/${slug2}/`], "capability", failures);
     const profile = parseJsonFile(files, `capabilities/${slug2}/profile.json`, failures);
     if (profile) {
+      const profileSlug = stringField6(profile.slug);
       const profileName = stringField6(profile.name);
-      if (profileName && profileName !== slug2) failures.push("capability profile name must match model.slug");
+      if (profileSlug && profileSlug !== slug2) failures.push("capability profile slug must match model.slug");
+      if (!profileSlug && profileName && profileName !== slug2) {
+        failures.push("capability profile name must match model.slug when slug is absent");
+      }
       if (profile.agent !== void 0)
         failures.push("capability profile must not set agent; agent wiring belongs outside capability creation");
       if (!["observe", "act", "verify"].includes(stringField6(profile.capabilityKind))) {
@@ -18312,13 +18316,17 @@ 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/templates/", "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);
     const profile = parseJsonFile(files, `capabilities/${slug2}/profile.json`, failures);
-    if (profile && (!profile.workflow || typeof profile.workflow !== "object")) {
-      failures.push("workflow profile must include workflow object");
+    if (profile) {
+      const hasWorkflowObject = Boolean(profile.workflow && typeof profile.workflow === "object");
+      const hasTopLevelSteps = Array.isArray(profile.steps) && profile.steps.length > 0;
+      if (!hasWorkflowObject && !hasTopLevelSteps) {
+        failures.push("workflow profile must include workflow object or top-level steps");
+      }
     }
   }
 }
@@ -18336,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}`)) {
@@ -18351,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") {
@@ -18381,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");
     }
   }
@@ -18398,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

@@ -38,6 +38,27 @@ Use these contracts when deciding whether a file belongs in the bundle:
 
 If one generated model needs information from another, reference the other model by slug. Do not copy that model's responsibility into the file.
 
+Use these exact model kinds and required file shapes:
+
+| Model kind | Required files |
+| --- | --- |
+| `agent` | `agents/<slug>.md` |
+| `goal` | `goals/templates/<slug>/state.json` |
+| `agentLoop` | a `state.json` under `goals/<slug>/` or `loops/<slug>/` |
+| `workflow` | `capabilities/<slug>/profile.json` containing a `workflow` object or top-level `steps` |
+| `capability` | `capabilities/<slug>/profile.json` and `capabilities/<slug>/capability.md` |
+
+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/dist/executables/capability-creator/prompt.md

@@ -63,6 +63,8 @@ Required files:
 - `capabilities/<slug>/profile.json`
 - `capabilities/<slug>/capability.md`
 
+In `profile.json`, include `"slug": "<slug>"`. The `"name"` field may be a display name, but if `slug` is absent then `name` must equal the slug.
+
 Add colocated prompt/scripts only if the capability needs a new implementation. Reuse existing capabilities, implementation profiles, skills, or scripts when they fit.
 
 # Final Output Contract

package/dist/executables/workflow-creator/prompt.md

@@ -50,6 +50,8 @@ Do not call Bash, Write, Edit, mkdir, cat, tee, printf, python, node, git, gh, o
 
 Prefer placing workflow steps on the public capability that owns the composed action. Do not create a workflow when a single capability is enough.
 
+Put the workflow contract in `capabilities/<slug>/profile.json`. Prefer a `workflow` object with `steps`; top-level `steps` are only for existing profiles that already use that shape.
+
 # Final Output Contract
 
 If the request is too ambiguous to produce one review-ready Workflow model, output one line:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.332",
+  "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",