@kody-ade/kody-engine 0.4.560 → 0.4.562

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.560",
+      version: "0.4.562",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -671,11 +671,22 @@ var init_format = __esm({
 
 // src/agency/capability-contract-validation.ts
 import Ajv from "ajv";
-function validateCapabilityContractValue(boundary, schema, value) {
-  const validate = validator.compile(schema);
-  if (!validate(value)) {
-    throw new CapabilityContractValidationError(boundary, validate.errors ?? []);
-  }
+function createCapabilityContractValueValidator(compile) {
+  const compiled = /* @__PURE__ */ new WeakMap();
+  return (boundary, schema, value) => {
+    let validate = compiled.get(schema);
+    if (!validate) {
+      validate = compile(schema);
+      compiled.set(schema, validate);
+    }
+    if (!validate(value)) {
+      throw new CapabilityContractValidationError(boundary, validate.errors ?? []);
+    }
+  };
+}
+function validateCapabilityContractOutput(schema, value) {
+  if (value === void 0) throw new CapabilityContractMissingOutputError();
+  validateCapabilityContractValue("output", schema, value);
 }
 function capabilityContractInput(inputs, args, capabilityId, contractProperties = []) {
   const isGenericRunnerInput = inputs.some((input) => input.name === "input") && Object.hasOwn(args, "input");
@@ -693,7 +704,7 @@ function capabilityContractInput(inputs, args, capabilityId, contractProperties
     return value;
   }
 }
-var validator, CapabilityContractValidationError;
+var validator, CapabilityContractValidationError, CapabilityContractMissingOutputError, validateCapabilityContractValue;
 var init_capability_contract_validation = __esm({
   "src/agency/capability-contract-validation.ts"() {
     "use strict";
@@ -717,6 +728,15 @@ var init_capability_contract_validation = __esm({
       boundary;
       errors;
     };
+    CapabilityContractMissingOutputError = class extends Error {
+      constructor() {
+        super("Capability output is missing despite its declared contract");
+        this.name = "CapabilityContractMissingOutputError";
+      }
+    };
+    validateCapabilityContractValue = createCapabilityContractValueValidator(
+      (schema) => validator.compile(schema)
+    );
   }
 });
 
@@ -731,7 +751,7 @@ function outputContractError(contract) {
     return `The required output file is missing or is not valid JSON: ${error instanceof Error ? error.message : String(error)}`;
   }
   try {
-    validateCapabilityContractValue("output", contract.schema, value);
+    validateCapabilityContractOutput(contract.schema, value);
     return null;
   } catch (error) {
     return error instanceof Error ? error.message : String(error);
@@ -2012,20 +2032,52 @@ function listCapabilityFolderSlugs(absDir) {
   return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).filter((e) => isCapabilityFolder(path8.join(absDir, e.name))).map((e) => e.name).sort();
 }
 function isCapabilityFolder(dir) {
-  if (!fs7.existsSync(path8.join(dir, CAPABILITY_BODY_FILE))) return false;
   const entries = fs7.readdirSync(dir, { withFileTypes: true });
+  const legacyBody = path8.join(dir, CAPABILITY_BODY_FILE);
+  if (fs7.existsSync(legacyBody)) {
+    return entries.every(
+      (entry) => entry.name === CAPABILITY_BODY_FILE || entry.name === CAPABILITY_CONTRACT_FILE || entry.isDirectory() && (entry.name === "skills" || entry.name === "tools")
+    );
+  }
+  const canonicalBody = path8.join(dir, CANONICAL_CAPABILITY_BODY_FILE);
+  const canonicalDefinition = path8.join(dir, CANONICAL_CAPABILITY_DEFINITION_FILE);
+  if (!fs7.existsSync(canonicalBody) || !fs7.existsSync(canonicalDefinition)) return false;
   return entries.every(
-    (entry) => entry.name === CAPABILITY_BODY_FILE || entry.name === CAPABILITY_CONTRACT_FILE || entry.isDirectory() && (entry.name === "skills" || entry.name === "tools")
+    (entry) => entry.name === CANONICAL_CAPABILITY_BODY_FILE || entry.name === CANONICAL_CAPABILITY_DEFINITION_FILE
   );
 }
 function readCapabilityFolder(root, slug) {
   const dir = path8.join(root, slug);
-  const bodyPath = path8.join(dir, CAPABILITY_BODY_FILE);
+  const legacyBodyPath = path8.join(dir, CAPABILITY_BODY_FILE);
+  const canonicalBodyPath = path8.join(dir, CANONICAL_CAPABILITY_BODY_FILE);
+  const bodyPath = fs7.existsSync(legacyBodyPath) ? legacyBodyPath : canonicalBodyPath;
   const contractPath = path8.join(dir, CAPABILITY_CONTRACT_FILE);
   if (!fs7.existsSync(bodyPath) || !fs7.statSync(bodyPath).isFile()) return null;
   if (!isCapabilityFolder(dir)) return null;
   try {
     const rawBody = fs7.readFileSync(bodyPath, "utf-8");
+    if (bodyPath === canonicalBodyPath) {
+      const definitionPath = path8.join(dir, CANONICAL_CAPABILITY_DEFINITION_FILE);
+      const definition = JSON.parse(fs7.readFileSync(definitionPath, "utf-8"));
+      if (definition.id !== slug || typeof definition.action !== "string") return null;
+      const { title: title2, body: body2 } = parseCapabilityBody(rawBody, slug);
+      return {
+        slug,
+        dir,
+        profilePath: definitionPath,
+        bodyPath,
+        title: title2,
+        body: body2,
+        rawBody,
+        config: {
+          action: definition.action,
+          describe: typeof definition.purpose === "string" ? definition.purpose : title2,
+          ...isPlainObject(definition.inputSchema) ? { inputSchema: definition.inputSchema } : {},
+          ...isPlainObject(definition.outputSchema) ? { outputSchema: definition.outputSchema } : {}
+        },
+        rawProfile: definition
+      };
+    }
     const contract = fs7.existsSync(contractPath) ? parseCapabilityContract(fs7.readFileSync(contractPath, "utf-8")) : void 0;
     if (contract?.execution === "script" && !isRegularFile(path8.join(dir, "tools", "run.sh"))) {
       throw new Error('script-backed Capability requires a regular "tools/run.sh" file');
@@ -2301,13 +2353,15 @@ function isSafeSlug(value) {
 function isSafeStepId(value) {
   return /^[A-Za-z][A-Za-z0-9_-]*$/.test(value) && !value.includes("..");
 }
-var CAPABILITY_BODY_FILE, CAPABILITY_CONTRACT_FILE, CAPABILITY_PROFILE_FILE;
+var CAPABILITY_BODY_FILE, CAPABILITY_CONTRACT_FILE, CAPABILITY_PROFILE_FILE, CANONICAL_CAPABILITY_BODY_FILE, CANONICAL_CAPABILITY_DEFINITION_FILE;
 var init_capabilityFolders = __esm({
   "src/capabilityFolders.ts"() {
     "use strict";
     CAPABILITY_BODY_FILE = "instructions.md";
     CAPABILITY_CONTRACT_FILE = "contract.json";
     CAPABILITY_PROFILE_FILE = CAPABILITY_BODY_FILE;
+    CANONICAL_CAPABILITY_BODY_FILE = "capability.md";
+    CANONICAL_CAPABILITY_DEFINITION_FILE = "definition.json";
   }
 });
 
@@ -2498,6 +2552,7 @@ function resolveCapabilityFolder(slug, projectCapabilitiesRoot = getProjectCapab
 function getCapabilityActionInputs(action, projectCapabilitiesRoot = getProjectCapabilitiesRoot()) {
   const resolved = resolveCapabilityAction(action, projectCapabilitiesRoot);
   if (!resolved) return null;
+  if (resolved.source === "builtin") return getProfileInputs(resolved.implementation);
   const capability = resolveCapabilityFolder(resolved.capability, projectCapabilitiesRoot);
   if (capability && !capability.config.workflow) {
     return [
@@ -17251,7 +17306,7 @@ var init_parseSimpleCapabilityOutput = __esm({
       const outputSchema = isObject2(ctx.data.capabilityOutputSchema) ? ctx.data.capabilityOutputSchema : void 0;
       if (outputSchema) {
         try {
-          validateCapabilityContractValue("output", outputSchema, output);
+          validateCapabilityContractOutput(outputSchema, output);
         } catch (error) {
           const reason2 = error instanceof Error ? error.message : String(error);
           ctx.output.exitCode = 64;
@@ -22221,8 +22276,7 @@ async function runImplementation(profileName, input) {
     const capabilityResults = Array.isArray(ctx.data.capabilityResults) ? ctx.data.capabilityResults : void 0;
     if (profile.canonicalContract) {
       try {
-        validateCapabilityContractValue(
-          "output",
+        validateCapabilityContractOutput(
           profile.canonicalContract.outputSchema,
           capabilityResults?.at(-1) ?? {
             exitCode: ctx.output.exitCode ?? 0,
@@ -23192,7 +23246,35 @@ async function runCapabilityImplementationStep(valid, profileName, capabilityIde
     input.cliArgs = simpleCapabilityRuntimeArgs(simpleCapabilityRuntime, capabilityIdentity, capabilityInput);
   }
   const run = base.chain === false ? runImplementation : runImplementationChain;
-  return run(profileName, input);
+  const result = await run(profileName, input);
+  return enforceCapabilityOutputContract(capabilityContext, result);
+}
+function enforceCapabilityOutputContract(capability, result) {
+  const schema = capability?.config.outputSchema;
+  if (result.exitCode !== 0 || !schema) {
+    return result;
+  }
+  try {
+    validateCapabilityContractOutput(schema, result.capabilityOutput);
+    return result;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const blocked = {
+      version: 1,
+      status: "blocked",
+      summary: reason,
+      facts: {},
+      artifacts: [],
+      missingEvidence: [],
+      blockers: [reason]
+    };
+    return {
+      ...result,
+      exitCode: 64,
+      reason,
+      capabilityResults: [blocked]
+    };
+  }
 }
 function shouldRunCapabilityWorkflow(job, workflow, capabilityIdentity, selectedImplementation, base) {
   if (workflow.steps.length === 0) return false;
@@ -23909,6 +23991,7 @@ var DEFAULT_INSTANT_AGENT, localJobSeq, InvalidJobError;
 var init_job = __esm({
   "src/job.ts"() {
     "use strict";
+    init_capability_contract_validation();
     init_agencyBoundaryEval();
     init_capabilityFolders();
     init_config();

package/package.json

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