@kody-ade/kody-engine 0.4.570 → 0.4.572

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.570",
+      version: "0.4.572",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -150,9 +150,38 @@ var init_claudeBinary = __esm({
   }
 });
 
+// src/completionGuard.ts
+import * as path2 from "path";
+function completionToolCutoffAt(startedAtMs, deadlineAtMs) {
+  const availableMs = Math.max(0, deadlineAtMs - startedAtMs);
+  const reserveMs = Math.min(MAX_COMPLETION_RESERVE_MS, Math.floor(availableMs / 2));
+  return deadlineAtMs - reserveMs;
+}
+function createCompletionToolGuard(cutoffAtMs, now = Date.now, requiredOutputPath) {
+  return async (input) => {
+    if (now() < cutoffAtMs) return {};
+    const toolInput = input?.tool_input;
+    const filePath = toolInput && typeof toolInput === "object" && !Array.isArray(toolInput) ? toolInput.file_path : void 0;
+    if (requiredOutputPath && input?.tool_name === "Write" && typeof filePath === "string" && path2.resolve(filePath) === path2.resolve(requiredOutputPath)) {
+      return {};
+    }
+    return {
+      decision: "block",
+      reason: "The run has entered its reserved completion window. Do not call more tools. " + (requiredOutputPath ? `If the required structured result is missing, write only ${requiredOutputPath}. ` : "") + "Use the evidence and changes already present, state any verification limits clearly, and return your final response now."
+    };
+  };
+}
+var MAX_COMPLETION_RESERVE_MS;
+var init_completionGuard = __esm({
+  "src/completionGuard.ts"() {
+    "use strict";
+    MAX_COMPLETION_RESERVE_MS = 15 * 6e4;
+  }
+});
+
 // src/config.ts
 import * as fs2 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 function parseReasoningEffort(raw) {
   if (!raw) return null;
   const v = raw.trim().toLowerCase();
@@ -217,7 +246,7 @@ function needsLitellmProxy(model) {
   return model.provider !== "claude" && model.provider !== "anthropic";
 }
 function loadConfig(projectDir = process.cwd()) {
-  const configPath = path2.join(projectDir, "kody.config.json");
+  const configPath = path3.join(projectDir, "kody.config.json");
   if (!fs2.existsSync(configPath)) {
     throw new Error(`kody.config.json not found at ${configPath}`);
   }
@@ -548,6 +577,29 @@ var init_config = __esm({
   }
 });
 
+// src/fileEditGuards.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+function createMissingParentWriteGuard(cwd) {
+  return async (input) => {
+    const toolInput = input.tool_input;
+    if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) return {};
+    const filePath = toolInput.file_path;
+    if (typeof filePath !== "string" || filePath.length === 0) return {};
+    const resolvedPath = path4.resolve(cwd, filePath);
+    if (fs3.existsSync(path4.dirname(resolvedPath))) return {};
+    return {
+      decision: "block",
+      reason: `Cannot write ${resolvedPath}: its parent directory does not exist. Locate and edit the real repository source path first. If this task genuinely requires a new directory, create that directory explicitly before writing the file.`
+    };
+  };
+}
+var init_fileEditGuards = __esm({
+  "src/fileEditGuards.ts"() {
+    "use strict";
+  }
+});
+
 // src/format.ts
 function renderEvent(msg, opts = {}) {
   if (opts.quiet) {
@@ -669,29 +721,6 @@ var init_format = __esm({
   }
 });
 
-// src/fileEditGuards.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-function createMissingParentWriteGuard(cwd) {
-  return async (input) => {
-    const toolInput = input.tool_input;
-    if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) return {};
-    const filePath = toolInput.file_path;
-    if (typeof filePath !== "string" || filePath.length === 0) return {};
-    const resolvedPath = path3.resolve(cwd, filePath);
-    if (fs3.existsSync(path3.dirname(resolvedPath))) return {};
-    return {
-      decision: "block",
-      reason: `Cannot write ${resolvedPath}: its parent directory does not exist. Locate and edit the real repository source path first. If this task genuinely requires a new directory, create that directory explicitly before writing the file.`
-    };
-  };
-}
-var init_fileEditGuards = __esm({
-  "src/fileEditGuards.ts"() {
-    "use strict";
-  }
-});
-
 // src/agency/capability-contract-validation.ts
 import Ajv from "ajv";
 function createCapabilityContractValueValidator(compile) {
@@ -765,7 +794,7 @@ var init_capability_contract_validation = __esm({
 
 // src/outputContractHooks.ts
 import * as fs4 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 function outputContractError(contract) {
   let value;
   try {
@@ -784,12 +813,12 @@ function correctionMessage(contract, error) {
   return `The authoritative output does not match its required contract: ${error}. Please overwrite ${contract.path} with only the required JSON shape before finishing.`;
 }
 function createOutputContractPostWriteHook(contract) {
-  const expectedPath = path4.resolve(contract.path);
+  const expectedPath = path5.resolve(contract.path);
   return async (input) => {
     const toolInput = input.tool_input;
     if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) return {};
     const filePath = toolInput.file_path;
-    if (typeof filePath !== "string" || path4.resolve(filePath) !== expectedPath) return {};
+    if (typeof filePath !== "string" || path5.resolve(filePath) !== expectedPath) return {};
     const error = outputContractError(contract);
     if (!error) return {};
     return {
@@ -833,21 +862,21 @@ __export(runtimePaths_exports, {
 });
 import { createHash } from "crypto";
 import * as os2 from "os";
-import * as path5 from "path";
+import * as path6 from "path";
 function runtimeDirForCwd(cwd, ...parts) {
-  const key = createHash("sha256").update(path5.resolve(cwd)).digest("hex").slice(0, 16);
-  return path5.join(os2.tmpdir(), "kody-engine", key, ...parts);
+  const key = createHash("sha256").update(path6.resolve(cwd)).digest("hex").slice(0, 16);
+  return path6.join(os2.tmpdir(), "kody-engine", key, ...parts);
 }
 function runtimeStatePath(cwd, ...parts) {
   const configuredRoot = process.env.KODY_RUNTIME_DIR?.trim();
-  const base = configuredRoot ? path5.resolve(configuredRoot) : runtimeDirForCwd(cwd);
-  return path5.join(base, ...parts);
+  const base = configuredRoot ? path6.resolve(configuredRoot) : runtimeDirForCwd(cwd);
+  return path6.join(base, ...parts);
 }
 function agentRunDir(cwd) {
   return runtimeStatePath(cwd, "agent-runs");
 }
 function lastRunLogPath(cwd) {
-  return path5.join(agentRunDir(cwd), "last-run.jsonl");
+  return path6.join(agentRunDir(cwd), "last-run.jsonl");
 }
 var init_runtimePaths = __esm({
   "src/runtimePaths.ts"() {
@@ -858,15 +887,15 @@ var init_runtimePaths = __esm({
 // src/scripts/buildSyntheticPlugin.ts
 import * as fs5 from "fs";
 import * as os3 from "os";
-import * as path6 from "path";
+import * as path7 from "path";
 function getPluginsCatalogRoot() {
-  const here = path6.dirname(new URL(import.meta.url).pathname);
+  const here = path7.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path6.join(here, "..", "plugins"),
+    path7.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path6.join(here, "..", "..", "plugins"),
+    path7.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path6.join(here, "..", "..", "src", "plugins")
+    path7.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
@@ -877,8 +906,8 @@ function getPluginsCatalogRoot() {
 function copyDir(src, dst) {
   fs5.mkdirSync(dst, { recursive: true });
   for (const ent of fs5.readdirSync(src, { withFileTypes: true })) {
-    const s = path6.join(src, ent.name);
-    const d = path6.join(dst, ent.name);
+    const s = path7.join(src, ent.name);
+    const d = path7.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
     else if (ent.isFile()) fs5.copyFileSync(s, d);
   }
@@ -893,35 +922,35 @@ var init_buildSyntheticPlugin = __esm({
       if (!needsSynthetic) return;
       const catalog = getPluginsCatalogRoot();
       const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      const root = path6.join(os3.tmpdir(), `kody-synth-${runId}`);
-      fs5.mkdirSync(path6.join(root, ".claude-plugin"), { recursive: true });
+      const root = path7.join(os3.tmpdir(), `kody-synth-${runId}`);
+      fs5.mkdirSync(path7.join(root, ".claude-plugin"), { recursive: true });
       const resolvePart = (bucket, entry) => {
-        const local = path6.join(profile.dir, bucket, entry);
+        const local = path7.join(profile.dir, bucket, entry);
         if (fs5.existsSync(local)) return local;
-        const shared = path6.resolve(profile.dir, "..", "..", "shared", bucket, entry);
+        const shared = path7.resolve(profile.dir, "..", "..", "shared", bucket, entry);
         if (fs5.existsSync(shared)) return shared;
-        const central = path6.join(catalog, bucket, entry);
+        const central = path7.join(catalog, bucket, entry);
         if (fs5.existsSync(central)) return central;
         throw new Error(
-          `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in implementation dir (${profile.dir}/${bucket}/), Store shared assets (${path6.dirname(shared)}/), or catalog (${catalog}/${bucket}/)`
+          `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in implementation dir (${profile.dir}/${bucket}/), Store shared assets (${path7.dirname(shared)}/), or catalog (${catalog}/${bucket}/)`
         );
       };
       if (cc.skills.length > 0) {
-        const dst = path6.join(root, "skills");
+        const dst = path7.join(root, "skills");
         fs5.mkdirSync(dst, { recursive: true });
         for (const name of cc.skills) {
-          copyDir(resolvePart("skills", name), path6.join(dst, name));
+          copyDir(resolvePart("skills", name), path7.join(dst, name));
         }
       }
       if (cc.commands.length > 0) {
-        const dst = path6.join(root, "commands");
+        const dst = path7.join(root, "commands");
         fs5.mkdirSync(dst, { recursive: true });
         for (const name of cc.commands) {
-          fs5.copyFileSync(resolvePart("commands", `${name}.md`), path6.join(dst, `${name}.md`));
+          fs5.copyFileSync(resolvePart("commands", `${name}.md`), path7.join(dst, `${name}.md`));
         }
       }
       if (cc.hooks.length > 0) {
-        const dst = path6.join(root, "hooks");
+        const dst = path7.join(root, "hooks");
         fs5.mkdirSync(dst, { recursive: true });
         const merged = { hooks: {} };
         for (const name of cc.hooks) {
@@ -933,7 +962,7 @@ var init_buildSyntheticPlugin = __esm({
             merged.hooks[event].push(...entries);
           }
         }
-        fs5.writeFileSync(path6.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+        fs5.writeFileSync(path7.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
       }
       const manifest = {
@@ -943,7 +972,7 @@ var init_buildSyntheticPlugin = __esm({
       };
       if (cc.skills.length > 0) manifest.skills = ["./skills/"];
       if (cc.commands.length > 0) manifest.commands = ["./commands/"];
-      fs5.writeFileSync(path6.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+      fs5.writeFileSync(path7.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
       ctx.data.syntheticPluginPath = root;
     };
@@ -952,7 +981,7 @@ var init_buildSyntheticPlugin = __esm({
 
 // src/subagents.ts
 import * as fs6 from "fs";
-import * as path7 from "path";
+import * as path8 from "path";
 async function enforceSubagentModelInheritance(input) {
   const toolInput = input.tool_input;
   if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput)) return {};
@@ -987,11 +1016,11 @@ function splitFrontmatter(raw) {
   return { fm, body: (match[2] ?? "").trim() };
 }
 function resolveAgentFile(profileDir, name) {
-  const local = path7.join(profileDir, "agents", `${name}.md`);
+  const local = path8.join(profileDir, "agents", `${name}.md`);
   if (fs6.existsSync(local)) return local;
-  const shared = path7.resolve(profileDir, "..", "..", "shared", "agents", `${name}.md`);
+  const shared = path8.resolve(profileDir, "..", "..", "shared", "agents", `${name}.md`);
   if (fs6.existsSync(shared)) return shared;
-  const central = path7.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
+  const central = path8.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
   if (fs6.existsSync(central)) return central;
   throw new Error(
     `loadSubagents: agent '${name}' not found in ${profileDir}/agents/, hydrated shared assets, or engine catalog`
@@ -1048,7 +1077,7 @@ __export(events_exports, {
 });
 import * as crypto from "crypto";
 import * as fs7 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 function resolveRunId() {
   if (process.env.KODY_RUN_ID) {
     cachedRunId = process.env.KODY_RUN_ID;
@@ -1081,7 +1110,7 @@ function emitEvent(cwd, ev) {
       ...ev
     };
     const file = eventsPath(cwd, runId);
-    fs7.mkdirSync(path8.dirname(file), { recursive: true });
+    fs7.mkdirSync(path9.dirname(file), { recursive: true });
     fs7.appendFileSync(file, `${JSON.stringify(fullEvent)}
 `);
   } catch {
@@ -1107,7 +1136,7 @@ function listRuns(cwd) {
   if (!fs7.existsSync(runsDir)) return [];
   return fs7.readdirSync(runsDir).filter((name) => {
     try {
-      return fs7.statSync(path8.join(runsDir, name)).isDirectory();
+      return fs7.statSync(path9.join(runsDir, name)).isDirectory();
     } catch {
       return false;
     }
@@ -1148,10 +1177,10 @@ function abortMessage(signal) {
   return reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "verification aborted";
 }
 function runCommand(command, cwd, signal) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     const start = Date.now();
     if (signal?.aborted) {
-      resolve23({ exitCode: -1, durationMs: 0, tail: abortMessage(signal) });
+      resolve24({ exitCode: -1, durationMs: 0, tail: abortMessage(signal) });
       return;
     }
     const child = spawn(command, {
@@ -1189,7 +1218,7 @@ function runCommand(command, cwd, signal) {
       signal?.removeEventListener("abort", onAbort);
       const output = Buffer.concat(buffers).toString("utf-8");
       const tail = [output, extraTail].filter(Boolean).join("\n").slice(-TAIL_CHARS);
-      resolve23({ exitCode, durationMs: Date.now() - start, tail });
+      resolve24({ exitCode, durationMs: Date.now() - start, tail });
     };
     const terminate = () => {
       killTree("SIGTERM");
@@ -1518,7 +1547,7 @@ function cmsHeaders(opts) {
     }
   };
 }
-async function callDashboardCms(opts, path58, init = {}) {
+async function callDashboardCms(opts, path59, init = {}) {
   const baseUrl = dashboardBaseUrl(opts);
   if (!baseUrl) {
     return {
@@ -1530,7 +1559,7 @@ async function callDashboardCms(opts, path58, init = {}) {
   const headerResult = cmsHeaders(opts);
   if (!headerResult.ok) return headerResult;
   try {
-    const res = await fetch(`${baseUrl}${path58}`, {
+    const res = await fetch(`${baseUrl}${path59}`, {
       ...init,
       headers: {
         ...headerResult.headers,
@@ -1602,8 +1631,8 @@ function documentArg(value) {
 function normalizeCmsDocumentIdInput(input) {
   const trimmed = stripWrappingQuotes(input.trim());
   const withoutQuery = trimmed.split(/[?#]/, 1)[0] ?? trimmed;
-  const path58 = parseDocumentPath(withoutQuery);
-  return path58 ?? parseDocumentIdSegment(withoutQuery) ?? withoutQuery;
+  const path59 = parseDocumentPath(withoutQuery);
+  return path59 ?? parseDocumentIdSegment(withoutQuery) ?? withoutQuery;
 }
 function stripWrappingQuotes(value) {
   let current = value;
@@ -1614,9 +1643,9 @@ function stripWrappingQuotes(value) {
   }
 }
 function parseDocumentPath(value) {
-  const path58 = value.startsWith("http://") || value.startsWith("https://") ? urlPathname(value) : value;
-  if (!path58?.includes("/content/entries/")) return null;
-  const parts = path58.split("/").filter(Boolean).map(decodePathPart);
+  const path59 = value.startsWith("http://") || value.startsWith("https://") ? urlPathname(value) : value;
+  if (!path59?.includes("/content/entries/")) return null;
+  const parts = path59.split("/").filter(Boolean).map(decodePathPart);
   const entriesIndex = parts.findIndex((part, index) => part === "content" && parts[index + 1] === "entries");
   const idPart = parts[entriesIndex + 3];
   if (!idPart || idPart === "new") return null;
@@ -2062,7 +2091,7 @@ var init_issue = __esm({
 
 // src/capabilityFolders.ts
 import * as fs8 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 function capabilityOutputConditionPaths(config) {
   if (config.outputSchema) {
     return new Set(schemaPropertyPaths(config.outputSchema, "result"));
@@ -2084,35 +2113,35 @@ function listCapabilityFolderSlugs(absDir) {
   } catch {
     return [];
   }
-  return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).filter((e) => isCapabilityFolder(path9.join(absDir, e.name))).map((e) => e.name).sort();
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).filter((e) => isCapabilityFolder(path10.join(absDir, e.name))).map((e) => e.name).sort();
 }
 function isCapabilityFolder(dir) {
   const entries = fs8.readdirSync(dir, { withFileTypes: true });
-  const legacyBody = path9.join(dir, CAPABILITY_BODY_FILE);
+  const legacyBody = path10.join(dir, CAPABILITY_BODY_FILE);
   if (fs8.existsSync(legacyBody)) {
     return entries.every(
       (entry) => entry.name === CAPABILITY_BODY_FILE || entry.name === CAPABILITY_CONTRACT_FILE || entry.isDirectory() && (entry.name === "skills" || entry.name === "tools")
     );
   }
-  const canonicalBody = path9.join(dir, CANONICAL_CAPABILITY_BODY_FILE);
-  const canonicalDefinition = path9.join(dir, CANONICAL_CAPABILITY_DEFINITION_FILE);
+  const canonicalBody = path10.join(dir, CANONICAL_CAPABILITY_BODY_FILE);
+  const canonicalDefinition = path10.join(dir, CANONICAL_CAPABILITY_DEFINITION_FILE);
   if (!fs8.existsSync(canonicalBody) || !fs8.existsSync(canonicalDefinition)) return false;
   return entries.every(
     (entry) => entry.name === CANONICAL_CAPABILITY_BODY_FILE || entry.name === CANONICAL_CAPABILITY_DEFINITION_FILE
   );
 }
 function readCapabilityFolder(root, slug) {
-  const dir = path9.join(root, slug);
-  const legacyBodyPath = path9.join(dir, CAPABILITY_BODY_FILE);
-  const canonicalBodyPath = path9.join(dir, CANONICAL_CAPABILITY_BODY_FILE);
+  const dir = path10.join(root, slug);
+  const legacyBodyPath = path10.join(dir, CAPABILITY_BODY_FILE);
+  const canonicalBodyPath = path10.join(dir, CANONICAL_CAPABILITY_BODY_FILE);
   const bodyPath = fs8.existsSync(legacyBodyPath) ? legacyBodyPath : canonicalBodyPath;
-  const contractPath = path9.join(dir, CAPABILITY_CONTRACT_FILE);
+  const contractPath = path10.join(dir, CAPABILITY_CONTRACT_FILE);
   if (!fs8.existsSync(bodyPath) || !fs8.statSync(bodyPath).isFile()) return null;
   if (!isCapabilityFolder(dir)) return null;
   try {
     const rawBody = fs8.readFileSync(bodyPath, "utf-8");
     if (bodyPath === canonicalBodyPath) {
-      const definitionPath = path9.join(dir, CANONICAL_CAPABILITY_DEFINITION_FILE);
+      const definitionPath = path10.join(dir, CANONICAL_CAPABILITY_DEFINITION_FILE);
       const definition = JSON.parse(fs8.readFileSync(definitionPath, "utf-8"));
       if (definition.id !== slug || typeof definition.action !== "string") return null;
       const { title: title2, body: body2 } = parseCapabilityBody(rawBody, slug);
@@ -2134,7 +2163,7 @@ function readCapabilityFolder(root, slug) {
       };
     }
     const contract = fs8.existsSync(contractPath) ? parseCapabilityContract(fs8.readFileSync(contractPath, "utf-8")) : void 0;
-    if (contract?.execution === "script" && !isRegularFile(path9.join(dir, "tools", "run.sh"))) {
+    if (contract?.execution === "script" && !isRegularFile(path10.join(dir, "tools", "run.sh"))) {
       throw new Error('script-backed Capability requires a regular "tools/run.sh" file');
     }
     const { title, body } = parseCapabilityBody(rawBody, slug);
@@ -2256,8 +2285,8 @@ function isRegularFile(filePath) {
 function schemaPropertyPaths(schema, prefix) {
   const properties = isPlainObject(schema.properties) ? schema.properties : {};
   return Object.entries(properties).flatMap(([name, property]) => {
-    const path58 = `${prefix}.${name}`;
-    return isPlainObject(property) ? [path58, ...schemaPropertyPaths(property, path58)] : [path58];
+    const path59 = `${prefix}.${name}`;
+    return isPlainObject(property) ? [path59, ...schemaPropertyPaths(property, path59)] : [path59];
   });
 }
 function parseCapabilityBody(raw, slug) {
@@ -2424,47 +2453,47 @@ var init_capabilityFolders = __esm({
 
 // src/definition-paths.ts
 import * as fs9 from "fs";
-import * as path10 from "path";
+import * as path11 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 && path10.resolve(cwd) === path10.resolve(overrideCwd)) {
-    return storeCatalogRoot(path10.resolve(override));
+  if (override && overrideCwd && path11.resolve(cwd) === path11.resolve(overrideCwd)) {
+    return storeCatalogRoot(path11.resolve(override));
   }
-  const hydrated = path10.join(cwd, ".kody-engine", "definitions");
+  const hydrated = path11.join(cwd, ".kody-engine", "definitions");
   if (fs9.existsSync(hydrated)) return hydrated;
-  return override ? storeCatalogRoot(path10.resolve(override)) : hydrated;
+  return override ? storeCatalogRoot(path11.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 && path10.resolve(cwd) === path10.resolve(rootCwd));
+  return Boolean(root && rootCwd && path11.resolve(cwd) === path11.resolve(rootCwd));
 }
 function capabilitiesRoot(cwd = process.cwd()) {
-  return storeAssetRoot(cwd, "capabilities") ?? path10.join(definitionsRoot(cwd), "capabilities");
+  return storeAssetRoot(cwd, "capabilities") ?? path11.join(definitionsRoot(cwd), "capabilities");
 }
 function implementationsRoot(cwd = process.cwd()) {
-  return path10.join(definitionsRoot(cwd), "implementations");
+  return path11.join(definitionsRoot(cwd), "implementations");
 }
 function agentsRoot(cwd = process.cwd()) {
-  return storeAssetRoot(cwd, "agent") ?? path10.join(definitionsRoot(cwd), "agents");
+  return storeAssetRoot(cwd, "agent") ?? path11.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) => path10.dirname(value));
-  return roots.length === 3 && new Set(roots).size === 1 ? path10.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) => path11.dirname(value));
+  return roots.length === 3 && new Set(roots).size === 1 ? path11.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 && path10.resolve(cwd) !== path10.resolve(overrideCwd)) return null;
-  const root = path10.resolve(override);
+  if (overrideCwd && path11.resolve(cwd) !== path11.resolve(overrideCwd)) return null;
+  const root = path11.resolve(override);
   const configured = readStoreManifest(root)?.assetRoots?.[kind];
-  return typeof configured === "string" && configured.trim() ? path10.join(root, configured) : null;
+  return typeof configured === "string" && configured.trim() ? path11.join(root, configured) : null;
 }
 function readStoreManifest(root) {
-  const file = path10.join(root, "kody-store.json");
+  const file = path11.join(root, "kody-store.json");
   if (!fs9.existsSync(file)) return null;
   try {
     return JSON.parse(fs9.readFileSync(file, "utf8"));
@@ -2480,15 +2509,15 @@ var init_definition_paths = __esm({
 
 // src/registry.ts
 import * as fs10 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 function getImplementationsRoot() {
-  const here = path11.dirname(new URL(import.meta.url).pathname);
+  const here = path12.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path11.join(here, "implementations"),
+    path12.join(here, "implementations"),
     // dev: src/
-    path11.join(here, "..", "implementations"),
+    path12.join(here, "..", "implementations"),
     // built: dist/bin → dist/implementations
-    path11.join(here, "..", "src", "implementations")
+    path12.join(here, "..", "src", "implementations")
     // fallback
   ];
   for (const c of candidates) {
@@ -2497,11 +2526,11 @@ function getImplementationsRoot() {
   return candidates[0];
 }
 function getRuntimeServicesRoot() {
-  const here = path11.dirname(new URL(import.meta.url).pathname);
+  const here = path12.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path11.join(here, "runtime-services"),
-    path11.join(here, "..", "runtime-services"),
-    path11.join(here, "..", "src", "runtime-services")
+    path12.join(here, "runtime-services"),
+    path12.join(here, "..", "runtime-services"),
+    path12.join(here, "..", "src", "runtime-services")
   ];
   for (const candidate of candidates) {
     if (fs10.existsSync(candidate) && fs10.statSync(candidate).isDirectory()) return candidate;
@@ -2512,13 +2541,13 @@ function getProjectCapabilitiesRoot() {
   return capabilitiesRoot();
 }
 function getBuiltinCapabilitiesRoot() {
-  const here = path11.dirname(new URL(import.meta.url).pathname);
+  const here = path12.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path11.join(here, "capabilities"),
+    path12.join(here, "capabilities"),
     // dev: src/
-    path11.join(here, "..", "capabilities"),
+    path12.join(here, "..", "capabilities"),
     // built: dist/bin → dist/capabilities
-    path11.join(here, "..", "src", "capabilities")
+    path12.join(here, "..", "src", "capabilities")
     // fallback
   ];
   for (const c of candidates) {
@@ -2662,17 +2691,17 @@ function isSafeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
 }
 function isCapabilityRoot(root) {
-  const normalized = path11.normalize(root);
-  if (path11.basename(normalized) === "capabilities") return true;
+  const normalized = path12.normalize(root);
+  if (path12.basename(normalized) === "capabilities") return true;
   const knownRoots = [getProjectCapabilitiesRoot(), getBuiltinCapabilitiesRoot()];
-  return knownRoots.some((candidate) => candidate && path11.normalize(candidate) === normalized);
+  return knownRoots.some((candidate) => candidate && path12.normalize(candidate) === normalized);
 }
 function implementationRuntimePath(root, name) {
-  const runtimePath = path11.join(root, name, "runtime.json");
+  const runtimePath = path12.join(root, name, "runtime.json");
   if (fs10.existsSync(runtimePath)) return runtimePath;
-  const internalProfilePath = path11.join(root, name, "profile.json");
+  const internalProfilePath = path12.join(root, name, "profile.json");
   if (fs10.existsSync(internalProfilePath)) return internalProfilePath;
-  return path11.join(root, name, CAPABILITY_PROFILE_FILE);
+  return path12.join(root, name, CAPABILITY_PROFILE_FILE);
 }
 function isImplementationProfile(profilePath, requireImplementationProfile) {
   if (!requireImplementationProfile) return true;
@@ -3839,7 +3868,7 @@ var init_capabilityMcp = __esm({
 // src/repoWorkspace.ts
 import { spawn as spawn2, spawnSync } from "child_process";
 import * as fs11 from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 function buildCloneProcess(repo, token, baseEnv = process.env) {
   const url = `https://github.com/${repo}.git`;
   const env = { ...baseEnv };
@@ -3854,10 +3883,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 = path12.resolve(reposRoot);
-  const dir = path12.resolve(root, name);
-  if (dir !== root && !dir.startsWith(root + path12.sep)) return null;
-  if (fs11.existsSync(path12.join(dir, ".git"))) return dir;
+  const root = path13.resolve(reposRoot);
+  const dir = path13.resolve(root, name);
+  if (dir !== root && !dir.startsWith(root + path13.sep)) return null;
+  if (fs11.existsSync(path13.join(dir, ".git"))) return dir;
   const inflight = repoClones.get(dir);
   if (inflight) {
     await inflight;
@@ -3889,9 +3918,9 @@ 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) => {
-      fs11.mkdirSync(path12.dirname(dir), { recursive: true });
+      fs11.mkdirSync(path13.dirname(dir), { recursive: true });
       const clone = buildCloneProcess(repo, token);
-      return new Promise((resolve23, reject) => {
+      return new Promise((resolve24, reject) => {
         const child = spawn2("git", ["clone", "--depth=1", clone.url, dir], {
           env: clone.env,
           stdio: "inherit"
@@ -3911,7 +3940,7 @@ var init_repoWorkspace = __esm({
             }
           } catch {
           }
-          resolve23();
+          resolve24();
         });
         child.on("error", reject);
       });
@@ -3984,7 +4013,7 @@ var init_fetchRepoMcp = __esm({
 
 // src/agent.ts
 import * as fs12 from "fs";
-import * as path13 from "path";
+import * as path14 from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 function classifySubtype(subtype) {
   if (!subtype) return "generic_failed";
@@ -4054,7 +4083,7 @@ function buildAgentEnvironment(baseEnv, repoToken, requestEnvironment) {
 async function runAgent(opts) {
   const ndjsonDir = opts.ndjsonDir ?? agentRunDir(opts.cwd);
   fs12.mkdirSync(ndjsonDir, { recursive: true });
-  const ndjsonPath = path13.join(ndjsonDir, "last-run.jsonl");
+  const ndjsonPath = path14.join(ndjsonDir, "last-run.jsonl");
   const env = buildAgentEnvironment(process.env, opts.repoToken, opts.environment);
   if (opts.litellmUrl) {
     env.ANTHROPIC_BASE_URL = opts.litellmUrl;
@@ -4062,6 +4091,11 @@ async function runAgent(opts) {
   }
   const startedAt = Date.now();
   const turnTimeoutMs = resolveTurnTimeoutMs(opts);
+  const completionGuard = typeof opts.deadlineAtMs === "number" ? createCompletionToolGuard(
+    completionToolCutoffAt(startedAt, opts.deadlineAtMs),
+    Date.now,
+    opts.outputContract?.path
+  ) : null;
   let outcome = "failed";
   let outcomeKind = "generic_failed";
   let errorMessage2;
@@ -4106,6 +4140,11 @@ async function runAgent(opts) {
         env,
         hooks: {
           PreToolUse: [
+            ...completionGuard ? [
+              {
+                hooks: [completionGuard]
+              }
+            ] : [],
             {
               matcher: "Agent",
               hooks: [enforceSubagentModelInheritance]
@@ -4229,11 +4268,13 @@ async function runAgent(opts) {
       } else if (typeof opts.maxThinkingTokens === "number" && opts.maxThinkingTokens > 0) {
         queryOptions.maxThinkingTokens = opts.maxThinkingTokens;
       }
-      if (typeof opts.systemPromptAppend === "string" && opts.systemPromptAppend.length > 0) {
+      const completionNotice = completionGuard ? "Work within the enforced run time. Tool access closes before the hard deadline to reserve time for a final response. When that happens, stop using tools and finish immediately." : null;
+      const systemPromptAppend = [opts.systemPromptAppend, completionNotice].filter((value) => typeof value === "string" && value.length > 0).join("\n\n");
+      if (systemPromptAppend.length > 0) {
         const systemPrompt = {
           type: "preset",
           preset: "claude_code",
-          append: opts.systemPromptAppend
+          append: systemPromptAppend
         };
         if (opts.cacheable) systemPrompt.excludeDynamicSections = true;
         queryOptions.systemPrompt = systemPrompt;
@@ -4263,10 +4304,10 @@ async function runAgent(opts) {
         let timer;
         let next;
         if (turnTimeoutMs > 0) {
-          const timeoutPromise = new Promise((resolve23) => {
+          const timeoutPromise = new Promise((resolve24) => {
             timer = setTimeout(() => {
               timedOut = true;
-              resolve23({ done: true, value: void 0 });
+              resolve24({ done: true, value: void 0 });
             }, turnTimeoutMs);
           });
           next = await Promise.race([nextPromise, timeoutPromise]);
@@ -4282,7 +4323,7 @@ async function runAgent(opts) {
             try {
               await Promise.race([
                 iterator.return(void 0).catch(() => void 0),
-                new Promise((resolve23) => setTimeout(resolve23, 1e4).unref())
+                new Promise((resolve24) => setTimeout(resolve24, 1e4).unref())
               ]);
             } catch {
             }
@@ -4463,9 +4504,10 @@ var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
     init_claudeBinary();
+    init_completionGuard();
     init_config();
-    init_format();
     init_fileEditGuards();
+    init_format();
     init_outputContractHooks();
     init_runtimePaths();
     init_subagents();
@@ -4488,7 +4530,7 @@ var init_agent = __esm({
 
 // src/agents.ts
 import * as fs13 from "fs";
-import * as path14 from "path";
+import * as path15 from "path";
 function stripFrontmatter(raw) {
   const match = /^---\n[\s\S]*?\n---\n?([\s\S]*)$/.exec(raw);
   return (match ? match[1] : raw).trim();
@@ -4509,7 +4551,7 @@ function loadAgentIdentity(cwd, slug, agentsDir = agentsRoot(cwd)) {
   throw new Error(`loadAgentIdentity: agent '${trimmed}' declared but ${agentPath} does not exist`);
 }
 function resolveAgentFile2(cwd, slug, agentsDir = agentsRoot(cwd)) {
-  const localPath = path14.resolve(cwd, agentsDir, `${slug}.md`);
+  const localPath = path15.resolve(cwd, agentsDir, `${slug}.md`);
   if (fs13.existsSync(localPath)) return localPath;
   return localPath;
 }
@@ -4543,7 +4585,7 @@ var init_agents = __esm({
 
 // src/task-artifacts.ts
 import fs14 from "fs";
-import path15 from "path";
+import path16 from "path";
 import posixPath from "path/posix";
 function prepareTaskArtifactsDir(cwd, taskId) {
   const safeId = String(taskId).replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -4579,14 +4621,14 @@ 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 = path15.join(artifacts.absDir, file);
+    const full = path16.join(artifacts.absDir, file);
     if (!fs14.existsSync(full)) fs14.writeFileSync(full, defaults[file], "utf8");
   }
 }
 function verifyTaskArtifacts(absDir) {
   const missing = [];
   for (const name of TASK_ARTIFACT_FILES) {
-    const full = path15.join(absDir, name);
+    const full = path16.join(absDir, name);
     try {
       const stat = fs14.statSync(full);
       if (!stat.isFile() || stat.size === 0) missing.push(name);
@@ -4604,7 +4646,7 @@ async function persistTaskArtifactsToState(config, _cwd, artifacts) {
   if (hasStateBackendConfig() && tenantId2) {
     const backend = createStateBackendFromEnv();
     for (const file of TASK_ARTIFACT_FILES) {
-      const full = path15.join(artifacts.absDir, file);
+      const full = path16.join(artifacts.absDir, file);
       if (!fs14.existsSync(full)) continue;
       const stat = fs14.statSync(full);
       if (!stat.isFile() || stat.size === 0) continue;
@@ -4917,15 +4959,15 @@ function validateWorkflow(value, options = {}) {
   }
   return issues;
 }
-function validateInputBindings(value, path58, issues, declaredInputs) {
+function validateInputBindings(value, path59, issues, declaredInputs) {
   if (value === void 0) return;
   const bindings = asRecord(value);
   if (!bindings || Object.keys(bindings).length === 0) {
-    issue(issues, "invalid_inputs", path58, "workflow step inputs must contain at least one named mapping");
+    issue(issues, "invalid_inputs", path59, "workflow step inputs must contain at least one named mapping");
     return;
   }
   for (const [name, value2] of Object.entries(bindings)) {
-    const bindingPath = `${path58}.${name}`;
+    const bindingPath = `${path59}.${name}`;
     if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(name)) {
       issue(issues, "invalid_input_name", bindingPath, `workflow input name ${name} is invalid`);
     }
@@ -4944,7 +4986,7 @@ function validateInputBindings(value, path58, issues, declaredInputs) {
     }
   }
 }
-function validateInputBindingSources(value, path58, issues, capabilitiesByStep, capabilityOutputs) {
+function validateInputBindingSources(value, path59, issues, capabilitiesByStep, capabilityOutputs) {
   const bindings = asRecord(value);
   if (!bindings) return;
   for (const [name, rawBinding] of Object.entries(bindings)) {
@@ -4957,7 +4999,7 @@ function validateInputBindingSources(value, path58, issues, capabilitiesByStep,
       issue(
         issues,
         "missing_input_step",
-        `${path58}.${name}.from`,
+        `${path59}.${name}.from`,
         `workflow input mapping references missing step ${sourceStep ?? "<none>"}`
       );
       continue;
@@ -4968,7 +5010,7 @@ function validateInputBindingSources(value, path58, issues, capabilitiesByStep,
       issue(
         issues,
         "undeclared_step_output",
-        `${path58}.${name}.from`,
+        `${path59}.${name}.from`,
         `workflow input mapping reads ${outputPath}, but step ${sourceStep} does not declare it`
       );
     }
@@ -4977,11 +5019,11 @@ function validateInputBindingSources(value, path58, issues, capabilitiesByStep,
 function formatWorkflowValidationIssues(issues) {
   return issues.map((entry) => `${entry.path}: ${entry.message}`);
 }
-function validateDataMatch(value, path58, issues, capabilityOutputs) {
+function validateDataMatch(value, path59, issues, capabilityOutputs) {
   if (value === void 0) return;
   const match = asRecord(value);
   if (!match || Object.keys(match).length === 0) {
-    issue(issues, "invalid_condition", path58, "workflow condition must contain at least one match");
+    issue(issues, "invalid_condition", path59, "workflow condition must contain at least one match");
     return;
   }
   for (const [field, expected] of Object.entries(match)) {
@@ -4989,7 +5031,7 @@ function validateDataMatch(value, path58, issues, capabilityOutputs) {
       issue(
         issues,
         "invalid_data_path",
-        `${path58}.${field}`,
+        `${path59}.${field}`,
         `workflow condition must read from facts, evidence, artifacts, result, workflow, or lastOutcome`
       );
     }
@@ -4997,12 +5039,12 @@ function validateDataMatch(value, path58, issues, capabilityOutputs) {
       issue(
         issues,
         "undeclared_result_path",
-        `${path58}.${field}`,
+        `${path59}.${field}`,
         `workflow condition reads ${field}, but the source capability does not declare it`
       );
     }
     if (!isComparable(expected)) {
-      issue(issues, "invalid_condition_value", `${path58}.${field}`, "workflow condition value must be a JSON scalar");
+      issue(issues, "invalid_condition_value", `${path59}.${field}`, "workflow condition value must be a JSON scalar");
     }
   }
 }
@@ -5026,8 +5068,8 @@ function isJsonValue(value) {
   if (!value || typeof value !== "object") return false;
   return Object.values(value).every(isJsonValue);
 }
-function issue(issues, code, path58, message) {
-  issues.push({ code, path: path58, message });
+function issue(issues, code, path59, message) {
+  issues.push({ code, path: path59, message });
 }
 var SAFE_NAME, SAFE_STEP_ID, SAFE_DATA_PATH, SAFE_INPUT_SOURCE, SUPPORTED_STEP_FIELDS, SUPPORTED_TRANSITION_FIELDS;
 var init_workflowValidation = __esm({
@@ -5061,7 +5103,7 @@ var init_workflowValidation = __esm({
 
 // src/workflowDefinitions.ts
 import * as fs20 from "fs";
-import * as path21 from "path";
+import * as path22 from "path";
 function isWorkflowDefinitionId(value) {
   return WORKFLOW_ID_PATTERN.test(value);
 }
@@ -5106,8 +5148,8 @@ function readWorkflowDefinition(_config, cwd, id) {
   const root = cwd ?? process.cwd();
   const relativePath = workflowDefinitionPath(id);
   const candidates = [
-    path21.join(root, ".kody-engine", "runtime", relativePath),
-    path21.join(definitionsRoot(root), relativePath)
+    path22.join(root, ".kody-engine", "runtime", relativePath),
+    path22.join(definitionsRoot(root), relativePath)
   ];
   for (const filePath of candidates) {
     if (!fs20.existsSync(filePath)) continue;
@@ -5119,7 +5161,7 @@ function readWorkflowDefinition(_config, cwd, id) {
 function workflowDefinitionToCapabilityFolder(id, workflow, source = workflowDefinitionPath(id)) {
   return {
     slug: id,
-    dir: path21.dirname(source),
+    dir: path22.dirname(source),
     profilePath: source,
     bodyPath: source,
     title: workflow.name,
@@ -5720,7 +5762,7 @@ var init_lifecycles = __esm({
 // src/profile.ts
 import { createHash as createHash3 } from "crypto";
 import * as fs24 from "fs";
-import * as path23 from "path";
+import * as path24 from "path";
 function loadProfile(profilePath) {
   if (!fs24.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
@@ -5739,7 +5781,7 @@ function loadProfile(profilePath) {
   const unknownKeys = Object.keys(r).filter((k) => !KNOWN_PROFILE_KEYS.has(k));
   if (unknownKeys.length > 0) {
     process.stderr.write(
-      `[kody profile] ${path23.basename(path23.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
+      `[kody profile] ${path24.basename(path24.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
 `
     );
   }
@@ -5749,7 +5791,7 @@ function loadProfile(profilePath) {
     if (!refPath) {
       throw new ProfileError(profilePath, `capability references unknown implementation '${execRef}'`);
     }
-    if (path23.resolve(refPath) === path23.resolve(profilePath)) {
+    if (path24.resolve(refPath) === path24.resolve(profilePath)) {
     } else {
       const base = loadProfile(refPath);
       return {
@@ -5847,8 +5889,8 @@ function loadProfile(profilePath) {
     // Phase 5 in-process handoff opt-in. Default false; containers
     // flip to true after end-to-end verification.
     preloadContext: r.preloadContext === true,
-    dir: path23.dirname(profilePath),
-    promptTemplates: readPromptTemplates(path23.dirname(profilePath))
+    dir: path24.dirname(profilePath),
+    promptTemplates: readPromptTemplates(path24.dirname(profilePath))
   };
   if (lifecycle) {
     applyLifecycle(profile, profilePath);
@@ -5883,19 +5925,19 @@ function loadProfile(profilePath) {
   return profile;
 }
 function compileRuntimeDocument(runtimePath, document) {
-  if (path23.basename(runtimePath) !== "runtime.json") return document;
+  if (path24.basename(runtimePath) !== "runtime.json") return document;
   if (document.adapter !== "kody-engine-profile") {
     throw new ProfileError(runtimePath, "unsupported runtime adapter document");
   }
-  const implementationDir = path23.dirname(runtimePath);
-  const implementation = readJsonObject(path23.join(implementationDir, "definition.json"), "Implementation definition");
-  const definitionsRoot2 = path23.dirname(path23.dirname(implementationDir));
+  const implementationDir = path24.dirname(runtimePath);
+  const implementation = readJsonObject(path24.join(implementationDir, "definition.json"), "Implementation definition");
+  const definitionsRoot2 = path24.dirname(path24.dirname(implementationDir));
   const capabilityId = implementation.capabilityRef && typeof implementation.capabilityRef === "object" && !Array.isArray(implementation.capabilityRef) ? implementation.capabilityRef.id : void 0;
   if (typeof capabilityId !== "string" || !capabilityId) {
     throw new ProfileError(runtimePath, "Implementation capabilityRef is invalid");
   }
   const capability = readJsonObject(
-    path23.join(definitionsRoot2, "capabilities", capabilityId, "definition.json"),
+    path24.join(definitionsRoot2, "capabilities", capabilityId, "definition.json"),
     "Capability definition"
   );
   const {
@@ -5956,13 +5998,13 @@ function readPromptTemplates(dir) {
     } catch {
     }
   };
-  read(path23.join(dir, "prompt.md"));
-  read(path23.join(dir, "capability.md"));
-  read(path23.join(dir, "capability.md"));
+  read(path24.join(dir, "prompt.md"));
+  read(path24.join(dir, "capability.md"));
+  read(path24.join(dir, "capability.md"));
   try {
-    const promptsDir = path23.join(dir, "prompts");
+    const promptsDir = path24.join(dir, "prompts");
     for (const ent of fs24.readdirSync(promptsDir)) {
-      if (ent.endsWith(".md")) read(path23.join(promptsDir, ent));
+      if (ent.endsWith(".md")) read(path24.join(promptsDir, ent));
     }
   } catch {
   }
@@ -6740,11 +6782,11 @@ var init_state = __esm({
 
 // src/prompt.ts
 import * as fs25 from "fs";
-import * as path24 from "path";
+import * as path25 from "path";
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path24.join(projectDir, rel);
+    const abs = path25.join(projectDir, rel);
     if (!fs25.existsSync(abs)) continue;
     let content;
     try {
@@ -6984,7 +7026,7 @@ __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
 import * as fs26 from "fs";
-import * as path25 from "path";
+import * as path26 from "path";
 function formatBlockFromBackend(docs) {
   const pages = docs.flatMap((record2) => {
     if (!record2.doc || typeof record2.doc !== "object") return [];
@@ -7018,10 +7060,10 @@ function collectPages(memoryAbs) {
       return;
     }
     const fm = raw.match(/^---\s*\n([\s\S]*?)\n---/);
-    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path25.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path26.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path25.relative(memoryAbs, file),
+      relPath: path26.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX2 : raw,
@@ -7095,7 +7137,7 @@ function walkMd(root, visit) {
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path25.join(dir, name);
+      const full = path26.join(dir, name);
       let stat;
       try {
         stat = fs26.statSync(full);
@@ -7133,7 +7175,7 @@ var init_loadMemoryContext = __esm({
         }
         return;
       }
-      const memoryAbs = path25.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+      const memoryAbs = path26.join(ctx.cwd, MEMORY_DIR_RELATIVE);
       if (!fs26.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
@@ -7649,7 +7691,7 @@ import { execFileSync as execFileSync4, spawn as spawn4 } from "child_process";
 import * as fs28 from "fs";
 import * as net from "net";
 import * as os4 from "os";
-import * as path26 from "path";
+import * as path27 from "path";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -7762,10 +7804,10 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   const spawnProxy = () => {
     const portMatch = activeUrl.match(/:(\d+)/);
     const port = portMatch ? portMatch[1] : "4000";
-    const configPath = path26.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
+    const configPath = path27.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
     fs28.writeFileSync(configPath, generateLitellmConfigYaml(model));
     const args = ["--config", configPath, "--port", port];
-    const nextLogPath = path26.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.log`);
+    const nextLogPath = path27.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.log`);
     const outFd = fs28.openSync(nextLogPath, "w");
     child = spawn4(cmd, args, { stdio: ["ignore", outFd, outFd], detached: true, env: childEnv });
     fs28.closeSync(outFd);
@@ -7855,17 +7897,17 @@ async function nextAvailableLitellmUrl(url) {
   throw new Error(`no free LiteLLM port found after ${startPort}`);
 }
 function canListen(port, host) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     const server = net.createServer();
-    server.once("error", () => resolve23(false));
+    server.once("error", () => resolve24(false));
     server.once("listening", () => {
-      server.close(() => resolve23(true));
+      server.close(() => resolve24(true));
     });
     server.listen(port, host);
   });
 }
 function readDotenvApiKeys(projectDir) {
-  const dotenvPath = path26.join(projectDir, ".env");
+  const dotenvPath = path27.join(projectDir, ".env");
   if (!fs28.existsSync(dotenvPath)) return {};
   const result = {};
   for (const rawLine of fs28.readFileSync(dotenvPath, "utf-8").split("\n")) {
@@ -8528,7 +8570,7 @@ var init_pushWithRetry = __esm({
 // src/commit.ts
 import { execFileSync as execFileSync6 } from "child_process";
 import * as fs29 from "fs";
-import * as path27 from "path";
+import * as path28 from "path";
 function isGitHubYamlPath(filePath) {
   const normalized = filePath.replace(/^\.\/+/, "");
   return normalized.startsWith(".github/") && /\.ya?ml$/i.test(normalized);
@@ -8570,18 +8612,18 @@ function ensureGitIdentity(cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path27.join(cwd ?? process.cwd(), ".git");
+  const gitDir = path28.join(cwd ?? process.cwd(), ".git");
   if (!fs29.existsSync(gitDir)) return aborted;
-  if (fs29.existsSync(path27.join(gitDir, "MERGE_HEAD"))) {
+  if (fs29.existsSync(path28.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs29.existsSync(path27.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs29.existsSync(path28.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs29.existsSync(path27.join(gitDir, "REVERT_HEAD"))) {
+  if (fs29.existsSync(path28.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs29.existsSync(path27.join(gitDir, "rebase-merge")) || fs29.existsSync(path27.join(gitDir, "rebase-apply"))) {
+  if (fs29.existsSync(path28.join(gitDir, "rebase-merge")) || fs29.existsSync(path28.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -8638,7 +8680,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs29.existsSync(path27.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs29.existsSync(path28.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -9282,9 +9324,9 @@ import * as fs30 from "fs";
 function stageGoalRunLogEvent(data, goalId, event, at = nowIso()) {
   const logs = goalRunLogs(data);
   const existing = logs[goalId];
-  const path58 = existing?.path ?? goalRunLogPath(goalId, data);
+  const path59 = existing?.path ?? goalRunLogPath(goalId, data);
   logs[goalId] = {
-    path: path58,
+    path: path59,
     events: [...existing?.events ?? [], buildGoalRunLogEvent(data, goalId, event, at)]
   };
 }
@@ -9732,7 +9774,7 @@ var init_stateStore = __esm({
 
 // src/goal/targetLoopResolution.ts
 import * as fs31 from "fs";
-import * as path28 from "path";
+import * as path29 from "path";
 async function resolveActiveGoalLoopTarget(config, cwd, loopGoalId, loopGoal) {
   const targetId = loopGoal.loopTarget?.id.trim() ?? "";
   assertSafeGoalId(targetId, "loop target");
@@ -9810,7 +9852,7 @@ function goalInstanceTime(state) {
   return Number.isNaN(parsed) ? 0 : parsed;
 }
 function loadGoalTemplate(cwd, targetId) {
-  return readJsonObject2(path28.join(cwd, ".kody-engine", "definitions", "goals", targetId, "state.json"));
+  return readJsonObject2(path29.join(cwd, ".kody-engine", "definitions", "goals", targetId, "state.json"));
 }
 function readJsonObject2(filePath) {
   if (!fs31.existsSync(filePath)) return null;
@@ -10161,15 +10203,15 @@ var init_backendStateBackend = __esm({
         this.jobsDir = opts.jobsDir.replace(/\/+$/, "");
       }
       async load(slug) {
-        const path58 = stateFilePath(this.jobsDir, slug);
+        const path59 = stateFilePath(this.jobsDir, slug);
         const loaded = await createStateBackendFromEnv().get(this.tenantId, `capabilities/${slug}`, "job-state");
         if (!loaded) {
-          return { path: path58, handle: null, state: initialStateEnvelope("seed"), created: true };
+          return { path: path59, handle: null, state: initialStateEnvelope("seed"), created: true };
         }
         if (!isStateEnvelope(loaded.doc)) {
           throw new Error(`BackendStateBackend: capabilities/${slug} is not a StateEnvelope`);
         }
-        return { path: path58, handle: loaded.updatedAt, state: loaded.doc, created: false };
+        return { path: path59, handle: loaded.updatedAt, state: loaded.doc, created: false };
       }
       async save(loaded, next) {
         if (!loaded.created && isStateUnchanged(loaded.state, next)) return false;
@@ -10190,7 +10232,7 @@ var init_backendStateBackend = __esm({
 
 // src/scripts/jobState/localFileBackend.ts
 import * as fs32 from "fs";
-import * as path29 from "path";
+import * as path30 from "path";
 function sanitizeKey(s) {
   return s.replace(/[^A-Za-z0-9._-]/g, "-");
 }
@@ -10246,7 +10288,7 @@ var init_localFileBackend = __esm({
         if (!opts.owner || !opts.repo) throw new Error("LocalFileBackend: owner and repo are required");
         this.cwd = opts.cwd;
         this.jobsDir = opts.jobsDir;
-        this.absDir = path29.resolve(opts.cwd, opts.jobsDir);
+        this.absDir = path30.resolve(opts.cwd, opts.jobsDir);
         this.owner = opts.owner;
         this.repo = opts.repo;
         this.cache = opts.cache ?? defaultCacheAdapter();
@@ -10306,7 +10348,7 @@ var init_localFileBackend = __esm({
       }
       load(slug) {
         const relPath = stateFilePath(this.jobsDir, slug);
-        const absPath = path29.resolve(this.cwd, relPath);
+        const absPath = path30.resolve(this.cwd, relPath);
         if (!fs32.existsSync(absPath)) {
           return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
         }
@@ -10327,8 +10369,8 @@ var init_localFileBackend = __esm({
         if (!loaded.created && isStateUnchanged(loaded.state, next)) {
           return false;
         }
-        const absPath = path29.resolve(this.cwd, loaded.path);
-        fs32.mkdirSync(path29.dirname(absPath), { recursive: true });
+        const absPath = path30.resolve(this.cwd, loaded.path);
+        fs32.mkdirSync(path30.dirname(absPath), { recursive: true });
         const body = `${JSON.stringify(next, null, 2)}
 `;
         const tmpPath = `${absPath}.${process.pid}.tmp`;
@@ -10365,7 +10407,7 @@ var init_jobState = __esm({
 });
 
 // src/scripts/goalCapabilityScheduling.ts
-import * as path30 from "path";
+import * as path31 from "path";
 function isCapabilityCadenceGoal(goal, extra) {
   return extra.scheduleMode === "agentLoop" || extra.scheduler === "agentLoop" || goal.type === "standing" && goal.capabilities.length > 0;
 }
@@ -10421,7 +10463,7 @@ function planTargetLoopSchedule(opts) {
 }
 async function planGoalCapabilitySchedule(opts) {
   const jobsDir = opts.jobsDir ?? capabilitiesRoot(opts.cwd);
-  const jobsRoot = path30.resolve(opts.cwd, jobsDir);
+  const jobsRoot = path31.resolve(opts.cwd, jobsDir);
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const at = now.toISOString();
   const backend = resolveBackend({ config: opts.config, cwd: opts.cwd, jobsDir });
@@ -12238,7 +12280,7 @@ var init_classifyByLabel = __esm({
 // src/scripts/commitAndPush.ts
 import { createHash as createHash5 } from "crypto";
 import * as fs33 from "fs";
-import * as path31 from "path";
+import * as path32 from "path";
 function sentinelPathForStage(cwd, profileName, workflowExecutionKey) {
   const runId = resolveRunId();
   const executionSuffix = typeof workflowExecutionKey === "string" && workflowExecutionKey.length > 0 ? `-${createHash5("sha256").update(workflowExecutionKey).digest("hex").slice(0, 16)}` : "";
@@ -12322,7 +12364,7 @@ var init_commitAndPush = __esm({
       const result = ctx.data.commitResult;
       if (sentinel && result?.committed) {
         try {
-          fs33.mkdirSync(path31.dirname(sentinel), { recursive: true });
+          fs33.mkdirSync(path32.dirname(sentinel), { recursive: true });
           fs33.writeFileSync(
             sentinel,
             JSON.stringify(
@@ -12418,7 +12460,7 @@ var init_commitGoalState = __esm({
 
 // src/scripts/composePrompt.ts
 import * as fs34 from "fs";
-import * as path32 from "path";
+import * as path33 from "path";
 function fenceUntrusted(value) {
   if (value.trim().length === 0) return value;
   const safe = value.replace(/-{3,}\s*END UNTRUSTED INPUT\s*-{3,}/gi, "[END UNTRUSTED INPUT]");
@@ -12542,10 +12584,10 @@ var init_composePrompt = __esm({
       const explicit = ctx.data.promptTemplate;
       const mode = ctx.args.mode;
       const candidates = [
-        explicit ? path32.join(profile.dir, explicit) : null,
-        mode ? path32.join(profile.dir, "prompts", `${mode}.md`) : null,
-        path32.join(profile.dir, "prompt.md"),
-        path32.join(profile.dir, "capability.md")
+        explicit ? path33.join(profile.dir, explicit) : null,
+        mode ? path33.join(profile.dir, "prompts", `${mode}.md`) : null,
+        path33.join(profile.dir, "prompt.md"),
+        path33.join(profile.dir, "capability.md")
       ].filter(Boolean);
       let templatePath = "";
       let template = "";
@@ -13305,14 +13347,14 @@ var init_deriveQaScopeFromIssue = __esm({
 import { execFileSync as execFileSync9 } from "child_process";
 import * as fs35 from "fs";
 import * as os5 from "os";
-import * as path33 from "path";
+import * as path34 from "path";
 var diagMcp;
 var init_diagMcp = __esm({
   "src/scripts/diagMcp.ts"() {
     "use strict";
     diagMcp = async (_ctx) => {
       const home = os5.homedir();
-      const cacheDir = path33.join(home, ".cache", "ms-playwright");
+      const cacheDir = path34.join(home, ".cache", "ms-playwright");
       let entries = [];
       try {
         entries = fs35.readdirSync(cacheDir);
@@ -13344,12 +13386,12 @@ var init_diagMcp = __esm({
 
 // src/scripts/frameworkDetectors.ts
 import * as fs36 from "fs";
-import * as path34 from "path";
+import * as path35 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs36.readFileSync(path34.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs36.readFileSync(path35.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -13386,14 +13428,14 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs36.existsSync(path34.join(cwd, c))) return c;
+    if (fs36.existsSync(path35.join(cwd, c))) return c;
   }
   return null;
 }
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path34.join(cwd, dir);
+    const full = path35.join(cwd, dir);
     if (!fs36.existsSync(full)) continue;
     let files;
     try {
@@ -13403,7 +13445,7 @@ function discoverPayloadCollections(cwd) {
     }
     for (const file of files) {
       try {
-        const filePath = path34.join(full, file);
+        const filePath = path35.join(full, file);
         const content = fs36.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
@@ -13418,7 +13460,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path34.relative(cwd, filePath),
+          filePath: path35.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -13431,7 +13473,7 @@ function discoverPayloadCollections(cwd) {
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path34.join(cwd, dir);
+    const full = path35.join(cwd, dir);
     if (!fs36.existsSync(full)) continue;
     let entries;
     try {
@@ -13440,19 +13482,19 @@ function discoverAdminComponents(cwd, collections) {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path34.join(full, entry.name);
+      const entryPath = path35.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs36.existsSync(path34.join(entryPath, f))
+          (f) => fs36.existsSync(path35.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path34.relative(cwd, path34.join(entryPath, indexFile));
+        filePath = path35.relative(cwd, path35.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path34.relative(cwd, entryPath);
+        filePath = path35.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -13460,7 +13502,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs36.readFileSync(path34.join(cwd, col.filePath), "utf-8");
+            const colContent = fs36.readFileSync(path35.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -13478,7 +13520,7 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path34.join(cwd, appDir, "api");
+    const apiDir = path35.join(cwd, appDir, "api");
     if (!fs36.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
@@ -13495,7 +13537,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
   const routeFile = entries.find((e) => e.isFile() && /^route\.(ts|js|tsx|jsx)$/.test(e.name));
   if (routeFile) {
     try {
-      const content = fs36.readFileSync(path34.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs36.readFileSync(path35.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
       const methods = HTTP_METHODS.filter(
         (m) => new RegExp(`export\\s+(?:async\\s+)?function\\s+${m}\\b`).test(content)
       );
@@ -13503,7 +13545,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path34.relative(cwd, path34.join(dir, routeFile.name))
+          filePath: path35.relative(cwd, path35.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -13514,7 +13556,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     if (entry.name === "node_modules" || entry.name === ".next") continue;
     let segment = entry.name;
     if (segment.startsWith("(") && segment.endsWith(")")) {
-      walkApiRoutes(path34.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path35.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -13522,13 +13564,13 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path34.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path35.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 function scanEnvVars(cwd) {
   const candidates = [".env.example", ".env.local.example", ".env.template"];
   for (const envFile of candidates) {
-    const envPath = path34.join(cwd, envFile);
+    const envPath = path35.join(cwd, envFile);
     if (!fs36.existsSync(envPath)) continue;
     try {
       const content = fs36.readFileSync(envPath, "utf-8");
@@ -13577,7 +13619,7 @@ var init_frameworkDetectors = __esm({
 
 // src/scripts/discoverQaContext.ts
 import * as fs37 from "fs";
-import * as path35 from "path";
+import * as path36 from "path";
 function runQaDiscovery(cwd) {
   const out = {
     routes: [],
@@ -13608,9 +13650,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs37.readFileSync(path35.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs37.readFileSync(path36.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs37.existsSync(path35.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs37.existsSync(path35.join(cwd, "yarn.lock")) ? "yarn" : fs37.existsSync(path35.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs37.existsSync(path36.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs37.existsSync(path36.join(cwd, "yarn.lock")) ? "yarn" : fs37.existsSync(path36.join(cwd, "bun.lockb")) ? "bun" : "npm";
     if (pkg.scripts?.dev) out.devCommand = `${pm} dev`;
     if (allDeps.next || allDeps.nuxt) out.devPort = 3e3;
     else if (allDeps.vite) out.devPort = 5173;
@@ -13620,7 +13662,7 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path35.join(cwd, appDir);
+    const full = path36.join(cwd, appDir);
     if (!fs37.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
@@ -13646,7 +13688,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     if (entry.name === "node_modules" || entry.name === ".next") continue;
     let segment = entry.name;
     if (segment.startsWith("(") && segment.endsWith(")")) {
-      walkFrontendRoutes(path35.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path36.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -13654,7 +13696,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path35.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path36.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -13671,13 +13713,13 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs37.existsSync(path35.join(cwd, c))) out.authFiles.push(c);
+    if (fs37.existsSync(path36.join(cwd, c))) out.authFiles.push(c);
   }
 }
 function detectRoles(cwd, out) {
   const rolePaths = ["src/types", "src/lib", "src/utils", "src/constants", "src/access", "src/collections"];
   for (const rp of rolePaths) {
-    const dir = path35.join(cwd, rp);
+    const dir = path36.join(cwd, rp);
     if (!fs37.existsSync(dir)) continue;
     let files;
     try {
@@ -13687,7 +13729,7 @@ function detectRoles(cwd, out) {
     }
     for (const f of files) {
       try {
-        const content = fs37.readFileSync(path35.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs37.readFileSync(path36.join(dir, f), "utf-8").slice(0, 5e3);
         const roleMatches = content.match(/(?:role|Role|ROLE)\s*[=:]\s*['"](\w+)['"]/g);
         if (roleMatches) {
           for (const m of roleMatches) {
@@ -13949,7 +13991,7 @@ var init_dispatchClassified = __esm({
 
 // src/loopDefinitions.ts
 import * as fs38 from "fs";
-import * as path36 from "path";
+import * as path37 from "path";
 function normalizeLoopDefinition(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const raw = value;
@@ -13976,7 +14018,7 @@ function readLoopDefinition(cwd, id) {
   if (!ID.test(id)) return null;
   const roots = loopRoots(cwd);
   for (const root of roots) {
-    const filePath = path36.join(root, "loops", id, "loop.json");
+    const filePath = path37.join(root, "loops", id, "loop.json");
     if (!fs38.existsSync(filePath)) continue;
     try {
       const loop = normalizeLoopDefinition(JSON.parse(fs38.readFileSync(filePath, "utf8")));
@@ -13989,7 +14031,7 @@ function readLoopDefinition(cwd, id) {
     }
   }
   process.stderr.write(
-    `[kody] Loop not found: ${id} (${roots.map((root) => path36.join(root, "loops", id, "loop.json")).join(", ")})
+    `[kody] Loop not found: ${id} (${roots.map((root) => path37.join(root, "loops", id, "loop.json")).join(", ")})
 `
   );
   return null;
@@ -13998,11 +14040,11 @@ function listLoopDefinitions(cwd) {
   const roots = loopRoots(cwd);
   const byId = /* @__PURE__ */ new Map();
   for (const root of roots.reverse()) {
-    const loopsDir = path36.join(root, "loops");
+    const loopsDir = path37.join(root, "loops");
     if (!fs38.existsSync(loopsDir)) continue;
     for (const id of fs38.readdirSync(loopsDir).sort()) {
       if (!ID.test(id)) continue;
-      const filePath = path36.join(loopsDir, id, "loop.json");
+      const filePath = path37.join(loopsDir, id, "loop.json");
       if (!fs38.existsSync(filePath)) continue;
       try {
         const loop = normalizeLoopDefinition(JSON.parse(fs38.readFileSync(filePath, "utf8")));
@@ -14017,8 +14059,8 @@ function listLoopDefinitions(cwd) {
 }
 function loopRoots(cwd) {
   return [
-    path36.join(cwd, ".kody-engine", "runtime"),
-    path36.join(cwd, ".kody-engine", "definitions"),
+    path37.join(cwd, ".kody-engine", "runtime"),
+    path37.join(cwd, ".kody-engine", "definitions"),
     definitionsRoot(cwd)
   ].filter((root, index, roots) => roots.indexOf(root) === index);
 }
@@ -15297,11 +15339,11 @@ var init_fixFlow = __esm({
 
 // src/workflow-template.ts
 import * as fs39 from "fs";
-import * as path37 from "path";
+import * as path38 from "path";
 import { fileURLToPath } from "url";
 function loadKodyWorkflowTemplate() {
-  const here = path37.dirname(fileURLToPath(import.meta.url));
-  const candidates = [path37.resolve(here, "../templates/kody.yml"), path37.resolve(here, "../../templates/kody.yml")];
+  const here = path38.dirname(fileURLToPath(import.meta.url));
+  const candidates = [path38.resolve(here, "../templates/kody.yml"), path38.resolve(here, "../../templates/kody.yml")];
   const source = candidates.find((candidate) => fs39.existsSync(candidate));
   if (!source) throw new Error(`Kody workflow template is missing: ${KODY_WORKFLOW_TEMPLATE_PATH}`);
   return fs39.readFileSync(source, "utf8");
@@ -15317,11 +15359,11 @@ var init_workflow_template = __esm({
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync14 } from "child_process";
 import * as fs40 from "fs";
-import * as path38 from "path";
+import * as path39 from "path";
 function detectPackageManager(cwd) {
-  if (fs40.existsSync(path38.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs40.existsSync(path38.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs40.existsSync(path38.join(cwd, "bun.lockb"))) return "bun";
+  if (fs40.existsSync(path39.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs40.existsSync(path39.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs40.existsSync(path39.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -15393,7 +15435,7 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path38.join(cwd, "kody.config.json");
+  const configPath = path39.join(cwd, "kody.config.json");
   if (fs40.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
@@ -15402,8 +15444,8 @@ function performInit(cwd, force) {
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path38.join(cwd, ".github", "workflows");
-  const workflowPath = path38.join(workflowDir, "kody.yml");
+  const workflowDir = path39.join(cwd, ".github", "workflows");
+  const workflowPath = path39.join(workflowDir, "kody.yml");
   if (fs40.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
@@ -15598,13 +15640,13 @@ var init_loadCapabilityState = __esm({
 function isCompanyIntentId(value) {
   return SLUG_RE2.test(value);
 }
-function normalizeCompanyIntent(path58, raw) {
+function normalizeCompanyIntent(path59, raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new Error(`${path58}: intent must be JSON object`);
+    throw new Error(`${path59}: intent must be JSON object`);
   }
   const input = raw;
   const id = stringField4(input.id);
-  if (!id || !isCompanyIntentId(id)) throw new Error(`${path58}: invalid intent id`);
+  if (!id || !isCompanyIntentId(id)) throw new Error(`${path59}: invalid intent id`);
   const createdAt = stringField4(input.createdAt) || nowIso();
   const updatedAt = stringField4(input.updatedAt) || createdAt;
   const description = stringField4(input.description);
@@ -15766,7 +15808,7 @@ function retryDelaysMs() {
 }
 function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve23) => setTimeout(resolve23, ms));
+  return new Promise((resolve24) => setTimeout(resolve24, ms));
 }
 async function fetchGoalStateWithRetry(config, goalId, cwd) {
   let state = await fetchGoalStateAsync(config, goalId, cwd);
@@ -15896,7 +15938,7 @@ var init_loadIssueStateComment = __esm({
 
 // src/scripts/loadJobFromFile.ts
 import * as fs42 from "fs";
-import * as path39 from "path";
+import * as path40 from "path";
 function parseJobFile(raw, slug) {
   let stripped = raw;
   if (stripped.startsWith("---\n")) {
@@ -15935,10 +15977,10 @@ var init_loadJobFromFile = __esm({
       if (!slug) {
         throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
       }
-      const capability = resolveCapabilityFolder(slug, path39.resolve(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug, path40.resolve(ctx.cwd, jobsDir));
       if (!capability) {
         throw new Error(
-          `loadJobFromFile: capability folder not found or incomplete: ${path39.resolve(ctx.cwd, jobsDir, slug)}`
+          `loadJobFromFile: capability folder not found or incomplete: ${path40.resolve(ctx.cwd, jobsDir, slug)}`
         );
       }
       const { title, body, config } = capability;
@@ -16034,9 +16076,9 @@ ${truncate2(issue2.body, FINDING_BODY_MAX_BYTES)}`;
 
 // src/scripts/kodyVariables.ts
 import * as fs43 from "fs";
-import * as path40 from "path";
+import * as path41 from "path";
 function readKodyVariables(cwd) {
-  const full = path40.join(cwd, KODY_VARIABLES_REL_PATH);
+  const full = path41.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
     raw = fs43.readFileSync(full, "utf-8");
@@ -16065,7 +16107,7 @@ var init_kodyVariables = __esm({
 
 // src/scripts/loadQaContext.ts
 import * as fs44 from "fs";
-import * as path41 from "path";
+import * as path42 from "path";
 function parseSlugList(value) {
   const inner = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
   return inner.split(",").map(
@@ -16094,7 +16136,7 @@ function readProfileAgents(raw) {
   return { agent: agent ?? legacy ?? ["kody"], body };
 }
 function readProfile(cwd) {
-  const dir = path41.join(cwd, CONTEXT_DIR_REL_PATH);
+  const dir = path42.join(cwd, CONTEXT_DIR_REL_PATH);
   if (!fs44.existsSync(dir)) return "";
   let entries;
   try {
@@ -16105,7 +16147,7 @@ function readProfile(cwd) {
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs44.readFileSync(path41.join(dir, file), "utf-8");
+      const raw = fs44.readFileSync(path42.join(dir, file), "utf-8");
       const { agent, body } = readProfileAgents(raw);
       if (!agent.includes(QA_AGENT) && !agent.includes(ALL_AGENTS)) continue;
       blocks.push(`## ${file}
@@ -16157,7 +16199,7 @@ var init_loadQaContext = __esm({
 import { randomUUID as randomUUID2 } from "crypto";
 import * as fs45 from "fs";
 import * as os6 from "os";
-import * as path42 from "path";
+import * as path43 from "path";
 function registerCapabilitySubagents(profile, toolRoot, toolFiles) {
   const subagentFiles = toolFiles.flatMap((file) => {
     const match = /^agents\/([a-z][a-z0-9-]{0,63})\.md$/.exec(file);
@@ -16170,7 +16212,7 @@ function registerCapabilitySubagents(profile, toolRoot, toolFiles) {
   profile.subagentTemplates = {
     ...profile.subagentTemplates ?? {},
     ...Object.fromEntries(
-      subagentFiles.map(({ name, file }) => [name, fs45.readFileSync(path42.join(toolRoot, file), "utf-8")])
+      subagentFiles.map(({ name, file }) => [name, fs45.readFileSync(path43.join(toolRoot, file), "utf-8")])
     )
   };
   if (!profile.claudeCode.tools.includes("Agent")) {
@@ -16215,10 +16257,10 @@ function listFiles(root) {
   const files = [];
   const visit = (dir) => {
     for (const entry of fs45.readdirSync(dir, { withFileTypes: true })) {
-      const absolute = path42.join(dir, entry.name);
+      const absolute = path43.join(dir, entry.name);
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) visit(absolute);
-      else if (entry.isFile()) files.push(path42.relative(root, absolute));
+      else if (entry.isFile()) files.push(path43.relative(root, absolute));
     }
   };
   visit(root);
@@ -16241,8 +16283,8 @@ var init_loadSimpleCapability = __esm({
       if (!capability) {
         throw new Error(`Capability "${slug}" is not a valid simple capability folder`);
       }
-      const toolRoot = path42.join(capability.dir, "tools");
-      const skillRoot = path42.join(capability.dir, "skills");
+      const toolRoot = path43.join(capability.dir, "tools");
+      const skillRoot = path43.join(capability.dir, "skills");
       const toolFiles = listFiles(toolRoot);
       const skillFiles = listFiles(skillRoot);
       const parsedInput = parseInput(ctx.args.input);
@@ -16267,14 +16309,14 @@ var init_loadSimpleCapability = __esm({
       }
       if (requiredSubagents.length > 0) ctx.data.requiredSubagents = requiredSubagents;
       if (capability.contract?.execution === "script") {
-        ctx.data.capabilityScriptPath = path42.join(capability.dir, "tools", "run.sh");
+        ctx.data.capabilityScriptPath = path43.join(capability.dir, "tools", "run.sh");
         ctx.data.capabilitySecretNames = capability.contract.secrets ?? [];
         ctx.data.capabilityScriptTimeoutMs = capability.contract.timeoutMs;
       }
       if (capability.config.outputSchema) {
         ctx.data.capabilityOutputSchema = capability.config.outputSchema;
       }
-      const outputPath = ctx.data.capabilityExecution === "agent" && capability.config.outputSchema ? path42.join(os6.tmpdir(), `kody-capability-output-${randomUUID2()}.json`) : void 0;
+      const outputPath = ctx.data.capabilityExecution === "agent" && capability.config.outputSchema ? path43.join(os6.tmpdir(), `kody-capability-output-${randomUUID2()}.json`) : void 0;
       if (outputPath) ctx.data.capabilityOutputPath = outputPath;
       ctx.data.capabilityEnvironment = {
         ...capabilityInputEnvironment(input),
@@ -16297,7 +16339,7 @@ var init_loadSimpleCapability = __esm({
           ...skillFiles.flatMap((file) => [
             `### ${file}`,
             "",
-            fs45.readFileSync(path42.join(skillRoot, file), "utf-8"),
+            fs45.readFileSync(path43.join(skillRoot, file), "utf-8"),
             ""
           ])
         ] : [],
@@ -16306,7 +16348,7 @@ var init_loadSimpleCapability = __esm({
           "## Tools",
           "",
           "Inspect or run these capability-owned files when needed:",
-          ...toolFiles.map((file) => `- ${path42.join(toolRoot, file)}`)
+          ...toolFiles.map((file) => `- ${path43.join(toolRoot, file)}`)
         ] : [],
         "",
         ...capability.config.outputSchema ? [
@@ -16338,7 +16380,7 @@ var init_loadSimpleCapability = __esm({
 
 // src/taskContext.ts
 import * as fs46 from "fs";
-import * as path43 from "path";
+import * as path44 from "path";
 function buildTaskContext(args) {
   return {
     schemaVersion: TASK_CONTEXT_SCHEMA_VERSION,
@@ -16355,7 +16397,7 @@ function persistTaskContext(cwd, ctx) {
   try {
     const dir = runtimeStatePath(cwd, "agent-runs", ctx.runId);
     fs46.mkdirSync(dir, { recursive: true });
-    const file = path43.join(dir, "task-context.json");
+    const file = path44.join(dir, "task-context.json");
     fs46.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
@@ -16783,19 +16825,19 @@ function parseAgencyModelProposal(raw) {
 function normalizeBundleFiles(bundle) {
   const seen = /* @__PURE__ */ new Set();
   return bundle.files.map((file, index) => {
-    const path58 = file.path.replace(/^\/+/, "");
-    const parts = path58.split("/");
-    if (!path58 || file.path.startsWith("/") || file.path.includes("\\") || parts.some((part) => !part || part === "." || part === "..")) {
+    const path59 = file.path.replace(/^\/+/, "");
+    const parts = path59.split("/");
+    if (!path59 || file.path.startsWith("/") || file.path.includes("\\") || parts.some((part) => !part || part === "." || part === "..")) {
       throw new Error(`openAgencyModelReviewPr: files[${index}].path is unsafe`);
     }
     if (!/^(agents\/[^/]+\.md|capabilities\/[^/]+\/.+|goals\/(?:templates\/)?[^/]+\/.+|workflows\/[^/]+\.json)$/.test(
-      path58
+      path59
     )) {
       throw new Error(`openAgencyModelReviewPr: files[${index}].path is not a supported definition path`);
     }
-    if (seen.has(path58)) throw new Error(`openAgencyModelReviewPr: duplicate generated file path: ${path58}`);
-    seen.add(path58);
-    return { path: path58, content: file.content.replace(/\r\n?/g, "\n") };
+    if (seen.has(path59)) throw new Error(`openAgencyModelReviewPr: duplicate generated file path: ${path59}`);
+    seen.add(path59);
+    return { path: path59, content: file.content.replace(/\r\n?/g, "\n") };
   });
 }
 function buildProposalId(issueNumber, bundle, sourceLabel) {
@@ -17907,7 +17949,7 @@ var init_postResearchComment = __esm({
 // src/scripts/prepareBrowserAuth.ts
 import * as fs48 from "fs";
 import * as os7 from "os";
-import * as path44 from "path";
+import * as path45 from "path";
 function appendAuthMessage(ctx, message) {
   const current = typeof ctx.data.qaAuthBlock === "string" ? ctx.data.qaAuthBlock.trim() : "";
   ctx.data.qaAuthBlock = current ? `${current}
@@ -17946,9 +17988,9 @@ async function githubJson(url, token) {
   return await response.json();
 }
 function writeKodyStorageState(input) {
-  const directory = fs48.mkdtempSync(path44.join(os7.tmpdir(), "kody-browser-auth-"));
+  const directory = fs48.mkdtempSync(path45.join(os7.tmpdir(), "kody-browser-auth-"));
   fs48.chmodSync(directory, 448);
-  const file = path44.join(directory, "storage-state.json");
+  const file = path45.join(directory, "storage-state.json");
   const now = Date.now();
   const repoEntry = {
     repoUrl: input.repoUrl,
@@ -18207,7 +18249,7 @@ var init_prepareCapabilityDelivery = __esm({
 
 // src/scripts/prepareSimpleCapabilityRuntime.ts
 import { isIP } from "net";
-import * as path45 from "path";
+import * as path46 from "path";
 function requirementsFrom(ctx) {
   const raw = ctx.data.capabilityRequirements;
   return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
@@ -18251,7 +18293,7 @@ function browserRuntime(ctx, requirements) {
       "--allowed-origins",
       origin,
       "--output-dir",
-      path45.resolve(ctx.cwd, "test-results", "quality-runs", qualityRunId)
+      path46.resolve(ctx.cwd, "test-results", "quality-runs", qualityRunId)
     ]
   };
 }
@@ -18616,9 +18658,9 @@ function latestResult(raw, agentResult) {
 function recordField4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function resolveDotted(root, path58) {
-  if (!path58) return void 0;
-  return path58.split(".").reduce((value, key) => recordField4(value)?.[key], root);
+function resolveDotted(root, path59) {
+  if (!path59) return void 0;
+  return path59.split(".").reduce((value, key) => recordField4(value)?.[key], root);
 }
 function stringValue5(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
@@ -19460,7 +19502,7 @@ var init_previewBuildHelpers = __esm({
 // src/scripts/previewBuildRun.ts
 import { spawn as spawn5 } from "child_process";
 async function runCmd(cmd, args, opts = {}) {
-  await new Promise((resolve23, reject) => {
+  await new Promise((resolve24, reject) => {
     const child = spawn5(cmd, args, {
       cwd: opts.cwd,
       env: { ...process.env, ...opts.env ?? {} },
@@ -19472,7 +19514,7 @@ async function runCmd(cmd, args, opts = {}) {
     }
     child.on("error", reject);
     child.on("close", (code) => {
-      if (code === 0) resolve23();
+      if (code === 0) resolve24();
       else reject(new Error(`${cmd} ${args.join(" ")} exited ${code}`));
     });
   });
@@ -19544,12 +19586,12 @@ fi
 
 // src/scripts/runPreviewBuild.ts
 import { copyFile, writeFile } from "fs/promises";
-import * as path46 from "path";
+import * as path47 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function bundledDockerfilePath(mode) {
-  const here = path46.dirname(fileURLToPath2(import.meta.url));
+  const here = path47.dirname(fileURLToPath2(import.meta.url));
   const file = mode === "dev" ? "default-Dockerfile.preview.dev" : "default-Dockerfile.preview.prod";
-  return path46.join(here, "preview-build-templates", file);
+  return path47.join(here, "preview-build-templates", file);
 }
 function required(name) {
   const v = (process.env[name] ?? "").trim();
@@ -19784,10 +19826,10 @@ var init_runPreviewBuild = __esm({
         console.log(`[preview-build] vault: ${Object.keys(buildEnv).length} secrets, mode=${buildMode}`);
         if (Object.keys(buildEnv).length > 0) {
           const lines = Object.entries(buildEnv).map(([k, v]) => `${k}=${JSON.stringify(v)}`);
-          await writeFile(path46.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
+          await writeFile(path47.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
 `, "utf8");
         }
-        const consumerDockerfile = path46.join(ctx.cwd, "Dockerfile.preview");
+        const consumerDockerfile = path47.join(ctx.cwd, "Dockerfile.preview");
         const { stat } = await import("fs/promises");
         let hasConsumerDockerfile = false;
         try {
@@ -19972,7 +20014,7 @@ var init_tickShellRunner = __esm({
 
 // src/scripts/runScheduledImplementationTick.ts
 import * as fs49 from "fs";
-import * as path47 from "path";
+import * as path48 from "path";
 var runScheduledImplementationTick;
 var init_runScheduledImplementationTick = __esm({
   "src/scripts/runScheduledImplementationTick.ts"() {
@@ -19993,13 +20035,13 @@ var init_runScheduledImplementationTick = __esm({
         ctx.output.reason = `runScheduledImplementationTick: args.slug or ctx.args.${slugArg} must be non-empty capability slug`;
         return;
       }
-      const capability = resolveCapabilityFolder(slug, path47.resolve(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug, path48.resolve(ctx.cwd, jobsDir));
       if (!capability) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledImplementationTick: capability folder not found or incomplete: ${slug} (searched ${jobsDir} and company store)`;
         return;
       }
-      const shellPath = path47.join(profile.dir, shell);
+      const shellPath = path48.join(profile.dir, shell);
       if (!fs49.existsSync(shellPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledImplementationTick: shell not found: ${shell} (looked in ${profile.dir})`;
@@ -20118,7 +20160,7 @@ var init_runSimpleCapabilityScript = __esm({
 
 // src/scripts/runTickScript.ts
 import * as fs51 from "fs";
-import * as path48 from "path";
+import * as path49 from "path";
 var runTickScript;
 var init_runTickScript = __esm({
   "src/scripts/runTickScript.ts"() {
@@ -20138,10 +20180,10 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
         return;
       }
-      const capability = readCapabilityFolder(path48.resolve(ctx.cwd, jobsDir), slug);
+      const capability = readCapabilityFolder(path49.resolve(ctx.cwd, jobsDir), slug);
       if (!capability) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path48.resolve(ctx.cwd, jobsDir, slug)}`;
+        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path49.resolve(ctx.cwd, jobsDir, slug)}`;
         return;
       }
       const tickScript = capability.config.tickScript;
@@ -20150,7 +20192,7 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: capability ${slug} has no \`tickScript\` in profile.json \u2014 route via capability-tick instead`;
         return;
       }
-      const scriptPath = path48.isAbsolute(tickScript) ? tickScript : path48.join(ctx.cwd, tickScript);
+      const scriptPath = path49.isAbsolute(tickScript) ? tickScript : path49.join(ctx.cwd, tickScript);
       if (!fs51.existsSync(scriptPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
@@ -20433,7 +20475,7 @@ var init_syncFlow = __esm({
 });
 
 // src/scripts/validateAgencyModelProposal.ts
-import * as path49 from "path";
+import * as path50 from "path";
 function validateModelBundle(bundle, expectedKind, options = {}) {
   const failures = [];
   validateOneModel(bundle.model, bundle.files, "model", true, failures, expectedKind, options);
@@ -20751,7 +20793,7 @@ var init_validateAgencyModelProposal = __esm({
       const bundle = parseAgencyModelProposal(raw);
       const expectedKind = readExpectedModelKind(args);
       const failures = validateModelBundle(bundle, expectedKind, {
-        capabilityRoot: path49.join(ctx.cwd, ".kody", "capabilities")
+        capabilityRoot: path50.join(ctx.cwd, ".kody", "capabilities")
       });
       if (failures.length > 0) {
         throw new Error(`validateAgencyModelProposal: ${failures.join("; ")}`);
@@ -20814,7 +20856,7 @@ function stripAnsi2(s) {
   return s.replace(ANSI_RE2, "");
 }
 function runCommand2(command, cwd) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     const child = spawn6(command, {
       cwd,
       shell: true,
@@ -20841,11 +20883,11 @@ function runCommand2(command, cwd) {
     }, TEST_TIMEOUT_MS);
     child.on("exit", (code) => {
       clearTimeout(timer);
-      resolve23({ exitCode: code ?? -1, output: Buffer.concat(buffers).toString("utf-8") });
+      resolve24({ exitCode: code ?? -1, output: Buffer.concat(buffers).toString("utf-8") });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve23({ exitCode: -1, output: err.message });
+      resolve24({ exitCode: -1, output: err.message });
     });
   });
 }
@@ -21259,21 +21301,21 @@ function lineStream(stream) {
     tryDeliver();
   });
   return {
-    next: (timeoutMs) => new Promise((resolve23) => {
+    next: (timeoutMs) => new Promise((resolve24) => {
       if (queue.length > 0) {
-        resolve23(queue.shift());
+        resolve24(queue.shift());
         return;
       }
       if (ended) {
-        resolve23(null);
+        resolve24(null);
         return;
       }
-      waiter = resolve23;
+      waiter = resolve24;
       const t = setTimeout(
         () => {
-          if (waiter === resolve23) {
+          if (waiter === resolve24) {
             waiter = null;
-            resolve23(null);
+            resolve24(null);
           }
         },
         Math.max(0, timeoutMs)
@@ -21675,15 +21717,15 @@ var init_scripts = __esm({
 
 // src/stateWorkspace.ts
 import * as fs53 from "fs";
-import * as path50 from "path";
+import * as path51 from "path";
 function tenantId(config) {
   const owner = config.github?.owner?.trim() || process.env.GITHUB_REPOSITORY?.split("/")[0]?.trim();
   const repo = config.github?.repo?.trim() || process.env.GITHUB_REPOSITORY?.split("/")[1]?.trim();
   return owner && repo ? `${owner}/${repo}` : null;
 }
 function writeRuntimeFile(cwd, relativePath, content) {
-  const target = path50.join(cwd, RUNTIME_ROOT, relativePath);
-  fs53.mkdirSync(path50.dirname(target), { recursive: true });
+  const target = path51.join(cwd, RUNTIME_ROOT, relativePath);
+  fs53.mkdirSync(path51.dirname(target), { recursive: true });
   fs53.writeFileSync(target, content, "utf8");
 }
 function record(value) {
@@ -21749,10 +21791,10 @@ async function hydrateStateWorkspace(config, cwd, backendOverride) {
       throw new Error("Kody backend access is required for runtime workspace documents");
     return;
   }
-  const key = `${path50.resolve(cwd)}|${tenant}`;
+  const key = `${path51.resolve(cwd)}|${tenant}`;
   if (hydratedWorkspaces.has(key)) return;
   const backend = backendOverride ?? createStateBackendFromEnv();
-  const root = path50.join(cwd, RUNTIME_ROOT);
+  const root = path51.join(cwd, RUNTIME_ROOT);
   fs53.rmSync(root, { recursive: true, force: true });
   await Promise.all([
     hydratePrefix(backend, tenant, cwd, "context:"),
@@ -21769,7 +21811,7 @@ var init_stateWorkspace = __esm({
   "src/stateWorkspace.ts"() {
     "use strict";
     init_state_backend();
-    RUNTIME_ROOT = path50.join(".kody-engine", "runtime");
+    RUNTIME_ROOT = path51.join(".kody-engine", "runtime");
     hydratedWorkspaces = /* @__PURE__ */ new Set();
   }
 });
@@ -21842,7 +21884,7 @@ var init_tools = __esm({
 import { spawn as spawn8 } from "child_process";
 import * as fs54 from "fs";
 import * as os8 from "os";
-import * as path51 from "path";
+import * as path52 from "path";
 function isMutatingPostflight(scriptName) {
   return MUTATING_POSTFLIGHTS.has(scriptName ?? "");
 }
@@ -22099,7 +22141,7 @@ async function runImplementation(profileName, input) {
       const reason = input.abortController.signal.reason;
       throw reason instanceof Error ? reason : new Error("agent invocation aborted");
     }
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path51.isAbsolute(p) ? p : path51.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path52.isAbsolute(p) ? p : path52.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
@@ -22138,6 +22180,7 @@ async function runImplementation(profileName, input) {
       verbose: input.verbose,
       quiet: input.quiet,
       abortController: input.abortController,
+      deadlineAtMs: input.deadlineAtMs,
       ndjsonDir,
       additionalDirectories: agentTaskArtifacts ? [agentTaskArtifacts.absDir] : void 0,
       allowedToolsOverride: profile.claudeCode.tools,
@@ -22580,13 +22623,13 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function resolveProfilePath(profileName, cwd = process.cwd()) {
   const found = resolveImplementation(profileName, getRuntimeProfileRootsForCwd(cwd));
   if (found) return found;
-  const here = path51.dirname(new URL(import.meta.url).pathname);
+  const here = path52.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path51.join(here, "implementations", profileName, "profile.json"),
+    path52.join(here, "implementations", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path51.join(here, "..", "implementations", profileName, "profile.json"),
+    path52.join(here, "..", "implementations", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/implementations)
-    path51.join(here, "..", "src", "implementations", profileName, "profile.json")
+    path52.join(here, "..", "src", "implementations", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
@@ -22705,7 +22748,7 @@ function resolveShellTimeoutMs(entry) {
 }
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path51.join(profile.dir, shellName);
+  const shellPath = path52.join(profile.dir, shellName);
   if (!fs54.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
@@ -22713,7 +22756,7 @@ async function runShellEntry(entry, ctx, profile) {
     return;
   }
   const positional = entry.with ? Object.values(entry.with).map((v) => String(v)) : [];
-  const outputFile = path51.join(
+  const outputFile = path52.join(
     os8.tmpdir(),
     `kody-shell-output-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
   );
@@ -22743,14 +22786,14 @@ async function runShellEntry(entry, ctx, profile) {
   let killTimer;
   let escalateTimer;
   const result = await new Promise(
-    (resolve23) => {
+    (resolve24) => {
       let settled = false;
       const settle = (code, signal, spawnErr) => {
         if (settled) return;
         settled = true;
         if (killTimer) clearTimeout(killTimer);
         if (escalateTimer) clearTimeout(escalateTimer);
-        resolve23({ code, signal, spawnErr });
+        resolve24({ code, signal, spawnErr });
       };
       child.on("error", (err) => settle(null, null, err));
       child.on("close", (code, signal) => settle(code, signal));
@@ -23324,6 +23367,7 @@ async function runCapabilityImplementationStep(valid, profileName, capabilityIde
     verbose: base.verbose,
     quiet: base.quiet,
     abortController: base.abortController,
+    deadlineAtMs: base.deadlineAtMs,
     preloadedData: Object.keys(preloadedData).length > 0 ? preloadedData : void 0
   };
   const shouldApplyResolvedCapabilityArgs = valid.implementation === void 0 && resolvedCapability && profileName === resolvedCapability.implementation;
@@ -23637,6 +23681,7 @@ async function runGraphCapabilityWorkflow(parent, workflow, capability, base, ch
       result = await runJob(child, {
         ...base,
         abortController: stepAbort.controller,
+        deadlineAtMs: stepAbort.deadlineAtMs,
         preloadedData: {
           ...chainData,
           runSubjectType: "capability",
@@ -23793,11 +23838,11 @@ function exhaustedWorkflowTransitions(step, data, counts) {
 }
 function workflowResultConditionPaths(transitions) {
   return transitions.flatMap(
-    (transition) => Object.keys(transition.when ?? {}).filter((path58) => path58.startsWith("result."))
+    (transition) => Object.keys(transition.when ?? {}).filter((path59) => path59.startsWith("result."))
   );
 }
 function conditionMatches(condition, context) {
-  return Object.entries(condition).every(([path58, expected]) => valueMatches(resolveDottedPath2(context, path58), expected));
+  return Object.entries(condition).every(([path59, expected]) => valueMatches(resolveDottedPath2(context, path59), expected));
 }
 function withWorkflowBoundaryEval(capability, result) {
   const capabilityKind = capability.config.capabilityKind;
@@ -23966,8 +24011,9 @@ function canContinueWorkflow(step, outcome) {
   return step.continueOn.includes(outcome.type);
 }
 function workflowStepAbortController(parent, timeoutSeconds) {
-  if (!timeoutSeconds) return { controller: parent, cleanup: () => void 0 };
+  if (!timeoutSeconds) return { controller: parent, deadlineAtMs: void 0, cleanup: () => void 0 };
   const controller = new AbortController();
+  const deadlineAtMs = Date.now() + timeoutSeconds * 1e3;
   const forwardParentAbort = () => controller.abort(parent?.signal.reason);
   if (parent?.signal.aborted) forwardParentAbort();
   else parent?.signal.addEventListener("abort", forwardParentAbort, { once: true });
@@ -23977,6 +24023,7 @@ function workflowStepAbortController(parent, timeoutSeconds) {
   timer.unref?.();
   return {
     controller,
+    deadlineAtMs,
     cleanup: () => {
       clearTimeout(timer);
       parent?.signal.removeEventListener("abort", forwardParentAbort);
@@ -24270,7 +24317,7 @@ function translateOpenAISseToBrain(opts) {
 
 // src/servers/brain-serve.ts
 import { createServer as createServer2 } from "http";
-import * as path54 from "path";
+import * as path55 from "path";
 
 // src/chat/loop.ts
 init_agent();
@@ -24279,12 +24326,12 @@ init_config();
 init_registry();
 init_task_artifacts();
 import * as fs18 from "fs";
-import * as path19 from "path";
+import * as path20 from "path";
 
 // src/chat/attachments.ts
 init_runtimePaths();
 import * as fs15 from "fs";
-import * as path16 from "path";
+import * as path17 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",
@@ -24320,7 +24367,7 @@ function prepareAttachments(turns, cwd, sessionId) {
             fs15.mkdirSync(dir, { recursive: true });
             dirEnsured = true;
           }
-          const filePath = path16.join(dir, `${imageCounter}.${extFor(mime)}`);
+          const filePath = path17.join(dir, `${imageCounter}.${extFor(mime)}`);
           fs15.writeFileSync(filePath, Buffer.from(data, "base64"));
           imageCounter += 1;
           imagePaths.push(filePath);
@@ -24339,7 +24386,7 @@ function prepareAttachments(turns, cwd, sessionId) {
 // src/chat/codex-app-server.ts
 import { spawn as spawn3 } from "child_process";
 import * as fs16 from "fs";
-import * as path17 from "path";
+import * as path18 from "path";
 import { createInterface } from "readline";
 function codexThreadStartParams(args) {
   return {
@@ -24424,9 +24471,9 @@ var CodexAppServerClient = class {
     await this.request("thread/resume", { threadId });
   }
   async runTurn(args) {
-    await new Promise((resolve23, reject) => {
+    await new Promise((resolve24, reject) => {
       this.process.turnWaiters.set(args.threadId, {
-        resolve: resolve23,
+        resolve: resolve24,
         reject,
         onNotification: args.onNotification,
         queue: Promise.resolve()
@@ -24443,8 +24490,8 @@ var CodexAppServerClient = class {
   }
   request(method, params) {
     const id = this.process.nextId++;
-    return new Promise((resolve23, reject) => {
-      this.process.pending.set(id, { resolve: resolve23, reject });
+    return new Promise((resolve24, reject) => {
+      this.process.pending.set(id, { resolve: resolve24, reject });
       this.process.child.stdin.write(`${JSON.stringify({ method, id, params })}
 `);
     });
@@ -24510,7 +24557,7 @@ var CodexAppServerClient = class {
 };
 var clients = /* @__PURE__ */ new Map();
 function threadMapPath(cwd) {
-  return path17.join(cwd, ".kody-engine", "runtime", "codex-threads.json");
+  return path18.join(cwd, ".kody-engine", "runtime", "codex-threads.json");
 }
 function readThreadMap(cwd) {
   try {
@@ -24527,7 +24574,7 @@ function readThreadMap(cwd) {
 }
 function writeThreadMap(cwd, map) {
   const file = threadMapPath(cwd);
-  fs16.mkdirSync(path17.dirname(file), { recursive: true });
+  fs16.mkdirSync(path18.dirname(file), { recursive: true });
   fs16.writeFileSync(file, `${JSON.stringify(map, null, 2)}
 `);
 }
@@ -24619,7 +24666,7 @@ async function runCodexChatTurn(args) {
 
 // src/chat/events.ts
 import * as fs17 from "fs";
-import * as path18 from "path";
+import * as path19 from "path";
 import posixPath2 from "path/posix";
 var BackendEventSink = class {
   constructor(append, tenantId2, sessionId) {
@@ -24635,7 +24682,7 @@ var BackendEventSink = class {
   }
 };
 function eventsFilePath(cwd, sessionId) {
-  return path18.join(cwd, ".kody-engine", "runtime", "events", `${sessionId}.jsonl`);
+  return path19.join(cwd, ".kody-engine", "runtime", "events", `${sessionId}.jsonl`);
 }
 var FileSink = class {
   constructor(file) {
@@ -24643,7 +24690,7 @@ var FileSink = class {
   }
   file;
   async emit(event) {
-    fs17.mkdirSync(path18.dirname(this.file), { recursive: true });
+    fs17.mkdirSync(path19.dirname(this.file), { recursive: true });
     fs17.appendFileSync(this.file, `${JSON.stringify(event)}
 `);
   }
@@ -25031,7 +25078,7 @@ async function runChatTurn(opts) {
     quiet: opts.quiet,
     additionalDirectories: [
       taskArtifactsPaths.absDir,
-      ...Array.from(new Set(imagePaths.map((p2) => path19.dirname(p2))))
+      ...Array.from(new Set(imagePaths.map((p2) => path20.dirname(p2))))
     ],
     systemPromptAppend: systemPrompt,
     ...opts.reasoningEffort ? { reasoningEffort: opts.reasoningEffort } : {},
@@ -25219,7 +25266,7 @@ 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 = path19.join(cwd, MEMORY_INDEX_REL);
+  const indexPath = path20.join(cwd, MEMORY_INDEX_REL);
   let raw;
   try {
     raw = fs18.readFileSync(indexPath, "utf-8");
@@ -25242,7 +25289,7 @@ _\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 = path19.join(cwd, CONTEXT_DIR_REL);
+  const dir = path20.join(cwd, CONTEXT_DIR_REL);
   let files;
   try {
     files = fs18.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
@@ -25252,7 +25299,7 @@ function readContextBlock(cwd) {
   const sections = [];
   for (const file of files) {
     try {
-      const content = fs18.readFileSync(path19.join(dir, file), "utf-8").trim();
+      const content = fs18.readFileSync(path20.join(dir, file), "utf-8").trim();
       if (content) sections.push(`### ${file.replace(/\.md$/, "")}
 
 ${content}`);
@@ -25278,7 +25325,7 @@ var SYSTEM_PROMPT_OVERRIDE_REL = ".kody-engine/runtime/system-prompt.md";
 function readSystemPromptOverride(cwd) {
   let raw;
   try {
-    raw = fs18.readFileSync(path19.join(cwd, SYSTEM_PROMPT_OVERRIDE_REL), "utf-8");
+    raw = fs18.readFileSync(path20.join(cwd, SYSTEM_PROMPT_OVERRIDE_REL), "utf-8");
   } catch {
     return null;
   }
@@ -25286,7 +25333,7 @@ function readSystemPromptOverride(cwd) {
   return trimmed.length > 0 ? trimmed : null;
 }
 function readInstructionsBlock(cwd) {
-  const instructionsPath = path19.join(cwd, INSTRUCTIONS_REL);
+  const instructionsPath = path20.join(cwd, INSTRUCTIONS_REL);
   let raw;
   try {
     raw = fs18.readFileSync(instructionsPath, "utf-8");
@@ -25324,10 +25371,10 @@ function resolveBrainDriver(runtime) {
 
 // src/chat/session.ts
 import * as fs19 from "fs";
-import * as path20 from "path";
+import * as path21 from "path";
 import posixPath3 from "path/posix";
 function sessionFilePath(cwd, sessionId) {
-  return path20.join(cwd, ".kody-engine", "runtime", "sessions", `${sessionId}.jsonl`);
+  return path21.join(cwd, ".kody-engine", "runtime", "sessions", `${sessionId}.jsonl`);
 }
 function readSession(file) {
   if (!fs19.existsSync(file)) return [];
@@ -25355,7 +25402,7 @@ init_state_backend();
 init_workflowDefinitions();
 import { createHash as createHash2 } from "crypto";
 import * as fs21 from "fs";
-import * as path22 from "path";
+import * as path23 from "path";
 var SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,127}$/;
 var REPOSITORY_OWNED_NAMESPACES = ["loops"];
 function assertSafeDefinitionPath(filePath) {
@@ -25387,8 +25434,8 @@ function verifyDefinition(definition) {
 }
 function writeBundle(root, bundle) {
   for (const [filePath, contents] of Object.entries(bundle.files)) {
-    const target = path22.join(root, filePath);
-    fs21.mkdirSync(path22.dirname(target), { recursive: true });
+    const target = path23.join(root, filePath);
+    fs21.mkdirSync(path23.dirname(target), { recursive: true });
     fs21.writeFileSync(target, contents, "utf8");
   }
 }
@@ -25397,22 +25444,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`);
-    fs21.writeFileSync(path22.join(root, "agents", `${definition.slug}.md`), raw, "utf8");
+    fs21.writeFileSync(path23.join(root, "agents", `${definition.slug}.md`), raw, "utf8");
     return;
   }
   if (kind === "goal") {
-    writeBundle(path22.join(root, "goals", definition.slug), bundle);
+    writeBundle(path23.join(root, "goals", definition.slug), bundle);
     return;
   }
   if (kind === "implementation") {
-    writeBundle(path22.join(root, "implementations", definition.slug), bundle);
+    writeBundle(path23.join(root, "implementations", definition.slug), bundle);
     return;
   }
   if (kind === "asset") {
-    writeBundle(path22.join(root, "shared"), bundle);
+    writeBundle(path23.join(root, "shared"), bundle);
     return;
   }
-  writeBundle(path22.join(root, "capabilities", definition.slug), bundle);
+  writeBundle(path23.join(root, "capabilities", definition.slug), bundle);
 }
 function writeWorkflow(root, document) {
   const workflow = normalizeWorkflowDefinition(document.definition);
@@ -25420,28 +25467,28 @@ function writeWorkflow(root, document) {
   const contents = `${JSON.stringify(workflow, null, 2)}
 `;
   const bundle = { schemaVersion: 1, files: { "workflow.json": contents } };
-  const target = path22.join(root, workflowDefinitionPath(document.workflowId));
-  fs21.mkdirSync(path22.dirname(target), { recursive: true });
+  const target = path23.join(root, workflowDefinitionPath(document.workflowId));
+  fs21.mkdirSync(path23.dirname(target), { recursive: true });
   fs21.writeFileSync(target, contents, "utf8");
   return definitionVersion(bundle);
 }
 function preserveRepositoryDefinitions(root, staging) {
   for (const namespace of REPOSITORY_OWNED_NAMESPACES) {
-    const source = path22.join(root, namespace);
+    const source = path23.join(root, namespace);
     if (!fs21.existsSync(source)) continue;
-    fs21.cpSync(source, path22.join(staging, namespace), { recursive: true });
+    fs21.cpSync(source, path23.join(staging, namespace), { recursive: true });
   }
 }
 async function hydrateDefinitions(options) {
-  const root = path22.join(options.cwd, ".kody-engine", "definitions");
+  const root = path23.join(options.cwd, ".kody-engine", "definitions");
   const staging = `${root}.tmp-${process.pid}-${Date.now()}`;
   fs21.rmSync(staging, { recursive: true, force: true });
-  fs21.mkdirSync(path22.join(staging, "agents"), { recursive: true });
-  fs21.mkdirSync(path22.join(staging, "capabilities"), { recursive: true });
-  fs21.mkdirSync(path22.join(staging, "goals"), { recursive: true });
-  fs21.mkdirSync(path22.join(staging, "implementations"), { recursive: true });
-  fs21.mkdirSync(path22.join(staging, "shared"), { recursive: true });
-  fs21.mkdirSync(path22.join(staging, "workflows"), { recursive: true });
+  fs21.mkdirSync(path23.join(staging, "agents"), { recursive: true });
+  fs21.mkdirSync(path23.join(staging, "capabilities"), { recursive: true });
+  fs21.mkdirSync(path23.join(staging, "goals"), { recursive: true });
+  fs21.mkdirSync(path23.join(staging, "implementations"), { recursive: true });
+  fs21.mkdirSync(path23.join(staging, "shared"), { recursive: true });
+  fs21.mkdirSync(path23.join(staging, "workflows"), { recursive: true });
   try {
     const [capabilities, agents, goals, implementations, assets, workflows] = await Promise.all([
       options.backend.listDefinitions(options.tenantId, "capability"),
@@ -25482,7 +25529,7 @@ async function hydrateDefinitions(options) {
       hydratedAt: (/* @__PURE__ */ new Date()).toISOString(),
       versions: Object.fromEntries(Object.entries(versions).sort(([left], [right]) => left.localeCompare(right)))
     };
-    fs21.writeFileSync(path22.join(staging, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    fs21.writeFileSync(path23.join(staging, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
     fs21.rmSync(root, { recursive: true, force: true });
     fs21.renameSync(staging, root);
@@ -25511,7 +25558,7 @@ async function hydrateDefinitionsFromEnv(cwd = process.cwd(), env = process.env)
 // src/kody-cli.ts
 import { execFileSync as execFileSync24 } from "child_process";
 import * as fs55 from "fs";
-import * as path52 from "path";
+import * as path53 from "path";
 
 // src/app-auth.ts
 import { createSign } from "crypto";
@@ -26313,9 +26360,9 @@ async function resolveAuthToken(env = process.env) {
   return void 0;
 }
 function detectPackageManager2(cwd) {
-  if (fs55.existsSync(path52.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs55.existsSync(path52.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs55.existsSync(path52.join(cwd, "bun.lockb"))) return "bun";
+  if (fs55.existsSync(path53.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs55.existsSync(path53.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs55.existsSync(path53.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shouldChainScheduledWatch(match) {
@@ -26448,7 +26495,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path52.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path53.resolve(args.cwd) : process.cwd();
   try {
     const n = unpackAllSecrets();
     if (n > 0) process.stdout.write(`\u2192 kody: unpacked ${n} secret(s) from ALL_SECRETS
@@ -26932,7 +26979,7 @@ init_repoWorkspace();
 // src/scripts/brainTurnLog.ts
 init_runtimePaths();
 import * as fs56 from "fs";
-import * as path53 from "path";
+import * as path54 from "path";
 import posixPath4 from "path/posix";
 var live = /* @__PURE__ */ new Map();
 function brainEventsFilePath(dir, chatId) {
@@ -26979,7 +27026,7 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = brainEventsFilePath(dir, chatId);
-  fs56.mkdirSync(path53.dirname(p), { recursive: true });
+  fs56.mkdirSync(path54.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
@@ -27117,17 +27164,17 @@ function authOk(req, expected) {
   return false;
 }
 function readJsonBody(req) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve23({});
+        resolve24({});
         return;
       }
       try {
-        resolve23(JSON.parse(raw));
+        resolve24(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -27419,7 +27466,7 @@ function buildServer(opts) {
   const runTurn = opts.runTurn ?? runChatTurn;
   const createStore = opts.createStore ?? createSessionStore;
   const cloneRepo = opts.cloneRepo ?? defaultCloneRepo;
-  const reposRoot = opts.reposRoot ?? path54.join(path54.dirname(path54.resolve(opts.cwd)), "repos");
+  const reposRoot = opts.reposRoot ?? path55.join(path55.dirname(path55.resolve(opts.cwd)), "repos");
   return createServer2(async (req, res) => {
     if (!req.method || !req.url) {
       sendJson(res, 400, { error: "bad request" });
@@ -27500,11 +27547,11 @@ async function brainServe(opts) {
     litellmUrl,
     driver
   });
-  await new Promise((resolve23) => {
+  await new Promise((resolve24) => {
     server.listen(port, "0.0.0.0", () => {
       process.stdout.write(`[brain-serve] listening on 0.0.0.0:${port} (cwd=${opts.cwd})
 `);
-      resolve23();
+      resolve24();
     });
   });
   const shutdown = (signal) => {
@@ -27759,14 +27806,14 @@ async function startBrainProxy(opts) {
   const { httpServer, handler } = buildBrainProxy(opts);
   const port = opts.port ?? 0;
   const host = opts.host ?? "127.0.0.1";
-  await new Promise((resolve23) => httpServer.listen(port, host, () => resolve23()));
+  await new Promise((resolve24) => httpServer.listen(port, host, () => resolve24()));
   const addr = httpServer.address();
   return {
     httpServer,
     port: addr.port,
     url: `http://${host}:${addr.port}`,
-    stop: () => new Promise((resolve23) => {
-      httpServer.close(() => resolve23());
+    stop: () => new Promise((resolve24) => {
+      httpServer.close(() => resolve24());
     }),
     handler
   };
@@ -27916,23 +27963,23 @@ function buildMcpHttpServer(opts) {
     httpServer,
     routes,
     port,
-    stop: () => new Promise((resolve23) => {
+    stop: () => new Promise((resolve24) => {
       let pending = transports.size;
       if (pending === 0) {
-        httpServer.close(() => resolve23());
+        httpServer.close(() => resolve24());
         return;
       }
       for (const transport of transports.values()) {
         void transport.close().finally(() => {
           pending--;
-          if (pending === 0) httpServer.close(() => resolve23());
+          if (pending === 0) httpServer.close(() => resolve24());
         });
       }
     })
   };
 }
 function listenMcpHttpServer(server, host = "127.0.0.1") {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     server.httpServer.once("error", reject);
     server.httpServer.listen(server.port, host, () => {
       server.httpServer.off("error", reject);
@@ -27940,7 +27987,7 @@ function listenMcpHttpServer(server, host = "127.0.0.1") {
       if (addr && typeof addr === "object") {
         server.port = addr.port;
       }
-      resolve23();
+      resolve24();
     });
   });
 }
@@ -28023,7 +28070,7 @@ async function loadConfigSafe() {
 }
 
 // src/chat-cli.ts
-import * as path55 from "path";
+import * as path56 from "path";
 
 // src/chat/inbox.ts
 import { execFileSync as execFileSync25 } from "child_process";
@@ -28090,7 +28137,7 @@ async function waitForNextUserMessage(opts) {
   }
 }
 function sleep3(ms) {
-  return new Promise((resolve23) => setTimeout(resolve23, ms));
+  return new Promise((resolve24) => setTimeout(resolve24, ms));
 }
 function currentBranch(cwd) {
   try {
@@ -28314,7 +28361,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path55.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path56.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const runRequest = readRunRequestFromEnv();
   if (runRequest && "request" in runRequest) {
@@ -28441,7 +28488,7 @@ init_registry();
 
 // src/servers/brain-terminal-agent.ts
 init_repoWorkspace();
-import * as path57 from "path";
+import * as path58 from "path";
 import { createInterface as createInterface2 } from "readline";
 
 // src/terminal/brain-terminal-session.ts
@@ -28755,10 +28802,10 @@ var BrainTerminalSessionAgent = class {
 // src/terminal/brain-terminal-adapters.ts
 import { createHash as createHash10, randomBytes as randomBytes2 } from "crypto";
 import { mkdir, readFile, rename, writeFile as writeFile2 } from "fs/promises";
-import * as path56 from "path";
+import * as path57 from "path";
 import { spawn as spawn9 } from "child_process";
 function runTerminalCommand(command, args, input) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     const child = spawn9(command, args, { stdio: ["pipe", "pipe", "pipe"] });
     const stdout = [];
     const stderr = [];
@@ -28766,7 +28813,7 @@ function runTerminalCommand(command, args, input) {
     child.stderr.on("data", (chunk) => stderr.push(chunk));
     child.on("error", reject);
     child.on("close", (code) => {
-      resolve23({
+      resolve24({
         code: code ?? 1,
         stdout: Buffer.concat(stdout).toString("utf8"),
         stderr: Buffer.concat(stderr).toString("utf8")
@@ -28790,7 +28837,7 @@ var FileBrainTerminalMetadataStore = class {
   }
   root;
   file(id) {
-    return path56.join(this.root, `${storeKey(id)}.json`);
+    return path57.join(this.root, `${storeKey(id)}.json`);
   }
   async read(id) {
     try {
@@ -28911,8 +28958,8 @@ async function brainTerminalAgent(options) {
   const input = options.input ?? process.stdin;
   const output = options.output ?? process.stdout;
   const error = options.error ?? process.stderr;
-  const reposRoot = process.env.BRAIN_REPOS_ROOT?.trim() || path57.join(path57.dirname(path57.resolve(options.cwd)), "repos");
-  const stateRoot = process.env.BRAIN_TERMINAL_STATE_ROOT?.trim() || path57.join(path57.dirname(reposRoot), ".kody", "terminal-sessions");
+  const reposRoot = process.env.BRAIN_REPOS_ROOT?.trim() || path58.join(path58.dirname(path58.resolve(options.cwd)), "repos");
+  const stateRoot = process.env.BRAIN_TERMINAL_STATE_ROOT?.trim() || path58.join(path58.dirname(reposRoot), ".kody", "terminal-sessions");
   const agent = new BrainTerminalSessionAgent({
     store: new FileBrainTerminalMetadataStore(stateRoot),
     runtime: new TmuxBrainTerminalRuntime()
@@ -29079,8 +29126,8 @@ var FlyClient = class {
   get fetch() {
     return this.opts.fetchImpl ?? fetch;
   }
-  async call(path58, init = {}) {
-    const res = await this.fetch(`${FLY_API_BASE}${path58}`, {
+  async call(path59, init = {}) {
+    const res = await this.fetch(`${FLY_API_BASE}${path59}`, {
       method: init.method ?? "GET",
       headers: {
         Authorization: `Bearer ${this.opts.token}`,
@@ -29091,7 +29138,7 @@ var FlyClient = class {
     if (res.status === 404 && init.allow404) return null;
     if (!res.ok) {
       const text2 = await res.text().catch(() => "");
-      throw new Error(`Fly API ${res.status} on ${path58}: ${text2.slice(0, 200) || res.statusText}`);
+      throw new Error(`Fly API ${res.status} on ${path59}: ${text2.slice(0, 200) || res.statusText}`);
     }
     if (res.status === 204) return null;
     const raw = await res.text();
@@ -29604,14 +29651,14 @@ function sendJson2(res, status, body) {
   res.end(JSON.stringify(body));
 }
 function readJsonBody2(req) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
-      if (!raw.trim()) return resolve23({});
+      if (!raw.trim()) return resolve24({});
       try {
-        resolve23(JSON.parse(raw));
+        resolve24(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -29765,10 +29812,10 @@ async function poolServe() {
     }
   });
   const apiHost = process.env.POOL_API_HOST ?? "::";
-  await new Promise((resolve23) => {
+  await new Promise((resolve24) => {
     server.listen(apiPort, apiHost, () => {
       log(`listening on ${apiHost}:${apiPort} (min=${min}, app=${app}, region=${region})`);
-      resolve23();
+      resolve24();
     });
   });
   if (loopTickEnabled) void runLoopTick();
@@ -29808,17 +29855,17 @@ function authOk2(req, expected) {
   return false;
 }
 function readJsonBody3(req) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve23({});
+        resolve24({});
         return;
       }
       try {
-        resolve23(JSON.parse(raw));
+        resolve24(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -29893,13 +29940,13 @@ async function defaultRunJob(job) {
     ...interactive && job.idleExitMs ? { KODY_IDLE_EXIT_MS: String(job.idleExitMs) } : {},
     ...interactive && job.hardCapMs ? { KODY_HARD_CAP_MS: String(job.hardCapMs) } : {}
   };
-  const run = (cmd, args, cwd) => new Promise((resolve23) => {
+  const run = (cmd, args, cwd) => new Promise((resolve24) => {
     const child = spawn10(cmd, args, { stdio: "inherit", env: childEnv, cwd });
-    child.on("exit", (code) => resolve23(code ?? 0));
+    child.on("exit", (code) => resolve24(code ?? 0));
     child.on("error", (err) => {
       process.stderr.write(`[runner-serve] ${cmd} failed: ${err.message}
 `);
-      resolve23(1);
+      resolve24(1);
     });
   });
   process.stdout.write(`[runner-serve] job ${job.jobId}: cloning ${job.repo}@${branch}
@@ -29975,11 +30022,11 @@ async function runnerServe() {
   const port = Number(process.env.PORT ?? DEFAULT_PORT2);
   const server = buildServer2({ apiKey });
   const host = process.env.RUNNER_HOST ?? "::";
-  await new Promise((resolve23) => {
+  await new Promise((resolve24) => {
     server.listen(port, host, () => {
       process.stdout.write(`[runner-serve] listening on ${host}:${port} (idle, awaiting job)
 `);
-      resolve23();
+      resolve24();
     });
   });
   const shutdown = (signal) => {
@@ -30048,14 +30095,14 @@ async function serve(opts) {
 `);
     const args = ["--dangerously-skip-permissions", "--model", model.model];
     const child = spawn11("claude", args, { stdio: "inherit", env: editorEnv, cwd: opts.cwd });
-    const exitCode = await new Promise((resolve23) => {
-      child.on("exit", (code) => resolve23(code ?? 0));
+    const exitCode = await new Promise((resolve24) => {
+      child.on("exit", (code) => resolve24(code ?? 0));
       child.on("error", (err) => {
         process.stderr.write(`[kody serve] failed to launch Claude Code: ${err.message}
 `);
         process.stderr.write(`  Install: https://docs.anthropic.com/claude/docs/claude-code
 `);
-        resolve23(1);
+        resolve24(1);
       });
     });
     killProxy();