@kody-ade/kody-engine 0.4.507 → 0.4.509

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.507",
+      version: "0.4.509",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -620,8 +620,9 @@ function formatResult(msg) {
 function summarizeToolInput(toolName, input = {}) {
   if (toolName === "Agent") {
     const agent = summarizeSingleLineValue(input.subagent_type, "unknown", 80);
-    const model = summarizeSingleLineValue(input.model, "inherit", 80);
-    return `: ${agent} model=${model}`;
+    const requestedModel = summarizeSingleLineValue(input.model, "inherit", 80);
+    const ignoredOverride = requestedModel === "inherit" ? "" : ` (ignored override=${requestedModel})`;
+    return `: ${agent} model=inherit${ignoredOverride}`;
   }
   if (toolName === "Bash" && typeof input.command === "string") {
     const cmd = input.command.split("\n")[0];
@@ -698,6 +699,178 @@ var init_runtimePaths = __esm({
   }
 });
 
+// src/scripts/buildSyntheticPlugin.ts
+import * as fs3 from "fs";
+import * as os3 from "os";
+import * as path4 from "path";
+function getPluginsCatalogRoot() {
+  const here = path4.dirname(new URL(import.meta.url).pathname);
+  const candidates = [
+    path4.join(here, "..", "plugins"),
+    // dev: src/scripts → src/plugins
+    path4.join(here, "..", "..", "plugins"),
+    // built: dist/scripts → dist/plugins
+    path4.join(here, "..", "..", "src", "plugins")
+    // fallback
+  ];
+  for (const c of candidates) {
+    if (fs3.existsSync(c) && fs3.statSync(c).isDirectory()) return c;
+  }
+  return candidates[0];
+}
+function copyDir(src, dst) {
+  fs3.mkdirSync(dst, { recursive: true });
+  for (const ent of fs3.readdirSync(src, { withFileTypes: true })) {
+    const s = path4.join(src, ent.name);
+    const d = path4.join(dst, ent.name);
+    if (ent.isDirectory()) copyDir(s, d);
+    else if (ent.isFile()) fs3.copyFileSync(s, d);
+  }
+}
+var buildSyntheticPlugin;
+var init_buildSyntheticPlugin = __esm({
+  "src/scripts/buildSyntheticPlugin.ts"() {
+    "use strict";
+    buildSyntheticPlugin = async (ctx, profile) => {
+      const cc = profile.claudeCode;
+      const needsSynthetic = cc.skills.length > 0 || cc.commands.length > 0 || cc.hooks.length > 0;
+      if (!needsSynthetic) return;
+      const catalog = getPluginsCatalogRoot();
+      const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const root = path4.join(os3.tmpdir(), `kody-synth-${runId}`);
+      fs3.mkdirSync(path4.join(root, ".claude-plugin"), { recursive: true });
+      const resolvePart = (bucket, entry) => {
+        const local = path4.join(profile.dir, bucket, entry);
+        if (fs3.existsSync(local)) return local;
+        const shared = path4.resolve(profile.dir, "..", "..", "shared", bucket, entry);
+        if (fs3.existsSync(shared)) return shared;
+        const central = path4.join(catalog, bucket, entry);
+        if (fs3.existsSync(central)) return central;
+        throw new Error(
+          `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in implementation dir (${profile.dir}/${bucket}/), Store shared assets (${path4.dirname(shared)}/), or catalog (${catalog}/${bucket}/)`
+        );
+      };
+      if (cc.skills.length > 0) {
+        const dst = path4.join(root, "skills");
+        fs3.mkdirSync(dst, { recursive: true });
+        for (const name of cc.skills) {
+          copyDir(resolvePart("skills", name), path4.join(dst, name));
+        }
+      }
+      if (cc.commands.length > 0) {
+        const dst = path4.join(root, "commands");
+        fs3.mkdirSync(dst, { recursive: true });
+        for (const name of cc.commands) {
+          fs3.copyFileSync(resolvePart("commands", `${name}.md`), path4.join(dst, `${name}.md`));
+        }
+      }
+      if (cc.hooks.length > 0) {
+        const dst = path4.join(root, "hooks");
+        fs3.mkdirSync(dst, { recursive: true });
+        const merged = { hooks: {} };
+        for (const name of cc.hooks) {
+          const src = resolvePart("hooks", `${name}.json`);
+          const parsed = JSON.parse(fs3.readFileSync(src, "utf-8"));
+          for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
+            if (!Array.isArray(entries)) continue;
+            if (!merged.hooks[event]) merged.hooks[event] = [];
+            merged.hooks[event].push(...entries);
+          }
+        }
+        fs3.writeFileSync(path4.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+`);
+      }
+      const manifest = {
+        name: `kody-synth-${profile.name}`,
+        version: "1.0.0",
+        description: `Synthetic plugin assembled by Kody for profile '${profile.name}' at runtime.`
+      };
+      if (cc.skills.length > 0) manifest.skills = ["./skills/"];
+      if (cc.commands.length > 0) manifest.commands = ["./commands/"];
+      fs3.writeFileSync(path4.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+      ctx.data.syntheticPluginPath = root;
+    };
+  }
+});
+
+// src/subagents.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+async function enforceSubagentModelInheritance(input) {
+  const toolInput = input.tool_input;
+  if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) return {};
+  const updatedInput = { ...toolInput };
+  delete updatedInput.model;
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      updatedInput
+    }
+  };
+}
+function splitFrontmatter(raw) {
+  const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(raw);
+  if (!match) return { fm: {}, body: raw.trim() };
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    fm[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+  return { fm, body: (match[2] ?? "").trim() };
+}
+function resolveAgentFile(profileDir, name) {
+  const local = path5.join(profileDir, "agents", `${name}.md`);
+  if (fs4.existsSync(local)) return local;
+  const shared = path5.resolve(profileDir, "..", "..", "shared", "agents", `${name}.md`);
+  if (fs4.existsSync(shared)) return shared;
+  const central = path5.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
+  if (fs4.existsSync(central)) return central;
+  throw new Error(
+    `loadSubagents: agent '${name}' not found in ${profileDir}/agents/, hydrated shared assets, or engine catalog`
+  );
+}
+function captureSubagentTemplates(profile) {
+  const names = profile.claudeCode.subagents;
+  if (!names || names.length === 0) return {};
+  const out = {};
+  for (const name of names) {
+    try {
+      out[name] = fs4.readFileSync(resolveAgentFile(profile.dir, name), "utf-8");
+    } catch {
+    }
+  }
+  return out;
+}
+function loadSubagents(profile) {
+  const names = profile.claudeCode.subagents;
+  if (!names || names.length === 0) return void 0;
+  const agents = {};
+  for (const name of names) {
+    const raw = profile.subagentTemplates?.[name] ?? fs4.readFileSync(resolveAgentFile(profile.dir, name), "utf-8");
+    const { fm, body } = splitFrontmatter(raw);
+    if (!body) throw new Error(`loadSubagents: agent '${name}' has an empty prompt body`);
+    const def = {
+      description: fm.description ?? `Subagent ${name}`,
+      prompt: body,
+      model: "inherit"
+    };
+    if (fm.tools) {
+      const tools = fm.tools.split(",").map((t) => t.trim()).filter(Boolean);
+      if (tools.length > 0) def.tools = tools;
+    }
+    agents[fm.name || name] = def;
+  }
+  return agents;
+}
+var init_subagents = __esm({
+  "src/subagents.ts"() {
+    "use strict";
+    init_buildSyntheticPlugin();
+  }
+});
+
 // src/events.ts
 var events_exports = {};
 __export(events_exports, {
@@ -708,8 +881,8 @@ __export(events_exports, {
   resolveRunId: () => resolveRunId
 });
 import * as crypto from "crypto";
-import * as fs3 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path6 from "path";
 function resolveRunId() {
   if (process.env.KODY_RUN_ID) {
     cachedRunId = process.env.KODY_RUN_ID;
@@ -742,16 +915,16 @@ function emitEvent(cwd, ev) {
       ...ev
     };
     const file = eventsPath(cwd, runId);
-    fs3.mkdirSync(path4.dirname(file), { recursive: true });
-    fs3.appendFileSync(file, `${JSON.stringify(fullEvent)}
+    fs5.mkdirSync(path6.dirname(file), { recursive: true });
+    fs5.appendFileSync(file, `${JSON.stringify(fullEvent)}
 `);
   } catch {
   }
 }
 function readEvents(cwd, runId) {
   const file = eventsPath(cwd, runId);
-  if (!fs3.existsSync(file)) return [];
-  const lines = fs3.readFileSync(file, "utf-8").split("\n");
+  if (!fs5.existsSync(file)) return [];
+  const lines = fs5.readFileSync(file, "utf-8").split("\n");
   const out = [];
   for (const line of lines) {
     const trimmed = line.trim();
@@ -765,10 +938,10 @@ function readEvents(cwd, runId) {
 }
 function listRuns(cwd) {
   const runsDir = runtimeStatePath(cwd, "agent-runs");
-  if (!fs3.existsSync(runsDir)) return [];
-  return fs3.readdirSync(runsDir).filter((name) => {
+  if (!fs5.existsSync(runsDir)) return [];
+  return fs5.readdirSync(runsDir).filter((name) => {
     try {
-      return fs3.statSync(path4.join(runsDir, name)).isDirectory();
+      return fs5.statSync(path6.join(runsDir, name)).isDirectory();
     } catch {
       return false;
     }
@@ -1690,8 +1863,8 @@ var init_issue = __esm({
 });
 
 // src/capabilityFolders.ts
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 function capabilityOutputConditionPaths(config) {
   if (config.outputSchema) {
     return new Set(schemaPropertyPaths(config.outputSchema, "result"));
@@ -1706,32 +1879,32 @@ function capabilityOutputConditionPaths(config) {
   ]);
 }
 function listCapabilityFolderSlugs(absDir) {
-  if (!fs4.existsSync(absDir)) return [];
+  if (!fs6.existsSync(absDir)) return [];
   let entries;
   try {
-    entries = fs4.readdirSync(absDir, { withFileTypes: true });
+    entries = fs6.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
-  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();
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).filter((e) => isCapabilityFolder(path7.join(absDir, e.name))).map((e) => e.name).sort();
 }
 function isCapabilityFolder(dir) {
-  if (!fs4.existsSync(path5.join(dir, CAPABILITY_BODY_FILE))) return false;
-  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  if (!fs6.existsSync(path7.join(dir, CAPABILITY_BODY_FILE))) return false;
+  const entries = fs6.readdirSync(dir, { withFileTypes: true });
   return entries.every(
     (entry) => entry.name === CAPABILITY_BODY_FILE || entry.name === CAPABILITY_CONTRACT_FILE || entry.isDirectory() && (entry.name === "skills" || entry.name === "tools")
   );
 }
 function readCapabilityFolder(root, slug) {
-  const dir = path5.join(root, slug);
-  const bodyPath = path5.join(dir, CAPABILITY_BODY_FILE);
-  const contractPath = path5.join(dir, CAPABILITY_CONTRACT_FILE);
-  if (!fs4.existsSync(bodyPath) || !fs4.statSync(bodyPath).isFile()) return null;
+  const dir = path7.join(root, slug);
+  const bodyPath = path7.join(dir, CAPABILITY_BODY_FILE);
+  const contractPath = path7.join(dir, CAPABILITY_CONTRACT_FILE);
+  if (!fs6.existsSync(bodyPath) || !fs6.statSync(bodyPath).isFile()) return null;
   if (!isCapabilityFolder(dir)) return null;
   try {
-    const rawBody = fs4.readFileSync(bodyPath, "utf-8");
-    const contract = fs4.existsSync(contractPath) ? parseCapabilityContract(fs4.readFileSync(contractPath, "utf-8")) : void 0;
-    if (contract?.execution === "script" && !isRegularFile(path5.join(dir, "tools", "run.sh"))) {
+    const rawBody = fs6.readFileSync(bodyPath, "utf-8");
+    const contract = fs6.existsSync(contractPath) ? parseCapabilityContract(fs6.readFileSync(contractPath, "utf-8")) : void 0;
+    if (contract?.execution === "script" && !isRegularFile(path7.join(dir, "tools", "run.sh"))) {
       throw new Error('script-backed Capability requires a regular "tools/run.sh" file');
     }
     const { title, body } = parseCapabilityBody(rawBody, slug);
@@ -1802,7 +1975,7 @@ function parseCapabilityContract(raw) {
 }
 function isRegularFile(filePath) {
   try {
-    const stat = fs4.lstatSync(filePath);
+    const stat = fs6.lstatSync(filePath);
     return stat.isFile() && !stat.isSymbolicLink();
   } catch {
     return false;
@@ -1961,51 +2134,51 @@ var init_capabilityFolders = __esm({
 });
 
 // src/definition-paths.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 function definitionsRoot(cwd = process.cwd()) {
   const override = process.env.KODY_DEFINITIONS_ROOT?.trim();
   const overrideCwd = process.env.KODY_DEFINITIONS_ROOT_CWD?.trim();
-  if (override && overrideCwd && path6.resolve(cwd) === path6.resolve(overrideCwd)) {
-    return storeCatalogRoot(path6.resolve(override));
+  if (override && overrideCwd && path8.resolve(cwd) === path8.resolve(overrideCwd)) {
+    return storeCatalogRoot(path8.resolve(override));
   }
-  const hydrated = path6.join(cwd, ".kody-engine", "definitions");
-  if (fs5.existsSync(hydrated)) return hydrated;
-  return override ? storeCatalogRoot(path6.resolve(override)) : hydrated;
+  const hydrated = path8.join(cwd, ".kody-engine", "definitions");
+  if (fs7.existsSync(hydrated)) return hydrated;
+  return override ? storeCatalogRoot(path8.resolve(override)) : hydrated;
 }
 function hasExplicitDefinitionsRoot(cwd = process.cwd(), env = process.env) {
   const root = env.KODY_DEFINITIONS_ROOT?.trim();
   const rootCwd = env.KODY_DEFINITIONS_ROOT_CWD?.trim();
-  return Boolean(root && rootCwd && path6.resolve(cwd) === path6.resolve(rootCwd));
+  return Boolean(root && rootCwd && path8.resolve(cwd) === path8.resolve(rootCwd));
 }
 function capabilitiesRoot(cwd = process.cwd()) {
-  return storeAssetRoot(cwd, "capabilities") ?? path6.join(definitionsRoot(cwd), "capabilities");
+  return storeAssetRoot(cwd, "capabilities") ?? path8.join(definitionsRoot(cwd), "capabilities");
 }
 function implementationsRoot(cwd = process.cwd()) {
-  return path6.join(definitionsRoot(cwd), "implementations");
+  return path8.join(definitionsRoot(cwd), "implementations");
 }
 function agentsRoot(cwd = process.cwd()) {
-  return storeAssetRoot(cwd, "agent") ?? path6.join(definitionsRoot(cwd), "agents");
+  return storeAssetRoot(cwd, "agent") ?? path8.join(definitionsRoot(cwd), "agents");
 }
 function storeCatalogRoot(root) {
   const manifest = readStoreManifest(root);
-  const roots = ["capabilities", "workflows", "loops"].map((kind) => manifest?.assetRoots?.[kind]).filter((value) => typeof value === "string" && Boolean(value.trim())).map((value) => path6.dirname(value));
-  return roots.length === 3 && new Set(roots).size === 1 ? path6.join(root, roots[0]) : root;
+  const roots = ["capabilities", "workflows", "loops"].map((kind) => manifest?.assetRoots?.[kind]).filter((value) => typeof value === "string" && Boolean(value.trim())).map((value) => path8.dirname(value));
+  return roots.length === 3 && new Set(roots).size === 1 ? path8.join(root, roots[0]) : root;
 }
 function storeAssetRoot(cwd, kind) {
   const override = process.env.KODY_DEFINITIONS_ROOT?.trim();
   if (!override) return null;
   const overrideCwd = process.env.KODY_DEFINITIONS_ROOT_CWD?.trim();
-  if (overrideCwd && path6.resolve(cwd) !== path6.resolve(overrideCwd)) return null;
-  const root = path6.resolve(override);
+  if (overrideCwd && path8.resolve(cwd) !== path8.resolve(overrideCwd)) return null;
+  const root = path8.resolve(override);
   const configured = readStoreManifest(root)?.assetRoots?.[kind];
-  return typeof configured === "string" && configured.trim() ? path6.join(root, configured) : null;
+  return typeof configured === "string" && configured.trim() ? path8.join(root, configured) : null;
 }
 function readStoreManifest(root) {
-  const file = path6.join(root, "kody-store.json");
-  if (!fs5.existsSync(file)) return null;
+  const file = path8.join(root, "kody-store.json");
+  if (!fs7.existsSync(file)) return null;
   try {
-    return JSON.parse(fs5.readFileSync(file, "utf8"));
+    return JSON.parse(fs7.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -2017,32 +2190,32 @@ var init_definition_paths = __esm({
 });
 
 // src/registry.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 function getImplementationsRoot() {
-  const here = path7.dirname(new URL(import.meta.url).pathname);
+  const here = path9.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path7.join(here, "implementations"),
+    path9.join(here, "implementations"),
     // dev: src/
-    path7.join(here, "..", "implementations"),
+    path9.join(here, "..", "implementations"),
     // built: dist/bin → dist/implementations
-    path7.join(here, "..", "src", "implementations")
+    path9.join(here, "..", "src", "implementations")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs6.existsSync(c) && fs6.statSync(c).isDirectory()) return c;
+    if (fs8.existsSync(c) && fs8.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function getRuntimeServicesRoot() {
-  const here = path7.dirname(new URL(import.meta.url).pathname);
+  const here = path9.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path7.join(here, "runtime-services"),
-    path7.join(here, "..", "runtime-services"),
-    path7.join(here, "..", "src", "runtime-services")
+    path9.join(here, "runtime-services"),
+    path9.join(here, "..", "runtime-services"),
+    path9.join(here, "..", "src", "runtime-services")
   ];
   for (const candidate of candidates) {
-    if (fs6.existsSync(candidate) && fs6.statSync(candidate).isDirectory()) return candidate;
+    if (fs8.existsSync(candidate) && fs8.statSync(candidate).isDirectory()) return candidate;
   }
   return candidates[0];
 }
@@ -2050,17 +2223,17 @@ function getProjectCapabilitiesRoot() {
   return capabilitiesRoot();
 }
 function getBuiltinCapabilitiesRoot() {
-  const here = path7.dirname(new URL(import.meta.url).pathname);
+  const here = path9.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path7.join(here, "capabilities"),
+    path9.join(here, "capabilities"),
     // dev: src/
-    path7.join(here, "..", "capabilities"),
+    path9.join(here, "..", "capabilities"),
     // built: dist/bin → dist/capabilities
-    path7.join(here, "..", "src", "capabilities")
+    path9.join(here, "..", "src", "capabilities")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs6.existsSync(c) && fs6.statSync(c).isDirectory()) return c;
+    if (fs8.existsSync(c) && fs8.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
@@ -2083,14 +2256,14 @@ function listImplementations(roots = getImplementationRoots()) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const root of rootList) {
-    if (!fs6.existsSync(root)) continue;
+    if (!fs8.existsSync(root)) continue;
     const requireImplementationProfile = isCapabilityRoot(root);
-    const entries = fs6.readdirSync(root, { withFileTypes: true });
+    const entries = fs8.readdirSync(root, { withFileTypes: true });
     for (const ent of entries) {
       if (!ent.isDirectory()) continue;
       if (seen.has(ent.name)) continue;
       const profilePath = implementationRuntimePath(root, ent.name);
-      if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile() && isImplementationProfile(profilePath, requireImplementationProfile)) {
+      if (fs8.existsSync(profilePath) && fs8.statSync(profilePath).isFile() && isImplementationProfile(profilePath, requireImplementationProfile)) {
         out.push({ name: ent.name, profilePath });
         seen.add(ent.name);
       }
@@ -2110,7 +2283,7 @@ function resolveImplementationCandidates(name, roots = getRuntimeProfileRootsFor
   const out = [];
   for (const root of rootList) {
     const profilePath = implementationRuntimePath(root, name);
-    if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile() && isImplementationProfile(profilePath, isCapabilityRoot(root))) {
+    if (fs8.existsSync(profilePath) && fs8.statSync(profilePath).isFile() && isImplementationProfile(profilePath, isCapabilityRoot(root))) {
       out.push(profilePath);
     }
   }
@@ -2179,7 +2352,7 @@ function implementationDeclaresInput(implementation, inputName, cwd = process.cw
   const profilePath = resolveImplementation(implementation, getRuntimeProfileRootsForCwd(cwd));
   if (!profilePath) return false;
   try {
-    const document = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
+    const document = JSON.parse(fs8.readFileSync(profilePath, "utf-8"));
     const raw = document.config ?? document;
     if (!Array.isArray(raw.inputs)) return false;
     return raw.inputs.some((entry) => {
@@ -2195,29 +2368,29 @@ function isSafeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
 }
 function isCapabilityRoot(root) {
-  const normalized = path7.normalize(root);
-  if (path7.basename(normalized) === "capabilities") return true;
+  const normalized = path9.normalize(root);
+  if (path9.basename(normalized) === "capabilities") return true;
   const knownRoots = [getProjectCapabilitiesRoot(), getBuiltinCapabilitiesRoot()];
-  return knownRoots.some((candidate) => candidate && path7.normalize(candidate) === normalized);
+  return knownRoots.some((candidate) => candidate && path9.normalize(candidate) === normalized);
 }
 function implementationRuntimePath(root, name) {
-  const runtimePath = path7.join(root, name, "runtime.json");
-  if (fs6.existsSync(runtimePath)) return runtimePath;
-  const internalProfilePath = path7.join(root, name, "profile.json");
-  if (fs6.existsSync(internalProfilePath)) return internalProfilePath;
-  return path7.join(root, name, CAPABILITY_PROFILE_FILE);
+  const runtimePath = path9.join(root, name, "runtime.json");
+  if (fs8.existsSync(runtimePath)) return runtimePath;
+  const internalProfilePath = path9.join(root, name, "profile.json");
+  if (fs8.existsSync(internalProfilePath)) return internalProfilePath;
+  return path9.join(root, name, CAPABILITY_PROFILE_FILE);
 }
 function isImplementationProfile(profilePath, requireImplementationProfile) {
   if (!requireImplementationProfile) return true;
   try {
-    const raw = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
+    const raw = JSON.parse(fs8.readFileSync(profilePath, "utf-8"));
     return typeof raw.role === "string" && PUBLIC_IMPLEMENTATION_ROLES.has(raw.role);
   } catch {
     return false;
   }
 }
 function listFolderCapabilityActions(root, source) {
-  if (!fs6.existsSync(root) || !fs6.statSync(root).isDirectory()) return [];
+  if (!fs8.existsSync(root) || !fs8.statSync(root).isDirectory()) return [];
   const out = [];
   for (const slug of listCapabilityFolderSlugs(root)) {
     if (!isSafeName(slug)) continue;
@@ -2249,7 +2422,7 @@ function hasUnresolvedExplicitImplementation(capability, implementation) {
   return resolveImplementation(implementation) === null;
 }
 function listBuiltinCapabilityActions(root = getBuiltinCapabilitiesRoot()) {
-  if (!fs6.existsSync(root) || !fs6.statSync(root).isDirectory()) return [];
+  if (!fs8.existsSync(root) || !fs8.statSync(root).isDirectory()) return [];
   const out = [];
   for (const slug of listCapabilityFolderSlugs(root)) {
     if (!isSafeName(slug)) continue;
@@ -2274,7 +2447,7 @@ function getProfileInputs(name, roots = getImplementationRoots()) {
   const profilePath = resolveImplementation(name, roots);
   if (!profilePath) return null;
   try {
-    const document = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
+    const document = JSON.parse(fs8.readFileSync(profilePath, "utf-8"));
     if (!document || typeof document !== "object") return [];
     const raw = "config" in document && document.config && typeof document.config === "object" ? document.config : document;
     if (!Array.isArray(raw.inputs)) return [];
@@ -3312,8 +3485,8 @@ var init_capabilityMcp = __esm({
 
 // src/repoWorkspace.ts
 import { spawn as spawn2, spawnSync } from "child_process";
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 function buildCloneProcess(repo, token, baseEnv = process.env) {
   const url = `https://github.com/${repo}.git`;
   const env = { ...baseEnv };
@@ -3328,10 +3501,10 @@ function buildCloneProcess(repo, token, baseEnv = process.env) {
 async function resolveAndClone(reposRoot, repo, repoToken, cloneRepo) {
   const name = repo?.trim();
   if (!name || !REPO_RE.test(name)) return null;
-  const root = path8.resolve(reposRoot);
-  const dir = path8.resolve(root, name);
-  if (dir !== root && !dir.startsWith(root + path8.sep)) return null;
-  if (fs7.existsSync(path8.join(dir, ".git"))) return dir;
+  const root = path10.resolve(reposRoot);
+  const dir = path10.resolve(root, name);
+  if (dir !== root && !dir.startsWith(root + path10.sep)) return null;
+  if (fs9.existsSync(path10.join(dir, ".git"))) return dir;
   const inflight = repoClones.get(dir);
   if (inflight) {
     await inflight;
@@ -3363,7 +3536,7 @@ var init_repoWorkspace = __esm({
     repoClones = /* @__PURE__ */ new Map();
     GIT_CREDENTIAL_HELPER = `!f() { if [ "$1" = get ] && [ -n "$GITHUB_TOKEN" ]; then printf '%s\\n' username=x-access-token "password=$GITHUB_TOKEN"; fi; }; f`;
     defaultCloneRepo = (repo, token, dir) => {
-      fs7.mkdirSync(path8.dirname(dir), { recursive: true });
+      fs9.mkdirSync(path10.dirname(dir), { recursive: true });
       const clone = buildCloneProcess(repo, token);
       return new Promise((resolve19, reject) => {
         const child = spawn2("git", ["clone", "--depth=1", clone.url, dir], {
@@ -3457,8 +3630,8 @@ var init_fetchRepoMcp = __esm({
 });
 
 // src/agent.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 function classifySubtype(subtype) {
   if (!subtype) return "generic_failed";
@@ -3527,8 +3700,8 @@ function buildAgentEnvironment(baseEnv, repoToken, requestEnvironment) {
 }
 async function runAgent(opts) {
   const ndjsonDir = opts.ndjsonDir ?? agentRunDir(opts.cwd);
-  fs8.mkdirSync(ndjsonDir, { recursive: true });
-  const ndjsonPath = path9.join(ndjsonDir, "last-run.jsonl");
+  fs10.mkdirSync(ndjsonDir, { recursive: true });
+  const ndjsonPath = path11.join(ndjsonDir, "last-run.jsonl");
   const env = buildAgentEnvironment(process.env, opts.repoToken, opts.environment);
   if (opts.litellmUrl) {
     env.ANTHROPIC_BASE_URL = opts.litellmUrl;
@@ -3547,7 +3720,7 @@ async function runAgent(opts) {
   for (let attempt = 0; ; attempt++) {
     let ndjsonWriteFailed = false;
     let ndjsonWriteError;
-    const fullLog = fs8.createWriteStream(ndjsonPath, { flags: "w" });
+    const fullLog = fs10.createWriteStream(ndjsonPath, { flags: "w" });
     fullLog.on("error", (err) => {
       ndjsonWriteFailed = true;
       ndjsonWriteError = err instanceof Error ? err.message : String(err);
@@ -3571,7 +3744,15 @@ async function runAgent(opts) {
         // opt-in tools like fetch_repo can be appended below.
         allowedTools: [...opts.allowedToolsOverride ?? DEFAULT_ALLOWED_TOOLS],
         permissionMode: opts.permissionModeOverride ?? "acceptEdits",
-        env
+        env,
+        hooks: {
+          PreToolUse: [
+            {
+              matcher: "Agent",
+              hooks: [enforceSubagentModelInheritance]
+            }
+          ]
+        }
       };
       const additionalDirectories = new Set(opts.additionalDirectories ?? []);
       const mcpEntries = [];
@@ -3902,6 +4083,7 @@ var init_agent = __esm({
     init_config();
     init_format();
     init_runtimePaths();
+    init_subagents();
     DEFAULT_ALLOWED_TOOLS = ["Bash", "Edit", "Read", "Write", "Glob", "Grep"];
     DEFAULT_TURN_TIMEOUT_MS = 6e5;
     MAX_CONNECTION_RETRIES = 2;
@@ -3920,8 +4102,8 @@ var init_agent = __esm({
 });
 
 // src/agents.ts
-import * as fs9 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path12 from "path";
 function stripFrontmatter(raw) {
   const match = /^---\n[\s\S]*?\n---\n?([\s\S]*)$/.exec(raw);
   return (match ? match[1] : raw).trim();
@@ -3929,9 +4111,9 @@ function stripFrontmatter(raw) {
 function loadAgentIdentity(cwd, slug, agentsDir = agentsRoot(cwd)) {
   const trimmed = slug.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"));
+  const agentPath = resolveAgentFile2(cwd, trimmed, agentsDir);
+  if (fs11.existsSync(agentPath)) {
+    const body = stripFrontmatter(fs11.readFileSync(agentPath, "utf-8"));
     if (body) return body;
     const builtinForEmpty = BUILTIN_AGENTS[trimmed];
     if (builtinForEmpty) return builtinForEmpty;
@@ -3941,9 +4123,9 @@ function loadAgentIdentity(cwd, slug, agentsDir = agentsRoot(cwd)) {
   if (builtin) return builtin;
   throw new Error(`loadAgentIdentity: agent '${trimmed}' declared but ${agentPath} does not exist`);
 }
-function resolveAgentFile(cwd, slug, agentsDir = agentsRoot(cwd)) {
-  const localPath = path10.resolve(cwd, agentsDir, `${slug}.md`);
-  if (fs9.existsSync(localPath)) return localPath;
+function resolveAgentFile2(cwd, slug, agentsDir = agentsRoot(cwd)) {
+  const localPath = path12.resolve(cwd, agentsDir, `${slug}.md`);
+  if (fs11.existsSync(localPath)) return localPath;
   return localPath;
 }
 function frameAgentIdentity(slug, agent) {
@@ -3975,14 +4157,14 @@ var init_agents = __esm({
 });
 
 // src/task-artifacts.ts
-import fs10 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path13 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;
-  fs10.mkdirSync(absDir, { recursive: true });
+  fs12.mkdirSync(absDir, { recursive: true });
   return { taskId: safeId, absDir, relDir };
 }
 function initializeTaskArtifacts(artifacts, metadata = { taskType: "job" }) {
@@ -4012,16 +4194,16 @@ function initializeTaskArtifacts(artifacts, metadata = { taskType: "job" }) {
     "handoff-notes.md": "Baseline handoff: the agent did not provide additional notes.\n"
   };
   for (const file of TASK_ARTIFACT_FILES) {
-    const full = path11.join(artifacts.absDir, file);
-    if (!fs10.existsSync(full)) fs10.writeFileSync(full, defaults[file], "utf8");
+    const full = path13.join(artifacts.absDir, file);
+    if (!fs12.existsSync(full)) fs12.writeFileSync(full, defaults[file], "utf8");
   }
 }
 function verifyTaskArtifacts(absDir) {
   const missing = [];
   for (const name of TASK_ARTIFACT_FILES) {
-    const full = path11.join(absDir, name);
+    const full = path13.join(absDir, name);
     try {
-      const stat = fs10.statSync(full);
+      const stat = fs12.statSync(full);
       if (!stat.isFile() || stat.size === 0) missing.push(name);
     } catch {
       missing.push(name);
@@ -4037,11 +4219,11 @@ async function persistTaskArtifactsToState(config, _cwd, artifacts) {
   if (hasStateBackendConfig() && tenantId2) {
     const backend = createStateBackendFromEnv();
     for (const file of TASK_ARTIFACT_FILES) {
-      const full = path11.join(artifacts.absDir, file);
-      if (!fs10.existsSync(full)) continue;
-      const stat = fs10.statSync(full);
+      const full = path13.join(artifacts.absDir, file);
+      if (!fs12.existsSync(full)) continue;
+      const stat = fs12.statSync(full);
       if (!stat.isFile() || stat.size === 0) continue;
-      const content = fs10.readFileSync(full, "utf-8");
+      const content = fs12.readFileSync(full, "utf-8");
       const kind = file.replace(/\.(json|md)$/, "");
       let doc = content;
       if (file.endsWith(".json")) {
@@ -4402,8 +4584,8 @@ var init_workflowValidation = __esm({
 });
 
 // src/workflowDefinitions.ts
-import * as fs16 from "fs";
-import * as path17 from "path";
+import * as fs18 from "fs";
+import * as path19 from "path";
 function isWorkflowDefinitionId(value) {
   return WORKFLOW_ID_PATTERN.test(value);
 }
@@ -4446,12 +4628,12 @@ function readWorkflowDefinition(_config, cwd, id) {
   const root = cwd ?? process.cwd();
   const relativePath = workflowDefinitionPath(id);
   const candidates = [
-    path17.join(root, ".kody-engine", "runtime", relativePath),
-    path17.join(definitionsRoot(root), relativePath)
+    path19.join(root, ".kody-engine", "runtime", relativePath),
+    path19.join(definitionsRoot(root), relativePath)
   ];
   for (const filePath of candidates) {
-    if (!fs16.existsSync(filePath)) continue;
-    const workflow = parseWorkflowDefinition(fs16.readFileSync(filePath, "utf8"));
+    if (!fs18.existsSync(filePath)) continue;
+    const workflow = parseWorkflowDefinition(fs18.readFileSync(filePath, "utf8"));
     if (workflow) return workflow;
   }
   return null;
@@ -4459,7 +4641,7 @@ function readWorkflowDefinition(_config, cwd, id) {
 function workflowDefinitionToCapabilityFolder(id, workflow, source = workflowDefinitionPath(id)) {
   return {
     slug: id,
-    dir: path17.dirname(source),
+    dir: path19.dirname(source),
     profilePath: source,
     bodyPath: source,
     title: workflow.name,
@@ -4514,7 +4696,7 @@ var init_workflowDefinitions = __esm({
 
 // src/gha.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import * as fs19 from "fs";
+import * as fs21 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -4525,10 +4707,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs19.existsSync(eventPath)) return;
+  if (!eventPath || !fs21.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs19.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs21.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -5109,166 +5291,6 @@ var init_lifecycles = __esm({
   }
 });
 
-// src/scripts/buildSyntheticPlugin.ts
-import * as fs20 from "fs";
-import * as os3 from "os";
-import * as path19 from "path";
-function getPluginsCatalogRoot() {
-  const here = path19.dirname(new URL(import.meta.url).pathname);
-  const candidates = [
-    path19.join(here, "..", "plugins"),
-    // dev: src/scripts → src/plugins
-    path19.join(here, "..", "..", "plugins"),
-    // built: dist/scripts → dist/plugins
-    path19.join(here, "..", "..", "src", "plugins")
-    // fallback
-  ];
-  for (const c of candidates) {
-    if (fs20.existsSync(c) && fs20.statSync(c).isDirectory()) return c;
-  }
-  return candidates[0];
-}
-function copyDir(src, dst) {
-  fs20.mkdirSync(dst, { recursive: true });
-  for (const ent of fs20.readdirSync(src, { withFileTypes: true })) {
-    const s = path19.join(src, ent.name);
-    const d = path19.join(dst, ent.name);
-    if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs20.copyFileSync(s, d);
-  }
-}
-var buildSyntheticPlugin;
-var init_buildSyntheticPlugin = __esm({
-  "src/scripts/buildSyntheticPlugin.ts"() {
-    "use strict";
-    buildSyntheticPlugin = async (ctx, profile) => {
-      const cc = profile.claudeCode;
-      const needsSynthetic = cc.skills.length > 0 || cc.commands.length > 0 || cc.hooks.length > 0;
-      if (!needsSynthetic) return;
-      const catalog = getPluginsCatalogRoot();
-      const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      const root = path19.join(os3.tmpdir(), `kody-synth-${runId}`);
-      fs20.mkdirSync(path19.join(root, ".claude-plugin"), { recursive: true });
-      const resolvePart = (bucket, entry) => {
-        const local = path19.join(profile.dir, bucket, entry);
-        if (fs20.existsSync(local)) return local;
-        const shared = path19.resolve(profile.dir, "..", "..", "shared", bucket, entry);
-        if (fs20.existsSync(shared)) return shared;
-        const central = path19.join(catalog, bucket, entry);
-        if (fs20.existsSync(central)) return central;
-        throw new Error(
-          `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in implementation dir (${profile.dir}/${bucket}/), Store shared assets (${path19.dirname(shared)}/), or catalog (${catalog}/${bucket}/)`
-        );
-      };
-      if (cc.skills.length > 0) {
-        const dst = path19.join(root, "skills");
-        fs20.mkdirSync(dst, { recursive: true });
-        for (const name of cc.skills) {
-          copyDir(resolvePart("skills", name), path19.join(dst, name));
-        }
-      }
-      if (cc.commands.length > 0) {
-        const dst = path19.join(root, "commands");
-        fs20.mkdirSync(dst, { recursive: true });
-        for (const name of cc.commands) {
-          fs20.copyFileSync(resolvePart("commands", `${name}.md`), path19.join(dst, `${name}.md`));
-        }
-      }
-      if (cc.hooks.length > 0) {
-        const dst = path19.join(root, "hooks");
-        fs20.mkdirSync(dst, { recursive: true });
-        const merged = { hooks: {} };
-        for (const name of cc.hooks) {
-          const src = resolvePart("hooks", `${name}.json`);
-          const parsed = JSON.parse(fs20.readFileSync(src, "utf-8"));
-          for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
-            if (!Array.isArray(entries)) continue;
-            if (!merged.hooks[event]) merged.hooks[event] = [];
-            merged.hooks[event].push(...entries);
-          }
-        }
-        fs20.writeFileSync(path19.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
-`);
-      }
-      const manifest = {
-        name: `kody-synth-${profile.name}`,
-        version: "1.0.0",
-        description: `Synthetic plugin assembled by Kody for profile '${profile.name}' at runtime.`
-      };
-      if (cc.skills.length > 0) manifest.skills = ["./skills/"];
-      if (cc.commands.length > 0) manifest.commands = ["./commands/"];
-      fs20.writeFileSync(path19.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
-`);
-      ctx.data.syntheticPluginPath = root;
-    };
-  }
-});
-
-// src/subagents.ts
-import * as fs21 from "fs";
-import * as path20 from "path";
-function splitFrontmatter(raw) {
-  const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(raw);
-  if (!match) return { fm: {}, body: raw.trim() };
-  const fm = {};
-  for (const line of match[1].split("\n")) {
-    const idx = line.indexOf(":");
-    if (idx === -1) continue;
-    fm[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
-  }
-  return { fm, body: (match[2] ?? "").trim() };
-}
-function resolveAgentFile2(profileDir, name) {
-  const local = path20.join(profileDir, "agents", `${name}.md`);
-  if (fs21.existsSync(local)) return local;
-  const shared = path20.resolve(profileDir, "..", "..", "shared", "agents", `${name}.md`);
-  if (fs21.existsSync(shared)) return shared;
-  const central = path20.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
-  if (fs21.existsSync(central)) return central;
-  throw new Error(
-    `loadSubagents: agent '${name}' not found in ${profileDir}/agents/, hydrated shared assets, or engine catalog`
-  );
-}
-function captureSubagentTemplates(profile) {
-  const names = profile.claudeCode.subagents;
-  if (!names || names.length === 0) return {};
-  const out = {};
-  for (const name of names) {
-    try {
-      out[name] = fs21.readFileSync(resolveAgentFile2(profile.dir, name), "utf-8");
-    } catch {
-    }
-  }
-  return out;
-}
-function loadSubagents(profile) {
-  const names = profile.claudeCode.subagents;
-  if (!names || names.length === 0) return void 0;
-  const agents = {};
-  for (const name of names) {
-    const raw = profile.subagentTemplates?.[name] ?? fs21.readFileSync(resolveAgentFile2(profile.dir, name), "utf-8");
-    const { fm, body } = splitFrontmatter(raw);
-    if (!body) throw new Error(`loadSubagents: agent '${name}' has an empty prompt body`);
-    const def = {
-      description: fm.description ?? `Subagent ${name}`,
-      prompt: body
-    };
-    if (fm.tools) {
-      const tools = fm.tools.split(",").map((t) => t.trim()).filter(Boolean);
-      if (tools.length > 0) def.tools = tools;
-    }
-    if (fm.model) def.model = fm.model;
-    agents[fm.name || name] = def;
-  }
-  return agents;
-}
-var init_subagents = __esm({
-  "src/subagents.ts"() {
-    "use strict";
-    init_buildSyntheticPlugin();
-  }
-});
-
 // src/profile.ts
 import { createHash as createHash3 } from "crypto";
 import * as fs22 from "fs";
@@ -15014,7 +15036,7 @@ var init_loadAgentAdhoc = __esm({
       if (!agentSlug) {
         throw new Error("loadAgentAdhoc: ctx.args.agent must be a non-empty slug");
       }
-      const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
+      const agentPath = resolveAgentFile2(ctx.cwd, agentSlug, agentsDir);
       if (!fs39.existsSync(agentPath)) {
         throw new Error(`loadAgentAdhoc: agent identity not found: ${agentPath}`);
       }
@@ -15439,7 +15461,7 @@ var init_loadJobFromFile = __esm({
       let agentTitle = "";
       let agentIdentity = "";
       if (agentSlug) {
-        const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
+        const agentPath = resolveAgentFile2(ctx.cwd, agentSlug, agentsDir);
         if (!fs40.existsSync(agentPath)) {
           throw new Error(
             `loadJobFromFile: capability '${slug}' declares agent '${agentSlug}' but ${agentPath} does not exist`
@@ -22991,13 +23013,13 @@ init_agents();
 init_config();
 init_registry();
 init_task_artifacts();
-import * as fs14 from "fs";
-import * as path15 from "path";
+import * as fs16 from "fs";
+import * as path17 from "path";
 
 // src/chat/attachments.ts
 init_runtimePaths();
-import * as fs11 from "fs";
-import * as path12 from "path";
+import * as fs13 from "fs";
+import * as path14 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",
@@ -23030,11 +23052,11 @@ function prepareAttachments(turns, cwd, sessionId) {
         if (!isImage) return `[File: ${name}]`;
         try {
           if (!dirEnsured) {
-            fs11.mkdirSync(dir, { recursive: true });
+            fs13.mkdirSync(dir, { recursive: true });
             dirEnsured = true;
           }
-          const filePath = path12.join(dir, `${imageCounter}.${extFor(mime)}`);
-          fs11.writeFileSync(filePath, Buffer.from(data, "base64"));
+          const filePath = path14.join(dir, `${imageCounter}.${extFor(mime)}`);
+          fs13.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.]`;
@@ -23051,8 +23073,8 @@ function prepareAttachments(turns, cwd, sessionId) {
 
 // src/chat/codex-app-server.ts
 import { spawn as spawn3 } from "child_process";
-import * as fs12 from "fs";
-import * as path13 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 import { createInterface } from "readline";
 function codexThreadStartParams(args) {
   return {
@@ -23223,11 +23245,11 @@ var CodexAppServerClient = class {
 };
 var clients = /* @__PURE__ */ new Map();
 function threadMapPath(cwd) {
-  return path13.join(cwd, ".kody-engine", "runtime", "codex-threads.json");
+  return path15.join(cwd, ".kody-engine", "runtime", "codex-threads.json");
 }
 function readThreadMap(cwd) {
   try {
-    const value = JSON.parse(fs12.readFileSync(threadMapPath(cwd), "utf8"));
+    const value = JSON.parse(fs14.readFileSync(threadMapPath(cwd), "utf8"));
     if (!value || typeof value !== "object" || Array.isArray(value)) return {};
     return Object.fromEntries(
       Object.entries(value).filter(
@@ -23240,8 +23262,8 @@ function readThreadMap(cwd) {
 }
 function writeThreadMap(cwd, map) {
   const file = threadMapPath(cwd);
-  fs12.mkdirSync(path13.dirname(file), { recursive: true });
-  fs12.writeFileSync(file, `${JSON.stringify(map, null, 2)}
+  fs14.mkdirSync(path15.dirname(file), { recursive: true });
+  fs14.writeFileSync(file, `${JSON.stringify(map, null, 2)}
 `);
 }
 async function runCodexChatTurn(args) {
@@ -23331,8 +23353,8 @@ async function runCodexChatTurn(args) {
 }
 
 // src/chat/events.ts
-import * as fs13 from "fs";
-import * as path14 from "path";
+import * as fs15 from "fs";
+import * as path16 from "path";
 import posixPath2 from "path/posix";
 var BackendEventSink = class {
   constructor(append, tenantId2, sessionId) {
@@ -23348,7 +23370,7 @@ var BackendEventSink = class {
   }
 };
 function eventsFilePath(cwd, sessionId) {
-  return path14.join(cwd, ".kody-engine", "runtime", "events", `${sessionId}.jsonl`);
+  return path16.join(cwd, ".kody-engine", "runtime", "events", `${sessionId}.jsonl`);
 }
 var FileSink = class {
   constructor(file) {
@@ -23356,8 +23378,8 @@ var FileSink = class {
   }
   file;
   async emit(event) {
-    fs13.mkdirSync(path14.dirname(this.file), { recursive: true });
-    fs13.appendFileSync(this.file, `${JSON.stringify(event)}
+    fs15.mkdirSync(path16.dirname(this.file), { recursive: true });
+    fs15.appendFileSync(this.file, `${JSON.stringify(event)}
 `);
   }
 };
@@ -23600,7 +23622,7 @@ function buildImplementationCatalog() {
   const entries = [];
   for (const { name, profilePath } of discovered) {
     try {
-      const raw = JSON.parse(fs14.readFileSync(profilePath, "utf-8"));
+      const raw = JSON.parse(fs16.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() });
@@ -23708,7 +23730,7 @@ 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) => path17.dirname(p2))))
     ],
     systemPromptAppend: systemPrompt,
     ...opts.reasoningEffort ? { reasoningEffort: opts.reasoningEffort } : {},
@@ -23892,10 +23914,10 @@ async function emit(sink, type, sessionId, suffix, payload) {
 var MEMORY_INDEX_REL = ".kody-engine/runtime/memory/INDEX.md";
 var MAX_INDEX_BYTES = 8e3;
 function readMemoryIndexBlock(cwd) {
-  const indexPath = path15.join(cwd, MEMORY_INDEX_REL);
+  const indexPath = path17.join(cwd, MEMORY_INDEX_REL);
   let raw;
   try {
-    raw = fs14.readFileSync(indexPath, "utf-8");
+    raw = fs16.readFileSync(indexPath, "utf-8");
   } catch {
     return "";
   }
@@ -23915,17 +23937,17 @@ _\u2026 (memory index truncated; use recall_search to read more)_` : trimmed;
 var CONTEXT_DIR_REL = ".kody-engine/runtime/context";
 var MAX_CONTEXT_BYTES = 12e3;
 function readContextBlock(cwd) {
-  const dir = path15.join(cwd, CONTEXT_DIR_REL);
+  const dir = path17.join(cwd, CONTEXT_DIR_REL);
   let files;
   try {
-    files = fs14.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    files = fs16.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const sections = [];
   for (const file of files) {
     try {
-      const content = fs14.readFileSync(path15.join(dir, file), "utf-8").trim();
+      const content = fs16.readFileSync(path17.join(dir, file), "utf-8").trim();
       if (content) sections.push(`### ${file.replace(/\.md$/, "")}
 
 ${content}`);
@@ -23951,7 +23973,7 @@ var SYSTEM_PROMPT_OVERRIDE_REL = ".kody-engine/runtime/system-prompt.md";
 function readSystemPromptOverride(cwd) {
   let raw;
   try {
-    raw = fs14.readFileSync(path15.join(cwd, SYSTEM_PROMPT_OVERRIDE_REL), "utf-8");
+    raw = fs16.readFileSync(path17.join(cwd, SYSTEM_PROMPT_OVERRIDE_REL), "utf-8");
   } catch {
     return null;
   }
@@ -23959,10 +23981,10 @@ function readSystemPromptOverride(cwd) {
   return trimmed.length > 0 ? trimmed : null;
 }
 function readInstructionsBlock(cwd) {
-  const instructionsPath = path15.join(cwd, INSTRUCTIONS_REL);
+  const instructionsPath = path17.join(cwd, INSTRUCTIONS_REL);
   let raw;
   try {
-    raw = fs14.readFileSync(instructionsPath, "utf-8");
+    raw = fs16.readFileSync(instructionsPath, "utf-8");
   } catch {
     return "";
   }
@@ -23996,15 +24018,15 @@ function resolveBrainDriver(runtime) {
 }
 
 // src/chat/session.ts
-import * as fs15 from "fs";
-import * as path16 from "path";
+import * as fs17 from "fs";
+import * as path18 from "path";
 import posixPath3 from "path/posix";
 function sessionFilePath(cwd, sessionId) {
-  return path16.join(cwd, ".kody-engine", "runtime", "sessions", `${sessionId}.jsonl`);
+  return path18.join(cwd, ".kody-engine", "runtime", "sessions", `${sessionId}.jsonl`);
 }
 function readSession(file) {
-  if (!fs15.existsSync(file)) return [];
-  const raw = fs15.readFileSync(file, "utf-8").trim();
+  if (!fs17.existsSync(file)) return [];
+  const raw = fs17.readFileSync(file, "utf-8").trim();
   if (!raw) return [];
   const turns = [];
   for (const line of raw.split("\n")) {
@@ -24027,8 +24049,8 @@ init_config();
 init_state_backend();
 init_workflowDefinitions();
 import { createHash as createHash2 } from "crypto";
-import * as fs17 from "fs";
-import * as path18 from "path";
+import * as fs19 from "fs";
+import * as path20 from "path";
 var SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,127}$/;
 var REPOSITORY_OWNED_NAMESPACES = ["loops"];
 function assertSafeDefinitionPath(filePath) {
@@ -24060,9 +24082,9 @@ function verifyDefinition(definition) {
 }
 function writeBundle(root, bundle) {
   for (const [filePath, contents] of Object.entries(bundle.files)) {
-    const target = path18.join(root, filePath);
-    fs17.mkdirSync(path18.dirname(target), { recursive: true });
-    fs17.writeFileSync(target, contents, "utf8");
+    const target = path20.join(root, filePath);
+    fs19.mkdirSync(path20.dirname(target), { recursive: true });
+    fs19.writeFileSync(target, contents, "utf8");
   }
 }
 function writeDefinition(root, kind, definition) {
@@ -24070,22 +24092,22 @@ function writeDefinition(root, kind, definition) {
   if (kind === "agent") {
     const raw = bundle.files["agent.md"];
     if (typeof raw !== "string") throw new Error(`agent definition ${definition.slug} is missing agent.md`);
-    fs17.writeFileSync(path18.join(root, "agents", `${definition.slug}.md`), raw, "utf8");
+    fs19.writeFileSync(path20.join(root, "agents", `${definition.slug}.md`), raw, "utf8");
     return;
   }
   if (kind === "goal") {
-    writeBundle(path18.join(root, "goals", definition.slug), bundle);
+    writeBundle(path20.join(root, "goals", definition.slug), bundle);
     return;
   }
   if (kind === "implementation") {
-    writeBundle(path18.join(root, "implementations", definition.slug), bundle);
+    writeBundle(path20.join(root, "implementations", definition.slug), bundle);
     return;
   }
   if (kind === "asset") {
-    writeBundle(path18.join(root, "shared"), bundle);
+    writeBundle(path20.join(root, "shared"), bundle);
     return;
   }
-  writeBundle(path18.join(root, "capabilities", definition.slug), bundle);
+  writeBundle(path20.join(root, "capabilities", definition.slug), bundle);
 }
 function writeWorkflow(root, document) {
   const workflow = normalizeWorkflowDefinition(document.definition);
@@ -24093,28 +24115,28 @@ function writeWorkflow(root, document) {
   const contents = `${JSON.stringify(workflow, null, 2)}
 `;
   const bundle = { schemaVersion: 1, files: { "workflow.json": contents } };
-  const target = path18.join(root, workflowDefinitionPath(document.workflowId));
-  fs17.mkdirSync(path18.dirname(target), { recursive: true });
-  fs17.writeFileSync(target, contents, "utf8");
+  const target = path20.join(root, workflowDefinitionPath(document.workflowId));
+  fs19.mkdirSync(path20.dirname(target), { recursive: true });
+  fs19.writeFileSync(target, contents, "utf8");
   return definitionVersion(bundle);
 }
 function preserveRepositoryDefinitions(root, staging) {
   for (const namespace of REPOSITORY_OWNED_NAMESPACES) {
-    const source = path18.join(root, namespace);
-    if (!fs17.existsSync(source)) continue;
-    fs17.cpSync(source, path18.join(staging, namespace), { recursive: true });
+    const source = path20.join(root, namespace);
+    if (!fs19.existsSync(source)) continue;
+    fs19.cpSync(source, path20.join(staging, namespace), { recursive: true });
   }
 }
 async function hydrateDefinitions(options) {
-  const root = path18.join(options.cwd, ".kody-engine", "definitions");
+  const root = path20.join(options.cwd, ".kody-engine", "definitions");
   const staging = `${root}.tmp-${process.pid}-${Date.now()}`;
-  fs17.rmSync(staging, { recursive: true, force: true });
-  fs17.mkdirSync(path18.join(staging, "agents"), { recursive: true });
-  fs17.mkdirSync(path18.join(staging, "capabilities"), { recursive: true });
-  fs17.mkdirSync(path18.join(staging, "goals"), { recursive: true });
-  fs17.mkdirSync(path18.join(staging, "implementations"), { recursive: true });
-  fs17.mkdirSync(path18.join(staging, "shared"), { recursive: true });
-  fs17.mkdirSync(path18.join(staging, "workflows"), { recursive: true });
+  fs19.rmSync(staging, { recursive: true, force: true });
+  fs19.mkdirSync(path20.join(staging, "agents"), { recursive: true });
+  fs19.mkdirSync(path20.join(staging, "capabilities"), { recursive: true });
+  fs19.mkdirSync(path20.join(staging, "goals"), { recursive: true });
+  fs19.mkdirSync(path20.join(staging, "implementations"), { recursive: true });
+  fs19.mkdirSync(path20.join(staging, "shared"), { recursive: true });
+  fs19.mkdirSync(path20.join(staging, "workflows"), { recursive: true });
   try {
     const [capabilities, agents, goals, implementations, assets, workflows] = await Promise.all([
       options.backend.listDefinitions(options.tenantId, "capability"),
@@ -24155,13 +24177,13 @@ async function hydrateDefinitions(options) {
       hydratedAt: (/* @__PURE__ */ new Date()).toISOString(),
       versions: Object.fromEntries(Object.entries(versions).sort(([left], [right]) => left.localeCompare(right)))
     };
-    fs17.writeFileSync(path18.join(staging, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    fs19.writeFileSync(path20.join(staging, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-    fs17.rmSync(root, { recursive: true, force: true });
-    fs17.renameSync(staging, root);
+    fs19.rmSync(root, { recursive: true, force: true });
+    fs19.renameSync(staging, root);
     return { root, tenantId: options.tenantId, versions: manifest.versions };
   } catch (error) {
-    fs17.rmSync(staging, { recursive: true, force: true });
+    fs19.rmSync(staging, { recursive: true, force: true });
     throw error;
   }
 }
@@ -24313,7 +24335,7 @@ init_definition_paths();
 
 // src/dispatch.ts
 init_config();
-import * as fs18 from "fs";
+import * as fs20 from "fs";
 
 // src/cron-match.ts
 var FIELD_BOUNDS = [
@@ -24420,10 +24442,10 @@ function autoDispatch(opts) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs18.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs20.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs18.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs20.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -24547,7 +24569,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 || !fs18.existsSync(eventPath)) {
+  if (!eventName || !eventPath || !fs20.existsSync(eventPath)) {
     return { kind: "silent", reason: "no GHA event context" };
   }
   if (eventName !== "issue_comment") {
@@ -24555,7 +24577,7 @@ function autoDispatchTyped(opts) {
   }
   let event = {};
   try {
-    event = JSON.parse(fs18.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs20.readFileSync(eventPath, "utf-8"));
   } catch {
     return { kind: "silent", reason: "GHA event payload unreadable" };
   }
@@ -24609,7 +24631,7 @@ function dispatchScheduledWatches(opts) {
   for (const exe of listRuntimeProfilesForCwd(opts?.cwd ?? process.cwd())) {
     let raw;
     try {
-      raw = fs18.readFileSync(exe.profilePath, "utf-8");
+      raw = fs20.readFileSync(exe.profilePath, "utf-8");
     } catch {
       continue;
     }
@@ -28411,7 +28433,9 @@ function envRunRequest(env = process.env) {
   const { target } = parsed.request;
   if (target.type === "chat") return { ...result, command: "chat", chatArgv: [] };
   if (target.type === "issue") return { ...result, command: "ci", ciArgv: ["--issue", String(target.id)] };
-  if (target.type === "goal" || target.type === "workflow") return { ...result, command: "ci", ciArgv: [] };
+  if (target.type === "goal" || target.type === "loop" || target.type === "workflow") {
+    return { ...result, command: "ci", ciArgv: [] };
+  }
   return { ...result, errors: [`unsupported runRequest target: ${target.type ?? "unknown"}`] };
 }
 var HELP_TEXT = `kody-engine \u2014 single-session autonomous engineer

package/package.json

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