@kody-ade/kody-engine 0.4.291 → 0.4.293

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.291",
+      version: "0.4.293",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -667,7 +667,7 @@ function parseReasoningEffort(raw) {
 function parseProviderModel(s) {
   const slash = s.indexOf("/");
   if (slash <= 0 || slash === s.length - 1) {
-    throw new Error(`Invalid model spec '${s}' \u2014 expected 'provider/model' (e.g. 'minimax/MiniMax-M2.7-highspeed')`);
+    throw new Error(`Invalid model spec '${s}' \u2014 expected 'provider/model' (e.g. 'minimax/MiniMax-M3')`);
   }
   return { provider: s.slice(0, slash), model: s.slice(slash + 1) };
 }
@@ -710,6 +710,9 @@ function parseModelRuntimeConfig(modelSpec, rawConfig) {
   if (protocol === "openai") out.litellmProvider = "openai";
   return out;
 }
+function litellmModelGroup(model) {
+  return model.spec?.trim() || model.model;
+}
 function providerApiKeyEnvVar(provider) {
   if (provider === "anthropic" || provider === "claude") return "ANTHROPIC_API_KEY";
   return `${provider.toUpperCase()}_API_KEY`;
@@ -735,7 +738,7 @@ function loadConfig(projectDir = process.cwd()) {
   const github = recordValue(raw.github) ?? {};
   const agent = recordValue(raw.agent) ?? {};
   if (!agent.model || typeof agent.model !== "string") {
-    throw new Error(`kody.config.json: agent.model is required (e.g. "minimax/MiniMax-M2.7-highspeed")`);
+    throw new Error(`kody.config.json: agent.model is required (e.g. "minimax/MiniMax-M3")`);
   }
   if (!github.owner || !github.repo) {
     throw new Error(`kody.config.json: github.owner and github.repo are required`);
@@ -836,10 +839,7 @@ function parseCompanyConfig(raw) {
   const r = raw;
   const out = {};
   if (r.activeCapabilities !== void 0)
-    out.activeCapabilities = parseSlugArray(
-      r.activeCapabilities,
-      "company.activeCapabilities"
-    );
+    out.activeCapabilities = parseSlugArray(r.activeCapabilities, "company.activeCapabilities");
   if (r.activeGoals !== void 0) out.activeGoals = parseGoalActivations(r.activeGoals);
   return Object.keys(out).length > 0 ? out : void 0;
 }
@@ -2022,12 +2022,16 @@ function getCompanyStoreRoot() {
 function getCompanyStoreAssetRoot(kind) {
   const root = getCompanyStoreRoot();
   if (!root) return null;
+  const manifestRoot = resolveManifestAssetRoot(root, kind);
+  if (manifestRoot) return manifestRoot;
   const folderByKind = {
     capabilities: "capabilities",
     goals: "goals",
     agents: "agents",
     workflows: "workflows"
   };
+  const rootLayoutPath = path7.join(root, folderByKind[kind]);
+  if (fs5.existsSync(rootLayoutPath)) return rootLayoutPath;
   return path7.join(root, ".kody", folderByKind[kind]);
 }
 function resolveCompanyStore() {
@@ -2065,9 +2069,27 @@ function fetchCompanyStore(repo, ref) {
 function localStoreRoot(repo) {
   if (!path7.isAbsolute(repo) && !repo.startsWith(".")) return null;
   const root = path7.resolve(repo);
-  if (!fs5.existsSync(path7.join(root, ".kody"))) return null;
+  if (!fs5.existsSync(path7.join(root, ".kody")) && !fs5.existsSync(path7.join(root, STORE_MANIFEST))) return null;
   return root;
 }
+function resolveManifestAssetRoot(root, kind) {
+  const manifestPath = path7.join(root, STORE_MANIFEST);
+  if (!fs5.existsSync(manifestPath)) return null;
+  try {
+    const raw = JSON.parse(fs5.readFileSync(manifestPath, "utf8"));
+    const candidates = kind === "agents" ? ["agents", "agent"] : [kind];
+    for (const key of candidates) {
+      const value = raw.assetRoots?.[key];
+      if (typeof value !== "string" || !value.trim()) continue;
+      return path7.resolve(root, value);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[company-store] failed to read ${manifestPath}: ${msg}
+`);
+  }
+  return null;
+}
 function repoToGitUrl(repo) {
   if (/^(https?:|ssh:|git@|file:)/.test(repo)) return repo;
   if (isGitHubShorthand(repo)) {
@@ -2098,7 +2120,7 @@ function setupGithubGitAuth() {
   } catch {
   }
 }
-var DEFAULT_COMPANY_STORE, DEFAULT_COMPANY_STORE_REF, STORE_ENV, REF_ENV, CACHE_ENV, memo;
+var DEFAULT_COMPANY_STORE, DEFAULT_COMPANY_STORE_REF, STORE_ENV, REF_ENV, CACHE_ENV, STORE_MANIFEST, memo;
 var init_companyStore = __esm({
   "src/companyStore.ts"() {
     "use strict";
@@ -2107,6 +2129,7 @@ var init_companyStore = __esm({
     STORE_ENV = "KODY_COMPANY_STORE";
     REF_ENV = "KODY_COMPANY_STORE_REF";
     CACHE_ENV = "KODY_COMPANY_STORE_CACHE";
+    STORE_MANIFEST = "kody-store.json";
     memo = null;
   }
 });
@@ -2153,11 +2176,7 @@ function getBuiltinCapabilitiesRoot() {
 function getExecutableRoots() {
   const projectCapabilitiesRoot = getProjectCapabilitiesRoot();
   const storeCapabilitiesRoot = getCompanyStoreCapabilitiesRoot();
-  return [
-    projectCapabilitiesRoot,
-    ...storeCapabilitiesRoot ? [storeCapabilitiesRoot] : [],
-    getExecutablesRoot()
-  ];
+  return [projectCapabilitiesRoot, ...storeCapabilitiesRoot ? [storeCapabilitiesRoot] : [], getExecutablesRoot()];
 }
 function getCapabilityRoots(projectCapabilitiesRoot = getProjectCapabilitiesRoot()) {
   const storeCapabilitiesRoot = getCompanyStoreCapabilitiesRoot();
@@ -2207,8 +2226,7 @@ function listCapabilityActions(projectCapabilitiesRoot = getProjectCapabilitiesR
     seen.add(action.action);
     out.push(action);
   };
-  for (const action of listFolderCapabilityActions(projectCapabilitiesRoot, "project-folder"))
-    add(action);
+  for (const action of listFolderCapabilityActions(projectCapabilitiesRoot, "project-folder")) add(action);
   const storeCapabilitiesRoot = getCompanyStoreCapabilitiesRoot();
   if (storeCapabilitiesRoot) {
     for (const action of listFolderCapabilityActions(storeCapabilitiesRoot, "company-store")) add(action);
@@ -2265,7 +2283,9 @@ function isSafeName(name) {
 }
 function isCapabilityRoot(root) {
   const normalized = path8.normalize(root);
-  return path8.basename(normalized) === "capabilities" && path8.basename(path8.dirname(normalized)) === ".kody";
+  if (path8.basename(normalized) === "capabilities") return true;
+  const knownRoots = [getProjectCapabilitiesRoot(), getCompanyStoreCapabilitiesRoot(), getBuiltinCapabilitiesRoot()];
+  return knownRoots.some((candidate) => candidate && path8.normalize(candidate) === normalized);
 }
 function isImplementationProfile(profilePath, requireImplementationProfile) {
   if (!requireImplementationProfile) return true;
@@ -3124,7 +3144,7 @@ async function runAgent(opts) {
     let noWorkSuccess = false;
     try {
       const queryOptions = {
-        model: opts.model.model,
+        model: opts.litellmUrl ? litellmModelGroup(opts.model) : opts.model.model,
         cwd: opts.cwd,
         // Fresh array (never mutate the shared DEFAULT_ALLOWED_TOOLS const) so
         // opt-in tools like fetch_repo can be appended below.
@@ -3470,23 +3490,77 @@ var init_agent = __esm({
   }
 });
 
+// src/agents.ts
+import * as fs9 from "fs";
+import * as path11 from "path";
+function stripFrontmatter(raw) {
+  const match = /^---\n[\s\S]*?\n---\n?([\s\S]*)$/.exec(raw);
+  return (match ? match[1] : raw).trim();
+}
+function loadAgentIdentity(cwd, slug2, agentsDir = DEFAULT_AGENT_DIR) {
+  const trimmed = slug2.trim();
+  if (!trimmed) throw new Error("loadAgentIdentity: empty agent slug");
+  const agentPath = resolveAgentFile(cwd, trimmed, agentsDir);
+  if (fs9.existsSync(agentPath)) {
+    const body = stripFrontmatter(fs9.readFileSync(agentPath, "utf-8"));
+    if (body) return body;
+    const builtinForEmpty = BUILTIN_AGENTS[trimmed];
+    if (builtinForEmpty) return builtinForEmpty;
+    throw new Error(`loadAgentIdentity: agent '${trimmed}' agent identity body is empty (${agentPath})`);
+  }
+  const builtin = BUILTIN_AGENTS[trimmed];
+  if (builtin) return builtin;
+  throw new Error(`loadAgentIdentity: agent '${trimmed}' declared but ${agentPath} does not exist`);
+}
+function resolveAgentFile(cwd, slug2, agentsDir = DEFAULT_AGENT_DIR) {
+  const localPath = path11.join(cwd, agentsDir, `${slug2}.md`);
+  if (fs9.existsSync(localPath)) return localPath;
+  const storeAgentRoot = getCompanyStoreAssetRoot("agents");
+  if (storeAgentRoot) {
+    const storePath = path11.join(storeAgentRoot, `${slug2}.md`);
+    if (fs9.existsSync(storePath)) return storePath;
+  }
+  return localPath;
+}
+function frameAgentIdentity(slug2, agent) {
+  return [
+    `## Who you are \u2014 agent identity (authoritative identity)`,
+    ``,
+    `You are operating as agent \`${slug2}\`. This identity defines *who* you are:`,
+    `your authority, doctrine, voice, and hard limits. Honour it exactly. Where the`,
+    `this identity's restrictions are stricter than the task, **the agent wins** \u2014 a task`,
+    `can never grant you authority your agent withholds.`,
+    ``,
+    agent
+  ].join("\n");
+}
+var DEFAULT_AGENT_DIR, BUILTIN_AGENTS;
+var init_agents = __esm({
+  "src/agents.ts"() {
+    "use strict";
+    init_companyStore();
+    DEFAULT_AGENT_DIR = ".kody/agents";
+    BUILTIN_AGENTS = {};
+  }
+});
+
 // src/task-artifacts.ts
-import fs9 from "fs";
-import path11 from "path";
+import fs10 from "fs";
+import path12 from "path";
 import posixPath from "path/posix";
 function prepareTaskArtifactsDir(cwd, taskId) {
   const safeId = String(taskId).replace(/[^a-zA-Z0-9._-]/g, "_");
   const absDir = runtimeStatePath(cwd, "task-artifacts", safeId);
   const relDir = absDir;
-  fs9.mkdirSync(absDir, { recursive: true });
+  fs10.mkdirSync(absDir, { recursive: true });
   return { taskId: safeId, absDir, relDir };
 }
 function verifyTaskArtifacts(absDir) {
   const missing = [];
   for (const name of TASK_ARTIFACT_FILES) {
-    const full = path11.join(absDir, name);
+    const full = path12.join(absDir, name);
     try {
-      const stat = fs9.statSync(full);
+      const stat = fs10.statSync(full);
       if (!stat.isFile() || stat.size === 0) missing.push(name);
     } catch {
       missing.push(name);
@@ -3499,11 +3573,11 @@ function taskArtifactStatePath(taskId, file) {
 }
 function persistTaskArtifactsToState(config, cwd, artifacts) {
   for (const file of TASK_ARTIFACT_FILES) {
-    const full = path11.join(artifacts.absDir, file);
-    if (!fs9.existsSync(full)) continue;
-    const stat = fs9.statSync(full);
+    const full = path12.join(artifacts.absDir, file);
+    if (!fs10.existsSync(full)) continue;
+    const stat = fs10.statSync(full);
     if (!stat.isFile() || stat.size === 0) continue;
-    const content = fs9.readFileSync(full, "utf-8");
+    const content = fs10.readFileSync(full, "utf-8");
     upsertStateText(
       config,
       cwd,
@@ -3583,7 +3657,7 @@ var init_task_artifacts = __esm({
 
 // src/gha.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -3594,10 +3668,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs15.existsSync(eventPath)) return;
+  if (!eventPath || !fs16.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs15.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs16.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -3648,60 +3722,6 @@ var init_gha = __esm({
   }
 });
 
-// src/agents.ts
-import * as fs16 from "fs";
-import * as path16 from "path";
-function stripFrontmatter(raw) {
-  const match = /^---\n[\s\S]*?\n---\n?([\s\S]*)$/.exec(raw);
-  return (match ? match[1] : raw).trim();
-}
-function loadAgentIdentity(cwd, slug2, agentsDir = DEFAULT_AGENT_DIR) {
-  const trimmed = slug2.trim();
-  if (!trimmed) throw new Error("loadAgentIdentity: empty agent slug");
-  const agentPath = resolveAgentFile(cwd, trimmed, agentsDir);
-  if (fs16.existsSync(agentPath)) {
-    const body = stripFrontmatter(fs16.readFileSync(agentPath, "utf-8"));
-    if (body) return body;
-    const builtinForEmpty = BUILTIN_AGENTS[trimmed];
-    if (builtinForEmpty) return builtinForEmpty;
-    throw new Error(`loadAgentIdentity: agent '${trimmed}' agent identity body is empty (${agentPath})`);
-  }
-  const builtin = BUILTIN_AGENTS[trimmed];
-  if (builtin) return builtin;
-  throw new Error(`loadAgentIdentity: agent '${trimmed}' declared but ${agentPath} does not exist`);
-}
-function resolveAgentFile(cwd, slug2, agentsDir = DEFAULT_AGENT_DIR) {
-  const localPath = path16.join(cwd, agentsDir, `${slug2}.md`);
-  if (fs16.existsSync(localPath)) return localPath;
-  const storeAgentRoot = getCompanyStoreAssetRoot("agents");
-  if (storeAgentRoot) {
-    const storePath = path16.join(storeAgentRoot, `${slug2}.md`);
-    if (fs16.existsSync(storePath)) return storePath;
-  }
-  return localPath;
-}
-function frameAgentIdentity(slug2, agent) {
-  return [
-    `## Who you are \u2014 agent identity (authoritative identity)`,
-    ``,
-    `You are operating as agent \`${slug2}\`. This identity defines *who* you are:`,
-    `your authority, doctrine, voice, and hard limits. Honour it exactly. Where the`,
-    `this identity's restrictions are stricter than the task, **the agent wins** \u2014 a task`,
-    `can never grant you authority your agent withholds.`,
-    ``,
-    agent
-  ].join("\n");
-}
-var DEFAULT_AGENT_DIR, BUILTIN_AGENTS;
-var init_agents = __esm({
-  "src/agents.ts"() {
-    "use strict";
-    init_companyStore();
-    DEFAULT_AGENT_DIR = ".kody/agents";
-    BUILTIN_AGENTS = {};
-  }
-});
-
 // src/capabilityReport.ts
 function parseCapabilityReportsFromText(text) {
   const reports = [];
@@ -5899,6 +5919,7 @@ var init_lifecycleLabels = __esm({
 // src/litellm.ts
 import { execFileSync as execFileSync5, spawn as spawn3 } from "child_process";
 import * as fs23 from "fs";
+import * as net from "net";
 import * as os5 from "os";
 import * as path22 from "path";
 async function checkLitellmHealth(url) {
@@ -5917,10 +5938,11 @@ function resolveLitellmTimeoutMs() {
 function generateLitellmConfigYaml(model) {
   const apiKeyVar = model.apiKeyEnvVar ?? providerApiKeyEnvVar(model.provider);
   const litellmProvider = model.litellmProvider ?? model.provider;
+  const modelGroup = litellmModelGroup(model);
   const providerParams = model.baseURL ? [["api_base", model.baseURL]] : [];
   return [
     "model_list:",
-    `  - model_name: ${model.model}`,
+    `  - model_name: ${modelGroup}`,
     `    litellm_params:`,
     `      model: ${litellmProvider}/${model.model}`,
     `      api_key: os.environ/${apiKeyVar}`,
@@ -5931,6 +5953,16 @@ function generateLitellmConfigYaml(model) {
     ""
   ].join("\n");
 }
+async function litellmServesModel(url, modelGroup) {
+  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);
+  } catch {
+    return false;
+  }
+}
 function litellmImportable() {
   try {
     execFileSync5("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
@@ -5982,12 +6014,14 @@ function resolveLitellmCommand() {
 async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL) {
   if (!needsLitellmProxy(model)) return null;
   const cmd = resolveLitellmCommand();
-  const portMatch = url.match(/:(\d+)/);
-  const port = portMatch ? portMatch[1] : "4000";
+  let activeUrl = url.replace(/\/+$/, "");
+  const modelGroup = litellmModelGroup(model);
   const childEnv = stripBlockingEnv({ ...process.env, ...readDotenvApiKeys(projectDir) });
   let child;
   let logPath;
   const spawnProxy = () => {
+    const portMatch = activeUrl.match(/:(\d+)/);
+    const port = portMatch ? portMatch[1] : "4000";
     const configPath = path22.join(os5.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
     fs23.writeFileSync(configPath, generateLitellmConfigYaml(model));
     const args = ["--config", configPath, "--port", port];
@@ -6001,7 +6035,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
     const deadline = Date.now() + resolveLitellmTimeoutMs();
     while (Date.now() < deadline) {
       await new Promise((r) => setTimeout(r, LITELLM_HEALTH_POLL_INTERVAL_MS));
-      if (await checkLitellmHealth(url)) return true;
+      if (await checkLitellmHealth(activeUrl)) return true;
     }
     return false;
   };
@@ -6032,7 +6066,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
     }, 2e3).unref?.();
   };
   const ensureHealthy = async () => {
-    if (await checkLitellmHealth(url)) return true;
+    if (await checkLitellmHealth(activeUrl)) return true;
     const tail = readLogTail();
     process.stderr.write(
       `[kody litellm] proxy unreachable mid-run; restarting.${tail ? ` Last log:
@@ -6043,9 +6077,17 @@ ${tail}
     spawnProxy();
     return waitForHealth();
   };
-  const isHealthy = () => checkLitellmHealth(url);
-  if (await checkLitellmHealth(url)) {
-    return { url, kill: killChild, isHealthy, ensureHealthy };
+  const isHealthy = () => checkLitellmHealth(activeUrl);
+  if (await checkLitellmHealth(activeUrl)) {
+    if (await litellmServesModel(activeUrl, modelGroup)) {
+      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}
+`
+    );
   }
   spawnProxy();
   if (!await waitForHealth()) {
@@ -6057,7 +6099,30 @@ ${tail}
 ${tail}`
     );
   }
-  return { url, kill: killChild, isHealthy, ensureHealthy };
+  return { url: activeUrl, kill: killChild, isHealthy, ensureHealthy };
+}
+async function nextAvailableLitellmUrl(url) {
+  const parsed = new URL(url);
+  const startPort = Number(parsed.port || "4000");
+  const host = parsed.hostname === "localhost" ? "127.0.0.1" : parsed.hostname;
+  for (let offset = 1; offset <= 50; offset++) {
+    const port = startPort + offset;
+    if (await canListen(port, host)) {
+      parsed.port = String(port);
+      return parsed.origin;
+    }
+  }
+  throw new Error(`no free LiteLLM port found after ${startPort}`);
+}
+function canListen(port, host) {
+  return new Promise((resolve10) => {
+    const server = net.createServer();
+    server.once("error", () => resolve10(false));
+    server.once("listening", () => {
+      server.close(() => resolve10(true));
+    });
+    server.listen(port, host);
+  });
 }
 function readDotenvApiKeys(projectDir) {
   const dotenvPath = path22.join(projectDir, ".env");
@@ -7638,8 +7703,7 @@ var init_typeDefinitions = __esm({
             stage: "publish",
             evidence: "productionDeployed",
             capability: "vercel-production-deploy",
-            executable: "vercel-production-deploy",
-            args: { goal: { fact: "goalId" } }
+            executable: "vercel-production-deploy"
           }
         ]
       },
@@ -8655,7 +8719,8 @@ var init_advanceManagedGoal = __esm({
         capability: decision.capability,
         cliArgs: decision.cliArgs,
         ...decision.executable ? { executable: decision.executable } : {},
-        ...decision.saveReport === true ? { saveReport: true } : {}
+        ...decision.saveReport === true ? { saveReport: true } : {},
+        resultTarget: { type: "goal", id: goal.id, evidence: decision.evidence }
       };
       ctx.output.reason = `dispatch ${decision.capability} for ${decision.evidence}`;
     };
@@ -9632,6 +9697,18 @@ function collectResults(raw, agentResult) {
   if (agentResult?.finalText) out.push(...parseCapabilityResultsFromText(agentResult.finalText));
   return out;
 }
+function parseResultTarget(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const target = raw;
+  if (target.type !== "goal") return null;
+  if (typeof target.id !== "string" || target.id.trim().length === 0) return null;
+  const evidence = typeof target.evidence === "string" && target.evidence.trim().length > 0 ? target.evidence.trim() : void 0;
+  return {
+    type: "goal",
+    id: target.id.trim(),
+    ...evidence ? { evidence } : {}
+  };
+}
 function collectGoalCapabilityEvidence(reports, results, fallbackGoalId, explicitEvidence) {
   const items = [];
   for (const report of reports) {
@@ -9725,8 +9802,9 @@ var init_applyCapabilityReports = __esm({
     applyCapabilityReports = async (ctx, _profile, agentResult) => {
       const reports = collectReports(ctx.data.capabilityReports, agentResult);
       const results = collectResults(ctx.data.capabilityResults ?? ctx.data.dutyResults, agentResult);
-      const resultGoalId = typeof ctx.args.goal === "string" && ctx.args.goal.length > 0 ? ctx.args.goal : null;
-      const explicitEvidence = typeof ctx.args.evidence === "string" && ctx.args.evidence.length > 0 ? ctx.args.evidence : void 0;
+      const resultTarget = parseResultTarget(ctx.data.capabilityResultTarget);
+      const resultGoalId = resultTarget?.id ?? (typeof ctx.args.goal === "string" && ctx.args.goal.length > 0 ? ctx.args.goal : null);
+      const explicitEvidence = resultTarget?.evidence ?? (typeof ctx.args.evidence === "string" && ctx.args.evidence.length > 0 ? ctx.args.evidence : void 0);
       const evidenceItems = collectGoalCapabilityEvidence(reports, results, resultGoalId, explicitEvidence);
       if (evidenceItems.length === 0) return;
       const evidenceByGoal = groupGoalEvidence(evidenceItems);
@@ -12566,7 +12644,7 @@ function makeConfig(pm, ownerRepo, defaultBranch) {
       repo: ownerRepo?.repo ?? "REPO"
     },
     agent: {
-      model: "minimax/MiniMax-M2.7-highspeed"
+      model: "minimax/MiniMax-M3"
     }
   };
 }
@@ -18337,7 +18415,8 @@ function handoffToJob(handoff) {
     executable: handoff.executable,
     cliArgs: handoff.cliArgs,
     flavor: "instant",
-    saveReport: handoff.saveReport === true
+    saveReport: handoff.saveReport === true,
+    resultTarget: handoff.resultTarget
   };
 }
 function clearStampedLifecycleLabels(profile, ctx) {
@@ -18752,7 +18831,20 @@ function validateJob(input) {
     cliArgs: j.cliArgs ?? {},
     flavor: j.flavor,
     force: j.force === true,
-    saveReport: j.saveReport === true
+    saveReport: j.saveReport === true,
+    resultTarget: parseCapabilityResultTarget(j.resultTarget)
+  };
+}
+function parseCapabilityResultTarget(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const target = raw;
+  if (target.type !== "goal") return void 0;
+  if (typeof target.id !== "string" || target.id.trim().length === 0) return void 0;
+  const evidence = typeof target.evidence === "string" && target.evidence.trim().length > 0 ? target.evidence.trim() : void 0;
+  return {
+    type: "goal",
+    id: target.id.trim(),
+    ...evidence ? { evidence } : {}
   };
 }
 async function runJob(job, base) {
@@ -18812,6 +18904,7 @@ async function runCapabilityImplementationStep(valid, profileName, capabilityIde
   preloadedData.jobExecutable = profileName;
   if (valid.schedule !== void 0 && valid.schedule.length > 0) preloadedData.jobSchedule = valid.schedule;
   if (valid.saveReport === true) preloadedData.jobSaveReport = true;
+  if (valid.resultTarget) preloadedData.capabilityResultTarget = valid.resultTarget;
   if (capabilityContext) {
     preloadedData.capabilitySlug = capabilityContext.slug;
     preloadedData.capabilityTitle = capabilityContext.title;
@@ -19067,7 +19160,7 @@ var init_job = __esm({
 init_package();
 
 // src/servers/brain-proxy.ts
-import { createServer as createServer2 } from "http";
+import { createServer as createServer3 } from "http";
 import { URL as URL2 } from "url";
 
 // src/servers/brain-protocol.ts
@@ -19171,20 +19264,22 @@ function translateOpenAISseToBrain(opts) {
 
 // src/servers/brain-serve.ts
 import * as fs48 from "fs";
-import { createServer } from "http";
+import { createServer as createServer2 } from "http";
 import * as path47 from "path";
 
 // src/chat/loop.ts
 init_agent();
+init_agents();
+init_config();
 init_registry();
 init_task_artifacts();
-import * as fs13 from "fs";
-import * as path15 from "path";
+import * as fs14 from "fs";
+import * as path16 from "path";
 
 // src/chat/attachments.ts
 init_runtimePaths();
-import * as fs10 from "fs";
-import * as path12 from "path";
+import * as fs11 from "fs";
+import * as path13 from "path";
 var INLINE_ATTACHMENT_RE = /(?:\[(?:Image|File): ([^\]]*)\]\n)?data:([\w.+-]+\/[\w.+-]+);base64,([A-Za-z0-9+/=]+)/g;
 var EXT_BY_MIME = {
   "image/png": "png",
@@ -19217,11 +19312,11 @@ function prepareAttachments(turns, cwd, sessionId) {
         if (!isImage) return `[File: ${name}]`;
         try {
           if (!dirEnsured) {
-            fs10.mkdirSync(dir, { recursive: true });
+            fs11.mkdirSync(dir, { recursive: true });
             dirEnsured = true;
           }
-          const filePath = path12.join(dir, `${imageCounter}.${extFor(mime)}`);
-          fs10.writeFileSync(filePath, Buffer.from(data, "base64"));
+          const filePath = path13.join(dir, `${imageCounter}.${extFor(mime)}`);
+          fs11.writeFileSync(filePath, Buffer.from(data, "base64"));
           imageCounter += 1;
           imagePaths.push(filePath);
           return `[Image "${name}" is attached \u2014 saved to ${filePath}. Use the Read tool on that exact path to view it.]`;
@@ -19237,11 +19332,11 @@ function prepareAttachments(turns, cwd, sessionId) {
 }
 
 // src/chat/events.ts
-import * as fs11 from "fs";
-import * as path13 from "path";
+import * as fs12 from "fs";
+import * as path14 from "path";
 import posixPath2 from "path/posix";
 function eventsFilePath(cwd, sessionId) {
-  return path13.join(cwd, ".kody", "events", `${sessionId}.jsonl`);
+  return path14.join(cwd, ".kody", "events", `${sessionId}.jsonl`);
 }
 function eventsStatePath(sessionId) {
   return posixPath2.join("events", `${sessionId}.jsonl`);
@@ -19252,8 +19347,8 @@ var FileSink = class {
   }
   file;
   async emit(event) {
-    fs11.mkdirSync(path13.dirname(this.file), { recursive: true });
-    fs11.appendFileSync(this.file, `${JSON.stringify(event)}
+    fs12.mkdirSync(path14.dirname(this.file), { recursive: true });
+    fs12.appendFileSync(this.file, `${JSON.stringify(event)}
 `);
   }
 };
@@ -19307,18 +19402,18 @@ function makeRunId(sessionId, suffix) {
 }
 
 // src/chat/session.ts
-import * as fs12 from "fs";
-import * as path14 from "path";
+import * as fs13 from "fs";
+import * as path15 from "path";
 import posixPath3 from "path/posix";
 function sessionFilePath(cwd, sessionId) {
-  return path14.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
+  return path15.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
 }
 function sessionStatePath(sessionId) {
   return posixPath3.join("sessions", `${sessionId}.jsonl`);
 }
 function readMeta(file) {
-  if (!fs12.existsSync(file)) return null;
-  const raw = fs12.readFileSync(file, "utf-8");
+  if (!fs13.existsSync(file)) return null;
+  const raw = fs13.readFileSync(file, "utf-8");
   const firstLine2 = raw.split("\n", 1)[0]?.trim();
   if (!firstLine2) return null;
   try {
@@ -19331,8 +19426,8 @@ function readMeta(file) {
   }
 }
 function readSession(file) {
-  if (!fs12.existsSync(file)) return [];
-  const raw = fs12.readFileSync(file, "utf-8").trim();
+  if (!fs13.existsSync(file)) return [];
+  const raw = fs13.readFileSync(file, "utf-8").trim();
   if (!raw) return [];
   const turns = [];
   for (const line of raw.split("\n")) {
@@ -19348,14 +19443,14 @@ function readSession(file) {
   return turns;
 }
 function appendTurn(file, turn) {
-  fs12.mkdirSync(path14.dirname(file), { recursive: true });
+  fs13.mkdirSync(path15.dirname(file), { recursive: true });
   const line = JSON.stringify({
     role: turn.role,
     content: turn.content,
     timestamp: turn.timestamp,
     toolCalls: turn.toolCalls ?? []
   });
-  fs12.appendFileSync(file, `${line}
+  fs13.appendFileSync(file, `${line}
 `);
 }
 function seedInitialMessage(file, message) {
@@ -19490,7 +19585,7 @@ function buildExecutableCatalog() {
   const entries = [];
   for (const { name, profilePath } of discovered) {
     try {
-      const raw = JSON.parse(fs13.readFileSync(profilePath, "utf-8"));
+      const raw = JSON.parse(fs14.readFileSync(profilePath, "utf-8"));
       const describe = typeof raw.describe === "string" ? raw.describe : "";
       const firstSentence = describe.split(/(?<=[.!?])\s+/, 1)[0] ?? "";
       entries.push({ name, describe: firstSentence.trim() });
@@ -19527,6 +19622,7 @@ async function runChatTurn(opts) {
   }
   const { turns: promptTurns, imagePaths } = prepareAttachments(turns, opts.cwd, opts.sessionId);
   const basePrompt = opts.systemPrompt ?? (opts.model.protocol === "openai" ? OPENAI_CHAT_SYSTEM_PROMPT : CHAT_SYSTEM_PROMPT);
+  const agentIdentityBlock = readAgentIdentityBlock(opts.cwd, opts.agentIdentity);
   const catalog = buildExecutableCatalog();
   const taskArtifactsPaths = prepareTaskArtifactsDir(opts.cwd, opts.sessionId);
   const artifactAddendum = taskArtifactsPromptAddendum({
@@ -19537,7 +19633,8 @@ async function runChatTurn(opts) {
   const contextBlock = readContextBlock(opts.cwd);
   const memoryBlock = readMemoryIndexBlock(opts.cwd);
   const instructionsBlock = readInstructionsBlock(opts.cwd);
-  const crossRepoBlock = opts.reposRoot ? CROSS_REPO_PROMPT : null;
+  const fetchRepoEnabled = Boolean(opts.enableFetchRepoTool && opts.reposRoot);
+  const crossRepoBlock = fetchRepoEnabled ? CROSS_REPO_PROMPT : null;
   const dashboardCmsEnabled = Boolean(opts.cmsDashboardUrl && opts.cmsRepoSlug && opts.cmsToken);
   const dashboardCmsBlock = dashboardCmsEnabled ? DASHBOARD_CMS_PROMPT : null;
   const imageBlock = imagePaths.length > 0 ? [
@@ -19550,6 +19647,7 @@ async function runChatTurn(opts) {
   ].join("\n") : null;
   const systemPrompt = [
     basePrompt,
+    agentIdentityBlock,
     contextBlock,
     memoryBlock,
     instructionsBlock,
@@ -19578,14 +19676,14 @@ async function runChatTurn(opts) {
     quiet: opts.quiet,
     additionalDirectories: [
       taskArtifactsPaths.absDir,
-      ...Array.from(new Set(imagePaths.map((p2) => path15.dirname(p2))))
+      ...Array.from(new Set(imagePaths.map((p2) => path16.dirname(p2))))
     ],
     systemPromptAppend: systemPrompt,
     ...opts.reasoningEffort ? { reasoningEffort: opts.reasoningEffort } : {},
-    // Let the agent clone + work on OTHER repos mid-conversation (a
-    // repo-less Brain serves many). Enabled whenever we know where repos
-    // live; grants read access to that root via additionalDirectories.
-    ...opts.reposRoot ? {
+    // Cross-repo work is opt-in. Repo Brain's default path remains focused
+    // on the selected repo even though the server stores clones under
+    // reposRoot.
+    ...fetchRepoEnabled ? {
       enableFetchRepoTool: true,
       reposRoot: opts.reposRoot,
       repoToken: opts.repoToken
@@ -19670,6 +19768,12 @@ async function runChatTurn(opts) {
   }
   return { exitCode: 0, reply };
 }
+function readAgentIdentityBlock(cwd, agentIdentity) {
+  const slug2 = agentIdentity?.slug?.trim();
+  if (!slug2) return null;
+  const body = agentIdentity?.body?.trim() || loadAgentIdentity(cwd, slug2);
+  return frameAgentIdentity(slug2, body);
+}
 async function runOpenAIChatTurn(args) {
   const { opts, turns, systemPrompt, sessionFile } = args;
   const doFetch = opts.fetchImpl ?? fetch;
@@ -19679,7 +19783,7 @@ async function runOpenAIChatTurn(args) {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        model: opts.model.model,
+        model: litellmModelGroup(opts.model),
         messages: [
           { role: "system", content: systemPrompt },
           ...turns.map((turn) => ({
@@ -19755,10 +19859,10 @@ async function emit(sink, type, sessionId, suffix, payload) {
 var MEMORY_INDEX_REL = ".kody/memory/INDEX.md";
 var MAX_INDEX_BYTES = 8e3;
 function readMemoryIndexBlock(cwd) {
-  const indexPath = path15.join(cwd, MEMORY_INDEX_REL);
+  const indexPath = path16.join(cwd, MEMORY_INDEX_REL);
   let raw;
   try {
-    raw = fs13.readFileSync(indexPath, "utf-8");
+    raw = fs14.readFileSync(indexPath, "utf-8");
   } catch {
     return "";
   }
@@ -19778,17 +19882,17 @@ _\u2026 (memory index truncated; use recall_search to read more)_` : trimmed;
 var CONTEXT_DIR_REL = ".kody/context";
 var MAX_CONTEXT_BYTES = 12e3;
 function readContextBlock(cwd) {
-  const dir = path15.join(cwd, CONTEXT_DIR_REL);
+  const dir = path16.join(cwd, CONTEXT_DIR_REL);
   let files;
   try {
-    files = fs13.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    files = fs14.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const sections = [];
   for (const file of files) {
     try {
-      const content = fs13.readFileSync(path15.join(dir, file), "utf-8").trim();
+      const content = fs14.readFileSync(path16.join(dir, file), "utf-8").trim();
       if (content) sections.push(`### ${file.replace(/\.md$/, "")}
 
 ${content}`);
@@ -19811,10 +19915,10 @@ _\u2026 (context truncated; use the state repo context files for the full text)_
 var INSTRUCTIONS_REL = ".kody/instructions.md";
 var MAX_INSTRUCTIONS_BYTES = 8e3;
 function readInstructionsBlock(cwd) {
-  const instructionsPath = path15.join(cwd, INSTRUCTIONS_REL);
+  const instructionsPath = path16.join(cwd, INSTRUCTIONS_REL);
   let raw;
   try {
-    raw = fs13.readFileSync(instructionsPath, "utf-8");
+    raw = fs14.readFileSync(instructionsPath, "utf-8");
   } catch {
     return "";
   }
@@ -19915,7 +20019,7 @@ init_config();
 
 // src/dispatch.ts
 init_config();
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 
 // src/cron-match.ts
 var FIELD_BOUNDS = [
@@ -20017,10 +20121,10 @@ function autoDispatch(opts) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs14.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs15.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs14.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs15.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -20131,7 +20235,7 @@ function autoDispatchTyped(opts) {
   if (legacy) return { kind: "route", ...legacy };
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs14.existsSync(eventPath)) {
+  if (!eventName || !eventPath || !fs15.existsSync(eventPath)) {
     return { kind: "silent", reason: "no GHA event context" };
   }
   if (eventName !== "issue_comment") {
@@ -20139,7 +20243,7 @@ function autoDispatchTyped(opts) {
   }
   let event = {};
   try {
-    event = JSON.parse(fs14.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs15.readFileSync(eventPath, "utf-8"));
   } catch {
     return { kind: "silent", reason: "GHA event payload unreadable" };
   }
@@ -20183,7 +20287,7 @@ function dispatchScheduledWatches(opts) {
   for (const exe of listExecutables()) {
     let raw;
     try {
-      raw = fs14.readFileSync(exe.profilePath, "utf-8");
+      raw = fs15.readFileSync(exe.profilePath, "utf-8");
     } catch {
       continue;
     }
@@ -21266,6 +21370,19 @@ function strField(body, key) {
   }
   return void 0;
 }
+function boolField(body, key) {
+  return typeof body === "object" && body !== null && body[key] === true;
+}
+function agentIdentityField(body) {
+  if (typeof body !== "object" || body === null || !("agentIdentity" in body)) return void 0;
+  const value = body.agentIdentity;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const record2 = value;
+  const slug2 = typeof record2.slug === "string" ? record2.slug.trim() : "";
+  const bodyText = typeof record2.body === "string" ? record2.body.trim() : "";
+  if (!slug2 || !bodyText) return void 0;
+  return { slug: slug2, body: bodyText };
+}
 function sendJson(res, status, body) {
   res.writeHead(status, { "content-type": "application/json" });
   res.end(JSON.stringify(body));
@@ -21400,6 +21517,8 @@ async function handleChatTurn(req, res, chatId, opts) {
   const dashboardUrl = strField(body, "dashboardUrl");
   const storeRepoUrl = strField(body, "storeRepoUrl");
   const storeRef = strField(body, "storeRef");
+  const allowCrossRepo = boolField(body, "allowCrossRepo");
+  const agentIdentity = agentIdentityField(body);
   let agentCwd;
   try {
     agentCwd = await ensureRepoCwd({
@@ -21474,9 +21593,12 @@ async function handleChatTurn(req, res, chatId, opts) {
         model: opts.model,
         litellmUrl: opts.litellmUrl,
         sink,
-        // Let the agent clone + work on OTHER repos via the fetch_repo tool.
         reposRoot: opts.reposRoot,
+        // Repo Brain is selected-repo focused by default. Higher-level
+        // coordinator flows can opt into fetch_repo explicitly.
+        ...allowCrossRepo ? { enableFetchRepoTool: true } : {},
         repoToken,
+        ...agentIdentity ? { agentIdentity } : {},
         ...dashboardUrl && repo && stateToken ? {
           cmsDashboardUrl: dashboardUrl,
           cmsRepoSlug: repo,
@@ -21529,7 +21651,7 @@ function buildServer(opts) {
   const runTurn = opts.runTurn ?? runChatTurn;
   const cloneRepo = opts.cloneRepo ?? defaultCloneRepo;
   const reposRoot = opts.reposRoot ?? path47.join(path47.dirname(path47.resolve(opts.cwd)), "repos");
-  return createServer(async (req, res) => {
+  return createServer2(async (req, res) => {
     if (!req.method || !req.url) {
       sendJson(res, 400, { error: "bad request" });
       return;
@@ -21727,7 +21849,7 @@ function buildBrainProxy(opts) {
     res.writeHead(404, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ error: "not found" }));
   };
-  const httpServer = createServer2((req, res) => {
+  const httpServer = createServer3((req, res) => {
     void handler(req, res);
   });
   return { httpServer, handler };
@@ -21746,7 +21868,9 @@ async function proxyToBrainServe(args) {
       ...args.body.repoToken ? { repoToken: args.body.repoToken } : {},
       ...args.body.dashboardUrl ? { dashboardUrl: args.body.dashboardUrl } : {},
       ...args.body.storeRepoUrl ? { storeRepoUrl: args.body.storeRepoUrl } : {},
-      ...args.body.storeRef ? { storeRef: args.body.storeRef } : {}
+      ...args.body.storeRef ? { storeRef: args.body.storeRef } : {},
+      ...args.body.allowCrossRepo === true ? { allowCrossRepo: true } : {},
+      ...args.body.agentIdentity ? { agentIdentity: args.body.agentIdentity } : {}
     })
   });
   if (!upstream.ok || !upstream.body) {
@@ -21948,7 +22072,7 @@ init_fetchRepoMcp();
 
 // src/servers/mcpHttpServer.ts
 import { randomUUID } from "crypto";
-import { createServer as createServer3 } from "http";
+import { createServer as createServer4 } from "http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 function buildMcpHttpServer(opts) {
@@ -22007,7 +22131,7 @@ function buildMcpHttpServer(opts) {
       res.end(JSON.stringify({ error: "internal error" }));
     }
   };
-  const httpServer = createServer3((req, res) => {
+  const httpServer = createServer4((req, res) => {
     if (req.url === "/healthz" || req.url === "/health") {
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ ok: true, routes: Array.from(routes.keys()) }));
@@ -22600,7 +22724,7 @@ init_job();
 init_registry();
 
 // src/servers/pool-serve.ts
-import { createServer as createServer4 } from "http";
+import { createServer as createServer5 } from "http";
 
 // src/github-health.ts
 var STATUS_URL = "https://www.githubstatus.com/api/v2/components.json";
@@ -23430,7 +23554,7 @@ async function poolServe() {
       (err) => log(`capability fallback tick failed: ${err instanceof Error ? err.message : String(err)}`)
     );
   }, capabilityTickMs) : null;
-  const server = createServer4(async (req, res) => {
+  const server = createServer5(async (req, res) => {
     try {
       if (!req.method || !req.url) return sendJson2(res, 400, { error: "bad request" });
       const url = new URL(req.url, "http://localhost");
@@ -23499,7 +23623,7 @@ async function poolServe() {
 // src/servers/runner-serve.ts
 import { spawn as spawn8 } from "child_process";
 import * as fs51 from "fs";
-import { createServer as createServer5 } from "http";
+import { createServer as createServer6 } from "http";
 var DEFAULT_PORT2 = 8080;
 var DEFAULT_WORKDIR = "/workspace/repo";
 function getApiKey3() {
@@ -23696,7 +23820,7 @@ async function defaultRunJob(job) {
 function buildServer2(opts) {
   const runJob2 = opts.runJob ?? defaultRunJob;
   let busy = false;
-  return createServer5(async (req, res) => {
+  return createServer6(async (req, res) => {
     if (!req.method || !req.url) {
       sendJson3(res, 400, { error: "bad request" });
       return;

package/dist/executables/types.ts

@@ -394,6 +394,12 @@ export interface OutputContract {
   }
 }
 
+export interface CapabilityResultTarget {
+  type: "goal"
+  id: string
+  evidence?: string
+}
+
 // ────────────────────────────────────────────────────────────────────────────
 // Run-time context passed to every script.
 // ────────────────────────────────────────────────────────────────────────────
@@ -429,6 +435,7 @@ export interface Context {
       executable?: string
       cliArgs: Record<string, unknown>
       saveReport?: boolean
+      resultTarget?: CapabilityResultTarget
     }
     /** In-process hand-off to a full Job, preserving job identity in task state. */
     nextJob?: Job
@@ -440,6 +447,7 @@ export interface Context {
       executable?: string
       cliArgs: Record<string, unknown>
       saveReport?: boolean
+      resultTarget?: CapabilityResultTarget
     }
   }
   /**
@@ -512,4 +520,6 @@ export interface Job {
   force?: boolean
   /** Ask the owning goal/loop to write a report run after its persisted decision. */
   saveReport?: boolean
+  /** Internal parent context used by postflights to attach neutral capability output. */
+  resultTarget?: CapabilityResultTarget
 }

package/package.json

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