@kody-ade/kody-engine 0.4.350 → 0.4.351

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.350",
+      version: "0.4.351",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -4551,7 +4551,13 @@ function loadProfile(profilePath) {
   const preNames = new Set(profile.scripts.preflight.map((e) => e.script).filter(Boolean));
   const postNames = profile.scripts.postflight.map((e) => e.script).filter(Boolean);
   const needsState = postNames.includes("writeJobStateFile") || postNames.includes("parseJobStateFromAgentResult");
-  const STATE_LOADERS = ["loadCapabilityState", "loadJobFromFile", "runTickScript", "runScheduledImplementationTick"];
+  const STATE_LOADERS = [
+    "loadCapabilityState",
+    "loadJobFromFile",
+    "runTickScript",
+    "runScheduledImplementationTick",
+    "runScheduledExecutableTick"
+  ];
   if (needsState && !STATE_LOADERS.some((s) => preNames.has(s))) {
     throw new ProfileError(
       profilePath,
@@ -5769,8 +5775,10 @@ async function runContainerLoop(profile, ctx, input) {
     const priorAction = priorState.implementations?.[child.implementation]?.lastAction;
     let actionType2;
     if (priorAction && /_COMPLETED$/i.test(priorAction.type)) {
-      process.stderr.write(`[kody container] skipping ${child.implementation}: already completed (${priorAction.type})
-`);
+      process.stderr.write(
+        `[kody container] skipping ${child.implementation}: already completed (${priorAction.type})
+`
+      );
       actionType2 = priorAction.type;
     } else {
       let cliArgs;
@@ -7482,6 +7490,7 @@ function managedGoalFromState(state) {
     destination: { outcome: destination.outcome, evidence },
     capabilities,
     route,
+    ...extra.runWithoutApproval === true ? { runWithoutApproval: true } : {},
     workflowRef: asWorkflowRef(extra.workflowRef),
     schedule: typeof extra.schedule === "string" ? extra.schedule : void 0,
     preferredRunTime: asPreferredRunTime(extra.preferredRunTime),
@@ -7503,6 +7512,7 @@ function writeManagedGoalToState(state, goal) {
       destination: goal.destination,
       capabilities: goal.capabilities,
       route: goal.route,
+      ...goal.runWithoutApproval === true ? { runWithoutApproval: true } : {},
       workflowRef: goal.workflowRef,
       stage: goal.stage,
       facts: goal.facts,
@@ -8078,15 +8088,7 @@ function serializeTodoGoalState(goalId, state, previousRaw) {
   const routeByEvidence = new Map(route.map((step) => [stringField3(step.evidence), step]));
   const previousItems = new Map(parseItemsFromAnyRaw(previousRaw ?? "").map((item) => [item.id, item]));
   const items = evidence.length > 0 ? evidence.map(
-    (key) => itemFromEvidence(
-      key,
-      routeByEvidence.get(key),
-      facts,
-      evidenceState,
-      createdAt,
-      now,
-      previousItems.get(key)
-    )
+    (key) => itemFromEvidence(key, routeByEvidence.get(key), facts, evidenceState, createdAt, now, previousItems.get(key))
   ) : stringArray(raw.capabilities).map(
     (capability) => itemFromCapability(capability, createdAt, previousItems.get(capability))
   );
@@ -8612,6 +8614,102 @@ var init_typeDefinitions = __esm({
   }
 });
 
+// src/workflowDefinitions.ts
+import * as fs28 from "fs";
+import * as path26 from "path";
+function isWorkflowDefinitionId(value) {
+  return WORKFLOW_ID_PATTERN.test(value);
+}
+function workflowDefinitionPath(id) {
+  if (!isWorkflowDefinitionId(id)) {
+    throw new Error(`Invalid workflow id "${id}"`);
+  }
+  return `workflows/${id}/workflow.json`;
+}
+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 workflow = parseCapabilityWorkflow({ steps: raw.steps });
+  const steps = workflow?.steps;
+  const capabilities = steps ? steps.map((step) => step.capability) : normalizeWorkflowCapabilities(raw.capabilities);
+  if (!name || capabilities.length === 0) return null;
+  return {
+    version: 1,
+    name,
+    capabilities,
+    ...raw.runWithoutApproval === true ? { runWithoutApproval: true } : {},
+    ...steps ? { steps } : {},
+    ...typeof raw.createdAt === "string" ? { createdAt: raw.createdAt } : {},
+    ...typeof raw.updatedAt === "string" ? { updatedAt: raw.updatedAt } : {}
+  };
+}
+function readWorkflowDefinition(config, cwd, id) {
+  const file = readStateText(config, cwd, workflowDefinitionPath(id));
+  if (!file) return readCompanyStoreWorkflowDefinition(id);
+  return parseWorkflowDefinition(file.content);
+}
+function workflowDefinitionToCapabilityFolder(id, workflow, source = workflowDefinitionPath(id)) {
+  return {
+    slug: id,
+    dir: path26.dirname(source),
+    profilePath: source,
+    bodyPath: source,
+    title: workflow.name,
+    body: "",
+    rawBody: "",
+    rawProfile: { name: id, workflow },
+    config: {
+      action: id,
+      workflow: workflowDefinitionToConfig(workflow),
+      describe: workflow.name
+    }
+  };
+}
+function normalizeWorkflowCapabilities(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const capabilities = [];
+  for (const item of value) {
+    if (typeof item !== "string") continue;
+    const slug2 = item.trim();
+    if (!CAPABILITY_ID_PATTERN.test(slug2) || seen.has(slug2)) continue;
+    seen.add(slug2);
+    capabilities.push(slug2);
+  }
+  return capabilities;
+}
+function workflowDefinitionToConfig(workflow) {
+  return {
+    steps: workflow.steps ?? workflow.capabilities.map((capability) => ({ capability }))
+  };
+}
+function readCompanyStoreWorkflowDefinition(id) {
+  const root = getCompanyStoreAssetRoot("workflows");
+  if (!root) return null;
+  const filePath = path26.join(root, id, "workflow.json");
+  if (!fs28.existsSync(filePath)) return null;
+  return parseWorkflowDefinition(fs28.readFileSync(filePath, "utf8"));
+}
+function parseWorkflowDefinition(content) {
+  try {
+    return normalizeWorkflowDefinition(JSON.parse(content));
+  } catch {
+    return null;
+  }
+}
+var WORKFLOW_ID_PATTERN, CAPABILITY_ID_PATTERN;
+var init_workflowDefinitions = __esm({
+  "src/workflowDefinitions.ts"() {
+    "use strict";
+    init_capabilityFolders();
+    init_companyStore();
+    init_stateRepo();
+    WORKFLOW_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,79}$/;
+    CAPABILITY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,79}$/;
+  }
+});
+
 // src/scripts/issueStateComment.ts
 function isStateEnvelope(x) {
   if (x === null || typeof x !== "object") return false;
@@ -8796,8 +8894,8 @@ var init_contentsApiBackend = __esm({
 });
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs28 from "fs";
-import * as path26 from "path";
+import * as fs29 from "fs";
+import * as path27 from "path";
 function sanitizeKey(s) {
   return s.replace(/[^A-Za-z0-9._-]/g, "-");
 }
@@ -8853,7 +8951,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 = path26.join(opts.cwd, opts.jobsDir);
+        this.absDir = path27.join(opts.cwd, opts.jobsDir);
         this.owner = opts.owner;
         this.repo = opts.repo;
         this.cache = opts.cache ?? defaultCacheAdapter();
@@ -8868,7 +8966,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        fs28.mkdirSync(this.absDir, { recursive: true });
+        fs29.mkdirSync(this.absDir, { recursive: true });
         const prefix = this.cacheKeyPrefix();
         const probeKey = `${prefix}probe-${Date.now()}`;
         try {
@@ -8897,7 +8995,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        if (!fs28.existsSync(this.absDir)) {
+        if (!fs29.existsSync(this.absDir)) {
           return;
         }
         const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -8913,11 +9011,11 @@ var init_localFileBackend = __esm({
       }
       load(slug2) {
         const relPath = stateFilePath(this.jobsDir, slug2);
-        const absPath = path26.join(this.cwd, relPath);
-        if (!fs28.existsSync(absPath)) {
+        const absPath = path27.join(this.cwd, relPath);
+        if (!fs29.existsSync(absPath)) {
           return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
         }
-        const raw = fs28.readFileSync(absPath, "utf-8");
+        const raw = fs29.readFileSync(absPath, "utf-8");
         let parsed;
         try {
           parsed = JSON.parse(raw);
@@ -8934,13 +9032,13 @@ var init_localFileBackend = __esm({
         if (!loaded.created && isStateUnchanged(loaded.state, next)) {
           return false;
         }
-        const absPath = path26.join(this.cwd, loaded.path);
-        fs28.mkdirSync(path26.dirname(absPath), { recursive: true });
+        const absPath = path27.join(this.cwd, loaded.path);
+        fs29.mkdirSync(path27.dirname(absPath), { recursive: true });
         const body = `${JSON.stringify(next, null, 2)}
 `;
         const tmpPath = `${absPath}.${process.pid}.tmp`;
-        fs28.writeFileSync(tmpPath, body, "utf-8");
-        fs28.renameSync(tmpPath, absPath);
+        fs29.writeFileSync(tmpPath, body, "utf-8");
+        fs29.renameSync(tmpPath, absPath);
         return true;
       }
       cacheKeyPrefix() {
@@ -8980,7 +9078,7 @@ var init_jobState = __esm({
 });
 
 // src/scripts/goalCapabilityScheduling.ts
-import * as path27 from "path";
+import * as path28 from "path";
 function isCapabilityCadenceGoal(goal, extra) {
   return extra.scheduleMode === "agentLoop" || extra.scheduler === "agentLoop" || goal.type === "standing" && goal.capabilities.length > 0;
 }
@@ -9036,7 +9134,7 @@ function planTargetLoopSchedule(opts) {
 }
 async function planGoalCapabilitySchedule(opts) {
   const jobsDir = opts.jobsDir ?? ".kody/capabilities";
-  const jobsRoot = path27.join(opts.cwd, jobsDir);
+  const jobsRoot = path28.join(opts.cwd, jobsDir);
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const at = now.toISOString();
   const backend = resolveBackend({ config: opts.config, cwd: opts.cwd, jobsDir });
@@ -9226,6 +9324,43 @@ var init_goalCapabilityScheduling = __esm({
 });
 
 // src/scripts/advanceManagedGoal.ts
+function autonomyBlockReason(ctx, goalId, goal, dispatch2) {
+  if (ctx.data.jobForce === true) return null;
+  if (goal.runWithoutApproval !== true) {
+    return `Run without approval is off for ${managedModelKind(goal)} ${goalId}`;
+  }
+  if (dispatch2.workflow) {
+    const workflow = readWorkflowDefinition(ctx.config, ctx.cwd, dispatch2.workflow);
+    if (workflow && workflow.runWithoutApproval !== true) {
+      return `Run without approval is off for workflow ${dispatch2.workflow}`;
+    }
+  }
+  const targetGoal = dispatch2.action === "goal-manager" && typeof dispatch2.cliArgs.goal === "string" ? dispatch2.cliArgs.goal : null;
+  if (targetGoal && targetGoal !== goalId) {
+    const target = fetchGoalState(ctx.config, targetGoal, ctx.cwd);
+    const targetManaged = target ? managedGoalFromState(expandManagedGoalState(target)) : null;
+    if (targetManaged && targetManaged.runWithoutApproval !== true) {
+      return `Run without approval is off for goal ${targetGoal}`;
+    }
+  }
+  return null;
+}
+function managedModelKind(goal) {
+  return goal.loopTarget || goal.schedule ? "Loop" : "Goal";
+}
+function stageAutonomyBlocked(data, goalId, goal, goalState, reason) {
+  stageGoalRunLogEvent(data, goalId, {
+    source: "goal-manager",
+    event: "goal.tick.wait",
+    goalType: goal.type,
+    goalState,
+    stage: goal.stage,
+    status: "wait",
+    reason,
+    goal: goalRunLogSnapshot(goalId, goalState, goal),
+    decision: { kind: "wait", reason }
+  });
+}
 function stageManagedGoalDecision(data, goalId, goal, goalState, decision, details) {
   if (decision.kind === "dispatch" || decision.kind === "dispatchWorkflow") {
     stageGoalRunLogEvent(data, goalId, {
@@ -9400,9 +9535,11 @@ var init_advanceManagedGoal = __esm({
     init_manager();
     init_runLog();
     init_state2();
+    init_stateStore();
     init_targetLoopResolution();
     init_typeDefinitions();
     init_issue();
+    init_workflowDefinitions();
     init_goalCapabilityScheduling();
     advanceManagedGoal = async (ctx) => {
       ctx.skipAgent = true;
@@ -9497,6 +9634,12 @@ var init_advanceManagedGoal = __esm({
         goal.raw = writeManagedGoalToState({ ...goal.raw, state: goal.state }, managed);
         goal.raw.extra.scheduleState = decision2.scheduleState;
         ctx.data.managedGoalDecision = decision2;
+        const autonomyBlock = decision2.kind === "dispatch" && decision2.dispatch ? autonomyBlockReason(ctx, goal.id, managed, decision2.dispatch) : null;
+        if (autonomyBlock) {
+          stageAutonomyBlocked(ctx.data, goal.id, managed, goal.state, autonomyBlock);
+          ctx.output.reason = autonomyBlock;
+          return;
+        }
         if (decision2.kind === "dispatch" && decision2.dispatch) {
           ctx.output.nextDispatch = {
             ...decision2.dispatch.action ? { action: decision2.dispatch.action } : {},
@@ -9553,6 +9696,12 @@ var init_advanceManagedGoal = __esm({
         goal.raw = writeManagedGoalToState({ ...goal.raw, state: goal.state }, managed);
         goal.raw.extra.scheduleState = decision2.scheduleState;
         ctx.data.managedGoalDecision = decision2;
+        const autonomyBlock = decision2.kind === "dispatch" && decision2.dispatch ? autonomyBlockReason(ctx, goal.id, managed, decision2.dispatch) : null;
+        if (autonomyBlock) {
+          stageAutonomyBlocked(ctx.data, goal.id, managed, goal.state, autonomyBlock);
+          ctx.output.reason = autonomyBlock;
+          return;
+        }
         if (decision2.kind === "dispatch" && decision2.dispatch) {
           ctx.output.nextDispatch = {
             capability: decision2.dispatch.capability,
@@ -9606,6 +9755,19 @@ var init_advanceManagedGoal = __esm({
       }
       goal.raw = writeManagedGoalToState({ ...goal.raw, state: goal.state }, managed);
       const afterDecisionSnapshot = goalRunLogSnapshot(goal.id, goal.state, managed);
+      if (decision.kind === "dispatch" || decision.kind === "dispatchWorkflow") {
+        const planned = decision.kind === "dispatchWorkflow" ? { workflow: decision.workflow, cliArgs: decision.cliArgs } : {
+          capability: decision.capability,
+          ...decision.implementation ? { implementation: decision.implementation } : {},
+          cliArgs: decision.cliArgs
+        };
+        const autonomyBlock = autonomyBlockReason(ctx, goal.id, managed, planned);
+        if (autonomyBlock) {
+          stageAutonomyBlocked(ctx.data, goal.id, managed, goal.state, autonomyBlock);
+          ctx.output.reason = autonomyBlock;
+          return;
+        }
+      }
       stageManagedGoalDecision(ctx.data, goal.id, managed, goal.state, decision, {
         goalSnapshot: afterDecisionSnapshot,
         inspection: {
@@ -11145,8 +11307,8 @@ var init_classifyByLabel = __esm({
 });
 
 // src/scripts/commitAndPush.ts
-import * as fs29 from "fs";
-import * as path28 from "path";
+import * as fs30 from "fs";
+import * as path29 from "path";
 function sentinelPathForStage(cwd, profileName) {
   const runId = resolveRunId();
   return runtimeStatePath(cwd, "agent-runs", runId, `commit-${profileName}.lock`);
@@ -11167,9 +11329,9 @@ var init_commitAndPush = __esm({
       }
       const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
       const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
-      if (sentinel && fs29.existsSync(sentinel)) {
+      if (sentinel && fs30.existsSync(sentinel)) {
         try {
-          const replay = JSON.parse(fs29.readFileSync(sentinel, "utf-8"));
+          const replay = JSON.parse(fs30.readFileSync(sentinel, "utf-8"));
           ctx.data.commitResult = replay.commitResult ?? { committed: false, pushed: false };
           if (Array.isArray(replay.changedFiles)) ctx.data.changedFiles = replay.changedFiles;
           if (typeof replay.hasCommitsAhead === "boolean") ctx.data.hasCommitsAhead = replay.hasCommitsAhead;
@@ -11222,8 +11384,8 @@ var init_commitAndPush = __esm({
       const result = ctx.data.commitResult;
       if (sentinel && result?.committed) {
         try {
-          fs29.mkdirSync(path28.dirname(sentinel), { recursive: true });
-          fs29.writeFileSync(
+          fs30.mkdirSync(path29.dirname(sentinel), { recursive: true });
+          fs30.writeFileSync(
             sentinel,
             JSON.stringify(
               {
@@ -11314,8 +11476,8 @@ var init_commitGoalState = __esm({
 });
 
 // src/scripts/composePrompt.ts
-import * as fs30 from "fs";
-import * as path29 from "path";
+import * as fs31 from "fs";
+import * as path30 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]");
@@ -11436,10 +11598,10 @@ var init_composePrompt = __esm({
       const explicit = ctx.data.promptTemplate;
       const mode = ctx.args.mode;
       const candidates = [
-        explicit ? path29.join(profile.dir, explicit) : null,
-        mode ? path29.join(profile.dir, "prompts", `${mode}.md`) : null,
-        path29.join(profile.dir, "prompt.md"),
-        path29.join(profile.dir, "capability.md")
+        explicit ? path30.join(profile.dir, explicit) : null,
+        mode ? path30.join(profile.dir, "prompts", `${mode}.md`) : null,
+        path30.join(profile.dir, "prompt.md"),
+        path30.join(profile.dir, "capability.md")
       ].filter(Boolean);
       let templatePath = "";
       let template = "";
@@ -11452,7 +11614,7 @@ var init_composePrompt = __esm({
           break;
         }
         try {
-          template = fs30.readFileSync(c, "utf-8");
+          template = fs31.readFileSync(c, "utf-8");
           templatePath = c;
           break;
         } catch (err) {
@@ -11463,7 +11625,7 @@ var init_composePrompt = __esm({
       if (!templatePath) {
         let dirState;
         try {
-          dirState = `dir contents: [${fs30.readdirSync(profile.dir).join(", ")}]`;
+          dirState = `dir contents: [${fs31.readdirSync(profile.dir).join(", ")}]`;
         } catch (err) {
           dirState = `readdir(${profile.dir}) failed: ${err?.code ?? String(err)}`;
         }
@@ -12152,19 +12314,19 @@ var init_deriveQaScopeFromIssue = __esm({
 
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync10 } from "child_process";
-import * as fs31 from "fs";
+import * as fs32 from "fs";
 import * as os6 from "os";
-import * as path30 from "path";
+import * as path31 from "path";
 var diagMcp;
 var init_diagMcp = __esm({
   "src/scripts/diagMcp.ts"() {
     "use strict";
     diagMcp = async (_ctx) => {
       const home = os6.homedir();
-      const cacheDir = path30.join(home, ".cache", "ms-playwright");
+      const cacheDir = path31.join(home, ".cache", "ms-playwright");
       let entries = [];
       try {
-        entries = fs31.readdirSync(cacheDir);
+        entries = fs32.readdirSync(cacheDir);
       } catch {
       }
       const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -12192,13 +12354,13 @@ var init_diagMcp = __esm({
 });
 
 // src/scripts/frameworkDetectors.ts
-import * as fs32 from "fs";
-import * as path31 from "path";
+import * as fs33 from "fs";
+import * as path32 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs32.readFileSync(path31.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs33.readFileSync(path32.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -12235,25 +12397,25 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs32.existsSync(path31.join(cwd, c))) return c;
+    if (fs33.existsSync(path32.join(cwd, c))) return c;
   }
   return null;
 }
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path31.join(cwd, dir);
-    if (!fs32.existsSync(full)) continue;
+    const full = path32.join(cwd, dir);
+    if (!fs33.existsSync(full)) continue;
     let files;
     try {
-      files = fs32.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs33.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const filePath = path31.join(full, file);
-        const content = fs32.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path32.join(full, file);
+        const content = fs33.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug2 = slugMatch[1];
@@ -12267,7 +12429,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug: slug2,
-          filePath: path31.relative(cwd, filePath),
+          filePath: path32.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -12280,28 +12442,28 @@ function discoverPayloadCollections(cwd) {
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path31.join(cwd, dir);
-    if (!fs32.existsSync(full)) continue;
+    const full = path32.join(cwd, dir);
+    if (!fs33.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs32.readdirSync(full, { withFileTypes: true });
+      entries = fs33.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path31.join(full, entry.name);
+      const entryPath = path32.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs32.existsSync(path31.join(entryPath, f))
+          (f) => fs33.existsSync(path32.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path31.relative(cwd, path31.join(entryPath, indexFile));
+        filePath = path32.relative(cwd, path32.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path31.relative(cwd, entryPath);
+        filePath = path32.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -12309,7 +12471,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs32.readFileSync(path31.join(cwd, col.filePath), "utf-8");
+            const colContent = fs33.readFileSync(path32.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -12327,8 +12489,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path31.join(cwd, appDir, "api");
-    if (!fs32.existsSync(apiDir)) continue;
+    const apiDir = path32.join(cwd, appDir, "api");
+    if (!fs33.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -12337,14 +12499,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs32.readdirSync(dir, { withFileTypes: true });
+    entries = fs33.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   const routeFile = entries.find((e) => e.isFile() && /^route\.(ts|js|tsx|jsx)$/.test(e.name));
   if (routeFile) {
     try {
-      const content = fs32.readFileSync(path31.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs33.readFileSync(path32.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)
       );
@@ -12352,7 +12514,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path31.relative(cwd, path31.join(dir, routeFile.name))
+          filePath: path32.relative(cwd, path32.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -12363,7 +12525,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(path31.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path32.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -12371,16 +12533,16 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path31.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path32.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 = path31.join(cwd, envFile);
-    if (!fs32.existsSync(envPath)) continue;
+    const envPath = path32.join(cwd, envFile);
+    if (!fs33.existsSync(envPath)) continue;
     try {
-      const content = fs32.readFileSync(envPath, "utf-8");
+      const content = fs33.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -12425,8 +12587,8 @@ var init_frameworkDetectors = __esm({
 });
 
 // src/scripts/discoverQaContext.ts
-import * as fs33 from "fs";
-import * as path32 from "path";
+import * as fs34 from "fs";
+import * as path33 from "path";
 function runQaDiscovery(cwd) {
   const out = {
     routes: [],
@@ -12457,9 +12619,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs33.readFileSync(path32.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs34.readFileSync(path33.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs33.existsSync(path32.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs33.existsSync(path32.join(cwd, "yarn.lock")) ? "yarn" : fs33.existsSync(path32.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs34.existsSync(path33.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs34.existsSync(path33.join(cwd, "yarn.lock")) ? "yarn" : fs34.existsSync(path33.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;
@@ -12469,8 +12631,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path32.join(cwd, appDir);
-    if (!fs33.existsSync(full)) continue;
+    const full = path33.join(cwd, appDir);
+    if (!fs34.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -12478,7 +12640,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs33.readdirSync(dir, { withFileTypes: true });
+    entries = fs34.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -12495,7 +12657,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(path32.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path33.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -12503,7 +12665,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path32.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path33.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -12520,23 +12682,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs33.existsSync(path32.join(cwd, c))) out.authFiles.push(c);
+    if (fs34.existsSync(path33.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 = path32.join(cwd, rp);
-    if (!fs33.existsSync(dir)) continue;
+    const dir = path33.join(cwd, rp);
+    if (!fs34.existsSync(dir)) continue;
     let files;
     try {
-      files = fs33.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs34.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs33.readFileSync(path32.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs34.readFileSync(path33.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) {
@@ -13781,12 +13943,12 @@ var init_fixFlow = __esm({
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync15 } from "child_process";
-import * as fs34 from "fs";
-import * as path33 from "path";
+import * as fs35 from "fs";
+import * as path34 from "path";
 function detectPackageManager(cwd) {
-  if (fs34.existsSync(path33.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs34.existsSync(path33.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs34.existsSync(path33.join(cwd, "bun.lockb"))) return "bun";
+  if (fs35.existsSync(path34.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs35.existsSync(path34.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs35.existsSync(path34.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -13858,22 +14020,22 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path33.join(cwd, "kody.config.json");
-  if (fs34.existsSync(configPath) && !force) {
+  const configPath = path34.join(cwd, "kody.config.json");
+  if (fs35.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs34.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs35.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path33.join(cwd, ".github", "workflows");
-  const workflowPath = path33.join(workflowDir, "kody.yml");
-  if (fs34.existsSync(workflowPath) && !force) {
+  const workflowDir = path34.join(cwd, ".github", "workflows");
+  const workflowPath = path34.join(workflowDir, "kody.yml");
+  if (fs35.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs34.mkdirSync(workflowDir, { recursive: true });
-    fs34.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs35.mkdirSync(workflowDir, { recursive: true });
+    fs35.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
   for (const exe of listImplementations()) {
@@ -13884,12 +14046,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path33.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs34.existsSync(target) && !force) {
+    const target = path34.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs35.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs34.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs35.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -14037,7 +14199,7 @@ Nothing to do. All files already present. (Use --force to overwrite.)
 });
 
 // src/scripts/loadAgentAdhoc.ts
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 function resolveMessage(messageArg) {
   const fromComment = readCommentBody();
   if (fromComment) return stripDirective(fromComment);
@@ -14045,9 +14207,9 @@ function resolveMessage(messageArg) {
 }
 function readCommentBody() {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs35.existsSync(eventPath)) return "";
+  if (!eventPath || !fs36.existsSync(eventPath)) return "";
   try {
-    const event = JSON.parse(fs35.readFileSync(eventPath, "utf-8"));
+    const event = JSON.parse(fs36.readFileSync(eventPath, "utf-8"));
     return String(event.comment?.body ?? "");
   } catch {
     return "";
@@ -14100,10 +14262,10 @@ var init_loadAgentAdhoc = __esm({
         throw new Error("loadAgentAdhoc: ctx.args.agent must be a non-empty slug");
       }
       const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
-      if (!fs35.existsSync(agentPath)) {
+      if (!fs36.existsSync(agentPath)) {
         throw new Error(`loadAgentAdhoc: agent identity not found: ${agentPath}`);
       }
-      const { title, body } = parseAgentFile(fs35.readFileSync(agentPath, "utf-8"), agentSlug);
+      const { title, body } = parseAgentFile(fs36.readFileSync(agentPath, "utf-8"), agentSlug);
       const message = resolveMessage(ctx.args.message);
       if (!message) {
         throw new Error(
@@ -14347,8 +14509,8 @@ var init_loadIssueStateComment = __esm({
 });
 
 // src/scripts/loadJobFromFile.ts
-import * as fs36 from "fs";
-import * as path34 from "path";
+import * as fs37 from "fs";
+import * as path35 from "path";
 function parseJobFile(raw, slug2) {
   let stripped = raw;
   if (stripped.startsWith("---\n")) {
@@ -14386,9 +14548,9 @@ var init_loadJobFromFile = __esm({
       if (!slug2) {
         throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
       }
-      const capability = resolveCapabilityFolder(slug2, path34.join(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug2, path35.join(ctx.cwd, jobsDir));
       if (!capability) {
-        throw new Error(`loadJobFromFile: capability folder not found or incomplete: ${path34.join(ctx.cwd, jobsDir, slug2)}`);
+        throw new Error(`loadJobFromFile: capability folder not found or incomplete: ${path35.join(ctx.cwd, jobsDir, slug2)}`);
       }
       const { title, body, config } = capability;
       const mentions = (config.mentions ?? []).map((login) => `@${login}`).join(" ");
@@ -14397,12 +14559,12 @@ var init_loadJobFromFile = __esm({
       let agentIdentity = "";
       if (agentSlug) {
         const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
-        if (!fs36.existsSync(agentPath)) {
+        if (!fs37.existsSync(agentPath)) {
           throw new Error(
             `loadJobFromFile: capability '${slug2}' declares agent '${agentSlug}' but ${agentPath} does not exist`
           );
         }
-        const agentRaw = fs36.readFileSync(agentPath, "utf-8");
+        const agentRaw = fs37.readFileSync(agentPath, "utf-8");
         const parsed = parseJobFile(agentRaw, agentSlug);
         agentTitle = parsed.title;
         agentIdentity = parsed.body;
@@ -14482,13 +14644,13 @@ ${truncate(issue.body, FINDING_BODY_MAX_BYTES)}`;
 });
 
 // src/scripts/kodyVariables.ts
-import * as fs37 from "fs";
-import * as path35 from "path";
+import * as fs38 from "fs";
+import * as path36 from "path";
 function readKodyVariables(cwd) {
-  const full = path35.join(cwd, KODY_VARIABLES_REL_PATH);
+  const full = path36.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
-    raw = fs37.readFileSync(full, "utf-8");
+    raw = fs38.readFileSync(full, "utf-8");
   } catch {
     return {};
   }
@@ -14556,8 +14718,8 @@ var init_keys = __esm({
 });
 
 // src/stateRepoGithub.ts
-import * as fs38 from "fs";
-import * as path36 from "path";
+import * as fs39 from "fs";
+import * as path37 from "path";
 function recordValue4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -14697,15 +14859,15 @@ function mergeJsonl(localText, remoteText) {
 async function syncJsonlFileFromGithubState(opts) {
   const remote = await readGithubStateTextWithConfig(opts);
   if (!remote) return;
-  const local = fs38.existsSync(opts.localPath) ? fs38.readFileSync(opts.localPath, "utf-8") : "";
+  const local = fs39.existsSync(opts.localPath) ? fs39.readFileSync(opts.localPath, "utf-8") : "";
   const next = mergeJsonl(local, remote.content);
   if (next === local) return;
-  fs38.mkdirSync(path36.dirname(opts.localPath), { recursive: true });
-  fs38.writeFileSync(opts.localPath, next);
+  fs39.mkdirSync(path37.dirname(opts.localPath), { recursive: true });
+  fs39.writeFileSync(opts.localPath, next);
 }
 async function persistJsonlFileToGithubState(opts) {
-  if (!fs38.existsSync(opts.localPath)) return;
-  const localText = fs38.readFileSync(opts.localPath, "utf-8");
+  if (!fs39.existsSync(opts.localPath)) return;
+  const localText = fs39.readFileSync(opts.localPath, "utf-8");
   for (let attempt = 1; attempt <= 3; attempt += 1) {
     const remote = await readGithubStateTextWithConfig(opts);
     const body = mergeJsonl(localText, remote?.content ?? "");
@@ -14844,8 +15006,8 @@ var init_runtimeSecrets = __esm({
 });
 
 // src/scripts/loadQaContext.ts
-import * as fs39 from "fs";
-import * as path37 from "path";
+import * as fs40 from "fs";
+import * as path38 from "path";
 function parseSlugList(value) {
   const inner = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
   return inner.split(",").map(
@@ -14874,18 +15036,18 @@ function readProfileAgents(raw) {
   return { agent: agent ?? legacy ?? ["kody"], body };
 }
 function readProfile(cwd) {
-  const dir = path37.join(cwd, CONTEXT_DIR_REL_PATH);
-  if (!fs39.existsSync(dir)) return "";
+  const dir = path38.join(cwd, CONTEXT_DIR_REL_PATH);
+  if (!fs40.existsSync(dir)) return "";
   let entries;
   try {
-    entries = fs39.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    entries = fs40.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs39.readFileSync(path37.join(dir, file), "utf-8");
+      const raw = fs40.readFileSync(path38.join(dir, file), "utf-8");
       const { agent, body } = readProfileAgents(raw);
       if (!agent.includes(QA_AGENT) && !agent.includes(ALL_AGENTS)) continue;
       blocks.push(`## ${file}
@@ -14934,8 +15096,8 @@ var init_loadQaContext = __esm({
 });
 
 // src/taskContext.ts
-import * as fs40 from "fs";
-import * as path38 from "path";
+import * as fs41 from "fs";
+import * as path39 from "path";
 function buildTaskContext(args) {
   return {
     schemaVersion: TASK_CONTEXT_SCHEMA_VERSION,
@@ -14951,9 +15113,9 @@ function buildTaskContext(args) {
 function persistTaskContext(cwd, ctx) {
   try {
     const dir = runtimeStatePath(cwd, "agent-runs", ctx.runId);
-    fs40.mkdirSync(dir, { recursive: true });
-    const file = path38.join(dir, "task-context.json");
-    fs40.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    fs41.mkdirSync(dir, { recursive: true });
+    const file = path39.join(dir, "task-context.json");
+    fs41.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -17463,12 +17625,12 @@ fi
 
 // src/scripts/runPreviewBuild.ts
 import { copyFile, writeFile } from "fs/promises";
-import * as path39 from "path";
+import * as path40 from "path";
 import { fileURLToPath } from "url";
 function bundledDockerfilePath(mode) {
-  const here = path39.dirname(fileURLToPath(import.meta.url));
+  const here = path40.dirname(fileURLToPath(import.meta.url));
   const file = mode === "dev" ? "default-Dockerfile.preview.dev" : "default-Dockerfile.preview.prod";
-  return path39.join(here, "preview-build-templates", file);
+  return path40.join(here, "preview-build-templates", file);
 }
 function required(name) {
   const v = (process.env[name] ?? "").trim();
@@ -17719,10 +17881,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(path39.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
+          await writeFile(path40.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
 `, "utf8");
         }
-        const consumerDockerfile = path39.join(ctx.cwd, "Dockerfile.preview");
+        const consumerDockerfile = path40.join(ctx.cwd, "Dockerfile.preview");
         const { stat } = await import("fs/promises");
         let hasConsumerDockerfile = false;
         try {
@@ -17906,8 +18068,8 @@ var init_tickShellRunner = __esm({
 });
 
 // src/scripts/runScheduledImplementationTick.ts
-import * as fs41 from "fs";
-import * as path40 from "path";
+import * as fs42 from "fs";
+import * as path41 from "path";
 var runScheduledImplementationTick;
 var init_runScheduledImplementationTick = __esm({
   "src/scripts/runScheduledImplementationTick.ts"() {
@@ -17927,14 +18089,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(slug2, path40.join(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug2, path41.join(ctx.cwd, jobsDir));
       if (!capability) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledImplementationTick: capability folder not found or incomplete: ${slug2} (searched ${jobsDir} and company store)`;
         return;
       }
-      const shellPath = path40.join(profile.dir, shell);
-      if (!fs41.existsSync(shellPath)) {
+      const shellPath = path41.join(profile.dir, shell);
+      if (!fs42.existsSync(shellPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledImplementationTick: shell not found: ${shell} (looked in ${profile.dir})`;
         return;
@@ -17965,8 +18127,8 @@ var init_runScheduledImplementationTick = __esm({
 });
 
 // src/scripts/runTickScript.ts
-import * as fs42 from "fs";
-import * as path41 from "path";
+import * as fs43 from "fs";
+import * as path42 from "path";
 var runTickScript;
 var init_runTickScript = __esm({
   "src/scripts/runTickScript.ts"() {
@@ -17985,10 +18147,10 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
         return;
       }
-      const capability = readCapabilityFolder(path41.join(ctx.cwd, jobsDir), slug2);
+      const capability = readCapabilityFolder(path42.join(ctx.cwd, jobsDir), slug2);
       if (!capability) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path41.join(ctx.cwd, jobsDir, slug2)}`;
+        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path42.join(ctx.cwd, jobsDir, slug2)}`;
         return;
       }
       const tickScript = capability.config.tickScript;
@@ -17997,8 +18159,8 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: capability ${slug2} has no \`tickScript\` in profile.json \u2014 route via capability-tick instead`;
         return;
       }
-      const scriptPath = path41.isAbsolute(tickScript) ? tickScript : path41.join(ctx.cwd, tickScript);
-      if (!fs42.existsSync(scriptPath)) {
+      const scriptPath = path42.isAbsolute(tickScript) ? tickScript : path42.join(ctx.cwd, tickScript);
+      if (!fs43.existsSync(scriptPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
         return;
@@ -19143,7 +19305,7 @@ var init_warmupMcp = __esm({
 });
 
 // src/scripts/writeAgentRunSummary.ts
-import * as fs43 from "fs";
+import * as fs44 from "fs";
 var writeAgentRunSummary;
 var init_writeAgentRunSummary = __esm({
   "src/scripts/writeAgentRunSummary.ts"() {
@@ -19169,7 +19331,7 @@ var init_writeAgentRunSummary = __esm({
       if (reason) lines.push(`- **Reason:** ${reason}`);
       lines.push("");
       try {
-        fs43.appendFileSync(summaryPath, `${lines.join("\n")}
+        fs44.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
       } catch {
       }
@@ -19427,6 +19589,7 @@ var init_scripts = __esm({
       planTaskJobs,
       dispatchNextTaskJob,
       runScheduledImplementationTick,
+      runScheduledExecutableTick: runScheduledImplementationTick,
       runTickScript,
       runPreviewBuild,
       advanceManagedGoal,
@@ -19495,53 +19658,53 @@ var init_scripts = __esm({
 // src/stateWorkspace.ts
 import { execFileSync as execFileSync24 } from "child_process";
 import * as crypto3 from "crypto";
-import * as fs44 from "fs";
+import * as fs45 from "fs";
 import * as os7 from "os";
-import * as path42 from "path";
+import * as path43 from "path";
 function writeLocalFile(cwd, relativePath, content) {
-  const fullPath = path42.join(cwd, relativePath);
-  fs44.mkdirSync(path42.dirname(fullPath), { recursive: true });
-  fs44.writeFileSync(fullPath, content);
+  const fullPath = path43.join(cwd, relativePath);
+  fs45.mkdirSync(path43.dirname(fullPath), { recursive: true });
+  fs45.writeFileSync(fullPath, content);
 }
 function copyPath(source, target) {
-  const st = fs44.lstatSync(source);
-  fs44.rmSync(target, { recursive: true, force: true });
+  const st = fs45.lstatSync(source);
+  fs45.rmSync(target, { recursive: true, force: true });
   if (st.isSymbolicLink()) return;
-  fs44.mkdirSync(path42.dirname(target), { recursive: true });
-  fs44.cpSync(source, target, { recursive: true, force: true });
+  fs45.mkdirSync(path43.dirname(target), { recursive: true });
+  fs45.cpSync(source, target, { recursive: true, force: true });
 }
 function overlayDirectoryChildren(cwd, sourceDir, localDir) {
-  if (!fs44.existsSync(sourceDir)) return;
-  for (const entry of fs44.readdirSync(sourceDir, { withFileTypes: true })) {
-    const source = path42.join(sourceDir, entry.name);
-    const target = path42.join(cwd, localDir, entry.name);
+  if (!fs45.existsSync(sourceDir)) return;
+  for (const entry of fs45.readdirSync(sourceDir, { withFileTypes: true })) {
+    const source = path43.join(sourceDir, entry.name);
+    const target = path43.join(cwd, localDir, entry.name);
     copyPath(source, target);
   }
 }
 function hydrateStateWorkspace(config, cwd) {
   if (process.env.VITEST && process.env[TEST_FETCH_ENV] !== "1") return;
   const parsed = parseStateRepo(config);
-  const hydrateKey = `${path42.resolve(cwd)}|${parsed.owner}/${parsed.repo}|${parsed.basePath}|${parsed.branch}`;
+  const hydrateKey = `${path43.resolve(cwd)}|${parsed.owner}/${parsed.repo}|${parsed.basePath}|${parsed.branch}`;
   if (hydratedWorkspaces.has(hydrateKey)) return;
   const snapshotRoot = fetchStateSnapshot(parsed);
   for (const mapping of DIR_MAPPINGS) {
-    overlayDirectoryChildren(cwd, path42.join(snapshotRoot, mapping.stateDir), mapping.localDir);
+    overlayDirectoryChildren(cwd, path43.join(snapshotRoot, mapping.stateDir), mapping.localDir);
   }
   for (const mapping of FILE_MAPPINGS) {
-    const source = path42.join(snapshotRoot, mapping.statePath);
-    if (fs44.existsSync(source) && !fs44.lstatSync(source).isSymbolicLink() && fs44.statSync(source).isFile()) {
-      writeLocalFile(cwd, mapping.localPath, fs44.readFileSync(source, "utf-8"));
+    const source = path43.join(snapshotRoot, mapping.statePath);
+    if (fs45.existsSync(source) && !fs45.lstatSync(source).isSymbolicLink() && fs45.statSync(source).isFile()) {
+      writeLocalFile(cwd, mapping.localPath, fs45.readFileSync(source, "utf-8"));
     }
   }
   hydratedWorkspaces.add(hydrateKey);
 }
 function fetchStateSnapshot(parsed) {
-  const cacheDir = path42.join(cacheRoot2(), cacheKey3(parsed));
+  const cacheDir = path43.join(cacheRoot2(), cacheKey3(parsed));
   const url = `https://github.com/${parsed.owner}/${parsed.repo}.git`;
   try {
-    fs44.mkdirSync(path42.dirname(cacheDir), { recursive: true });
-    if (!fs44.existsSync(path42.join(cacheDir, ".git"))) {
-      fs44.rmSync(cacheDir, { recursive: true, force: true });
+    fs45.mkdirSync(path43.dirname(cacheDir), { recursive: true });
+    if (!fs45.existsSync(path43.join(cacheDir, ".git"))) {
+      fs45.rmSync(cacheDir, { recursive: true, force: true });
       runGit3(["clone", "--no-checkout", "--filter=blob:none", url, cacheDir]);
     }
     runGit3(["-C", cacheDir, "remote", "set-url", "origin", url]);
@@ -19556,10 +19719,10 @@ function fetchStateSnapshot(parsed) {
       `stateWorkspace: failed to fetch ${parsed.owner}/${parsed.repo}:${parsed.basePath}@${parsed.branch}: ${msg}`
     );
   }
-  return path42.join(cacheDir, parsed.basePath);
+  return path43.join(cacheDir, parsed.basePath);
 }
 function cacheRoot2() {
-  return process.env[CACHE_ENV2]?.trim() || path42.join(os7.homedir(), ".cache", "kody", "state-repo");
+  return process.env[CACHE_ENV2]?.trim() || path43.join(os7.homedir(), ".cache", "kody", "state-repo");
 }
 function cacheKey3(parsed) {
   return crypto3.createHash("sha256").update(`${parsed.owner}/${parsed.repo}#${parsed.branch}#${parsed.basePath}`).digest("hex").slice(0, 24);
@@ -19599,15 +19762,15 @@ var init_stateWorkspace = __esm({
     "use strict";
     init_stateRepo();
     DIR_MAPPINGS = [
-      { stateDir: "capabilities", localDir: path42.join(".kody", "capabilities") },
-      { stateDir: "agents", localDir: path42.join(".kody", "agents") },
-      { stateDir: "context", localDir: path42.join(".kody", "context") },
-      { stateDir: "memory", localDir: path42.join(".kody", "memory") }
+      { stateDir: "capabilities", localDir: path43.join(".kody", "capabilities") },
+      { stateDir: "agents", localDir: path43.join(".kody", "agents") },
+      { stateDir: "context", localDir: path43.join(".kody", "context") },
+      { stateDir: "memory", localDir: path43.join(".kody", "memory") }
     ];
     FILE_MAPPINGS = [
-      { statePath: "instructions.md", localPath: path42.join(".kody", "instructions.md") },
-      { statePath: "variables.json", localPath: path42.join(".kody", "variables.json") },
-      { statePath: "secrets.enc", localPath: path42.join(".kody", "secrets.enc") }
+      { statePath: "instructions.md", localPath: path43.join(".kody", "instructions.md") },
+      { statePath: "variables.json", localPath: path43.join(".kody", "variables.json") },
+      { statePath: "secrets.enc", localPath: path43.join(".kody", "secrets.enc") }
     ];
     CACHE_ENV2 = "KODY_STATE_REPO_CACHE";
     TEST_FETCH_ENV = "KODY_STATE_WORKSPACE_FETCH_FOR_TESTS";
@@ -19681,8 +19844,8 @@ var init_tools = __esm({
 
 // src/executor.ts
 import { spawn as spawn7 } from "child_process";
-import * as fs45 from "fs";
-import * as path43 from "path";
+import * as fs46 from "fs";
+import * as path44 from "path";
 function isMutatingPostflight(scriptName) {
   return MUTATING_POSTFLIGHTS.has(scriptName ?? "");
 }
@@ -19727,9 +19890,7 @@ function jobReferenceBlock(profileName, profile, data) {
   const jobId = typeof data.jobId === "string" && data.jobId.length > 0 ? data.jobId : null;
   const flavor = typeof data.jobFlavor === "string" && data.jobFlavor.length > 0 ? data.jobFlavor : null;
   const schedule = typeof data.jobSchedule === "string" && data.jobSchedule.length > 0 ? data.jobSchedule : null;
-  const isJob2 = Boolean(
-    jobId || flavor || schedule || data.jobCapability || data.selectedImplementation || data.jobWhy
-  );
+  const isJob2 = Boolean(jobId || flavor || schedule || data.jobCapability || data.selectedImplementation || data.jobWhy);
   if (!isJob2) return null;
   const capability = typeof data.jobCapability === "string" && data.jobCapability.length > 0 ? data.jobCapability : profile.implementation ? profile.name : null;
   const implementation = typeof profile.implementation === "string" && profile.implementation.length > 0 ? profile.implementation : typeof data.selectedImplementation === "string" && data.selectedImplementation.length > 0 ? data.selectedImplementation : profileName;
@@ -19907,7 +20068,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) => path43.isAbsolute(p) ? p : path43.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path44.isAbsolute(p) ? p : path44.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
@@ -20333,17 +20494,17 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function resolveProfilePath(profileName) {
   const found = resolveImplementation(profileName);
   if (found) return found;
-  const here = path43.dirname(new URL(import.meta.url).pathname);
+  const here = path44.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path43.join(here, "implementations", profileName, "profile.json"),
+    path44.join(here, "implementations", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path43.join(here, "..", "implementations", profileName, "profile.json"),
+    path44.join(here, "..", "implementations", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/implementations)
-    path43.join(here, "..", "src", "implementations", profileName, "profile.json")
+    path44.join(here, "..", "src", "implementations", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs45.existsSync(c)) return c;
+    if (fs46.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -20458,8 +20619,8 @@ function resolveShellTimeoutMs(entry) {
 }
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path43.join(profile.dir, shellName);
-  if (!fs45.existsSync(shellPath)) {
+  const shellPath = path44.join(profile.dir, shellName);
+  if (!fs46.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -20610,101 +20771,6 @@ var init_executor = __esm({
   }
 });
 
-// src/workflowDefinitions.ts
-import * as fs46 from "fs";
-import * as path44 from "path";
-function isWorkflowDefinitionId(value) {
-  return WORKFLOW_ID_PATTERN.test(value);
-}
-function workflowDefinitionPath(id) {
-  if (!isWorkflowDefinitionId(id)) {
-    throw new Error(`Invalid workflow id "${id}"`);
-  }
-  return `workflows/${id}/workflow.json`;
-}
-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 workflow = parseCapabilityWorkflow({ steps: raw.steps });
-  const steps = workflow?.steps;
-  const capabilities = steps ? steps.map((step) => step.capability) : normalizeWorkflowCapabilities(raw.capabilities);
-  if (!name || capabilities.length === 0) return null;
-  return {
-    version: 1,
-    name,
-    capabilities,
-    ...steps ? { steps } : {},
-    ...typeof raw.createdAt === "string" ? { createdAt: raw.createdAt } : {},
-    ...typeof raw.updatedAt === "string" ? { updatedAt: raw.updatedAt } : {}
-  };
-}
-function readWorkflowDefinition(config, cwd, id) {
-  const file = readStateText(config, cwd, workflowDefinitionPath(id));
-  if (!file) return readCompanyStoreWorkflowDefinition(id);
-  return parseWorkflowDefinition(file.content);
-}
-function workflowDefinitionToCapabilityFolder(id, workflow, source = workflowDefinitionPath(id)) {
-  return {
-    slug: id,
-    dir: path44.dirname(source),
-    profilePath: source,
-    bodyPath: source,
-    title: workflow.name,
-    body: "",
-    rawBody: "",
-    rawProfile: { name: id, workflow },
-    config: {
-      action: id,
-      workflow: workflowDefinitionToConfig(workflow),
-      describe: workflow.name
-    }
-  };
-}
-function normalizeWorkflowCapabilities(value) {
-  if (!Array.isArray(value)) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const capabilities = [];
-  for (const item of value) {
-    if (typeof item !== "string") continue;
-    const slug2 = item.trim();
-    if (!CAPABILITY_ID_PATTERN.test(slug2) || seen.has(slug2)) continue;
-    seen.add(slug2);
-    capabilities.push(slug2);
-  }
-  return capabilities;
-}
-function workflowDefinitionToConfig(workflow) {
-  return {
-    steps: workflow.steps ?? workflow.capabilities.map((capability) => ({ capability }))
-  };
-}
-function readCompanyStoreWorkflowDefinition(id) {
-  const root = getCompanyStoreAssetRoot("workflows");
-  if (!root) return null;
-  const filePath = path44.join(root, id, "workflow.json");
-  if (!fs46.existsSync(filePath)) return null;
-  return parseWorkflowDefinition(fs46.readFileSync(filePath, "utf8"));
-}
-function parseWorkflowDefinition(content) {
-  try {
-    return normalizeWorkflowDefinition(JSON.parse(content));
-  } catch {
-    return null;
-  }
-}
-var WORKFLOW_ID_PATTERN, CAPABILITY_ID_PATTERN;
-var init_workflowDefinitions = __esm({
-  "src/workflowDefinitions.ts"() {
-    "use strict";
-    init_capabilityFolders();
-    init_companyStore();
-    init_stateRepo();
-    WORKFLOW_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,79}$/;
-    CAPABILITY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,79}$/;
-  }
-});
-
 // src/job.ts
 var job_exports = {};
 __export(job_exports, {
@@ -20824,6 +20890,7 @@ async function runCapabilityImplementationStep(valid, profileName, capabilityIde
   preloadedData.selectedImplementation = profileName;
   if (valid.schedule !== void 0 && valid.schedule.length > 0) preloadedData.jobSchedule = valid.schedule;
   if (valid.saveReport === true) preloadedData.jobSaveReport = true;
+  if (valid.force === true) preloadedData.jobForce = true;
   if (valid.resultTarget) preloadedData.capabilityResultTarget = valid.resultTarget;
   if (capabilityContext) {
     preloadedData.capabilitySlug = capabilityContext.slug;
@@ -23032,8 +23099,10 @@ ${CI_HELP}`);
 `);
     const buildOnly = dispatch2.implementation === "preview-build";
     if (args.skipInstall || buildOnly) {
-      process.stdout.write(`\u2192 kody: skipping dep install (${buildOnly ? "build-only implementation" : "--skip-install"})
-`);
+      process.stdout.write(
+        `\u2192 kody: skipping dep install (${buildOnly ? "build-only implementation" : "--skip-install"})
+`
+      );
     } else {
       const code = installDeps(pm, cwd);
       if (code !== 0) {
@@ -26206,7 +26275,8 @@ Usage:
   kody-engine release --issue <N>                    [--cwd <path>] [--verbose|--quiet]
   kody-engine init                                   [--cwd <path>] [--verbose|--quiet]
   kody-engine <action>                               [--cwd <path>] [--verbose|--quiet]
-  kody-engine implementation <name>                      [--cwd <path>] [--verbose|--quiet]
+  kody-engine exec <name>                            [--cwd <path>] [--verbose|--quiet]
+  kody-engine implementation <name>                  [--cwd <path>] [--verbose|--quiet]
   kody-engine ci      [preflight flags \u2014 see: kody-engine ci --help]
   kody-engine chat    [chat flags \u2014 see: kody-engine chat --help]
   kody-engine stats   [--since 7d|--run <id>|--json|--cwd <path>]
@@ -26214,7 +26284,7 @@ Usage:
   kody-engine version
 
 Top-level work commands are capabilities. A capability owns the public command name
-and resolves the implementation that runs it. Use the implementation command only for
+and resolves the implementation that runs it. Use the exec command only for
 internal implementation profiles and scheduled helpers.
 
 Exit codes:
@@ -26250,10 +26320,10 @@ function parseArgs(argv) {
   if (cmd === "stats") {
     return { ...result, command: "stats", statsArgv: argv.slice(1) };
   }
-  if (cmd === "implementation") {
+  if (cmd === "implementation" || cmd === "exec") {
     const implementationName = argv[1];
     if (!implementationName || implementationName.startsWith("-")) {
-      result.errors.push("implementation requires a name");
+      result.errors.push(`${cmd} requires a name`);
       return result;
     }
     if (!resolveImplementation(implementationName)) {
@@ -26288,7 +26358,7 @@ function parseArgs(argv) {
     return result;
   }
   const discoveredActions = listCapabilityActions().map((e) => e.action);
-  const available = ["ci", "chat", "stats", "implementation", "help", "version", ...discoveredActions];
+  const available = ["ci", "chat", "stats", "exec", "implementation", "help", "version", ...discoveredActions];
   result.errors.push(`unknown command: ${cmd} (available: ${available.join(", ")})`);
   return result;
 }