@kody-ade/kody-engine 0.4.244 → 0.4.246

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.244",
+      version: "0.4.246",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative agentAction profiles.",
       license: "MIT",
       type: "module",
@@ -194,8 +194,8 @@ function isRunningAsBot() {
 }
 function postIssueComment(issueNumber, body, cwd) {
   if (isRunningAsBot()) {
-    const slug = detectBotDispatchShape(body);
-    if (slug) throw new BotDispatchCommentError(slug);
+    const slug2 = detectBotDispatchShape(body);
+    if (slug2) throw new BotDispatchCommentError(slug2);
   }
   try {
     gh(["issue", "comment", String(issueNumber), "--body-file", "-"], { input: stripKodyMentions(body), cwd });
@@ -295,8 +295,8 @@ function getPrLatestReviewBody(prNumber, cwd) {
 }
 function postPrReviewComment(prNumber, body, cwd) {
   if (isRunningAsBot()) {
-    const slug = detectBotDispatchShape(body);
-    if (slug) throw new BotDispatchCommentError(slug);
+    const slug2 = detectBotDispatchShape(body);
+    if (slug2) throw new BotDispatchCommentError(slug2);
   }
   try {
     gh(["pr", "comment", String(prNumber), "--body-file", "-"], { input: stripKodyMentions(body), cwd });
@@ -313,9 +313,9 @@ var init_issue = __esm({
     "use strict";
     API_TIMEOUT_MS = 3e4;
     BotDispatchCommentError = class extends Error {
-      constructor(slug) {
+      constructor(slug2) {
         super(
-          `bot self-dispatch via @kody comments is banned. Refusing to post "@kody ${slug} \u2026" \u2014 use runAgentActionChain (same-run) or dispatchAgentAction (cross-run) instead. See docs/agent-responsibility-dispatch.md for the contract.`
+          `bot self-dispatch via @kody comments is banned. Refusing to post "@kody ${slug2} \u2026" \u2014 use runAgentActionChain (same-run) or dispatchAgentAction (cross-run) instead. See docs/agent-responsibility-dispatch.md for the contract.`
         );
         this.name = "BotDispatchCommentError";
       }
@@ -332,8 +332,8 @@ function is404(err) {
   const msg = err instanceof Error ? err.message : String(err);
   return /HTTP 404/i.test(msg) || /Not Found/i.test(msg);
 }
-function parseStateRepoSlug(slug, field = "stateRepo") {
-  const value = slug.trim();
+function parseStateRepoSlug(slug2, field = "stateRepo") {
+  const value = slug2.trim();
   let repoPath = value;
   if (/^https?:\/\//i.test(value)) {
     let parsed;
@@ -460,6 +460,18 @@ function appendStateLine(config, cwd, filePath, line, message) {
 `}`;
   writeStateText(config, cwd, filePath, next, message, prior?.sha);
 }
+function listStateDirectory(config, cwd, dirPath) {
+  const targetPath = stateRepoPath(config, dirPath);
+  let raw = "";
+  try {
+    raw = gh(["api", apiPath(config, targetPath)], { cwd });
+  } catch (err) {
+    if (is404(err)) return [];
+    throw err;
+  }
+  const parsed = JSON.parse(raw);
+  return Array.isArray(parsed) ? parsed : [];
+}
 var init_stateRepo = __esm({
   "src/stateRepo.ts"() {
     "use strict";
@@ -619,11 +631,11 @@ function parseGoalActivations(raw) {
   const seen = /* @__PURE__ */ new Set();
   for (const value of raw) {
     if (typeof value === "string") {
-      const slug = parseSlug(value, "company.activeGoals");
-      if (!slug) continue;
-      if (!seen.has(slug)) {
-        seen.add(slug);
-        out.push(slug);
+      const slug2 = parseSlug(value, "company.activeGoals");
+      if (!slug2) continue;
+      if (!seen.has(slug2)) {
+        seen.add(slug2);
+        out.push(slug2);
       }
       continue;
     }
@@ -658,20 +670,20 @@ function parseSlugArray(raw, field) {
   if (!Array.isArray(raw)) throw new Error(`kody.config.json: ${field} must be an array of strings`);
   const out = [];
   for (const value of raw) {
-    const slug = parseSlug(value, field);
-    if (!slug) continue;
-    out.push(slug);
+    const slug2 = parseSlug(value, field);
+    if (!slug2) continue;
+    out.push(slug2);
   }
   return [...new Set(out)];
 }
 function parseSlug(value, field) {
   if (typeof value !== "string") throw new Error(`kody.config.json: ${field} entries must be strings`);
-  const slug = value.trim();
-  if (!slug) return "";
-  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(slug)) {
+  const slug2 = value.trim();
+  if (!slug2) return "";
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(slug2)) {
     throw new Error(`kody.config.json: ${field} contains invalid slug "${value}"`);
   }
-  return slug;
+  return slug2;
 }
 function recordValue(raw) {
   return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : void 0;
@@ -2303,56 +2315,6 @@ var init_agent = __esm({
   }
 });
 
-// src/scripts/scheduleEvery.ts
-function isScheduleEvery(value) {
-  return typeof value === "string" && SCHEDULE_EVERY_VALUES.includes(value);
-}
-function scheduleEveryToMs(every) {
-  const MIN = 60 * 1e3;
-  const HOUR = 60 * MIN;
-  const DAY = 24 * HOUR;
-  switch (every) {
-    case "15m":
-      return 15 * MIN;
-    case "30m":
-      return 30 * MIN;
-    case "1h":
-      return HOUR;
-    case "2h":
-      return 2 * HOUR;
-    case "6h":
-      return 6 * HOUR;
-    case "12h":
-      return 12 * HOUR;
-    case "1d":
-      return DAY;
-    case "3d":
-      return 3 * DAY;
-    case "7d":
-      return 7 * DAY;
-    case "manual":
-      return Number.POSITIVE_INFINITY;
-  }
-}
-var SCHEDULE_EVERY_VALUES;
-var init_scheduleEvery = __esm({
-  "src/scripts/scheduleEvery.ts"() {
-    "use strict";
-    SCHEDULE_EVERY_VALUES = [
-      "15m",
-      "30m",
-      "1h",
-      "2h",
-      "6h",
-      "12h",
-      "1d",
-      "3d",
-      "7d",
-      "manual"
-    ];
-  }
-});
-
 // src/agent-responsibilityFolders.ts
 import * as fs6 from "fs";
 import * as path8 from "path";
@@ -2369,8 +2331,8 @@ function listAgentResponsibilityFolderSlugs(absDir) {
 function isAgentResponsibilityFolder(dir) {
   return fs6.existsSync(path8.join(dir, AGENT_RESPONSIBILITY_PROFILE_FILE)) && fs6.existsSync(path8.join(dir, AGENT_RESPONSIBILITY_BODY_FILE));
 }
-function readAgentResponsibilityFolder(root, slug) {
-  const dir = path8.join(root, slug);
+function readAgentResponsibilityFolder(root, slug2) {
+  const dir = path8.join(root, slug2);
   const profilePath = path8.join(dir, AGENT_RESPONSIBILITY_PROFILE_FILE);
   const bodyPath = path8.join(dir, AGENT_RESPONSIBILITY_BODY_FILE);
   if (!fs6.existsSync(profilePath) || !fs6.statSync(profilePath).isFile()) return null;
@@ -2378,9 +2340,9 @@ function readAgentResponsibilityFolder(root, slug) {
   try {
     const rawProfile = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
     const rawBody = fs6.readFileSync(bodyPath, "utf-8");
-    const { title, body } = parseAgentResponsibilityBody(rawBody, slug);
+    const { title, body } = parseAgentResponsibilityBody(rawBody, slug2);
     return {
-      slug,
+      slug: slug2,
       dir,
       profilePath,
       bodyPath,
@@ -2399,7 +2361,6 @@ function parseAgentResponsibilityConfig(raw) {
   return {
     action: stringField(raw.action),
     agentAction: stringField(raw.agentAction),
-    every: isScheduleEvery(raw.every) ? raw.every : void 0,
     tickScript: stringField(raw.tickScript),
     disabled: typeof raw.disabled === "boolean" ? raw.disabled : void 0,
     agent: stringField(raw.agent),
@@ -2413,11 +2374,11 @@ function parseAgentResponsibilityConfig(raw) {
     writesTo: stringList(raw.writesTo ?? raw.writes_to)
   };
 }
-function parseAgentResponsibilityBody(raw, slug) {
+function parseAgentResponsibilityBody(raw, slug2) {
   const trimmed = raw.trim();
   const firstLine2 = trimmed.split("\n", 1)[0] ?? "";
   const h1 = /^#\s+(.+?)\s*$/.exec(firstLine2);
-  const title = h1 ? h1[1].trim() : humanizeSlug(slug);
+  const title = h1 ? h1[1].trim() : humanizeSlug(slug2);
   const body = stripLeadingH1(raw);
   return { title, body };
 }
@@ -2431,8 +2392,8 @@ function stripLeadingH1(raw) {
   }
   return lines.slice(i).join("\n");
 }
-function humanizeSlug(slug) {
-  return slug.split(/[-_]+/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+function humanizeSlug(slug2) {
+  return slug2.split(/[-_]+/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
 }
 function stringField(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
@@ -2454,7 +2415,6 @@ var AGENT_RESPONSIBILITY_PROFILE_FILE, AGENT_RESPONSIBILITY_BODY_FILE;
 var init_agent_responsibilityFolders = __esm({
   "src/agent-responsibilityFolders.ts"() {
     "use strict";
-    init_scheduleEvery();
     AGENT_RESPONSIBILITY_PROFILE_FILE = "profile.json";
     AGENT_RESPONSIBILITY_BODY_FILE = "agent-responsibility.md";
   }
@@ -2680,10 +2640,10 @@ function resolveAgentResponsibilityAction(action, projectAgentResponsibilitiesRo
 function hasAgentResponsibilityAction(action, projectAgentResponsibilitiesRoot = getProjectAgentResponsibilitiesRoot()) {
   return resolveAgentResponsibilityAction(action, projectAgentResponsibilitiesRoot) !== null;
 }
-function resolveAgentResponsibilityFolder(slug, projectAgentResponsibilitiesRoot = getProjectAgentResponsibilitiesRoot()) {
-  if (!isSafeName(slug)) return null;
+function resolveAgentResponsibilityFolder(slug2, projectAgentResponsibilitiesRoot = getProjectAgentResponsibilitiesRoot()) {
+  if (!isSafeName(slug2)) return null;
   for (const root of getAgentResponsibilityRoots(projectAgentResponsibilitiesRoot)) {
-    const agentResponsibility = readAgentResponsibilityFolder(root, slug);
+    const agentResponsibility = readAgentResponsibilityFolder(root, slug2);
     if (agentResponsibility) return agentResponsibility;
   }
   return null;
@@ -2742,15 +2702,15 @@ function listAgentActionResponsibilityActions(root, source) {
 function listFolderAgentResponsibilityActions(root, source) {
   if (!fs8.existsSync(root) || !fs8.statSync(root).isDirectory()) return [];
   const out = [];
-  for (const slug of listAgentResponsibilityFolderSlugs(root)) {
-    if (!isSafeName(slug)) continue;
-    const agentResponsibility = readAgentResponsibilityFolder(root, slug);
+  for (const slug2 of listAgentResponsibilityFolderSlugs(root)) {
+    if (!isSafeName(slug2)) continue;
+    const agentResponsibility = readAgentResponsibilityFolder(root, slug2);
     if (!agentResponsibility) continue;
-    const action = agentResponsibility.config.action ?? slug;
+    const action = agentResponsibility.config.action ?? slug2;
     const { agentAction, cliArgs } = resolveAgentResponsibilityExecution(agentResponsibility);
     out.push({
       action,
-      agentResponsibility: slug,
+      agentResponsibility: slug2,
       agentAction,
       cliArgs,
       source,
@@ -2765,15 +2725,15 @@ function listFolderAgentResponsibilityActions(root, source) {
 function listBuiltinAgentResponsibilityActions(root = getBuiltinAgentResponsibilitiesRoot()) {
   if (!fs8.existsSync(root) || !fs8.statSync(root).isDirectory()) return [];
   const out = [];
-  for (const slug of listAgentResponsibilityFolderSlugs(root)) {
-    if (!isSafeName(slug)) continue;
-    const agentResponsibility = readAgentResponsibilityFolder(root, slug);
+  for (const slug2 of listAgentResponsibilityFolderSlugs(root)) {
+    if (!isSafeName(slug2)) continue;
+    const agentResponsibility = readAgentResponsibilityFolder(root, slug2);
     if (!agentResponsibility) continue;
-    const action = agentResponsibility.config.action ?? slug;
-    const agentAction = agentResponsibility.config.agentAction ?? slug;
+    const action = agentResponsibility.config.action ?? slug2;
+    const agentAction = agentResponsibility.config.agentAction ?? slug2;
     out.push({
       action,
-      agentResponsibility: slug,
+      agentResponsibility: slug2,
       agentAction,
       cliArgs: {},
       source: "builtin",
@@ -3199,8 +3159,8 @@ function stripFrontmatter(raw) {
   const match = /^---\n[\s\S]*?\n---\n?([\s\S]*)$/.exec(raw);
   return (match ? match[1] : raw).trim();
 }
-function loadAgentIdentity(cwd, slug, agentsDir = DEFAULT_AGENT_DIR) {
-  const trimmed = slug.trim();
+function loadAgentIdentity(cwd, slug2, agentsDir = DEFAULT_AGENT_DIR) {
+  const trimmed = slug2.trim();
   if (!trimmed) throw new Error("loadAgentIdentity: empty agent slug");
   const agentPath = resolveAgentFile(cwd, trimmed, agentsDir);
   if (fs16.existsSync(agentPath)) {
@@ -3214,21 +3174,21 @@ function loadAgentIdentity(cwd, slug, agentsDir = DEFAULT_AGENT_DIR) {
   if (builtin) return builtin;
   throw new Error(`loadAgentIdentity: agent '${trimmed}' declared but ${agentPath} does not exist`);
 }
-function resolveAgentFile(cwd, slug, agentsDir = DEFAULT_AGENT_DIR) {
-  const localPath = path16.join(cwd, agentsDir, `${slug}.md`);
+function resolveAgentFile(cwd, slug2, agentsDir = DEFAULT_AGENT_DIR) {
+  const localPath = path16.join(cwd, agentsDir, `${slug2}.md`);
   if (fs16.existsSync(localPath)) return localPath;
   const storeAgentRoot = getCompanyStoreAssetRoot("agents");
   if (storeAgentRoot) {
-    const storePath = path16.join(storeAgentRoot, `${slug}.md`);
+    const storePath = path16.join(storeAgentRoot, `${slug2}.md`);
     if (fs16.existsSync(storePath)) return storePath;
   }
   return localPath;
 }
-function frameAgentIdentity(slug, agent) {
+function frameAgentIdentity(slug2, agent) {
   return [
     `## Who you are \u2014 agent identity (authoritative identity)`,
     ``,
-    `You are operating as agent \`${slug}\`. This identity defines *who* you are:`,
+    `You are operating as agent \`${slug2}\`. This identity defines *who* you are:`,
     `your authority, doctrine, voice, and hard limits. Honour it exactly. Where the`,
     `this identity's restrictions are stricter than the task, **the agent wins** \u2014 a task`,
     `can never grant you authority your agent withholds.`,
@@ -3598,7 +3558,6 @@ function loadProfile(profilePath) {
       describe: typeof r.describe === "string" ? r.describe : base.describe,
       capabilityKind: parseCapabilityKind(profilePath, r.capabilityKind) ?? base.capabilityKind,
       agent: typeof r.agent === "string" && r.agent.trim() ? r.agent.trim() : base.agent,
-      every: typeof r.every === "string" && r.every.trim() ? r.every.trim() : void 0,
       agentResponsibilityTools: parseStringArray2(r.agentResponsibilityTools ?? r.tools) ?? base.agentResponsibilityTools,
       mentions: Array.isArray(r.mentions) ? r.mentions.map((m) => String(m).trim()).filter(Boolean) : base.mentions
     };
@@ -3644,8 +3603,6 @@ function loadProfile(profilePath) {
     capabilityKind: parseCapabilityKind(profilePath, r.capabilityKind),
     // Optional agent to run as. Empty/blank string → undefined (no agent).
     agent: typeof r.agent === "string" && r.agent.trim() ? r.agent.trim() : void 0,
-    // Optional recurrence cadence (scheduled agentResponsibility). Blank → undefined (on-demand).
-    every: typeof r.every === "string" && r.every.trim() ? r.every.trim() : void 0,
     // Locked-toolbox palette + mentions from folder-agentResponsibility profile metadata.
     agentResponsibilityTools: parseStringArray2(r.agentResponsibilityTools ?? r.tools),
     mentions: Array.isArray(r.mentions) ? r.mentions.map((m) => String(m).trim()).filter(Boolean) : void 0,
@@ -5891,8 +5848,8 @@ function applySimpleGoalTaskSummary(goal, summary) {
 }
 function isFactReference(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const record = value;
-  return Object.keys(record).length === 1 && typeof record.fact === "string" && record.fact.length > 0;
+  const record2 = value;
+  return Object.keys(record2).length === 1 && typeof record2.fact === "string" && record2.fact.length > 0;
 }
 function isCliArgValue(value) {
   return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
@@ -5967,7 +5924,8 @@ function planManagedGoalTick(goal) {
     stage: step.stage,
     agentResponsibility: step.agentResponsibility,
     agentAction: step.agentAction,
-    cliArgs: resolved.cliArgs
+    cliArgs: resolved.cliArgs,
+    ...step.saveReport === true ? { saveReport: true } : {}
   };
 }
 function asStringArray(value) {
@@ -5994,11 +5952,26 @@ function asRoute(value) {
       stage: raw.stage,
       agentResponsibility: raw.agentResponsibility,
       agentAction: typeof raw.agentAction === "string" ? raw.agentAction : void 0,
-      args: args ?? void 0
+      args: args ?? void 0,
+      saveReport: raw.saveReport === true
     });
   }
   return route;
 }
+function asPreferredRunTime(value) {
+  const raw = asRecord(value);
+  if (!raw) return void 0;
+  if (typeof raw.time !== "string" || !/^([01]\d|2[0-3]):[0-5]\d$/.test(raw.time)) return void 0;
+  if (typeof raw.timezone !== "string" || raw.timezone.trim().length === 0) return void 0;
+  return { time: raw.time, timezone: raw.timezone };
+}
+function asLoopTarget(value) {
+  const raw = asRecord(value);
+  if (!raw) return void 0;
+  if (raw.type !== "goal" && raw.type !== "agentResponsibility") return void 0;
+  if (typeof raw.id !== "string" || raw.id.trim().length === 0) return void 0;
+  return { type: raw.type, id: raw.id };
+}
 function managedGoalFromState(state) {
   const extra = state.extra;
   const destination = asRecord(extra.destination);
@@ -6015,6 +5988,9 @@ function managedGoalFromState(state) {
     destination: { outcome: destination.outcome, evidence },
     agentResponsibilities,
     route,
+    schedule: typeof extra.schedule === "string" ? extra.schedule : void 0,
+    preferredRunTime: asPreferredRunTime(extra.preferredRunTime),
+    loopTarget: asLoopTarget(extra.loopTarget),
     stage: typeof extra.stage === "string" ? extra.stage : void 0,
     facts,
     blockers
@@ -6088,10 +6064,10 @@ var init_state2 = __esm({
     "use strict";
     VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "done"]);
     GoalStateError = class extends Error {
-      constructor(path47, message) {
-        super(`Invalid goal state at ${path47}:
+      constructor(path46, message) {
+        super(`Invalid goal state at ${path46}:
   ${message}`);
-        this.path = path47;
+        this.path = path46;
         this.name = "GoalStateError";
       }
       path;
@@ -6336,8 +6312,8 @@ function isStateUnchanged(prev, next) {
   if (prev.done !== next.done) return false;
   return JSON.stringify(prev.data) === JSON.stringify(next.data);
 }
-function stateFilePath(jobsDir, slug) {
-  return `${jobsDir.replace(/\/+$/, "")}/${slug}/state.json`;
+function stateFilePath(jobsDir, slug2) {
+  return `${jobsDir.replace(/\/+$/, "")}/${slug2}/state.json`;
 }
 function slugFromStateFilePath(filePath) {
   if (/\/state\.json$/i.test(filePath)) {
@@ -6379,8 +6355,8 @@ var init_contentsApiBackend = __esm({
         this.jobsDir = stateRepoJobsDir(opts.jobsDir);
         this.cwd = opts.cwd;
       }
-      load(slug) {
-        const filePath = stateFilePath(this.jobsDir, slug);
+      load(slug2) {
+        const filePath = stateFilePath(this.jobsDir, slug2);
         const loaded = readStateText(this.config, this.cwd, filePath);
         if (!loaded) {
           return { path: filePath, handle: null, state: initialStateEnvelope("seed"), created: true };
@@ -6400,20 +6376,20 @@ var init_contentsApiBackend = __esm({
         if (!loaded.created && isStateUnchanged(loaded.state, next)) {
           return false;
         }
-        const slug = slugFromStateFilePath(loaded.path);
+        const slug2 = slugFromStateFilePath(loaded.path);
         const body = `${JSON.stringify(next, null, 2)}
 `;
-        const message = `chore(jobs): update state for ${slug} (rev ${next.rev})`;
+        const message = `chore(jobs): update state for ${slug2} (rev ${next.rev})`;
         const sha = typeof loaded.handle === "string" ? loaded.handle : void 0;
         try {
           writeStateText(this.config, this.cwd, loaded.path, body, message, sha);
         } catch (err) {
           if (!isShaConflict(err)) throw err;
-          const current = this.load(slug);
+          const current = this.load(slug2);
           if (!current.created && isStateUnchanged(current.state, next)) return false;
           const currentSha = typeof current.handle === "string" ? current.handle : void 0;
           process.stderr.write(
-            `[kody] jobState: concurrent write detected for ${slug}; reloaded SHA and retrying (last-write-wins)
+            `[kody] jobState: concurrent write detected for ${slug2}; reloaded SHA and retrying (last-write-wins)
 `
           );
           writeStateText(this.config, this.cwd, loaded.path, body, message, currentSha);
@@ -6540,8 +6516,8 @@ var init_localFileBackend = __esm({
 `);
         }
       }
-      load(slug) {
-        const relPath = stateFilePath(this.jobsDir, slug);
+      load(slug2) {
+        const relPath = stateFilePath(this.jobsDir, slug2);
         const absPath = path24.join(this.cwd, relPath);
         if (!fs25.existsSync(absPath)) {
           return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
@@ -6613,29 +6589,63 @@ import * as path25 from "path";
 function isAgentResponsibilityCadenceGoal(goal, extra) {
   return extra.scheduleMode === "agentLoop" || extra.scheduler === "agentLoop" || goal.type === "standing" && goal.agentResponsibilities.length > 0;
 }
-async function planGoalAgentResponsibilitySchedule(opts) {
+function isGoalTargetLoop(goal) {
+  return goal.type === "agentLoop" && goal.loopTarget?.type === "goal" && goal.loopTarget.id.trim().length > 0;
+}
+function planGoalTargetLoopSchedule(opts) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const at = now.toISOString();
+  const targetId = opts.goal.loopTarget?.type === "goal" ? opts.goal.loopTarget.id.trim() : "";
+  if (!targetId) {
+    const reason = "goal target loop missing target goal";
+    return targetLoopDecision("blocked", reason, at);
+  }
+  const preferred = opts.goal.preferredRunTime;
+  if (preferred) {
+    const gate = preferredRunTimeGate(preferred, now, opts.previousScheduleState);
+    if (!gate.ok) return targetLoopDecision("idle", gate.reason, at);
+  }
+  return {
+    kind: "dispatch",
+    reason: `dispatch goal ${targetId}`,
+    dispatch: { action: "goal-manager", agentAction: "goal-manager", cliArgs: { goal: targetId } },
+    scheduleState: {
+      mode: "agentLoop",
+      lastGoalTickAt: at,
+      lastDecision: {
+        kind: "dispatch",
+        targetType: "goal",
+        targetId,
+        agentAction: "goal-manager",
+        reason: preferred ? `preferred time ${preferred.time} ${preferred.timezone}` : "ready target loop tick",
+        at
+      },
+      agentResponsibilities: {}
+    }
+  };
+}
+async function planGoalAgentResponsibilitySchedule(opts) {
   const jobsDir = opts.jobsDir ?? ".kody/agent-responsibilities";
   const jobsRoot = path25.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 });
   const statuses = {};
   const blockers = [];
-  for (const slug of opts.goal.agentResponsibilities) {
-    const agentResponsibility2 = resolveAgentResponsibilityFolder(slug, jobsRoot);
+  for (const slug2 of opts.goal.agentResponsibilities) {
+    const agentResponsibility2 = resolveAgentResponsibilityFolder(slug2, jobsRoot);
     const status = await describeAgentResponsibilitySchedule(
       agentResponsibility2,
-      slug,
+      slug2,
       backend,
-      now.getTime(),
-      opts.previousScheduleState?.agentResponsibilities[slug]
+      opts.previousScheduleState?.agentResponsibilities[slug2]
     );
-    statuses[slug] = status;
-    if (status.state === "blocked") blockers.push(`${slug}: ${status.reason}`);
+    statuses[slug2] = status;
+    if (status.state === "blocked") blockers.push(`${slug2}: ${status.reason}`);
   }
-  const due = opts.goal.agentResponsibilities.map((slug) => statuses[slug]).find((status) => status?.state === "due");
+  const due = opts.goal.agentResponsibilities.map((slug2) => statuses[slug2]).filter((status) => status?.state === "due").sort(compareOldestLastFired)[0];
   if (!due) {
-    const reason = blockers.length > 0 ? "no runnable due agentResponsibility; blocked agentResponsibilities need attention" : "no agentResponsibility due now";
+    const reason = blockers.length > 0 ? "no runnable agentResponsibility; blocked agentResponsibilities need attention" : "no runnable agentResponsibility";
     const kind = blockers.length > 0 ? "blocked" : "idle";
     return {
       kind,
@@ -6682,29 +6692,19 @@ async function planGoalAgentResponsibilitySchedule(opts) {
     }
   };
 }
-async function describeAgentResponsibilitySchedule(agentResponsibility, slug, backend, now, previous) {
-  if (!agentResponsibility) return { slug, state: "blocked", reason: "agentResponsibility folder missing" };
+async function describeAgentResponsibilitySchedule(agentResponsibility, slug2, backend, previous) {
+  if (!agentResponsibility) return { slug: slug2, state: "blocked", reason: "agentResponsibility folder missing" };
   const { config } = agentResponsibility;
   if (config.disabled === true) {
-    return { slug, title: agentResponsibility.title, cadence: config.every, state: "disabled", reason: "disabled" };
-  }
-  if (config.every === "manual" || !config.every && !config.agent && config.agentAction) {
-    return { slug, title: agentResponsibility.title, cadence: config.every, state: "manual", reason: "manual only" };
+    return { slug: slug2, title: agentResponsibility.title, state: "disabled", reason: "disabled" };
   }
   if (!config.agent || config.agent.trim().length === 0) {
-    return {
-      slug,
-      title: agentResponsibility.title,
-      cadence: config.every,
-      state: "blocked",
-      reason: "no agent assigned"
-    };
+    return { slug: slug2, title: agentResponsibility.title, state: "blocked", reason: "no agent assigned" };
   }
   if (config.agentActions && config.agentActions.length > 1) {
     return {
-      slug,
+      slug: slug2,
       title: agentResponsibility.title,
-      cadence: config.every,
       state: "blocked",
       reason: "multi-agentAction agentResponsibility needs task-jobs route"
     };
@@ -6712,79 +6712,104 @@ async function describeAgentResponsibilitySchedule(agentResponsibility, slug, ba
   let lastFiredAt = validIso(previous?.lastFiredAt) ? previous?.lastFiredAt : void 0;
   try {
     if (!lastFiredAt) {
-      const loaded = await backend.load(slug);
+      const loaded = await backend.load(slug2);
       const raw = loaded.state.data?.lastFiredAt;
       if (typeof raw === "string" && validIso(raw)) lastFiredAt = raw;
     }
   } catch {
     return {
-      slug,
-      title: agentResponsibility.title,
-      cadence: config.every,
-      state: "due",
-      reason: "state unreadable; run to refresh"
-    };
-  }
-  if (!config.every) {
-    return {
-      slug,
+      slug: slug2,
       title: agentResponsibility.title,
       state: "due",
-      reason: "no cadence; check every goal tick",
-      lastFiredAt
-    };
-  }
-  if (!lastFiredAt) {
-    return {
-      slug,
-      title: agentResponsibility.title,
-      cadence: config.every,
-      state: "due",
-      reason: `first check for ${config.every}`
-    };
-  }
-  const last = Date.parse(lastFiredAt);
-  const interval = scheduleEveryToMs(config.every);
-  const next = new Date(last + interval).toISOString();
-  if (now - last >= interval) {
-    return {
-      slug,
-      title: agentResponsibility.title,
-      cadence: config.every,
-      state: "due",
-      reason: `due ${config.every}`,
-      lastFiredAt,
-      nextEligibleAt: next
+      reason: "state unreadable; ready for loop tick"
     };
   }
   return {
-    slug,
+    slug: slug2,
     title: agentResponsibility.title,
-    cadence: config.every,
-    state: "waiting",
-    reason: `next due ${next}`,
-    lastFiredAt,
-    nextEligibleAt: next
+    state: "due",
+    reason: "ready for loop tick",
+    lastFiredAt
   };
 }
 function dutyDispatch(agentResponsibility) {
   const { agentAction, cliArgs } = resolveAgentResponsibilityExecution(agentResponsibility);
   return { agentResponsibility: agentResponsibility.slug, agentAction, cliArgs };
 }
+function compareOldestLastFired(a, b) {
+  const aTime = validIso(a.lastFiredAt) ? Date.parse(a.lastFiredAt) : Number.NEGATIVE_INFINITY;
+  const bTime = validIso(b.lastFiredAt) ? Date.parse(b.lastFiredAt) : Number.NEGATIVE_INFINITY;
+  return aTime - bTime;
+}
 function validIso(value) {
   return typeof value === "string" && !Number.isNaN(Date.parse(value));
 }
 function markAgentResponsibilitySelected(status, now) {
-  const lastFiredAt = now.toISOString();
-  const nextEligibleAt = status.cadence && status.cadence !== "manual" ? new Date(now.getTime() + scheduleEveryToMs(status.cadence)).toISOString() : status.nextEligibleAt;
-  return { ...status, lastFiredAt, nextEligibleAt };
+  return { ...status, lastFiredAt: now.toISOString() };
+}
+function targetLoopDecision(kind, reason, at) {
+  return {
+    kind,
+    reason,
+    scheduleState: {
+      mode: "agentLoop",
+      lastGoalTickAt: at,
+      lastDecision: { kind, reason, at },
+      agentResponsibilities: {}
+    }
+  };
+}
+function preferredRunTimeGate(preferred, now, previous) {
+  const current = zonedTimeParts(now, preferred.timezone);
+  if (!current) return { ok: false, reason: `invalid preferred timezone: ${preferred.timezone}` };
+  const preferredMinute = preferredTimeToMinute(preferred.time);
+  if (preferredMinute === null) return { ok: false, reason: `invalid preferred time: ${preferred.time}` };
+  const currentMinute = current.hour * 60 + current.minute;
+  if (currentMinute < preferredMinute) {
+    return { ok: false, reason: `waiting preferred time ${preferred.time} ${preferred.timezone}` };
+  }
+  const lastDispatchAt = previous?.lastDecision.kind === "dispatch" ? previous.lastDecision.at : void 0;
+  if (lastDispatchAt) {
+    const last = zonedTimeParts(new Date(lastDispatchAt), preferred.timezone);
+    if (last?.date === current.date) {
+      return { ok: false, reason: `already dispatched today at preferred time ${preferred.time} ${preferred.timezone}` };
+    }
+  }
+  return { ok: true };
+}
+function preferredTimeToMinute(value) {
+  const match = value.match(/^([01]\d|2[0-3]):([0-5]\d)$/);
+  if (!match) return null;
+  return Number(match[1]) * 60 + Number(match[2]);
+}
+function zonedTimeParts(date, timezone) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23"
+    }).formatToParts(date);
+    const get = (type) => parts.find((part) => part.type === type)?.value;
+    const year = get("year");
+    const month = get("month");
+    const day = get("day");
+    const hour = get("hour");
+    const minute = get("minute");
+    if (!year || !month || !day || !hour || !minute) return null;
+    return { date: `${year}-${month}-${day}`, hour: Number(hour), minute: Number(minute) };
+  } catch {
+    return null;
+  }
 }
 var init_goalAgentResponsibilityScheduling = __esm({
   "src/scripts/goalAgentResponsibilityScheduling.ts"() {
     "use strict";
     init_registry();
     init_jobState();
-    init_scheduleEvery();
   }
 });
 
@@ -6812,8 +6837,8 @@ function routeNeedsIssueFact(goal) {
   return goal.route.some(
     (step) => Object.values(step.args ?? {}).some((value) => {
       if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-      const record = value;
-      return Object.keys(record).length === 1 && record.fact === "issue";
+      const record2 = value;
+      return Object.keys(record2).length === 1 && record2.fact === "issue";
     })
   );
 }
@@ -6891,6 +6916,23 @@ var init_advanceManagedGoal = __esm({
         ctx.output.reason = reason;
         return;
       }
+      if (isGoalTargetLoop(managed)) {
+        const previousScheduleState = goal.raw.extra.scheduleState && typeof goal.raw.extra.scheduleState === "object" ? goal.raw.extra.scheduleState : void 0;
+        const decision2 = planGoalTargetLoopSchedule({ goal: managed, previousScheduleState });
+        restoreGoalIdFact();
+        goal.raw = writeManagedGoalToState({ ...goal.raw, state: goal.state }, managed);
+        goal.raw.extra.scheduleState = decision2.scheduleState;
+        ctx.data.managedGoalDecision = decision2;
+        if (decision2.kind === "dispatch" && decision2.dispatch) {
+          ctx.output.nextDispatch = {
+            action: decision2.dispatch.action,
+            agentAction: decision2.dispatch.agentAction,
+            cliArgs: decision2.dispatch.cliArgs
+          };
+        }
+        ctx.output.reason = decision2.reason;
+        return;
+      }
       if (isAgentResponsibilityCadenceGoal(managed, goal.raw.extra)) {
         const previousScheduleState = goal.raw.extra.scheduleState && typeof goal.raw.extra.scheduleState === "object" ? goal.raw.extra.scheduleState : void 0;
         const decision2 = await planGoalAgentResponsibilitySchedule({
@@ -6907,7 +6949,8 @@ var init_advanceManagedGoal = __esm({
           ctx.output.nextDispatch = {
             agentResponsibility: decision2.dispatch.agentResponsibility,
             agentAction: decision2.dispatch.agentAction,
-            cliArgs: decision2.dispatch.cliArgs
+            cliArgs: decision2.dispatch.cliArgs,
+            ...goal.raw.extra.saveReport === true ? { saveReport: true } : {}
           };
         }
         ctx.output.reason = decision2.reason;
@@ -6930,7 +6973,8 @@ var init_advanceManagedGoal = __esm({
       ctx.output.nextDispatch = {
         agentResponsibility: decision.agentResponsibility,
         agentAction: decision.agentAction,
-        cliArgs: decision.cliArgs
+        cliArgs: decision.cliArgs,
+        ...decision.saveReport === true ? { saveReport: true } : {}
       };
       ctx.output.reason = `dispatch ${decision.agentResponsibility} for ${decision.evidence}`;
     };
@@ -6944,9 +6988,9 @@ function resolveTrigger(force) {
   if (force || event === "issue_comment" || event === "workflow_dispatch") return "manual";
   return "event";
 }
-function appendLine(ctx, record) {
-  const filePath = `activity/${record.ts.slice(0, 10)}.jsonl`;
-  appendStateLine(ctx.config, ctx.cwd, filePath, JSON.stringify(record), `chore(activity): ${record.action}`);
+function appendLine(ctx, record2) {
+  const filePath = `activity/${record2.ts.slice(0, 10)}.jsonl`;
+  appendStateLine(ctx.config, ctx.cwd, filePath, JSON.stringify(record2), `chore(activity): ${record2.action}`);
 }
 var appendCompanyActivity;
 var init_appendCompanyActivity = __esm({
@@ -6962,7 +7006,7 @@ var init_appendCompanyActivity = __esm({
         const agent = ctx.data.agentSlug || null;
         const agentTitle = ctx.data.agentTitle || null;
         const force = ctx.args?.force === true;
-        const record = {
+        const record2 = {
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           action: `Ran agentResponsibility: ${agentResponsibilityTitle ?? agentResponsibility}`,
           agentResponsibility,
@@ -6976,7 +7020,7 @@ var init_appendCompanyActivity = __esm({
           durationMs: agentResult?.durationMs ?? null,
           runUrl: getRunUrl() || null
         };
-        appendLine(ctx, record);
+        appendLine(ctx, record2);
       } catch (err) {
         process.stderr.write(
           `[activity] company-activity append failed: ${err instanceof Error ? err.message : String(err)}
@@ -6987,6 +7031,338 @@ var init_appendCompanyActivity = __esm({
   }
 });
 
+// src/companyManagerDecision.ts
+function parseCompanyManagerDecisionText(finalText) {
+  const raw = extractDecisionJson(finalText);
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("company-manager decision must be JSON object");
+  }
+  const input = parsed;
+  const actions = Array.isArray(input.actions) ? input.actions.map(parseAction) : [];
+  return {
+    summary: typeof input.summary === "string" ? input.summary.trim() : "",
+    actions
+  };
+}
+function buildManagedGoalState(action) {
+  const at = nowIso();
+  return {
+    state: "active",
+    createdAt: at,
+    updatedAt: at,
+    extra: {
+      type: action.goalType ?? "release",
+      destination: { outcome: action.outcome, evidence: action.evidence },
+      agentResponsibilities: action.agentResponsibilities,
+      route: action.route,
+      facts: action.facts ?? {},
+      blockers: [],
+      createdByIntent: action.intentId,
+      manager: "cto"
+    }
+  };
+}
+function buildAgentLoopState(action) {
+  const at = nowIso();
+  return {
+    state: "active",
+    createdAt: at,
+    updatedAt: at,
+    extra: {
+      type: "agentLoop",
+      scheduleMode: "agentLoop",
+      schedule: action.every,
+      destination: { outcome: action.outcome, evidence: [] },
+      agentResponsibilities: action.agentResponsibilities,
+      route: [],
+      facts: {},
+      blockers: [],
+      createdByIntent: action.intentId,
+      manager: "cto"
+    }
+  };
+}
+function extractDecisionJson(finalText) {
+  const fence = finalText.match(/```(?:kody-company-manager-decision|json)\s*([\s\S]*?)```/i);
+  if (fence?.[1]) return fence[1].trim();
+  const line = finalText.match(/KODY_COMPANY_MANAGER_DECISION=(\{[\s\S]*\})/);
+  if (line?.[1]) return line[1].trim();
+  throw new Error("missing kody-company-manager-decision JSON");
+}
+function parseAction(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("company-manager action must be object");
+  }
+  const input = value;
+  const kind = input.kind;
+  if (kind === "createManagedGoal") return parseCreateManagedGoal(input);
+  if (kind === "createAgentLoop") return parseCreateAgentLoop(input);
+  if (kind === "setGoalLifecycle") return parseSetGoalLifecycle(input);
+  if (kind === "updateIntentPortfolio") return parseUpdateIntentPortfolio(input);
+  if (kind === "note") return parseNote(input);
+  throw new Error(`unsupported company-manager action kind: ${String(kind)}`);
+}
+function parseCreateManagedGoal(input) {
+  const route = Array.isArray(input.route) ? input.route.map(parseRouteStep) : [];
+  if (route.length === 0) throw new Error("createManagedGoal requires route");
+  const evidence = stringArray2(input.evidence);
+  if (evidence.length === 0) throw new Error("createManagedGoal requires evidence");
+  return {
+    kind: "createManagedGoal",
+    intentId: slug(input.intentId, "intentId"),
+    id: slug(input.id, "id"),
+    outcome: requiredString(input.outcome, "outcome"),
+    goalType: typeof input.goalType === "string" && input.goalType.trim() ? input.goalType.trim() : void 0,
+    evidence,
+    agentResponsibilities: nonEmptyStringArray(input.agentResponsibilities, "agentResponsibilities"),
+    route,
+    facts: record(input.facts) ?? {},
+    reason: requiredString(input.reason, "reason")
+  };
+}
+function parseCreateAgentLoop(input) {
+  return {
+    kind: "createAgentLoop",
+    intentId: slug(input.intentId, "intentId"),
+    id: slug(input.id, "id"),
+    outcome: requiredString(input.outcome, "outcome"),
+    every: oneOf(input.every, ["manual", "1h", "1d", "7d", "30d"], "1d"),
+    agentResponsibilities: nonEmptyStringArray(input.agentResponsibilities, "agentResponsibilities"),
+    reason: requiredString(input.reason, "reason")
+  };
+}
+function parseSetGoalLifecycle(input) {
+  return {
+    kind: "setGoalLifecycle",
+    intentId: slug(input.intentId, "intentId"),
+    id: slug(input.id, "id"),
+    state: oneOf(input.state, ["active", "closed", "abandoned"], "active"),
+    reason: requiredString(input.reason, "reason")
+  };
+}
+function parseUpdateIntentPortfolio(input) {
+  return {
+    kind: "updateIntentPortfolio",
+    intentId: slug(input.intentId, "intentId"),
+    goals: stringArray2(input.goals).filter(isSlug),
+    loops: stringArray2(input.loops).filter(isSlug),
+    responsibilities: stringArray2(input.responsibilities).filter(isSlug),
+    reason: requiredString(input.reason, "reason")
+  };
+}
+function parseNote(input) {
+  return {
+    kind: "note",
+    intentId: typeof input.intentId === "string" && isSlug(input.intentId) ? input.intentId : void 0,
+    message: requiredString(input.message ?? input.content, "message")
+  };
+}
+function parseRouteStep(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("route step must be object");
+  const input = value;
+  return {
+    stage: requiredString(input.stage, "route.stage"),
+    evidence: requiredString(input.evidence, "route.evidence"),
+    agentResponsibility: slug(input.agentResponsibility, "route.agentResponsibility"),
+    ...typeof input.agentAction === "string" && input.agentAction.trim() ? { agentAction: input.agentAction.trim() } : {},
+    ...record(input.args) ? { args: record(input.args) } : {}
+  };
+}
+function slug(value, field) {
+  const text = requiredString(value, field);
+  if (!isSlug(text)) throw new Error(`${field} must be lowercase slug`);
+  return text;
+}
+function isSlug(value) {
+  return SLUG_RE.test(value);
+}
+function requiredString(value, field) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${field} is required`);
+  return value.trim();
+}
+function stringArray2(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+}
+function nonEmptyStringArray(value, field) {
+  const values = stringArray2(value);
+  if (values.length === 0) throw new Error(`${field} must not be empty`);
+  return values;
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : null;
+}
+function oneOf(value, allowed, fallback) {
+  return typeof value === "string" && allowed.includes(value) ? value : fallback;
+}
+var SLUG_RE;
+var init_companyManagerDecision = __esm({
+  "src/companyManagerDecision.ts"() {
+    "use strict";
+    init_state2();
+    SLUG_RE = /^[a-z][a-z0-9-]{0,63}$/;
+  }
+});
+
+// src/companyIntent.ts
+function isCompanyIntentId(value) {
+  return SLUG_RE2.test(value);
+}
+function companyIntentPath(id) {
+  assertIntentId(id);
+  return `intents/${id}/intent.json`;
+}
+function normalizeCompanyIntent(path46, raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`${path46}: intent must be JSON object`);
+  }
+  const input = raw;
+  const id = stringField2(input.id);
+  if (!id || !isCompanyIntentId(id)) throw new Error(`${path46}: invalid intent id`);
+  const createdAt = stringField2(input.createdAt) || nowIso();
+  const updatedAt = stringField2(input.updatedAt) || createdAt;
+  return {
+    version: 1,
+    id,
+    status: oneOf2(input.status, ["active", "paused", "archived"], "active"),
+    for: stringField2(input.for),
+    priority: numberField(input.priority, 100),
+    posture: oneOf2(
+      input.posture,
+      ["confidence", "speed", "stability-recovery", "maintenance", "balanced"],
+      "balanced"
+    ),
+    scope: {
+      repos: stringArray3(recordField(input.scope)?.repos),
+      areas: stringArray3(recordField(input.scope)?.areas)
+    },
+    principles: stringArray3(input.principles),
+    metrics: stringArray3(input.metrics),
+    policy: {
+      release: normalizeReleasePolicy(recordField(recordField(input.policy)?.release)),
+      automation: normalizeAutomationPolicy(recordField(recordField(input.policy)?.automation))
+    },
+    portfolio: {
+      goals: stringArray3(recordField(input.portfolio)?.goals).filter(isCompanyIntentId),
+      loops: stringArray3(recordField(input.portfolio)?.loops).filter(isCompanyIntentId),
+      responsibilities: stringArray3(recordField(input.portfolio)?.responsibilities).filter(isCompanyIntentId)
+    },
+    manager: normalizeManager(recordField(input.manager)),
+    createdAt,
+    updatedAt
+  };
+}
+function listCompanyIntents(config, cwd) {
+  const entries = listStateDirectory(config, cwd, "intents");
+  const records = [];
+  for (const entry of entries) {
+    if (entry.type !== "dir" || !entry.name || !isCompanyIntentId(entry.name)) continue;
+    const path46 = companyIntentPath(entry.name);
+    const file = readStateText(config, cwd, path46);
+    if (!file) continue;
+    records.push({
+      id: entry.name,
+      path: file.path,
+      intent: normalizeCompanyIntent(file.path, JSON.parse(file.content))
+    });
+  }
+  return records.sort((a, b) => a.intent.priority - b.intent.priority || a.id.localeCompare(b.id));
+}
+function readCompanyIntent(config, cwd, id) {
+  const path46 = companyIntentPath(id);
+  const file = readStateText(config, cwd, path46);
+  if (!file) return null;
+  return { id, path: file.path, intent: normalizeCompanyIntent(file.path, JSON.parse(file.content)) };
+}
+function writeCompanyIntent(config, cwd, intent, message = `chore(intents): update ${intent.id}`) {
+  upsertStateText(config, cwd, companyIntentPath(intent.id), `${JSON.stringify(intent, null, 2)}
+`, message);
+}
+function appendCompanyIntentDecision(config, cwd, intentId, entry) {
+  assertIntentId(intentId);
+  appendStateLine(config, cwd, `intents/${intentId}/decisions.jsonl`, JSON.stringify(entry), `chore(intents): log ${intentId} decision`);
+}
+function listCompanyPortfolio(config, cwd) {
+  const entries = listStateDirectory(config, cwd, "goals/instances");
+  const goals = [];
+  for (const entry of entries) {
+    if (entry.type !== "dir" || !entry.name || !isCompanyIntentId(entry.name)) continue;
+    const file = readStateText(config, cwd, `goals/instances/${entry.name}/state.json`);
+    if (!file) continue;
+    const state = parseGoalState(file.path, JSON.parse(file.content));
+    const destination = recordField(state.extra.destination);
+    goals.push({
+      id: entry.name,
+      state: state.state,
+      type: stringField2(state.extra.type) || void 0,
+      outcome: stringField2(destination?.outcome) || void 0,
+      agentResponsibilities: stringArray3(state.extra.agentResponsibilities),
+      isLoop: state.extra.scheduleMode === "agentLoop" || state.extra.type === "agentLoop",
+      updatedAt: state.updatedAt
+    });
+  }
+  return { goals: goals.sort((a, b) => a.id.localeCompare(b.id)) };
+}
+function writeCompanyGoalState(config, cwd, id, state, message) {
+  assertIntentId(id);
+  upsertStateText(config, cwd, `goals/instances/${id}/state.json`, serializeGoalState(state), message);
+}
+function assertIntentId(id) {
+  if (!isCompanyIntentId(id)) throw new Error(`invalid intent/portfolio id: ${id}`);
+}
+function stringField2(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function numberField(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function recordField(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringArray3(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+}
+function oneOf2(value, allowed, fallback) {
+  return typeof value === "string" && allowed.includes(value) ? value : fallback;
+}
+function normalizeReleasePolicy(raw) {
+  if (!raw) return void 0;
+  return {
+    cadence: oneOf2(raw.cadence, ["manual", "1d", "1w"], "manual"),
+    qaDepth: oneOf2(raw.qaDepth, ["light", "standard", "strict"], "standard"),
+    blockerLevel: oneOf2(raw.blockerLevel, ["low", "standard", "strict"], "standard"),
+    approval: oneOf2(raw.approval, ["none", "before-production", "before-risky-actions"], "before-risky-actions")
+  };
+}
+function normalizeAutomationPolicy(raw) {
+  return {
+    authority: "full-auto",
+    maxConcurrentGoals: Math.max(1, Math.floor(numberField(raw?.maxConcurrentGoals, 1))),
+    maxDailyActions: Math.max(1, Math.floor(numberField(raw?.maxDailyActions, 6))),
+    requiresHumanFor: stringArray3(raw?.requiresHumanFor)
+  };
+}
+function normalizeManager(raw) {
+  return {
+    agent: "cto",
+    loop: "company-manager-loop",
+    responsibility: "company-manager",
+    reviewEvery: oneOf2(raw?.reviewEvery, ["1d", "1w"], "1d"),
+    ...typeof raw?.lastReviewedAt === "string" ? { lastReviewedAt: raw.lastReviewedAt } : {}
+  };
+}
+var SLUG_RE2;
+var init_companyIntent = __esm({
+  "src/companyIntent.ts"() {
+    "use strict";
+    init_state2();
+    init_stateRepo();
+    SLUG_RE2 = /^[a-z][a-z0-9-]{0,63}$/;
+  }
+});
+
 // src/goal/stateStore.ts
 function statePath(goalId) {
   return `goals/instances/${goalId}/state.json`;
@@ -7008,6 +7384,133 @@ var init_stateStore = __esm({
   }
 });
 
+// src/scripts/applyCompanyManagerDecision.ts
+function applyAction(config, cwd, action) {
+  if (action.kind === "createManagedGoal") {
+    const existing = fetchGoalState(config, action.id, cwd);
+    if (existing) return applied(action, false, "goal already exists");
+    writeCompanyGoalState(config, cwd, action.id, buildManagedGoalState(action), `chore(goals): create ${action.id} from intent ${action.intentId}`);
+    return applied(action, true, action.reason, action.id);
+  }
+  if (action.kind === "createAgentLoop") {
+    const existing = fetchGoalState(config, action.id, cwd);
+    if (existing) return applied(action, false, "loop already exists");
+    writeCompanyGoalState(config, cwd, action.id, buildAgentLoopState(action), `chore(goals): create loop ${action.id} from intent ${action.intentId}`);
+    return applied(action, true, action.reason, action.id);
+  }
+  if (action.kind === "setGoalLifecycle") {
+    const state = fetchGoalState(config, action.id, cwd);
+    if (!state) return applied(action, false, "goal/loop missing", action.id);
+    const before = state.state;
+    if (before === action.state) return applied(action, false, "state already set", action.id);
+    const next = {
+      ...state,
+      state: action.state,
+      updatedAt: nowIso(),
+      extra: {
+        ...state.extra,
+        lifecycleChangedByIntent: action.intentId,
+        lifecycleChangeReason: action.reason
+      }
+    };
+    writeCompanyGoalState(config, cwd, action.id, next, `chore(goals): ${action.state} ${action.id} from intent ${action.intentId}`);
+    return applied(action, true, action.reason, action.id);
+  }
+  if (action.kind === "updateIntentPortfolio") {
+    const record2 = readCompanyIntent(config, cwd, action.intentId);
+    if (!record2) return applied(action, false, "intent missing");
+    const intent = {
+      ...record2.intent,
+      portfolio: {
+        goals: mergeUnique(record2.intent.portfolio.goals, action.goals ?? []),
+        loops: mergeUnique(record2.intent.portfolio.loops, action.loops ?? []),
+        responsibilities: mergeUnique(record2.intent.portfolio.responsibilities, action.responsibilities ?? [])
+      },
+      updatedAt: nowIso()
+    };
+    writeCompanyIntent(config, cwd, intent, `chore(intents): update ${action.intentId} portfolio`);
+    return applied(action, true, action.reason);
+  }
+  if (action.kind === "note") {
+    return {
+      kind: action.kind,
+      intentId: action.intentId,
+      changed: false,
+      reason: action.message
+    };
+  }
+  return { kind: "unknown", changed: false, reason: "unsupported action" };
+}
+function applied(action, changed, reason, resource) {
+  return {
+    kind: action.kind,
+    intentId: "intentId" in action ? action.intentId : void 0,
+    resource,
+    changed,
+    reason
+  };
+}
+function mergeUnique(left, right) {
+  return [.../* @__PURE__ */ new Set([...left, ...right])].sort();
+}
+function logAppliedCompanyManagerActions(config, cwd, appliedActions) {
+  const at = nowIso();
+  for (const action of appliedActions) {
+    if (!action.intentId) continue;
+    appendCompanyIntentDecision(config, cwd, action.intentId, {
+      at,
+      agent: "cto",
+      intentId: action.intentId,
+      action: action.kind,
+      reason: action.reason,
+      after: { changed: action.changed },
+      resources: action.resource ? [action.resource] : []
+    });
+  }
+}
+var applyCompanyManagerDecision;
+var init_applyCompanyManagerDecision = __esm({
+  "src/scripts/applyCompanyManagerDecision.ts"() {
+    "use strict";
+    init_companyManagerDecision();
+    init_companyIntent();
+    init_stateStore();
+    init_state2();
+    applyCompanyManagerDecision = async (ctx) => {
+      const decision = ctx.data.companyManagerDecision;
+      if (!decision || !Array.isArray(decision.actions)) return;
+      if (ctx.output.exitCode !== 0) return;
+      const applied2 = [];
+      for (const action of decision.actions) {
+        applied2.push(applyAction(ctx.config, ctx.cwd, action));
+      }
+      ctx.data.companyManagerApplied = applied2;
+      ctx.data.companyManagerApplySummary = `company-manager applied ${applied2.filter((item) => item.changed).length}/${applied2.length} action(s)`;
+    };
+  }
+});
+
+// src/scripts/appendCompanyIntentDecision.ts
+var appendCompanyIntentDecision2;
+var init_appendCompanyIntentDecision = __esm({
+  "src/scripts/appendCompanyIntentDecision.ts"() {
+    "use strict";
+    init_applyCompanyManagerDecision();
+    appendCompanyIntentDecision2 = async (ctx) => {
+      const applied2 = ctx.data.companyManagerApplied;
+      if (!applied2 || applied2.length === 0) return;
+      try {
+        logAppliedCompanyManagerActions(ctx.config, ctx.cwd, applied2);
+      } catch (err) {
+        process.stderr.write(
+          `[company-manager] failed append intent decision log: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    };
+  }
+});
+
 // src/scripts/applyAgentResponsibilityReports.ts
 function collectReports(raw, agentResult) {
   const out = [];
@@ -8214,7 +8717,7 @@ function discoverPayloadCollections(cwd) {
         const content = fs29.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
-        const slug = slugMatch[1];
+        const slug2 = slugMatch[1];
         const name = file.replace(/\.(ts|tsx)$/, "");
         const fields = [];
         const fieldMatches = content.matchAll(/name:\s*['"]([a-zA-Z_][a-zA-Z0-9_]*)['"]/g);
@@ -8224,7 +8727,7 @@ function discoverPayloadCollections(cwd) {
         const hasAdmin = /components:\s*\{/.test(content) || /Field:\s*['"]/.test(content) || /Cell:\s*['"]/.test(content) || /views:\s*\{/.test(content);
         out.push({
           name,
-          slug,
+          slug: slug2,
           filePath: path29.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
@@ -8621,425 +9124,34 @@ var init_dispatch = __esm({
         };
         ctx.data.action = action;
         if (state) state.core.lastOutcome = action;
-        return;
-      }
-      if (state?.flow) {
-        state.flow.step = next;
-      }
-      const usePr = target === "pr" && state?.core.prUrl;
-      const targetNumber = usePr ? parsePr(state.core.prUrl) ?? issueNumber : issueNumber;
-      ctx.output.nextDispatch = {
-        action: next,
-        cliArgs: usePr ? { pr: targetNumber } : { issue: targetNumber }
-      };
-    };
-  }
-});
-
-// src/jobIdentity.ts
-function stableJobKey(job) {
-  const agentResponsibility = job.agentResponsibility ?? job.action;
-  const agentAction = job.agentAction ?? agentResponsibility ?? "unknown";
-  if (job.flavor === "scheduled" && job.agentResponsibility)
-    return `scheduled:${job.agentResponsibility}:${agentAction}`;
-  const target = typeof job.target === "number" ? job.target : targetFromCliArgs(job.cliArgs);
-  const work = agentResponsibility && agentAction && agentAction !== agentResponsibility ? `${agentResponsibility}:${agentAction}` : agentResponsibility ?? agentAction;
-  return target === void 0 ? `${job.flavor}:${work}` : `${job.flavor}:${work}:${target}`;
-}
-function targetFromCliArgs(cliArgs) {
-  if (!cliArgs) return void 0;
-  for (const key of ["issue", "pr", "target", "issue_number"]) {
-    const value = cliArgs[key];
-    if (typeof value === "number" && Number.isFinite(value)) return value;
-  }
-  return void 0;
-}
-var init_jobIdentity = __esm({
-  "src/jobIdentity.ts"() {
-    "use strict";
-  }
-});
-
-// src/scripts/planTaskJobs.ts
-function parseTaskJobSpecs(body) {
-  const match = body.match(new RegExp(`<!--\\s*${TASK_JOBS_MARKER}\\s*([\\s\\S]*?)-->`));
-  if (!match) return [];
-  let parsed;
-  try {
-    parsed = JSON.parse(match[1].trim());
-  } catch (err) {
-    throw new Error(`task job plan is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  if (!Array.isArray(parsed)) throw new Error("task job plan must be a JSON array");
-  return parsed.map((entry, index) => normalizeSpec(entry, index));
-}
-function taskJobSpecToJob(spec, issueNumber) {
-  const cliArgs = spec.cliArgs ?? { issue: issueNumber };
-  const target = typeof spec.target === "number" ? spec.target : targetFromCliArgs(cliArgs) ?? issueNumber;
-  return {
-    agentResponsibility: spec.agentResponsibility ?? spec.agentAction,
-    agentAction: spec.agentAction,
-    why: spec.reason,
-    agent: spec.agent,
-    schedule: spec.schedule,
-    target,
-    cliArgs,
-    flavor: spec.flavor ?? "instant"
-  };
-}
-function normalizeSpec(input, index) {
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    throw new Error(`task job plan entry ${index} must be an object`);
-  }
-  const raw = input;
-  const agentAction = typeof raw.agentAction === "string" ? raw.agentAction.trim() : "";
-  if (!/^[a-z][a-z0-9-]*$/.test(agentAction)) {
-    throw new Error(`task job plan entry ${index} must have a valid agentAction`);
-  }
-  const cliArgs = raw.cliArgs;
-  if (cliArgs !== void 0 && (!cliArgs || typeof cliArgs !== "object" || Array.isArray(cliArgs))) {
-    throw new Error(`task job plan entry ${index} cliArgs must be an object`);
-  }
-  const flavor = raw.flavor;
-  if (flavor !== void 0 && flavor !== "instant" && flavor !== "scheduled") {
-    throw new Error(`task job plan entry ${index} flavor must be "instant" or "scheduled"`);
-  }
-  return {
-    agentAction,
-    ...typeof raw.agentResponsibility === "string" && raw.agentResponsibility.trim() ? { agentResponsibility: raw.agentResponsibility.trim() } : {},
-    ...typeof raw.reason === "string" && raw.reason.trim() ? { reason: raw.reason.trim() } : {},
-    ...typeof raw.agent === "string" && raw.agent.trim() ? { agent: raw.agent.trim() } : {},
-    ...typeof raw.agent === "string" && raw.agent.trim() ? { agent: raw.agent.trim() } : {},
-    ...cliArgs ? { cliArgs } : {},
-    ...typeof raw.target === "number" && Number.isFinite(raw.target) ? { target: raw.target } : {},
-    ...flavor === "instant" || flavor === "scheduled" ? { flavor } : {},
-    ...typeof raw.schedule === "string" && raw.schedule.trim() ? { schedule: raw.schedule.trim() } : {}
-  };
-}
-function jobToPlannedTaskJob(job) {
-  return {
-    id: stableJobKey(job),
-    agentAction: job.agentAction ?? job.agentResponsibility ?? "unknown",
-    agentResponsibility: job.agentResponsibility ?? job.action ?? job.agentAction ?? "unknown",
-    ...job.agent ? { agent: job.agent } : {},
-    ...job.flavor ? { flavor: job.flavor } : {},
-    ...job.schedule ? { schedule: job.schedule } : {},
-    ...typeof job.target === "number" ? { target: job.target } : {},
-    ...job.why ? { reason: job.why } : {}
-  };
-}
-function assertUniqueJobIds(planned) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const job of planned) {
-    if (seen.has(job.id)) throw new Error(`duplicate planned task job id: ${job.id}`);
-    seen.add(job.id);
-  }
-}
-var TASK_JOBS_MARKER, planTaskJobs;
-var init_planTaskJobs = __esm({
-  "src/scripts/planTaskJobs.ts"() {
-    "use strict";
-    init_jobIdentity();
-    init_state();
-    TASK_JOBS_MARKER = "kody:task-jobs:v1";
-    planTaskJobs = async (ctx) => {
-      const issueNumber = ctx.args.issue;
-      if (!issueNumber) {
-        ctx.skipAgent = true;
-        ctx.output.exitCode = 64;
-        ctx.output.reason = "planTaskJobs requires --issue";
-        return;
-      }
-      const issue = ctx.data.issue;
-      const specs = parseTaskJobSpecs(issue?.body ?? "");
-      if (specs.length === 0) {
-        ctx.skipAgent = true;
-        ctx.output.exitCode = 64;
-        ctx.output.reason = `no ${TASK_JOBS_MARKER} block found on issue #${issueNumber}`;
-        return;
-      }
-      const jobs = specs.map((spec) => taskJobSpecToJob(spec, issueNumber));
-      const planned = jobs.map(jobToPlannedTaskJob);
-      assertUniqueJobIds(planned);
-      const prior = ctx.data.taskState ?? emptyState();
-      const next = upsertTaskJobs(prior, planned, (/* @__PURE__ */ new Date()).toISOString());
-      ctx.data.taskState = next;
-      ctx.data.plannedTaskJobs = jobs;
-      ctx.data.plannedTaskJobIds = planned.map((job) => job.id);
-      const target = ctx.data.commentTargetType;
-      const number = ctx.data.commentTargetNumber;
-      if (target && number) writeTaskState(target, number, next, ctx.cwd, ctx.config);
-    };
-  }
-});
-
-// src/scripts/dispatchAgentResponsibilityFileTicks.ts
-import * as path31 from "path";
-async function decideShouldFire(every, slug, backend, now) {
-  if (!every) return { skip: false, reason: "no schedule (every cron tick)" };
-  if (every === "manual") {
-    return { skip: true, reason: "manual-only (no auto-fire; trigger via dashboard Run now)" };
-  }
-  let lastFiredAt = null;
-  try {
-    const loaded = await backend.load(slug);
-    const raw = loaded.state.data?.lastFiredAt;
-    if (typeof raw === "string") {
-      const ms = Date.parse(raw);
-      if (!Number.isNaN(ms)) lastFiredAt = ms;
-    }
-  } catch {
-    return { skip: false, reason: "state unreadable; firing" };
-  }
-  if (lastFiredAt === null) {
-    return { skip: false, reason: `first tick (every ${every})` };
-  }
-  const intervalMs = scheduleEveryToMs(every);
-  const elapsedMs = now - lastFiredAt;
-  if (elapsedMs >= intervalMs) {
-    return { skip: false, reason: `due (every ${every}, last ${formatAgo(elapsedMs)} ago)` };
-  }
-  const remainingMs = intervalMs - elapsedMs;
-  return {
-    skip: true,
-    reason: `every ${every}; ${formatAgo(elapsedMs)} since last tick, next in ${formatAgo(remainingMs)}`
-  };
-}
-function formatAgo(ms) {
-  const sec = Math.max(0, Math.round(ms / 1e3));
-  if (sec < 60) return `${sec}s`;
-  const min = Math.round(sec / 60);
-  if (min < 60) return `${min}m`;
-  const hr = Math.round(min / 60);
-  if (hr < 48) return `${hr}h`;
-  const day = Math.round(hr / 24);
-  return `${day}d`;
-}
-function parseAgentResponsibilityFilter(raw) {
-  return typeof raw === "string" && raw.trim().length > 0 ? raw.trim() : void 0;
-}
-function filterSlugs(slugs, onlyAgentResponsibility) {
-  return onlyAgentResponsibility ? slugs.filter((slug) => slug === onlyAgentResponsibility) : slugs;
-}
-function listActivatedAgentResponsibilitySlugs(projectRoot, storeRoot, activeStoreAgentResponsibilities) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const slug of listAgentResponsibilityFolderSlugs(projectRoot)) {
-    if (seen.has(slug)) continue;
-    seen.add(slug);
-    out.push(slug);
-  }
-  const active = new Set(activeStoreAgentResponsibilities ?? []);
-  if (storeRoot && active.size > 0) {
-    for (const slug of listAgentResponsibilityFolderSlugs(storeRoot)) {
-      if (!active.has(slug) || seen.has(slug)) continue;
-      seen.add(slug);
-      out.push(slug);
-    }
-  }
-  return out.sort();
-}
-function createAgentResponsibilityTaskIssue(opts) {
-  const title = `AgentResponsibility ${opts.slug} - multi-agentAction task`;
-  const body = buildAgentResponsibilityTaskIssueBody(opts.slug, opts.body, opts.config);
-  const out = gh(["issue", "create", "--title", title, "--body-file", "-"], { input: body, cwd: opts.cwd });
-  const url = out.split("\n").map((line) => line.trim()).filter(Boolean).pop() ?? "";
-  const match = url.match(/\/issues\/(\d+)\b/);
-  if (!match) throw new Error(`gh issue create returned unexpected output: ${out}`);
-  return { number: Number(match[1]), url };
-}
-function buildAgentResponsibilityTaskIssueBody(slug, agentResponsibilityBody, config) {
-  const specs = (config.agentActions ?? []).map((agentAction) => ({
-    agentAction,
-    agentResponsibility: slug,
-    ...config.agent ? { agent: config.agent } : {},
-    reason: `AgentResponsibility \`${slug}\` slice for \`${agentAction}\`.`,
-    flavor: "scheduled",
-    ...config.every ? { schedule: config.every } : {}
-  }));
-  return [
-    `# AgentResponsibility task: ${slug}`,
-    "",
-    agentResponsibilityBody.trim() || "(no agentResponsibility body)",
-    "",
-    `<!-- ${TASK_JOBS_MARKER}`,
-    JSON.stringify(specs, null, 2),
-    "-->",
-    ""
-  ].join("\n");
-}
-async function stampFired(backend, slug, now, task) {
-  try {
-    const loaded = await backend.load(slug);
-    const nextData = {
-      ...loaded.state.data ?? {},
-      lastFiredAt: new Date(now).toISOString(),
-      ...task ? { lastTaskIssue: task.number, lastTaskUrl: task.url } : {}
-    };
-    await backend.save(loaded, { ...loaded.state, data: nextData });
-  } catch (err) {
-    process.stderr.write(`[jobs] failed to stamp lastFiredAt for ${slug}: ${String(err)}
-`);
-  }
-}
-var dispatchAgentResponsibilityFileTicks;
-var init_dispatchAgentResponsibilityFileTicks = __esm({
-  "src/scripts/dispatchAgentResponsibilityFileTicks.ts"() {
-    "use strict";
-    init_agent_responsibilityFolders();
-    init_issue();
-    init_job();
-    init_registry();
-    init_jobState();
-    init_planTaskJobs();
-    init_scheduleEvery();
-    dispatchAgentResponsibilityFileTicks = async (ctx, _profile, args) => {
-      ctx.skipAgent = true;
-      const targetAgentAction = String(args?.targetAgentAction ?? "");
-      if (!targetAgentAction) {
-        throw new Error("dispatchAgentResponsibilityFileTicks: `with.targetAgentAction` is required");
-      }
-      const jobsDir = String(args?.jobsDir ?? ".kody/agent-responsibilities");
-      const scriptedAgentAction = String(args?.scriptedAgentAction ?? "agent-responsibility-tick-scripted");
-      const slugArg = String(args?.slugArg ?? "agentResponsibility");
-      const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
-      if (backend.hydrate) {
-        await backend.hydrate();
-      }
-      try {
-        const onlyAgentResponsibility = parseAgentResponsibilityFilter(ctx.args.agentResponsibility);
-        if (args?.requireExplicitAgentResponsibility === true && !onlyAgentResponsibility) {
-          ctx.output.exitCode = 0;
-          ctx.output.reason = "scheduled agentResponsibility fan-out is owned by goal-scheduler";
-          process.stdout.write(
-            "[jobs] no flat agentResponsibility fan-out; goal-scheduler owns scheduled agentResponsibility decisions\n"
-          );
-          return;
-        }
-        const jobsPath = path31.join(ctx.cwd, jobsDir);
-        const storeJobsPath = getCompanyStoreAgentResponsibilitiesRoot();
-        const slugs = filterSlugs(
-          listActivatedAgentResponsibilitySlugs(jobsPath, storeJobsPath, ctx.config.company?.activeAgentResponsibilities),
-          onlyAgentResponsibility
-        );
-        ctx.data.jobSlugCount = slugs.length;
-        if (slugs.length === 0) {
-          const filter = onlyAgentResponsibility ? ` matching ${onlyAgentResponsibility}` : "";
-          process.stdout.write(`[jobs] no agentResponsibility folders${filter} in ${jobsDir}
-`);
-          return;
-        }
-        const filtered = onlyAgentResponsibility ? ` matching ${onlyAgentResponsibility}` : "";
-        process.stdout.write(
-          `[jobs] ticking ${slugs.length} agent responsibility/ies${filtered} via ${targetAgentAction}
-`
-        );
-        const results = [];
-        const now = Date.now();
-        for (const slug of slugs) {
-          const agentResponsibility = resolveAgentResponsibilityFolder(slug, jobsPath);
-          if (!agentResponsibility) {
-            process.stderr.write(
-              `[jobs] \u23ED  skip ${slug}: agentResponsibility folder is missing profile.json or agent-responsibility.md
-`
-            );
-            results.push({ slug, exitCode: 0, skipped: true, reason: "incomplete agentResponsibility folder" });
-            continue;
-          }
-          const config = agentResponsibility.config;
-          if (config.disabled === true) {
-            process.stdout.write(`[jobs] \u23ED  skip ${slug}: disabled in profile.json
-`);
-            results.push({ slug, exitCode: 0, skipped: true, reason: "disabled" });
-            continue;
-          }
-          if (!config.agent || config.agent.trim().length === 0) {
-            process.stderr.write(`[jobs] \u23ED  skip ${slug}: no agent assigned (add "agent" to profile.json)
-`);
-            results.push({ slug, exitCode: 0, skipped: true, reason: "no agent assigned" });
-            continue;
-          }
-          const decision = await decideShouldFire(config.every, slug, backend, now);
-          if (decision.skip) {
-            process.stdout.write(`[jobs] \u23ED  skip ${slug}: ${decision.reason}
-`);
-            results.push({ slug, exitCode: 0, skipped: true, reason: decision.reason });
-            continue;
-          }
-          if (config.agentActions && config.agentActions.length > 0) {
-            try {
-              const task = createAgentResponsibilityTaskIssue({
-                slug,
-                body: agentResponsibility.body,
-                config,
-                cwd: ctx.cwd
-              });
-              await stampFired(backend, slug, now, task);
-              process.stdout.write(`[jobs] \u2192 run ${slug} multi-agentAction task #${task.number} (task-jobs)
-`);
-              const out = await runJob(
-                mintScheduledJob({
-                  agentResponsibility: slug,
-                  agentAction: "task-jobs",
-                  schedule: config.every,
-                  agent: config.agent,
-                  cliArgs: { issue: task.number }
-                }),
-                { cwd: ctx.cwd, config: ctx.config, verbose: ctx.verbose, quiet: ctx.quiet }
-              );
-              results.push({ slug, exitCode: out.exitCode, reason: out.reason });
-              if (out.exitCode !== 0) {
-                process.stderr.write(`[jobs] task ${slug} failed (exit ${out.exitCode}): ${out.reason ?? ""}
-`);
-              }
-            } catch (err) {
-              const msg = err instanceof Error ? err.message : String(err);
-              process.stderr.write(`[jobs] task ${slug} crashed: ${msg}
-`);
-              results.push({ slug, exitCode: 99, reason: msg });
-            }
-            continue;
-          }
-          const slugTarget = config.tickScript ? scriptedAgentAction : config.agentAction ?? targetAgentAction;
-          const cliArgs = config.agentAction && !config.tickScript ? {} : { [slugArg]: slug };
-          process.stdout.write(`[jobs] \u2192 tick ${slug} (${slugTarget})
-`);
-          try {
-            const out = await runJob(
-              mintScheduledJob({
-                agentResponsibility: slug,
-                agentAction: slugTarget,
-                schedule: config.every,
-                agent: config.agent,
-                cliArgs
-              }),
-              { cwd: ctx.cwd, config: ctx.config, verbose: ctx.verbose, quiet: ctx.quiet, chain: false }
-            );
-            results.push({ slug, exitCode: out.exitCode, reason: out.reason });
-            if (out.exitCode !== 0) {
-              process.stderr.write(`[jobs] tick ${slug} failed (exit ${out.exitCode}): ${out.reason ?? ""}
-`);
-            }
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`[jobs] tick ${slug} crashed: ${msg}
-`);
-            results.push({ slug, exitCode: 99, reason: msg });
-          }
-        }
-        ctx.data.jobTickResults = results;
-        ctx.output.exitCode = 0;
-      } finally {
-        if (backend.persist) {
-          try {
-            await backend.persist();
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`[jobs] backend persist failed: ${msg}
-`);
-          }
-        }
+        return;
+      }
+      if (state?.flow) {
+        state.flow.step = next;
       }
+      const usePr = target === "pr" && state?.core.prUrl;
+      const targetNumber = usePr ? parsePr(state.core.prUrl) ?? issueNumber : issueNumber;
+      ctx.output.nextDispatch = {
+        action: next,
+        cliArgs: usePr ? { pr: targetNumber } : { issue: targetNumber }
+      };
+    };
+  }
+});
+
+// src/scripts/dispatchAgentResponsibilityFileTicks.ts
+var dispatchAgentResponsibilityFileTicks;
+var init_dispatchAgentResponsibilityFileTicks = __esm({
+  "src/scripts/dispatchAgentResponsibilityFileTicks.ts"() {
+    "use strict";
+    dispatchAgentResponsibilityFileTicks = async (ctx) => {
+      ctx.skipAgent = true;
+      ctx.data.jobTickResults = [];
+      ctx.output.exitCode = 0;
+      ctx.output.reason = "responsibility scheduling is owned by goals and loops";
+      process.stdout.write(
+        "[jobs] no flat agentResponsibility fan-out; goals and loops own scheduled responsibility decisions\n"
+      );
     };
   }
 });
@@ -9147,6 +9259,30 @@ var init_dispatchClassified = __esm({
   }
 });
 
+// src/jobIdentity.ts
+function stableJobKey(job) {
+  const agentResponsibility = job.agentResponsibility ?? job.action;
+  const agentAction = job.agentAction ?? agentResponsibility ?? "unknown";
+  if (job.flavor === "scheduled" && job.agentResponsibility)
+    return `scheduled:${job.agentResponsibility}:${agentAction}`;
+  const target = typeof job.target === "number" ? job.target : targetFromCliArgs(job.cliArgs);
+  const work = agentResponsibility && agentAction && agentAction !== agentResponsibility ? `${agentResponsibility}:${agentAction}` : agentResponsibility ?? agentAction;
+  return target === void 0 ? `${job.flavor}:${work}` : `${job.flavor}:${work}:${target}`;
+}
+function targetFromCliArgs(cliArgs) {
+  if (!cliArgs) return void 0;
+  for (const key of ["issue", "pr", "target", "issue_number"]) {
+    const value = cliArgs[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+var init_jobIdentity = __esm({
+  "src/jobIdentity.ts"() {
+    "use strict";
+  }
+});
+
 // src/scripts/dispatchNextTaskJob.ts
 function taskJobToJob(job, issueArg) {
   const target = typeof job.target === "number" ? job.target : typeof issueArg === "number" ? issueArg : void 0;
@@ -9669,8 +9805,8 @@ function git3(args, cwd) {
   }).trim();
 }
 function deriveBranchName(issueNumber, title) {
-  const slug = title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 50).replace(/-$/, "");
-  return slug ? `${issueNumber}-${slug}` : `${issueNumber}-task`;
+  const slug2 = title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 50).replace(/-$/, "");
+  return slug2 ? `${issueNumber}-${slug2}` : `${issueNumber}-task`;
 }
 function getCurrentBranch(cwd) {
   return git3(["branch", "--show-current"], cwd);
@@ -10076,11 +10212,11 @@ var init_fixFlow = __esm({
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync15 } from "child_process";
 import * as fs31 from "fs";
-import * as path32 from "path";
+import * as path31 from "path";
 function detectPackageManager(cwd) {
-  if (fs31.existsSync(path32.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs31.existsSync(path32.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs31.existsSync(path32.join(cwd, "bun.lockb"))) return "bun";
+  if (fs31.existsSync(path31.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs31.existsSync(path31.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs31.existsSync(path31.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -10152,7 +10288,7 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch2 = defaultBranchFromGit(cwd);
-  const configPath = path32.join(cwd, "kody.config.json");
+  const configPath = path31.join(cwd, "kody.config.json");
   if (fs31.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
@@ -10161,8 +10297,8 @@ function performInit(cwd, force) {
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path32.join(cwd, ".github", "workflows");
-  const workflowPath = path32.join(workflowDir, "kody.yml");
+  const workflowDir = path31.join(cwd, ".github", "workflows");
+  const workflowPath = path31.join(workflowDir, "kody.yml");
   if (fs31.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
@@ -10170,8 +10306,8 @@ function performInit(cwd, force) {
     fs31.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
-  const agentsDir = path32.join(cwd, ".kody", "agents");
-  const agentPath = path32.join(agentsDir, "kody.md");
+  const agentsDir = path31.join(cwd, ".kody", "agents");
+  const agentPath = path31.join(agentsDir, "kody.md");
   if (fs31.existsSync(agentPath) && !force) {
     skipped.push(".kody/agents/kody.md");
   } else {
@@ -10187,7 +10323,7 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path32.join(workflowDir, `kody-${exe.name}.yml`);
+    const target = path31.join(workflowDir, `kody-${exe.name}.yml`);
     if (fs31.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
@@ -10385,7 +10521,7 @@ function stripDirective(body) {
   }
   return lines.slice(start).join("\n").trim();
 }
-function parseAgentFile(raw, slug) {
+function parseAgentFile(raw, slug2) {
   const stripped = stripLeadingFrontmatter(raw);
   const trimmed = stripped.trim();
   const firstLine2 = trimmed.split("\n", 1)[0] ?? "";
@@ -10394,14 +10530,14 @@ function parseAgentFile(raw, slug) {
     const rest = trimmed.slice(firstLine2.length).replace(/^\n+/, "");
     return { title: h1[1].trim(), body: rest };
   }
-  return { title: humanizeSlug2(slug), body: trimmed };
+  return { title: humanizeSlug2(slug2), body: trimmed };
 }
 function stripLeadingFrontmatter(raw) {
   const match = /^---\r?\n[\s\S]*?\r?\n---\r?\n?/.exec(raw);
   return match ? raw.slice(match[0].length) : raw;
 }
-function humanizeSlug2(slug) {
-  return slug.split(/[-_]+/).filter((s) => s.length > 0).map((s) => s[0].toUpperCase() + s.slice(1)).join(" ");
+function humanizeSlug2(slug2) {
+  return slug2.split(/[-_]+/).filter((s) => s.length > 0).map((s) => s[0].toUpperCase() + s.slice(1)).join(" ");
 }
 var loadAgentAdhoc;
 var init_loadAgentAdhoc = __esm({
@@ -10444,19 +10580,19 @@ var init_loadAgentResponsibilityState = __esm({
     AGENT_RESPONSIBILITY_TOOL_PALETTE = new Set(AGENT_RESPONSIBILITY_MCP_TOOL_NAMES);
     loadAgentResponsibilityState = async (ctx, profile, args) => {
       const jobsDir = String(args?.jobsDir ?? ".kody/agent-responsibilities");
-      const slug = profile.name;
+      const slug2 = profile.name;
       const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
       if (backend.hydrate) await backend.hydrate();
-      const loaded = await backend.load(slug);
-      ctx.data.jobSlug = slug;
+      const loaded = await backend.load(slug2);
+      ctx.data.jobSlug = slug2;
       ctx.data.jobState = loaded;
       ctx.data.jobStateJson = JSON.stringify(loaded.state, null, 2);
-      ctx.data.agentResponsibilitySlug = slug;
+      ctx.data.agentResponsibilitySlug = slug2;
       ctx.data.agentResponsibilityTitle = profile.describe;
       ctx.data.agentActionSlug = profile.agentAction ?? profile.name;
       ctx.data.agentSlug = profile.agent ?? "";
       ctx.data.agentTitle = "";
-      ctx.data.agentResponsibilitySchedule = profile.every ?? profile.schedule ?? "";
+      ctx.data.agentResponsibilitySchedule = String(ctx.data.jobSchedule ?? "");
       const mentions = (profile.mentions ?? []).map((l) => `@${l}`).join(" ");
       ctx.data.mentions = mentions;
       const declaredTools = profile.agentResponsibilityTools ?? [];
@@ -10464,7 +10600,7 @@ var init_loadAgentResponsibilityState = __esm({
         const unknown = declaredTools.filter((name) => !AGENT_RESPONSIBILITY_TOOL_PALETTE.has(name));
         if (unknown.length > 0) {
           throw new Error(
-            `loadAgentResponsibilityState: agentResponsibility '${slug}' declared agentResponsibilityTools not in the kody-agentResponsibility palette: ${unknown.join(", ")}. Available: ${[...AGENT_RESPONSIBILITY_MCP_TOOL_NAMES].join(", ")}`
+            `loadAgentResponsibilityState: agentResponsibility '${slug2}' declared agentResponsibilityTools not in the kody-agentResponsibility palette: ${unknown.join(", ")}. Available: ${[...AGENT_RESPONSIBILITY_MCP_TOOL_NAMES].join(", ")}`
           );
         }
         ctx.data.agentResponsibilityTools = declaredTools;
@@ -10478,6 +10614,43 @@ var init_loadAgentResponsibilityState = __esm({
   }
 });
 
+// src/scripts/loadCompanyIntents.ts
+var loadCompanyIntents;
+var init_loadCompanyIntents = __esm({
+  "src/scripts/loadCompanyIntents.ts"() {
+    "use strict";
+    init_companyIntent();
+    loadCompanyIntents = async (ctx) => {
+      const intents = listCompanyIntents(ctx.config, ctx.cwd);
+      const active = intents.filter((record2) => record2.intent.status === "active");
+      ctx.data.companyIntents = intents;
+      ctx.data.companyActiveIntents = active;
+      ctx.data.companyIntentsJson = JSON.stringify(
+        active.map((record2) => record2.intent),
+        null,
+        2
+      );
+      if (active.length === 0) {
+        ctx.output.reason = "no active company intents";
+      }
+    };
+  }
+});
+
+// src/scripts/loadCompanyPortfolio.ts
+var loadCompanyPortfolio;
+var init_loadCompanyPortfolio = __esm({
+  "src/scripts/loadCompanyPortfolio.ts"() {
+    "use strict";
+    init_companyIntent();
+    loadCompanyPortfolio = async (ctx) => {
+      const portfolio = listCompanyPortfolio(ctx.config, ctx.cwd);
+      ctx.data.companyPortfolio = portfolio;
+      ctx.data.companyPortfolioJson = JSON.stringify(portfolio, null, 2);
+    };
+  }
+});
+
 // src/scripts/loadGoalState.ts
 function retryDelaysMs() {
   const raw = process.env.KODY_GOAL_STATE_RETRY_DELAYS_MS?.trim();
@@ -10620,8 +10793,8 @@ var init_loadIssueStateComment = __esm({
 
 // src/scripts/loadJobFromFile.ts
 import * as fs33 from "fs";
-import * as path33 from "path";
-function parseJobFile(raw, slug) {
+import * as path32 from "path";
+function parseJobFile(raw, slug2) {
   let stripped = raw;
   if (stripped.startsWith("---\n")) {
     const end = stripped.indexOf("\n---\n", 4);
@@ -10636,10 +10809,10 @@ function parseJobFile(raw, slug) {
     const rest = trimmed.slice(firstLine2.length).replace(/^\n+/, "");
     return { title: h1[1].trim(), body: rest };
   }
-  return { title: humanizeSlug3(slug), body: trimmed };
+  return { title: humanizeSlug3(slug2), body: trimmed };
 }
-function humanizeSlug3(slug) {
-  return slug.split(/[-_]+/).filter((s) => s.length > 0).map((s) => s[0].toUpperCase() + s.slice(1)).join(" ");
+function humanizeSlug3(slug2) {
+  return slug2.split(/[-_]+/).filter((s) => s.length > 0).map((s) => s[0].toUpperCase() + s.slice(1)).join(" ");
 }
 var AGENT_RESPONSIBILITY_TOOL_PALETTE2, loadJobFromFile;
 var init_loadJobFromFile = __esm({
@@ -10654,14 +10827,14 @@ var init_loadJobFromFile = __esm({
       const jobsDir = String(args?.jobsDir ?? ".kody/agent-responsibilities");
       const agentsDir = String(args?.agentsDir ?? ".kody/agents");
       const slugArg = String(args?.slugArg ?? "job");
-      const slug = String(ctx.args[slugArg] ?? "").trim();
-      if (!slug) {
+      const slug2 = String(ctx.args[slugArg] ?? "").trim();
+      if (!slug2) {
         throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
       }
-      const agentResponsibility = resolveAgentResponsibilityFolder(slug, path33.join(ctx.cwd, jobsDir));
+      const agentResponsibility = resolveAgentResponsibilityFolder(slug2, path32.join(ctx.cwd, jobsDir));
       if (!agentResponsibility) {
         throw new Error(
-          `loadJobFromFile: agentResponsibility folder not found or incomplete: ${path33.join(ctx.cwd, jobsDir, slug)}`
+          `loadJobFromFile: agentResponsibility folder not found or incomplete: ${path32.join(ctx.cwd, jobsDir, slug2)}`
         );
       }
       const { title, body, config } = agentResponsibility;
@@ -10673,7 +10846,7 @@ var init_loadJobFromFile = __esm({
         const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
         if (!fs33.existsSync(agentPath)) {
           throw new Error(
-            `loadJobFromFile: agentResponsibility '${slug}' declares agent '${agentSlug}' but ${agentPath} does not exist`
+            `loadJobFromFile: agentResponsibility '${slug2}' declares agent '${agentSlug}' but ${agentPath} does not exist`
           );
         }
         const agentRaw = fs33.readFileSync(agentPath, "utf-8");
@@ -10682,28 +10855,28 @@ var init_loadJobFromFile = __esm({
         agentIdentity = parsed.body;
       }
       const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
-      const loaded = await backend.load(slug);
-      ctx.data.jobSlug = slug;
+      const loaded = await backend.load(slug2);
+      ctx.data.jobSlug = slug2;
       ctx.data.jobTitle = title;
-      ctx.data.jobIntent = body.replace(/\{\{\s*mentions\s*\}\}/g, mentions).replace(/\{\{\s*agentResponsibility\s*\}\}/g, slug);
+      ctx.data.jobIntent = body.replace(/\{\{\s*mentions\s*\}\}/g, mentions).replace(/\{\{\s*agentResponsibility\s*\}\}/g, slug2);
       ctx.data.jobState = loaded;
       ctx.data.jobStateJson = JSON.stringify(loaded.state, null, 2);
       ctx.data.agentSlug = agentSlug;
       ctx.data.agentTitle = agentTitle;
       ctx.data.agentIdentity = agentIdentity;
       ctx.data.mentions = mentions;
-      ctx.data.agentResponsibilitySlug = slug;
+      ctx.data.agentResponsibilitySlug = slug2;
       ctx.data.agentResponsibilityTitle = title;
       ctx.data.agentSlug = agentSlug;
       ctx.data.agentTitle = agentTitle;
       ctx.data.agentActionSlug = profile.name;
-      ctx.data.agentResponsibilitySchedule = config.every ?? "";
+      ctx.data.agentResponsibilitySchedule = String(ctx.data.jobSchedule ?? "");
       const declaredTools = config.tools ?? [];
       if (declaredTools.length > 0) {
         const unknown = declaredTools.filter((name) => !AGENT_RESPONSIBILITY_TOOL_PALETTE2.has(name));
         if (unknown.length > 0) {
           throw new Error(
-            `loadJobFromFile: agentResponsibility '${slug}' declared tools not in the kody-agentResponsibility palette: ${unknown.join(", ")}. Available: ${[...AGENT_RESPONSIBILITY_MCP_TOOL_NAMES].join(", ")}`
+            `loadJobFromFile: agentResponsibility '${slug2}' declared tools not in the kody-agentResponsibility palette: ${unknown.join(", ")}. Available: ${[...AGENT_RESPONSIBILITY_MCP_TOOL_NAMES].join(", ")}`
           );
         }
         const mcpToolNames = declaredTools.map((name) => `mcp__kody-agent-responsibility__${name}`);
@@ -10751,9 +10924,9 @@ ${truncate(issue.body, FINDING_BODY_MAX_BYTES)}`;
 
 // src/scripts/kodyVariables.ts
 import * as fs34 from "fs";
-import * as path34 from "path";
+import * as path33 from "path";
 function readKodyVariables(cwd) {
-  const full = path34.join(cwd, KODY_VARIABLES_REL_PATH);
+  const full = path33.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
     raw = fs34.readFileSync(full, "utf-8");
@@ -10782,7 +10955,7 @@ var init_kodyVariables = __esm({
 
 // src/scripts/loadQaContext.ts
 import * as fs35 from "fs";
-import * as path35 from "path";
+import * as path34 from "path";
 function parseSlugList(value) {
   const inner = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
   return inner.split(",").map(
@@ -10811,7 +10984,7 @@ function readProfileAgents(raw) {
   return { agent: agent ?? legacy ?? ["kody"], body };
 }
 function readProfile(cwd) {
-  const dir = path35.join(cwd, CONTEXT_DIR_REL_PATH);
+  const dir = path34.join(cwd, CONTEXT_DIR_REL_PATH);
   if (!fs35.existsSync(dir)) return "";
   let entries;
   try {
@@ -10822,7 +10995,7 @@ function readProfile(cwd) {
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs35.readFileSync(path35.join(dir, file), "utf-8");
+      const raw = fs35.readFileSync(path34.join(dir, file), "utf-8");
       const { agent, body } = readProfileAgents(raw);
       if (!agent.includes(QA_AGENT) && !agent.includes(ALL_AGENTS)) continue;
       blocks.push(`## ${file}
@@ -10869,7 +11042,7 @@ var init_loadQaContext = __esm({
 
 // src/taskContext.ts
 import * as fs36 from "fs";
-import * as path36 from "path";
+import * as path35 from "path";
 function buildTaskContext(args) {
   return {
     schemaVersion: TASK_CONTEXT_SCHEMA_VERSION,
@@ -10886,7 +11059,7 @@ function persistTaskContext(cwd, ctx) {
   try {
     const dir = runtimeStatePath(cwd, "agent-runs", ctx.runId);
     fs36.mkdirSync(dir, { recursive: true });
-    const file = path36.join(dir, "task-context.json");
+    const file = path35.join(dir, "task-context.json");
     fs36.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
@@ -11303,8 +11476,8 @@ function parseAgentFactoryBundle(raw) {
   return { title, summary, files };
 }
 function buildAgentFactoryBranchName(issueNumber, title, now = Date.now()) {
-  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48).replace(/-+$/g, "");
-  const suffix = slug ? `-${slug}` : "";
+  const slug2 = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48).replace(/-+$/g, "");
+  const suffix = slug2 ? `-${slug2}` : "";
   return `agent-factory/issue-${issueNumber}-${now.toString(36)}${suffix}`;
 }
 function normalizeBundleFiles(ctx, bundle) {
@@ -11537,21 +11710,21 @@ var init_openQaIssue = __esm({
         ctx.data.action = failedAction3(reason);
         return;
       }
-      const reportBody = agentResult.finalText.trim();
-      if (!reportBody) {
+      const reportBody2 = agentResult.finalText.trim();
+      if (!reportBody2) {
         process.stderr.write("qa-engineer: agent produced no report body\n");
         ctx.output.exitCode = 1;
         ctx.output.reason = "empty report body";
         ctx.data.action = failedAction3("empty report body");
         return;
       }
-      const verdict = detectVerdict(reportBody);
+      const verdict = detectVerdict(reportBody2);
       ctx.data.qaVerdict = verdict;
-      ctx.data.qaReport = reportBody;
+      ctx.data.qaReport = reportBody2;
       const existingIssue = ctx.args.issue;
       if (typeof existingIssue === "number" && Number.isFinite(existingIssue) && existingIssue > 0) {
         try {
-          postIssueComment(existingIssue, reportBody, ctx.cwd);
+          postIssueComment(existingIssue, reportBody2, ctx.cwd);
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           ctx.output.exitCode = 4;
@@ -11573,7 +11746,7 @@ QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.gith
       const hasLabel = ensureLabel2(ctx.cwd);
       let created;
       try {
-        created = createQaIssue(title, reportBody, hasLabel, ctx.cwd);
+        created = createQaIssue(title, reportBody2, hasLabel, ctx.cwd);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         ctx.output.exitCode = 4;
@@ -11636,6 +11809,39 @@ var init_parseAgentResult = __esm({
   }
 });
 
+// src/scripts/parseCompanyManagerDecision.ts
+function makeAction3(type, payload) {
+  return { type, payload, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+}
+var parseCompanyManagerDecision;
+var init_parseCompanyManagerDecision = __esm({
+  "src/scripts/parseCompanyManagerDecision.ts"() {
+    "use strict";
+    init_companyManagerDecision();
+    parseCompanyManagerDecision = async (ctx, _profile, agentResult) => {
+      if (!agentResult) {
+        ctx.data.companyManagerDecision = { summary: "", actions: [] };
+        ctx.data.action = makeAction3("COMPANY_MANAGER_NOT_RUN", { reason: "no agent result" });
+        return;
+      }
+      try {
+        const decision = parseCompanyManagerDecisionText(agentResult.finalText);
+        ctx.data.companyManagerDecision = decision;
+        ctx.data.action = makeAction3("COMPANY_MANAGER_DECIDED", {
+          summary: decision.summary,
+          actionCount: decision.actions.length
+        });
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        ctx.data.companyManagerDecisionError = reason;
+        ctx.data.action = makeAction3("COMPANY_MANAGER_FAILED", { reason });
+        ctx.output.exitCode = 1;
+        ctx.output.reason = reason;
+      }
+    };
+  }
+});
+
 // src/scripts/stateEnvelope.ts
 function isPartialEnvelope(x) {
   if (x === null || typeof x !== "object") return false;
@@ -11896,6 +12102,119 @@ var init_persistFlowState = __esm({
   }
 });
 
+// src/scripts/planTaskJobs.ts
+function parseTaskJobSpecs(body) {
+  const match = body.match(new RegExp(`<!--\\s*${TASK_JOBS_MARKER}\\s*([\\s\\S]*?)-->`));
+  if (!match) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(match[1].trim());
+  } catch (err) {
+    throw new Error(`task job plan is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!Array.isArray(parsed)) throw new Error("task job plan must be a JSON array");
+  return parsed.map((entry, index) => normalizeSpec(entry, index));
+}
+function taskJobSpecToJob(spec, issueNumber) {
+  const cliArgs = spec.cliArgs ?? { issue: issueNumber };
+  const target = typeof spec.target === "number" ? spec.target : targetFromCliArgs(cliArgs) ?? issueNumber;
+  return {
+    agentResponsibility: spec.agentResponsibility ?? spec.agentAction,
+    agentAction: spec.agentAction,
+    why: spec.reason,
+    agent: spec.agent,
+    schedule: spec.schedule,
+    target,
+    cliArgs,
+    flavor: spec.flavor ?? "instant"
+  };
+}
+function normalizeSpec(input, index) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error(`task job plan entry ${index} must be an object`);
+  }
+  const raw = input;
+  const agentAction = typeof raw.agentAction === "string" ? raw.agentAction.trim() : "";
+  if (!/^[a-z][a-z0-9-]*$/.test(agentAction)) {
+    throw new Error(`task job plan entry ${index} must have a valid agentAction`);
+  }
+  const cliArgs = raw.cliArgs;
+  if (cliArgs !== void 0 && (!cliArgs || typeof cliArgs !== "object" || Array.isArray(cliArgs))) {
+    throw new Error(`task job plan entry ${index} cliArgs must be an object`);
+  }
+  const flavor = raw.flavor;
+  if (flavor !== void 0 && flavor !== "instant" && flavor !== "scheduled") {
+    throw new Error(`task job plan entry ${index} flavor must be "instant" or "scheduled"`);
+  }
+  return {
+    agentAction,
+    ...typeof raw.agentResponsibility === "string" && raw.agentResponsibility.trim() ? { agentResponsibility: raw.agentResponsibility.trim() } : {},
+    ...typeof raw.reason === "string" && raw.reason.trim() ? { reason: raw.reason.trim() } : {},
+    ...typeof raw.agent === "string" && raw.agent.trim() ? { agent: raw.agent.trim() } : {},
+    ...typeof raw.agent === "string" && raw.agent.trim() ? { agent: raw.agent.trim() } : {},
+    ...cliArgs ? { cliArgs } : {},
+    ...typeof raw.target === "number" && Number.isFinite(raw.target) ? { target: raw.target } : {},
+    ...flavor === "instant" || flavor === "scheduled" ? { flavor } : {},
+    ...typeof raw.schedule === "string" && raw.schedule.trim() ? { schedule: raw.schedule.trim() } : {}
+  };
+}
+function jobToPlannedTaskJob(job) {
+  return {
+    id: stableJobKey(job),
+    agentAction: job.agentAction ?? job.agentResponsibility ?? "unknown",
+    agentResponsibility: job.agentResponsibility ?? job.action ?? job.agentAction ?? "unknown",
+    ...job.agent ? { agent: job.agent } : {},
+    ...job.flavor ? { flavor: job.flavor } : {},
+    ...job.schedule ? { schedule: job.schedule } : {},
+    ...typeof job.target === "number" ? { target: job.target } : {},
+    ...job.why ? { reason: job.why } : {}
+  };
+}
+function assertUniqueJobIds(planned) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const job of planned) {
+    if (seen.has(job.id)) throw new Error(`duplicate planned task job id: ${job.id}`);
+    seen.add(job.id);
+  }
+}
+var TASK_JOBS_MARKER, planTaskJobs;
+var init_planTaskJobs = __esm({
+  "src/scripts/planTaskJobs.ts"() {
+    "use strict";
+    init_jobIdentity();
+    init_state();
+    TASK_JOBS_MARKER = "kody:task-jobs:v1";
+    planTaskJobs = async (ctx) => {
+      const issueNumber = ctx.args.issue;
+      if (!issueNumber) {
+        ctx.skipAgent = true;
+        ctx.output.exitCode = 64;
+        ctx.output.reason = "planTaskJobs requires --issue";
+        return;
+      }
+      const issue = ctx.data.issue;
+      const specs = parseTaskJobSpecs(issue?.body ?? "");
+      if (specs.length === 0) {
+        ctx.skipAgent = true;
+        ctx.output.exitCode = 64;
+        ctx.output.reason = `no ${TASK_JOBS_MARKER} block found on issue #${issueNumber}`;
+        return;
+      }
+      const jobs = specs.map((spec) => taskJobSpecToJob(spec, issueNumber));
+      const planned = jobs.map(jobToPlannedTaskJob);
+      assertUniqueJobIds(planned);
+      const prior = ctx.data.taskState ?? emptyState();
+      const next = upsertTaskJobs(prior, planned, (/* @__PURE__ */ new Date()).toISOString());
+      ctx.data.taskState = next;
+      ctx.data.plannedTaskJobs = jobs;
+      ctx.data.plannedTaskJobIds = planned.map((job) => job.id);
+      const target = ctx.data.commentTargetType;
+      const number = ctx.data.commentTargetNumber;
+      if (target && number) writeTaskState(target, number, next, ctx.cwd, ctx.config);
+    };
+  }
+});
+
 // src/scripts/postAgentSummaryComment.ts
 function postAgentSummaryComment(ctx, opts = {}) {
   if (!ctx.data.agentDone) return;
@@ -12195,7 +12514,7 @@ function tryAuditComment(issueNumber, body, cwd) {
   } catch {
   }
 }
-function makeAction3(type, payload) {
+function makeAction4(type, payload) {
   return { type, payload, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
 }
 function failedAction4(reason) {
@@ -12232,7 +12551,7 @@ var init_recordClassification = __esm({
         ctx.output.reason = "classify: no decision";
         return;
       }
-      ctx.data.action = makeAction3(`CLASSIFIED_AS_${classification.toUpperCase()}`, {
+      ctx.data.action = makeAction4(`CLASSIFIED_AS_${classification.toUpperCase()}`, {
         classification,
         reason: reason ?? "",
         source: ctx.data.classificationSource ?? "agent"
@@ -13075,12 +13394,12 @@ fi
 
 // src/scripts/runPreviewBuild.ts
 import { copyFile, writeFile } from "fs/promises";
-import * as path37 from "path";
+import * as path36 from "path";
 import { fileURLToPath } from "url";
 function bundledDockerfilePath(mode) {
-  const here = path37.dirname(fileURLToPath(import.meta.url));
+  const here = path36.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 path36.join(here, "preview-build-templates", file);
 }
 function required(name) {
   const v = (process.env[name] ?? "").trim();
@@ -13339,10 +13658,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(path36.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
 `, "utf8");
         }
-        const consumerDockerfile = path37.join(ctx.cwd, "Dockerfile.preview");
+        const consumerDockerfile = path36.join(ctx.cwd, "Dockerfile.preview");
         const { stat } = await import("fs/promises");
         let hasConsumerDockerfile = false;
         try {
@@ -13527,7 +13846,7 @@ var init_tickShellRunner = __esm({
 
 // src/scripts/runScheduledAgentActionTick.ts
 import * as fs37 from "fs";
-import * as path38 from "path";
+import * as path37 from "path";
 var runScheduledAgentActionTick;
 var init_runScheduledAgentActionTick = __esm({
   "src/scripts/runScheduledAgentActionTick.ts"() {
@@ -13541,19 +13860,19 @@ var init_runScheduledAgentActionTick = __esm({
       const slugArg = String(args?.slugArg ?? "agentResponsibility");
       const fenceLabel = String(args?.fenceLabel ?? "kody-job-next-state");
       const shell = String(args?.shell ?? "tick.sh");
-      const slug = String(args?.slug ?? ctx.args[slugArg] ?? "").trim();
-      if (!slug) {
+      const slug2 = String(args?.slug ?? ctx.args[slugArg] ?? "").trim();
+      if (!slug2) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledAgentActionTick: args.slug or ctx.args.${slugArg} must be non-empty agentResponsibility slug`;
         return;
       }
-      const agentResponsibility = resolveAgentResponsibilityFolder(slug, path38.join(ctx.cwd, jobsDir));
+      const agentResponsibility = resolveAgentResponsibilityFolder(slug2, path37.join(ctx.cwd, jobsDir));
       if (!agentResponsibility) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runScheduledAgentActionTick: agentResponsibility folder not found or incomplete: ${slug} (searched ${jobsDir} and company store)`;
+        ctx.output.reason = `runScheduledAgentActionTick: agentResponsibility folder not found or incomplete: ${slug2} (searched ${jobsDir} and company store)`;
         return;
       }
-      const shellPath = path38.join(profile.dir, shell);
+      const shellPath = path37.join(profile.dir, shell);
       if (!fs37.existsSync(shellPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledAgentActionTick: shell not found: ${shell} (looked in ${profile.dir})`;
@@ -13562,14 +13881,14 @@ var init_runScheduledAgentActionTick = __esm({
       const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
       let loaded;
       try {
-        loaded = await backend.load(slug);
+        loaded = await backend.load(slug2);
       } catch (err) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledAgentActionTick: state load failed: ${err instanceof Error ? err.message : String(err)}`;
         return;
       }
-      ctx.data.jobSlug = slug;
-      ctx.data.agentResponsibilitySlug = slug;
+      ctx.data.jobSlug = slug2;
+      ctx.data.agentResponsibilitySlug = slug2;
       ctx.data.agentActionSlug = profile.name;
       ctx.data.jobState = loaded;
       runTickShellAndParse({
@@ -13586,7 +13905,7 @@ var init_runScheduledAgentActionTick = __esm({
 
 // src/scripts/runTickScript.ts
 import * as fs38 from "fs";
-import * as path39 from "path";
+import * as path38 from "path";
 var runTickScript;
 var init_runTickScript = __esm({
   "src/scripts/runTickScript.ts"() {
@@ -13599,25 +13918,25 @@ var init_runTickScript = __esm({
       const jobsDir = String(args?.jobsDir ?? ".kody/agent-responsibilities");
       const slugArg = String(args?.slugArg ?? "job");
       const fenceLabel = String(args?.fenceLabel ?? "kody-job-next-state");
-      const slug = String(ctx.args[slugArg] ?? "").trim();
-      if (!slug) {
+      const slug2 = String(ctx.args[slugArg] ?? "").trim();
+      if (!slug2) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
         return;
       }
-      const agentResponsibility = readAgentResponsibilityFolder(path39.join(ctx.cwd, jobsDir), slug);
+      const agentResponsibility = readAgentResponsibilityFolder(path38.join(ctx.cwd, jobsDir), slug2);
       if (!agentResponsibility) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runTickScript: agentResponsibility folder not found or incomplete: ${path39.join(ctx.cwd, jobsDir, slug)}`;
+        ctx.output.reason = `runTickScript: agentResponsibility folder not found or incomplete: ${path38.join(ctx.cwd, jobsDir, slug2)}`;
         return;
       }
       const tickScript = agentResponsibility.config.tickScript;
       if (!tickScript) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runTickScript: agentResponsibility ${slug} has no \`tickScript\` in profile.json \u2014 route via agent-responsibility-tick instead`;
+        ctx.output.reason = `runTickScript: agentResponsibility ${slug2} has no \`tickScript\` in profile.json \u2014 route via agent-responsibility-tick instead`;
         return;
       }
-      const scriptPath = path39.isAbsolute(tickScript) ? tickScript : path39.join(ctx.cwd, tickScript);
+      const scriptPath = path38.isAbsolute(tickScript) ? tickScript : path38.join(ctx.cwd, tickScript);
       if (!fs38.existsSync(scriptPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
@@ -13626,13 +13945,13 @@ var init_runTickScript = __esm({
       const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
       let loaded;
       try {
-        loaded = await backend.load(slug);
+        loaded = await backend.load(slug2);
       } catch (err) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: state load failed: ${err instanceof Error ? err.message : String(err)}`;
         return;
       }
-      ctx.data.jobSlug = slug;
+      ctx.data.jobSlug = slug2;
       ctx.data.jobState = loaded;
       runTickShellAndParse({
         ctx,
@@ -14577,6 +14896,86 @@ var init_writeJobStateFile = __esm({
   }
 });
 
+// src/scripts/writeResponsibilityReport.ts
+function writeReport(ctx, profile, agentResult) {
+  const slug2 = responsibilitySlug(ctx);
+  if (!slug2) {
+    fail2(ctx, "writeResponsibilityReport: missing responsibility slug");
+    return;
+  }
+  if (!REPORT_SLUG_RE.test(slug2)) {
+    fail2(ctx, `writeResponsibilityReport: invalid responsibility slug "${slug2}"`);
+    return;
+  }
+  const body = reportBody(ctx, agentResult, profile);
+  if (!body.trim()) {
+    fail2(ctx, `writeResponsibilityReport: ${slug2} produced no report output`);
+    return;
+  }
+  const filePath = `reports/${slug2}.md`;
+  const current = readStateText(ctx.config, ctx.cwd, filePath);
+  if (current?.content === body) {
+    ctx.data.responsibilityReport = { slug: slug2, path: current.path, changed: false };
+    return;
+  }
+  upsertStateText(
+    ctx.config,
+    ctx.cwd,
+    filePath,
+    body,
+    `chore(reports): refresh ${slug2}`
+  );
+  ctx.data.responsibilityReport = { slug: slug2, path: filePath, changed: true };
+}
+function responsibilitySlug(ctx) {
+  const candidates = [
+    ctx.data.jobAgentResponsibility,
+    ctx.data.agentResponsibilitySlug,
+    ctx.data.jobSlug
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
+  }
+  return null;
+}
+function reportBody(ctx, agentResult, profile) {
+  const prSummary = ctx.data.prSummary;
+  if (typeof prSummary === "string" && prSummary.trim()) return ensureTrailingNewline(prSummary.trim());
+  if (agentResult?.finalText.trim()) return ensureTrailingNewline(agentResult.finalText.trim());
+  const reason = ctx.output.reason || ctx.data.agentFailureReason || agentResult?.error;
+  if (typeof reason === "string" && reason.trim()) {
+    return `# ${profile.name}
+
+FAILED: ${reason.trim()}
+`;
+  }
+  return "";
+}
+function fail2(ctx, reason) {
+  ctx.output.reason = ctx.output.reason ? `${ctx.output.reason}; ${reason}` : reason;
+  if (ctx.output.exitCode === 0) ctx.output.exitCode = 99;
+}
+function ensureTrailingNewline(value) {
+  return value.endsWith("\n") ? value : `${value}
+`;
+}
+var REPORT_SLUG_RE, writeResponsibilityReport;
+var init_writeResponsibilityReport = __esm({
+  "src/scripts/writeResponsibilityReport.ts"() {
+    "use strict";
+    init_stateRepo();
+    REPORT_SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+    writeResponsibilityReport = async (ctx, profile, agentResult) => {
+      if (ctx.data.jobSaveReport !== true) return;
+      try {
+        writeReport(ctx, profile, agentResult);
+      } catch (err) {
+        fail2(ctx, `writeResponsibilityReport: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    };
+  }
+});
+
 // src/scripts/index.ts
 var preflightScripts, postflightScripts, allScriptNames;
 var init_scripts = __esm({
@@ -14586,7 +14985,9 @@ var init_scripts = __esm({
     init_advanceFlow();
     init_advanceManagedGoal();
     init_appendCompanyActivity();
+    init_appendCompanyIntentDecision();
     init_applyAgentResponsibilityReports();
+    init_applyCompanyManagerDecision();
     init_buildSyntheticPlugin();
     init_checkCoverageWithRetry();
     init_classifyByLabel();
@@ -14611,6 +15012,8 @@ var init_scripts = __esm({
     init_initFlow();
     init_loadAgentAdhoc();
     init_loadAgentResponsibilityState();
+    init_loadCompanyIntents();
+    init_loadCompanyPortfolio();
     init_loadConventions();
     init_loadCoverageRules();
     init_loadGoalState();
@@ -14631,6 +15034,7 @@ var init_scripts = __esm({
     init_openAgentFactoryStatePr();
     init_openQaIssue();
     init_parseAgentResult();
+    init_parseCompanyManagerDecision();
     init_parseIssueStateFromAgentResult();
     init_parseJobStateFromAgentResult();
     init_parseReproOutput();
@@ -14673,6 +15077,7 @@ var init_scripts = __esm({
     init_writeAgentRunSummary();
     init_writeIssueStateComment();
     init_writeJobStateFile();
+    init_writeResponsibilityReport();
     preflightScripts = {
       runFlow,
       fixFlow,
@@ -14689,6 +15094,8 @@ var init_scripts = __esm({
       loadIssueStateComment,
       loadJobFromFile,
       loadAgentResponsibilityState,
+      loadCompanyIntents,
+      loadCompanyPortfolio,
       loadAgentAdhoc,
       loadConventions,
       loadCoverageRules,
@@ -14723,12 +15130,15 @@ var init_scripts = __esm({
     };
     postflightScripts = {
       parseAgentResult: parseAgentResult2,
+      parseCompanyManagerDecision,
       parseIssueStateFromAgentResult,
       parseJobStateFromAgentResult,
       parseReproOutput,
       writeIssueStateComment,
       writeJobStateFile,
       appendCompanyActivity,
+      appendCompanyIntentDecision: appendCompanyIntentDecision2,
+      applyCompanyManagerDecision,
       requireFeedbackActions,
       requirePlanDeviations,
       verify,
@@ -14746,6 +15156,7 @@ var init_scripts = __esm({
       postReviewResult,
       persistArtifacts,
       writeAgentRunSummary,
+      writeResponsibilityReport,
       saveTaskState,
       mirrorStateToPr,
       startFlow,
@@ -14842,7 +15253,7 @@ var init_tools = __esm({
 // src/executor.ts
 import { spawn as spawn7 } from "child_process";
 import * as fs40 from "fs";
-import * as path40 from "path";
+import * as path39 from "path";
 function isMutatingPostflight(scriptName) {
   return MUTATING_POSTFLIGHTS.has(scriptName ?? "");
 }
@@ -15007,13 +15418,13 @@ async function runAgentAction(profileName, input) {
       })
     };
   })() : null;
-  const ndjsonDir = path40.join(input.cwd, ".kody");
+  const ndjsonDir = path39.join(input.cwd, ".kody");
   const agentSlug = typeof profile.agent === "string" && profile.agent.length > 0 ? profile.agent : typeof ctx.data.jobAgent === "string" && ctx.data.jobAgent.length > 0 ? ctx.data.jobAgent : null;
   const agentIdentityBlock = agentSlug ? frameAgentIdentity(agentSlug, loadAgentIdentity(input.cwd, agentSlug)) : null;
   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) => path40.isAbsolute(p) ? p : path40.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path39.isAbsolute(p) ? p : path39.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
@@ -15248,6 +15659,7 @@ async function runAgentAction(profileName, input) {
         outcome: postOutcome
       });
     }
+    await writeResponsibilityReport(ctx, profile, agentResult);
     return finishAndEnd({
       exitCode: ctx.output.exitCode ?? 0,
       prUrl: ctx.output.prUrl,
@@ -15376,7 +15788,8 @@ function handoffToJob(handoff) {
     agentResponsibility: handoff.agentResponsibility,
     agentAction: handoff.agentAction,
     cliArgs: handoff.cliArgs,
-    flavor: "instant"
+    flavor: "instant",
+    saveReport: handoff.saveReport === true
   };
 }
 function clearStampedLifecycleLabels(profile, ctx) {
@@ -15395,13 +15808,13 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function resolveProfilePath(profileName) {
   const found = resolveAgentAction(profileName);
   if (found) return found;
-  const here = path40.dirname(new URL(import.meta.url).pathname);
+  const here = path39.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path40.join(here, "agent-actions", profileName, "profile.json"),
+    path39.join(here, "agent-actions", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path40.join(here, "..", "agent-actions", profileName, "profile.json"),
+    path39.join(here, "..", "agent-actions", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/agent-actions)
-    path40.join(here, "..", "src", "agent-actions", profileName, "profile.json")
+    path39.join(here, "..", "src", "agent-actions", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
@@ -15503,7 +15916,7 @@ function resolveShellTimeoutMs(entry) {
 }
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path40.join(profile.dir, shellName);
+  const shellPath = path39.join(profile.dir, shellName);
   if (!fs40.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
@@ -15636,6 +16049,7 @@ var init_executor = __esm({
     init_profile();
     init_registry();
     init_scripts();
+    init_writeResponsibilityReport();
     init_subagents();
     init_task_artifacts();
     init_tools();
@@ -15663,7 +16077,7 @@ __export(job_exports, {
   stableJobKey: () => stableJobKey,
   validateJob: () => validateJob
 });
-import * as path41 from "path";
+import * as path40 from "path";
 function newJobId(flavor) {
   localJobSeq += 1;
   const runId = process.env.GITHUB_RUN_ID;
@@ -15694,13 +16108,14 @@ function validateJob(input) {
     target: typeof j.target === "number" ? j.target : void 0,
     cliArgs: j.cliArgs ?? {},
     flavor: j.flavor,
-    force: j.force === true
+    force: j.force === true,
+    saveReport: j.saveReport === true
   };
 }
 async function runJob(job, base) {
   const valid = validateJob(job);
   const action = valid.action ?? valid.agentResponsibility;
-  const projectAgentResponsibilitiesRoot = path41.join(base.cwd, ".kody", "agent-responsibilities");
+  const projectAgentResponsibilitiesRoot = path40.join(base.cwd, ".kody", "agent-responsibilities");
   const resolvedAgentResponsibility = action ? resolveAgentResponsibilityAction(action, projectAgentResponsibilitiesRoot) : null;
   const agentResponsibilityIdentity = valid.agentResponsibility ?? resolvedAgentResponsibility?.agentResponsibility;
   const agentResponsibilityContext = loadAgentResponsibilityContext(agentResponsibilityIdentity, base.cwd);
@@ -15727,6 +16142,7 @@ async function runJob(job, base) {
   if (executableIdentity !== void 0 && executableIdentity.length > 0)
     preloadedData.jobAgentAction = executableIdentity;
   if (valid.schedule !== void 0 && valid.schedule.length > 0) preloadedData.jobSchedule = valid.schedule;
+  if (valid.saveReport === true) preloadedData.jobSaveReport = true;
   if (agentResponsibilityContext) {
     preloadedData.agentResponsibilitySlug = agentResponsibilityContext.slug;
     preloadedData.agentResponsibilityTitle = agentResponsibilityContext.title;
@@ -15737,9 +16153,6 @@ async function runJob(job, base) {
     if (agentResponsibilityContext.config.agent && preloadedData.jobAgent === void 0) {
       preloadedData.jobAgent = agentResponsibilityContext.config.agent;
     }
-    if (agentResponsibilityContext.config.every && preloadedData.jobSchedule === void 0) {
-      preloadedData.jobSchedule = agentResponsibilityContext.config.every;
-    }
     if (agentResponsibilityContext.config.mentions && agentResponsibilityContext.config.mentions.length > 0) {
       preloadedData.mentions = agentResponsibilityContext.config.mentions.map((login) => `@${login}`).join(" ");
     }
@@ -15760,9 +16173,9 @@ async function runJob(job, base) {
   const run = base.chain === false ? runAgentAction : runAgentActionChain;
   return run(profileName, input);
 }
-function loadAgentResponsibilityContext(slug, cwd) {
-  if (!slug) return null;
-  return resolveAgentResponsibilityFolder(slug, path41.join(cwd, ".kody", "agent-responsibilities"));
+function loadAgentResponsibilityContext(slug2, cwd) {
+  if (!slug2) return null;
+  return resolveAgentResponsibilityFolder(slug2, path40.join(cwd, ".kody", "agent-responsibilities"));
 }
 function mintInstantJob(dispatch2, opts) {
   return {
@@ -15784,7 +16197,8 @@ function mintScheduledJob(input) {
     schedule: input.schedule,
     agent: input.agent,
     cliArgs: input.cliArgs ?? {},
-    flavor: "scheduled"
+    flavor: "scheduled",
+    saveReport: input.saveReport === true
   };
 }
 var DEFAULT_INSTANT_AGENT, localJobSeq, InvalidJobError;
@@ -15915,7 +16329,7 @@ function translateOpenAISseToBrain(opts) {
 // src/servers/brain-serve.ts
 import * as fs43 from "fs";
 import { createServer } from "http";
-import * as path44 from "path";
+import * as path43 from "path";
 
 // src/chat/loop.ts
 init_agent();
@@ -16458,7 +16872,7 @@ init_config();
 // src/kody-cli.ts
 import { execFileSync as execFileSync25 } from "child_process";
 import * as fs41 from "fs";
-import * as path42 from "path";
+import * as path41 from "path";
 
 // src/app-auth.ts
 import { createSign } from "crypto";
@@ -17054,9 +17468,9 @@ async function resolveAuthToken(env = process.env) {
   return void 0;
 }
 function detectPackageManager2(cwd) {
-  if (fs41.existsSync(path42.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs41.existsSync(path42.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs41.existsSync(path42.join(cwd, "bun.lockb"))) return "bun";
+  if (fs41.existsSync(path41.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs41.existsSync(path41.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs41.existsSync(path41.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -17143,7 +17557,7 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path42.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path41.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
     if (fs41.existsSync(logPath)) {
@@ -17172,7 +17586,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path42.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path41.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   let earlyConfigError;
   try {
@@ -17514,10 +17928,10 @@ init_repoWorkspace();
 
 // src/scripts/brainTurnLog.ts
 import * as fs42 from "fs";
-import * as path43 from "path";
+import * as path42 from "path";
 var live = /* @__PURE__ */ new Map();
 function eventsPath2(dir, chatId) {
-  return path43.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
+  return path42.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
 }
 function lastPersistedSeq(dir, chatId) {
   const p = eventsPath2(dir, chatId);
@@ -17560,7 +17974,7 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = eventsPath2(dir, chatId);
-  fs42.mkdirSync(path43.dirname(p), { recursive: true });
+  fs42.mkdirSync(path42.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
@@ -17835,7 +18249,7 @@ async function handleChatTurn(req, res, chatId, opts) {
   const repo = strField(body, "repo");
   const repoToken = strField(body, "repoToken");
   const sessionFile = sessionFilePath(opts.cwd, chatId);
-  fs43.mkdirSync(path44.dirname(sessionFile), { recursive: true });
+  fs43.mkdirSync(path43.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
     role: "user",
     content: message,
@@ -17882,7 +18296,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 ?? path44.join(path44.dirname(path44.resolve(opts.cwd)), "repos");
+  const reposRoot = opts.reposRoot ?? path43.join(path43.dirname(path43.resolve(opts.cwd)), "repos");
   return createServer(async (req, res) => {
     if (!req.method || !req.url) {
       sendJson(res, 400, { error: "bad request" });
@@ -18478,13 +18892,13 @@ async function loadConfigSafe() {
 // src/chat-cli.ts
 import { execFileSync as execFileSync28 } from "child_process";
 import * as fs45 from "fs";
-import * as path46 from "path";
+import * as path45 from "path";
 
 // src/chat/modes/interactive.ts
 init_issue();
 import { execFileSync as execFileSync27 } from "child_process";
 import * as fs44 from "fs";
-import * as path45 from "path";
+import * as path44 from "path";
 
 // src/chat/inbox.ts
 import { execFileSync as execFileSync26 } from "child_process";
@@ -18644,9 +19058,9 @@ function findNextUserTurn(turns, fromIdx) {
   return -1;
 }
 function commitTurn(cwd, sessionId, _verbose) {
-  const sessionRel = path45.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsRel = path45.relative(cwd, eventsFilePath(cwd, sessionId));
-  const rels = [sessionRel, eventsRel].filter((p) => fs44.existsSync(path45.join(cwd, p)));
+  const sessionRel = path44.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsRel = path44.relative(cwd, eventsFilePath(cwd, sessionId));
+  const rels = [sessionRel, eventsRel].filter((p) => fs44.existsSync(path44.join(cwd, p)));
   if (rels.length === 0) return;
   const repository = process.env.GITHUB_REPOSITORY;
   if (!repository) {
@@ -18658,8 +19072,8 @@ function commitTurn(cwd, sessionId, _verbose) {
   }
   const branch = defaultBranch(cwd) ?? "main";
   for (const rel of rels) {
-    const repoPath = rel.split(path45.sep).join("/");
-    const localText = fs44.readFileSync(path45.join(cwd, rel), "utf-8");
+    const repoPath = rel.split(path44.sep).join("/");
+    const localText = fs44.readFileSync(path44.join(cwd, rel), "utf-8");
     putJsonlViaContents(repository, branch, repoPath, localText, sessionId, cwd);
   }
 }
@@ -18804,12 +19218,12 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path46.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path46.relative(cwd, eventsFilePath(cwd, sessionId));
+  const sessionFile = path45.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path45.relative(cwd, eventsFilePath(cwd, sessionId));
   const safeSession = sessionId.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const tasksDir = path46.join(".kody", "tasks", safeSession);
+  const tasksDir = path45.join(".kody", "tasks", safeSession);
   const candidatePaths = [sessionFile, eventsFile, tasksDir];
-  const paths = candidatePaths.filter((p) => fs45.existsSync(path46.join(cwd, p)));
+  const paths = candidatePaths.filter((p) => fs45.existsSync(path45.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
@@ -18853,7 +19267,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path46.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path45.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -19064,8 +19478,8 @@ var FlyClient = class {
   get fetch() {
     return this.opts.fetchImpl ?? fetch;
   }
-  async call(path47, init = {}) {
-    const res = await this.fetch(`${FLY_API_BASE}${path47}`, {
+  async call(path46, init = {}) {
+    const res = await this.fetch(`${FLY_API_BASE}${path46}`, {
       method: init.method ?? "GET",
       headers: {
         Authorization: `Bearer ${this.opts.token}`,
@@ -19076,7 +19490,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 ${path47}: ${text.slice(0, 200) || res.statusText}`);
+      throw new Error(`Fly API ${res.status} on ${path46}: ${text.slice(0, 200) || res.statusText}`);
     }
     if (res.status === 204) return null;
     const raw = await res.text();