@kody-ade/kody-engine 0.4.254 → 0.4.256

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.254",
+      version: "0.4.256",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative agentAction profiles.",
       license: "MIT",
       type: "module",
@@ -3162,12 +3162,18 @@ function parseAgentResponsibilityResult(raw) {
   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,
     status: obj.status,
     summary,
     facts,
-    artifacts
+    artifacts,
+    missingEvidence,
+    blockers
   };
 }
 function applyAgentResponsibilityResultToObjectiveState(state, result, evidenceOverride) {
@@ -3186,8 +3192,9 @@ function applyAgentResponsibilityResultToObjectiveState(state, result, evidenceO
     }
   }
   const blockers = parseStringArray(state.extra.blockers) ?? [];
-  if ((result.status === "fail" || result.status === "blocked") && !blockers.includes(result.summary)) {
-    blockers.push(result.summary);
+  const resultBlockers = result.blockers.length > 0 || result.status !== "fail" && result.status !== "blocked" ? result.blockers : [result.summary];
+  for (const blocker of resultBlockers) {
+    if (!blockers.includes(blocker)) blockers.push(blocker);
   }
   return {
     ...state,
@@ -3199,7 +3206,9 @@ function applyAgentResponsibilityResultToObjectiveState(state, result, evidenceO
         status: result.status,
         summary: result.summary,
         facts: result.facts,
-        artifacts: result.artifacts
+        artifacts: result.artifacts,
+        missingEvidence: result.missingEvidence,
+        blockers: result.blockers
       }
     }
   };
@@ -3227,6 +3236,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;
@@ -6179,6 +6192,308 @@ 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];
+  const path48 = existing?.path ?? goalRunLogPath(goalId, data);
+  logs[goalId] = {
+    path: path48,
+    events: [
+      ...existing?.events ?? [],
+      {
+        version: 1,
+        time: at,
+        goalId,
+        ...event
+      }
+    ]
+  };
+}
+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(enrichGoalRunLogEvent(config, data, log2.path, event))).join("\n")}
+`;
+    appendStateLine(config, cwd, log2.path, lines, `chore(goal-logs): append ${goalId}`);
+    log2.events = [];
+  }
+}
+function goalRunLogPath(goalId, data) {
+  const startedAt = goalRunStartedAt(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)) {
+    return existing;
+  }
+  const logs = {};
+  data[LOGS_KEY] = logs;
+  return logs;
+}
+function goalRunStartedAt(data) {
+  const existing = data[LOG_STARTED_KEY];
+  if (typeof existing === "string" && existing.length > 0) return existing;
+  const stamp = nowIso().replace(/[:.]/g, "-");
+  data[LOG_STARTED_KEY] = stamp;
+  return stamp;
+}
+function goalRunId(data) {
+  const existing = data[LOG_RUN_KEY];
+  if (typeof existing === "string" && existing.length > 0) return existing;
+  const raw = stringValue(data.jobId) ?? githubRunId() ?? `local-${process.pid}-${Date.now()}`;
+  const safe = safePathSegment(raw);
+  data[LOG_RUN_KEY] = safe;
+  return safe;
+}
+function githubRunId() {
+  const runId = process.env.GITHUB_RUN_ID?.trim();
+  if (!runId) return null;
+  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;
+}
+function safePathSegment(value) {
+  const safe = value.trim().replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "");
+  return safe || "unknown";
+}
+var LOGS_KEY, LOG_RUN_KEY, LOG_STARTED_KEY;
+var init_runLog = __esm({
+  "src/goal/runLog.ts"() {
+    "use strict";
+    init_stateRepo();
+    init_state2();
+    LOGS_KEY = "__goalRunLogs";
+    LOG_RUN_KEY = "__goalRunLogRunId";
+    LOG_STARTED_KEY = "__goalRunLogStartedAt";
+  }
+});
+
 // src/goal/typeDefinitions.ts
 function cloneRoute(route) {
   return route.map((step) => ({
@@ -6505,7 +6820,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, "-");
@@ -6577,7 +6892,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 {
@@ -6606,7 +6921,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()}`;
@@ -6623,10 +6938,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);
@@ -6644,12 +6959,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() {
@@ -6918,6 +7233,87 @@ var init_goalAgentResponsibilityScheduling = __esm({
 });
 
 // src/scripts/advanceManagedGoal.ts
+function stageManagedGoalDecision(data, goalId, goal, goalState, decision, details) {
+  if (decision.kind === "dispatch") {
+    stageGoalRunLogEvent(data, goalId, {
+      source: "goal-manager",
+      event: "goal.tick.dispatch",
+      goalType: goal.type,
+      goalState,
+      stage: decision.stage,
+      evidence: decision.evidence,
+      status: decision.kind,
+      dispatch: {
+        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;
+  }
+  if (decision.kind === "done") {
+    stageGoalRunLogEvent(data, goalId, {
+      source: "goal-manager",
+      event: "goal.tick.done",
+      goalType: goal.type,
+      goalState: "done",
+      stage: "done",
+      status: decision.kind,
+      reason: "managed goal complete",
+      goal: details.goalSnapshot,
+      inspection: details.inspection,
+      decision: { kind: decision.kind, reason: "managed goal complete" },
+      change: details.change
+    });
+    return;
+  }
+  if (decision.kind === "idle") {
+    stageGoalRunLogEvent(data, goalId, {
+      source: "goal-manager",
+      event: "goal.tick.idle",
+      goalType: goal.type,
+      goalState,
+      stage: goal.stage,
+      status: decision.kind,
+      reason: decision.reason,
+      goal: details.goalSnapshot,
+      inspection: details.inspection,
+      decision: { kind: decision.kind, reason: decision.reason },
+      change: details.change
+    });
+    return;
+  }
+  stageGoalRunLogEvent(data, goalId, {
+    source: "goal-manager",
+    event: `goal.tick.${decision.kind}`,
+    goalType: goal.type,
+    goalState,
+    stage: decision.stage,
+    evidence: decision.evidence,
+    status: decision.kind,
+    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) {
   const raw = gh(
     ["issue", "list", "--state", "all", "--label", `goal:${goalId}`, "--limit", "1000", "--json", "number,state"],
@@ -6984,6 +7380,7 @@ var init_advanceManagedGoal = __esm({
   "src/scripts/advanceManagedGoal.ts"() {
     "use strict";
     init_manager();
+    init_runLog();
     init_state2();
     init_typeDefinitions();
     init_issue();
@@ -7005,6 +7402,23 @@ var init_advanceManagedGoal = __esm({
       }
       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 restoreGoalIdFact = () => {
         if (previousGoalIdFact === void 0) delete managed.facts.goalId;
         else managed.facts.goalId = previousGoalIdFact;
@@ -7017,10 +7431,28 @@ 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",
+          goalType: managed.type,
+          goalState: goal.state,
+          stage: managed.stage,
+          status: "blocked",
+          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();
@@ -7034,10 +7466,41 @@ var init_advanceManagedGoal = __esm({
             cliArgs: decision2.dispatch.cliArgs
           };
         }
+        stageGoalRunLogEvent(ctx.data, goal.id, {
+          source: "goal-manager",
+          event: decision2.kind === "dispatch" ? "loop.tick.dispatch" : `loop.tick.${decision2.kind}`,
+          goalType: managed.type,
+          goalState: goal.state,
+          stage: managed.stage,
+          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,
+          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,
@@ -7057,12 +7520,43 @@ var init_advanceManagedGoal = __esm({
             ...goal.raw.extra.saveReport === true ? { saveReport: true } : {}
           };
         }
+        stageGoalRunLogEvent(ctx.data, goal.id, {
+          source: "goal-manager",
+          event: decision2.kind === "dispatch" ? "loop.tick.dispatch" : `loop.tick.${decision2.kind}`,
+          goalType: managed.type,
+          goalState: goal.state,
+          stage: managed.stage,
+          status: decision2.kind,
+          reason: decision2.reason,
+          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;
@@ -7070,6 +7564,19 @@ var init_advanceManagedGoal = __esm({
         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;
@@ -7616,6 +8123,16 @@ var init_appendCompanyIntentDecision = __esm({
 });
 
 // src/scripts/applyAgentResponsibilityReports.ts
+function flushLogs(ctx) {
+  try {
+    flushGoalRunLogEvents(ctx.config, ctx.cwd, ctx.data);
+  } catch (err) {
+    process.stderr.write(
+      `[kody agentResponsibility-report] goal log persist failed (${err instanceof Error ? err.message : String(err)})
+`
+    );
+  }
+}
 function collectReports(raw, agentResult) {
   const out = [];
   if (Array.isArray(raw)) {
@@ -7657,6 +8174,76 @@ function completeSatisfiedManagedGoal(state) {
   if (decision.kind !== "done") return state;
   return writeManagedGoalToState({ ...state, state: "done" }, managed);
 }
+function snapshotFromState(goalId, state) {
+  const managed = managedGoalFromState(state);
+  return managed ? goalRunLogSnapshot(goalId, state.state, managed) : null;
+}
+function responsibilityReportOutput(report, goalAfter) {
+  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 {
+    kind: "report",
+    status,
+    summary: "responsibility reported goal evidence",
+    evidence,
+    facts: report.facts ?? {},
+    artifacts: [],
+    missingEvidence: stringArrayField(goalAfter, "missingEvidence"),
+    blockers: stringArrayField(goalAfter, "blockers")
+  };
+}
+function responsibilityResultOutput(result) {
+  return {
+    kind: "result",
+    status: result.status,
+    summary: result.summary,
+    facts: result.facts,
+    artifacts: result.artifacts,
+    missingEvidence: result.missingEvidence,
+    blockers: result.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, reports, results) {
   const pieces = [];
   if (reports && reports.length > 0) pieces.push(`report=${reports.length}`);
@@ -7670,6 +8257,7 @@ var init_applyAgentResponsibilityReports = __esm({
     init_agent_responsibilityReport();
     init_agent_responsibilityResult();
     init_manager();
+    init_runLog();
     init_state2();
     init_stateStore();
     applyAgentResponsibilityReports = async (ctx, _profile, agentResult) => {
@@ -7683,22 +8271,99 @@ var init_applyAgentResponsibilityReports = __esm({
       for (const goalId of goalIds) {
         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: {
+                reports: reportsByGoal.get(goalId)?.length ?? 0,
+                results: goalId === resultGoalId ? results.length : 0
+              },
+              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) ?? []) {
+          const beforeSnapshot = snapshotFromState(goalId, next);
           next = applyAgentResponsibilityReportToGoalState(next, report);
+          const afterSnapshot = snapshotFromState(goalId, next);
+          const change = goalRunLogChange(beforeSnapshot, afterSnapshot);
+          const output = responsibilityReportOutput(report, afterSnapshot);
+          stageGoalRunLogEvent(ctx.data, goalId, {
+            source: "goal-loop",
+            event: change ? "goal.evidence.applied" : "goal.evidence.unchanged",
+            goalState: next.state,
+            evidenceValues: report.evidence,
+            facts: report.facts,
+            goal: afterSnapshot ?? void 0,
+            inspection: evidenceInspection(beforeSnapshot, afterSnapshot, output),
+            decision: {
+              ...evidenceDecision(change, afterSnapshot, output),
+              evidence: report.evidence
+            },
+            change
+          });
         }
         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) {
+            const beforeSnapshot = snapshotFromState(goalId, next);
             next = applyAgentResponsibilityResultToObjectiveState(next, result, evidence);
+            const afterSnapshot = snapshotFromState(goalId, next);
+            const change = goalRunLogChange(beforeSnapshot, afterSnapshot);
+            const output = responsibilityResultOutput(result);
+            stageGoalRunLogEvent(ctx.data, goalId, {
+              source: "goal-loop",
+              event: change ? "goal.evidence.applied" : "goal.evidence.unchanged",
+              goalState: next.state,
+              evidence,
+              status: result.status,
+              reason: result.summary,
+              facts: result.facts,
+              artifacts: result.artifacts,
+              goal: afterSnapshot ?? beforeSnapshot ?? void 0,
+              inspection: evidenceInspection(beforeSnapshot, afterSnapshot, output, evidence),
+              decision: {
+                ...evidenceDecision(change, afterSnapshot, output),
+                evidence
+              },
+              change
+            });
           }
         }
+        const beforeCompletionSnapshot = snapshotFromState(goalId, next);
         next = completeSatisfiedManagedGoal(next);
-        if (serializeGoalState(next) === serializeGoalState(prior)) continue;
+        const afterCompletionSnapshot = snapshotFromState(goalId, next);
+        if (prior.state !== "done" && next.state === "done") {
+          stageGoalRunLogEvent(ctx.data, goalId, {
+            source: "goal-loop",
+            event: "goal.decision.done",
+            goalState: "done",
+            status: "done",
+            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,
@@ -7706,6 +8371,7 @@ var init_applyAgentResponsibilityReports = __esm({
           describeMessage(goalId, reportsByGoal.get(goalId), results),
           ctx.cwd
         );
+        flushLogs(ctx);
       }
     };
   }
@@ -7877,7 +8543,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();
@@ -7899,9 +8565,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;
@@ -7954,8 +8620,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(
               {
@@ -7977,6 +8643,16 @@ var init_commitAndPush = __esm({
 });
 
 // src/scripts/commitGoalState.ts
+function flushLogs2(ctx) {
+  try {
+    flushGoalRunLogEvents(ctx.config, ctx.cwd, ctx.data);
+  } catch (err) {
+    process.stderr.write(
+      `[goal-manager] goal log persist failed (${err instanceof Error ? err.message : String(err)})
+`
+    );
+  }
+}
 function describeCommitMessage(goal) {
   if (goal.state === "done") return `chore(goals): complete ${goal.id}`;
   return `chore(goals): update ${goal.id}`;
@@ -7985,13 +8661,23 @@ var commitGoalState;
 var init_commitGoalState = __esm({
   "src/scripts/commitGoalState.ts"() {
     "use strict";
+    init_runLog();
     init_stateStore();
     commitGoalState = async (ctx) => {
       const goal = ctx.data.goal;
-      if (!goal) return;
-      if (ctx.data.goalPersistChanged !== true) return;
+      if (!goal) {
+        flushLogs2(ctx);
+        return;
+      }
+      if (ctx.data.goalPersistChanged !== true) {
+        flushLogs2(ctx);
+        return;
+      }
       const updated = ctx.data.goalPersistState;
-      if (!updated) return;
+      if (!updated) {
+        flushLogs2(ctx);
+        return;
+      }
       try {
         putGoalState(ctx.config, goal.id, updated, describeCommitMessage(goal), ctx.cwd);
       } catch (err) {
@@ -7999,13 +8685,15 @@ var init_commitGoalState = __esm({
           `[goal-manager] commitGoalState: persist to state repo failed (${err instanceof Error ? err.message : String(err)}); will retry next tick
 `
         );
+      } finally {
+        flushLogs2(ctx);
       }
     };
   }
 });
 
 // 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;
@@ -8145,7 +8833,7 @@ var init_composePrompt = __esm({
           break;
         }
         try {
-          template = fs27.readFileSync(c, "utf-8");
+          template = fs28.readFileSync(c, "utf-8");
           templatePath = c;
           break;
         } catch (err) {
@@ -8156,7 +8844,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)}`;
         }
@@ -8728,7 +9416,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;
@@ -8740,7 +9428,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"));
@@ -8768,13 +9456,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;
@@ -8811,7 +9499,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;
 }
@@ -8819,17 +9507,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];
@@ -8857,10 +9545,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;
     }
@@ -8870,7 +9558,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;
@@ -8885,7 +9573,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;
@@ -8904,7 +9592,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;
   }
@@ -8913,14 +9601,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)
       );
@@ -8954,9 +9642,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();
@@ -9001,7 +9689,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 = {
@@ -9033,9 +9721,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;
@@ -9046,7 +9734,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;
   }
@@ -9054,7 +9742,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;
   }
@@ -9096,23 +9784,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) {
@@ -10326,12 +11014,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) {
@@ -10404,21 +11092,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()) {
@@ -10430,11 +11118,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;
@@ -10587,7 +11275,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);
@@ -10595,9 +11283,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 "";
@@ -10650,10 +11338,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(
@@ -10891,7 +11579,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;
@@ -10943,12 +11631,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;
@@ -11022,13 +11710,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 {};
   }
@@ -11053,7 +11741,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;
@@ -11084,17 +11772,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}
@@ -11140,7 +11828,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 {
@@ -11157,9 +11845,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) {
@@ -13504,9 +14192,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) {
@@ -13562,12 +14250,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`;
@@ -13645,15 +14333,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 ?? "");
@@ -14130,7 +14818,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({
@@ -14158,7 +14846,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;
@@ -14189,7 +14877,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({
@@ -14222,7 +14910,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;
@@ -15044,7 +15732,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"() {
@@ -15070,7 +15758,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 {
       }
@@ -15472,17 +16160,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);
@@ -15590,7 +16278,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 ?? "");
@@ -16167,7 +16855,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];
 }
@@ -16266,7 +16954,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})`;
@@ -16678,7 +17366,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";
 
@@ -17240,7 +17928,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
@@ -17862,9 +18550,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) {
@@ -17957,8 +18645,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 {
@@ -17998,9 +18686,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();
@@ -18332,7 +19020,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();
@@ -18344,8 +19032,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;
@@ -18355,9 +19043,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);
@@ -18383,12 +19071,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(
@@ -18427,7 +19115,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 {
   }
@@ -18733,7 +19421,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,
@@ -19393,7 +20081,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
@@ -19466,7 +20154,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);
@@ -19484,15 +20172,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 ?? "");
@@ -19813,7 +20501,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 {
@@ -20700,7 +21388,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";
@@ -20780,8 +21468,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";