@kody-ade/kody-engine 0.4.272 → 0.4.274

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.272",
+      version: "0.4.274",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -2217,7 +2217,7 @@ function cmsHeaders(opts) {
     }
   };
 }
-async function callDashboardCms(opts, path49, init = {}) {
+async function callDashboardCms(opts, path50, init = {}) {
   const baseUrl = dashboardBaseUrl();
   if (!baseUrl) {
     return {
@@ -2229,7 +2229,7 @@ async function callDashboardCms(opts, path49, init = {}) {
   const headerResult = cmsHeaders(opts);
   if (!headerResult.ok) return headerResult;
   try {
-    const res = await fetch(`${baseUrl}${path49}`, {
+    const res = await fetch(`${baseUrl}${path50}`, {
       ...init,
       headers: {
         ...headerResult.headers,
@@ -6430,10 +6430,10 @@ var init_state2 = __esm({
     "use strict";
     VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "done"]);
     GoalStateError = class extends Error {
-      constructor(path49, message) {
-        super(`Invalid goal state at ${path49}:
+      constructor(path50, message) {
+        super(`Invalid goal state at ${path50}:
   ${message}`);
-        this.path = path49;
+        this.path = path50;
         this.name = "GoalStateError";
       }
       path;
@@ -6446,9 +6446,9 @@ import * as fs25 from "fs";
 function stageGoalRunLogEvent(data, goalId, event, at = nowIso()) {
   const logs = goalRunLogs(data);
   const existing = logs[goalId];
-  const path49 = existing?.path ?? goalRunLogPath(goalId, data);
+  const path50 = existing?.path ?? goalRunLogPath(goalId, data);
   logs[goalId] = {
-    path: path49,
+    path: path50,
     events: [
       ...existing?.events ?? [],
       buildGoalRunLogEvent(data, goalId, event, at)
@@ -6810,6 +6810,188 @@ var init_runLog = __esm({
   }
 });
 
+// src/goal/stateStore.ts
+function statePath(goalId) {
+  return `goals/instances/${goalId}/state.json`;
+}
+function fetchGoalState(config, goalId, cwd) {
+  const filePath = statePath(goalId);
+  const loaded = readStateText(config, cwd, filePath);
+  if (!loaded) return null;
+  return parseGoalState(loaded.path, JSON.parse(loaded.content));
+}
+function putGoalState(config, goalId, state, message = `chore(goals): update ${goalId}`, cwd) {
+  upsertStateText(config, cwd, statePath(goalId), serializeGoalState(state), message);
+}
+var init_stateStore = __esm({
+  "src/goal/stateStore.ts"() {
+    "use strict";
+    init_stateRepo();
+    init_state2();
+  }
+});
+
+// src/goal/targetLoopResolution.ts
+import * as fs26 from "fs";
+import * as path24 from "path";
+function resolveGoalLoopTarget(config, cwd, loopGoalId, loopGoal, now) {
+  const targetId = loopGoal.loopTarget?.id.trim() ?? "";
+  assertSafeGoalId(targetId, "loop target");
+  if (!hasExplicitStateRepo(config)) {
+    return { targetId, templateId: targetId, reason: "literal target; state repo not configured" };
+  }
+  const activeInstance = findActiveTargetInstance(config, cwd, loopGoalId, targetId);
+  if (activeInstance) {
+    return {
+      targetId: activeInstance.id,
+      templateId: targetId,
+      reason: "active target instance"
+    };
+  }
+  const directTarget = fetchGoalState(config, targetId, cwd);
+  if (directTarget?.state === "active") {
+    return { targetId, templateId: targetId, reason: "active target goal" };
+  }
+  const template = loadGoalTemplate(cwd, targetId);
+  if (!template) {
+    if (directTarget) {
+      throw new Error(`goal target ${targetId} is ${directTarget.state}; no active instance or template found`);
+    }
+    return { targetId, templateId: targetId, reason: "literal target; no target state or template found" };
+  }
+  const instanceId = chooseTargetInstanceId(config, cwd, targetId, loopGoal.preferredRunTime?.timezone, now);
+  const instance = buildGoalTargetInstance(template, targetId, now);
+  putGoalState(config, instanceId, instance, `chore(goals): create ${instanceId}`, cwd);
+  return {
+    targetId: instanceId,
+    templateId: targetId,
+    reason: "created target instance from template",
+    created: true
+  };
+}
+function goalLoopNow() {
+  const value = process.env.KODY_GOAL_LOOP_NOW?.trim();
+  if (value) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) return date;
+  }
+  return /* @__PURE__ */ new Date();
+}
+function hasExplicitStateRepo(config) {
+  const state = config.state;
+  return !!state && typeof state.repo === "string" && state.repo.trim().length > 0 && typeof state.path === "string" && state.path.trim().length > 0;
+}
+function findActiveTargetInstance(config, cwd, loopGoalId, targetId) {
+  const entries = listStateDirectory(config, cwd, "goals/instances");
+  const candidates = [];
+  for (const entry of entries) {
+    const id = typeof entry.name === "string" ? entry.name.trim() : "";
+    if (!id || id === loopGoalId || id === targetId || !id.startsWith(`${targetId}-`)) continue;
+    assertSafeGoalId(id, "goal instance");
+    const state = fetchGoalState(config, id, cwd);
+    if (!state || state.state !== "active") continue;
+    if (!isTargetInstanceState(id, state, targetId)) continue;
+    candidates.push({ id, state });
+  }
+  candidates.sort(compareGoalInstanceAge);
+  return candidates[0] ?? null;
+}
+function isTargetInstanceState(id, state, targetId) {
+  if (id.startsWith(`${targetId}-`)) return true;
+  return ["template", "sourceTemplate", "templateId", "type"].some((key) => state.extra[key] === targetId);
+}
+function compareGoalInstanceAge(a, b) {
+  const byTime = goalInstanceTime(a.state) - goalInstanceTime(b.state);
+  return byTime === 0 ? a.id.localeCompare(b.id) : byTime;
+}
+function goalInstanceTime(state) {
+  const value = state.createdAt ?? state.startedAt ?? state.updatedAt;
+  if (!value) return 0;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function loadGoalTemplate(cwd, targetId) {
+  const local = path24.join(cwd, ".kody", "goals", "templates", targetId, "state.json");
+  const localTemplate = readJsonObject(local);
+  if (localTemplate) return localTemplate;
+  const storeGoalRoot = getCompanyStoreAssetRoot("goals");
+  if (!storeGoalRoot) return null;
+  return readJsonObject(path24.join(storeGoalRoot, "templates", targetId, "state.json"));
+}
+function readJsonObject(filePath) {
+  if (!fs26.existsSync(filePath)) return null;
+  const parsed = JSON.parse(fs26.readFileSync(filePath, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`goal template ${filePath} must be a JSON object`);
+  }
+  return parsed;
+}
+function chooseTargetInstanceId(config, cwd, targetId, timezone, now) {
+  const base = `${targetId}-${zonedDate(now, timezone ?? "UTC")}`;
+  for (let index = 1; index <= 20; index += 1) {
+    const id = index === 1 ? base : `${base}-${index}`;
+    assertSafeGoalId(id, "goal instance");
+    const existing = fetchGoalState(config, id, cwd);
+    if (!existing || existing.state === "active") return id;
+  }
+  throw new Error(`could not allocate goal target instance id for ${targetId}`);
+}
+function buildGoalTargetInstance(template, targetId, now) {
+  const extra = { ...template };
+  for (const key of ["state", "createdAt", "updatedAt", "startedAt"]) {
+    delete extra[key];
+  }
+  extra.kind = "instance";
+  extra.template = targetId;
+  extra.sourceTemplate = targetId;
+  extra.templateId = targetId;
+  if (!isPlainObject2(extra.facts)) extra.facts = {};
+  if (!Array.isArray(extra.blockers)) extra.blockers = [];
+  const at = isoNoMs(now);
+  return {
+    state: "active",
+    createdAt: at,
+    updatedAt: at,
+    extra
+  };
+}
+function isPlainObject2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function assertSafeGoalId(value, label) {
+  if (!/^[A-Za-z0-9_.-]+$/.test(value)) {
+    throw new Error(`${label} id must contain only letters, numbers, dot, underscore, or dash: ${value}`);
+  }
+}
+function zonedDate(date, timezone) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    }).formatToParts(date);
+    const get = (type) => parts.find((part) => part.type === type)?.value;
+    const year = get("year");
+    const month = get("month");
+    const day = get("day");
+    if (year && month && day) return `${year}-${month}-${day}`;
+  } catch {
+  }
+  return date.toISOString().slice(0, 10);
+}
+function isoNoMs(date) {
+  return date.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+var init_targetLoopResolution = __esm({
+  "src/goal/targetLoopResolution.ts"() {
+    "use strict";
+    init_companyStore();
+    init_stateRepo();
+    init_stateStore();
+  }
+});
+
 // src/goal/typeDefinitions.ts
 function cloneRoute(route) {
   return route.map((step) => ({
@@ -7136,8 +7318,8 @@ var init_contentsApiBackend = __esm({
 });
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs26 from "fs";
-import * as path24 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 function sanitizeKey(s) {
   return s.replace(/[^A-Za-z0-9._-]/g, "-");
 }
@@ -7193,7 +7375,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 = path24.join(opts.cwd, opts.jobsDir);
+        this.absDir = path25.join(opts.cwd, opts.jobsDir);
         this.owner = opts.owner;
         this.repo = opts.repo;
         this.cache = opts.cache ?? defaultCacheAdapter();
@@ -7208,7 +7390,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        fs26.mkdirSync(this.absDir, { recursive: true });
+        fs27.mkdirSync(this.absDir, { recursive: true });
         const prefix = this.cacheKeyPrefix();
         const probeKey = `${prefix}probe-${Date.now()}`;
         try {
@@ -7237,7 +7419,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        if (!fs26.existsSync(this.absDir)) {
+        if (!fs27.existsSync(this.absDir)) {
           return;
         }
         const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -7253,11 +7435,11 @@ var init_localFileBackend = __esm({
       }
       load(slug2) {
         const relPath = stateFilePath(this.jobsDir, slug2);
-        const absPath = path24.join(this.cwd, relPath);
-        if (!fs26.existsSync(absPath)) {
+        const absPath = path25.join(this.cwd, relPath);
+        if (!fs27.existsSync(absPath)) {
           return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
         }
-        const raw = fs26.readFileSync(absPath, "utf-8");
+        const raw = fs27.readFileSync(absPath, "utf-8");
         let parsed;
         try {
           parsed = JSON.parse(raw);
@@ -7274,13 +7456,13 @@ var init_localFileBackend = __esm({
         if (!loaded.created && isStateUnchanged(loaded.state, next)) {
           return false;
         }
-        const absPath = path24.join(this.cwd, loaded.path);
-        fs26.mkdirSync(path24.dirname(absPath), { recursive: true });
+        const absPath = path25.join(this.cwd, loaded.path);
+        fs27.mkdirSync(path25.dirname(absPath), { recursive: true });
         const body = `${JSON.stringify(next, null, 2)}
 `;
         const tmpPath = `${absPath}.${process.pid}.tmp`;
-        fs26.writeFileSync(tmpPath, body, "utf-8");
-        fs26.renameSync(tmpPath, absPath);
+        fs27.writeFileSync(tmpPath, body, "utf-8");
+        fs27.renameSync(tmpPath, absPath);
         return true;
       }
       cacheKeyPrefix() {
@@ -7320,7 +7502,7 @@ var init_jobState = __esm({
 });
 
 // src/scripts/goalCapabilityScheduling.ts
-import * as path25 from "path";
+import * as path26 from "path";
 function isCapabilityCadenceGoal(goal, extra) {
   return extra.scheduleMode === "agentLoop" || extra.scheduler === "agentLoop" || goal.type === "standing" && goal.capabilities.length > 0;
 }
@@ -7348,10 +7530,11 @@ function planTargetLoopSchedule(opts) {
     const gate = preferredRunTimeGate(preferred, now, opts.previousScheduleState);
     if (!gate.ok) return targetLoopDecision("idle", gate.reason, at);
   }
-  const dispatch2 = target.type === "goal" ? { action: "goal-manager", executable: "goal-manager", cliArgs: { goal: targetId } } : { workflow: targetId, cliArgs: {} };
+  const dispatchTargetId = target.type === "goal" && opts.resolvedGoalTargetId?.trim() ? opts.resolvedGoalTargetId.trim() : targetId;
+  const dispatch2 = target.type === "goal" ? { action: "goal-manager", executable: "goal-manager", cliArgs: { goal: dispatchTargetId } } : { workflow: targetId, cliArgs: {} };
   return {
     kind: "dispatch",
-    reason: `dispatch ${target.type} ${targetId}`,
+    reason: `dispatch ${target.type} ${target.type === "goal" ? dispatchTargetId : targetId}`,
     dispatch: dispatch2,
     scheduleState: {
       mode: "agentLoop",
@@ -7359,7 +7542,7 @@ function planTargetLoopSchedule(opts) {
       lastDecision: {
         kind: "dispatch",
         targetType: target.type,
-        targetId,
+        targetId: target.type === "goal" ? dispatchTargetId : targetId,
         ...dispatch2.action ? { action: dispatch2.action } : {},
         ...dispatch2.capability ? { capability: dispatch2.capability } : {},
         ...dispatch2.workflow ? { workflow: dispatch2.workflow } : {},
@@ -7373,7 +7556,7 @@ function planTargetLoopSchedule(opts) {
 }
 async function planGoalCapabilitySchedule(opts) {
   const jobsDir = opts.jobsDir ?? ".kody/capabilities";
-  const jobsRoot = path25.join(opts.cwd, jobsDir);
+  const jobsRoot = path26.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 });
@@ -7710,6 +7893,7 @@ var init_advanceManagedGoal = __esm({
     init_manager();
     init_runLog();
     init_state2();
+    init_targetLoopResolution();
     init_typeDefinitions();
     init_issue();
     init_goalCapabilityScheduling();
@@ -7782,7 +7966,18 @@ var init_advanceManagedGoal = __esm({
       if (isGoalTargetLoop(managed) || isWorkflowTargetLoop(managed)) {
         const beforeSnapshot = goalRunLogSnapshot(goal.id, goal.state, managed);
         const previousScheduleState = goal.raw.extra.scheduleState && typeof goal.raw.extra.scheduleState === "object" ? goal.raw.extra.scheduleState : void 0;
-        const decision2 = planTargetLoopSchedule({ goal: managed, previousScheduleState });
+        const now = goalLoopNow();
+        let decision2 = planTargetLoopSchedule({ goal: managed, previousScheduleState, now });
+        let targetResolution;
+        if (decision2.kind === "dispatch" && decision2.dispatch && isGoalTargetLoop(managed)) {
+          targetResolution = resolveGoalLoopTarget(ctx.config, ctx.cwd, goal.id, managed, now);
+          decision2 = planTargetLoopSchedule({
+            goal: managed,
+            previousScheduleState,
+            now,
+            resolvedGoalTargetId: targetResolution.targetId
+          });
+        }
         restoreGoalIdFact();
         goal.raw = writeManagedGoalToState({ ...goal.raw, state: goal.state }, managed);
         goal.raw.extra.scheduleState = decision2.scheduleState;
@@ -7809,6 +8004,7 @@ var init_advanceManagedGoal = __esm({
           goal: goalRunLogSnapshot(goal.id, goal.state, managed),
           inspection: {
             loopTarget: managed.loopTarget,
+            ...targetResolution ? { targetResolution } : {},
             preferredRunTime: managed.preferredRunTime,
             previousScheduleState,
             scheduleState: decision2.scheduleState
@@ -8154,13 +8350,13 @@ function companyIntentPath(id) {
   assertIntentId(id);
   return `intents/${id}/intent.json`;
 }
-function normalizeCompanyIntent(path49, raw) {
+function normalizeCompanyIntent(path50, raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new Error(`${path49}: intent must be JSON object`);
+    throw new Error(`${path50}: intent must be JSON object`);
   }
   const input = raw;
   const id = stringField2(input.id);
-  if (!id || !isCompanyIntentId(id)) throw new Error(`${path49}: invalid intent id`);
+  if (!id || !isCompanyIntentId(id)) throw new Error(`${path50}: invalid intent id`);
   const createdAt = stringField2(input.createdAt) || nowIso();
   const updatedAt = stringField2(input.updatedAt) || createdAt;
   return {
@@ -8199,8 +8395,8 @@ function listCompanyIntents(config, cwd) {
   const records = [];
   for (const entry of entries) {
     if (entry.type !== "dir" || !entry.name || !isCompanyIntentId(entry.name)) continue;
-    const path49 = companyIntentPath(entry.name);
-    const file = readStateText(config, cwd, path49);
+    const path50 = companyIntentPath(entry.name);
+    const file = readStateText(config, cwd, path50);
     if (!file) continue;
     records.push({
       id: entry.name,
@@ -8211,8 +8407,8 @@ function listCompanyIntents(config, cwd) {
   return records.sort((a, b) => a.intent.priority - b.intent.priority || a.id.localeCompare(b.id));
 }
 function readCompanyIntent(config, cwd, id) {
-  const path49 = companyIntentPath(id);
-  const file = readStateText(config, cwd, path49);
+  const path50 = companyIntentPath(id);
+  const file = readStateText(config, cwd, path50);
   if (!file) return null;
   return { id, path: file.path, intent: normalizeCompanyIntent(file.path, JSON.parse(file.content)) };
 }
@@ -8304,27 +8500,6 @@ var init_companyIntent = __esm({
   }
 });
 
-// src/goal/stateStore.ts
-function statePath(goalId) {
-  return `goals/instances/${goalId}/state.json`;
-}
-function fetchGoalState(config, goalId, cwd) {
-  const filePath = statePath(goalId);
-  const loaded = readStateText(config, cwd, filePath);
-  if (!loaded) return null;
-  return parseGoalState(loaded.path, JSON.parse(loaded.content));
-}
-function putGoalState(config, goalId, state, message = `chore(goals): update ${goalId}`, cwd) {
-  upsertStateText(config, cwd, statePath(goalId), serializeGoalState(state), message);
-}
-var init_stateStore = __esm({
-  "src/goal/stateStore.ts"() {
-    "use strict";
-    init_stateRepo();
-    init_state2();
-  }
-});
-
 // src/scripts/applyCompanyManagerDecision.ts
 function applyAction(config, cwd, action) {
   if (action.kind === "createManagedGoal") {
@@ -9266,8 +9441,8 @@ var init_classifyByLabel = __esm({
 });
 
 // src/scripts/commitAndPush.ts
-import * as fs27 from "fs";
-import * as path26 from "path";
+import * as fs28 from "fs";
+import * as path27 from "path";
 function sentinelPathForStage(cwd, profileName) {
   const runId = resolveRunId();
   return runtimeStatePath(cwd, "agent-runs", runId, `commit-${profileName}.lock`);
@@ -9288,9 +9463,9 @@ var init_commitAndPush = __esm({
       }
       const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
       const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
-      if (sentinel && fs27.existsSync(sentinel)) {
+      if (sentinel && fs28.existsSync(sentinel)) {
         try {
-          const replay = JSON.parse(fs27.readFileSync(sentinel, "utf-8"));
+          const replay = JSON.parse(fs28.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;
@@ -9343,8 +9518,8 @@ var init_commitAndPush = __esm({
       const result = ctx.data.commitResult;
       if (sentinel && result?.committed) {
         try {
-          fs27.mkdirSync(path26.dirname(sentinel), { recursive: true });
-          fs27.writeFileSync(
+          fs28.mkdirSync(path27.dirname(sentinel), { recursive: true });
+          fs28.writeFileSync(
             sentinel,
             JSON.stringify(
               {
@@ -9435,8 +9610,8 @@ var init_commitGoalState = __esm({
 });
 
 // src/scripts/composePrompt.ts
-import * as fs28 from "fs";
-import * as path27 from "path";
+import * as fs29 from "fs";
+import * as path28 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]");
@@ -9559,10 +9734,10 @@ var init_composePrompt = __esm({
       const explicit = ctx.data.promptTemplate;
       const mode = ctx.args.mode;
       const candidates = [
-        explicit ? path27.join(profile.dir, explicit) : null,
-        mode ? path27.join(profile.dir, "prompts", `${mode}.md`) : null,
-        path27.join(profile.dir, "prompt.md"),
-        path27.join(profile.dir, "capability.md")
+        explicit ? path28.join(profile.dir, explicit) : null,
+        mode ? path28.join(profile.dir, "prompts", `${mode}.md`) : null,
+        path28.join(profile.dir, "prompt.md"),
+        path28.join(profile.dir, "capability.md")
       ].filter(Boolean);
       let templatePath = "";
       let template = "";
@@ -9575,7 +9750,7 @@ var init_composePrompt = __esm({
           break;
         }
         try {
-          template = fs28.readFileSync(c, "utf-8");
+          template = fs29.readFileSync(c, "utf-8");
           templatePath = c;
           break;
         } catch (err) {
@@ -9586,7 +9761,7 @@ var init_composePrompt = __esm({
       if (!templatePath) {
         let dirState;
         try {
-          dirState = `dir contents: [${fs28.readdirSync(profile.dir).join(", ")}]`;
+          dirState = `dir contents: [${fs29.readdirSync(profile.dir).join(", ")}]`;
         } catch (err) {
           dirState = `readdir(${profile.dir}) failed: ${err?.code ?? String(err)}`;
         }
@@ -10186,19 +10361,19 @@ var init_deriveQaScopeFromIssue = __esm({
 
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync10 } from "child_process";
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 import * as os6 from "os";
-import * as path28 from "path";
+import * as path29 from "path";
 var diagMcp;
 var init_diagMcp = __esm({
   "src/scripts/diagMcp.ts"() {
     "use strict";
     diagMcp = async (_ctx) => {
       const home = os6.homedir();
-      const cacheDir = path28.join(home, ".cache", "ms-playwright");
+      const cacheDir = path29.join(home, ".cache", "ms-playwright");
       let entries = [];
       try {
-        entries = fs29.readdirSync(cacheDir);
+        entries = fs30.readdirSync(cacheDir);
       } catch {
       }
       const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -10226,13 +10401,13 @@ var init_diagMcp = __esm({
 });
 
 // src/scripts/frameworkDetectors.ts
-import * as fs30 from "fs";
-import * as path29 from "path";
+import * as fs31 from "fs";
+import * as path30 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs30.readFileSync(path29.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs31.readFileSync(path30.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -10269,25 +10444,25 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs30.existsSync(path29.join(cwd, c))) return c;
+    if (fs31.existsSync(path30.join(cwd, c))) return c;
   }
   return null;
 }
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path29.join(cwd, dir);
-    if (!fs30.existsSync(full)) continue;
+    const full = path30.join(cwd, dir);
+    if (!fs31.existsSync(full)) continue;
     let files;
     try {
-      files = fs30.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs31.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const filePath = path29.join(full, file);
-        const content = fs30.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path30.join(full, file);
+        const content = fs31.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug2 = slugMatch[1];
@@ -10301,7 +10476,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug: slug2,
-          filePath: path29.relative(cwd, filePath),
+          filePath: path30.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -10314,28 +10489,28 @@ function discoverPayloadCollections(cwd) {
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path29.join(cwd, dir);
-    if (!fs30.existsSync(full)) continue;
+    const full = path30.join(cwd, dir);
+    if (!fs31.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs30.readdirSync(full, { withFileTypes: true });
+      entries = fs31.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path29.join(full, entry.name);
+      const entryPath = path30.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs30.existsSync(path29.join(entryPath, f))
+          (f) => fs31.existsSync(path30.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path29.relative(cwd, path29.join(entryPath, indexFile));
+        filePath = path30.relative(cwd, path30.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path29.relative(cwd, entryPath);
+        filePath = path30.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -10343,7 +10518,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs30.readFileSync(path29.join(cwd, col.filePath), "utf-8");
+            const colContent = fs31.readFileSync(path30.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -10361,8 +10536,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path29.join(cwd, appDir, "api");
-    if (!fs30.existsSync(apiDir)) continue;
+    const apiDir = path30.join(cwd, appDir, "api");
+    if (!fs31.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -10371,14 +10546,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs30.readdirSync(dir, { withFileTypes: true });
+    entries = fs31.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 = fs30.readFileSync(path29.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs31.readFileSync(path30.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)
       );
@@ -10386,7 +10561,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path29.relative(cwd, path29.join(dir, routeFile.name))
+          filePath: path30.relative(cwd, path30.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -10397,7 +10572,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(path29.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path30.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -10405,16 +10580,16 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path29.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path30.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 = path29.join(cwd, envFile);
-    if (!fs30.existsSync(envPath)) continue;
+    const envPath = path30.join(cwd, envFile);
+    if (!fs31.existsSync(envPath)) continue;
     try {
-      const content = fs30.readFileSync(envPath, "utf-8");
+      const content = fs31.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -10459,8 +10634,8 @@ var init_frameworkDetectors = __esm({
 });
 
 // src/scripts/discoverQaContext.ts
-import * as fs31 from "fs";
-import * as path30 from "path";
+import * as fs32 from "fs";
+import * as path31 from "path";
 function runQaDiscovery(cwd) {
   const out = {
     routes: [],
@@ -10491,9 +10666,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs31.readFileSync(path30.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs32.readFileSync(path31.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs31.existsSync(path30.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs31.existsSync(path30.join(cwd, "yarn.lock")) ? "yarn" : fs31.existsSync(path30.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs32.existsSync(path31.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs32.existsSync(path31.join(cwd, "yarn.lock")) ? "yarn" : fs32.existsSync(path31.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;
@@ -10503,8 +10678,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path30.join(cwd, appDir);
-    if (!fs31.existsSync(full)) continue;
+    const full = path31.join(cwd, appDir);
+    if (!fs32.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -10512,7 +10687,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs31.readdirSync(dir, { withFileTypes: true });
+    entries = fs32.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -10529,7 +10704,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(path30.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path31.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -10537,7 +10712,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path30.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path31.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -10554,23 +10729,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs31.existsSync(path30.join(cwd, c))) out.authFiles.push(c);
+    if (fs32.existsSync(path31.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 = path30.join(cwd, rp);
-    if (!fs31.existsSync(dir)) continue;
+    const dir = path31.join(cwd, rp);
+    if (!fs32.existsSync(dir)) continue;
     let files;
     try {
-      files = fs31.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs32.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs31.readFileSync(path30.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs32.readFileSync(path31.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) {
@@ -11789,12 +11964,12 @@ var init_fixFlow = __esm({
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync15 } from "child_process";
-import * as fs32 from "fs";
-import * as path31 from "path";
+import * as fs33 from "fs";
+import * as path32 from "path";
 function detectPackageManager(cwd) {
-  if (fs32.existsSync(path31.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs32.existsSync(path31.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs32.existsSync(path31.join(cwd, "bun.lockb"))) return "bun";
+  if (fs33.existsSync(path32.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs33.existsSync(path32.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs33.existsSync(path32.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -11866,22 +12041,22 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path31.join(cwd, "kody.config.json");
-  if (fs32.existsSync(configPath) && !force) {
+  const configPath = path32.join(cwd, "kody.config.json");
+  if (fs33.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs32.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs33.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path31.join(cwd, ".github", "workflows");
-  const workflowPath = path31.join(workflowDir, "kody.yml");
-  if (fs32.existsSync(workflowPath) && !force) {
+  const workflowDir = path32.join(cwd, ".github", "workflows");
+  const workflowPath = path32.join(workflowDir, "kody.yml");
+  if (fs33.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs32.mkdirSync(workflowDir, { recursive: true });
-    fs32.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs33.mkdirSync(workflowDir, { recursive: true });
+    fs33.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
   for (const exe of listExecutables()) {
@@ -11892,12 +12067,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path31.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs32.existsSync(target) && !force) {
+    const target = path32.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs33.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs32.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs33.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -12050,7 +12225,7 @@ Nothing to do. All files already present. (Use --force to overwrite.)
 });
 
 // src/scripts/loadAgentAdhoc.ts
-import * as fs33 from "fs";
+import * as fs34 from "fs";
 function resolveMessage(messageArg) {
   const fromComment = readCommentBody();
   if (fromComment) return stripDirective(fromComment);
@@ -12058,9 +12233,9 @@ function resolveMessage(messageArg) {
 }
 function readCommentBody() {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs33.existsSync(eventPath)) return "";
+  if (!eventPath || !fs34.existsSync(eventPath)) return "";
   try {
-    const event = JSON.parse(fs33.readFileSync(eventPath, "utf-8"));
+    const event = JSON.parse(fs34.readFileSync(eventPath, "utf-8"));
     return String(event.comment?.body ?? "");
   } catch {
     return "";
@@ -12113,10 +12288,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 (!fs33.existsSync(agentPath)) {
+      if (!fs34.existsSync(agentPath)) {
         throw new Error(`loadAgentAdhoc: agent identity not found: ${agentPath}`);
       }
-      const { title, body } = parseAgentFile(fs33.readFileSync(agentPath, "utf-8"), agentSlug);
+      const { title, body } = parseAgentFile(fs34.readFileSync(agentPath, "utf-8"), agentSlug);
       const message = resolveMessage(ctx.args.message);
       if (!message) {
         throw new Error(
@@ -12354,8 +12529,8 @@ var init_loadIssueStateComment = __esm({
 });
 
 // src/scripts/loadJobFromFile.ts
-import * as fs34 from "fs";
-import * as path32 from "path";
+import * as fs35 from "fs";
+import * as path33 from "path";
 function parseJobFile(raw, slug2) {
   let stripped = raw;
   if (stripped.startsWith("---\n")) {
@@ -12393,10 +12568,10 @@ var init_loadJobFromFile = __esm({
       if (!slug2) {
         throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
       }
-      const capability = resolveCapabilityFolder(slug2, path32.join(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug2, path33.join(ctx.cwd, jobsDir));
       if (!capability) {
         throw new Error(
-          `loadJobFromFile: capability folder not found or incomplete: ${path32.join(ctx.cwd, jobsDir, slug2)}`
+          `loadJobFromFile: capability folder not found or incomplete: ${path33.join(ctx.cwd, jobsDir, slug2)}`
         );
       }
       const { title, body, config } = capability;
@@ -12406,12 +12581,12 @@ var init_loadJobFromFile = __esm({
       let agentIdentity = "";
       if (agentSlug) {
         const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
-        if (!fs34.existsSync(agentPath)) {
+        if (!fs35.existsSync(agentPath)) {
           throw new Error(
             `loadJobFromFile: capability '${slug2}' declares agent '${agentSlug}' but ${agentPath} does not exist`
           );
         }
-        const agentRaw = fs34.readFileSync(agentPath, "utf-8");
+        const agentRaw = fs35.readFileSync(agentPath, "utf-8");
         const parsed = parseJobFile(agentRaw, agentSlug);
         agentTitle = parsed.title;
         agentIdentity = parsed.body;
@@ -12485,13 +12660,13 @@ ${truncate(issue.body, FINDING_BODY_MAX_BYTES)}`;
 });
 
 // src/scripts/kodyVariables.ts
-import * as fs35 from "fs";
-import * as path33 from "path";
+import * as fs36 from "fs";
+import * as path34 from "path";
 function readKodyVariables(cwd) {
-  const full = path33.join(cwd, KODY_VARIABLES_REL_PATH);
+  const full = path34.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
-    raw = fs35.readFileSync(full, "utf-8");
+    raw = fs36.readFileSync(full, "utf-8");
   } catch {
     return {};
   }
@@ -12516,8 +12691,8 @@ var init_kodyVariables = __esm({
 });
 
 // src/scripts/loadQaContext.ts
-import * as fs36 from "fs";
-import * as path34 from "path";
+import * as fs37 from "fs";
+import * as path35 from "path";
 function parseSlugList(value) {
   const inner = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
   return inner.split(",").map(
@@ -12546,18 +12721,18 @@ function readProfileAgents(raw) {
   return { agent: agent ?? legacy ?? ["kody"], body };
 }
 function readProfile(cwd) {
-  const dir = path34.join(cwd, CONTEXT_DIR_REL_PATH);
-  if (!fs36.existsSync(dir)) return "";
+  const dir = path35.join(cwd, CONTEXT_DIR_REL_PATH);
+  if (!fs37.existsSync(dir)) return "";
   let entries;
   try {
-    entries = fs36.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    entries = fs37.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs36.readFileSync(path34.join(dir, file), "utf-8");
+      const raw = fs37.readFileSync(path35.join(dir, file), "utf-8");
       const { agent, body } = readProfileAgents(raw);
       if (!agent.includes(QA_AGENT) && !agent.includes(ALL_AGENTS)) continue;
       blocks.push(`## ${file}
@@ -12603,8 +12778,8 @@ var init_loadQaContext = __esm({
 });
 
 // src/taskContext.ts
-import * as fs37 from "fs";
-import * as path35 from "path";
+import * as fs38 from "fs";
+import * as path36 from "path";
 function buildTaskContext(args) {
   return {
     schemaVersion: TASK_CONTEXT_SCHEMA_VERSION,
@@ -12620,9 +12795,9 @@ function buildTaskContext(args) {
 function persistTaskContext(cwd, ctx) {
   try {
     const dir = runtimeStatePath(cwd, "agent-runs", ctx.runId);
-    fs37.mkdirSync(dir, { recursive: true });
-    const file = path35.join(dir, "task-context.json");
-    fs37.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    fs38.mkdirSync(dir, { recursive: true });
+    const file = path36.join(dir, "task-context.json");
+    fs38.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -14967,8 +15142,8 @@ fi
 });
 
 // src/stateRepoGithub.ts
-import * as fs38 from "fs";
-import * as path36 from "path";
+import * as fs39 from "fs";
+import * as path37 from "path";
 function recordValue3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -15108,15 +15283,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 ?? "");
@@ -15150,12 +15325,12 @@ var init_stateRepoGithub = __esm({
 
 // src/scripts/runPreviewBuild.ts
 import { copyFile, writeFile } from "fs/promises";
-import * as path37 from "path";
+import * as path38 from "path";
 import { fileURLToPath } from "url";
 function bundledDockerfilePath(mode) {
-  const here = path37.dirname(fileURLToPath(import.meta.url));
+  const here = path38.dirname(fileURLToPath(import.meta.url));
   const file = mode === "dev" ? "default-Dockerfile.preview.dev" : "default-Dockerfile.preview.prod";
-  return path37.join(here, "preview-build-templates", file);
+  return path38.join(here, "preview-build-templates", file);
 }
 function required(name) {
   const v = (process.env[name] ?? "").trim();
@@ -15406,10 +15581,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(path37.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
+          await writeFile(path38.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
 `, "utf8");
         }
-        const consumerDockerfile = path37.join(ctx.cwd, "Dockerfile.preview");
+        const consumerDockerfile = path38.join(ctx.cwd, "Dockerfile.preview");
         const { stat } = await import("fs/promises");
         let hasConsumerDockerfile = false;
         try {
@@ -15593,8 +15768,8 @@ var init_tickShellRunner = __esm({
 });
 
 // src/scripts/runScheduledExecutableTick.ts
-import * as fs39 from "fs";
-import * as path38 from "path";
+import * as fs40 from "fs";
+import * as path39 from "path";
 var runScheduledExecutableTick;
 var init_runScheduledExecutableTick = __esm({
   "src/scripts/runScheduledExecutableTick.ts"() {
@@ -15614,14 +15789,14 @@ var init_runScheduledExecutableTick = __esm({
         ctx.output.reason = `runScheduledExecutableTick: args.slug or ctx.args.${slugArg} must be non-empty capability slug`;
         return;
       }
-      const capability = resolveCapabilityFolder(slug2, path38.join(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug2, path39.join(ctx.cwd, jobsDir));
       if (!capability) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledExecutableTick: capability folder not found or incomplete: ${slug2} (searched ${jobsDir} and company store)`;
         return;
       }
-      const shellPath = path38.join(profile.dir, shell);
-      if (!fs39.existsSync(shellPath)) {
+      const shellPath = path39.join(profile.dir, shell);
+      if (!fs40.existsSync(shellPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledExecutableTick: shell not found: ${shell} (looked in ${profile.dir})`;
         return;
@@ -15652,8 +15827,8 @@ var init_runScheduledExecutableTick = __esm({
 });
 
 // src/scripts/runTickScript.ts
-import * as fs40 from "fs";
-import * as path39 from "path";
+import * as fs41 from "fs";
+import * as path40 from "path";
 var runTickScript;
 var init_runTickScript = __esm({
   "src/scripts/runTickScript.ts"() {
@@ -15672,10 +15847,10 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
         return;
       }
-      const capability = readCapabilityFolder(path39.join(ctx.cwd, jobsDir), slug2);
+      const capability = readCapabilityFolder(path40.join(ctx.cwd, jobsDir), slug2);
       if (!capability) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path39.join(ctx.cwd, jobsDir, slug2)}`;
+        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path40.join(ctx.cwd, jobsDir, slug2)}`;
         return;
       }
       const tickScript = capability.config.tickScript;
@@ -15684,8 +15859,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 = path39.isAbsolute(tickScript) ? tickScript : path39.join(ctx.cwd, tickScript);
-      if (!fs40.existsSync(scriptPath)) {
+      const scriptPath = path40.isAbsolute(tickScript) ? tickScript : path40.join(ctx.cwd, tickScript);
+      if (!fs41.existsSync(scriptPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
         return;
@@ -16507,7 +16682,7 @@ var init_warmupMcp = __esm({
 });
 
 // src/scripts/writeAgentRunSummary.ts
-import * as fs41 from "fs";
+import * as fs42 from "fs";
 var writeAgentRunSummary;
 var init_writeAgentRunSummary = __esm({
   "src/scripts/writeAgentRunSummary.ts"() {
@@ -16533,7 +16708,7 @@ var init_writeAgentRunSummary = __esm({
       if (reason) lines.push(`- **Reason:** ${reason}`);
       lines.push("");
       try {
-        fs41.appendFileSync(summaryPath, `${lines.join("\n")}
+        fs42.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
       } catch {
       }
@@ -16853,22 +17028,22 @@ var init_scripts = __esm({
 });
 
 // src/stateWorkspace.ts
-import * as fs42 from "fs";
-import * as path40 from "path";
+import * as fs43 from "fs";
+import * as path41 from "path";
 function writeLocalFile(cwd, relativePath, content) {
-  const fullPath = path40.join(cwd, relativePath);
-  fs42.mkdirSync(path40.dirname(fullPath), { recursive: true });
-  fs42.writeFileSync(fullPath, content);
+  const fullPath = path41.join(cwd, relativePath);
+  fs43.mkdirSync(path41.dirname(fullPath), { recursive: true });
+  fs43.writeFileSync(fullPath, content);
 }
 function hydrateDirectory(config, cwd, stateDir, localDir) {
   const entries = listStateDirectory(config, cwd, stateDir);
   if (entries.length === 0) return;
   for (const entry of entries) {
     if (!entry.name || !entry.type) continue;
-    const childState = path40.posix.join(stateDir, entry.name);
-    const childLocal = path40.join(localDir, entry.name);
+    const childState = path41.posix.join(stateDir, entry.name);
+    const childLocal = path41.join(localDir, entry.name);
     if (entry.type === "dir") {
-      fs42.rmSync(path40.join(cwd, childLocal), { recursive: true, force: true });
+      fs43.rmSync(path41.join(cwd, childLocal), { recursive: true, force: true });
       hydrateDirectory(config, cwd, childState, childLocal);
     } else if (entry.type === "file") {
       const file = readStateText(config, cwd, childState);
@@ -16891,16 +17066,16 @@ var init_stateWorkspace = __esm({
     "use strict";
     init_stateRepo();
     DIR_MAPPINGS = [
-      { stateDir: "executables", localDir: path40.join(".kody", "executables") },
-      { stateDir: "capabilities", localDir: path40.join(".kody", "capabilities") },
-      { stateDir: "agents", localDir: path40.join(".kody", "agents") },
-      { stateDir: "context", localDir: path40.join(".kody", "context") },
-      { stateDir: "memory", localDir: path40.join(".kody", "memory") }
+      { stateDir: "executables", localDir: path41.join(".kody", "executables") },
+      { stateDir: "capabilities", localDir: path41.join(".kody", "capabilities") },
+      { stateDir: "agents", localDir: path41.join(".kody", "agents") },
+      { stateDir: "context", localDir: path41.join(".kody", "context") },
+      { stateDir: "memory", localDir: path41.join(".kody", "memory") }
     ];
     FILE_MAPPINGS = [
-      { statePath: "instructions.md", localPath: path40.join(".kody", "instructions.md") },
-      { statePath: "variables.json", localPath: path40.join(".kody", "variables.json") },
-      { statePath: "secrets.enc", localPath: path40.join(".kody", "secrets.enc") }
+      { statePath: "instructions.md", localPath: path41.join(".kody", "instructions.md") },
+      { statePath: "variables.json", localPath: path41.join(".kody", "variables.json") },
+      { statePath: "secrets.enc", localPath: path41.join(".kody", "secrets.enc") }
     ];
   }
 });
@@ -16971,8 +17146,8 @@ var init_tools = __esm({
 
 // src/executor.ts
 import { spawn as spawn7 } from "child_process";
-import * as fs43 from "fs";
-import * as path41 from "path";
+import * as fs44 from "fs";
+import * as path42 from "path";
 function isMutatingPostflight(scriptName) {
   return MUTATING_POSTFLIGHTS.has(scriptName ?? "");
 }
@@ -17150,7 +17325,7 @@ async function runExecutable(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) => path41.isAbsolute(p) ? p : path41.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path42.isAbsolute(p) ? p : path42.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
@@ -17542,17 +17717,17 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path41.dirname(new URL(import.meta.url).pathname);
+  const here = path42.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path41.join(here, "executables", profileName, "profile.json"),
+    path42.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path41.join(here, "..", "executables", profileName, "profile.json"),
+    path42.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path41.join(here, "..", "src", "executables", profileName, "profile.json")
+    path42.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs43.existsSync(c)) return c;
+    if (fs44.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -17650,8 +17825,8 @@ function resolveShellTimeoutMs(entry) {
 }
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path41.join(profile.dir, shellName);
-  if (!fs43.existsSync(shellPath)) {
+  const shellPath = path42.join(profile.dir, shellName);
+  if (!fs44.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -17801,8 +17976,8 @@ var init_executor = __esm({
 });
 
 // src/workflowDefinitions.ts
-import * as fs44 from "fs";
-import * as path42 from "path";
+import * as fs45 from "fs";
+import * as path43 from "path";
 function isWorkflowDefinitionId(value) {
   return WORKFLOW_ID_PATTERN.test(value);
 }
@@ -17836,7 +18011,7 @@ function readWorkflowDefinition(config, cwd, id) {
 function workflowDefinitionToCapabilityFolder(id, workflow, source = workflowDefinitionPath(id)) {
   return {
     slug: id,
-    dir: path42.dirname(source),
+    dir: path43.dirname(source),
     profilePath: source,
     bodyPath: source,
     title: workflow.name,
@@ -17871,9 +18046,9 @@ function workflowDefinitionToConfig(workflow) {
 function readCompanyStoreWorkflowDefinition(id) {
   const root = getCompanyStoreAssetRoot("workflows");
   if (!root) return null;
-  const filePath = path42.join(root, id, "workflow.json");
-  if (!fs44.existsSync(filePath)) return null;
-  return parseWorkflowDefinition(fs44.readFileSync(filePath, "utf8"));
+  const filePath = path43.join(root, id, "workflow.json");
+  if (!fs45.existsSync(filePath)) return null;
+  return parseWorkflowDefinition(fs45.readFileSync(filePath, "utf8"));
 }
 function parseWorkflowDefinition(content) {
   try {
@@ -17905,7 +18080,7 @@ __export(job_exports, {
   stableJobKey: () => stableJobKey,
   validateJob: () => validateJob
 });
-import * as path43 from "path";
+import * as path44 from "path";
 function newJobId(flavor) {
   localJobSeq += 1;
   const runId = process.env.GITHUB_RUN_ID;
@@ -17944,7 +18119,7 @@ function validateJob(input) {
 async function runJob(job, base) {
   const valid = validateJob(job);
   const action = valid.action ?? valid.capability;
-  const projectCapabilitiesRoot = path43.join(base.cwd, ".kody", "capabilities");
+  const projectCapabilitiesRoot = path44.join(base.cwd, ".kody", "capabilities");
   const resolvedCapability = !valid.workflow && action ? resolveCapabilityAction(action, projectCapabilitiesRoot) : null;
   const capabilityIdentity = valid.capability ?? resolvedCapability?.capability;
   const capabilityContext = valid.workflow ? null : loadCapabilityContext(capabilityIdentity, base.cwd);
@@ -18127,7 +18302,7 @@ function shouldRunWorkflowStep(step, data) {
   if (!step.runWhen) return true;
   const context = workflowConditionContext(data);
   return Object.entries(step.runWhen).every(
-    ([path49, expected]) => valueMatches(resolveDottedPath2(context, path49), expected)
+    ([path50, expected]) => valueMatches(resolveDottedPath2(context, path50), expected)
   );
 }
 function canContinueWorkflow(step, outcome) {
@@ -18197,7 +18372,7 @@ function composeStepWhy(parentWhy, step) {
 }
 function loadCapabilityContext(slug2, cwd) {
   if (!slug2) return null;
-  return resolveCapabilityFolder(slug2, path43.join(cwd, ".kody", "capabilities"));
+  return resolveCapabilityFolder(slug2, path44.join(cwd, ".kody", "capabilities"));
 }
 function loadWorkflowContext(slug2, base) {
   if (!slug2 || !base.config || !isWorkflowDefinitionId(slug2)) return null;
@@ -18355,9 +18530,9 @@ function translateOpenAISseToBrain(opts) {
 }
 
 // src/servers/brain-serve.ts
-import * as fs47 from "fs";
+import * as fs48 from "fs";
 import { createServer } from "http";
-import * as path46 from "path";
+import * as path47 from "path";
 
 // src/chat/loop.ts
 init_agent();
@@ -18917,8 +19092,8 @@ init_config();
 
 // src/kody-cli.ts
 import { execFileSync as execFileSync25 } from "child_process";
-import * as fs45 from "fs";
-import * as path44 from "path";
+import * as fs46 from "fs";
+import * as path45 from "path";
 
 // src/app-auth.ts
 import { createSign } from "crypto";
@@ -19539,9 +19714,9 @@ async function resolveAuthToken(env = process.env) {
   return void 0;
 }
 function detectPackageManager2(cwd) {
-  if (fs45.existsSync(path44.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs45.existsSync(path44.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs45.existsSync(path44.join(cwd, "bun.lockb"))) return "bun";
+  if (fs46.existsSync(path45.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs46.existsSync(path45.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs46.existsSync(path45.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shouldChainScheduledWatch(match) {
@@ -19634,8 +19809,8 @@ function postFailureTail(issueNumber, cwd, reason) {
   const logPath = lastRunLogPath(cwd);
   let tail = "";
   try {
-    if (fs45.existsSync(logPath)) {
-      const content = fs45.readFileSync(logPath, "utf-8");
+    if (fs46.existsSync(logPath)) {
+      const content = fs46.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -19660,7 +19835,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path44.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path45.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   let earlyConfigError;
   try {
@@ -19675,9 +19850,17 @@ async function runCi(argv) {
   let manualWorkflowDispatch = false;
   let forceRunAction = null;
   let forceRunCliArgs = {};
-  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs45.existsSync(dispatchEventPath)) {
+  const envForceAction = (process.env.KODY_FORCE_ACTION ?? "").trim();
+  const envForceMessage = (process.env.KODY_FORCE_MESSAGE ?? "").trim();
+  if (!args.issueNumber && !autoFallback && envForceAction) {
+    forceRunAction = envForceAction;
+    if (envForceAction === "goal-manager" && envForceMessage) {
+      forceRunCliArgs = { goal: envForceMessage };
+    }
+  }
+  if (!args.issueNumber && !autoFallback && !forceRunAction && eventName === "workflow_dispatch" && dispatchEventPath && fs46.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs45.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs46.readFileSync(dispatchEventPath, "utf-8"));
       const issueInput = parseInt(String(evt?.inputs?.issue_number ?? ""), 10);
       const sessionInput = String(evt?.inputs?.sessionId ?? "");
       const dutyInput = String(evt?.inputs?.capability ?? evt?.inputs?.executable ?? "").trim();
@@ -20009,8 +20192,8 @@ init_repoWorkspace();
 
 // src/scripts/brainTurnLog.ts
 init_runtimePaths();
-import * as fs46 from "fs";
-import * as path45 from "path";
+import * as fs47 from "fs";
+import * as path46 from "path";
 import posixPath4 from "path/posix";
 var live = /* @__PURE__ */ new Map();
 function brainEventsFilePath(dir, chatId) {
@@ -20021,8 +20204,8 @@ function brainEventsStatePath(chatId) {
 }
 function lastPersistedSeq(dir, chatId) {
   const p = brainEventsFilePath(dir, chatId);
-  if (!fs46.existsSync(p)) return 0;
-  const lines = fs46.readFileSync(p, "utf-8").split("\n").filter(Boolean);
+  if (!fs47.existsSync(p)) return 0;
+  const lines = fs47.readFileSync(p, "utf-8").split("\n").filter(Boolean);
   if (lines.length === 0) return 0;
   try {
     return JSON.parse(lines[lines.length - 1]).seq || 0;
@@ -20032,9 +20215,9 @@ function lastPersistedSeq(dir, chatId) {
 }
 function readSince(dir, chatId, since) {
   const p = brainEventsFilePath(dir, chatId);
-  if (!fs46.existsSync(p)) return [];
+  if (!fs47.existsSync(p)) return [];
   const out = [];
-  for (const line of fs46.readFileSync(p, "utf-8").split("\n")) {
+  for (const line of fs47.readFileSync(p, "utf-8").split("\n")) {
     if (!line) continue;
     try {
       const rec = JSON.parse(line);
@@ -20060,12 +20243,12 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = brainEventsFilePath(dir, chatId);
-  fs46.mkdirSync(path45.dirname(p), { recursive: true });
+  fs47.mkdirSync(path46.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
     try {
-      fs46.appendFileSync(p, `${JSON.stringify(rec)}
+      fs47.appendFileSync(p, `${JSON.stringify(rec)}
 `);
     } catch (err) {
       process.stderr.write(
@@ -20104,7 +20287,7 @@ function endTurnIfUnterminated(dir, chatId, errMessage) {
     event: { type: "error", error: errMessage || "turn ended unexpectedly", chatId }
   };
   try {
-    fs46.appendFileSync(brainEventsFilePath(dir, chatId), `${JSON.stringify(rec)}
+    fs47.appendFileSync(brainEventsFilePath(dir, chatId), `${JSON.stringify(rec)}
 `);
   } catch {
   }
@@ -20410,7 +20593,7 @@ async function handleChatTurn(req, res, chatId, opts) {
       );
     }
   }
-  fs47.mkdirSync(path46.dirname(sessionFile), { recursive: true });
+  fs48.mkdirSync(path47.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
     role: "user",
     content: message,
@@ -20475,7 +20658,7 @@ async function handleChatTurn(req, res, chatId, opts) {
 function buildServer(opts) {
   const runTurn = opts.runTurn ?? runChatTurn;
   const cloneRepo = opts.cloneRepo ?? defaultCloneRepo;
-  const reposRoot = opts.reposRoot ?? path46.join(path46.dirname(path46.resolve(opts.cwd)), "repos");
+  const reposRoot = opts.reposRoot ?? path47.join(path47.dirname(path47.resolve(opts.cwd)), "repos");
   return createServer(async (req, res) => {
     if (!req.method || !req.url) {
       sendJson(res, 400, { error: "bad request" });
@@ -21070,8 +21253,8 @@ async function loadConfigSafe() {
 }
 
 // src/chat-cli.ts
-import * as fs49 from "fs";
-import * as path48 from "path";
+import * as fs50 from "fs";
+import * as path49 from "path";
 
 // src/chat/inbox.ts
 import { execFileSync as execFileSync26 } from "child_process";
@@ -21143,8 +21326,8 @@ function currentBranch(cwd) {
 
 // src/chat/state-sync.ts
 init_stateRepo();
-import * as fs48 from "fs";
-import * as path47 from "path";
+import * as fs49 from "fs";
+import * as path48 from "path";
 function jsonlLines2(text) {
   return text.split("\n").filter((line) => line.length > 0);
 }
@@ -21161,15 +21344,15 @@ function mergeJsonl2(localText, remoteText) {
 function syncJsonlFileFromState(opts) {
   const remote = readStateText(opts.config, opts.cwd, opts.statePath);
   if (!remote) return;
-  const local = fs48.existsSync(opts.localPath) ? fs48.readFileSync(opts.localPath, "utf-8") : "";
+  const local = fs49.existsSync(opts.localPath) ? fs49.readFileSync(opts.localPath, "utf-8") : "";
   const next = mergeJsonl2(local, remote.content);
   if (next === local) return;
-  fs48.mkdirSync(path47.dirname(opts.localPath), { recursive: true });
-  fs48.writeFileSync(opts.localPath, next);
+  fs49.mkdirSync(path48.dirname(opts.localPath), { recursive: true });
+  fs49.writeFileSync(opts.localPath, next);
 }
 function persistJsonlFileToState(opts) {
-  if (!fs48.existsSync(opts.localPath)) return;
-  const localText = fs48.readFileSync(opts.localPath, "utf-8");
+  if (!fs49.existsSync(opts.localPath)) return;
+  const localText = fs49.readFileSync(opts.localPath, "utf-8");
   for (let attempt = 1; attempt <= 3; attempt += 1) {
     const remote = readStateText(opts.config, opts.cwd, opts.statePath);
     const body = mergeJsonl2(localText, remote?.content ?? "");
@@ -21429,7 +21612,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path48.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path49.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -21490,7 +21673,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs49.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs50.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {
@@ -21650,8 +21833,8 @@ var FlyClient = class {
   get fetch() {
     return this.opts.fetchImpl ?? fetch;
   }
-  async call(path49, init = {}) {
-    const res = await this.fetch(`${FLY_API_BASE}${path49}`, {
+  async call(path50, init = {}) {
+    const res = await this.fetch(`${FLY_API_BASE}${path50}`, {
       method: init.method ?? "GET",
       headers: {
         Authorization: `Bearer ${this.opts.token}`,
@@ -21662,7 +21845,7 @@ var FlyClient = class {
     if (res.status === 404 && init.allow404) return null;
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      throw new Error(`Fly API ${res.status} on ${path49}: ${text.slice(0, 200) || res.statusText}`);
+      throw new Error(`Fly API ${res.status} on ${path50}: ${text.slice(0, 200) || res.statusText}`);
     }
     if (res.status === 204) return null;
     const raw = await res.text();
@@ -22377,7 +22560,7 @@ async function poolServe() {
 
 // src/servers/runner-serve.ts
 import { spawn as spawn8 } from "child_process";
-import * as fs50 from "fs";
+import * as fs51 from "fs";
 import { createServer as createServer5 } from "http";
 var DEFAULT_PORT2 = 8080;
 var DEFAULT_WORKDIR = "/workspace/repo";
@@ -22446,6 +22629,9 @@ function parseJob(body) {
   }
   if (typeof b.ref === "string" && b.ref.trim()) job.ref = b.ref.trim();
   if (typeof b.model === "string" && b.model.trim()) job.model = b.model.trim();
+  if (typeof b.reasoningEffort === "string" && b.reasoningEffort.trim()) job.reasoningEffort = b.reasoningEffort.trim();
+  if (typeof b.action === "string" && b.action.trim()) job.action = b.action.trim();
+  if (typeof b.message === "string" && b.message.trim()) job.message = b.message.trim();
   if (typeof b.sessionId === "string" && b.sessionId.trim()) job.sessionId = b.sessionId.trim();
   if (typeof b.dashboardUrl === "string" && b.dashboardUrl.trim()) job.dashboardUrl = b.dashboardUrl.trim();
   if (b.allSecrets && (typeof b.allSecrets === "object" || typeof b.allSecrets === "string")) {
@@ -22457,19 +22643,23 @@ 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`;
-  fs50.rmSync(workdir, { recursive: true, force: true });
-  fs50.mkdirSync(workdir, { recursive: true });
+  fs51.rmSync(workdir, { recursive: true, force: true });
+  fs51.mkdirSync(workdir, { recursive: true });
   const allSecrets = typeof job.allSecrets === "string" ? job.allSecrets : JSON.stringify(job.allSecrets ?? {});
   const interactive = job.mode === "interactive";
   const scheduled = job.mode === "scheduled";
+  const runMode = interactive ? "interactive" : scheduled ? "scheduled" : "issue";
   const childEnv = {
     ...process.env,
     REPO: job.repo,
     REF: branch,
     GITHUB_TOKEN: job.githubToken,
+    KODY_RUN_MODE: runMode,
     // Scheduled mode drives the engine down the same path GitHub Actions' cron
     // takes (runScheduledFanOut → due capabilities/goals). Bare `kody` routes on this.
     ...scheduled ? { GITHUB_EVENT_NAME: "schedule" } : {},
+    ...job.action ? { KODY_FORCE_ACTION: job.action } : {},
+    ...job.message ? { KODY_FORCE_MESSAGE: job.message } : {},
     // GITHUB_REPOSITORY + GH_TOKEN are normally injected by GitHub Actions.
     // The engine's interactive mode needs GITHUB_REPOSITORY to resolve the
     // configured state repo and persist chat.ready / events (the durable signal
@@ -22477,13 +22667,14 @@ async function defaultRunJob(job) {
     // and the session never appears "ready". GH_TOKEN auths the `gh` CLI.
     GITHUB_REPOSITORY: job.repo,
     GH_TOKEN: job.githubToken,
-    // Issue mode bakes ISSUE_NUMBER → `kody run --issue N`. Interactive mode
-    // leaves it empty and sets SESSION_ID so the engine boots a chat session.
+    // Issue mode carries ISSUE_NUMBER. Interactive mode leaves it empty and
+    // sets SESSION_ID so the engine boots a chat session.
     ISSUE_NUMBER: interactive || scheduled ? "" : String(job.issueNumber),
     ALL_SECRETS: allSecrets,
     SESSION_ID: job.sessionId ?? "",
     DASHBOARD_URL: job.dashboardUrl ?? "",
     MODEL: job.model ?? "",
+    REASONING_EFFORT: job.reasoningEffort ?? "",
     ...interactive && job.idleExitMs ? { KODY_IDLE_EXIT_MS: String(job.idleExitMs) } : {},
     ...interactive && job.hardCapMs ? { KODY_HARD_CAP_MS: String(job.hardCapMs) } : {}
   };
@@ -22509,11 +22700,10 @@ async function defaultRunJob(job) {
   const authorEmail = process.env.GIT_AUTHOR_EMAIL ?? "kody-bot@users.noreply.github.com";
   await run("git", ["config", "user.name", authorName], workdir);
   await run("git", ["config", "user.email", authorEmail], workdir);
-  const runArgs = interactive || scheduled ? [] : ["run", "--issue", String(job.issueNumber)];
   const jobDesc = interactive ? `interactive session ${job.sessionId}` : scheduled ? "scheduled fan-out" : `running issue #${job.issueNumber}`;
   process.stdout.write(`[runner-serve] job ${job.jobId}: ${jobDesc}
 `);
-  const runCode = await run("kody", runArgs, workdir);
+  const runCode = await run("kody", [], workdir);
   process.stdout.write(`[runner-serve] job ${job.jobId}: finished (exit ${runCode})
 `);
   process.exit(runCode);
@@ -22903,6 +23093,25 @@ function formatMs(ms) {
 }
 
 // src/entry.ts
+function envRunMode(env = process.env) {
+  const result = { command: "help", errors: [] };
+  const mode = (env.KODY_RUN_MODE ?? "").trim().toLowerCase();
+  if (!mode) return null;
+  if (mode === "chat" || mode === "interactive") {
+    return { ...result, command: "chat", chatArgv: [] };
+  }
+  if (mode === "ci" || mode === "scheduled" || mode === "manual") {
+    return { ...result, command: "ci", ciArgv: [] };
+  }
+  if (mode === "issue") {
+    const issue = (env.ISSUE_NUMBER ?? "").trim();
+    if (!issue) {
+      return { ...result, errors: ["KODY_RUN_MODE=issue requires ISSUE_NUMBER"] };
+    }
+    return { ...result, command: "ci", ciArgv: ["--issue", issue] };
+  }
+  return { ...result, errors: [`unknown KODY_RUN_MODE: ${mode}`] };
+}
 var HELP_TEXT = `kody-engine \u2014 single-session autonomous engineer
 
 Usage:
@@ -22939,6 +23148,8 @@ Exit codes:
 function parseArgs(argv) {
   const result = { command: "help", errors: [] };
   if (argv.length === 0) {
+    const mode = envRunMode();
+    if (mode) return mode;
     if (process.env.SESSION_ID) return { ...result, command: "chat", chatArgv: [] };
     if (process.env.GITHUB_EVENT_NAME) return { ...result, command: "ci", ciArgv: [] };
     return result;