@kody-ade/kody-engine 0.4.255 → 0.4.257

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.255",
+      version: "0.4.257",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative agentAction profiles.",
       license: "MIT",
       type: "module",
@@ -3069,9 +3069,9 @@ function parseAgentResponsibilityReportsFromText(text) {
 function parseAgentResponsibilityReport(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
   const obj = raw;
-  const target = parseTarget(obj.target);
+  const target = parseAgentResponsibilityReportTarget(obj.target);
   if (!target) return null;
-  const evidence = parseBooleanRecord(obj.evidence);
+  const evidence = parseAgentResponsibilityReportEvidence(obj.evidence);
   const facts = parseFacts(obj.facts);
   if (!evidence && !facts) return null;
   return {
@@ -3080,36 +3080,14 @@ function parseAgentResponsibilityReport(raw) {
     ...facts ? { facts } : {}
   };
 }
-function applyAgentResponsibilityReportToGoalState(state, report) {
-  const priorFacts = parseFacts(state.extra.facts) ?? {};
-  const nextFacts = { ...priorFacts };
-  for (const [key, value] of Object.entries(report.facts ?? {})) {
-    if (CONTROL_FACT_KEYS.has(key)) continue;
-    nextFacts[key] = value;
-  }
-  for (const [key, value] of Object.entries(report.evidence ?? {})) {
-    nextFacts[key] = value;
-  }
-  const pending = nextFacts.pendingEvidence;
-  if (typeof pending === "string" && Object.hasOwn(report.evidence ?? {}, pending)) {
-    delete nextFacts.pendingEvidence;
-  }
-  return {
-    ...state,
-    extra: {
-      ...state.extra,
-      facts: nextFacts
-    }
-  };
-}
-function parseTarget(raw) {
+function parseAgentResponsibilityReportTarget(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
   const target = raw;
   if (target.type !== "goal" && target.type !== "task" && target.type !== "agentResponsibility") return null;
   if (typeof target.id !== "string" || target.id.trim().length === 0) return null;
   return { type: target.type, id: target.id.trim() };
 }
-function parseBooleanRecord(raw) {
+function parseAgentResponsibilityReportEvidence(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
   const out = {};
   for (const [key, value] of Object.entries(raw)) {
@@ -3158,50 +3136,28 @@ function parseAgentResponsibilityResult(raw) {
   if (!isAgentResponsibilityResultStatus(obj.status)) return null;
   const summary = typeof obj.summary === "string" ? obj.summary.trim() : "";
   if (!summary) return null;
+  const target = obj.target === void 0 ? void 0 : parseAgentResponsibilityReportTarget(obj.target);
+  if (obj.target !== void 0 && !target) return null;
+  const evidence = obj.evidence === void 0 ? void 0 : parseAgentResponsibilityReportEvidence(obj.evidence);
+  if (obj.evidence !== void 0 && !evidence) return null;
   const facts = parseFacts2(obj.facts);
   if (!facts) return null;
   const artifacts = parseArtifacts(obj.artifacts);
   if (!artifacts) return null;
+  const missingEvidence = parseOptionalStringArray(obj.missingEvidence);
+  if (!missingEvidence) return null;
+  const blockers = parseOptionalStringArray(obj.blockers);
+  if (!blockers) return null;
   return {
     version: 1,
+    ...target ? { target } : {},
     status: obj.status,
     summary,
+    ...evidence ? { evidence } : {},
     facts,
-    artifacts
-  };
-}
-function applyAgentResponsibilityResultToObjectiveState(state, result, evidenceOverride) {
-  const priorFacts = parseFacts2(state.extra.facts) ?? {};
-  const nextFacts = { ...priorFacts };
-  for (const [key, value] of Object.entries(result.facts)) {
-    if (CONTROL_FACT_KEYS2.has(key)) continue;
-    nextFacts[key] = value;
-  }
-  const evidence = evidenceOverride || (typeof nextFacts.pendingEvidence === "string" ? nextFacts.pendingEvidence : "");
-  if (evidence) {
-    if (result.status === "pass") nextFacts[evidence] = true;
-    if (result.status === "fail" || result.status === "blocked") nextFacts[evidence] = false;
-    if ((result.status === "pass" || result.status === "fail" || result.status === "blocked") && nextFacts.pendingEvidence === evidence) {
-      delete nextFacts.pendingEvidence;
-    }
-  }
-  const blockers = parseStringArray(state.extra.blockers) ?? [];
-  if ((result.status === "fail" || result.status === "blocked") && !blockers.includes(result.summary)) {
-    blockers.push(result.summary);
-  }
-  return {
-    ...state,
-    extra: {
-      ...state.extra,
-      facts: nextFacts,
-      blockers,
-      lastAgentResponsibilityResult: {
-        status: result.status,
-        summary: result.summary,
-        facts: result.facts,
-        artifacts: result.artifacts
-      }
-    }
+    artifacts,
+    missingEvidence,
+    blockers
   };
 }
 function isAgentResponsibilityResultStatus(value) {
@@ -3227,6 +3183,10 @@ function parseStringArray(raw) {
   }
   return out;
 }
+function parseOptionalStringArray(raw) {
+  if (raw === void 0) return [];
+  return parseStringArray(raw);
+}
 function parseArtifacts(raw) {
   if (raw === void 0) return [];
   if (!Array.isArray(raw)) return null;
@@ -3250,6 +3210,7 @@ var RESULT_LINE, STATUSES, CONTROL_FACT_KEYS2;
 var init_agent_responsibilityResult = __esm({
   "src/agent-responsibilityResult.ts"() {
     "use strict";
+    init_agent_responsibilityReport();
     RESULT_LINE = /^KODY_AGENT_RESPONSIBILITY_RESULT=(.+)$/gm;
     STATUSES = /* @__PURE__ */ new Set(["pass", "fail", "blocked", "changed", "noop"]);
     CONTROL_FACT_KEYS2 = /* @__PURE__ */ new Set(["blockers", "destination", "agent-responsibilities", "route", "stage", "state"]);
@@ -6180,6 +6141,7 @@ var init_state2 = __esm({
 });
 
 // src/goal/runLog.ts
+import * as fs25 from "fs";
 function stageGoalRunLogEvent(data, goalId, event, at = nowIso()) {
   const logs = goalRunLogs(data);
   const existing = logs[goalId];
@@ -6201,7 +6163,7 @@ function flushGoalRunLogEvents(config, cwd, data) {
   const logs = goalRunLogs(data);
   for (const [goalId, log2] of Object.entries(logs)) {
     if (log2.events.length === 0) continue;
-    const lines = `${log2.events.map((event) => JSON.stringify(event)).join("\n")}
+    const lines = `${log2.events.map((event) => JSON.stringify(enrichGoalRunLogEvent(config, data, log2.path, event))).join("\n")}
 `;
     appendStateLine(config, cwd, log2.path, lines, `chore(goal-logs): append ${goalId}`);
     log2.events = [];
@@ -6212,6 +6174,55 @@ function goalRunLogPath(goalId, data) {
   const runId = goalRunId(data);
   return `logs/goals/${safePathSegment(goalId)}/runs/${startedAt}-${runId}.jsonl`;
 }
+function goalStateLogPath(goalId) {
+  return `goals/instances/${safePathSegment(goalId)}/state.json`;
+}
+function goalRunLogSnapshot(goalId, goalState, goal) {
+  const requiredEvidence = [...goal.destination.evidence];
+  const pendingEvidence = typeof goal.facts.pendingEvidence === "string" ? goal.facts.pendingEvidence : void 0;
+  return {
+    id: goalId,
+    type: goal.type,
+    state: goalState,
+    stage: goal.stage,
+    outcome: goal.destination.outcome,
+    requiredEvidence,
+    satisfiedEvidence: requiredEvidence.filter((evidence) => goal.facts[evidence] === true),
+    failedEvidence: requiredEvidence.filter((evidence) => goal.facts[evidence] === false),
+    missingEvidence: requiredEvidence.filter((evidence) => goal.facts[evidence] !== true),
+    pendingEvidence,
+    agentResponsibilities: [...goal.agentResponsibilities],
+    route: goal.route.map(routeStepForLog),
+    schedule: goal.schedule,
+    preferredRunTime: goal.preferredRunTime,
+    loopTarget: goal.loopTarget,
+    blockers: [...goal.blockers],
+    facts: { ...goal.facts }
+  };
+}
+function goalRunLogChange(before, after) {
+  if (!before || !after) return void 0;
+  const change = {};
+  addScalarChange(change, "state", before.state, after.state);
+  addScalarChange(change, "stage", before.stage, after.stage);
+  addScalarChange(change, "pendingEvidence", before.pendingEvidence, after.pendingEvidence);
+  const beforeFacts = recordValue2(before.facts);
+  const afterFacts = recordValue2(after.facts);
+  if (beforeFacts || afterFacts) change.facts = diffRecordKeys(beforeFacts ?? {}, afterFacts ?? {});
+  const beforeBlockers = stringArrayValue(before.blockers);
+  const afterBlockers = stringArrayValue(after.blockers);
+  if (beforeBlockers || afterBlockers) {
+    const blockers = diffStringArrays(beforeBlockers ?? [], afterBlockers ?? []);
+    if (blockers.added.length > 0 || blockers.removed.length > 0) change.blockers = blockers;
+  }
+  const beforeSatisfied = stringArrayValue(before.satisfiedEvidence);
+  const afterSatisfied = stringArrayValue(after.satisfiedEvidence);
+  if (beforeSatisfied || afterSatisfied) {
+    const evidence = diffStringArrays(beforeSatisfied ?? [], afterSatisfied ?? []);
+    if (evidence.added.length > 0 || evidence.removed.length > 0) change.satisfiedEvidence = evidence;
+  }
+  return Object.keys(change).length > 0 ? change : void 0;
+}
 function goalRunLogs(data) {
   const existing = data[LOGS_KEY];
   if (existing && typeof existing === "object" && !Array.isArray(existing)) {
@@ -6242,6 +6253,176 @@ function githubRunId() {
   const attempt = process.env.GITHUB_RUN_ATTEMPT?.trim();
   return attempt ? `gh-${runId}-${attempt}` : `gh-${runId}`;
 }
+function enrichGoalRunLogEvent(config, data, logPath, event) {
+  const stateRepo = stateRepoContext(config, event.goalId, logPath);
+  return pruneUndefined({
+    ...event,
+    run: event.run ?? runContext(data),
+    repo: event.repo ?? repoContext(config),
+    stateRepo: event.stateRepo ?? stateRepo,
+    trigger: event.trigger ?? triggerContext(),
+    job: event.job ?? jobContext(data),
+    links: event.links ?? linkContext(stateRepo)
+  });
+}
+function runContext(data) {
+  const runId = process.env.GITHUB_RUN_ID?.trim();
+  const attempt = process.env.GITHUB_RUN_ATTEMPT?.trim();
+  const repository = process.env.GITHUB_REPOSITORY?.trim();
+  const server = process.env.GITHUB_SERVER_URL?.trim() || "https://github.com";
+  return pruneUndefined({
+    id: goalRunId(data),
+    provider: runId ? "github-actions" : "local",
+    githubRunId: runId || void 0,
+    githubRunAttempt: attempt || void 0,
+    workflow: process.env.GITHUB_WORKFLOW?.trim() || void 0,
+    job: process.env.GITHUB_JOB?.trim() || void 0,
+    url: runId && repository ? `${server}/${repository}/actions/runs/${runId}` : void 0,
+    startedAt: data[LOG_STARTED_KEY]
+  });
+}
+function repoContext(config) {
+  const owner = config.github?.owner;
+  const repo = config.github?.repo;
+  return pruneUndefined({
+    owner,
+    repo,
+    fullName: owner && repo ? `${owner}/${repo}` : process.env.GITHUB_REPOSITORY?.trim() || void 0,
+    ref: process.env.GITHUB_REF?.trim() || void 0,
+    sha: process.env.GITHUB_SHA?.trim() || void 0
+  });
+}
+function stateRepoContext(config, goalId, logPath) {
+  try {
+    const state = resolveStateRepoConfig(config);
+    return {
+      repo: state.repo,
+      path: state.path,
+      goalStatePath: `${state.path}/${goalStateLogPath(goalId)}`,
+      logPath: `${state.path}/${logPath}`
+    };
+  } catch {
+    return void 0;
+  }
+}
+function triggerContext() {
+  const event = readGithubEvent();
+  const inputs = recordValue2(event?.inputs);
+  return pruneUndefined({
+    eventName: process.env.GITHUB_EVENT_NAME?.trim() || void 0,
+    actor: process.env.GITHUB_ACTOR?.trim() || void 0,
+    eventPath: process.env.GITHUB_EVENT_PATH?.trim() || void 0,
+    issue: numberValue(recordValue2(event?.issue)?.number),
+    pullRequest: numberValue(recordValue2(event?.pull_request)?.number),
+    comment: numberValue(recordValue2(event?.comment)?.id),
+    schedule: stringValue(event?.schedule),
+    inputs: inputs ? pickRecord(inputs, ["issue_number", "sessionId", "message", "model", "title", "agentAction", "base"]) : void 0
+  });
+}
+function jobContext(data) {
+  const job = pruneUndefined({
+    id: stringValue(data.jobId),
+    key: stringValue(data.jobKey),
+    flavor: stringValue(data.jobFlavor),
+    action: stringValue(data.jobAction),
+    agentResponsibility: stringValue(data.jobAgentResponsibility),
+    agentAction: stringValue(data.jobAgentAction),
+    agent: stringValue(data.jobAgent),
+    schedule: stringValue(data.jobSchedule),
+    target: data.jobTarget,
+    why: truncateString(stringValue(data.jobWhy), 1e3),
+    saveReport: data.jobSaveReport === true ? true : void 0
+  });
+  return Object.keys(job).length > 0 ? job : void 0;
+}
+function linkContext(stateRepo) {
+  const links = {};
+  const runId = process.env.GITHUB_RUN_ID?.trim();
+  const repository = process.env.GITHUB_REPOSITORY?.trim();
+  const server = process.env.GITHUB_SERVER_URL?.trim() || "https://github.com";
+  if (runId && repository) links.workflowRun = `${server}/${repository}/actions/runs/${runId}`;
+  const repo = stringValue(stateRepo?.repo);
+  const goalStatePath = stringValue(stateRepo?.goalStatePath);
+  const logPath = stringValue(stateRepo?.logPath);
+  if (repo && goalStatePath) links.goalState = githubBlobUrl(repo, goalStatePath);
+  if (repo && logPath) links.log = githubBlobUrl(repo, logPath);
+  return Object.keys(links).length > 0 ? links : void 0;
+}
+function githubBlobUrl(repo, filePath) {
+  try {
+    const parsed = parseStateRepoSlug(repo);
+    return `https://github.com/${parsed.owner}/${parsed.repo}/blob/main/${filePath}`;
+  } catch {
+    return void 0;
+  }
+}
+function routeStepForLog(step) {
+  return pruneUndefined({
+    evidence: step.evidence,
+    stage: step.stage,
+    agentResponsibility: step.agentResponsibility,
+    agentAction: step.agentAction,
+    args: step.args,
+    saveReport: step.saveReport === true ? true : void 0
+  });
+}
+function readGithubEvent() {
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventPath) return null;
+  try {
+    if (!fs25.existsSync(eventPath)) return null;
+    const parsed = JSON.parse(fs25.readFileSync(eventPath, "utf-8"));
+    return recordValue2(parsed);
+  } catch {
+    return null;
+  }
+}
+function addScalarChange(change, field, before, after) {
+  if (before === after) return;
+  change[field] = pruneUndefined({ from: before, to: after });
+}
+function diffRecordKeys(before, after) {
+  const beforeKeys = new Set(Object.keys(before));
+  const afterKeys = new Set(Object.keys(after));
+  const added = [...afterKeys].filter((key) => !beforeKeys.has(key)).sort();
+  const removed = [...beforeKeys].filter((key) => !afterKeys.has(key)).sort();
+  const changed = [...afterKeys].filter((key) => beforeKeys.has(key) && JSON.stringify(before[key]) !== JSON.stringify(after[key])).sort();
+  return { added, removed, changed };
+}
+function diffStringArrays(before, after) {
+  const beforeSet = new Set(before);
+  const afterSet = new Set(after);
+  return {
+    added: after.filter((item) => !beforeSet.has(item)).sort(),
+    removed: before.filter((item) => !afterSet.has(item)).sort()
+  };
+}
+function recordValue2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringArrayValue(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? [...value] : null;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function pickRecord(input, keys) {
+  const out = {};
+  for (const key of keys) {
+    if (input[key] !== void 0 && input[key] !== "") out[key] = input[key];
+  }
+  return out;
+}
+function pruneUndefined(input) {
+  for (const key of Object.keys(input)) {
+    if (input[key] === void 0) delete input[key];
+  }
+  return input;
+}
+function truncateString(value, max) {
+  if (!value) return void 0;
+  return value.length > max ? `${value.slice(0, max)}...` : value;
+}
 function stringValue(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -6587,7 +6768,7 @@ var init_contentsApiBackend = __esm({
 });
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 import * as path24 from "path";
 function sanitizeKey(s) {
   return s.replace(/[^A-Za-z0-9._-]/g, "-");
@@ -6659,7 +6840,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        fs25.mkdirSync(this.absDir, { recursive: true });
+        fs26.mkdirSync(this.absDir, { recursive: true });
         const prefix = this.cacheKeyPrefix();
         const probeKey = `${prefix}probe-${Date.now()}`;
         try {
@@ -6688,7 +6869,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        if (!fs25.existsSync(this.absDir)) {
+        if (!fs26.existsSync(this.absDir)) {
           return;
         }
         const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -6705,10 +6886,10 @@ var init_localFileBackend = __esm({
       load(slug2) {
         const relPath = stateFilePath(this.jobsDir, slug2);
         const absPath = path24.join(this.cwd, relPath);
-        if (!fs25.existsSync(absPath)) {
+        if (!fs26.existsSync(absPath)) {
           return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
         }
-        const raw = fs25.readFileSync(absPath, "utf-8");
+        const raw = fs26.readFileSync(absPath, "utf-8");
         let parsed;
         try {
           parsed = JSON.parse(raw);
@@ -6726,12 +6907,12 @@ var init_localFileBackend = __esm({
           return false;
         }
         const absPath = path24.join(this.cwd, loaded.path);
-        fs25.mkdirSync(path24.dirname(absPath), { recursive: true });
+        fs26.mkdirSync(path24.dirname(absPath), { recursive: true });
         const body = `${JSON.stringify(next, null, 2)}
 `;
         const tmpPath = `${absPath}.${process.pid}.tmp`;
-        fs25.writeFileSync(tmpPath, body, "utf-8");
-        fs25.renameSync(tmpPath, absPath);
+        fs26.writeFileSync(tmpPath, body, "utf-8");
+        fs26.renameSync(tmpPath, absPath);
         return true;
       }
       cacheKeyPrefix() {
@@ -7000,7 +7181,7 @@ var init_goalAgentResponsibilityScheduling = __esm({
 });
 
 // src/scripts/advanceManagedGoal.ts
-function stageManagedGoalDecision(data, goalId, goal, goalState, decision) {
+function stageManagedGoalDecision(data, goalId, goal, goalState, decision, details) {
   if (decision.kind === "dispatch") {
     stageGoalRunLogEvent(data, goalId, {
       source: "goal-manager",
@@ -7014,7 +7195,18 @@ function stageManagedGoalDecision(data, goalId, goal, goalState, decision) {
         agentResponsibility: decision.agentResponsibility,
         agentAction: decision.agentAction,
         cliArgs: decision.cliArgs
-      }
+      },
+      goal: details.goalSnapshot,
+      inspection: details.inspection,
+      decision: {
+        kind: decision.kind,
+        evidence: decision.evidence,
+        stage: decision.stage,
+        agentResponsibility: decision.agentResponsibility,
+        agentAction: decision.agentAction,
+        cliArgs: decision.cliArgs
+      },
+      change: details.change
     });
     return;
   }
@@ -7026,7 +7218,11 @@ function stageManagedGoalDecision(data, goalId, goal, goalState, decision) {
       goalState: "done",
       stage: "done",
       status: decision.kind,
-      reason: "managed goal complete"
+      reason: "managed goal complete",
+      goal: details.goalSnapshot,
+      inspection: details.inspection,
+      decision: { kind: decision.kind, reason: "managed goal complete" },
+      change: details.change
     });
     return;
   }
@@ -7038,7 +7234,11 @@ function stageManagedGoalDecision(data, goalId, goal, goalState, decision) {
       goalState,
       stage: goal.stage,
       status: decision.kind,
-      reason: decision.reason
+      reason: decision.reason,
+      goal: details.goalSnapshot,
+      inspection: details.inspection,
+      decision: { kind: decision.kind, reason: decision.reason },
+      change: details.change
     });
     return;
   }
@@ -7050,7 +7250,16 @@ function stageManagedGoalDecision(data, goalId, goal, goalState, decision) {
     stage: decision.stage,
     evidence: decision.evidence,
     status: decision.kind,
-    reason: decision.reason
+    reason: decision.reason,
+    goal: details.goalSnapshot,
+    inspection: details.inspection,
+    decision: {
+      kind: decision.kind,
+      evidence: decision.evidence,
+      stage: decision.stage,
+      reason: decision.reason
+    },
+    change: details.change
   });
 }
 function readSimpleGoalTaskSummary(goalId, cwd) {
@@ -7139,16 +7348,25 @@ var init_advanceManagedGoal = __esm({
         ctx.output.reason = "goal has no managed-goal contract; nothing to advance";
         return;
       }
+      const previousGoalIdFact = managed.facts.goalId;
+      managed.facts.goalId = goal.id;
+      const startSnapshot = goalRunLogSnapshot(goal.id, goal.state, managed);
       stageGoalRunLogEvent(ctx.data, goal.id, {
         source: "goal-manager",
         event: "goal.tick.start",
         goalType: managed.type,
         goalState: goal.state,
         stage: managed.stage,
+        goal: startSnapshot,
+        inspection: {
+          requiredEvidence: startSnapshot.requiredEvidence,
+          satisfiedEvidence: startSnapshot.satisfiedEvidence,
+          missingEvidence: startSnapshot.missingEvidence,
+          pendingEvidence: startSnapshot.pendingEvidence,
+          blockers: startSnapshot.blockers
+        },
         facts: managed.facts
       });
-      const previousGoalIdFact = managed.facts.goalId;
-      managed.facts.goalId = goal.id;
       const restoreGoalIdFact = () => {
         if (previousGoalIdFact === void 0) delete managed.facts.goalId;
         else managed.facts.goalId = previousGoalIdFact;
@@ -7161,6 +7379,7 @@ var init_advanceManagedGoal = __esm({
         if (!managed.blockers.includes(reason)) managed.blockers.push(reason);
         restoreGoalIdFact();
         goal.raw = writeManagedGoalToState({ ...goal.raw, state: goal.state }, managed);
+        const blockedSnapshot = goalRunLogSnapshot(goal.id, goal.state, managed);
         stageGoalRunLogEvent(ctx.data, goal.id, {
           source: "goal-manager",
           event: "goal.tick.blocked",
@@ -7168,12 +7387,20 @@ var init_advanceManagedGoal = __esm({
           goalState: goal.state,
           stage: managed.stage,
           status: "blocked",
-          reason
+          reason,
+          goal: blockedSnapshot,
+          inspection: {
+            purpose: "prepare goal issue fact before dispatch",
+            routeNeedsIssueFact: true
+          },
+          decision: { kind: "blocked", reason },
+          change: goalRunLogChange(startSnapshot, blockedSnapshot)
         });
         ctx.output.reason = reason;
         return;
       }
       if (isGoalTargetLoop(managed)) {
+        const beforeSnapshot = goalRunLogSnapshot(goal.id, goal.state, managed);
         const previousScheduleState = goal.raw.extra.scheduleState && typeof goal.raw.extra.scheduleState === "object" ? goal.raw.extra.scheduleState : void 0;
         const decision2 = planGoalTargetLoopSchedule({ goal: managed, previousScheduleState });
         restoreGoalIdFact();
@@ -7196,12 +7423,32 @@ var init_advanceManagedGoal = __esm({
           status: decision2.kind,
           reason: decision2.reason,
           target: decision2.dispatch?.cliArgs.goal && typeof decision2.dispatch.cliArgs.goal === "string" ? { type: "goal", id: decision2.dispatch.cliArgs.goal } : managed.loopTarget,
-          dispatch: decision2.dispatch
+          dispatch: decision2.dispatch,
+          goal: goalRunLogSnapshot(goal.id, goal.state, managed),
+          inspection: {
+            loopTarget: managed.loopTarget,
+            preferredRunTime: managed.preferredRunTime,
+            previousScheduleState,
+            scheduleState: decision2.scheduleState
+          },
+          decision: {
+            kind: decision2.kind,
+            reason: decision2.reason,
+            dispatch: decision2.dispatch
+          },
+          change: {
+            ...goalRunLogChange(beforeSnapshot, goalRunLogSnapshot(goal.id, goal.state, managed)) ?? {},
+            scheduleState: {
+              previousDecision: previousScheduleState?.lastDecision,
+              nextDecision: decision2.scheduleState.lastDecision
+            }
+          }
         });
         ctx.output.reason = decision2.reason;
         return;
       }
       if (isAgentResponsibilityCadenceGoal(managed, goal.raw.extra)) {
+        const beforeSnapshot = goalRunLogSnapshot(goal.id, goal.state, managed);
         const previousScheduleState = goal.raw.extra.scheduleState && typeof goal.raw.extra.scheduleState === "object" ? goal.raw.extra.scheduleState : void 0;
         const decision2 = await planGoalAgentResponsibilitySchedule({
           goal: managed,
@@ -7229,22 +7476,55 @@ var init_advanceManagedGoal = __esm({
           stage: managed.stage,
           status: decision2.kind,
           reason: decision2.reason,
-          dispatch: decision2.dispatch
+          dispatch: decision2.dispatch,
+          goal: goalRunLogSnapshot(goal.id, goal.state, managed),
+          inspection: {
+            agentResponsibilities: decision2.scheduleState.agentResponsibilities,
+            previousScheduleState,
+            scheduleState: decision2.scheduleState
+          },
+          decision: {
+            kind: decision2.kind,
+            reason: decision2.reason,
+            dispatch: decision2.dispatch
+          },
+          change: {
+            ...goalRunLogChange(beforeSnapshot, goalRunLogSnapshot(goal.id, goal.state, managed)) ?? {},
+            scheduleState: {
+              previousDecision: previousScheduleState?.lastDecision,
+              nextDecision: decision2.scheduleState.lastDecision
+            }
+          }
         });
         ctx.output.reason = decision2.reason;
         return;
       }
+      let simpleTaskSummary;
       if (isSimpleGoal(managed)) {
-        applySimpleGoalTaskSummary(managed, readSimpleGoalTaskSummary(goal.id, ctx.cwd));
+        simpleTaskSummary = readSimpleGoalTaskSummary(goal.id, ctx.cwd);
+        applySimpleGoalTaskSummary(managed, simpleTaskSummary);
       }
+      const beforeDecisionSnapshot = goalRunLogSnapshot(goal.id, goal.state, managed);
       const decision = planManagedGoalTick(managed);
       restoreGoalIdFact();
       ctx.data.managedGoalDecision = decision;
-      stageManagedGoalDecision(ctx.data, goal.id, managed, goal.state, decision);
       if (decision.kind === "done") {
         goal.state = "done";
       }
       goal.raw = writeManagedGoalToState({ ...goal.raw, state: goal.state }, managed);
+      const afterDecisionSnapshot = goalRunLogSnapshot(goal.id, goal.state, managed);
+      stageManagedGoalDecision(ctx.data, goal.id, managed, goal.state, decision, {
+        goalSnapshot: afterDecisionSnapshot,
+        inspection: {
+          requiredEvidence: beforeDecisionSnapshot.requiredEvidence,
+          satisfiedEvidence: beforeDecisionSnapshot.satisfiedEvidence,
+          missingEvidence: beforeDecisionSnapshot.missingEvidence,
+          pendingEvidence: beforeDecisionSnapshot.pendingEvidence,
+          route: beforeDecisionSnapshot.route,
+          simpleTaskSummary
+        },
+        change: goalRunLogChange(beforeDecisionSnapshot, afterDecisionSnapshot)
+      });
       if (decision.kind === "blocked" || decision.kind === "wait" || decision.kind === "idle" || decision.kind === "done") {
         ctx.output.reason = decision.kind === "done" ? "managed goal complete" : decision.reason;
         return;
@@ -7790,6 +8070,174 @@ var init_appendCompanyIntentDecision = __esm({
   }
 });
 
+// src/agent-responsibilityEvidence.ts
+function agentResponsibilityReportToEvidence(report) {
+  if (report.target.type !== "goal") return null;
+  const evidence = report.evidence ?? {};
+  const values = Object.values(evidence);
+  const status = values.some((value) => value === false) ? "fail" : values.length > 0 || report.facts ? "changed" : "noop";
+  return {
+    version: 1,
+    target: { type: "goal", id: report.target.id },
+    status,
+    summary: "responsibility reported goal evidence",
+    evidence,
+    facts: report.facts ?? {},
+    artifacts: [],
+    missingEvidence: [],
+    blockers: [],
+    sources: ["report"]
+  };
+}
+function agentResponsibilityResultToEvidence(result, fallbackGoalId, explicitEvidence) {
+  const targetId = result.target?.type === "goal" ? result.target.id : fallbackGoalId;
+  if (!targetId) return null;
+  return {
+    version: 1,
+    target: { type: "goal", id: targetId },
+    status: result.status,
+    summary: result.summary,
+    evidence: result.evidence,
+    explicitEvidence,
+    facts: result.facts,
+    artifacts: result.artifacts,
+    missingEvidence: result.missingEvidence,
+    blockers: result.blockers,
+    sources: ["result"]
+  };
+}
+function mergeResponsibilityEvidence(items) {
+  const reports = items.filter((item) => item.sources.includes("report") && !item.sources.includes("result"));
+  const results = items.filter((item) => item.sources.includes("result"));
+  const usedReports = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const result of results) {
+    const reportIndex = reports.findIndex(
+      (report, index) => !usedReports.has(index) && evidenceMatches(report, result, reports)
+    );
+    if (reportIndex >= 0) {
+      usedReports.add(reportIndex);
+      merged.push(mergeReportAndResult(reports[reportIndex], result));
+    } else {
+      merged.push(result);
+    }
+  }
+  for (let i = 0; i < reports.length; i += 1) {
+    if (!usedReports.has(i)) merged.push(reports[i]);
+  }
+  return merged;
+}
+function applyAgentResponsibilityEvidenceToGoalState(state, evidence) {
+  const priorFacts = parseFacts3(state.extra.facts) ?? {};
+  const nextFacts = { ...priorFacts };
+  for (const [key, value] of Object.entries(evidence.facts)) {
+    if (CONTROL_FACT_KEYS3.has(key)) continue;
+    nextFacts[key] = value;
+  }
+  for (const [key, value] of Object.entries(evidence.evidence ?? {})) {
+    nextFacts[key] = value;
+  }
+  const pending = typeof nextFacts.pendingEvidence === "string" ? nextFacts.pendingEvidence : "";
+  const statusEvidence = evidence.explicitEvidence || pending;
+  const hasPendingEvidenceValue = pending ? Object.hasOwn(evidence.evidence ?? {}, pending) : false;
+  const terminalStatus = evidence.status === "pass" || evidence.status === "fail" || evidence.status === "blocked";
+  if (statusEvidence && !Object.hasOwn(evidence.evidence ?? {}, statusEvidence)) {
+    if (evidence.status === "pass") nextFacts[statusEvidence] = true;
+    if (evidence.status === "fail" || evidence.status === "blocked") nextFacts[statusEvidence] = false;
+  }
+  if (pending && (hasPendingEvidenceValue || statusEvidence === pending && terminalStatus)) {
+    delete nextFacts.pendingEvidence;
+  }
+  const blockers = parseStringArray3(state.extra.blockers) ?? [];
+  const evidenceBlockers = evidence.blockers.length > 0 || evidence.status !== "fail" && evidence.status !== "blocked" ? evidence.blockers : [evidence.summary];
+  for (const blocker of evidenceBlockers) {
+    if (!blockers.includes(blocker)) blockers.push(blocker);
+  }
+  const nextExtra = {
+    ...state.extra,
+    facts: nextFacts
+  };
+  if (blockers.length > 0 || Array.isArray(state.extra.blockers)) {
+    nextExtra.blockers = blockers;
+  }
+  return {
+    ...state,
+    extra: nextExtra
+  };
+}
+function evidenceMatches(report, result, allReports) {
+  if (report.target.id !== result.target.id) return false;
+  if (result.explicitEvidence && Object.hasOwn(report.evidence ?? {}, result.explicitEvidence)) return true;
+  const resultEvidenceKeys = Object.keys(result.evidence ?? {});
+  if (resultEvidenceKeys.length > 0 && resultEvidenceKeys.some((key) => Object.hasOwn(report.evidence ?? {}, key))) {
+    return true;
+  }
+  return !result.explicitEvidence && resultEvidenceKeys.length === 0 && allReports.filter((item) => item.target.id === result.target.id).length === 1;
+}
+function mergeReportAndResult(report, result) {
+  return {
+    ...result,
+    evidence: mergeOptionalRecords(report.evidence, result.evidence),
+    facts: { ...report.facts, ...result.facts },
+    artifacts: uniqueArtifacts([...report.artifacts, ...result.artifacts]),
+    missingEvidence: uniqueStrings([...report.missingEvidence, ...result.missingEvidence]),
+    blockers: uniqueStrings([...report.blockers, ...result.blockers]),
+    sources: uniqueSources([...report.sources, ...result.sources])
+  };
+}
+function mergeOptionalRecords(left, right) {
+  const merged = { ...left ?? {}, ...right ?? {} };
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function uniqueStrings(values) {
+  return [...new Set(values)].sort();
+}
+function uniqueSources(values) {
+  const order = ["report", "result"];
+  const set = new Set(values);
+  return order.filter((source) => set.has(source));
+}
+function uniqueArtifacts(artifacts) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const artifact of artifacts) {
+    const key = `${artifact.label}
+${artifact.url ?? ""}
+${artifact.path ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(artifact);
+  }
+  return out;
+}
+function parseFacts3(raw) {
+  if (raw === void 0) return {};
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const facts = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (!key.trim()) return null;
+    if (CONTROL_FACT_KEYS3.has(key)) continue;
+    facts[key] = value;
+  }
+  return facts;
+}
+function parseStringArray3(raw) {
+  if (!Array.isArray(raw)) return null;
+  const out = [];
+  for (const item of raw) {
+    if (typeof item !== "string") return null;
+    out.push(item);
+  }
+  return out;
+}
+var CONTROL_FACT_KEYS3;
+var init_agent_responsibilityEvidence = __esm({
+  "src/agent-responsibilityEvidence.ts"() {
+    "use strict";
+    CONTROL_FACT_KEYS3 = /* @__PURE__ */ new Set(["blockers", "destination", "agent-responsibilities", "route", "stage", "state"]);
+  }
+});
+
 // src/scripts/applyAgentResponsibilityReports.ts
 function flushLogs(ctx) {
   try {
@@ -7823,13 +8271,24 @@ function collectResults(raw, agentResult) {
   if (agentResult?.finalText) out.push(...parseAgentResponsibilityResultsFromText(agentResult.finalText));
   return out;
 }
-function groupGoalReports(reports) {
-  const grouped = /* @__PURE__ */ new Map();
+function collectGoalResponsibilityEvidence(reports, results, fallbackGoalId, explicitEvidence) {
+  const items = [];
   for (const report of reports) {
-    if (report.target.type !== "goal") continue;
-    const list = grouped.get(report.target.id) ?? [];
-    list.push(report);
-    grouped.set(report.target.id, list);
+    const evidence = agentResponsibilityReportToEvidence(report);
+    if (evidence) items.push(evidence);
+  }
+  for (const result of results) {
+    const evidence = agentResponsibilityResultToEvidence(result, fallbackGoalId, explicitEvidence);
+    if (evidence) items.push(evidence);
+  }
+  return mergeResponsibilityEvidence(items);
+}
+function groupGoalEvidence(evidenceItems) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const evidence of evidenceItems) {
+    const list = grouped.get(evidence.target.id) ?? [];
+    list.push(evidence);
+    grouped.set(evidence.target.id, list);
   }
   return grouped;
 }
@@ -7842,16 +8301,72 @@ function completeSatisfiedManagedGoal(state) {
   if (decision.kind !== "done") return state;
   return writeManagedGoalToState({ ...state, state: "done" }, managed);
 }
-function describeMessage(goalId, reports, results) {
-  const pieces = [];
-  if (reports && reports.length > 0) pieces.push(`report=${reports.length}`);
-  if (results.length > 0) pieces.push(`result=${results.map((result) => result.status).join(",")}`);
+function snapshotFromState(goalId, state) {
+  const managed = managedGoalFromState(state);
+  return managed ? goalRunLogSnapshot(goalId, state.state, managed) : null;
+}
+function responsibilityEvidenceOutput(evidence) {
+  return {
+    kind: "responsibility-evidence",
+    sources: evidence.sources,
+    status: evidence.status,
+    summary: evidence.summary,
+    evidence: evidence.evidence ?? {},
+    facts: evidence.facts,
+    artifacts: evidence.artifacts,
+    missingEvidence: evidence.missingEvidence,
+    blockers: evidence.blockers
+  };
+}
+function evidenceInspection(goalBefore, goalAfter, responsibilityOutput, explicitEvidence) {
+  return {
+    expectedEvidence: {
+      required: goalBefore?.requiredEvidence,
+      missingBefore: goalBefore?.missingEvidence,
+      pendingBefore: goalBefore?.pendingEvidence,
+      explicit: explicitEvidence
+    },
+    responsibilityOutput,
+    actualGoalState: {
+      satisfiedEvidence: goalAfter?.satisfiedEvidence,
+      missingEvidence: goalAfter?.missingEvidence,
+      pendingEvidence: goalAfter?.pendingEvidence,
+      blockers: goalAfter?.blockers
+    }
+  };
+}
+function evidenceDecision(change, goalAfter, responsibilityOutput) {
+  return {
+    kind: change ? "accept-evidence" : "no-state-change",
+    status: responsibilityOutput.status,
+    nextStep: nextStepFromEvidence(goalAfter, responsibilityOutput),
+    reason: responsibilityOutput.summary
+  };
+}
+function nextStepFromEvidence(goalAfter, responsibilityOutput) {
+  const status = typeof responsibilityOutput.status === "string" ? responsibilityOutput.status : "";
+  const outputBlockers = stringArrayField(responsibilityOutput, "blockers");
+  const goalBlockers = stringArrayField(goalAfter, "blockers");
+  const missingEvidence = stringArrayField(goalAfter, "missingEvidence");
+  if (goalAfter && missingEvidence.length === 0) return "done";
+  if (status === "fail" || status === "blocked" || outputBlockers.length > 0) return "rescue";
+  if (goalBlockers.length > 0) return "block";
+  if (missingEvidence.length > 0 && status !== "noop") return "dispatch";
+  return "wait";
+}
+function stringArrayField(record2, key) {
+  const value = record2?.[key];
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+}
+function describeMessage(goalId, evidenceItems) {
+  const pieces = evidenceItems.map((evidence) => `${evidence.sources.join("+")}:${evidence.status}`);
   return `Apply agentResponsibility output to ${goalId}${pieces.length > 0 ? ` (${pieces.join("; ")})` : ""}`;
 }
 var applyAgentResponsibilityReports;
 var init_applyAgentResponsibilityReports = __esm({
   "src/scripts/applyAgentResponsibilityReports.ts"() {
     "use strict";
+    init_agent_responsibilityEvidence();
     init_agent_responsibilityReport();
     init_agent_responsibilityResult();
     init_manager();
@@ -7862,65 +8377,86 @@ var init_applyAgentResponsibilityReports = __esm({
       const reports = collectReports(ctx.data.agentResponsibilityReports, agentResult);
       const results = collectResults(ctx.data.dutyResults, agentResult);
       const resultGoalId = typeof ctx.args.goal === "string" && ctx.args.goal.length > 0 ? ctx.args.goal : null;
-      if (reports.length === 0 && (results.length === 0 || !resultGoalId)) return;
-      const reportsByGoal = groupGoalReports(reports);
-      const goalIds = new Set(reportsByGoal.keys());
-      if (results.length > 0 && resultGoalId) goalIds.add(resultGoalId);
-      for (const goalId of goalIds) {
+      const explicitEvidence = typeof ctx.args.evidence === "string" && ctx.args.evidence.length > 0 ? ctx.args.evidence : void 0;
+      const evidenceItems = collectGoalResponsibilityEvidence(reports, results, resultGoalId, explicitEvidence);
+      if (evidenceItems.length === 0) return;
+      const evidenceByGoal = groupGoalEvidence(evidenceItems);
+      for (const [goalId, goalEvidence] of evidenceByGoal) {
         const prior = fetchGoalState(ctx.config, goalId, ctx.cwd);
         if (!prior) {
+          stageGoalRunLogEvent(ctx.data, goalId, {
+            source: "goal-loop",
+            event: "goal.evidence.rejected",
+            status: "rejected",
+            reason: "goal missing in state repo",
+            inspection: {
+              responsibilityOutput: {
+                kind: "responsibility-evidence",
+                count: goalEvidence.length,
+                items: goalEvidence.map(responsibilityEvidenceOutput)
+              },
+              missingEvidence: [],
+              blockers: ["goal missing in state repo"]
+            },
+            decision: { kind: "reject-evidence", nextStep: "block", reason: "goal missing in state repo" }
+          });
+          flushLogs(ctx);
           process.stderr.write(`[kody agentResponsibility-report] goal ${goalId} missing in state repo; report skipped
 `);
           continue;
         }
         let next = prior;
-        for (const report of reportsByGoal.get(goalId) ?? []) {
+        for (const evidence of goalEvidence) {
+          const beforeSnapshot = snapshotFromState(goalId, next);
+          next = applyAgentResponsibilityEvidenceToGoalState(next, evidence);
+          const afterSnapshot = snapshotFromState(goalId, next);
+          const change = goalRunLogChange(beforeSnapshot, afterSnapshot);
+          const output = responsibilityEvidenceOutput(evidence);
           stageGoalRunLogEvent(ctx.data, goalId, {
-            source: "goal-report",
-            event: "goal.evidence.reported",
-            goalState: prior.state,
-            evidenceValues: report.evidence,
-            facts: report.facts
+            source: "goal-loop",
+            event: change ? "goal.evidence.applied" : "goal.evidence.unchanged",
+            goalState: next.state,
+            evidence: evidence.explicitEvidence,
+            evidenceValues: evidence.evidence,
+            status: evidence.status,
+            reason: evidence.summary,
+            facts: evidence.facts,
+            artifacts: evidence.artifacts,
+            goal: afterSnapshot ?? void 0,
+            inspection: evidenceInspection(beforeSnapshot, afterSnapshot, output, evidence.explicitEvidence),
+            decision: {
+              ...evidenceDecision(change, afterSnapshot, output),
+              evidence: evidence.explicitEvidence,
+              evidenceValues: evidence.evidence
+            },
+            change
           });
-          next = applyAgentResponsibilityReportToGoalState(next, report);
-        }
-        if (goalId === resultGoalId) {
-          const evidence = typeof ctx.args.evidence === "string" && ctx.args.evidence.length > 0 ? ctx.args.evidence : void 0;
-          for (const result of results) {
-            stageGoalRunLogEvent(ctx.data, goalId, {
-              source: "goal-report",
-              event: "goal.result.applied",
-              goalState: prior.state,
-              evidence,
-              status: result.status,
-              reason: result.summary,
-              facts: result.facts,
-              artifacts: result.artifacts
-            });
-            next = applyAgentResponsibilityResultToObjectiveState(next, result, evidence);
-          }
         }
+        const beforeCompletionSnapshot = snapshotFromState(goalId, next);
         next = completeSatisfiedManagedGoal(next);
+        const afterCompletionSnapshot = snapshotFromState(goalId, next);
         if (prior.state !== "done" && next.state === "done") {
           stageGoalRunLogEvent(ctx.data, goalId, {
-            source: "goal-report",
-            event: "goal.completed",
+            source: "goal-loop",
+            event: "goal.decision.done",
             goalState: "done",
             status: "done",
-            reason: "destination evidence satisfied"
+            reason: "destination evidence satisfied",
+            goal: afterCompletionSnapshot ?? void 0,
+            inspection: {
+              requiredEvidence: beforeCompletionSnapshot?.requiredEvidence,
+              satisfiedEvidence: beforeCompletionSnapshot?.satisfiedEvidence,
+              missingEvidence: beforeCompletionSnapshot?.missingEvidence
+            },
+            decision: { kind: "done", nextStep: "done", reason: "destination evidence satisfied" },
+            change: goalRunLogChange(beforeCompletionSnapshot, afterCompletionSnapshot)
           });
         }
         if (serializeGoalState(next) === serializeGoalState(prior)) {
           flushLogs(ctx);
           continue;
         }
-        putGoalState(
-          ctx.config,
-          goalId,
-          { ...next, updatedAt: nowIso() },
-          describeMessage(goalId, reportsByGoal.get(goalId), results),
-          ctx.cwd
-        );
+        putGoalState(ctx.config, goalId, { ...next, updatedAt: nowIso() }, describeMessage(goalId, goalEvidence), ctx.cwd);
         flushLogs(ctx);
       }
     };
@@ -8093,7 +8629,7 @@ var init_classifyByLabel = __esm({
 });
 
 // src/scripts/commitAndPush.ts
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 import * as path26 from "path";
 function sentinelPathForStage(cwd, profileName) {
   const runId = resolveRunId();
@@ -8115,9 +8651,9 @@ var init_commitAndPush = __esm({
       }
       const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
       const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
-      if (sentinel && fs26.existsSync(sentinel)) {
+      if (sentinel && fs27.existsSync(sentinel)) {
         try {
-          const replay = JSON.parse(fs26.readFileSync(sentinel, "utf-8"));
+          const replay = JSON.parse(fs27.readFileSync(sentinel, "utf-8"));
           ctx.data.commitResult = replay.commitResult ?? { committed: false, pushed: false };
           if (Array.isArray(replay.changedFiles)) ctx.data.changedFiles = replay.changedFiles;
           if (typeof replay.hasCommitsAhead === "boolean") ctx.data.hasCommitsAhead = replay.hasCommitsAhead;
@@ -8170,8 +8706,8 @@ var init_commitAndPush = __esm({
       const result = ctx.data.commitResult;
       if (sentinel && result?.committed) {
         try {
-          fs26.mkdirSync(path26.dirname(sentinel), { recursive: true });
-          fs26.writeFileSync(
+          fs27.mkdirSync(path26.dirname(sentinel), { recursive: true });
+          fs27.writeFileSync(
             sentinel,
             JSON.stringify(
               {
@@ -8243,7 +8779,7 @@ var init_commitGoalState = __esm({
 });
 
 // src/scripts/composePrompt.ts
-import * as fs27 from "fs";
+import * as fs28 from "fs";
 import * as path27 from "path";
 function fenceUntrusted(value) {
   if (value.trim().length === 0) return value;
@@ -8383,7 +8919,7 @@ var init_composePrompt = __esm({
           break;
         }
         try {
-          template = fs27.readFileSync(c, "utf-8");
+          template = fs28.readFileSync(c, "utf-8");
           templatePath = c;
           break;
         } catch (err) {
@@ -8394,7 +8930,7 @@ var init_composePrompt = __esm({
       if (!templatePath) {
         let dirState;
         try {
-          dirState = `dir contents: [${fs27.readdirSync(profile.dir).join(", ")}]`;
+          dirState = `dir contents: [${fs28.readdirSync(profile.dir).join(", ")}]`;
         } catch (err) {
           dirState = `readdir(${profile.dir}) failed: ${err?.code ?? String(err)}`;
         }
@@ -8966,7 +9502,7 @@ var init_deriveQaScopeFromIssue = __esm({
 
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync10 } from "child_process";
-import * as fs28 from "fs";
+import * as fs29 from "fs";
 import * as os6 from "os";
 import * as path28 from "path";
 var diagMcp;
@@ -8978,7 +9514,7 @@ var init_diagMcp = __esm({
       const cacheDir = path28.join(home, ".cache", "ms-playwright");
       let entries = [];
       try {
-        entries = fs28.readdirSync(cacheDir);
+        entries = fs29.readdirSync(cacheDir);
       } catch {
       }
       const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -9006,13 +9542,13 @@ var init_diagMcp = __esm({
 });
 
 // src/scripts/frameworkDetectors.ts
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 import * as path29 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs29.readFileSync(path29.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs30.readFileSync(path29.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -9049,7 +9585,7 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs29.existsSync(path29.join(cwd, c))) return c;
+    if (fs30.existsSync(path29.join(cwd, c))) return c;
   }
   return null;
 }
@@ -9057,17 +9593,17 @@ function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
     const full = path29.join(cwd, dir);
-    if (!fs29.existsSync(full)) continue;
+    if (!fs30.existsSync(full)) continue;
     let files;
     try {
-      files = fs29.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs30.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
         const filePath = path29.join(full, file);
-        const content = fs29.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const content = fs30.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug2 = slugMatch[1];
@@ -9095,10 +9631,10 @@ function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
     const full = path29.join(cwd, dir);
-    if (!fs29.existsSync(full)) continue;
+    if (!fs30.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs29.readdirSync(full, { withFileTypes: true });
+      entries = fs30.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -9108,7 +9644,7 @@ function discoverAdminComponents(cwd, collections) {
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs29.existsSync(path29.join(entryPath, f))
+          (f) => fs30.existsSync(path29.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
@@ -9123,7 +9659,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs29.readFileSync(path29.join(cwd, col.filePath), "utf-8");
+            const colContent = fs30.readFileSync(path29.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -9142,7 +9678,7 @@ function scanApiRoutes(cwd) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
     const apiDir = path29.join(cwd, appDir, "api");
-    if (!fs29.existsSync(apiDir)) continue;
+    if (!fs30.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -9151,14 +9687,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs29.readdirSync(dir, { withFileTypes: true });
+    entries = fs30.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   const routeFile = entries.find((e) => e.isFile() && /^route\.(ts|js|tsx|jsx)$/.test(e.name));
   if (routeFile) {
     try {
-      const content = fs29.readFileSync(path29.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs30.readFileSync(path29.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
       const methods = HTTP_METHODS.filter(
         (m) => new RegExp(`export\\s+(?:async\\s+)?function\\s+${m}\\b`).test(content)
       );
@@ -9192,9 +9728,9 @@ function scanEnvVars(cwd) {
   const candidates = [".env.example", ".env.local.example", ".env.template"];
   for (const envFile of candidates) {
     const envPath = path29.join(cwd, envFile);
-    if (!fs29.existsSync(envPath)) continue;
+    if (!fs30.existsSync(envPath)) continue;
     try {
-      const content = fs29.readFileSync(envPath, "utf-8");
+      const content = fs30.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -9239,7 +9775,7 @@ var init_frameworkDetectors = __esm({
 });
 
 // src/scripts/discoverQaContext.ts
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import * as path30 from "path";
 function runQaDiscovery(cwd) {
   const out = {
@@ -9271,9 +9807,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs30.readFileSync(path30.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs31.readFileSync(path30.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs30.existsSync(path30.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs30.existsSync(path30.join(cwd, "yarn.lock")) ? "yarn" : fs30.existsSync(path30.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs31.existsSync(path30.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs31.existsSync(path30.join(cwd, "yarn.lock")) ? "yarn" : fs31.existsSync(path30.join(cwd, "bun.lockb")) ? "bun" : "npm";
     if (pkg.scripts?.dev) out.devCommand = `${pm} dev`;
     if (allDeps.next || allDeps.nuxt) out.devPort = 3e3;
     else if (allDeps.vite) out.devPort = 5173;
@@ -9284,7 +9820,7 @@ function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
     const full = path30.join(cwd, appDir);
-    if (!fs30.existsSync(full)) continue;
+    if (!fs31.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -9292,7 +9828,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs30.readdirSync(dir, { withFileTypes: true });
+    entries = fs31.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -9334,23 +9870,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs30.existsSync(path30.join(cwd, c))) out.authFiles.push(c);
+    if (fs31.existsSync(path30.join(cwd, c))) out.authFiles.push(c);
   }
 }
 function detectRoles(cwd, out) {
   const rolePaths = ["src/types", "src/lib", "src/utils", "src/constants", "src/access", "src/collections"];
   for (const rp of rolePaths) {
     const dir = path30.join(cwd, rp);
-    if (!fs30.existsSync(dir)) continue;
+    if (!fs31.existsSync(dir)) continue;
     let files;
     try {
-      files = fs30.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs31.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs30.readFileSync(path30.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs31.readFileSync(path30.join(dir, f), "utf-8").slice(0, 5e3);
         const roleMatches = content.match(/(?:role|Role|ROLE)\s*[=:]\s*['"](\w+)['"]/g);
         if (roleMatches) {
           for (const m of roleMatches) {
@@ -10564,12 +11100,12 @@ var init_fixFlow = __esm({
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync15 } from "child_process";
-import * as fs31 from "fs";
+import * as fs32 from "fs";
 import * as path31 from "path";
 function detectPackageManager(cwd) {
-  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";
+  if (fs32.existsSync(path31.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs32.existsSync(path31.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs32.existsSync(path31.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -10642,21 +11178,21 @@ function performInit(cwd, force) {
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
   const configPath = path31.join(cwd, "kody.config.json");
-  if (fs31.existsSync(configPath) && !force) {
+  if (fs32.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs31.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs32.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
   const workflowDir = path31.join(cwd, ".github", "workflows");
   const workflowPath = path31.join(workflowDir, "kody.yml");
-  if (fs31.existsSync(workflowPath) && !force) {
+  if (fs32.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs31.mkdirSync(workflowDir, { recursive: true });
-    fs31.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs32.mkdirSync(workflowDir, { recursive: true });
+    fs32.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
   for (const exe of listAgentActions()) {
@@ -10668,11 +11204,11 @@ function performInit(cwd, force) {
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
     const target = path31.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs31.existsSync(target) && !force) {
+    if (fs32.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs31.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs32.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -10825,7 +11361,7 @@ Nothing to do. All files already present. (Use --force to overwrite.)
 });
 
 // src/scripts/loadAgentAdhoc.ts
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 function resolveMessage(messageArg) {
   const fromComment = readCommentBody();
   if (fromComment) return stripDirective(fromComment);
@@ -10833,9 +11369,9 @@ function resolveMessage(messageArg) {
 }
 function readCommentBody() {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs32.existsSync(eventPath)) return "";
+  if (!eventPath || !fs33.existsSync(eventPath)) return "";
   try {
-    const event = JSON.parse(fs32.readFileSync(eventPath, "utf-8"));
+    const event = JSON.parse(fs33.readFileSync(eventPath, "utf-8"));
     return String(event.comment?.body ?? "");
   } catch {
     return "";
@@ -10888,10 +11424,10 @@ var init_loadAgentAdhoc = __esm({
         throw new Error("loadAgentAdhoc: ctx.args.agent must be a non-empty slug");
       }
       const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
-      if (!fs32.existsSync(agentPath)) {
+      if (!fs33.existsSync(agentPath)) {
         throw new Error(`loadAgentAdhoc: agent identity not found: ${agentPath}`);
       }
-      const { title, body } = parseAgentFile(fs32.readFileSync(agentPath, "utf-8"), agentSlug);
+      const { title, body } = parseAgentFile(fs33.readFileSync(agentPath, "utf-8"), agentSlug);
       const message = resolveMessage(ctx.args.message);
       if (!message) {
         throw new Error(
@@ -11129,7 +11665,7 @@ var init_loadIssueStateComment = __esm({
 });
 
 // src/scripts/loadJobFromFile.ts
-import * as fs33 from "fs";
+import * as fs34 from "fs";
 import * as path32 from "path";
 function parseJobFile(raw, slug2) {
   let stripped = raw;
@@ -11181,12 +11717,12 @@ var init_loadJobFromFile = __esm({
       let agentIdentity = "";
       if (agentSlug) {
         const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
-        if (!fs33.existsSync(agentPath)) {
+        if (!fs34.existsSync(agentPath)) {
           throw new Error(
             `loadJobFromFile: agentResponsibility '${slug2}' declares agent '${agentSlug}' but ${agentPath} does not exist`
           );
         }
-        const agentRaw = fs33.readFileSync(agentPath, "utf-8");
+        const agentRaw = fs34.readFileSync(agentPath, "utf-8");
         const parsed = parseJobFile(agentRaw, agentSlug);
         agentTitle = parsed.title;
         agentIdentity = parsed.body;
@@ -11260,13 +11796,13 @@ ${truncate(issue.body, FINDING_BODY_MAX_BYTES)}`;
 });
 
 // src/scripts/kodyVariables.ts
-import * as fs34 from "fs";
+import * as fs35 from "fs";
 import * as path33 from "path";
 function readKodyVariables(cwd) {
   const full = path33.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
-    raw = fs34.readFileSync(full, "utf-8");
+    raw = fs35.readFileSync(full, "utf-8");
   } catch {
     return {};
   }
@@ -11291,7 +11827,7 @@ var init_kodyVariables = __esm({
 });
 
 // src/scripts/loadQaContext.ts
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 import * as path34 from "path";
 function parseSlugList(value) {
   const inner = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
@@ -11322,17 +11858,17 @@ function readProfileAgents(raw) {
 }
 function readProfile(cwd) {
   const dir = path34.join(cwd, CONTEXT_DIR_REL_PATH);
-  if (!fs35.existsSync(dir)) return "";
+  if (!fs36.existsSync(dir)) return "";
   let entries;
   try {
-    entries = fs35.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    entries = fs36.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs35.readFileSync(path34.join(dir, file), "utf-8");
+      const raw = fs36.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}
@@ -11378,7 +11914,7 @@ var init_loadQaContext = __esm({
 });
 
 // src/taskContext.ts
-import * as fs36 from "fs";
+import * as fs37 from "fs";
 import * as path35 from "path";
 function buildTaskContext(args) {
   return {
@@ -11395,9 +11931,9 @@ function buildTaskContext(args) {
 function persistTaskContext(cwd, ctx) {
   try {
     const dir = runtimeStatePath(cwd, "agent-runs", ctx.runId);
-    fs36.mkdirSync(dir, { recursive: true });
+    fs37.mkdirSync(dir, { recursive: true });
     const file = path35.join(dir, "task-context.json");
-    fs36.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    fs37.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -13742,9 +14278,9 @@ fi
 });
 
 // src/stateRepoGithub.ts
-import * as fs37 from "fs";
+import * as fs38 from "fs";
 import * as path36 from "path";
-function recordValue2(value) {
+function recordValue3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function contentsUrl(owner, repo, filePath) {
@@ -13800,12 +14336,12 @@ async function loadGithubStateConfig(opts) {
       throw new Error(`kody.config.json is invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  const githubRaw = recordValue2(raw.github) ?? {};
+  const githubRaw = recordValue3(raw.github) ?? {};
   const github = {
     owner: typeof githubRaw.owner === "string" && githubRaw.owner.trim() ? githubRaw.owner.trim() : opts.owner,
     repo: typeof githubRaw.repo === "string" && githubRaw.repo.trim() ? githubRaw.repo.trim() : opts.repo
   };
-  const nestedState = recordValue2(raw.state) ?? {};
+  const nestedState = recordValue3(raw.state) ?? {};
   const repoRaw = typeof raw.stateRepo === "string" ? raw.stateRepo : nestedState.repo;
   const pathRaw = typeof raw.statePath === "string" ? raw.statePath : nestedState.path;
   const stateRepo = typeof repoRaw === "string" && repoRaw.trim().length > 0 ? repoRaw.trim() : `https://github.com/${github.owner}/kody-state`;
@@ -13883,15 +14419,15 @@ function mergeJsonl(localText, remoteText) {
 async function syncJsonlFileFromGithubState(opts) {
   const remote = await readGithubStateTextWithConfig(opts);
   if (!remote) return;
-  const local = fs37.existsSync(opts.localPath) ? fs37.readFileSync(opts.localPath, "utf-8") : "";
+  const local = fs38.existsSync(opts.localPath) ? fs38.readFileSync(opts.localPath, "utf-8") : "";
   const next = mergeJsonl(local, remote.content);
   if (next === local) return;
-  fs37.mkdirSync(path36.dirname(opts.localPath), { recursive: true });
-  fs37.writeFileSync(opts.localPath, next);
+  fs38.mkdirSync(path36.dirname(opts.localPath), { recursive: true });
+  fs38.writeFileSync(opts.localPath, next);
 }
 async function persistJsonlFileToGithubState(opts) {
-  if (!fs37.existsSync(opts.localPath)) return;
-  const localText = fs37.readFileSync(opts.localPath, "utf-8");
+  if (!fs38.existsSync(opts.localPath)) return;
+  const localText = fs38.readFileSync(opts.localPath, "utf-8");
   for (let attempt = 1; attempt <= 3; attempt += 1) {
     const remote = await readGithubStateTextWithConfig(opts);
     const body = mergeJsonl(localText, remote?.content ?? "");
@@ -14368,7 +14904,7 @@ var init_tickShellRunner = __esm({
 });
 
 // src/scripts/runScheduledAgentActionTick.ts
-import * as fs38 from "fs";
+import * as fs39 from "fs";
 import * as path38 from "path";
 var runScheduledAgentActionTick;
 var init_runScheduledAgentActionTick = __esm({
@@ -14396,7 +14932,7 @@ var init_runScheduledAgentActionTick = __esm({
         return;
       }
       const shellPath = path38.join(profile.dir, shell);
-      if (!fs38.existsSync(shellPath)) {
+      if (!fs39.existsSync(shellPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledAgentActionTick: shell not found: ${shell} (looked in ${profile.dir})`;
         return;
@@ -14427,7 +14963,7 @@ var init_runScheduledAgentActionTick = __esm({
 });
 
 // src/scripts/runTickScript.ts
-import * as fs39 from "fs";
+import * as fs40 from "fs";
 import * as path39 from "path";
 var runTickScript;
 var init_runTickScript = __esm({
@@ -14460,7 +14996,7 @@ var init_runTickScript = __esm({
         return;
       }
       const scriptPath = path39.isAbsolute(tickScript) ? tickScript : path39.join(ctx.cwd, tickScript);
-      if (!fs39.existsSync(scriptPath)) {
+      if (!fs40.existsSync(scriptPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
         return;
@@ -15282,7 +15818,7 @@ var init_warmupMcp = __esm({
 });
 
 // src/scripts/writeAgentRunSummary.ts
-import * as fs40 from "fs";
+import * as fs41 from "fs";
 var writeAgentRunSummary;
 var init_writeAgentRunSummary = __esm({
   "src/scripts/writeAgentRunSummary.ts"() {
@@ -15308,7 +15844,7 @@ var init_writeAgentRunSummary = __esm({
       if (reason) lines.push(`- **Reason:** ${reason}`);
       lines.push("");
       try {
-        fs40.appendFileSync(summaryPath, `${lines.join("\n")}
+        fs41.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
       } catch {
       }
@@ -15710,17 +16246,17 @@ var init_scripts = __esm({
 });
 
 // src/stateWorkspace.ts
-import * as fs41 from "fs";
+import * as fs42 from "fs";
 import * as path40 from "path";
 function writeLocalFile(cwd, relativePath, content) {
   const fullPath = path40.join(cwd, relativePath);
-  fs41.mkdirSync(path40.dirname(fullPath), { recursive: true });
-  fs41.writeFileSync(fullPath, content);
+  fs42.mkdirSync(path40.dirname(fullPath), { recursive: true });
+  fs42.writeFileSync(fullPath, content);
 }
 function hydrateDirectory(config, cwd, stateDir, localDir) {
   const entries = listStateDirectory(config, cwd, stateDir);
   if (entries.length === 0) return;
-  fs41.rmSync(path40.join(cwd, localDir), { recursive: true, force: true });
+  fs42.rmSync(path40.join(cwd, localDir), { recursive: true, force: true });
   for (const entry of entries) {
     if (!entry.name || !entry.type) continue;
     const childState = path40.posix.join(stateDir, entry.name);
@@ -15828,7 +16364,7 @@ var init_tools = __esm({
 
 // src/executor.ts
 import { spawn as spawn7 } from "child_process";
-import * as fs42 from "fs";
+import * as fs43 from "fs";
 import * as path41 from "path";
 function isMutatingPostflight(scriptName) {
   return MUTATING_POSTFLIGHTS.has(scriptName ?? "");
@@ -16405,7 +16941,7 @@ function resolveProfilePath(profileName) {
     // fallback
   ];
   for (const c of candidates) {
-    if (fs42.existsSync(c)) return c;
+    if (fs43.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -16504,7 +17040,7 @@ function resolveShellTimeoutMs(entry) {
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
   const shellPath = path41.join(profile.dir, shellName);
-  if (!fs42.existsSync(shellPath)) {
+  if (!fs43.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -16916,7 +17452,7 @@ function translateOpenAISseToBrain(opts) {
 }
 
 // src/servers/brain-serve.ts
-import * as fs45 from "fs";
+import * as fs46 from "fs";
 import { createServer } from "http";
 import * as path45 from "path";
 
@@ -17478,7 +18014,7 @@ init_config();
 
 // src/kody-cli.ts
 import { execFileSync as execFileSync25 } from "child_process";
-import * as fs43 from "fs";
+import * as fs44 from "fs";
 import * as path43 from "path";
 
 // src/app-auth.ts
@@ -18100,9 +18636,9 @@ async function resolveAuthToken(env = process.env) {
   return void 0;
 }
 function detectPackageManager2(cwd) {
-  if (fs43.existsSync(path43.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs43.existsSync(path43.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs43.existsSync(path43.join(cwd, "bun.lockb"))) return "bun";
+  if (fs44.existsSync(path43.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs44.existsSync(path43.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs44.existsSync(path43.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shouldChainScheduledWatch(match) {
@@ -18195,8 +18731,8 @@ function postFailureTail(issueNumber, cwd, reason) {
   const logPath = lastRunLogPath(cwd);
   let tail = "";
   try {
-    if (fs43.existsSync(logPath)) {
-      const content = fs43.readFileSync(logPath, "utf-8");
+    if (fs44.existsSync(logPath)) {
+      const content = fs44.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -18236,9 +18772,9 @@ async function runCi(argv) {
   let manualWorkflowDispatch = false;
   let forceRunAction = null;
   let forceRunCliArgs = {};
-  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs43.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs44.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs43.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs44.readFileSync(dispatchEventPath, "utf-8"));
       const issueInput = parseInt(String(evt?.inputs?.issue_number ?? ""), 10);
       const sessionInput = String(evt?.inputs?.sessionId ?? "");
       const dutyInput = String(evt?.inputs?.agentResponsibility ?? evt?.inputs?.agentAction ?? "").trim();
@@ -18570,7 +19106,7 @@ init_repoWorkspace();
 
 // src/scripts/brainTurnLog.ts
 init_runtimePaths();
-import * as fs44 from "fs";
+import * as fs45 from "fs";
 import * as path44 from "path";
 import posixPath4 from "path/posix";
 var live = /* @__PURE__ */ new Map();
@@ -18582,8 +19118,8 @@ function brainEventsStatePath(chatId) {
 }
 function lastPersistedSeq(dir, chatId) {
   const p = brainEventsFilePath(dir, chatId);
-  if (!fs44.existsSync(p)) return 0;
-  const lines = fs44.readFileSync(p, "utf-8").split("\n").filter(Boolean);
+  if (!fs45.existsSync(p)) return 0;
+  const lines = fs45.readFileSync(p, "utf-8").split("\n").filter(Boolean);
   if (lines.length === 0) return 0;
   try {
     return JSON.parse(lines[lines.length - 1]).seq || 0;
@@ -18593,9 +19129,9 @@ function lastPersistedSeq(dir, chatId) {
 }
 function readSince(dir, chatId, since) {
   const p = brainEventsFilePath(dir, chatId);
-  if (!fs44.existsSync(p)) return [];
+  if (!fs45.existsSync(p)) return [];
   const out = [];
-  for (const line of fs44.readFileSync(p, "utf-8").split("\n")) {
+  for (const line of fs45.readFileSync(p, "utf-8").split("\n")) {
     if (!line) continue;
     try {
       const rec = JSON.parse(line);
@@ -18621,12 +19157,12 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = brainEventsFilePath(dir, chatId);
-  fs44.mkdirSync(path44.dirname(p), { recursive: true });
+  fs45.mkdirSync(path44.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
     try {
-      fs44.appendFileSync(p, `${JSON.stringify(rec)}
+      fs45.appendFileSync(p, `${JSON.stringify(rec)}
 `);
     } catch (err) {
       process.stderr.write(
@@ -18665,7 +19201,7 @@ function endTurnIfUnterminated(dir, chatId, errMessage) {
     event: { type: "error", error: errMessage || "turn ended unexpectedly", chatId }
   };
   try {
-    fs44.appendFileSync(brainEventsFilePath(dir, chatId), `${JSON.stringify(rec)}
+    fs45.appendFileSync(brainEventsFilePath(dir, chatId), `${JSON.stringify(rec)}
 `);
   } catch {
   }
@@ -18971,7 +19507,7 @@ async function handleChatTurn(req, res, chatId, opts) {
       );
     }
   }
-  fs45.mkdirSync(path45.dirname(sessionFile), { recursive: true });
+  fs46.mkdirSync(path45.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
     role: "user",
     content: message,
@@ -19631,7 +20167,7 @@ async function loadConfigSafe() {
 }
 
 // src/chat-cli.ts
-import * as fs47 from "fs";
+import * as fs48 from "fs";
 import * as path47 from "path";
 
 // src/chat/inbox.ts
@@ -19704,7 +20240,7 @@ function currentBranch(cwd) {
 
 // src/chat/state-sync.ts
 init_stateRepo();
-import * as fs46 from "fs";
+import * as fs47 from "fs";
 import * as path46 from "path";
 function jsonlLines2(text) {
   return text.split("\n").filter((line) => line.length > 0);
@@ -19722,15 +20258,15 @@ function mergeJsonl2(localText, remoteText) {
 function syncJsonlFileFromState(opts) {
   const remote = readStateText(opts.config, opts.cwd, opts.statePath);
   if (!remote) return;
-  const local = fs46.existsSync(opts.localPath) ? fs46.readFileSync(opts.localPath, "utf-8") : "";
+  const local = fs47.existsSync(opts.localPath) ? fs47.readFileSync(opts.localPath, "utf-8") : "";
   const next = mergeJsonl2(local, remote.content);
   if (next === local) return;
-  fs46.mkdirSync(path46.dirname(opts.localPath), { recursive: true });
-  fs46.writeFileSync(opts.localPath, next);
+  fs47.mkdirSync(path46.dirname(opts.localPath), { recursive: true });
+  fs47.writeFileSync(opts.localPath, next);
 }
 function persistJsonlFileToState(opts) {
-  if (!fs46.existsSync(opts.localPath)) return;
-  const localText = fs46.readFileSync(opts.localPath, "utf-8");
+  if (!fs47.existsSync(opts.localPath)) return;
+  const localText = fs47.readFileSync(opts.localPath, "utf-8");
   for (let attempt = 1; attempt <= 3; attempt += 1) {
     const remote = readStateText(opts.config, opts.cwd, opts.statePath);
     const body = mergeJsonl2(localText, remote?.content ?? "");
@@ -20051,7 +20587,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs47.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs48.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {
@@ -20938,7 +21474,7 @@ async function poolServe() {
 
 // src/servers/runner-serve.ts
 import { spawn as spawn8 } from "child_process";
-import * as fs48 from "fs";
+import * as fs49 from "fs";
 import { createServer as createServer5 } from "http";
 var DEFAULT_PORT2 = 8080;
 var DEFAULT_WORKDIR = "/workspace/repo";
@@ -21018,8 +21554,8 @@ async function defaultRunJob(job) {
   const workdir = process.env.RUNNER_WORKDIR ?? DEFAULT_WORKDIR;
   const branch = job.ref ?? "main";
   const authUrl = `https://x-access-token:${job.githubToken}@github.com/${job.repo}.git`;
-  fs48.rmSync(workdir, { recursive: true, force: true });
-  fs48.mkdirSync(workdir, { recursive: true });
+  fs49.rmSync(workdir, { recursive: true, force: true });
+  fs49.mkdirSync(workdir, { recursive: true });
   const allSecrets = typeof job.allSecrets === "string" ? job.allSecrets : JSON.stringify(job.allSecrets ?? {});
   const interactive = job.mode === "interactive";
   const scheduled = job.mode === "scheduled";
@@ -21154,7 +21690,7 @@ async function runnerServe() {
 init_config();
 init_litellm();
 import { spawn as spawn9 } from "child_process";
-function parseTarget2(positional) {
+function parseTarget(positional) {
   if (!Array.isArray(positional) || positional.length === 0) return "none";
   const first = String(positional[0]).toLowerCase();
   if (first === "vscode" || first === "code") return "vscode";
@@ -21169,7 +21705,7 @@ function buildProxyEnv(url) {
   };
 }
 async function serve(opts) {
-  const target = parseTarget2(opts.args);
+  const target = parseTarget(opts.args);
   const model = parseProviderModel(opts.config.agent.model);
   const usesProxy = needsLitellmProxy(model);
   let handle = null;