@kody-ade/kody-engine 0.4.308 → 0.4.310

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.308",
+      version: "0.4.310",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -6009,27 +6009,30 @@ function resolveLitellmTimeoutMs() {
 function generateLitellmConfigYaml(model) {
   const apiKeyVar = model.apiKeyEnvVar ?? providerApiKeyEnvVar(model.provider);
   const litellmProvider = model.litellmProvider ?? model.provider;
-  const modelGroup = litellmModelGroup(model);
+  const modelGroups = litellmModelGroups(model);
   const providerParams = model.baseURL ? [["api_base", model.baseURL]] : [];
-  return [
-    "model_list:",
+  const modelEntries = modelGroups.flatMap((modelGroup) => [
     `  - model_name: ${modelGroup}`,
     `    litellm_params:`,
     `      model: ${litellmProvider}/${model.model}`,
     `      api_key: os.environ/${apiKeyVar}`,
-    ...providerParams.map(([key, value]) => `      ${key}: ${value}`),
-    "",
-    "litellm_settings:",
-    "  drop_params: true",
-    ""
-  ].join("\n");
+    ...providerParams.map(([key, value]) => `      ${key}: ${value}`)
+  ]);
+  return ["model_list:", ...modelEntries, "", "litellm_settings:", "  drop_params: true", ""].join("\n");
 }
-async function litellmServesModel(url, modelGroup) {
+function litellmModelGroups(model) {
+  const primary = litellmModelGroup(model);
+  return Array.from(/* @__PURE__ */ new Set([primary, ...CLAUDE_CODE_PROXY_MODEL_ALIASES]));
+}
+async function litellmServesModels(url, modelGroups) {
   try {
     const response = await fetch(`${url.replace(/\/+$/, "")}/v1/models`, { signal: AbortSignal.timeout(3e3) });
     if (!response.ok) return false;
     const payload = await response.json();
-    return (payload.data ?? []).some((entry) => entry.id === modelGroup);
+    const served = new Set(
+      (payload.data ?? []).map((entry) => entry.id).filter((id) => typeof id === "string")
+    );
+    return modelGroups.every((modelGroup) => served.has(modelGroup));
   } catch {
     return false;
   }
@@ -6086,7 +6089,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   if (!needsLitellmProxy(model)) return null;
   const cmd = resolveLitellmCommand();
   let activeUrl = url.replace(/\/+$/, "");
-  const modelGroup = litellmModelGroup(model);
+  const modelGroups = litellmModelGroups(model);
   const childEnv = stripBlockingEnv({ ...process.env, ...readDotenvApiKeys(projectDir) });
   let child;
   let logPath;
@@ -6150,13 +6153,13 @@ ${tail}
   };
   const isHealthy = () => checkLitellmHealth(activeUrl);
   if (await checkLitellmHealth(activeUrl)) {
-    if (await litellmServesModel(activeUrl, modelGroup)) {
+    if (await litellmServesModels(activeUrl, modelGroups)) {
       return { url: activeUrl, kill: killChild, isHealthy, ensureHealthy };
     }
     const staleUrl = activeUrl;
     activeUrl = await nextAvailableLitellmUrl(activeUrl);
     process.stderr.write(
-      `[kody litellm] existing proxy at ${staleUrl} does not serve ${modelGroup}; starting a separate proxy at ${activeUrl}
+      `[kody litellm] existing proxy at ${staleUrl} does not serve ${modelGroups.join(", ")}; starting a separate proxy at ${activeUrl}
 `
     );
   }
@@ -6220,13 +6223,14 @@ function stripBlockingEnv(env) {
   delete out.AI_BASE_URL;
   return out;
 }
-var DEFAULT_LITELLM_STARTUP_TIMEOUT_SEC, LITELLM_HEALTH_POLL_INTERVAL_MS;
+var DEFAULT_LITELLM_STARTUP_TIMEOUT_SEC, LITELLM_HEALTH_POLL_INTERVAL_MS, CLAUDE_CODE_PROXY_MODEL_ALIASES;
 var init_litellm = __esm({
   "src/litellm.ts"() {
     "use strict";
     init_config();
     DEFAULT_LITELLM_STARTUP_TIMEOUT_SEC = 150;
     LITELLM_HEALTH_POLL_INTERVAL_MS = 2e3;
+    CLAUDE_CODE_PROXY_MODEL_ALIASES = ["claude-haiku-4-5-20251001", "haiku"];
   }
 });
 
@@ -7052,16 +7056,76 @@ function enrichGoalRunLogEvent(config, data, logPath, event) {
   const stateRepo = stateRepoContext(config, event.goalId, logPath);
   const trigger = event.trigger ?? triggerContext();
   const job = event.job ?? jobContext(data);
-  return pruneUndefined({
+  const run = event.run ?? runContext(data);
+  const links = event.links ?? linkContext(stateRepo);
+  const enriched = pruneUndefined({
     ...event,
-    run: event.run ?? runContext(data),
+    run,
     repo: event.repo ?? repoContext(config),
     stateRepo: event.stateRepo ?? stateRepo,
     trigger,
     job,
     dispatchContext: event.dispatchContext ?? dispatchContext(event, trigger, job),
-    links: event.links ?? linkContext(stateRepo)
+    links
+  });
+  enriched.trace = event.trace ?? goalRunTrace(enriched);
+  return enriched;
+}
+function goalRunTrace(event) {
+  const run = recordValue2(event.run);
+  const trigger = recordValue2(event.trigger);
+  const goal = recordValue2(event.goal);
+  const inspection = recordValue2(event.inspection);
+  const capabilityOutput = recordValue2(inspection?.capabilityOutput);
+  return pruneUndefined({
+    version: 1,
+    runId: stringValue2(run?.id) ?? void 0,
+    workflowRunId: stringValue2(run?.githubRunId) ?? void 0,
+    triggerKind: stringValue2(trigger?.kind) ?? void 0,
+    source: event.source,
+    event: event.event,
+    goal: pruneUndefined({
+      id: event.goalId,
+      type: event.goalType ?? stringValue2(goal?.type) ?? void 0,
+      state: event.goalState ?? stringValue2(goal?.state) ?? void 0,
+      stage: event.stage ?? stringValue2(goal?.stage) ?? void 0
+    }),
+    evidence: goalTraceEvidence(event, goal, inspection),
+    capability: event.dispatch ?? capabilityDispatchFromOutput(capabilityOutput),
+    result: goalTraceResult(event, capabilityOutput),
+    change: event.change,
+    links: event.links
+  });
+}
+function goalTraceEvidence(event, goal, inspection) {
+  const expectedEvidence = recordValue2(inspection?.expectedEvidence);
+  const out = pruneUndefined({
+    current: event.evidence,
+    required: stringArrayValue(goal?.requiredEvidence) ?? stringArrayValue(inspection?.requiredEvidence) ?? void 0,
+    satisfied: stringArrayValue(goal?.satisfiedEvidence) ?? stringArrayValue(inspection?.satisfiedEvidence) ?? void 0,
+    missing: stringArrayValue(goal?.missingEvidence) ?? stringArrayValue(inspection?.missingEvidence) ?? stringArrayValue(expectedEvidence?.missingBefore) ?? void 0,
+    pending: stringValue2(goal?.pendingEvidence) ?? stringValue2(inspection?.pendingEvidence) ?? stringValue2(expectedEvidence?.pendingBefore) ?? void 0,
+    values: event.evidenceValues
+  });
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function capabilityDispatchFromOutput(output) {
+  if (!output) return void 0;
+  const dispatch2 = pruneUndefined({
+    capability: stringValue2(output.capability) ?? void 0,
+    executable: stringValue2(output.executable) ?? void 0,
+    action: stringValue2(output.action) ?? void 0
   });
+  return Object.keys(dispatch2).length > 0 ? dispatch2 : void 0;
+}
+function goalTraceResult(event, capabilityOutput) {
+  const result = pruneUndefined({
+    status: event.status ?? stringValue2(capabilityOutput?.status) ?? void 0,
+    summary: event.reason ?? stringValue2(capabilityOutput?.summary) ?? void 0,
+    blockers: event.inspection ? stringArrayValue(capabilityOutput?.blockers) ?? void 0 : void 0,
+    artifacts: event.artifacts
+  });
+  return Object.keys(result).length > 0 ? result : void 0;
 }
 function runContext(data) {
   const runId = process.env.GITHUB_RUN_ID?.trim();
@@ -12218,6 +12282,126 @@ var init_ensurePr = __esm({
   }
 });
 
+// src/agencyBoundaryEval.ts
+function evaluateAgencyBoundaries(input) {
+  const findings = [];
+  const results = input.results ?? [];
+  findings.push(evaluateObserveBoundary(input.capabilityKind, results));
+  findings.push(evaluateVerifyBoundary(input.capabilityKind, results));
+  findings.push(evaluateGoalOwnershipBoundary(results));
+  return {
+    version: 1,
+    status: findings.some((finding) => finding.status === "fail") ? "fail" : "pass",
+    ...input.capability ? { capability: input.capability } : {},
+    ...input.capabilityKind ? { capabilityKind: input.capabilityKind } : {},
+    findings
+  };
+}
+function evaluateObserveBoundary(capabilityKind, results) {
+  if (capabilityKind !== "observe") {
+    return pass("observe-does-not-act", "capability is not observe", { capabilityKind });
+  }
+  const actionResults = results.filter(resultLooksLikeAction);
+  if (actionResults.length === 0) {
+    return pass("observe-does-not-act", "observe capability reported facts without action output", {
+      resultCount: results.length
+    });
+  }
+  return fail2("observe-does-not-act", "observe capability returned action-shaped output", {
+    resultCount: results.length,
+    actionResults: actionResults.map(resultSummary)
+  });
+}
+function evaluateVerifyBoundary(capabilityKind, results) {
+  if (capabilityKind !== "verify") {
+    return pass("verify-does-not-fix", "capability is not verify", { capabilityKind });
+  }
+  const actionResults = results.filter(resultLooksLikeAction);
+  if (actionResults.length === 0) {
+    return pass("verify-does-not-fix", "verify capability returned verdict evidence without action output", {
+      resultCount: results.length
+    });
+  }
+  return fail2("verify-does-not-fix", "verify capability returned fix/change output", {
+    resultCount: results.length,
+    actionResults: actionResults.map(resultSummary)
+  });
+}
+function evaluateGoalOwnershipBoundary(results) {
+  const targetBearing = results.filter((result) => result.target?.type === "goal");
+  if (targetBearing.length === 0) {
+    return pass("capability-does-not-own-goal-progress", "capability output is parent-neutral", {
+      resultCount: results.length
+    });
+  }
+  return fail2("capability-does-not-own-goal-progress", "capability output names a goal target", {
+    resultCount: results.length,
+    targetBearingResults: targetBearing.map(resultSummary)
+  });
+}
+function resultLooksLikeAction(result) {
+  if (result.status === "changed") return true;
+  return Object.keys(result.facts).some((key) => ACTION_FACT_KEYS.has(key));
+}
+function resultSummary(result) {
+  return {
+    status: result.status,
+    summary: result.summary,
+    target: result.target,
+    actionFactKeys: Object.keys(result.facts).filter((key) => ACTION_FACT_KEYS.has(key))
+  };
+}
+function pass(rule, message, evidence) {
+  return { rule, status: "pass", message, evidence };
+}
+function fail2(rule, message, evidence) {
+  return { rule, status: "fail", message, evidence };
+}
+var ACTION_FACT_KEYS;
+var init_agencyBoundaryEval = __esm({
+  "src/agencyBoundaryEval.ts"() {
+    "use strict";
+    ACTION_FACT_KEYS = /* @__PURE__ */ new Set(["changedResources", "createdResources", "actionResult"]);
+  }
+});
+
+// src/scripts/evaluateAgencyBoundaries.ts
+function collectResults2(raw, agentResult) {
+  const out = [];
+  if (Array.isArray(raw)) {
+    for (const item of raw) {
+      const parsed = parseCapabilityResult(item);
+      if (parsed) out.push(parsed);
+    }
+  }
+  if (agentResult?.finalText) out.push(...parseCapabilityResultsFromText(agentResult.finalText));
+  return out;
+}
+var evaluateAgencyBoundariesScript;
+var init_evaluateAgencyBoundaries = __esm({
+  "src/scripts/evaluateAgencyBoundaries.ts"() {
+    "use strict";
+    init_agencyBoundaryEval();
+    init_capabilityResult();
+    evaluateAgencyBoundariesScript = async (ctx, profile, agentResult) => {
+      const results = collectResults2(ctx.data.capabilityResults ?? ctx.data.dutyResults, agentResult);
+      const evalResult = evaluateAgencyBoundaries({
+        capability: profile.name,
+        capabilityKind: profile.capabilityKind,
+        results
+      });
+      ctx.data.agencyBoundaryEval = evalResult;
+      process.stdout.write(`KODY_AGENCY_BOUNDARY_EVAL=${JSON.stringify(evalResult)}
+`);
+      if (evalResult.status === "fail") {
+        const failed = evalResult.findings.filter((finding) => finding.status === "fail").map((finding) => finding.rule);
+        ctx.output.exitCode = ctx.output.exitCode === 0 ? 99 : ctx.output.exitCode;
+        ctx.output.reason = ctx.output.reason ? `${ctx.output.reason}; agency boundary eval failed: ${failed.join(", ")}` : `agency boundary eval failed: ${failed.join(", ")}`;
+      }
+    };
+  }
+});
+
 // src/scripts/failOnceTaskJob.ts
 var failOnceTaskJob;
 var init_failOnceTaskJob = __esm({
@@ -14088,7 +14272,7 @@ var init_markFlowSuccess = __esm({
 });
 
 // src/goal/operations.ts
-function fail2(err) {
+function fail3(err) {
   if (err instanceof Error) {
     const lines = err.message.split("\n").filter(Boolean);
     return { ok: false, error: lines[0] ?? err.message };
@@ -14100,7 +14284,7 @@ function commentOnIssue(issueNumber, body, cwd) {
     gh(["issue", "comment", String(issueNumber), "--body", body], { cwd });
     return { ok: true };
   } catch (err) {
-    return fail2(err);
+    return fail3(err);
   }
 }
 function mergePrSquash(prNumber, cwd) {
@@ -14108,7 +14292,7 @@ function mergePrSquash(prNumber, cwd) {
     gh(["pr", "merge", String(prNumber), "--squash", "--delete-branch"], { cwd });
     return { ok: true };
   } catch (err) {
-    return fail2(err);
+    return fail3(err);
   }
 }
 var init_operations = __esm({
@@ -17988,6 +18172,7 @@ var init_scripts = __esm({
     init_dispatchClassified();
     init_dispatchNextTaskJob();
     init_ensurePr();
+    init_evaluateAgencyBoundaries();
     init_failOnceTaskJob();
     init_finalizeTerminal();
     init_finishFlow();
@@ -18132,6 +18317,7 @@ var init_scripts = __esm({
       stageMergeConflicts,
       commitAndPush: commitAndPush2,
       ensurePr: ensurePr2,
+      evaluateAgencyBoundaries: evaluateAgencyBoundariesScript,
       postAgentComment,
       postIssueComment: postIssueComment2,
       postPlanComment,

package/package.json

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