@kody-ade/kody-engine 0.4.442 → 0.4.444

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.442",
+      version: "0.4.444",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -1681,62 +1681,38 @@ function listCapabilityFolderSlugs(absDir) {
   return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).filter((e) => isCapabilityFolder(path5.join(absDir, e.name))).map((e) => e.name).sort();
 }
 function isCapabilityFolder(dir) {
-  if (!fs4.existsSync(path5.join(dir, CAPABILITY_DEFINITION_FILE))) return false;
   if (!fs4.existsSync(path5.join(dir, CAPABILITY_BODY_FILE))) return false;
   const entries = fs4.readdirSync(dir, { withFileTypes: true });
   return entries.every(
-    (entry) => entry.name === CAPABILITY_DEFINITION_FILE || entry.name === CAPABILITY_BODY_FILE || entry.isDirectory() && (entry.name === "skills" || entry.name === "tools")
+    (entry) => entry.name === CAPABILITY_BODY_FILE || entry.isDirectory() && (entry.name === "skills" || entry.name === "tools")
   );
 }
 function readCapabilityFolder(root, slug) {
   const dir = path5.join(root, slug);
-  const definitionPath = path5.join(dir, CAPABILITY_DEFINITION_FILE);
-  const profilePath = definitionPath;
   const bodyPath = path5.join(dir, CAPABILITY_BODY_FILE);
-  if (!fs4.existsSync(profilePath) || !fs4.statSync(profilePath).isFile()) return null;
   if (!fs4.existsSync(bodyPath) || !fs4.statSync(bodyPath).isFile()) return null;
+  if (!isCapabilityFolder(dir)) return null;
   try {
-    const rawDefinition = JSON.parse(fs4.readFileSync(profilePath, "utf-8"));
-    const contract = parseCapabilityContract(rawDefinition);
-    if (!contract) return null;
-    const rawProfile = {
-      inputSchema: contract.input.schema,
-      outputSchema: contract.output.schema,
-      contract
-    };
     const rawBody = fs4.readFileSync(bodyPath, "utf-8");
     const { title, body } = parseCapabilityBody(rawBody, slug);
     return {
       slug,
       dir,
-      profilePath,
+      profilePath: bodyPath,
       bodyPath,
       title,
       body,
       rawBody,
       config: {
         action: slug,
-        describe: title,
-        outputSchema: contract.output.schema
+        describe: title
       },
-      rawProfile
+      rawProfile: {}
     };
   } catch {
     return null;
   }
 }
-function parseCapabilityContract(raw) {
-  if (Object.keys(raw).length !== 2 || !isPlainObject(raw.input) || !isPlainObject(raw.output)) return null;
-  const parseValue = (value) => {
-    if (Object.keys(value).some((key) => key !== "name" && key !== "schema") || typeof value.name !== "string" || !/^[a-z][a-z0-9-]*$/.test(value.name) || !isPlainObject(value.schema)) {
-      return null;
-    }
-    return { name: value.name, schema: value.schema };
-  };
-  const input = parseValue(raw.input);
-  const output = parseValue(raw.output);
-  return input && output ? { input, output } : null;
-}
 function parseCapabilityBody(raw, slug) {
   const trimmed = raw.trim();
   const firstLine2 = trimmed.split("\n", 1)[0] ?? "";
@@ -1789,28 +1765,24 @@ function parseWorkflowStep(value) {
   const raw = value;
   const capability = stringField(raw.capability ?? raw.action);
   if (!capability || !isSafeSlug(capability)) return null;
-  const implementation = stringField(raw.implementation);
   const id = stringField(raw.id);
   const action = stringField(raw.action);
   const evidence = stringField(raw.evidence);
   const reason = stringField(raw.reason);
   const target = stringField(raw.target);
   const targetFact = stringField(raw.targetFact ?? raw.target_fact);
-  const cliArgs = raw.cliArgs;
-  const inputs = parseWorkflowInputs(raw.inputs);
+  const hasInput = Object.hasOwn(raw, "input");
   const next = parseWorkflowTransitions(raw.next);
   const report = parseReportPublication(raw.report);
   return {
     capability,
+    ...hasInput ? { input: raw.input } : {},
     ...id && isSafeStepId(id) ? { id } : {},
     ...action && isSafeSlug(action) ? { action } : {},
-    ...implementation && isSafeSlug(implementation) ? { implementation } : {},
     ...evidence ? { evidence } : {},
     ...target === "issue" || target === "pr" ? { target } : {},
     ...targetFact ? { targetFact } : {},
     ...reason ? { reason } : {},
-    ...cliArgs && typeof cliArgs === "object" && !Array.isArray(cliArgs) ? { cliArgs } : {},
-    ...inputs ? { inputs } : {},
     ...next ? { next } : {},
     ...isPlainObject(raw.runWhen) ? { runWhen: raw.runWhen } : {},
     ...stringList(raw.continueOn ?? raw.continue_on).length > 0 ? { continueOn: stringList(raw.continueOn ?? raw.continue_on) } : {},
@@ -1818,17 +1790,6 @@ function parseWorkflowStep(value) {
     ...report ? { report } : {}
   };
 }
-function parseWorkflowInputs(value) {
-  if (!isPlainObject(value)) return void 0;
-  const inputs = {};
-  for (const [name, raw] of Object.entries(value)) {
-    if (!isSafeSlug(name) || !isPlainObject(raw)) continue;
-    const from = stringField(raw.from);
-    if (!from) continue;
-    inputs[name] = { from };
-  }
-  return Object.keys(inputs).length > 0 ? inputs : void 0;
-}
 function parseWorkflowTransitions(value) {
   const rawTransitions = Array.isArray(value) ? value : value === void 0 ? [] : [value];
   const transitions = rawTransitions.map((raw) => {
@@ -1885,13 +1846,12 @@ function isSafeSlug(value) {
 function isSafeStepId(value) {
   return /^[A-Za-z][A-Za-z0-9_-]*$/.test(value) && !value.includes("..");
 }
-var CAPABILITY_PROFILE_FILE, CAPABILITY_DEFINITION_FILE, CAPABILITY_BODY_FILE;
+var CAPABILITY_BODY_FILE, CAPABILITY_PROFILE_FILE;
 var init_capabilityFolders = __esm({
   "src/capabilityFolders.ts"() {
     "use strict";
-    CAPABILITY_PROFILE_FILE = "contract.json";
-    CAPABILITY_DEFINITION_FILE = "contract.json";
     CAPABILITY_BODY_FILE = "instructions.md";
+    CAPABILITY_PROFILE_FILE = CAPABILITY_BODY_FILE;
   }
 });
 
@@ -2060,36 +2020,27 @@ function getCapabilityActionInputs(action, projectCapabilitiesRoot = getProjectC
   const resolved = resolveCapabilityAction(action, projectCapabilitiesRoot);
   if (!resolved) return null;
   const capability = resolveCapabilityFolder(resolved.capability, projectCapabilitiesRoot);
-  if (capability && path7.basename(capability.profilePath) === "contract.json") {
-    const schema = capability.rawProfile.inputSchema;
-    if (!schema || typeof schema !== "object" || Array.isArray(schema)) return [];
-    const properties = schema.properties;
-    if (!properties || typeof properties !== "object" || Array.isArray(properties)) return [];
-    const required2 = new Set(
-      Array.isArray(schema.required) ? schema.required.filter((value) => typeof value === "string") : []
-    );
-    return Object.entries(properties).map(([name, value]) => {
-      const property = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-      const type = property.type === "integer" ? "int" : property.type === "boolean" ? "bool" : Array.isArray(property.enum) ? "enum" : "string";
-      return {
-        name,
-        flag: `--${name}`,
-        type,
-        required: required2.has(name),
-        ...type === "enum" && Array.isArray(property.enum) ? { values: property.enum.filter((item) => typeof item === "string") } : {},
-        describe: typeof property.description === "string" ? property.description : name
-      };
-    });
+  if (capability && !capability.config.workflow) {
+    return [
+      {
+        name: "input",
+        flag: "--input",
+        type: "string",
+        required: false,
+        bindsCommentRest: true,
+        describe: "One JSON-compatible input value."
+      }
+    ];
   }
   return getProfileInputs(resolved.implementation);
 }
 function resolveCapabilityExecution(capability, cwd = process.cwd()) {
-  if (path7.basename(capability.profilePath) === "contract.json") {
+  if (!capability.config.workflow) {
     return { implementation: "capability-run", cliArgs: { capability: capability.slug } };
   }
   const firstWorkflowStep = capability.config.workflow?.steps[0];
   if (firstWorkflowStep) {
-    const implementation2 = firstWorkflowStep.implementation ?? firstWorkflowStep.capability;
+    const implementation2 = firstWorkflowStep.capability;
     return { implementation: implementation2, cliArgs: {} };
   }
   const implementation = capability.config.implementation ?? capability.config.implementations?.[0] ?? (capability.config.role ? capability.slug : void 0) ?? (capability.config.tickScript ? "capability-tick-scripted" : "capability-tick");
@@ -3471,7 +3422,7 @@ function stripAgentSecrets(env) {
   }
   return out;
 }
-function buildAgentEnvironment(baseEnv, repoToken) {
+function buildAgentEnvironment(baseEnv, repoToken, requestEnvironment) {
   const env = stripAgentSecrets({
     ...baseEnv,
     SKIP_HOOKS: "1",
@@ -3484,13 +3435,14 @@ function buildAgentEnvironment(baseEnv, repoToken) {
     env.GITHUB_TOKEN = repoToken;
     env.GH_TOKEN = repoToken;
   }
+  Object.assign(env, requestEnvironment);
   return env;
 }
 async function runAgent(opts) {
   const ndjsonDir = opts.ndjsonDir ?? agentRunDir(opts.cwd);
   fs8.mkdirSync(ndjsonDir, { recursive: true });
   const ndjsonPath = path9.join(ndjsonDir, "last-run.jsonl");
-  const env = buildAgentEnvironment(process.env, opts.repoToken);
+  const env = buildAgentEnvironment(process.env, opts.repoToken, opts.environment);
   if (opts.litellmUrl) {
     env.ANTHROPIC_BASE_URL = opts.litellmUrl;
     env.ANTHROPIC_API_KEY = getAnthropicApiKeyOrDummy();
@@ -8892,7 +8844,7 @@ function validateWorkflow(value, options = {}) {
   }
   const graphMode = workflow?.startAt !== void 0 || rawSteps.some((entry) => {
     const step = asRecord2(entry);
-    return Boolean(step && (step.id !== void 0 || step.next !== void 0 || step.inputs !== void 0));
+    return Boolean(step && (step.id !== void 0 || step.next !== void 0));
   });
   const steps = rawSteps.map(
     (entry) => typeof entry === "string" ? { capability: entry } : asRecord2(entry)
@@ -8929,33 +8881,8 @@ function validateWorkflow(value, options = {}) {
       }
     }
     validateDataMatch(step.runWhen, `${base}.runWhen`, issues);
-    const inputs = asRecord2(step.inputs);
-    if (step.inputs !== void 0 && !inputs) {
-      issue(issues, "invalid_inputs", `${base}.inputs`, "workflow step inputs must be an object");
-    }
-    if (inputs) {
-      for (const [name, mapping] of Object.entries(inputs)) {
-        const inputPath = `${base}.inputs.${name}`;
-        if (!SAFE_NAME.test(name)) issue(issues, "invalid_input_name", inputPath, `invalid input name ${name}`);
-        const from = text(asRecord2(mapping)?.from);
-        if (!from || !SAFE_DATA_PATH.test(from)) {
-          issue(
-            issues,
-            "invalid_data_path",
-            `${inputPath}.from`,
-            `workflow input ${name} must read from facts, evidence, artifacts, result, workflow, or lastOutcome`
-          );
-        }
-        const declared = capability ? options.capabilityInputs?.get(capability) : void 0;
-        if (declared && !declared.has(name)) {
-          issue(
-            issues,
-            "unknown_capability_input",
-            inputPath,
-            `capability ${capability} does not declare input ${name}`
-          );
-        }
-      }
+    if (step.input !== void 0 && !isJsonValue(step.input)) {
+      issue(issues, "invalid_input", `${base}.input`, "workflow step input must be one JSON value");
     }
   });
   if (!graphMode) return issues;
@@ -9140,6 +9067,12 @@ function isComparable(value) {
   if (value === null || ["string", "number", "boolean"].includes(typeof value)) return true;
   return Array.isArray(value) && value.length > 0 && value.every((item) => isComparable(item) && !Array.isArray(item));
 }
+function isJsonValue(value) {
+  if (value === null || ["string", "number", "boolean"].includes(typeof value)) return true;
+  if (Array.isArray(value)) return value.every(isJsonValue);
+  if (!value || typeof value !== "object") return false;
+  return Object.values(value).every(isJsonValue);
+}
 function issue(issues, code, path54, message) {
   issues.push({ code, path: path54, message });
 }
@@ -9153,14 +9086,12 @@ var init_workflowValidation = __esm({
     SUPPORTED_STEP_FIELDS = /* @__PURE__ */ new Set([
       "id",
       "capability",
+      "input",
       "action",
-      "implementation",
       "evidence",
       "target",
       "targetFact",
       "reason",
-      "cliArgs",
-      "inputs",
       "next",
       "runWhen",
       "continueOn",
@@ -9189,10 +9120,7 @@ function normalizeWorkflowDefinition(value) {
   const name = typeof raw.name === "string" ? raw.name.trim() : "";
   const requestedAgent = typeof raw.agent === "string" ? raw.agent.trim() : "";
   const agent = /^[a-z][a-z0-9-]*$/.test(requestedAgent) ? requestedAgent : "kody";
-  const hasGraphConnections = Array.isArray(raw.steps) && raw.steps.some(
-    (step) => step && typeof step === "object" && !Array.isArray(step) && (step.next !== void 0 || step.inputs !== void 0)
-  );
-  if (hasGraphConnections) {
+  if (Array.isArray(raw.steps)) {
     if (validateWorkflow({ steps: raw.steps, ...raw.startAt !== void 0 ? { startAt: raw.startAt } : {} }).length > 0) {
       return null;
     }
@@ -15244,6 +15172,51 @@ var init_loadCapabilityState = __esm({
 // src/scripts/loadSimpleCapability.ts
 import * as fs39 from "fs";
 import * as path36 from "path";
+function parseInput(supplied) {
+  if (typeof supplied !== "string") return supplied;
+  try {
+    return JSON.parse(supplied);
+  } catch {
+    return parseFlagInput(supplied) ?? supplied;
+  }
+}
+function parseFlagInput(value) {
+  const tokens = value.trim().split(/\s+/).filter(Boolean);
+  if (!tokens.some((token) => token.startsWith("--"))) return null;
+  const input = {};
+  const text2 = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token.startsWith("--") || token.length === 2) {
+      text2.push(token);
+      continue;
+    }
+    const equalAt = token.indexOf("=");
+    const name = equalAt >= 0 ? token.slice(2, equalAt) : token.slice(2);
+    const next = equalAt >= 0 ? token.slice(equalAt + 1) : tokens[index + 1];
+    if (equalAt < 0 && next && !next.startsWith("--")) index += 1;
+    input[name] = next && !next.startsWith("--") ? scalar(next) : true;
+  }
+  if (text2.length > 0) input.request = text2.join(" ");
+  return input;
+}
+function scalar(value) {
+  if (value === "true" || value === "false") return value === "true";
+  if (/^-?\d+$/.test(value)) return Number(value);
+  return value;
+}
+function capabilityEnvironment(input) {
+  const environment = {
+    KODY_CAPABILITY_INPUT: JSON.stringify(input ?? null)
+  };
+  if (!input || typeof input !== "object" || Array.isArray(input)) return environment;
+  for (const [name, value] of Object.entries(input)) {
+    if (value === void 0 || value === null) continue;
+    const key = name.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
+    environment[`KODY_ARG_${key}`] = typeof value === "string" ? value : JSON.stringify(value);
+  }
+  return environment;
+}
 function listFiles(root) {
   if (!fs39.existsSync(root)) return [];
   const files = [];
@@ -15262,8 +15235,8 @@ var loadSimpleCapability;
 var init_loadSimpleCapability = __esm({
   "src/scripts/loadSimpleCapability.ts"() {
     "use strict";
-    init_definition_paths();
     init_capabilityFolders();
+    init_definition_paths();
     loadSimpleCapability = async (ctx) => {
       const slug = typeof ctx.args.capability === "string" ? ctx.args.capability.trim() : "";
       if (!/^[a-z][a-z0-9-]*$/.test(slug)) {
@@ -15273,37 +15246,24 @@ var init_loadSimpleCapability = __esm({
       if (!capability) {
         throw new Error(`Capability "${slug}" is not a valid simple capability folder`);
       }
-      const contract = capability.rawProfile.contract;
       const toolRoot = path36.join(capability.dir, "tools");
       const skillRoot = path36.join(capability.dir, "skills");
       const toolFiles = listFiles(toolRoot);
       const skillFiles = listFiles(skillRoot);
-      const supplied = ctx.args.input;
-      let input = supplied;
-      if (typeof supplied === "string") {
-        try {
-          input = JSON.parse(supplied);
-        } catch {
-          input = supplied;
-        }
-      }
+      const input = parseInput(ctx.args.input);
       ctx.data.jobCapability = slug;
       ctx.data.capabilityInput = input;
-      ctx.data.capabilityContract = contract;
+      ctx.data.capabilityEnvironment = capabilityEnvironment(input);
       ctx.data.prompt = [
         capability.rawBody.trim(),
         "",
         "## Input",
         "",
         "```json",
-        JSON.stringify({ [contract.input.name]: input }, null, 2),
+        JSON.stringify(input ?? null, null, 2),
         "```",
         "",
-        "Return one JSON value matching the output contract:",
-        "",
-        "```json",
-        JSON.stringify({ [contract.output.name]: contract.output.schema }, null, 2),
-        "```",
+        "Return one JSON value.",
         ...skillFiles.length ? [
           "",
           "## Skills",
@@ -16871,16 +16831,29 @@ var init_parseJobStateFromAgentResult = __esm({
 });
 
 // src/scripts/parseSimpleCapabilityOutput.ts
-function parseEnvelope(text2) {
-  if (!text2) return null;
-  const candidate = text2.match(/```(?:json)?\s*([\s\S]*?)\s*```/i)?.[1] ?? text2;
+function parseOutput(text2) {
+  if (!text2) return void 0;
   try {
-    const parsed = JSON.parse(candidate);
-    if (!isObject(parsed) || !isObject(parsed.result)) return null;
-    return { result: parsed.result };
+    return JSON.parse(text2);
   } catch {
-    return null;
   }
+  const fences = [...text2.matchAll(/```([a-z0-9_-]+)?\s*([\s\S]*?)\s*```/gi)];
+  const jsonFences = fences.filter((match) => match[1]?.toLowerCase() === "json");
+  const labelledOutput = parseSingleJsonCandidate(jsonFences.map((match) => match[2]));
+  if (labelledOutput.found) return labelledOutput.value;
+  const plainOutput = parseSingleJsonCandidate(fences.filter((match) => !match[1]).map((match) => match[2]));
+  return plainOutput.found ? plainOutput.value : void 0;
+}
+function parseSingleJsonCandidate(candidates) {
+  const parsed = [];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    try {
+      parsed.push(JSON.parse(candidate));
+    } catch {
+    }
+  }
+  return parsed.length === 1 ? { found: true, value: parsed[0] } : { found: false };
 }
 function isObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -16893,28 +16866,31 @@ var init_parseSimpleCapabilityOutput = __esm({
   "src/scripts/parseSimpleCapabilityOutput.ts"() {
     "use strict";
     parseSimpleCapabilityOutput = async (ctx, _profile, agentResult) => {
-      const envelope = parseEnvelope(agentResult?.finalText);
-      if (!envelope) {
+      const output = parseOutput(agentResult?.finalText);
+      if (output === void 0) {
         ctx.output.exitCode = 64;
-        ctx.output.reason = "simple capability did not return its JSON output contract";
+        ctx.output.reason = "simple capability did not return one JSON value";
         return;
       }
-      const result = envelope.result;
-      const data = isObject(result.data) ? result.data : {};
+      ctx.data.capabilityOutput = output;
+      const result = isObject(output) ? output : {};
+      const data = isObject(result.data) ? result.data : isObject(output) ? output : { output };
       const summary = typeof result.summary === "string" ? result.summary : "Capability completed";
       const reason = typeof result.reason === "string" ? result.reason : summary;
       const prUrl = stringValue4(data.pullRequestUrl) ?? stringValue4(data.prUrl) ?? stringValue4(result.pullRequestUrl) ?? stringValue4(result.prUrl);
       if (prUrl) ctx.output.prUrl = prUrl;
       ctx.output.reason = reason;
-      ctx.data.capabilityResults = [{
-        version: 1,
-        status: "changed",
-        summary,
-        facts: data,
-        artifacts: prUrl ? [{ label: "Pull request", url: prUrl }] : [],
-        missingEvidence: [],
-        blockers: []
-      }];
+      ctx.data.capabilityResults = [
+        {
+          version: 1,
+          status: "changed",
+          summary,
+          facts: data,
+          artifacts: prUrl ? [{ label: "Pull request", url: prUrl }] : [],
+          missingEvidence: [],
+          blockers: []
+        }
+      ];
     };
   }
 });
@@ -19650,26 +19626,18 @@ function validateFilesForKind(kind, slug, files, strictSingleModel, failures, op
         const workflow = hasWorkflowObject ? profile.workflow : { steps: profile.steps, ...profile.startAt !== void 0 ? { startAt: profile.startAt } : {} };
         const known = options.capabilityRoot ? getCapabilityRoots(options.capabilityRoot).flatMap((root) => listCapabilityFolderSlugs(root)) : [];
         const uniqueKnown = [...new Set(known)];
-        const capabilityInputs = /* @__PURE__ */ new Map();
         const capabilityOutputs = /* @__PURE__ */ new Map();
         if (options.capabilityRoot) {
           for (const capability of uniqueKnown) {
             const folder = getCapabilityRoots(options.capabilityRoot).map((root) => readCapabilityFolder(root, capability)).find((entry) => entry !== null);
-            capabilityOutputs.set(capability, folder ? capabilityOutputConditionPaths(folder.config) : /* @__PURE__ */ new Set());
-            const inputs = getCapabilityActionInputs(capability, options.capabilityRoot);
-            if (inputs) {
-              capabilityInputs.set(
-                capability,
-                new Set(inputs.flatMap((input) => [input.name, input.flag.replace(/^--/, "")]))
-              );
-            }
+            const outputPaths = folder ? capabilityOutputConditionPaths(folder.config) : /* @__PURE__ */ new Set();
+            if (outputPaths.size > 0) capabilityOutputs.set(capability, outputPaths);
           }
         }
         failures.push(
           ...formatWorkflowValidationIssues(
             validateWorkflow(workflow, {
               ...uniqueKnown.length > 0 ? { knownCapabilities: new Set(uniqueKnown) } : {},
-              ...capabilityInputs.size > 0 ? { capabilityInputs } : {},
               ...capabilityOutputs.size > 0 ? { capabilityOutputs } : {}
             })
           )
@@ -21214,6 +21182,7 @@ async function runImplementation(profileName, input) {
       prompt,
       model,
       cwd: input.cwd,
+      environment: ctx.data.capabilityEnvironment && typeof ctx.data.capabilityEnvironment === "object" && !Array.isArray(ctx.data.capabilityEnvironment) ? ctx.data.capabilityEnvironment : void 0,
       litellmUrl: lm?.url ?? null,
       // On a connection drop mid-run, restart the (possibly crashed) proxy
       // before the agent retries. No-op for direct-Anthropic runs (lm null).
@@ -21471,7 +21440,8 @@ async function runImplementation(profileName, input) {
       nextJob: ctx.output.nextJob,
       afterNextJob: ctx.output.afterNextJob,
       taskState: ctx.data.taskState,
-      capabilityResults
+      capabilityResults,
+      ...Object.hasOwn(ctx.data, "capabilityOutput") ? { capabilityOutput: ctx.data.capabilityOutput } : {}
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -22251,12 +22221,10 @@ async function runCapabilityImplementationStep(valid, profileName, capabilityIde
   const shouldApplyResolvedCapabilityArgs = valid.implementation === void 0 && resolvedCapability && profileName === resolvedCapability.implementation;
   input.cliArgs = shouldApplyResolvedCapabilityArgs ? { ...resolvedCapability.cliArgs, ...input.cliArgs } : input.cliArgs;
   if (profileName === "capability-run" && capabilityIdentity) {
-    const capabilityInput = { ...valid.cliArgs };
+    const capabilityInput = Object.keys(valid.cliArgs).length > 0 ? genericInputFromArgs(valid.cliArgs) : void 0;
     input.cliArgs = {
       capability: capabilityIdentity,
-      ...Object.keys(capabilityInput).length > 0 ? {
-        input: Object.keys(capabilityInput).length === 1 && typeof capabilityInput.input === "string" ? capabilityInput.input : JSON.stringify(capabilityInput)
-      } : {}
+      ...capabilityInput !== void 0 ? { input: JSON.stringify(capabilityInput) } : {}
     };
   }
   const run = base.chain === false ? runImplementation : runImplementationChain;
@@ -22316,7 +22284,7 @@ async function runLinearCapabilityWorkflow(parent, workflow, capability, base) {
       );
       continue;
     }
-    const child = workflowStepToJob(step, parent, chainData);
+    const child = workflowStepToJob(step, parent, chainData, base.cwd);
     process.stdout.write(
       `\u2192 kody: workflow ${capability.slug} step ${index + 1}/${workflow.steps.length} \u2192 ${label}
 
@@ -22341,6 +22309,7 @@ async function runLinearCapabilityWorkflow(parent, workflow, capability, base) {
       ...chainData,
       ...result.taskState ? { taskState: result.taskState } : {},
       ...outcome ? { workflowLastOutcome: outcome } : {},
+      ...result.capabilityOutput !== void 0 ? { workflowLastOutput: result.capabilityOutput } : {},
       ...prUrl ? { workflowPrUrl: prUrl } : {},
       ...parsePrNumber5(prUrl) ? { workflowPrNumber: parsePrNumber5(prUrl) } : {}
     };
@@ -22354,12 +22323,11 @@ async function runLinearCapabilityWorkflow(parent, workflow, capability, base) {
   return withWorkflowBoundaryEval(capability, result);
 }
 function isGraphWorkflow(workflow) {
-  return workflow.startAt !== void 0 || workflow.steps.some((step) => step.id !== void 0 || step.next !== void 0 || step.inputs !== void 0);
+  return workflow.startAt !== void 0 || workflow.steps.some((step) => step.id !== void 0 || step.next !== void 0);
 }
 function workflowError(workflow, base) {
   const projectCapabilitiesRoot = hydratedCapabilitiesRoot(base.cwd);
   const knownCapabilities = /* @__PURE__ */ new Set();
-  const capabilityInputs = /* @__PURE__ */ new Map();
   const capabilityOutputs = /* @__PURE__ */ new Map();
   for (const step of workflow.steps) {
     const action = step.action ?? step.capability;
@@ -22367,21 +22335,10 @@ function workflowError(workflow, base) {
     const resolvedFolder = resolveCapabilityFolder(step.capability, projectCapabilitiesRoot);
     if (!resolvedAction && !resolvedFolder) continue;
     knownCapabilities.add(step.capability);
-    capabilityOutputs.set(
-      step.capability,
-      resolvedFolder ? capabilityOutputConditionPaths(resolvedFolder.config) : /* @__PURE__ */ new Set()
-    );
-    const inputs = getCapabilityActionInputs(action, projectCapabilitiesRoot);
-    if (inputs) {
-      capabilityInputs.set(
-        step.capability,
-        new Set(inputs.flatMap((input) => [input.name, input.flag.replace(/^--/, "")]))
-      );
-    }
+    const outputPaths = resolvedFolder ? capabilityOutputConditionPaths(resolvedFolder.config) : /* @__PURE__ */ new Set();
+    if (outputPaths.size > 0) capabilityOutputs.set(step.capability, outputPaths);
   }
-  return formatWorkflowValidationIssues(
-    validateWorkflow(workflow, { knownCapabilities, capabilityInputs, capabilityOutputs })
-  )[0] ?? null;
+  return formatWorkflowValidationIssues(validateWorkflow(workflow, { knownCapabilities, capabilityOutputs }))[0] ?? null;
 }
 function initialWorkflowState(parent, workflow) {
   const prior = parent.workflowState;
@@ -22456,7 +22413,7 @@ async function runGraphCapabilityWorkflow(parent, workflow, capability, base, ch
     await checkpoint?.(state);
     let child;
     try {
-      child = workflowStepToJob(step, parent, chainData);
+      child = workflowStepToJob(step, parent, chainData, base.cwd);
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
       state.status = "blocked";
@@ -22490,6 +22447,7 @@ async function runGraphCapabilityWorkflow(parent, workflow, capability, base, ch
       ...result.taskState ? { taskState: result.taskState } : {},
       ...outcome ? { workflowLastOutcome: outcome } : {},
       ...result.capabilityResults?.at(-1) ? { workflowLastResult: result.capabilityResults.at(-1) } : {},
+      ...result.capabilityOutput !== void 0 ? { workflowLastOutput: result.capabilityOutput } : {},
       ...prUrl ? { workflowPrUrl: prUrl } : {},
       ...parsePrNumber5(prUrl) ? { workflowPrNumber: parsePrNumber5(prUrl) } : {}
     };
@@ -22588,23 +22546,12 @@ function withWorkflowBoundaryEval(capability, result) {
     reason: result.reason ? `${result.reason}; agency boundary eval failed: ${failed.join(", ")}` : `agency boundary eval failed: ${failed.join(", ")}`
   };
 }
-function workflowStepToJob(step, parent, chainData) {
+function workflowStepToJob(step, parent, chainData, cwd) {
   const action = step.action ?? step.capability;
-  const mappedArgs = {};
-  const conditionContext = workflowConditionContext(chainData);
-  for (const [name, mapping] of Object.entries(step.inputs ?? {})) {
-    const value = resolveDottedPath2(conditionContext, mapping.from);
-    if (value === void 0) {
-      throw new InvalidJobError(`workflow step ${step.id ?? action} needs missing input ${mapping.from}`);
-    }
-    mappedArgs[name] = value;
-  }
+  const targetNumber = workflowStepTargetNumber(step, parent, chainData);
   const rawArgs = {
-    ...parent.cliArgs,
-    ...mappedArgs,
-    ...step.cliArgs ?? {}
+    ...parent.cliArgs
   };
-  const targetNumber = workflowStepTargetNumber(step, parent, chainData);
   if (step.target === "pr") {
     if (typeof targetNumber !== "number") {
       throw new InvalidJobError(`workflow step ${action} needs a PR target but no prior PR URL is available`);
@@ -22613,12 +22560,16 @@ function workflowStepToJob(step, parent, chainData) {
   } else if (step.target === "issue" && typeof targetNumber === "number") {
     rawArgs.issue = targetNumber;
   }
-  const cliArgs = filterCliArgsForStep(action, rawArgs);
+  const genericInput = capabilityStepInput(
+    step.input ?? chainData.workflowLastOutput ?? genericInputFromArgs(rawArgs),
+    step.target,
+    targetNumber
+  );
+  const cliArgs = usesGenericCapabilityInput(action, cwd) ? genericInput === void 0 ? {} : { input: JSON.stringify(genericInput) } : filterCliArgsForStep(action, rawArgs);
   const target = typeof targetNumber === "number" ? targetNumber : typeof parent.target === "number" ? parent.target : targetFromCliArgs(cliArgs);
   return {
     action,
     capability: step.capability,
-    ...step.implementation ? { implementation: step.implementation } : {},
     ...composeStepWhy(parent.why, step) ? { why: composeStepWhy(parent.why, step) } : {},
     ...parent.agent ? { agent: parent.agent } : {},
     ...parent.schedule ? { schedule: parent.schedule } : {},
@@ -22632,6 +22583,38 @@ function workflowStepToJob(step, parent, chainData) {
     ...parent.resultTarget ? { resultTarget: parent.resultTarget } : {}
   };
 }
+function usesGenericCapabilityInput(action, cwd) {
+  const inputs = getCapabilityActionInputs(action, hydratedCapabilitiesRoot(cwd));
+  return Boolean(inputs?.length === 1 && inputs[0]?.name === "input" && inputs[0]?.flag === "--input");
+}
+function genericInputFromArgs(args) {
+  if (Object.hasOwn(args, "input")) {
+    const { input, ...routing } = args;
+    const parsed = parseGenericInput(input);
+    if (Object.keys(routing).length === 0) return parsed;
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { ...parsed, ...routing };
+    }
+    return { request: parsed, ...routing };
+  }
+  return args;
+}
+function parseGenericInput(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function capabilityStepInput(input, target, targetNumber) {
+  if (!target || targetNumber === void 0) return input;
+  const routing = { [target]: targetNumber };
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    return { ...input, ...routing };
+  }
+  return input === void 0 ? routing : { request: input, ...routing };
+}
 function shouldRunWorkflowStep(step, data) {
   if (!step.runWhen) return true;
   const context = workflowConditionContext(data);
@@ -22647,15 +22630,17 @@ function workflowOutcome(result) {
 function workflowConditionContext(data) {
   const lastOutcome = data.workflowLastOutcome;
   const lastResult = data.workflowLastResult;
+  const lastOutput = data.workflowLastOutput;
   return {
     ...data,
     facts: data.workflowFacts ?? {},
     evidence: data.workflowEvidence ?? {},
     artifacts: data.workflowArtifacts ?? [],
-    result: lastResult,
+    result: lastOutput === void 0 ? lastResult : lastOutput,
     workflow: {
       lastOutcome,
       lastResult,
+      lastOutput,
       issueNumber: data.workflowIssueNumber,
       prNumber: data.workflowPrNumber,
       prUrl: data.workflowPrUrl
@@ -22674,10 +22659,9 @@ function valueMatches(actual, expected) {
   return actual === expected;
 }
 function workflowStepTargetNumber(step, parent, chainData) {
-  if (step.target === "pr")
-    return workflowPrNumber(chainData) ?? workflowTargetFactNumber(step, chainData) ?? targetFromCliArgs(step.cliArgs ?? {});
+  if (step.target === "pr") return workflowPrNumber(chainData) ?? workflowTargetFactNumber(step, chainData);
   if (step.target === "issue") return workflowIssueNumber(parent);
-  return typeof parent.target === "number" ? parent.target : targetFromCliArgs({ ...parent.cliArgs, ...step.cliArgs ?? {} });
+  return typeof parent.target === "number" ? parent.target : targetFromCliArgs(parent.cliArgs);
 }
 function workflowResumeStartIndex(steps, evidence) {
   if (!evidence) return 0;

package/dist/runtime-services/capability-run/profile.json

@@ -16,6 +16,7 @@
       "flag": "--input",
       "type": "string",
       "required": false,
+      "bindsCommentRest": true,
       "describe": "The capability's single JSON input."
     }
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.442",
+  "version": "0.4.444",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
   "license": "MIT",
   "type": "module",
@@ -12,6 +12,29 @@
     "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:runtime-services": "node --test \"tests/runtime-services/*.test.mjs\"",
+    "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 --build-arg KODY_ENGINE_REF=$(git rev-parse HEAD) -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 test:runtime-services && pnpm build && pnpm verify:package"
+  },
   "dependencies": {
     "@actions/cache": "^6.0.0",
     "@anthropic-ai/claude-agent-sdk": "0.2.119",
@@ -38,27 +61,5 @@
     "url": "git+https://github.com/aharonyaircohen/kody-engine.git"
   },
   "homepage": "https://github.com/aharonyaircohen/kody-engine",
-  "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:runtime-services": "node --test \"tests/runtime-services/*.test.mjs\"",
-    "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 --build-arg KODY_ENGINE_REF=$(git rev-parse HEAD) -t ghcr.io/${KODY_BRAIN_GHCR_OWNER:-aharonyaircohen}/kody-brain:latest --push runner"
-  }
-}
+  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues"
+}