@kody-ade/kody-engine 0.4.434 → 0.4.436

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.434",
+      version: "0.4.436",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -47,7 +47,7 @@ var init_package = __esm({
         "lint:fix": "biome check --write",
         format: "biome format --write",
         "verify:package": "node scripts/verify-package-tarball.cjs",
-        "brain:publish": "docker buildx build --platform linux/amd64 -f runner/Dockerfile.brain -t ghcr.io/${KODY_BRAIN_GHCR_OWNER:-aharonyaircohen}/kody-brain:latest --push runner",
+        "brain:publish": "docker buildx build --platform linux/amd64 -f runner/Dockerfile.brain --build-arg KODY_ENGINE_REF=$(git rev-parse HEAD) -t ghcr.io/${KODY_BRAIN_GHCR_OWNER:-aharonyaircohen}/kody-brain:latest --push runner",
         prepublishOnly: "pnpm typecheck && vitest run tests/unit tests/int --no-coverage && pnpm test:runtime-services && pnpm build && pnpm verify:package"
       },
       dependencies: {
@@ -1104,7 +1104,7 @@ function cmsHeaders(opts) {
     }
   };
 }
-async function callDashboardCms(opts, path52, init = {}) {
+async function callDashboardCms(opts, path54, init = {}) {
   const baseUrl = dashboardBaseUrl(opts);
   if (!baseUrl) {
     return {
@@ -1116,7 +1116,7 @@ async function callDashboardCms(opts, path52, init = {}) {
   const headerResult = cmsHeaders(opts);
   if (!headerResult.ok) return headerResult;
   try {
-    const res = await fetch(`${baseUrl}${path52}`, {
+    const res = await fetch(`${baseUrl}${path54}`, {
       ...init,
       headers: {
         ...headerResult.headers,
@@ -1188,8 +1188,8 @@ function documentArg(value) {
 function normalizeCmsDocumentIdInput(input) {
   const trimmed = stripWrappingQuotes(input.trim());
   const withoutQuery = trimmed.split(/[?#]/, 1)[0] ?? trimmed;
-  const path52 = parseDocumentPath(withoutQuery);
-  return path52 ?? parseDocumentIdSegment(withoutQuery) ?? withoutQuery;
+  const path54 = parseDocumentPath(withoutQuery);
+  return path54 ?? parseDocumentIdSegment(withoutQuery) ?? withoutQuery;
 }
 function stripWrappingQuotes(value) {
   let current = value;
@@ -1200,9 +1200,9 @@ function stripWrappingQuotes(value) {
   }
 }
 function parseDocumentPath(value) {
-  const path52 = value.startsWith("http://") || value.startsWith("https://") ? urlPathname(value) : value;
-  if (!path52?.includes("/content/entries/")) return null;
-  const parts = path52.split("/").filter(Boolean).map(decodePathPart);
+  const path54 = value.startsWith("http://") || value.startsWith("https://") ? urlPathname(value) : value;
+  if (!path54?.includes("/content/entries/")) return null;
+  const parts = path54.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;
@@ -1646,56 +1646,6 @@ var init_issue = __esm({
   }
 });
 
-// src/agency/implementation-resolution.ts
-function resolveCapabilityImplementation(input) {
-  const compatible = input.implementations.filter(
-    (implementation) => implementation.capabilityRef.id === input.capabilityId && implementation.compatibleCapabilityRevision === input.capabilityRevision
-  );
-  if (input.explicitOverride) {
-    if (!input.authorizeOverride?.(input.explicitOverride)) {
-      throw new ImplementationResolutionError(`Implementation override "${input.explicitOverride}" is not authorized`);
-    }
-    return selectNamed(input.explicitOverride, input, compatible, "override");
-  }
-  if (input.repositoryBinding) {
-    return selectNamed(input.repositoryBinding, input, compatible, "repository binding");
-  }
-  if (compatible.length === 1) return compatible[0];
-  if (compatible.length === 0) {
-    throw new ImplementationResolutionError(
-      `No compatible Implementation is available for Capability "${input.capabilityId}" at revision "${input.capabilityRevision}"`
-    );
-  }
-  throw new ImplementationResolutionError(
-    `Capability "${input.capabilityId}" has ${compatible.length} compatible Implementations; configure a repository binding`
-  );
-}
-function selectNamed(id, input, compatible, source) {
-  const known = input.implementations.find((implementation) => implementation.id === id);
-  if (!known) {
-    throw new ImplementationResolutionError(`Implementation ${source} "${id}" is not available`);
-  }
-  const selected = compatible.find((implementation) => implementation.id === id);
-  if (!selected) {
-    throw new ImplementationResolutionError(
-      `Implementation ${source} "${id}" is not compatible with Capability "${input.capabilityId}" at revision "${input.capabilityRevision}"`
-    );
-  }
-  return selected;
-}
-var ImplementationResolutionError;
-var init_implementation_resolution = __esm({
-  "src/agency/implementation-resolution.ts"() {
-    "use strict";
-    ImplementationResolutionError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "ImplementationResolutionError";
-      }
-    };
-  }
-});
-
 // src/capabilityFolders.ts
 import * as fs4 from "fs";
 import * as path5 from "path";
@@ -1731,19 +1681,29 @@ function listCapabilityFolderSlugs(absDir) {
   return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).filter((e) => isCapabilityFolder(path5.join(absDir, e.name))).map((e) => e.name).sort();
 }
 function isCapabilityFolder(dir) {
-  return (fs4.existsSync(path5.join(dir, CAPABILITY_DEFINITION_FILE)) || fs4.existsSync(path5.join(dir, CAPABILITY_PROFILE_FILE))) && fs4.existsSync(path5.join(dir, CAPABILITY_BODY_FILE));
+  if (!fs4.existsSync(path5.join(dir, CAPABILITY_DEFINITION_FILE))) return false;
+  if (!fs4.existsSync(path5.join(dir, CAPABILITY_BODY_FILE))) return false;
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  return entries.every(
+    (entry) => entry.name === CAPABILITY_DEFINITION_FILE || entry.name === CAPABILITY_BODY_FILE || entry.isDirectory() && (entry.name === "skills" || entry.name === "tools")
+  );
 }
 function readCapabilityFolder(root, slug) {
   const dir = path5.join(root, slug);
   const definitionPath = path5.join(dir, CAPABILITY_DEFINITION_FILE);
-  const legacyProfilePath = path5.join(dir, CAPABILITY_PROFILE_FILE);
-  const profilePath = fs4.existsSync(definitionPath) ? definitionPath : legacyProfilePath;
+  const profilePath = definitionPath;
   const bodyPath = path5.join(dir, CAPABILITY_BODY_FILE);
   if (!fs4.existsSync(profilePath) || !fs4.statSync(profilePath).isFile()) return null;
   if (!fs4.existsSync(bodyPath) || !fs4.statSync(bodyPath).isFile()) return null;
   try {
     const rawDefinition = JSON.parse(fs4.readFileSync(profilePath, "utf-8"));
-    const rawProfile = rawDefinition;
+    const contract = parseCapabilityContract(rawDefinition);
+    if (!contract) return null;
+    const rawProfile = {
+      inputSchema: contract.input.schema,
+      outputSchema: contract.output.schema,
+      contract
+    };
     const rawBody = fs4.readFileSync(bodyPath, "utf-8");
     const { title, body } = parseCapabilityBody(rawBody, slug);
     return {
@@ -1754,54 +1714,28 @@ function readCapabilityFolder(root, slug) {
       title,
       body,
       rawBody,
-      config: parseCapabilityConfig(rawProfile),
+      config: {
+        action: slug,
+        describe: title,
+        outputSchema: contract.output.schema
+      },
       rawProfile
     };
   } catch {
     return null;
   }
 }
-function parseCapabilityConfig(raw) {
-  const tools = stringList(raw.tools ?? raw.capabilityTools ?? raw.capabilityTools);
-  const implementations = stringList(raw.implementations);
-  return {
-    action: stringField(raw.action),
-    implementation: stringField(raw.implementation),
-    tickScript: stringField(raw.tickScript),
-    capabilityKind: parseCapabilityKind(raw.capabilityKind),
-    disabled: typeof raw.disabled === "boolean" ? raw.disabled : void 0,
-    internal: typeof raw.internal === "boolean" ? raw.internal : void 0,
-    public: typeof raw.public === "boolean" ? raw.public : void 0,
-    agent: stringField(raw.agent),
-    mentions: stringList(raw.mentions).map((m) => m.replace(/^@/, "")),
-    tools,
-    capabilityTools: tools,
-    capabilityToolMode: parseCapabilityToolMode(raw.capabilityToolMode),
-    implementations,
-    role: stringField(raw.role),
-    describe: stringField(raw.describe) ?? stringField(raw.purpose),
-    stage: stringField(raw.stage),
-    readsFrom: stringList(raw.readsFrom ?? raw.reads_from),
-    writesTo: stringList(raw.writesTo ?? raw.writes_to),
-    output: parseCapabilityOutput(raw.output),
-    outputSchema: isPlainObject(raw.outputSchema) ? raw.outputSchema : void 0,
-    workflow: parseCapabilityWorkflow(raw.workflow)
+function parseCapabilityContract(raw) {
+  if (Object.keys(raw).length !== 2 || !isPlainObject(raw.input) || !isPlainObject(raw.output)) return null;
+  const parseValue = (value) => {
+    if (Object.keys(value).some((key) => key !== "name" && key !== "schema") || typeof value.name !== "string" || !/^[a-z][a-z0-9-]*$/.test(value.name) || !isPlainObject(value.schema)) {
+      return null;
+    }
+    return { name: value.name, schema: value.schema };
   };
-}
-function parseCapabilityOutput(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
-  const result = raw.result;
-  if (!result || typeof result !== "object" || Array.isArray(result)) return void 0;
-  const facts = stringList(result.facts);
-  return { result: { facts } };
-}
-function parseCapabilityKind(raw) {
-  return raw === "observe" || raw === "act" || raw === "verify" ? raw : void 0;
-}
-function parseCapabilityToolMode(raw) {
-  if (raw === void 0 || raw === null || raw === "") return void 0;
-  if (raw === "lock" || raw === "append") return raw;
-  return void 0;
+  const input = parseValue(raw.input);
+  const output = parseValue(raw.output);
+  return input && output ? { input, output } : null;
 }
 function parseCapabilityBody(raw, slug) {
   const trimmed = raw.trim();
@@ -1859,7 +1793,6 @@ function parseWorkflowStep(value) {
   const id = stringField(raw.id);
   const action = stringField(raw.action);
   const evidence = stringField(raw.evidence);
-  const agent = stringField(raw.agent);
   const reason = stringField(raw.reason);
   const target = stringField(raw.target);
   const targetFact = stringField(raw.targetFact ?? raw.target_fact);
@@ -1875,7 +1808,6 @@ function parseWorkflowStep(value) {
     ...evidence ? { evidence } : {},
     ...target === "issue" || target === "pr" ? { target } : {},
     ...targetFact ? { targetFact } : {},
-    ...agent && isSafeSlug(agent) ? { agent } : {},
     ...reason ? { reason } : {},
     ...cliArgs && typeof cliArgs === "object" && !Array.isArray(cliArgs) ? { cliArgs } : {},
     ...inputs ? { inputs } : {},
@@ -1957,9 +1889,9 @@ var CAPABILITY_PROFILE_FILE, CAPABILITY_DEFINITION_FILE, CAPABILITY_BODY_FILE;
 var init_capabilityFolders = __esm({
   "src/capabilityFolders.ts"() {
     "use strict";
-    CAPABILITY_PROFILE_FILE = "profile.json";
-    CAPABILITY_DEFINITION_FILE = "definition.json";
-    CAPABILITY_BODY_FILE = "capability.md";
+    CAPABILITY_PROFILE_FILE = "contract.json";
+    CAPABILITY_DEFINITION_FILE = "contract.json";
+    CAPABILITY_BODY_FILE = "instructions.md";
   }
 });
 
@@ -1997,7 +1929,6 @@ var init_definition_paths = __esm({
 });
 
 // src/registry.ts
-import { createHash as createHash2 } from "crypto";
 import * as fs6 from "fs";
 import * as path7 from "path";
 function getImplementationsRoot() {
@@ -2049,10 +1980,12 @@ function getImplementationRoots() {
   return getImplementationRootsForCwd(process.cwd());
 }
 function getImplementationRootsForCwd(cwd) {
-  return [implementationsRoot(cwd), getImplementationsRoot()];
+  void cwd;
+  return [getImplementationsRoot()];
 }
 function getRuntimeProfileRootsForCwd(cwd) {
-  return [...getImplementationRootsForCwd(cwd), getRuntimeServicesRoot()];
+  const roots = [...getImplementationRootsForCwd(cwd), getRuntimeServicesRoot()];
+  return process.env.NODE_ENV === "test" ? [implementationsRoot(cwd), ...roots] : roots;
 }
 function getCapabilityRoots(projectCapabilitiesRoot = getProjectCapabilitiesRoot()) {
   return [projectCapabilitiesRoot, getBuiltinCapabilitiesRoot()];
@@ -2127,7 +2060,7 @@ function getCapabilityActionInputs(action, projectCapabilitiesRoot = getProjectC
   const resolved = resolveCapabilityAction(action, projectCapabilitiesRoot);
   if (!resolved) return null;
   const capability = resolveCapabilityFolder(resolved.capability, projectCapabilitiesRoot);
-  if (capability && path7.basename(capability.profilePath) === "definition.json") {
+  if (capability && path7.basename(capability.profilePath) === "contract.json") {
     const schema = capability.rawProfile.inputSchema;
     if (!schema || typeof schema !== "object" || Array.isArray(schema)) return [];
     const properties = schema.properties;
@@ -2151,17 +2084,8 @@ function getCapabilityActionInputs(action, projectCapabilitiesRoot = getProjectC
   return getProfileInputs(resolved.implementation);
 }
 function resolveCapabilityExecution(capability, cwd = process.cwd()) {
-  if (path7.basename(capability.profilePath) === "definition.json") {
-    const implementations = readExternalImplementations(cwd);
-    const definition = JSON.parse(fs6.readFileSync(capability.profilePath, "utf-8"));
-    const capabilityRevision = createHash2("sha256").update(canonical(definition)).digest("hex");
-    const selected = resolveCapabilityImplementation({
-      capabilityId: capability.slug,
-      capabilityRevision,
-      implementations,
-      repositoryBinding: repositoryImplementationBinding(capability.slug, cwd)
-    });
-    return { implementation: selected.id, cliArgs: {} };
+  if (path7.basename(capability.profilePath) === "contract.json") {
+    return { implementation: "capability-run", cliArgs: { capability: capability.slug } };
   }
   const firstWorkflowStep = capability.config.workflow?.steps[0];
   if (firstWorkflowStep) {
@@ -2172,36 +2096,6 @@ function resolveCapabilityExecution(capability, cwd = process.cwd()) {
   const cliArgs = implementationDeclaresInput(implementation, "capability", cwd) ? { capability: capability.slug } : {};
   return { implementation, cliArgs };
 }
-function repositoryImplementationBinding(capabilityId, cwd) {
-  try {
-    return loadConfig(cwd).execution?.capabilityBindings[capabilityId];
-  } catch {
-    return void 0;
-  }
-}
-function readExternalImplementations(cwd) {
-  const root = implementationsRoot(cwd);
-  if (!fs6.existsSync(root)) return [];
-  const definitions = [];
-  for (const entry of fs6.readdirSync(root, { withFileTypes: true })) {
-    if (!entry.isDirectory() || !isSafeName(entry.name)) continue;
-    const definitionPath = path7.join(root, entry.name, "definition.json");
-    if (!fs6.existsSync(definitionPath)) continue;
-    try {
-      const definition = JSON.parse(fs6.readFileSync(definitionPath, "utf-8"));
-      definitions.push(definition);
-    } catch {
-    }
-  }
-  return definitions;
-}
-function canonical(value) {
-  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
-  if (value && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
 function implementationDeclaresInput(implementation, inputName, cwd = process.cwd()) {
   const profilePath = resolveImplementation(implementation, getRuntimeProfileRootsForCwd(cwd));
   if (!profilePath) return false;
@@ -2229,7 +2123,10 @@ function isCapabilityRoot(root) {
 }
 function implementationRuntimePath(root, name) {
   const runtimePath = path7.join(root, name, "runtime.json");
-  return fs6.existsSync(runtimePath) ? runtimePath : path7.join(root, name, CAPABILITY_PROFILE_FILE);
+  if (fs6.existsSync(runtimePath)) return runtimePath;
+  const internalProfilePath = path7.join(root, name, "profile.json");
+  if (fs6.existsSync(internalProfilePath)) return internalProfilePath;
+  return path7.join(root, name, CAPABILITY_PROFILE_FILE);
 }
 function isImplementationProfile(profilePath, requireImplementationProfile) {
   if (!requireImplementationProfile) return true;
@@ -2336,9 +2233,7 @@ var PUBLIC_IMPLEMENTATION_ROLES;
 var init_registry = __esm({
   "src/registry.ts"() {
     "use strict";
-    init_implementation_resolution();
     init_capabilityFolders();
-    init_config();
     init_definition_paths();
     PUBLIC_IMPLEMENTATION_ROLES = /* @__PURE__ */ new Set(["primitive", "orchestrator", "container", "watch", "utility"]);
   }
@@ -4931,7 +4826,7 @@ var init_subagents = __esm({
 });
 
 // src/profile.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import * as fs21 from "fs";
 import * as path20 from "path";
 function loadProfile(profilePath) {
@@ -4972,7 +4867,7 @@ function loadProfile(profilePath) {
         implementation: execRef,
         internal: typeof r.internal === "boolean" ? r.internal : base.internal,
         public: typeof r.public === "boolean" ? r.public : base.public,
-        capabilityKind: parseCapabilityKind2(r.capabilityKind) ?? base.capabilityKind,
+        capabilityKind: parseCapabilityKind(r.capabilityKind) ?? base.capabilityKind,
         slug: typeof r.slug === "string" && r.slug.trim() ? r.slug.trim() : base.slug,
         title: typeof r.title === "string" && r.title.trim() ? r.title.trim() : base.title,
         skills: parseStringArray2(r.skills) ?? base.skills,
@@ -4981,7 +4876,7 @@ function loadProfile(profilePath) {
         describe: typeof r.describe === "string" ? r.describe : base.describe,
         agent: typeof r.agent === "string" && r.agent.trim() ? r.agent.trim() : base.agent,
         capabilityTools: parseStringArray2(r.capabilityTools ?? r.capabilityTools ?? r.tools) ?? base.capabilityTools,
-        capabilityToolMode: parseCapabilityToolMode2(profilePath, r.capabilityToolMode) ?? base.capabilityToolMode,
+        capabilityToolMode: parseCapabilityToolMode(profilePath, r.capabilityToolMode) ?? base.capabilityToolMode,
         mentions: Array.isArray(r.mentions) ? r.mentions.map((m) => String(m).trim()).filter(Boolean) : base.mentions
       };
     }
@@ -5025,7 +4920,7 @@ function loadProfile(profilePath) {
     implementation: void 0,
     internal: typeof r.internal === "boolean" ? r.internal : void 0,
     public: typeof r.public === "boolean" ? r.public : void 0,
-    capabilityKind: parseCapabilityKind2(r.capabilityKind),
+    capabilityKind: parseCapabilityKind(r.capabilityKind),
     slug: typeof r.slug === "string" && r.slug.trim() ? r.slug.trim() : void 0,
     title: typeof r.title === "string" && r.title.trim() ? r.title.trim() : void 0,
     skills: parseStringArray2(r.skills),
@@ -5037,7 +4932,7 @@ function loadProfile(profilePath) {
     agent: typeof r.agent === "string" && r.agent.trim() ? r.agent.trim() : void 0,
     // Locked-toolbox palette + mentions from folder-capability profile metadata.
     capabilityTools: parseStringArray2(r.capabilityTools ?? r.capabilityTools ?? r.tools),
-    capabilityToolMode: parseCapabilityToolMode2(profilePath, r.capabilityToolMode),
+    capabilityToolMode: parseCapabilityToolMode(profilePath, r.capabilityToolMode),
     mentions: Array.isArray(r.mentions) ? r.mentions.map((m) => String(m).trim()).filter(Boolean) : void 0,
     role,
     kind,
@@ -5130,18 +5025,18 @@ function compileRuntimeDocument(runtimePath, document) {
     agent: agentRef,
     canonicalContract: {
       capabilityId,
-      capabilityRevision: createHash4("sha256").update(canonical2(capability)).digest("hex"),
+      capabilityRevision: createHash3("sha256").update(canonical(capability)).digest("hex"),
       implementationId: String(implementation.id),
-      implementationRevision: createHash4("sha256").update(canonical2(implementation)).digest("hex"),
+      implementationRevision: createHash3("sha256").update(canonical(implementation)).digest("hex"),
       inputSchema: capability.inputSchema,
       outputSchema: capability.outputSchema
     }
   };
 }
-function canonical2(value) {
-  if (Array.isArray(value)) return `[${value.map(canonical2).join(",")}]`;
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
   if (value && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonical2(item)}`).join(",")}}`;
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
   }
   return JSON.stringify(value);
 }
@@ -5156,7 +5051,7 @@ function readJsonObject(filePath, label) {
     throw new ProfileError(filePath, `${label} is invalid: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
-function parseCapabilityToolMode2(profilePath, raw) {
+function parseCapabilityToolMode(profilePath, raw) {
   if (raw === void 0 || raw === null || raw === "") return void 0;
   if (raw === "lock" || raw === "append") return raw;
   throw new ProfileError(profilePath, `"capabilityToolMode" must be "lock" or "append"`);
@@ -5274,7 +5169,7 @@ function parseAuth(p, raw) {
   });
   return { methods };
 }
-function parseCapabilityKind2(raw) {
+function parseCapabilityKind(raw) {
   return raw === "observe" || raw === "act" || raw === "verify" ? raw : void 0;
 }
 function parseInputs(p, raw) {
@@ -8227,9 +8122,9 @@ import * as fs27 from "fs";
 function stageGoalRunLogEvent(data, goalId, event, at = nowIso()) {
   const logs = goalRunLogs(data);
   const existing = logs[goalId];
-  const path52 = existing?.path ?? goalRunLogPath(goalId, data);
+  const path54 = existing?.path ?? goalRunLogPath(goalId, data);
   logs[goalId] = {
-    path: path52,
+    path: path54,
     events: [...existing?.events ?? [], buildGoalRunLogEvent(data, goalId, event, at)]
   };
 }
@@ -9202,11 +9097,11 @@ function validateWorkflow(value, options = {}) {
 function formatWorkflowValidationIssues(issues) {
   return issues.map((entry) => `${entry.path}: ${entry.message}`);
 }
-function validateDataMatch(value, path52, issues, capabilityOutputs) {
+function validateDataMatch(value, path54, issues, capabilityOutputs) {
   if (value === void 0) return;
   const match = asRecord2(value);
   if (!match || Object.keys(match).length === 0) {
-    issue(issues, "invalid_condition", path52, "workflow condition must contain at least one match");
+    issue(issues, "invalid_condition", path54, "workflow condition must contain at least one match");
     return;
   }
   for (const [field, expected] of Object.entries(match)) {
@@ -9214,7 +9109,7 @@ function validateDataMatch(value, path52, issues, capabilityOutputs) {
       issue(
         issues,
         "invalid_data_path",
-        `${path52}.${field}`,
+        `${path54}.${field}`,
         `workflow condition must read from facts, evidence, artifacts, result, workflow, or lastOutcome`
       );
     }
@@ -9222,12 +9117,12 @@ function validateDataMatch(value, path52, issues, capabilityOutputs) {
       issue(
         issues,
         "undeclared_result_path",
-        `${path52}.${field}`,
+        `${path54}.${field}`,
         `workflow condition reads ${field}, but the source capability does not declare it`
       );
     }
     if (!isComparable(expected)) {
-      issue(issues, "invalid_condition_value", `${path52}.${field}`, "workflow condition value must be a JSON scalar");
+      issue(issues, "invalid_condition_value", `${path54}.${field}`, "workflow condition value must be a JSON scalar");
     }
   }
 }
@@ -9245,8 +9140,8 @@ function isComparable(value) {
   if (value === null || ["string", "number", "boolean"].includes(typeof value)) return true;
   return Array.isArray(value) && value.length > 0 && value.every((item) => isComparable(item) && !Array.isArray(item));
 }
-function issue(issues, code, path52, message) {
-  issues.push({ code, path: path52, message });
+function issue(issues, code, path54, message) {
+  issues.push({ code, path: path54, message });
 }
 var SAFE_NAME, SAFE_STEP_ID, SAFE_DATA_PATH, SUPPORTED_STEP_FIELDS, SUPPORTED_TRANSITION_FIELDS;
 var init_workflowValidation = __esm({
@@ -9264,7 +9159,6 @@ var init_workflowValidation = __esm({
       "target",
       "targetFact",
       "reason",
-      "agent",
       "cliArgs",
       "inputs",
       "next",
@@ -9293,6 +9187,8 @@ function normalizeWorkflowDefinition(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const raw = value;
   const name = typeof raw.name === "string" ? raw.name.trim() : "";
+  const requestedAgent = typeof raw.agent === "string" ? raw.agent.trim() : "";
+  const agent = /^[a-z][a-z0-9-]*$/.test(requestedAgent) ? requestedAgent : "kody";
   const hasGraphConnections = Array.isArray(raw.steps) && raw.steps.some(
     (step) => step && typeof step === "object" && !Array.isArray(step) && (step.next !== void 0 || step.inputs !== void 0)
   );
@@ -9309,8 +9205,8 @@ function normalizeWorkflowDefinition(value) {
   const capabilities = steps ? steps.map((step) => step.capability) : normalizeWorkflowCapabilities(raw.capabilities);
   if (!name || capabilities.length === 0) return null;
   return {
-    version: 1,
     name,
+    agent,
     capabilities,
     ...raw.runWithoutApproval === true ? { runWithoutApproval: true } : {},
     ...steps ? { steps } : {},
@@ -9324,7 +9220,7 @@ function readWorkflowDefinition(_config, cwd, id) {
   const relativePath = workflowDefinitionPath(id);
   const candidates = [
     path26.join(root, ".kody-engine", "runtime", relativePath),
-    path26.join(root, ".kody-engine", "definitions", relativePath)
+    path26.join(definitionsRoot(root), relativePath)
   ];
   for (const filePath of candidates) {
     if (!fs29.existsSync(filePath)) continue;
@@ -9346,7 +9242,8 @@ function workflowDefinitionToCapabilityFolder(id, workflow, source = workflowDef
     config: {
       action: id,
       workflow: workflowDefinitionToConfig(workflow),
-      describe: workflow.name
+      describe: workflow.name,
+      agent: workflow.agent
     }
   };
 }
@@ -9381,6 +9278,7 @@ var init_workflowDefinitions = __esm({
   "src/workflowDefinitions.ts"() {
     "use strict";
     init_capabilityFolders();
+    init_definition_paths();
     init_workflowValidation();
     WORKFLOW_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,79}$/;
     CAPABILITY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,79}$/;
@@ -9513,15 +9411,15 @@ var init_backendStateBackend = __esm({
         this.jobsDir = opts.jobsDir.replace(/\/+$/, "");
       }
       async load(slug) {
-        const path52 = stateFilePath(this.jobsDir, slug);
+        const path54 = stateFilePath(this.jobsDir, slug);
         const loaded = await createStateBackendFromEnv().get(this.tenantId, `capabilities/${slug}`, "job-state");
         if (!loaded) {
-          return { path: path52, handle: null, state: initialStateEnvelope("seed"), created: true };
+          return { path: path54, handle: null, state: initialStateEnvelope("seed"), created: true };
         }
         if (!isStateEnvelope(loaded.doc)) {
           throw new Error(`BackendStateBackend: capabilities/${slug} is not a StateEnvelope`);
         }
-        return { path: path52, handle: loaded.updatedAt, state: loaded.doc, created: false };
+        return { path: path54, handle: loaded.updatedAt, state: loaded.doc, created: false };
       }
       async save(loaded, next) {
         if (!loaded.created && isStateUnchanged(loaded.state, next)) return false;
@@ -13524,7 +13422,7 @@ var init_triggerDispatcher = __esm({
 });
 
 // src/goal/policyResolver.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function resolveDispatchPolicy(input) {
   const operation = input.catalog.operations.get(input.owner.definition.operationId);
   if (!operation) throw new Error(`Dispatch blocked: Operation "${input.owner.definition.operationId}" is unresolved`);
@@ -13542,7 +13440,7 @@ function resolveDispatchPolicy(input) {
   const snapshotValue = { policy, constraints };
   return {
     snapshot: {
-      hash: createHash5("sha256").update(stableJson(snapshotValue)).digest("hex"),
+      hash: createHash4("sha256").update(stableJson(snapshotValue)).digest("hex"),
       ...snapshotValue
     },
     operation,
@@ -15343,17 +15241,103 @@ var init_loadCapabilityState = __esm({
   }
 });
 
+// src/scripts/loadSimpleCapability.ts
+import * as fs39 from "fs";
+import * as path36 from "path";
+function listFiles(root) {
+  if (!fs39.existsSync(root)) return [];
+  const files = [];
+  const visit = (dir) => {
+    for (const entry of fs39.readdirSync(dir, { withFileTypes: true })) {
+      const absolute = path36.join(dir, entry.name);
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) visit(absolute);
+      else if (entry.isFile()) files.push(path36.relative(root, absolute));
+    }
+  };
+  visit(root);
+  return files.sort();
+}
+var loadSimpleCapability;
+var init_loadSimpleCapability = __esm({
+  "src/scripts/loadSimpleCapability.ts"() {
+    "use strict";
+    init_definition_paths();
+    init_capabilityFolders();
+    loadSimpleCapability = async (ctx) => {
+      const slug = typeof ctx.args.capability === "string" ? ctx.args.capability.trim() : "";
+      if (!/^[a-z][a-z0-9-]*$/.test(slug)) {
+        throw new Error("capability-run requires a valid capability slug");
+      }
+      const capability = readCapabilityFolder(capabilitiesRoot(ctx.cwd), slug);
+      if (!capability) {
+        throw new Error(`Capability "${slug}" is not a valid simple capability folder`);
+      }
+      const contract = capability.rawProfile.contract;
+      const toolRoot = path36.join(capability.dir, "tools");
+      const skillRoot = path36.join(capability.dir, "skills");
+      const toolFiles = listFiles(toolRoot);
+      const skillFiles = listFiles(skillRoot);
+      const supplied = ctx.args.input;
+      let input = supplied;
+      if (typeof supplied === "string") {
+        try {
+          input = JSON.parse(supplied);
+        } catch {
+          input = supplied;
+        }
+      }
+      ctx.data.jobCapability = slug;
+      ctx.data.capabilityInput = input;
+      ctx.data.capabilityContract = contract;
+      ctx.data.prompt = [
+        capability.rawBody.trim(),
+        "",
+        "## Input",
+        "",
+        "```json",
+        JSON.stringify({ [contract.input.name]: input }, null, 2),
+        "```",
+        "",
+        "Return one JSON value matching the output contract:",
+        "",
+        "```json",
+        JSON.stringify({ [contract.output.name]: contract.output.schema }, null, 2),
+        "```",
+        ...skillFiles.length ? [
+          "",
+          "## Skills",
+          "",
+          ...skillFiles.flatMap((file) => [
+            `### ${file}`,
+            "",
+            fs39.readFileSync(path36.join(skillRoot, file), "utf-8"),
+            ""
+          ])
+        ] : [],
+        ...toolFiles.length ? [
+          "",
+          "## Tools",
+          "",
+          "Inspect or run these capability-owned files when needed:",
+          ...toolFiles.map((file) => `- ${path36.join(toolRoot, file)}`)
+        ] : []
+      ].join("\n");
+    };
+  }
+});
+
 // src/companyIntent.ts
 function isCompanyIntentId(value) {
   return SLUG_RE2.test(value);
 }
-function normalizeCompanyIntent(path52, raw) {
+function normalizeCompanyIntent(path54, raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new Error(`${path52}: intent must be JSON object`);
+    throw new Error(`${path54}: intent must be JSON object`);
   }
   const input = raw;
   const id = stringField4(input.id);
-  if (!id || !isCompanyIntentId(id)) throw new Error(`${path52}: invalid intent id`);
+  if (!id || !isCompanyIntentId(id)) throw new Error(`${path54}: invalid intent id`);
   const createdAt = stringField4(input.createdAt) || nowIso();
   const updatedAt = stringField4(input.updatedAt) || createdAt;
   const description = stringField4(input.description);
@@ -15644,8 +15628,8 @@ var init_loadIssueStateComment = __esm({
 });
 
 // src/scripts/loadJobFromFile.ts
-import * as fs39 from "fs";
-import * as path36 from "path";
+import * as fs40 from "fs";
+import * as path37 from "path";
 function parseJobFile(raw, slug) {
   let stripped = raw;
   if (stripped.startsWith("---\n")) {
@@ -15684,10 +15668,10 @@ var init_loadJobFromFile = __esm({
       if (!slug) {
         throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
       }
-      const capability = resolveCapabilityFolder(slug, path36.resolve(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug, path37.resolve(ctx.cwd, jobsDir));
       if (!capability) {
         throw new Error(
-          `loadJobFromFile: capability folder not found or incomplete: ${path36.resolve(ctx.cwd, jobsDir, slug)}`
+          `loadJobFromFile: capability folder not found or incomplete: ${path37.resolve(ctx.cwd, jobsDir, slug)}`
         );
       }
       const { title, body, config } = capability;
@@ -15697,12 +15681,12 @@ var init_loadJobFromFile = __esm({
       let agentIdentity = "";
       if (agentSlug) {
         const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
-        if (!fs39.existsSync(agentPath)) {
+        if (!fs40.existsSync(agentPath)) {
           throw new Error(
             `loadJobFromFile: capability '${slug}' declares agent '${agentSlug}' but ${agentPath} does not exist`
           );
         }
-        const agentRaw = fs39.readFileSync(agentPath, "utf-8");
+        const agentRaw = fs40.readFileSync(agentPath, "utf-8");
         const parsed = parseJobFile(agentRaw, agentSlug);
         agentTitle = parsed.title;
         agentIdentity = parsed.body;
@@ -15782,13 +15766,13 @@ ${truncate2(issue2.body, FINDING_BODY_MAX_BYTES)}`;
 });
 
 // src/scripts/kodyVariables.ts
-import * as fs40 from "fs";
-import * as path37 from "path";
+import * as fs41 from "fs";
+import * as path38 from "path";
 function readKodyVariables(cwd) {
-  const full = path37.join(cwd, KODY_VARIABLES_REL_PATH);
+  const full = path38.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
-    raw = fs40.readFileSync(full, "utf-8");
+    raw = fs41.readFileSync(full, "utf-8");
   } catch {
     return {};
   }
@@ -15813,9 +15797,9 @@ var init_kodyVariables = __esm({
 });
 
 // src/backendVault.ts
-import { createDecipheriv, createHash as createHash6 } from "crypto";
+import { createDecipheriv, createHash as createHash5 } from "crypto";
 function cacheKey(owner, repo, masterKey) {
-  const keyHash = createHash6("sha256").update(masterKey).digest("hex").slice(0, 16);
+  const keyHash = createHash5("sha256").update(masterKey).digest("hex").slice(0, 16);
   return `${owner}/${repo}:${keyHash}`.toLowerCase();
 }
 function decryptVault(payload, masterKey) {
@@ -15964,8 +15948,8 @@ var init_runtimeSecrets = __esm({
 });
 
 // src/scripts/loadQaContext.ts
-import * as fs41 from "fs";
-import * as path38 from "path";
+import * as fs42 from "fs";
+import * as path39 from "path";
 function parseSlugList(value) {
   const inner = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
   return inner.split(",").map(
@@ -15994,18 +15978,18 @@ function readProfileAgents(raw) {
   return { agent: agent ?? legacy ?? ["kody"], body };
 }
 function readProfile(cwd) {
-  const dir = path38.join(cwd, CONTEXT_DIR_REL_PATH);
-  if (!fs41.existsSync(dir)) return "";
+  const dir = path39.join(cwd, CONTEXT_DIR_REL_PATH);
+  if (!fs42.existsSync(dir)) return "";
   let entries;
   try {
-    entries = fs41.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    entries = fs42.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs41.readFileSync(path38.join(dir, file), "utf-8");
+      const raw = fs42.readFileSync(path39.join(dir, file), "utf-8");
       const { agent, body } = readProfileAgents(raw);
       if (!agent.includes(QA_AGENT) && !agent.includes(ALL_AGENTS)) continue;
       blocks.push(`## ${file}
@@ -16054,8 +16038,8 @@ var init_loadQaContext = __esm({
 });
 
 // src/taskContext.ts
-import * as fs42 from "fs";
-import * as path39 from "path";
+import * as fs43 from "fs";
+import * as path40 from "path";
 function buildTaskContext(args) {
   return {
     schemaVersion: TASK_CONTEXT_SCHEMA_VERSION,
@@ -16071,9 +16055,9 @@ function buildTaskContext(args) {
 function persistTaskContext(cwd, ctx) {
   try {
     const dir = runtimeStatePath(cwd, "agent-runs", ctx.runId);
-    fs42.mkdirSync(dir, { recursive: true });
-    const file = path39.join(dir, "task-context.json");
-    fs42.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    fs43.mkdirSync(dir, { recursive: true });
+    const file = path40.join(dir, "task-context.json");
+    fs43.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -16464,7 +16448,7 @@ var init_notifyTerminal = __esm({
 });
 
 // src/scripts/openAgencyModelReviewPr.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 function parseAgencyModelProposal(raw) {
   const text2 = raw.trim();
   const jsonText = (text2.match(/^```(?:json)?\s*\n([\s\S]*?)\n```$/i)?.[1] ?? text2).trim();
@@ -16500,23 +16484,23 @@ function parseAgencyModelProposal(raw) {
 function normalizeBundleFiles(bundle) {
   const seen = /* @__PURE__ */ new Set();
   return bundle.files.map((file, index) => {
-    const path52 = file.path.replace(/^\/+/, "");
-    const parts = path52.split("/");
-    if (!path52 || file.path.startsWith("/") || file.path.includes("\\") || parts.some((part) => !part || part === "." || part === "..")) {
+    const path54 = file.path.replace(/^\/+/, "");
+    const parts = path54.split("/");
+    if (!path54 || 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(
-      path52
+      path54
     )) {
       throw new Error(`openAgencyModelReviewPr: files[${index}].path is not a supported definition path`);
     }
-    if (seen.has(path52)) throw new Error(`openAgencyModelReviewPr: duplicate generated file path: ${path52}`);
-    seen.add(path52);
-    return { path: path52, content: file.content.replace(/\r\n?/g, "\n") };
+    if (seen.has(path54)) throw new Error(`openAgencyModelReviewPr: duplicate generated file path: ${path54}`);
+    seen.add(path54);
+    return { path: path54, content: file.content.replace(/\r\n?/g, "\n") };
   });
 }
 function buildProposalId(issueNumber, bundle, sourceLabel) {
-  const digest = createHash7("sha256").update(JSON.stringify({ issueNumber, sourceLabel, title: bundle.title, files: normalizeBundleFiles(bundle) })).digest("hex").slice(0, 16);
+  const digest = createHash6("sha256").update(JSON.stringify({ issueNumber, sourceLabel, title: bundle.title, files: normalizeBundleFiles(bundle) })).digest("hex").slice(0, 16);
   return `issue-${issueNumber}-${digest}`;
 }
 function isDryRun(ctx) {
@@ -17456,9 +17440,9 @@ var init_postResearchComment = __esm({
 });
 
 // src/scripts/prepareBrowserAuth.ts
-import * as fs43 from "fs";
+import * as fs44 from "fs";
 import * as os6 from "os";
-import * as path40 from "path";
+import * as path41 from "path";
 function appendAuthMessage(ctx, message) {
   const current = typeof ctx.data.qaAuthBlock === "string" ? ctx.data.qaAuthBlock.trim() : "";
   ctx.data.qaAuthBlock = current ? `${current}
@@ -17497,9 +17481,9 @@ async function githubJson(url, token) {
   return await response.json();
 }
 function writeKodyStorageState(input) {
-  const directory = fs43.mkdtempSync(path40.join(os6.tmpdir(), "kody-browser-auth-"));
-  fs43.chmodSync(directory, 448);
-  const file = path40.join(directory, "storage-state.json");
+  const directory = fs44.mkdtempSync(path41.join(os6.tmpdir(), "kody-browser-auth-"));
+  fs44.chmodSync(directory, 448);
+  const file = path41.join(directory, "storage-state.json");
   const now = Date.now();
   const repoEntry = {
     repoUrl: input.repoUrl,
@@ -17529,7 +17513,7 @@ function writeKodyStorageState(input) {
       }
     ]
   };
-  fs43.writeFileSync(file, JSON.stringify(storageState), { mode: 384 });
+  fs44.writeFileSync(file, JSON.stringify(storageState), { mode: 384 });
   return { directory, file };
 }
 function configurePlaywright(profile, storageStatePath) {
@@ -17611,7 +17595,7 @@ async function prepareMethod(ctx, profile, method) {
     configurePlaywright(profile, state.file);
     const authDirectory = state.directory;
     registerRuntimeCleanup(ctx, () => {
-      fs43.rmSync(authDirectory, { recursive: true, force: true });
+      fs44.rmSync(authDirectory, { recursive: true, force: true });
     });
     appendAuthMessage(
       ctx,
@@ -17619,7 +17603,7 @@ async function prepareMethod(ctx, profile, method) {
     );
     return true;
   } catch (error) {
-    if (state) fs43.rmSync(state.directory, { recursive: true, force: true });
+    if (state) fs44.rmSync(state.directory, { recursive: true, force: true });
     const reason = error instanceof Error ? error.message : String(error);
     appendAuthMessage(
       ctx,
@@ -17732,9 +17716,9 @@ function latestResult(raw, agentResult) {
 function recordField4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function resolveDotted(root, path52) {
-  if (!path52) return void 0;
-  return path52.split(".").reduce((value, key) => recordField4(value)?.[key], root);
+function resolveDotted(root, path54) {
+  if (!path54) return void 0;
+  return path54.split(".").reduce((value, key) => recordField4(value)?.[key], root);
 }
 function stringValue4(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
@@ -18588,9 +18572,9 @@ var init_runFlow = __esm({
 });
 
 // src/scripts/previewBuildHelpers.ts
-import { createDecipheriv as createDecipheriv2, createHash as createHash8, hkdfSync as hkdfSync2 } from "crypto";
+import { createDecipheriv as createDecipheriv2, createHash as createHash7, hkdfSync as hkdfSync2 } from "crypto";
 function shortHash(s) {
-  return createHash8("sha256").update(s).digest("hex").slice(0, 6);
+  return createHash7("sha256").update(s).digest("hex").slice(0, 6);
 }
 function previewAppName(repo, pr) {
   const [owner, name] = repo.split("/");
@@ -18623,7 +18607,7 @@ function formatPreviewComment(args) {
   ].join("\n");
 }
 function defaultImageTag(repo, ref) {
-  return createHash8("sha256").update(`${repo}@${ref}`).digest("hex").slice(0, 12);
+  return createHash7("sha256").update(`${repo}@${ref}`).digest("hex").slice(0, 12);
 }
 var init_previewBuildHelpers = __esm({
   "src/scripts/previewBuildHelpers.ts"() {
@@ -18718,12 +18702,12 @@ fi
 
 // src/scripts/runPreviewBuild.ts
 import { copyFile, writeFile } from "fs/promises";
-import * as path41 from "path";
+import * as path42 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function bundledDockerfilePath(mode) {
-  const here = path41.dirname(fileURLToPath2(import.meta.url));
+  const here = path42.dirname(fileURLToPath2(import.meta.url));
   const file = mode === "dev" ? "default-Dockerfile.preview.dev" : "default-Dockerfile.preview.prod";
-  return path41.join(here, "preview-build-templates", file);
+  return path42.join(here, "preview-build-templates", file);
 }
 function required(name) {
   const v = (process.env[name] ?? "").trim();
@@ -18958,10 +18942,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(path41.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
+          await writeFile(path42.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
 `, "utf8");
         }
-        const consumerDockerfile = path41.join(ctx.cwd, "Dockerfile.preview");
+        const consumerDockerfile = path42.join(ctx.cwd, "Dockerfile.preview");
         const { stat } = await import("fs/promises");
         let hasConsumerDockerfile = false;
         try {
@@ -19145,8 +19129,8 @@ var init_tickShellRunner = __esm({
 });
 
 // src/scripts/runScheduledImplementationTick.ts
-import * as fs44 from "fs";
-import * as path42 from "path";
+import * as fs45 from "fs";
+import * as path43 from "path";
 var runScheduledImplementationTick;
 var init_runScheduledImplementationTick = __esm({
   "src/scripts/runScheduledImplementationTick.ts"() {
@@ -19167,14 +19151,14 @@ 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, path42.resolve(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug, path43.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 = path42.join(profile.dir, shell);
-      if (!fs44.existsSync(shellPath)) {
+      const shellPath = path43.join(profile.dir, shell);
+      if (!fs45.existsSync(shellPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledImplementationTick: shell not found: ${shell} (looked in ${profile.dir})`;
         return;
@@ -19205,8 +19189,8 @@ var init_runScheduledImplementationTick = __esm({
 });
 
 // src/scripts/runTickScript.ts
-import * as fs45 from "fs";
-import * as path43 from "path";
+import * as fs46 from "fs";
+import * as path44 from "path";
 var runTickScript;
 var init_runTickScript = __esm({
   "src/scripts/runTickScript.ts"() {
@@ -19226,10 +19210,10 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
         return;
       }
-      const capability = readCapabilityFolder(path43.resolve(ctx.cwd, jobsDir), slug);
+      const capability = readCapabilityFolder(path44.resolve(ctx.cwd, jobsDir), slug);
       if (!capability) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path43.resolve(ctx.cwd, jobsDir, slug)}`;
+        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path44.resolve(ctx.cwd, jobsDir, slug)}`;
         return;
       }
       const tickScript = capability.config.tickScript;
@@ -19238,8 +19222,8 @@ 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 = path43.isAbsolute(tickScript) ? tickScript : path43.join(ctx.cwd, tickScript);
-      if (!fs45.existsSync(scriptPath)) {
+      const scriptPath = path44.isAbsolute(tickScript) ? tickScript : path44.join(ctx.cwd, tickScript);
+      if (!fs46.existsSync(scriptPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
         return;
@@ -19521,7 +19505,7 @@ var init_syncFlow = __esm({
 });
 
 // src/scripts/validateAgencyModelProposal.ts
-import * as path44 from "path";
+import * as path45 from "path";
 function validateModelBundle(bundle, expectedKind, options = {}) {
   const failures = [];
   validateOneModel(bundle.model, bundle.files, "model", true, failures, expectedKind, options);
@@ -19847,7 +19831,7 @@ var init_validateAgencyModelProposal = __esm({
       const bundle = parseAgencyModelProposal(raw);
       const expectedKind = readExpectedModelKind(args);
       const failures = validateModelBundle(bundle, expectedKind, {
-        capabilityRoot: path44.join(ctx.cwd, ".kody", "capabilities")
+        capabilityRoot: path45.join(ctx.cwd, ".kody", "capabilities")
       });
       if (failures.length > 0) {
         throw new Error(`validateAgencyModelProposal: ${failures.join("; ")}`);
@@ -20398,7 +20382,7 @@ var init_warmupMcp = __esm({
 });
 
 // src/scripts/writeAgentRunSummary.ts
-import * as fs46 from "fs";
+import * as fs47 from "fs";
 var writeAgentRunSummary;
 var init_writeAgentRunSummary = __esm({
   "src/scripts/writeAgentRunSummary.ts"() {
@@ -20424,7 +20408,7 @@ var init_writeAgentRunSummary = __esm({
       if (reason) lines.push(`- **Reason:** ${reason}`);
       lines.push("");
       try {
-        fs46.appendFileSync(summaryPath, `${lines.join("\n")}
+        fs47.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
       } catch {
       }
@@ -20572,6 +20556,7 @@ var init_scripts = __esm({
     init_initFlow();
     init_loadAgentAdhoc();
     init_loadCapabilityState();
+    init_loadSimpleCapability();
     init_loadCompanyIntents();
     init_loadCompanyPortfolio();
     init_loadConventions();
@@ -20656,6 +20641,7 @@ var init_scripts = __esm({
       loadIssueStateComment,
       loadJobFromFile,
       loadCapabilityState,
+      loadSimpleCapability,
       loadCompanyIntents,
       loadCompanyPortfolio,
       loadAgentAdhoc,
@@ -20752,17 +20738,17 @@ var init_scripts = __esm({
 });
 
 // src/stateWorkspace.ts
-import * as fs47 from "fs";
-import * as path45 from "path";
+import * as fs48 from "fs";
+import * as path46 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 = path45.join(cwd, RUNTIME_ROOT, relativePath);
-  fs47.mkdirSync(path45.dirname(target), { recursive: true });
-  fs47.writeFileSync(target, content, "utf8");
+  const target = path46.join(cwd, RUNTIME_ROOT, relativePath);
+  fs48.mkdirSync(path46.dirname(target), { recursive: true });
+  fs48.writeFileSync(target, content, "utf8");
 }
 function record(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -20827,11 +20813,11 @@ async function hydrateStateWorkspace(config, cwd, backendOverride) {
       throw new Error("Kody backend access is required for runtime workspace documents");
     return;
   }
-  const key = `${path45.resolve(cwd)}|${tenant}`;
+  const key = `${path46.resolve(cwd)}|${tenant}`;
   if (hydratedWorkspaces.has(key)) return;
   const backend = backendOverride ?? createStateBackendFromEnv();
-  const root = path45.join(cwd, RUNTIME_ROOT);
-  fs47.rmSync(root, { recursive: true, force: true });
+  const root = path46.join(cwd, RUNTIME_ROOT);
+  fs48.rmSync(root, { recursive: true, force: true });
   await Promise.all([
     hydratePrefix(backend, tenant, cwd, "context:"),
     hydratePrefix(backend, tenant, cwd, "memory:"),
@@ -20847,7 +20833,7 @@ var init_stateWorkspace = __esm({
   "src/stateWorkspace.ts"() {
     "use strict";
     init_state_backend();
-    RUNTIME_ROOT = path45.join(".kody-engine", "runtime");
+    RUNTIME_ROOT = path46.join(".kody-engine", "runtime");
     hydratedWorkspaces = /* @__PURE__ */ new Set();
   }
 });
@@ -20918,9 +20904,9 @@ var init_tools = __esm({
 
 // src/executor.ts
 import { spawn as spawn8 } from "child_process";
-import * as fs48 from "fs";
+import * as fs49 from "fs";
 import * as os7 from "os";
-import * as path46 from "path";
+import * as path47 from "path";
 function isMutatingPostflight(scriptName) {
   return MUTATING_POSTFLIGHTS.has(scriptName ?? "");
 }
@@ -21161,7 +21147,7 @@ async function runImplementation(profileName, input) {
   const jobWhyBlock = typeof ctx.data.jobWhy === "string" ? operatorRequestBlock(ctx.data.jobWhy) : null;
   const jobRefBlock = jobReferenceBlock(profileName, profile, ctx.data);
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path46.isAbsolute(p) ? p : path46.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path47.isAbsolute(p) ? p : path47.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
@@ -21623,17 +21609,17 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function resolveProfilePath(profileName, cwd = process.cwd()) {
   const found = resolveImplementation(profileName, getRuntimeProfileRootsForCwd(cwd));
   if (found) return found;
-  const here = path46.dirname(new URL(import.meta.url).pathname);
+  const here = path47.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path46.join(here, "implementations", profileName, "profile.json"),
+    path47.join(here, "implementations", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path46.join(here, "..", "implementations", profileName, "profile.json"),
+    path47.join(here, "..", "implementations", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/implementations)
-    path46.join(here, "..", "src", "implementations", profileName, "profile.json")
+    path47.join(here, "..", "src", "implementations", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs48.existsSync(c)) return c;
+    if (fs49.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -21748,15 +21734,15 @@ function resolveShellTimeoutMs(entry) {
 }
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path46.join(profile.dir, shellName);
-  if (!fs48.existsSync(shellPath)) {
+  const shellPath = path47.join(profile.dir, shellName);
+  if (!fs49.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
     return;
   }
   const positional = entry.with ? Object.values(entry.with).map((v) => String(v)) : [];
-  const outputFile = path46.join(
+  const outputFile = path47.join(
     os7.tmpdir(),
     `kody-shell-output-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
   );
@@ -21828,9 +21814,9 @@ async function runShellEntry(entry, ctx, profile) {
   }
   let sideChannelText = "";
   try {
-    if (fs48.existsSync(outputFile)) {
-      sideChannelText = fs48.readFileSync(outputFile, "utf-8");
-      fs48.rmSync(outputFile, { force: true });
+    if (fs49.existsSync(outputFile)) {
+      sideChannelText = fs49.readFileSync(outputFile, "utf-8");
+      fs49.rmSync(outputFile, { force: true });
     }
   } catch {
   }
@@ -22002,7 +21988,7 @@ __export(job_exports, {
   stableJobKey: () => stableJobKey,
   validateJob: () => validateJob
 });
-import * as path47 from "path";
+import * as path48 from "path";
 function newJobId(flavor) {
   localJobSeq += 1;
   const runId = process.env.GITHUB_RUN_ID;
@@ -22091,6 +22077,7 @@ async function runJob(job, base) {
     const persistedState = valid.workflowRunId && workflowIdentity && base.config ? await readWorkflowRunState(base.config, base.cwd, workflowIdentity, valid.workflowRunId) : null;
     const workflowJob = {
       ...workflowContext && !valid.why ? { ...valid, why: workflowContext.body } : valid,
+      ...workflowCapability.config.agent ? { agent: workflowCapability.config.agent } : {},
       ...valid.workflowState ?? persistedState ? { workflowState: valid.workflowState ?? persistedState ?? void 0 } : {}
     };
     const checkpoint = valid.workflowRunId && workflowIdentity && base.config ? (state) => writeWorkflowRunState(base.config, base.cwd, workflowIdentity, valid.workflowRunId, state) : void 0;
@@ -22517,11 +22504,11 @@ function selectWorkflowTransition(step, data, counts) {
 }
 function workflowResultConditionPaths(transitions) {
   return transitions.flatMap(
-    (transition) => Object.keys(transition.when ?? {}).filter((path52) => path52.startsWith("result."))
+    (transition) => Object.keys(transition.when ?? {}).filter((path54) => path54.startsWith("result."))
   );
 }
 function conditionMatches(condition, context) {
-  return Object.entries(condition).every(([path52, expected]) => valueMatches(resolveDottedPath2(context, path52), expected));
+  return Object.entries(condition).every(([path54, expected]) => valueMatches(resolveDottedPath2(context, path54), expected));
 }
 function withWorkflowBoundaryEval(capability, result) {
   const capabilityKind = capability.config.capabilityKind;
@@ -22573,7 +22560,7 @@ function workflowStepToJob(step, parent, chainData) {
     capability: step.capability,
     ...step.implementation ? { implementation: step.implementation } : {},
     ...composeStepWhy(parent.why, step) ? { why: composeStepWhy(parent.why, step) } : {},
-    ...step.agent ?? parent.agent ? { agent: step.agent ?? parent.agent } : {},
+    ...parent.agent ? { agent: parent.agent } : {},
     ...parent.schedule ? { schedule: parent.schedule } : {},
     ...typeof target === "number" ? { target } : {},
     cliArgs,
@@ -22679,7 +22666,7 @@ function loadCapabilityContext(slug, cwd) {
   return resolveCapabilityFolder(slug, hydratedCapabilitiesRoot(cwd));
 }
 function hydratedCapabilitiesRoot(cwd) {
-  return path47.join(cwd, ".kody-engine", "definitions", "capabilities");
+  return path48.join(cwd, ".kody-engine", "definitions", "capabilities");
 }
 function loadWorkflowContext(slug, base) {
   if (!slug || !isWorkflowDefinitionId(slug)) return null;
@@ -22844,7 +22831,7 @@ function translateOpenAISseToBrain(opts) {
 
 // src/servers/brain-serve.ts
 import { createServer as createServer2 } from "http";
-import * as path50 from "path";
+import * as path52 from "path";
 
 // src/chat/loop.ts
 init_agent();
@@ -23886,7 +23873,7 @@ init_config();
 
 // src/definition-hydration.ts
 init_state_backend();
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import * as fs16 from "fs";
 import * as path17 from "path";
 var SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,127}$/;
@@ -23907,7 +23894,7 @@ function normalizeDefinitionBundle(bundle) {
   return { schemaVersion: 1, files };
 }
 function definitionVersion(bundle) {
-  return `sha256:${createHash3("sha256").update(JSON.stringify(normalizeDefinitionBundle(bundle))).digest("hex")}`;
+  return `sha256:${createHash2("sha256").update(JSON.stringify(normalizeDefinitionBundle(bundle))).digest("hex")}`;
 }
 function verifyDefinition(definition) {
   if (!SLUG_RE.test(definition.slug)) throw new Error(`invalid definition slug: ${definition.slug}`);
@@ -24018,8 +24005,8 @@ async function hydrateDefinitionsFromEnv(cwd = process.cwd(), env = process.env)
 
 // src/kody-cli.ts
 import { execFileSync as execFileSync24 } from "child_process";
-import * as fs49 from "fs";
-import * as path48 from "path";
+import * as fs51 from "fs";
+import * as path50 from "path";
 
 // src/app-auth.ts
 import { createSign } from "crypto";
@@ -24655,6 +24642,74 @@ function readRunRequestFromEnv(env = process.env) {
 
 // src/kody-cli.ts
 init_runtimePaths();
+
+// src/loopDefinitions.ts
+init_definition_paths();
+import * as fs50 from "fs";
+import * as path49 from "path";
+var ID = /^[a-z0-9][a-z0-9_-]{0,79}$/;
+function normalizeLoopDefinition(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  if (Object.keys(raw).some((key) => !["id", "trigger", "target", "input", "enabled"].includes(key))) return null;
+  if (typeof raw.id !== "string" || !ID.test(raw.id)) return null;
+  if (typeof raw.enabled !== "boolean") return null;
+  if (!isObject(raw.input) || !isObject(raw.trigger) || !isObject(raw.target)) return null;
+  const targetKind = raw.target.kind;
+  const targetId = raw.target.id;
+  if (targetKind !== "workflow" && targetKind !== "capability" || typeof targetId !== "string" || !ID.test(targetId)) {
+    return null;
+  }
+  const trigger = normalizeTrigger(raw.trigger);
+  if (!trigger) return null;
+  return {
+    id: raw.id,
+    trigger,
+    target: { kind: targetKind, id: targetId },
+    input: raw.input,
+    enabled: raw.enabled
+  };
+}
+function readLoopDefinition(cwd, id) {
+  if (!ID.test(id)) return null;
+  const roots = [
+    path49.join(cwd, ".kody-engine", "runtime"),
+    definitionsRoot(cwd)
+  ];
+  for (const root of roots) {
+    const filePath = path49.join(root, "loops", id, "loop.json");
+    if (!fs50.existsSync(filePath)) continue;
+    try {
+      const loop = normalizeLoopDefinition(JSON.parse(fs50.readFileSync(filePath, "utf8")));
+      if (loop?.id === id) return loop;
+    } catch {
+    }
+  }
+  return null;
+}
+function normalizeTrigger(raw) {
+  if (raw.type === "manual" && Object.keys(raw).length === 1) return { type: "manual" };
+  if (raw.type === "schedule" && typeof raw.every === "string" && /^\d+[mhd]$/.test(raw.every)) {
+    if (raw.at === void 0 && Object.keys(raw).every((key) => key === "type" || key === "every")) {
+      return { type: "schedule", every: raw.every };
+    }
+    if (isObject(raw.at) && typeof raw.at.time === "string" && typeof raw.at.timezone === "string" && Object.keys(raw.at).every((key) => key === "time" || key === "timezone") && Object.keys(raw).every((key) => key === "type" || key === "every" || key === "at")) {
+      return { type: "schedule", every: raw.every, at: { time: raw.at.time, timezone: raw.at.timezone } };
+    }
+  }
+  if ((raw.type === "event" || raw.type === "webhook") && typeof raw.event === "string" && raw.event.trim() && Object.keys(raw).every((key) => key === "type" || key === "event")) {
+    return { type: raw.type, event: raw.event.trim() };
+  }
+  if (raw.type === "condition" && typeof raw.expression === "string" && raw.expression.trim() && Object.keys(raw).every((key) => key === "type" || key === "expression")) {
+    return { type: "condition", expression: raw.expression.trim() };
+  }
+  return null;
+}
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/kody-cli.ts
 init_stateWorkspace();
 init_workflowDefinitions();
 var FAILED_DISPATCH_LABEL = {
@@ -24832,9 +24887,9 @@ async function resolveAuthToken(env = process.env) {
   return void 0;
 }
 function detectPackageManager2(cwd) {
-  if (fs49.existsSync(path48.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs49.existsSync(path48.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs49.existsSync(path48.join(cwd, "bun.lockb"))) return "bun";
+  if (fs51.existsSync(path50.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs51.existsSync(path50.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs51.existsSync(path50.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shouldChainScheduledWatch(match) {
@@ -24927,8 +24982,8 @@ function postFailureTail(issueNumber, cwd, reason) {
   const logPath = lastRunLogPath(cwd);
   let tail = "";
   try {
-    if (fs49.existsSync(logPath)) {
-      const content = fs49.readFileSync(logPath, "utf-8");
+    if (fs51.existsSync(logPath)) {
+      const content = fs51.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -24957,7 +25012,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path48.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path50.resolve(args.cwd) : process.cwd();
   try {
     const n = unpackAllSecrets();
     if (n > 0) process.stdout.write(`\u2192 kody: unpacked ${n} secret(s) from ALL_SECRETS
@@ -25016,9 +25071,9 @@ async function runCi(argv) {
       forceRunCliArgs = { goal: envForceMessage };
     }
   }
-  if (!args.issueNumber && !autoFallback && !forceRunAction && !runRequestFanOut && eventName === "workflow_dispatch" && dispatchEventPath && fs49.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && !forceRunAction && !runRequestFanOut && eventName === "workflow_dispatch" && dispatchEventPath && fs51.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs49.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs51.readFileSync(dispatchEventPath, "utf-8"));
       const inputs = objectValue2(evt.inputs);
       const issueInput = parseInt(String(inputs?.issue_number ?? ""), 10);
       const sessionInput = String(inputs?.sessionId ?? "");
@@ -25068,7 +25123,9 @@ async function runCi(argv) {
       workflow: forceRunAction,
       cliArgs: {}
     };
-    const scheduledWatchRoute = manualGoalManager || capabilityRoute || workflowRoute ? void 0 : dispatchScheduledWatches({ force: true, cwd }).find(
+    const loop = manualGoalManager || capabilityRoute || workflowRoute ? null : readLoopDefinition(cwd, forceRunAction);
+    const loopRoute = loop ? loop.target.kind === "workflow" ? { workflow: loop.target.id, cliArgs: loop.input } : { capability: loop.target.id, action: loop.target.id, cliArgs: loop.input } : void 0;
+    const scheduledWatchRoute = manualGoalManager || capabilityRoute || workflowRoute || loopRoute ? void 0 : dispatchScheduledWatches({ force: true, cwd }).find(
       (match) => match.action === forceRunAction || match.capability === forceRunAction || match.implementation === forceRunAction
     );
     const route = manualGoalManager ? {
@@ -25076,7 +25133,7 @@ async function runCi(argv) {
       capability: "goal-manager",
       implementation: "goal-manager",
       cliArgs: forceRunCliArgs
-    } : capabilityRoute ?? workflowRoute ?? scheduledWatchRoute;
+    } : capabilityRoute ?? workflowRoute ?? loopRoute ?? scheduledWatchRoute;
     if (!route) {
       const root = capabilitiesRoot(cwd);
       const available = listCapabilityActions(root).map((item) => item.action);
@@ -25425,8 +25482,8 @@ init_repoWorkspace();
 
 // src/scripts/brainTurnLog.ts
 init_runtimePaths();
-import * as fs50 from "fs";
-import * as path49 from "path";
+import * as fs52 from "fs";
+import * as path51 from "path";
 import posixPath4 from "path/posix";
 var live = /* @__PURE__ */ new Map();
 function brainEventsFilePath(dir, chatId) {
@@ -25434,8 +25491,8 @@ function brainEventsFilePath(dir, chatId) {
 }
 function lastPersistedSeq(dir, chatId) {
   const p = brainEventsFilePath(dir, chatId);
-  if (!fs50.existsSync(p)) return 0;
-  const lines = fs50.readFileSync(p, "utf-8").split("\n").filter(Boolean);
+  if (!fs52.existsSync(p)) return 0;
+  const lines = fs52.readFileSync(p, "utf-8").split("\n").filter(Boolean);
   if (lines.length === 0) return 0;
   try {
     return JSON.parse(lines[lines.length - 1]).seq || 0;
@@ -25445,9 +25502,9 @@ function lastPersistedSeq(dir, chatId) {
 }
 function readSince(dir, chatId, since) {
   const p = brainEventsFilePath(dir, chatId);
-  if (!fs50.existsSync(p)) return [];
+  if (!fs52.existsSync(p)) return [];
   const out = [];
-  for (const line of fs50.readFileSync(p, "utf-8").split("\n")) {
+  for (const line of fs52.readFileSync(p, "utf-8").split("\n")) {
     if (!line) continue;
     try {
       const rec = JSON.parse(line);
@@ -25473,12 +25530,12 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = brainEventsFilePath(dir, chatId);
-  fs50.mkdirSync(path49.dirname(p), { recursive: true });
+  fs52.mkdirSync(path51.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
     try {
-      fs50.appendFileSync(p, `${JSON.stringify(rec)}
+      fs52.appendFileSync(p, `${JSON.stringify(rec)}
 `);
     } catch (err) {
       process.stderr.write(
@@ -25517,7 +25574,7 @@ function endTurnIfUnterminated(dir, chatId, errMessage) {
     event: { type: "error", error: errMessage || "turn ended unexpectedly", chatId }
   };
   try {
-    fs50.appendFileSync(brainEventsFilePath(dir, chatId), `${JSON.stringify(rec)}
+    fs52.appendFileSync(brainEventsFilePath(dir, chatId), `${JSON.stringify(rec)}
 `);
   } catch {
   }
@@ -25910,7 +25967,7 @@ function buildServer(opts) {
   const runTurn = opts.runTurn ?? runChatTurn;
   const createStore = opts.createStore ?? createSessionStore;
   const cloneRepo = opts.cloneRepo ?? defaultCloneRepo;
-  const reposRoot = opts.reposRoot ?? path50.join(path50.dirname(path50.resolve(opts.cwd)), "repos");
+  const reposRoot = opts.reposRoot ?? path52.join(path52.dirname(path52.resolve(opts.cwd)), "repos");
   return createServer2(async (req, res) => {
     if (!req.method || !req.url) {
       sendJson(res, 400, { error: "bad request" });
@@ -26514,7 +26571,7 @@ async function loadConfigSafe() {
 }
 
 // src/chat-cli.ts
-import * as path51 from "path";
+import * as path53 from "path";
 
 // src/chat/inbox.ts
 import { execFileSync as execFileSync25 } from "child_process";
@@ -26795,7 +26852,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path51.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path53.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const runRequest = readRunRequestFromEnv();
   if (runRequest && "request" in runRequest) {
@@ -26985,8 +27042,8 @@ var FlyClient = class {
   get fetch() {
     return this.opts.fetchImpl ?? fetch;
   }
-  async call(path52, init = {}) {
-    const res = await this.fetch(`${FLY_API_BASE}${path52}`, {
+  async call(path54, init = {}) {
+    const res = await this.fetch(`${FLY_API_BASE}${path54}`, {
       method: init.method ?? "GET",
       headers: {
         Authorization: `Bearer ${this.opts.token}`,
@@ -26997,7 +27054,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 ${path52}: ${text2.slice(0, 200) || res.statusText}`);
+      throw new Error(`Fly API ${res.status} on ${path54}: ${text2.slice(0, 200) || res.statusText}`);
     }
     if (res.status === 204) return null;
     const raw = await res.text();
@@ -27750,7 +27807,7 @@ async function poolServe() {
 
 // src/servers/runner-serve.ts
 import { spawn as spawn9 } from "child_process";
-import * as fs51 from "fs";
+import * as fs53 from "fs";
 import { createServer as createServer6 } from "http";
 var DEFAULT_PORT2 = 8080;
 var DEFAULT_WORKDIR = "/workspace/repo";
@@ -27885,8 +27942,8 @@ async function defaultRunJob(job) {
   const workdir = process.env.RUNNER_WORKDIR ?? DEFAULT_WORKDIR;
   const branch = job.ref ?? "main";
   const authUrl = `https://x-access-token:${job.githubToken}@github.com/${job.repo}.git`;
-  fs51.rmSync(workdir, { recursive: true, force: true });
-  fs51.mkdirSync(workdir, { recursive: true });
+  fs53.rmSync(workdir, { recursive: true, force: true });
+  fs53.mkdirSync(workdir, { recursive: true });
   const allSecrets = typeof job.allSecrets === "string" ? job.allSecrets : JSON.stringify(job.allSecrets ?? {});
   const target = job.runRequest.target;
   const interactive = target.type === "chat";