@kody-ade/kody-engine 0.4.97 → 0.4.100

package/dist/bin/kody.js

@@ -19,8 +19,8 @@ __export(events_exports, {
   resolveRunId: () => resolveRunId
 });
 import * as crypto from "crypto";
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 function resolveRunId() {
   if (cachedRunId) return cachedRunId;
   if (process.env.KODY_RUN_ID) {
@@ -49,17 +49,17 @@ function emitEvent(cwd, ev) {
       runId,
       ...ev
     };
-    const eventsPath2 = path4.join(cwd, ".kody", "runs", runId, "events.jsonl");
-    fs4.mkdirSync(path4.dirname(eventsPath2), { recursive: true });
-    fs4.appendFileSync(eventsPath2, `${JSON.stringify(fullEvent)}
+    const eventsPath2 = path5.join(cwd, ".kody", "runs", runId, "events.jsonl");
+    fs5.mkdirSync(path5.dirname(eventsPath2), { recursive: true });
+    fs5.appendFileSync(eventsPath2, `${JSON.stringify(fullEvent)}
 `);
   } catch {
   }
 }
 function readEvents(cwd, runId) {
-  const eventsPath2 = path4.join(cwd, ".kody", "runs", runId, "events.jsonl");
-  if (!fs4.existsSync(eventsPath2)) return [];
-  const lines = fs4.readFileSync(eventsPath2, "utf-8").split("\n");
+  const eventsPath2 = path5.join(cwd, ".kody", "runs", runId, "events.jsonl");
+  if (!fs5.existsSync(eventsPath2)) return [];
+  const lines = fs5.readFileSync(eventsPath2, "utf-8").split("\n");
   const out = [];
   for (const line of lines) {
     const trimmed = line.trim();
@@ -72,11 +72,11 @@ function readEvents(cwd, runId) {
   return out;
 }
 function listRuns(cwd) {
-  const runsDir = path4.join(cwd, ".kody", "runs");
-  if (!fs4.existsSync(runsDir)) return [];
-  return fs4.readdirSync(runsDir).filter((name) => {
+  const runsDir = path5.join(cwd, ".kody", "runs");
+  if (!fs5.existsSync(runsDir)) return [];
+  return fs5.readdirSync(runsDir).filter((name) => {
     try {
-      return fs4.statSync(path4.join(runsDir, name)).isDirectory();
+      return fs5.statSync(path5.join(runsDir, name)).isDirectory();
     } catch {
       return false;
     }
@@ -469,16 +469,16 @@ var init_issue = __esm({
 });
 
 // src/prompt.ts
-import * as fs17 from "fs";
-import * as path15 from "path";
+import * as fs18 from "fs";
+import * as path16 from "path";
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path15.join(projectDir, rel);
-    if (!fs17.existsSync(abs)) continue;
+    const abs = path16.join(projectDir, rel);
+    if (!fs18.existsSync(abs)) continue;
     let content;
     try {
-      content = fs17.readFileSync(abs, "utf-8");
+      content = fs18.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -626,28 +626,28 @@ var loadMemoryContext_exports = {};
 __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
-import * as fs32 from "fs";
-import * as path30 from "path";
+import * as fs33 from "fs";
+import * as path31 from "path";
 function collectPages(memoryAbs) {
   const out = [];
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs32.statSync(file);
+      stat = fs33.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs32.readFileSync(file, "utf-8");
+      raw = fs33.readFileSync(file, "utf-8");
     } catch {
       return;
     }
     const fm = raw.match(/^---\s*\n([\s\S]*?)\n---/);
-    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path30.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path31.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path30.relative(memoryAbs, file),
+      relPath: path31.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX : raw,
@@ -715,16 +715,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs32.readdirSync(dir);
+      names = fs33.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path30.join(dir, name);
+      const full = path31.join(dir, name);
       let stat;
       try {
-        stat = fs32.statSync(full);
+        stat = fs33.statSync(full);
       } catch {
         continue;
       }
@@ -747,8 +747,8 @@ var init_loadMemoryContext = __esm({
     TRUNCATED_SUFFIX = "\n\n\u2026 (truncated)";
     loadMemoryContext = async (ctx) => {
       if (typeof ctx.data.memoryContext === "string") return;
-      const memoryAbs = path30.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-      if (!fs32.existsSync(memoryAbs)) {
+      const memoryAbs = path31.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+      if (!fs33.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
       }
@@ -877,7 +877,7 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.97",
+  version: "0.4.100",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -931,9 +931,9 @@ var package_default = {
 };
 
 // src/chat-cli.ts
-import { execFileSync as execFileSync31 } from "child_process";
-import * as fs38 from "fs";
-import * as path35 from "path";
+import { execFileSync as execFileSync32 } from "child_process";
+import * as fs39 from "fs";
+import * as path36 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -999,18 +999,106 @@ function makeRunId(sessionId, suffix) {
 }
 
 // src/chat/loop.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
+
+// src/task-artifacts.ts
+import fs2 from "fs";
+import path2 from "path";
+var TASK_ARTIFACT_FILES = [
+  "context.json",
+  "memory-recs.json",
+  "followups.json",
+  "handoff-notes.md"
+];
+function prepareTaskArtifactsDir(cwd, taskId) {
+  const safeId = String(taskId).replace(/[^a-zA-Z0-9._-]/g, "_");
+  const relDir = path2.join(".kody", "tasks", safeId);
+  const absDir = path2.join(cwd, relDir);
+  fs2.mkdirSync(absDir, { recursive: true });
+  return { taskId: safeId, absDir, relDir };
+}
+function verifyTaskArtifacts(absDir) {
+  const missing = [];
+  for (const name of TASK_ARTIFACT_FILES) {
+    const full = path2.join(absDir, name);
+    try {
+      const stat = fs2.statSync(full);
+      if (!stat.isFile() || stat.size === 0) missing.push(name);
+    } catch {
+      missing.push(name);
+    }
+  }
+  return missing;
+}
+function taskArtifactsPromptAddendum(opts) {
+  return [
+    "## Per-task artifacts (REQUIRED before your final response)",
+    "",
+    `Before you finish, write these four files into \`${opts.relDir}/\`:`,
+    "",
+    `1. **context.json** \u2014 task header. Shape:`,
+    "   ```json",
+    "   {",
+    `     "taskId": "${opts.taskId}",`,
+    `     "taskType": "${opts.taskType}",`,
+    `     "target": "<issue/PR number, session id, or job slug>",`,
+    `     "outcome": "success" | "failure" | "partial",`,
+    `     "exitCode": <number>,`,
+    `     "reason": "<one-line summary of why you exited>",`,
+    `     "prUrl": "<url or null>",`,
+    `     "runUrl": "<url or null>",`,
+    `     "filesTouched": ["path/from/repo/root.ts", ...],`,
+    `     "sessionLog": ".kody/sessions/<id>.jsonl",`,
+    `     "startedAt": "<ISO>",`,
+    `     "finishedAt": "<ISO>"`,
+    "   }",
+    "   ```",
+    "",
+    `2. **memory-recs.json** \u2014 array of sticky-note candidates worth promoting`,
+    `   to long-term \`.kody/memory/\`. Each item:`,
+    "   ```json",
+    "   {",
+    `     "type": "preference" | "decision" | "lesson",`,
+    `     "name": "kebab-case-slug",`,
+    `     "hook": "one-line summary for INDEX.md",`,
+    `     "body": "markdown body \u2014 explain the rule plus a Why: line",`,
+    `     "why": "the load-bearing reason a future session needs this",`,
+    `     "confidence": 0.0 to 1.0`,
+    "   }",
+    "   ```",
+    `   Use \`[]\` if nothing in this task is worth remembering. Forced`,
+    `   filler is worse than nothing \u2014 only record what would be lost`,
+    `   otherwise.`,
+    "",
+    `3. **followups.json** \u2014 array of TODOs uncovered but not fixed.`,
+    "   ```json",
+    "   {",
+    `     "title": "short summary",`,
+    `     "body": "what the operator should do, and where",`,
+    `     "rationale": "why this matters",`,
+    `     "priority": "low" | "medium" | "high"`,
+    "   }",
+    "   ```",
+    `   Use \`[]\` if nothing surfaced.`,
+    "",
+    `4. **handoff-notes.md** \u2014 short prose (\u2264200 words), no frontmatter:`,
+    `   what you did and why, so the next person/agent can pick up cold.`,
+    "",
+    "Skipping any of the four files is an error. Empty arrays are fine;",
+    "skipping the file is not."
+  ].join("\n");
+}
 
 // src/agent.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
 // src/claudeBinary.ts
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 import { createRequire } from "module";
 import * as os from "os";
-import * as path2 from "path";
+import * as path3 from "path";
 var SDK_PKG = "@anthropic-ai/claude-agent-sdk";
 function candidateSpecs(platform, arch) {
   const ext = platform === "win32" ? ".exe" : "";
@@ -1020,8 +1108,8 @@ function candidateSpecs(platform, arch) {
 function readSdkVersion(req) {
   try {
     const entry = req.resolve(SDK_PKG);
-    const pkgDir = path2.dirname(entry);
-    const raw = fs2.readFileSync(path2.join(pkgDir, "package.json"), "utf8");
+    const pkgDir = path3.dirname(entry);
+    const raw = fs3.readFileSync(path3.join(pkgDir, "package.json"), "utf8");
     const v = JSON.parse(raw)?.version;
     return typeof v === "string" && v.length > 0 ? v : "unknown";
   } catch {
@@ -1043,24 +1131,24 @@ function ensureStableClaudeBinary() {
       } catch {
       }
     }
-    if (!source || !fs2.existsSync(source)) {
+    if (!source || !fs3.existsSync(source)) {
       cached = null;
       return cached;
     }
     const ext = process.platform === "win32" ? ".exe" : "";
     const version = readSdkVersion(req);
-    const destDir = path2.join(os.tmpdir(), "kody-claude-sdk", version);
-    const dest = path2.join(destDir, `claude${ext}`);
-    const srcSize = fs2.statSync(source).size;
-    if (fs2.existsSync(dest) && fs2.statSync(dest).size === srcSize) {
+    const destDir = path3.join(os.tmpdir(), "kody-claude-sdk", version);
+    const dest = path3.join(destDir, `claude${ext}`);
+    const srcSize = fs3.statSync(source).size;
+    if (fs3.existsSync(dest) && fs3.statSync(dest).size === srcSize) {
       cached = dest;
       return cached;
     }
-    fs2.mkdirSync(destDir, { recursive: true });
-    const tmp = path2.join(destDir, `.claude.${process.pid}.${Date.now()}.tmp`);
-    fs2.copyFileSync(source, tmp);
-    fs2.chmodSync(tmp, 493);
-    fs2.renameSync(tmp, dest);
+    fs3.mkdirSync(destDir, { recursive: true });
+    const tmp = path3.join(destDir, `.claude.${process.pid}.${Date.now()}.tmp`);
+    fs3.copyFileSync(source, tmp);
+    fs3.chmodSync(tmp, 493);
+    fs3.renameSync(tmp, dest);
     cached = dest;
     return cached;
   } catch {
@@ -1070,8 +1158,8 @@ function ensureStableClaudeBinary() {
 }
 
 // src/config.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 var LITELLM_DEFAULT_PORT = 4e3;
 var LITELLM_DEFAULT_URL = `http://localhost:${LITELLM_DEFAULT_PORT}`;
 function parseProviderModel(s) {
@@ -1089,13 +1177,13 @@ function needsLitellmProxy(model) {
   return model.provider !== "claude" && model.provider !== "anthropic";
 }
 function loadConfig(projectDir = process.cwd()) {
-  const configPath = path3.join(projectDir, "kody.config.json");
-  if (!fs3.existsSync(configPath)) {
+  const configPath = path4.join(projectDir, "kody.config.json");
+  if (!fs4.existsSync(configPath)) {
     throw new Error(`kody.config.json not found at ${configPath}`);
   }
   let raw;
   try {
-    raw = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+    raw = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new Error(`kody.config.json is invalid JSON: ${msg}`);
@@ -1358,10 +1446,10 @@ function resolveTurnTimeoutMs(opts) {
   return DEFAULT_TURN_TIMEOUT_MS;
 }
 async function runAgent(opts) {
-  const ndjsonDir = opts.ndjsonDir ?? path5.join(opts.cwd, ".kody");
-  fs5.mkdirSync(ndjsonDir, { recursive: true });
-  const ndjsonPath = path5.join(ndjsonDir, "last-run.jsonl");
-  const fullLog = fs5.createWriteStream(ndjsonPath, { flags: "w" });
+  const ndjsonDir = opts.ndjsonDir ?? path6.join(opts.cwd, ".kody");
+  fs6.mkdirSync(ndjsonDir, { recursive: true });
+  const ndjsonPath = path6.join(ndjsonDir, "last-run.jsonl");
+  const fullLog = fs6.createWriteStream(ndjsonPath, { flags: "w" });
   const env = {
     ...process.env,
     SKIP_HOOKS: "1",
@@ -1592,48 +1680,48 @@ async function runAgent(opts) {
 }
 
 // src/registry.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 function getExecutablesRoot() {
-  const here = path6.dirname(new URL(import.meta.url).pathname);
+  const here = path7.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path6.join(here, "executables"),
+    path7.join(here, "executables"),
     // dev: src/
-    path6.join(here, "..", "executables"),
+    path7.join(here, "..", "executables"),
     // built: dist/bin → dist/executables
-    path6.join(here, "..", "src", "executables")
+    path7.join(here, "..", "src", "executables")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs6.existsSync(c) && fs6.statSync(c).isDirectory()) return c;
+    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function getProjectExecutablesRoot() {
-  return path6.join(process.cwd(), ".kody", "executables");
+  return path7.join(process.cwd(), ".kody", "executables");
 }
 function getBuiltinJobsRoot() {
-  const here = path6.dirname(new URL(import.meta.url).pathname);
+  const here = path7.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path6.join(here, "jobs"),
+    path7.join(here, "jobs"),
     // dev: src/
-    path6.join(here, "..", "jobs"),
+    path7.join(here, "..", "jobs"),
     // built: dist/bin → dist/jobs
-    path6.join(here, "..", "src", "jobs")
+    path7.join(here, "..", "src", "jobs")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs6.existsSync(c) && fs6.statSync(c).isDirectory()) return c;
+    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function listBuiltinJobs(root = getBuiltinJobsRoot()) {
-  if (!fs6.existsSync(root) || !fs6.statSync(root).isDirectory()) return [];
+  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) return [];
   const out = [];
-  for (const ent of fs6.readdirSync(root, { withFileTypes: true })) {
+  for (const ent of fs7.readdirSync(root, { withFileTypes: true })) {
     if (!ent.isFile() || !ent.name.endsWith(".md")) continue;
     const slug = ent.name.slice(0, -3);
-    out.push({ slug, filePath: path6.join(root, ent.name) });
+    out.push({ slug, filePath: path7.join(root, ent.name) });
   }
   out.sort((a, b) => a.slug.localeCompare(b.slug));
   return out;
@@ -1646,13 +1734,13 @@ function listExecutables(roots = getExecutableRoots()) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const root of rootList) {
-    if (!fs6.existsSync(root)) continue;
-    const entries = fs6.readdirSync(root, { withFileTypes: true });
+    if (!fs7.existsSync(root)) continue;
+    const entries = fs7.readdirSync(root, { withFileTypes: true });
     for (const ent of entries) {
       if (!ent.isDirectory()) continue;
       if (seen.has(ent.name)) continue;
-      const profilePath = path6.join(root, ent.name, "profile.json");
-      if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile()) {
+      const profilePath = path7.join(root, ent.name, "profile.json");
+      if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
         out.push({ name: ent.name, profilePath });
         seen.add(ent.name);
       }
@@ -1664,8 +1752,8 @@ function resolveExecutable(name, roots = getExecutableRoots()) {
   if (!isSafeName(name)) return null;
   const rootList = typeof roots === "string" ? [roots] : roots;
   for (const root of rootList) {
-    const profilePath = path6.join(root, name, "profile.json");
-    if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile()) {
+    const profilePath = path7.join(root, name, "profile.json");
+    if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
       return profilePath;
     }
   }
@@ -1681,7 +1769,7 @@ function getProfileInputs(name, roots = getExecutableRoots()) {
   const profilePath = resolveExecutable(name, roots);
   if (!profilePath) return null;
   try {
-    const raw = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
+    const raw = JSON.parse(fs7.readFileSync(profilePath, "utf-8"));
     if (!raw || typeof raw !== "object" || !Array.isArray(raw.inputs)) return [];
     return raw.inputs;
   } catch {
@@ -1711,14 +1799,14 @@ function parseGenericFlags(argv) {
 }
 
 // src/chat/session.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 function sessionFilePath(cwd, sessionId) {
-  return path7.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
+  return path8.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
 }
 function readMeta(file) {
-  if (!fs7.existsSync(file)) return null;
-  const raw = fs7.readFileSync(file, "utf-8");
+  if (!fs8.existsSync(file)) return null;
+  const raw = fs8.readFileSync(file, "utf-8");
   const firstLine2 = raw.split("\n", 1)[0]?.trim();
   if (!firstLine2) return null;
   try {
@@ -1731,8 +1819,8 @@ function readMeta(file) {
   }
 }
 function readSession(file) {
-  if (!fs7.existsSync(file)) return [];
-  const raw = fs7.readFileSync(file, "utf-8").trim();
+  if (!fs8.existsSync(file)) return [];
+  const raw = fs8.readFileSync(file, "utf-8").trim();
   if (!raw) return [];
   const turns = [];
   for (const line of raw.split("\n")) {
@@ -1748,14 +1836,14 @@ function readSession(file) {
   return turns;
 }
 function appendTurn(file, turn) {
-  fs7.mkdirSync(path7.dirname(file), { recursive: true });
+  fs8.mkdirSync(path8.dirname(file), { recursive: true });
   const line = JSON.stringify({
     role: turn.role,
     content: turn.content,
     timestamp: turn.timestamp,
     toolCalls: turn.toolCalls ?? []
   });
-  fs7.appendFileSync(file, `${line}
+  fs8.appendFileSync(file, `${line}
 `);
 }
 function seedInitialMessage(file, message) {
@@ -1865,7 +1953,7 @@ function buildExecutableCatalog() {
   const entries = [];
   for (const { name, profilePath } of discovered) {
     try {
-      const raw = JSON.parse(fs8.readFileSync(profilePath, "utf-8"));
+      const raw = JSON.parse(fs9.readFileSync(profilePath, "utf-8"));
       const describe = typeof raw.describe === "string" ? raw.describe : "";
       const firstSentence = describe.split(/(?<=[.!?])\s+/, 1)[0] ?? "";
       entries.push({ name, describe: firstSentence.trim() });
@@ -1902,9 +1990,13 @@ async function runChatTurn(opts) {
   }
   const basePrompt = opts.systemPrompt ?? CHAT_SYSTEM_PROMPT;
   const catalog = buildExecutableCatalog();
-  const systemPrompt = catalog ? `${basePrompt}
-
-${catalog}` : basePrompt;
+  const taskArtifactsPaths = prepareTaskArtifactsDir(opts.cwd, opts.sessionId);
+  const artifactAddendum = taskArtifactsPromptAddendum({
+    taskId: taskArtifactsPaths.taskId,
+    taskType: "chat",
+    relDir: taskArtifactsPaths.relDir
+  });
+  const systemPrompt = [basePrompt, catalog, artifactAddendum].filter((s) => typeof s === "string" && s.length > 0).join("\n\n");
   const prompt = buildPrompt(turns);
   let progressSeq = 0;
   const invoke = opts.invokeAgent ?? ((p) => runAgent({
@@ -1970,6 +2062,16 @@ ${catalog}` : basePrompt;
     timestamp: now
   });
   await emit(opts.sink, "chat.done", opts.sessionId, "done", { sessionId: opts.sessionId });
+  try {
+    const missing = verifyTaskArtifacts(taskArtifactsPaths.absDir);
+    if (missing.length > 0) {
+      process.stderr.write(
+        `[task-artifacts] chat session ${taskArtifactsPaths.taskId} missing: ${missing.join(", ")}
+`
+      );
+    }
+  } catch {
+  }
   return { exitCode: 0, reply };
 }
 function buildPrompt(turns) {
@@ -1990,8 +2092,8 @@ async function emit(sink, type, sessionId, suffix, payload) {
 // src/chat/modes/interactive.ts
 init_issue();
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs9 from "fs";
-import * as path8 from "path";
+import * as fs10 from "fs";
+import * as path9 from "path";
 
 // src/chat/inbox.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -2150,9 +2252,9 @@ function findNextUserTurn(turns, fromIdx) {
   return -1;
 }
 function commitTurn(cwd, sessionId, _verbose) {
-  const sessionRel = path8.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsRel = path8.relative(cwd, eventsFilePath(cwd, sessionId));
-  const rels = [sessionRel, eventsRel].filter((p) => fs9.existsSync(path8.join(cwd, p)));
+  const sessionRel = path9.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsRel = path9.relative(cwd, eventsFilePath(cwd, sessionId));
+  const rels = [sessionRel, eventsRel].filter((p) => fs10.existsSync(path9.join(cwd, p)));
   if (rels.length === 0) return;
   const repository = process.env.GITHUB_REPOSITORY;
   if (!repository) {
@@ -2164,8 +2266,8 @@ function commitTurn(cwd, sessionId, _verbose) {
   }
   const branch = defaultBranch(cwd) ?? "main";
   for (const rel of rels) {
-    const repoPath = rel.split(path8.sep).join("/");
-    const localText = fs9.readFileSync(path8.join(cwd, rel), "utf-8");
+    const repoPath = rel.split(path9.sep).join("/");
+    const localText = fs10.readFileSync(path9.join(cwd, rel), "utf-8");
     putJsonlViaContents(repository, branch, repoPath, localText, sessionId, cwd);
   }
 }
@@ -2254,12 +2356,12 @@ async function emit2(sink, type, sessionId, suffix, payload) {
 }
 
 // src/kody-cli.ts
-import { execFileSync as execFileSync30 } from "child_process";
-import * as fs37 from "fs";
-import * as path34 from "path";
+import { execFileSync as execFileSync31 } from "child_process";
+import * as fs38 from "fs";
+import * as path35 from "path";
 
 // src/dispatch.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 
 // src/cron-match.ts
 var FIELD_BOUNDS = [
@@ -2343,10 +2445,10 @@ function autoDispatch(opts) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs10.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs11.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs10.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs11.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -2419,7 +2521,7 @@ function autoDispatchTyped(opts) {
   if (legacy) return { kind: "route", ...legacy };
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs10.existsSync(eventPath)) {
+  if (!eventName || !eventPath || !fs11.existsSync(eventPath)) {
     return { kind: "silent", reason: "no GHA event context" };
   }
   if (eventName !== "issue_comment") {
@@ -2427,7 +2529,7 @@ function autoDispatchTyped(opts) {
   }
   let event = {};
   try {
-    event = JSON.parse(fs10.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs11.readFileSync(eventPath, "utf-8"));
   } catch {
     return { kind: "silent", reason: "GHA event payload unreadable" };
   }
@@ -2461,7 +2563,7 @@ function dispatchScheduledWatches(opts) {
   for (const exe of listExecutables()) {
     let raw;
     try {
-      raw = fs10.readFileSync(exe.profilePath, "utf-8");
+      raw = fs11.readFileSync(exe.profilePath, "utf-8");
     } catch {
       continue;
     }
@@ -2577,17 +2679,17 @@ function coerceBare(spec, value) {
 init_issue();
 
 // src/executor.ts
-import { execFileSync as execFileSync29, spawn as spawn6 } from "child_process";
-import * as fs36 from "fs";
-import * as path33 from "path";
+import { execFileSync as execFileSync30, spawn as spawn6 } from "child_process";
+import * as fs37 from "fs";
+import * as path34 from "path";
 init_events();
 
 // src/lifecycleLabels.ts
 init_issue();
 
 // src/profile.ts
-import * as fs11 from "fs";
-import * as path9 from "path";
+import * as fs12 from "fs";
+import * as path10 from "path";
 
 // src/profile-error.ts
 var ProfileError = class extends Error {
@@ -2755,12 +2857,12 @@ var KNOWN_PROFILE_KEYS = /* @__PURE__ */ new Set([
   "preloadContext"
 ]);
 function loadProfile(profilePath) {
-  if (!fs11.existsSync(profilePath)) {
+  if (!fs12.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs11.readFileSync(profilePath, "utf-8"));
+    raw = JSON.parse(fs12.readFileSync(profilePath, "utf-8"));
   } catch (err) {
     throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -2771,7 +2873,7 @@ function loadProfile(profilePath) {
   const unknownKeys = Object.keys(r).filter((k) => !KNOWN_PROFILE_KEYS.has(k));
   if (unknownKeys.length > 0) {
     process.stderr.write(
-      `[kody profile] ${path9.basename(path9.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
+      `[kody profile] ${path10.basename(path10.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
 `
     );
   }
@@ -2832,7 +2934,7 @@ function loadProfile(profilePath) {
     // Phase 5 in-process handoff opt-in. Default false; containers
     // flip to true after end-to-end verification.
     preloadContext: r.preloadContext === true,
-    dir: path9.dirname(profilePath)
+    dir: path10.dirname(profilePath)
   };
   if (lifecycle) {
     applyLifecycle(profile, profilePath);
@@ -3202,9 +3304,9 @@ function errMsg(err) {
 
 // src/litellm.ts
 import { execFileSync as execFileSync4, spawn as spawn2 } from "child_process";
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as os2 from "os";
-import * as path10 from "path";
+import * as path11 from "path";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -3251,20 +3353,20 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
       throw new Error("litellm not installed \u2014 run: pip install 'litellm[proxy]'");
     }
   }
-  const configPath = path10.join(os2.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
-  fs12.writeFileSync(configPath, generateLitellmConfigYaml(model));
+  const configPath = path11.join(os2.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
+  fs13.writeFileSync(configPath, generateLitellmConfigYaml(model));
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4000";
   const args = cmd === "litellm" ? ["--config", configPath, "--port", port] : ["-m", "litellm", "--config", configPath, "--port", port];
   const dotenvVars = readDotenvApiKeys(projectDir);
-  const logPath = path10.join(os2.tmpdir(), `kody-litellm-${Date.now()}.log`);
-  const outFd = fs12.openSync(logPath, "w");
+  const logPath = path11.join(os2.tmpdir(), `kody-litellm-${Date.now()}.log`);
+  const outFd = fs13.openSync(logPath, "w");
   const child = spawn2(cmd, args, {
     stdio: ["ignore", outFd, outFd],
     detached: true,
     env: stripBlockingEnv({ ...process.env, ...dotenvVars })
   });
-  fs12.closeSync(outFd);
+  fs13.closeSync(outFd);
   const timeoutMs = resolveLitellmTimeoutMs();
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -3283,7 +3385,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   }
   let logTail = "";
   try {
-    logTail = fs12.readFileSync(logPath, "utf-8").slice(-2e3);
+    logTail = fs13.readFileSync(logPath, "utf-8").slice(-2e3);
   } catch {
   }
   try {
@@ -3295,10 +3397,10 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
 ${logTail}`);
 }
 function readDotenvApiKeys(projectDir) {
-  const dotenvPath = path10.join(projectDir, ".env");
-  if (!fs12.existsSync(dotenvPath)) return {};
+  const dotenvPath = path11.join(projectDir, ".env");
+  if (!fs13.existsSync(dotenvPath)) return {};
   const result = {};
-  for (const rawLine of fs12.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  for (const rawLine of fs13.readFileSync(dotenvPath, "utf-8").split("\n")) {
     const line = rawLine.trim();
     if (!line || line.startsWith("#")) continue;
     const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
@@ -3321,9 +3423,87 @@ function stripBlockingEnv(env) {
 }
 
 // src/commit.ts
+import { execFileSync as execFileSync6 } from "child_process";
+
+// src/pushWithRetry.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import * as fs13 from "fs";
-import * as path11 from "path";
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_BACKOFF_MS = 1e3;
+var MAX_BACKOFF_MS = 6e4;
+var NON_FAST_FORWARD_RE = /non-fast-forward|fetch first|\(rejected\)|! \[rejected\]/i;
+function sleepSync(ms) {
+  if (ms <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function runGit(args, cwd) {
+  try {
+    const stdout = execFileSync5("git", args, {
+      cwd,
+      encoding: "utf-8",
+      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { ok: true, stdout: stdout?.toString() ?? "", stderr: "" };
+  } catch (err) {
+    const e = err;
+    const stderr = e.stderr?.toString() ?? e.message ?? "";
+    const stdout = e.stdout?.toString() ?? "";
+    return { ok: false, stdout, stderr };
+  }
+}
+function resolveBranch(cwd, explicit) {
+  if (explicit && explicit.trim()) return explicit.trim();
+  const r = runGit(["symbolic-ref", "--short", "HEAD"], cwd);
+  return r.ok ? r.stdout.trim() : "";
+}
+function pushWithRetry(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const baseBackoff = opts.backoffMs ?? DEFAULT_BACKOFF_MS;
+  const branch = resolveBranch(cwd, opts.branch);
+  if (!branch) {
+    return { ok: false, reason: "could not determine current branch (detached HEAD?)", attempts: 0 };
+  }
+  const pushArgs = opts.setUpstream ? ["push", "-u", "origin", `HEAD:${branch}`] : ["push", "origin", "HEAD"];
+  let lastError = "";
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    const push = runGit(pushArgs, cwd);
+    if (push.ok) return { ok: true, attempts: attempt };
+    lastError = push.stderr || push.stdout || "(no error detail)";
+    if (!NON_FAST_FORWARD_RE.test(lastError)) {
+      return { ok: false, reason: `push failed (not retryable): ${lastError.trim().slice(-400)}`, attempts: attempt };
+    }
+    if (attempt === maxRetries) break;
+    const fetch2 = runGit(["fetch", "origin", branch], cwd);
+    if (!fetch2.ok) {
+      return {
+        ok: false,
+        reason: `fetch failed during retry: ${(fetch2.stderr || fetch2.stdout).trim().slice(-400)}`,
+        attempts: attempt
+      };
+    }
+    const rebase = runGit(["rebase", `origin/${branch}`], cwd);
+    if (!rebase.ok) {
+      runGit(["rebase", "--abort"], cwd);
+      return {
+        ok: false,
+        reason: `rebase onto origin/${branch} failed (conflict?): ${(rebase.stderr || rebase.stdout).trim().slice(-400)}`,
+        attempts: attempt
+      };
+    }
+    const delay = Math.min(baseBackoff * 2 ** (attempt - 1), MAX_BACKOFF_MS);
+    sleepSync(delay);
+  }
+  return {
+    ok: false,
+    reason: `push rejected after ${maxRetries} attempts: ${lastError.trim().slice(-400)}`,
+    attempts: maxRetries
+  };
+}
+
+// src/commit.ts
+import * as fs14 from "fs";
+import * as path12 from "path";
 var FORBIDDEN_PATH_PREFIXES = [
   ".kody/",
   ".kody-engine/",
@@ -3350,13 +3530,9 @@ var CONVENTIONAL_PREFIXES = [
   "build:",
   "revert:"
 ];
-var PUSH_RETRY_DELAYS_MS = [2e3, 4e3, 8e3];
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
 function git(args, cwd) {
   try {
-    return execFileSync5("git", args, {
+    return execFileSync6("git", args, {
       encoding: "utf-8",
       timeout: 12e4,
       cwd,
@@ -3383,18 +3559,18 @@ function tryGit(args, cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path11.join(cwd ?? process.cwd(), ".git");
-  if (!fs13.existsSync(gitDir)) return aborted;
-  if (fs13.existsSync(path11.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path12.join(cwd ?? process.cwd(), ".git");
+  if (!fs14.existsSync(gitDir)) return aborted;
+  if (fs14.existsSync(path12.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs13.existsSync(path11.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs14.existsSync(path12.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs13.existsSync(path11.join(gitDir, "REVERT_HEAD"))) {
+  if (fs14.existsSync(path12.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs13.existsSync(path11.join(gitDir, "rebase-merge")) || fs13.existsSync(path11.join(gitDir, "rebase-apply"))) {
+  if (fs14.existsSync(path12.join(gitDir, "rebase-merge")) || fs14.existsSync(path12.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -3415,7 +3591,7 @@ function isForbiddenPath(p) {
   return false;
 }
 function listChangedFiles(cwd) {
-  const raw = execFileSync5("git", ["status", "--porcelain=v1", "-z"], {
+  const raw = execFileSync6("git", ["status", "--porcelain=v1", "-z"], {
     encoding: "utf-8",
     cwd,
     env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
@@ -3427,7 +3603,7 @@ function listChangedFiles(cwd) {
 }
 function listFilesInCommit(ref = "HEAD", cwd) {
   try {
-    const raw = execFileSync5("git", ["show", "--name-only", "--pretty=format:", "-z", ref], {
+    const raw = execFileSync6("git", ["show", "--name-only", "--pretty=format:", "-z", ref], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
@@ -3450,7 +3626,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs13.existsSync(path11.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs14.existsSync(path12.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -3471,28 +3647,11 @@ function commitAndPush(branch, agentMessage, cwd) {
     throw err;
   }
   const sha = git(["rev-parse", "HEAD"], cwd).slice(0, 7);
-  let pushError = "push failed (no error detail)";
-  for (let attempt = 0; attempt <= PUSH_RETRY_DELAYS_MS.length; attempt++) {
-    try {
-      git(["push", "-u", "origin", branch], cwd);
-      return { committed: true, pushed: true, sha, message };
-    } catch (firstErr) {
-      try {
-        git(["push", "--force-with-lease", "-u", "origin", branch], cwd);
-        return { committed: true, pushed: true, sha, message };
-      } catch (secondErr) {
-        const tail = (secondErr instanceof Error ? secondErr.message : String(secondErr)).slice(-400);
-        const initial = firstErr instanceof Error ? firstErr.message : String(firstErr);
-        pushError = `push failed: ${initial.slice(-200)} | force-with-lease failed: ${tail}`;
-        const delay = PUSH_RETRY_DELAYS_MS[attempt];
-        if (delay === void 0) break;
-        process.stderr.write(`[kody:commit] push failed (attempt ${attempt + 1}); retrying in ${delay}ms
-`);
-        sleepSync(delay);
-      }
-    }
+  const pushResult = pushWithRetry({ cwd, branch, setUpstream: true });
+  if (pushResult.ok) {
+    return { committed: true, pushed: true, sha, message };
   }
-  return { committed: true, pushed: false, sha, message, pushError };
+  return { committed: true, pushed: false, sha, message, pushError: pushResult.reason };
 }
 function hasCommitsAhead(branch, defaultBranch2, cwd) {
   try {
@@ -3519,10 +3678,10 @@ var abortUnfinishedGitOps2 = async (ctx) => {
 };
 
 // src/scripts/advanceFlow.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync8 } from "child_process";
 
 // src/state.ts
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 var STATE_BEGIN = "<!-- kody:state:v1:begin -->";
 var STATE_END = "<!-- kody:state:v1:end -->";
 var HISTORY_MAX_ENTRIES = 20;
@@ -3548,7 +3707,7 @@ function ghToken2() {
 function gh2(args, input, cwd) {
   const token = ghToken2();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync6("gh", args, {
+  return execFileSync7("gh", args, {
     encoding: "utf-8",
     timeout: API_TIMEOUT_MS2,
     cwd,
@@ -3751,7 +3910,7 @@ var advanceFlow = async (ctx, profile) => {
   }
   const body = `@kody ${flow.name}`;
   try {
-    execFileSync7("gh", ["issue", "comment", String(flow.issueNumber), "--body", body], {
+    execFileSync8("gh", ["issue", "comment", String(flow.issueNumber), "--body", body], {
       timeout: API_TIMEOUT_MS3,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -3766,20 +3925,20 @@ var advanceFlow = async (ctx, profile) => {
 
 // src/scripts/brainServe.ts
 import { createServer } from "http";
-import * as fs15 from "fs";
-import * as path13 from "path";
+import * as fs16 from "fs";
+import * as path14 from "path";
 
 // src/scripts/brainTurnLog.ts
-import * as fs14 from "fs";
-import * as path12 from "path";
+import * as fs15 from "fs";
+import * as path13 from "path";
 var live = /* @__PURE__ */ new Map();
 function eventsPath(dir, chatId) {
-  return path12.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
+  return path13.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
 }
 function lastPersistedSeq(dir, chatId) {
   const p = eventsPath(dir, chatId);
-  if (!fs14.existsSync(p)) return 0;
-  const lines = fs14.readFileSync(p, "utf-8").split("\n").filter(Boolean);
+  if (!fs15.existsSync(p)) return 0;
+  const lines = fs15.readFileSync(p, "utf-8").split("\n").filter(Boolean);
   if (lines.length === 0) return 0;
   try {
     return JSON.parse(lines[lines.length - 1]).seq || 0;
@@ -3789,9 +3948,9 @@ function lastPersistedSeq(dir, chatId) {
 }
 function readSince(dir, chatId, since) {
   const p = eventsPath(dir, chatId);
-  if (!fs14.existsSync(p)) return [];
+  if (!fs15.existsSync(p)) return [];
   const out = [];
-  for (const line of fs14.readFileSync(p, "utf-8").split("\n")) {
+  for (const line of fs15.readFileSync(p, "utf-8").split("\n")) {
     if (!line) continue;
     try {
       const rec = JSON.parse(line);
@@ -3817,12 +3976,12 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = eventsPath(dir, chatId);
-  fs14.mkdirSync(path12.dirname(p), { recursive: true });
+  fs15.mkdirSync(path13.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
     try {
-      fs14.appendFileSync(p, JSON.stringify(rec) + "\n");
+      fs15.appendFileSync(p, JSON.stringify(rec) + "\n");
     } catch (err) {
       process.stderr.write(
         `[brain-turn-log] append failed for ${chatId}: ${err instanceof Error ? err.message : String(err)}
@@ -3860,7 +4019,7 @@ function endTurnIfUnterminated(dir, chatId, errMessage) {
     event: { type: "error", error: errMessage || "turn ended unexpectedly", chatId }
   };
   try {
-    fs14.appendFileSync(eventsPath(dir, chatId), JSON.stringify(rec) + "\n");
+    fs15.appendFileSync(eventsPath(dir, chatId), JSON.stringify(rec) + "\n");
   } catch {
   }
   state.status = "ended";
@@ -4077,7 +4236,7 @@ async function handleChatTurn(req, res, chatId, opts) {
     return;
   }
   const sessionFile = sessionFilePath(opts.cwd, chatId);
-  fs15.mkdirSync(path13.dirname(sessionFile), { recursive: true });
+  fs16.mkdirSync(path14.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
     role: "user",
     content: message,
@@ -4217,21 +4376,21 @@ var brainServe = async (ctx) => {
 };
 
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as os3 from "os";
-import * as path14 from "path";
+import * as path15 from "path";
 function getPluginsCatalogRoot() {
-  const here = path14.dirname(new URL(import.meta.url).pathname);
+  const here = path15.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path14.join(here, "..", "plugins"),
+    path15.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path14.join(here, "..", "..", "plugins"),
+    path15.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path14.join(here, "..", "..", "src", "plugins")
+    path15.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs16.existsSync(c) && fs16.statSync(c).isDirectory()) return c;
+    if (fs17.existsSync(c) && fs17.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
@@ -4241,52 +4400,52 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   if (!needsSynthetic) return;
   const catalog = getPluginsCatalogRoot();
   const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const root = path14.join(os3.tmpdir(), `kody-synth-${runId}`);
-  fs16.mkdirSync(path14.join(root, ".claude-plugin"), { recursive: true });
+  const root = path15.join(os3.tmpdir(), `kody-synth-${runId}`);
+  fs17.mkdirSync(path15.join(root, ".claude-plugin"), { recursive: true });
   const resolvePart = (bucket, entry) => {
-    const local = path14.join(profile.dir, bucket, entry);
-    if (fs16.existsSync(local)) return local;
-    const central = path14.join(catalog, bucket, entry);
-    if (fs16.existsSync(central)) return central;
+    const local = path15.join(profile.dir, bucket, entry);
+    if (fs17.existsSync(local)) return local;
+    const central = path15.join(catalog, bucket, entry);
+    if (fs17.existsSync(central)) return central;
     throw new Error(
       `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in executable dir (${profile.dir}/${bucket}/) or catalog (${catalog}/${bucket}/)`
     );
   };
   if (cc.skills.length > 0) {
-    const dst = path14.join(root, "skills");
-    fs16.mkdirSync(dst, { recursive: true });
+    const dst = path15.join(root, "skills");
+    fs17.mkdirSync(dst, { recursive: true });
     for (const name of cc.skills) {
-      copyDir(resolvePart("skills", name), path14.join(dst, name));
+      copyDir(resolvePart("skills", name), path15.join(dst, name));
     }
   }
   if (cc.commands.length > 0) {
-    const dst = path14.join(root, "commands");
-    fs16.mkdirSync(dst, { recursive: true });
+    const dst = path15.join(root, "commands");
+    fs17.mkdirSync(dst, { recursive: true });
     for (const name of cc.commands) {
-      fs16.copyFileSync(resolvePart("commands", `${name}.md`), path14.join(dst, `${name}.md`));
+      fs17.copyFileSync(resolvePart("commands", `${name}.md`), path15.join(dst, `${name}.md`));
     }
   }
   if (cc.subagents.length > 0) {
-    const dst = path14.join(root, "agents");
-    fs16.mkdirSync(dst, { recursive: true });
+    const dst = path15.join(root, "agents");
+    fs17.mkdirSync(dst, { recursive: true });
     for (const name of cc.subagents) {
-      fs16.copyFileSync(resolvePart("agents", `${name}.md`), path14.join(dst, `${name}.md`));
+      fs17.copyFileSync(resolvePart("agents", `${name}.md`), path15.join(dst, `${name}.md`));
     }
   }
   if (cc.hooks.length > 0) {
-    const dst = path14.join(root, "hooks");
-    fs16.mkdirSync(dst, { recursive: true });
+    const dst = path15.join(root, "hooks");
+    fs17.mkdirSync(dst, { recursive: true });
     const merged = { hooks: {} };
     for (const name of cc.hooks) {
       const src = resolvePart("hooks", `${name}.json`);
-      const parsed = JSON.parse(fs16.readFileSync(src, "utf-8"));
+      const parsed = JSON.parse(fs17.readFileSync(src, "utf-8"));
       for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
         if (!Array.isArray(entries)) continue;
         if (!merged.hooks[event]) merged.hooks[event] = [];
         merged.hooks[event].push(...entries);
       }
     }
-    fs16.writeFileSync(path14.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+    fs17.writeFileSync(path15.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
   }
   const manifest = {
@@ -4297,22 +4456,22 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   if (cc.skills.length > 0) manifest.skills = ["./skills/"];
   if (cc.commands.length > 0) manifest.commands = ["./commands/"];
   if (cc.subagents.length > 0) manifest.agents = cc.subagents.map((n) => `./agents/${n}.md`);
-  fs16.writeFileSync(path14.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+  fs17.writeFileSync(path15.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
   ctx.data.syntheticPluginPath = root;
 };
 function copyDir(src, dst) {
-  fs16.mkdirSync(dst, { recursive: true });
-  for (const ent of fs16.readdirSync(src, { withFileTypes: true })) {
-    const s = path14.join(src, ent.name);
-    const d = path14.join(dst, ent.name);
+  fs17.mkdirSync(dst, { recursive: true });
+  for (const ent of fs17.readdirSync(src, { withFileTypes: true })) {
+    const s = path15.join(src, ent.name);
+    const d = path15.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs16.copyFileSync(s, d);
+    else if (ent.isFile()) fs17.copyFileSync(s, d);
   }
 }
 
 // src/coverage.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 function patternToRegex(pattern) {
   let s = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
   s = s.replace(/\*\*\//g, "\xA7S").replace(/\*\*/g, "\xA7A").replace(/\*/g, "[^/]*");
@@ -4330,7 +4489,7 @@ function renderSiblingPath(file, requireSibling) {
 }
 function safeGit(args, cwd) {
   try {
-    return execFileSync8("git", args, { encoding: "utf-8", cwd, env: { ...process.env, HUSKY: "0" } }).trim();
+    return execFileSync9("git", args, { encoding: "utf-8", cwd, env: { ...process.env, HUSKY: "0" } }).trim();
   } catch {
     return "";
   }
@@ -4448,13 +4607,13 @@ function defaultLabelMap() {
 }
 
 // src/scripts/commitAndPush.ts
-import * as fs18 from "fs";
-import * as path16 from "path";
+import * as fs19 from "fs";
+import * as path17 from "path";
 init_events();
 var DEFAULT_COMMIT_MESSAGE = "chore: kody changes";
 function sentinelPathForStage(cwd, profileName) {
   const runId = resolveRunId();
-  return path16.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
+  return path17.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
 }
 var commitAndPush2 = async (ctx, profile) => {
   const branch = ctx.data.branch;
@@ -4464,9 +4623,9 @@ var commitAndPush2 = async (ctx, profile) => {
   }
   const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
   const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
-  if (sentinel && fs18.existsSync(sentinel)) {
+  if (sentinel && fs19.existsSync(sentinel)) {
     try {
-      const replay = JSON.parse(fs18.readFileSync(sentinel, "utf-8"));
+      const replay = JSON.parse(fs19.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;
@@ -4519,8 +4678,8 @@ var commitAndPush2 = async (ctx, profile) => {
   const result = ctx.data.commitResult;
   if (sentinel && result?.committed) {
     try {
-      fs18.mkdirSync(path16.dirname(sentinel), { recursive: true });
-      fs18.writeFileSync(
+      fs19.mkdirSync(path17.dirname(sentinel), { recursive: true });
+      fs19.writeFileSync(
         sentinel,
         JSON.stringify(
           {
@@ -4540,14 +4699,14 @@ var commitAndPush2 = async (ctx, profile) => {
 };
 
 // src/scripts/commitGoalState.ts
-import { execFileSync as execFileSync9 } from "child_process";
-import * as path17 from "path";
+import { execFileSync as execFileSync10 } from "child_process";
+import * as path18 from "path";
 var commitGoalState = async (ctx) => {
   const goal = ctx.data.goal;
   if (!goal) return;
-  const stateRel = path17.posix.join(".kody", "goals", goal.id, "state.json");
+  const stateRel = path18.posix.join(".kody", "goals", goal.id, "state.json");
   try {
-    execFileSync9("git", ["add", stateRel], { cwd: ctx.cwd, stdio: "pipe" });
+    execFileSync10("git", ["add", stateRel], { cwd: ctx.cwd, stdio: "pipe" });
   } catch (err) {
     process.stderr.write(
       `[goal-tick] commitGoalState: git add failed: ${err instanceof Error ? err.message : String(err)}
@@ -4556,13 +4715,13 @@ var commitGoalState = async (ctx) => {
     return;
   }
   try {
-    execFileSync9("git", ["diff", "--cached", "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
+    execFileSync10("git", ["diff", "--cached", "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
     return;
   } catch {
   }
   const msg = describeCommitMessage(goal);
   try {
-    execFileSync9("git", ["commit", "-m", msg, "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
+    execFileSync10("git", ["commit", "-m", msg, "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
   } catch (err) {
     process.stderr.write(
       `[goal-tick] commitGoalState: git commit failed: ${err instanceof Error ? err.message : String(err)}
@@ -4570,10 +4729,10 @@ var commitGoalState = async (ctx) => {
     );
     return;
   }
-  try {
-    execFileSync9("git", ["push", "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
-  } catch {
-    process.stderr.write("[goal-tick] commitGoalState: push failed (will retry next tick)\n");
+  const result = pushWithRetry({ cwd: ctx.cwd });
+  if (!result.ok) {
+    process.stderr.write(`[goal-tick] commitGoalState: push failed (${result.reason}); will retry next tick
+`);
   }
 };
 function describeCommitMessage(goal) {
@@ -4590,20 +4749,20 @@ function describeCommitMessage(goal) {
 }
 
 // src/scripts/composePrompt.ts
-import * as fs19 from "fs";
-import * as path18 from "path";
+import * as fs20 from "fs";
+import * as path19 from "path";
 var MUSTACHE = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
 var composePrompt = async (ctx, profile) => {
   const explicit = ctx.data.promptTemplate;
   const mode = ctx.args.mode;
   const candidates = [
-    explicit ? path18.join(profile.dir, explicit) : null,
-    mode ? path18.join(profile.dir, "prompts", `${mode}.md`) : null,
-    path18.join(profile.dir, "prompt.md")
+    explicit ? path19.join(profile.dir, explicit) : null,
+    mode ? path19.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path19.join(profile.dir, "prompt.md")
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
-    if (fs19.existsSync(c)) {
+    if (fs20.existsSync(c)) {
       templatePath = c;
       break;
     }
@@ -4611,7 +4770,7 @@ var composePrompt = async (ctx, profile) => {
   if (!templatePath) {
     throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
   }
-  const template = fs19.readFileSync(templatePath, "utf-8");
+  const template = fs20.readFileSync(templatePath, "utf-8");
   const tokens = {
     ...stringifyAll(ctx.args, "args."),
     ...stringifyAll(ctx.data, ""),
@@ -4689,9 +4848,9 @@ function formatToolsUsage(profile) {
 
 // src/scripts/createQaGoal.ts
 init_issue();
-import { execFileSync as execFileSync10 } from "child_process";
-import * as fs20 from "fs";
-import * as path19 from "path";
+import { execFileSync as execFileSync11 } from "child_process";
+import * as fs21 from "fs";
+import * as path20 from "path";
 
 // src/scripts/postReviewResult.ts
 init_issue();
@@ -4944,8 +5103,8 @@ function createOrUpdateManifestIssue(number, manifest, cwd) {
   return { number: Number(m[1]), created: true };
 }
 function writeStateFile(cwd, goalId, lastDispatchedIssue) {
-  const dir = path19.join(cwd, ".kody", "goals", goalId);
-  fs20.mkdirSync(dir, { recursive: true });
+  const dir = path20.join(cwd, ".kody", "goals", goalId);
+  fs21.mkdirSync(dir, { recursive: true });
   const state = {
     version: 1,
     state: "active",
@@ -4953,15 +5112,15 @@ function writeStateFile(cwd, goalId, lastDispatchedIssue) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...typeof lastDispatchedIssue === "number" ? { lastDispatchedIssue } : {}
   };
-  const filePath = path19.join(dir, "state.json");
-  fs20.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
+  const filePath = path20.join(dir, "state.json");
+  fs21.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
 `);
   return filePath;
 }
 function gitTry(args, cwd) {
   const env = { ...process.env, SKIP_HOOKS: "1", HUSKY: "0" };
   try {
-    execFileSync10("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], env });
+    execFileSync11("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], env });
     return { ok: true, stderr: "" };
   } catch (err) {
     const e = err;
@@ -5462,16 +5621,16 @@ function filterGoalTaskPrs(prs, taskIssueNumbers) {
 }
 
 // src/scripts/diagMcp.ts
-import { execFileSync as execFileSync11 } from "child_process";
-import * as fs21 from "fs";
+import { execFileSync as execFileSync12 } from "child_process";
+import * as fs22 from "fs";
 import * as os4 from "os";
-import * as path20 from "path";
+import * as path21 from "path";
 var diagMcp = async (_ctx) => {
   const home = os4.homedir();
-  const cacheDir = path20.join(home, ".cache", "ms-playwright");
+  const cacheDir = path21.join(home, ".cache", "ms-playwright");
   let entries = [];
   try {
-    entries = fs21.readdirSync(cacheDir);
+    entries = fs22.readdirSync(cacheDir);
   } catch {
   }
   const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -5482,7 +5641,7 @@ var diagMcp = async (_ctx) => {
   process.stderr.write(`[kody diag] chromium present: ${hasChromium ? "yes" : "no"}
 `);
   try {
-    const v = execFileSync11("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
+    const v = execFileSync12("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
       stdio: "pipe",
       timeout: 6e4,
       encoding: "utf8"
@@ -5497,17 +5656,17 @@ var diagMcp = async (_ctx) => {
 };
 
 // src/scripts/discoverQaContext.ts
-import * as fs23 from "fs";
-import * as path22 from "path";
+import * as fs24 from "fs";
+import * as path23 from "path";
 
 // src/scripts/frameworkDetectors.ts
-import * as fs22 from "fs";
-import * as path21 from "path";
+import * as fs23 from "fs";
+import * as path22 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs22.readFileSync(path21.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs23.readFileSync(path22.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -5544,7 +5703,7 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs22.existsSync(path21.join(cwd, c))) return c;
+    if (fs23.existsSync(path22.join(cwd, c))) return c;
   }
   return null;
 }
@@ -5557,18 +5716,18 @@ var COLLECTION_DIRS = [
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path21.join(cwd, dir);
-    if (!fs22.existsSync(full)) continue;
+    const full = path22.join(cwd, dir);
+    if (!fs23.existsSync(full)) continue;
     let files;
     try {
-      files = fs22.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs23.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const filePath = path21.join(full, file);
-        const content = fs22.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path22.join(full, file);
+        const content = fs23.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
@@ -5582,7 +5741,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path21.relative(cwd, filePath),
+          filePath: path22.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -5596,28 +5755,28 @@ var ADMIN_COMPONENT_DIRS = ["src/ui/admin", "src/admin/components", "src/compone
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path21.join(cwd, dir);
-    if (!fs22.existsSync(full)) continue;
+    const full = path22.join(cwd, dir);
+    if (!fs23.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs22.readdirSync(full, { withFileTypes: true });
+      entries = fs23.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path21.join(full, entry.name);
+      const entryPath = path22.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs22.existsSync(path21.join(entryPath, f))
+          (f) => fs23.existsSync(path22.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path21.relative(cwd, path21.join(entryPath, indexFile));
+        filePath = path22.relative(cwd, path22.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path21.relative(cwd, entryPath);
+        filePath = path22.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -5625,7 +5784,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs22.readFileSync(path21.join(cwd, col.filePath), "utf-8");
+            const colContent = fs23.readFileSync(path22.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -5644,8 +5803,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path21.join(cwd, appDir, "api");
-    if (!fs22.existsSync(apiDir)) continue;
+    const apiDir = path22.join(cwd, appDir, "api");
+    if (!fs23.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -5654,14 +5813,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs22.readdirSync(dir, { withFileTypes: true });
+    entries = fs23.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 = fs22.readFileSync(path21.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs23.readFileSync(path22.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)
       );
@@ -5669,7 +5828,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path21.relative(cwd, path21.join(dir, routeFile.name))
+          filePath: path22.relative(cwd, path22.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -5680,7 +5839,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     if (entry.name === "node_modules" || entry.name === ".next") continue;
     let segment = entry.name;
     if (segment.startsWith("(") && segment.endsWith(")")) {
-      walkApiRoutes(path21.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path22.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -5688,7 +5847,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path21.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path22.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
@@ -5708,10 +5867,10 @@ var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
 function scanEnvVars(cwd) {
   const candidates = [".env.example", ".env.local.example", ".env.template"];
   for (const envFile of candidates) {
-    const envPath = path21.join(cwd, envFile);
-    if (!fs22.existsSync(envPath)) continue;
+    const envPath = path22.join(cwd, envFile);
+    if (!fs23.existsSync(envPath)) continue;
     try {
-      const content = fs22.readFileSync(envPath, "utf-8");
+      const content = fs23.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -5759,9 +5918,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs23.readFileSync(path22.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs24.readFileSync(path23.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs23.existsSync(path22.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs23.existsSync(path22.join(cwd, "yarn.lock")) ? "yarn" : fs23.existsSync(path22.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs24.existsSync(path23.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs24.existsSync(path23.join(cwd, "yarn.lock")) ? "yarn" : fs24.existsSync(path23.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;
@@ -5771,8 +5930,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path22.join(cwd, appDir);
-    if (!fs23.existsSync(full)) continue;
+    const full = path23.join(cwd, appDir);
+    if (!fs24.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -5780,7 +5939,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs23.readdirSync(dir, { withFileTypes: true });
+    entries = fs24.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -5797,7 +5956,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     if (entry.name === "node_modules" || entry.name === ".next") continue;
     let segment = entry.name;
     if (segment.startsWith("(") && segment.endsWith(")")) {
-      walkFrontendRoutes(path22.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path23.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -5805,7 +5964,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path22.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path23.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -5822,23 +5981,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs23.existsSync(path22.join(cwd, c))) out.authFiles.push(c);
+    if (fs24.existsSync(path23.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 = path22.join(cwd, rp);
-    if (!fs23.existsSync(dir)) continue;
+    const dir = path23.join(cwd, rp);
+    if (!fs24.existsSync(dir)) continue;
     let files;
     try {
-      files = fs23.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs24.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs23.readFileSync(path22.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs24.readFileSync(path23.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) {
@@ -5984,7 +6143,7 @@ var discoverQaContext = async (ctx) => {
 };
 
 // src/scripts/dispatch.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 var API_TIMEOUT_MS4 = 3e4;
 var dispatch = async (ctx, _profile, _agentResult, args) => {
   const next = args?.next;
@@ -6020,7 +6179,7 @@ var dispatch = async (ctx, _profile, _agentResult, args) => {
   const sub = usePr ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync12("gh", [sub, "comment", String(targetNumber), "--body", body], {
+    execFileSync13("gh", [sub, "comment", String(targetNumber), "--body", body], {
       timeout: API_TIMEOUT_MS4,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -6040,7 +6199,7 @@ function parsePr(url) {
 }
 
 // src/scripts/dispatchClassified.ts
-import { execFileSync as execFileSync13 } from "child_process";
+import { execFileSync as execFileSync14 } from "child_process";
 var API_TIMEOUT_MS5 = 3e4;
 var VALID_CLASSES2 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
 var dispatchClassified = async (ctx) => {
@@ -6048,17 +6207,30 @@ var dispatchClassified = async (ctx) => {
   if (!issueNumber) return;
   const classification = ctx.data.classification;
   if (!classification || !VALID_CLASSES2.has(classification)) return;
+  const action = ctx.data.action;
+  if (!action) return;
   const baseArg = typeof ctx.args.base === "string" && ctx.args.base.length > 0 ? ` --base ${ctx.args.base}` : "";
-  const body = `@kody ${classification}${baseArg}`;
+  const dispatchLine = `@kody ${classification}${baseArg}`;
+  const auditLine = ctx.data.classificationAudit ?? `\u{1F50E} kody classified as \`${classification}\``;
+  const state = ctx.data.taskState ?? emptyState();
+  const nextState = reduce(state, "classify", action, void 0);
+  const stateBody = renderStateComment(nextState);
+  ctx.data.taskState = nextState;
+  ctx.data.taskStateRendered = stateBody;
+  const body = `${dispatchLine}
+
+${auditLine}
+
+${stateBody}`;
   try {
-    execFileSync13("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync14("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       cwd: ctx.cwd,
       timeout: API_TIMEOUT_MS5,
       stdio: ["ignore", "pipe", "pipe"]
     });
   } catch (err) {
     process.stderr.write(
-      `[kody dispatchClassified] failed to dispatch ${body}: ${err instanceof Error ? err.message : String(err)}
+      `[kody dispatchClassified] failed to dispatch ${dispatchLine}: ${err instanceof Error ? err.message : String(err)}
 `
     );
     ctx.data.action = failedAction3("dispatch post failed");
@@ -6071,8 +6243,8 @@ function failedAction3(reason) {
 }
 
 // src/scripts/dispatchJobFileTicks.ts
-import * as fs25 from "fs";
-import * as path24 from "path";
+import * as fs26 from "fs";
+import * as path25 from "path";
 
 // src/scripts/jobFrontmatter.ts
 var SCHEDULE_EVERY_VALUES = [
@@ -6333,8 +6505,8 @@ var ContentsApiBackend = class {
 };
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs24 from "fs";
-import * as path23 from "path";
+import * as fs25 from "fs";
+import * as path24 from "path";
 var LocalFileBackend = class {
   name = "local-file";
   cwd;
@@ -6349,7 +6521,7 @@ var LocalFileBackend = class {
     if (!opts.owner || !opts.repo) throw new Error("LocalFileBackend: owner and repo are required");
     this.cwd = opts.cwd;
     this.jobsDir = opts.jobsDir;
-    this.absDir = path23.join(opts.cwd, opts.jobsDir);
+    this.absDir = path24.join(opts.cwd, opts.jobsDir);
     this.owner = opts.owner;
     this.repo = opts.repo;
     this.cache = opts.cache ?? defaultCacheAdapter();
@@ -6364,7 +6536,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    fs24.mkdirSync(this.absDir, { recursive: true });
+    fs25.mkdirSync(this.absDir, { recursive: true });
     const prefix = this.cacheKeyPrefix();
     const probeKey = `${prefix}probe-${Date.now()}`;
     try {
@@ -6393,7 +6565,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    if (!fs24.existsSync(this.absDir)) {
+    if (!fs25.existsSync(this.absDir)) {
       return;
     }
     const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -6409,11 +6581,11 @@ var LocalFileBackend = class {
   }
   load(slug) {
     const relPath = stateFilePath(this.jobsDir, slug);
-    const absPath = path23.join(this.cwd, relPath);
-    if (!fs24.existsSync(absPath)) {
+    const absPath = path24.join(this.cwd, relPath);
+    if (!fs25.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
     }
-    const raw = fs24.readFileSync(absPath, "utf-8");
+    const raw = fs25.readFileSync(absPath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -6430,10 +6602,10 @@ var LocalFileBackend = class {
     if (!loaded.created && isStateUnchanged(loaded.state, next)) {
       return false;
     }
-    const absPath = path23.join(this.cwd, loaded.path);
-    fs24.mkdirSync(path23.dirname(absPath), { recursive: true });
+    const absPath = path24.join(this.cwd, loaded.path);
+    fs25.mkdirSync(path24.dirname(absPath), { recursive: true });
     const body = JSON.stringify(next, null, 2) + "\n";
-    fs24.writeFileSync(absPath, body, "utf-8");
+    fs25.writeFileSync(absPath, body, "utf-8");
     return true;
   }
   cacheKeyPrefix() {
@@ -6511,7 +6683,7 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
     await backend.hydrate();
   }
   try {
-    const slugs = listJobSlugs(path24.join(ctx.cwd, jobsDir));
+    const slugs = listJobSlugs(path25.join(ctx.cwd, jobsDir));
     ctx.data.jobSlugCount = slugs.length;
     if (slugs.length === 0) {
       process.stdout.write(`[jobs] no job files in ${jobsDir}
@@ -6624,17 +6796,17 @@ function formatAgo(ms) {
 }
 function readJobFrontmatter(cwd, jobsDir, slug) {
   try {
-    const raw = fs25.readFileSync(path24.join(cwd, jobsDir, `${slug}.md`), "utf-8");
+    const raw = fs26.readFileSync(path25.join(cwd, jobsDir, `${slug}.md`), "utf-8");
     return splitFrontmatter(raw).frontmatter;
   } catch {
     return {};
   }
 }
 function listJobSlugs(absDir) {
-  if (!fs25.existsSync(absDir)) return [];
+  if (!fs26.existsSync(absDir)) return [];
   let entries;
   try {
-    entries = fs25.readdirSync(absDir, { withFileTypes: true });
+    entries = fs26.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -7148,7 +7320,7 @@ var finalizeTerminal = async (ctx) => {
 
 // src/scripts/finishFlow.ts
 init_issue();
-import { execFileSync as execFileSync14 } from "child_process";
+import { execFileSync as execFileSync15 } from "child_process";
 var TERMINAL_PHASE = {
   "review-passed": { phase: "shipped", status: "succeeded" },
   "fix-applied": { phase: "shipped", status: "succeeded" },
@@ -7188,7 +7360,7 @@ var finishFlow = async (ctx, profile, _agentResult, args) => {
 **PR:** ${state.core.prUrl}` : "";
   const body = `${icon} kody flow \`${flowName}\` finished \u2014 \`${reason}\`${prSuffix}`;
   try {
-    execFileSync14("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync15("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       timeout: API_TIMEOUT_MS6,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -7218,9 +7390,9 @@ var finishFlow = async (ctx, profile, _agentResult, args) => {
 };
 
 // src/branch.ts
-import { execFileSync as execFileSync15 } from "child_process";
+import { execFileSync as execFileSync16 } from "child_process";
 function git2(args, cwd) {
-  return execFileSync15("git", args, {
+  return execFileSync16("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -7237,11 +7409,11 @@ function getCurrentBranch(cwd) {
 }
 function resetWorkingTree(cwd) {
   try {
-    execFileSync15("git", ["reset", "--hard", "HEAD"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+    execFileSync16("git", ["reset", "--hard", "HEAD"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
   } catch {
   }
   try {
-    execFileSync15("git", ["clean", "-fd"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+    execFileSync16("git", ["clean", "-fd"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
   } catch {
   }
 }
@@ -7253,14 +7425,14 @@ function checkoutPrBranch(prNumber, cwd) {
     GH_TOKEN: process.env.GH_PAT?.trim() || process.env.GH_TOKEN || ""
   };
   try {
-    execFileSync15("git", ["reset", "--hard", "HEAD"], { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+    execFileSync16("git", ["reset", "--hard", "HEAD"], { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
   } catch {
   }
   try {
-    execFileSync15("git", ["clean", "-fd"], { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+    execFileSync16("git", ["clean", "-fd"], { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
   } catch {
   }
-  execFileSync15("gh", ["pr", "checkout", String(prNumber)], {
+  execFileSync16("gh", ["pr", "checkout", String(prNumber)], {
     cwd,
     env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -7386,8 +7558,8 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch2, cwd, baseBranch
 }
 
 // src/gha.ts
-import { execFileSync as execFileSync16 } from "child_process";
-import * as fs26 from "fs";
+import { execFileSync as execFileSync17 } from "child_process";
+import * as fs27 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -7398,10 +7570,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs26.existsSync(eventPath)) return;
+  if (!eventPath || !fs27.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs26.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs27.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -7429,7 +7601,7 @@ function reactToTriggerComment(cwd) {
   for (let attempt = 0; attempt < 3; attempt++) {
     if (attempt > 0) sleepMs(attempt === 1 ? 500 : 1500);
     try {
-      execFileSync16("gh", args, opts);
+      execFileSync17("gh", args, opts);
       return;
     } catch (err) {
       lastErr = err;
@@ -7442,7 +7614,7 @@ function reactToTriggerComment(cwd) {
 }
 function sleepMs(ms) {
   try {
-    execFileSync16("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
+    execFileSync17("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
   } catch {
   }
 }
@@ -7451,7 +7623,7 @@ function sleepMs(ms) {
 init_issue();
 
 // src/workflow.ts
-import { execFileSync as execFileSync17 } from "child_process";
+import { execFileSync as execFileSync18 } from "child_process";
 var GH_TIMEOUT_MS = 3e4;
 function ghToken3() {
   return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
@@ -7459,7 +7631,7 @@ function ghToken3() {
 function gh3(args, cwd) {
   const token = ghToken3();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync17("gh", args, {
+  return execFileSync18("gh", args, {
     encoding: "utf-8",
     timeout: GH_TIMEOUT_MS,
     cwd,
@@ -7693,23 +7865,23 @@ var handleAbandonedGoal = async (ctx) => {
 };
 
 // src/scripts/initFlow.ts
-import { execFileSync as execFileSync18 } from "child_process";
-import * as fs28 from "fs";
-import * as path26 from "path";
+import { execFileSync as execFileSync19 } from "child_process";
+import * as fs29 from "fs";
+import * as path27 from "path";
 
 // src/scripts/loadQaGuide.ts
-import * as fs27 from "fs";
-import * as path25 from "path";
+import * as fs28 from "fs";
+import * as path26 from "path";
 var QA_GUIDE_REL_PATH = ".kody/qa-guide.md";
 var loadQaGuide = async (ctx) => {
-  const full = path25.join(ctx.cwd, QA_GUIDE_REL_PATH);
-  if (!fs27.existsSync(full)) {
+  const full = path26.join(ctx.cwd, QA_GUIDE_REL_PATH);
+  if (!fs28.existsSync(full)) {
     ctx.data.qaGuide = "";
     ctx.data.qaGuidePath = "";
     return;
   }
   try {
-    ctx.data.qaGuide = fs27.readFileSync(full, "utf-8");
+    ctx.data.qaGuide = fs28.readFileSync(full, "utf-8");
     ctx.data.qaGuidePath = QA_GUIDE_REL_PATH;
   } catch {
     ctx.data.qaGuide = "";
@@ -7719,9 +7891,9 @@ var loadQaGuide = async (ctx) => {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  if (fs28.existsSync(path26.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs28.existsSync(path26.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs28.existsSync(path26.join(cwd, "bun.lockb"))) return "bun";
+  if (fs29.existsSync(path27.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs29.existsSync(path27.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs29.existsSync(path27.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -7734,7 +7906,7 @@ function qualityCommandsFor(pm) {
 function detectOwnerRepo(cwd) {
   let url;
   try {
-    url = execFileSync18("git", ["remote", "get-url", "origin"], {
+    url = execFileSync19("git", ["remote", "get-url", "origin"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -7819,7 +7991,7 @@ jobs:
 `;
 function defaultBranchFromGit(cwd) {
   try {
-    const ref = execFileSync18("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync19("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -7827,7 +7999,7 @@ function defaultBranchFromGit(cwd) {
     return ref.replace("refs/remotes/origin/", "");
   } catch {
     try {
-      return execFileSync18("git", ["branch", "--show-current"], {
+      return execFileSync19("git", ["branch", "--show-current"], {
         cwd,
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "pipe"]
@@ -7843,48 +8015,48 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch2 = defaultBranchFromGit(cwd);
-  const configPath = path26.join(cwd, "kody.config.json");
-  if (fs28.existsSync(configPath) && !force) {
+  const configPath = path27.join(cwd, "kody.config.json");
+  if (fs29.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch2);
-    fs28.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs29.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path26.join(cwd, ".github", "workflows");
-  const workflowPath = path26.join(workflowDir, "kody.yml");
-  if (fs28.existsSync(workflowPath) && !force) {
+  const workflowDir = path27.join(cwd, ".github", "workflows");
+  const workflowPath = path27.join(workflowDir, "kody.yml");
+  if (fs29.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs28.mkdirSync(workflowDir, { recursive: true });
-    fs28.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs29.mkdirSync(workflowDir, { recursive: true });
+    fs29.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
-  const hasUi = fs28.existsSync(path26.join(cwd, "src/app")) || fs28.existsSync(path26.join(cwd, "app")) || fs28.existsSync(path26.join(cwd, "pages"));
+  const hasUi = fs29.existsSync(path27.join(cwd, "src/app")) || fs29.existsSync(path27.join(cwd, "app")) || fs29.existsSync(path27.join(cwd, "pages"));
   if (hasUi) {
-    const qaGuidePath = path26.join(cwd, QA_GUIDE_REL_PATH);
-    if (fs28.existsSync(qaGuidePath) && !force) {
+    const qaGuidePath = path27.join(cwd, QA_GUIDE_REL_PATH);
+    if (fs29.existsSync(qaGuidePath) && !force) {
       skipped.push(QA_GUIDE_REL_PATH);
     } else {
-      fs28.mkdirSync(path26.dirname(qaGuidePath), { recursive: true });
+      fs29.mkdirSync(path27.dirname(qaGuidePath), { recursive: true });
       const discovery = runQaDiscovery(cwd);
-      fs28.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
+      fs29.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
       wrote.push(QA_GUIDE_REL_PATH);
     }
   }
   const builtinJobs = listBuiltinJobs();
   if (builtinJobs.length > 0) {
-    const jobsDir = path26.join(cwd, ".kody", "jobs");
-    fs28.mkdirSync(jobsDir, { recursive: true });
+    const jobsDir = path27.join(cwd, ".kody", "jobs");
+    fs29.mkdirSync(jobsDir, { recursive: true });
     for (const job of builtinJobs) {
-      const rel = path26.join(".kody", "jobs", `${job.slug}.md`);
-      const target = path26.join(cwd, rel);
-      if (fs28.existsSync(target) && !force) {
+      const rel = path27.join(".kody", "jobs", `${job.slug}.md`);
+      const target = path27.join(cwd, rel);
+      if (fs29.existsSync(target) && !force) {
         skipped.push(rel);
         continue;
       }
-      fs28.writeFileSync(target, fs28.readFileSync(job.filePath, "utf-8"));
+      fs29.writeFileSync(target, fs29.readFileSync(job.filePath, "utf-8"));
       wrote.push(rel);
     }
   }
@@ -7896,12 +8068,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path26.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs28.existsSync(target) && !force) {
+    const target = path27.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs29.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs28.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs29.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -7979,14 +8151,14 @@ init_loadConventions();
 init_loadCoverageRules();
 
 // src/goal/state.ts
-import * as fs29 from "fs";
-import * as path27 from "path";
+import * as fs30 from "fs";
+import * as path28 from "path";
 var VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "awaiting-merge", "done"]);
 var GoalStateError = class extends Error {
-  constructor(path36, message) {
-    super(`Invalid goal state at ${path36}:
+  constructor(path37, message) {
+    super(`Invalid goal state at ${path37}:
   ${message}`);
-    this.path = path36;
+    this.path = path37;
     this.name = "GoalStateError";
   }
   path;
@@ -8034,16 +8206,16 @@ function serializeGoalState(s) {
 `;
 }
 function goalStatePath(cwd, goalId) {
-  return path27.join(cwd, ".kody", "goals", goalId, "state.json");
+  return path28.join(cwd, ".kody", "goals", goalId, "state.json");
 }
 function readGoalState(cwd, goalId) {
   const file = goalStatePath(cwd, goalId);
-  if (!fs29.existsSync(file)) {
+  if (!fs30.existsSync(file)) {
     throw new GoalStateError(file, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs29.readFileSync(file, "utf-8"));
+    raw = JSON.parse(fs30.readFileSync(file, "utf-8"));
   } catch (err) {
     throw new GoalStateError(file, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -8051,8 +8223,8 @@ function readGoalState(cwd, goalId) {
 }
 function writeGoalState(cwd, goalId, state) {
   const file = goalStatePath(cwd, goalId);
-  fs29.mkdirSync(path27.dirname(file), { recursive: true });
-  fs29.writeFileSync(file, serializeGoalState(state), "utf-8");
+  fs30.mkdirSync(path28.dirname(file), { recursive: true });
+  fs30.writeFileSync(file, serializeGoalState(state), "utf-8");
 }
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -8149,8 +8321,8 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 
 // src/scripts/loadJobFromFile.ts
-import * as fs30 from "fs";
-import * as path28 from "path";
+import * as fs31 from "fs";
+import * as path29 from "path";
 var loadJobFromFile = async (ctx, _profile, args) => {
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
   const workersDir = String(args?.workersDir ?? ".kody/workers");
@@ -8159,23 +8331,23 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   if (!slug) {
     throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const absPath = path28.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs30.existsSync(absPath)) {
+  const absPath = path29.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs31.existsSync(absPath)) {
     throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
   }
-  const raw = fs30.readFileSync(absPath, "utf-8");
+  const raw = fs31.readFileSync(absPath, "utf-8");
   const { title, body } = parseJobFile(raw, slug);
   const workerSlug = (splitFrontmatter(raw).frontmatter.worker ?? "").trim();
   let workerTitle = "";
   let workerPersona = "";
   if (workerSlug) {
-    const workerPath = path28.join(ctx.cwd, workersDir, `${workerSlug}.md`);
-    if (!fs30.existsSync(workerPath)) {
+    const workerPath = path29.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+    if (!fs31.existsSync(workerPath)) {
       throw new Error(
         `loadJobFromFile: job '${slug}' declares worker '${workerSlug}' but ${workerPath} does not exist`
       );
     }
-    const workerRaw = fs30.readFileSync(workerPath, "utf-8");
+    const workerRaw = fs31.readFileSync(workerPath, "utf-8");
     const parsed = parseJobFile(workerRaw, workerSlug);
     workerTitle = parsed.title;
     workerPersona = parsed.body;
@@ -8213,19 +8385,19 @@ function humanizeSlug(slug) {
 }
 
 // src/scripts/loadWorkerAdhoc.ts
-import * as fs31 from "fs";
-import * as path29 from "path";
+import * as fs32 from "fs";
+import * as path30 from "path";
 var loadWorkerAdhoc = async (ctx, _profile, args) => {
   const workersDir = String(args?.workersDir ?? ".kody/workers");
   const workerSlug = String(ctx.args.worker ?? "").trim();
   if (!workerSlug) {
     throw new Error("loadWorkerAdhoc: ctx.args.worker must be a non-empty slug");
   }
-  const workerPath = path29.join(ctx.cwd, workersDir, `${workerSlug}.md`);
-  if (!fs31.existsSync(workerPath)) {
+  const workerPath = path30.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+  if (!fs32.existsSync(workerPath)) {
     throw new Error(`loadWorkerAdhoc: worker persona not found: ${workerPath}`);
   }
-  const { title, body } = parsePersona(fs31.readFileSync(workerPath, "utf-8"), workerSlug);
+  const { title, body } = parsePersona(fs32.readFileSync(workerPath, "utf-8"), workerSlug);
   const message = resolveMessage(ctx.args.message);
   if (!message) {
     throw new Error(
@@ -8245,9 +8417,9 @@ function resolveMessage(messageArg) {
 }
 function readCommentBody() {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs31.existsSync(eventPath)) return "";
+  if (!eventPath || !fs32.existsSync(eventPath)) return "";
   try {
-    const event = JSON.parse(fs31.readFileSync(eventPath, "utf-8"));
+    const event = JSON.parse(fs32.readFileSync(eventPath, "utf-8"));
     return String(event.comment?.body ?? "");
   } catch {
     return "";
@@ -8293,8 +8465,8 @@ init_loadPriorArt();
 init_events();
 
 // src/taskContext.ts
-import * as fs33 from "fs";
-import * as path31 from "path";
+import * as fs34 from "fs";
+import * as path32 from "path";
 var TASK_CONTEXT_SCHEMA_VERSION = 1;
 function buildTaskContext(args) {
   return {
@@ -8310,10 +8482,10 @@ function buildTaskContext(args) {
 }
 function persistTaskContext(cwd, ctx) {
   try {
-    const dir = path31.join(cwd, ".kody", "runs", ctx.runId);
-    fs33.mkdirSync(dir, { recursive: true });
-    const file = path31.join(dir, "task-context.json");
-    fs33.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    const dir = path32.join(cwd, ".kody", "runs", ctx.runId);
+    fs34.mkdirSync(dir, { recursive: true });
+    const file = path32.join(dir, "task-context.json");
+    fs34.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -8369,7 +8541,7 @@ var markFlowSuccess = async (ctx) => {
 };
 
 // src/scripts/mergeReleasePr.ts
-import { execFileSync as execFileSync19 } from "child_process";
+import { execFileSync as execFileSync20 } from "child_process";
 var API_TIMEOUT_MS7 = 6e4;
 var mergeReleasePr = async (ctx) => {
   const state = ctx.data.taskState;
@@ -8388,7 +8560,7 @@ var mergeReleasePr = async (ctx) => {
   process.stderr.write(`[kody mergeReleasePr] merging PR #${prNumber} (${prUrl})
 `);
   try {
-    const out = execFileSync19("gh", ["pr", "merge", String(prNumber), "--merge"], {
+    const out = execFileSync20("gh", ["pr", "merge", String(prNumber), "--merge"], {
       timeout: API_TIMEOUT_MS7,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -9023,7 +9195,7 @@ ${body}`;
 }
 
 // src/scripts/recordClassification.ts
-import { execFileSync as execFileSync20 } from "child_process";
+import { execFileSync as execFileSync21 } from "child_process";
 var API_TIMEOUT_MS8 = 3e4;
 var VALID_CLASSES3 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
 var recordClassification = async (ctx) => {
@@ -9051,7 +9223,6 @@ var recordClassification = async (ctx) => {
     ctx.output.reason = "classify: no decision";
     return;
   }
-  tryAuditComment(issueNumber, `\u{1F50E} kody classified as \`${classification}\`${reason ? ` \u2014 ${reason}` : ""}`, ctx.cwd);
   ctx.data.action = makeAction3(`CLASSIFIED_AS_${classification.toUpperCase()}`, {
     classification,
     reason: reason ?? "",
@@ -9059,6 +9230,7 @@ var recordClassification = async (ctx) => {
   });
   ctx.data.classification = classification;
   ctx.data.classificationReason = reason ?? "";
+  ctx.data.classificationAudit = `\u{1F50E} kody classified as \`${classification}\`${reason ? ` \u2014 ${reason}` : ""}`;
 };
 function parseClassification(prSummary) {
   if (!prSummary) return null;
@@ -9071,7 +9243,7 @@ function parseClassification(prSummary) {
 }
 function tryAuditComment(issueNumber, body, cwd) {
   try {
-    execFileSync20("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync21("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       cwd,
       timeout: API_TIMEOUT_MS8,
       stdio: ["ignore", "pipe", "pipe"]
@@ -9185,7 +9357,7 @@ var resolveArtifacts = async (ctx, profile) => {
 };
 
 // src/scripts/resolveFlow.ts
-import { execFileSync as execFileSync21 } from "child_process";
+import { execFileSync as execFileSync22 } from "child_process";
 init_issue();
 var CONFLICT_DIFF_MAX_BYTES = 4e4;
 var resolveFlow = async (ctx) => {
@@ -9279,7 +9451,7 @@ function buildPreferBlock(prefer, baseBranch) {
 }
 function getConflictedFiles(cwd) {
   try {
-    const out = execFileSync21("git", ["diff", "--name-only", "--diff-filter=U"], {
+    const out = execFileSync22("git", ["diff", "--name-only", "--diff-filter=U"], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0" }
@@ -9294,7 +9466,7 @@ function getConflictMarkersPreview(files, cwd, maxBytes = CONFLICT_DIFF_MAX_BYTE
   let total = 0;
   for (const f of files) {
     try {
-      const content = execFileSync21("cat", [f], { encoding: "utf-8", cwd }).toString();
+      const content = execFileSync22("cat", [f], { encoding: "utf-8", cwd }).toString();
       const snippet = `### ${f}
 
 \`\`\`
@@ -9318,12 +9490,12 @@ function tryPostPr3(prNumber, body, cwd) {
 function pushEmptyCommit(branch, cwd) {
   const env = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
   try {
-    execFileSync21(
+    execFileSync22(
       "git",
       ["commit", "--allow-empty", "-m", "chore: kody resolve refresh \u2014 empty commit to recompute mergeable status"],
       { cwd, env, stdio: ["ignore", "pipe", "pipe"] }
     );
-    execFileSync21("git", ["push", "-u", "origin", branch], {
+    execFileSync22("git", ["push", "-u", "origin", branch], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -9414,10 +9586,10 @@ var resolvePreviewUrl = async (ctx) => {
 };
 
 // src/scripts/resolveQaUrl.ts
-import { execFileSync as execFileSync22 } from "child_process";
+import { execFileSync as execFileSync23 } from "child_process";
 function ghQuery(args, cwd) {
   try {
-    const out = execFileSync22("gh", args, {
+    const out = execFileSync23("gh", args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8",
@@ -9487,7 +9659,7 @@ var resolveQaUrl = async (ctx) => {
 };
 
 // src/scripts/revertFlow.ts
-import { execFileSync as execFileSync23 } from "child_process";
+import { execFileSync as execFileSync24 } from "child_process";
 init_issue();
 var SHA_RE = /^[0-9a-f]{4,40}$/i;
 var revertFlow = async (ctx) => {
@@ -9570,7 +9742,7 @@ function buildPrSummary(resolved) {
   return resolved.map((r) => `- Reverted \`${r.full.slice(0, 7)}\`${r.subject ? ` \u2014 ${r.subject}` : ""}`).join("\n");
 }
 function git3(args, cwd) {
-  return execFileSync23("git", args, {
+  return execFileSync24("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -9580,7 +9752,7 @@ function git3(args, cwd) {
 }
 function isAncestorOfHead(sha, cwd) {
   try {
-    execFileSync23("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
+    execFileSync24("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
       cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: ["ignore", "ignore", "ignore"]
@@ -9676,8 +9848,8 @@ function resolveBaseOverride(value) {
 
 // src/scripts/runTickScript.ts
 import { spawnSync } from "child_process";
-import * as fs34 from "fs";
-import * as path32 from "path";
+import * as fs35 from "fs";
+import * as path33 from "path";
 var runTickScript = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
@@ -9689,13 +9861,13 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
     return;
   }
-  const jobPath = path32.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs34.existsSync(jobPath)) {
+  const jobPath = path33.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs35.existsSync(jobPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
     return;
   }
-  const raw = fs34.readFileSync(jobPath, "utf-8");
+  const raw = fs35.readFileSync(jobPath, "utf-8");
   const { frontmatter } = splitFrontmatter(raw);
   const tickScript = frontmatter.tickScript;
   if (!tickScript) {
@@ -9703,8 +9875,8 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: job ${slug} has no \`tickScript:\` frontmatter \u2014 route via job-tick instead`;
     return;
   }
-  const scriptPath = path32.isAbsolute(tickScript) ? tickScript : path32.join(ctx.cwd, tickScript);
-  if (!fs34.existsSync(scriptPath)) {
+  const scriptPath = path33.isAbsolute(tickScript) ? tickScript : path33.join(ctx.cwd, tickScript);
+  if (!fs35.existsSync(scriptPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
     return;
@@ -9999,11 +10171,11 @@ var skipAgent = async (ctx) => {
 };
 
 // src/scripts/stageMergeConflicts.ts
-import { execFileSync as execFileSync24 } from "child_process";
+import { execFileSync as execFileSync25 } from "child_process";
 var stageMergeConflicts = async (ctx) => {
   if (ctx.data.agentDone === false) return;
   try {
-    execFileSync24("git", ["add", "-A"], {
+    execFileSync25("git", ["add", "-A"], {
       cwd: ctx.cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: "pipe"
@@ -10014,7 +10186,7 @@ var stageMergeConflicts = async (ctx) => {
 
 // src/scripts/startFlow.ts
 init_issue();
-import { execFileSync as execFileSync25 } from "child_process";
+import { execFileSync as execFileSync26 } from "child_process";
 var API_TIMEOUT_MS9 = 3e4;
 var startFlow = async (ctx, profile, _agentResult, args) => {
   const entry = args?.entry;
@@ -10048,7 +10220,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
   const sub = target === "pr" && state?.core.prUrl ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync25("gh", [sub, "comment", String(targetNumber), "--body", body], {
+    execFileSync26("gh", [sub, "comment", String(targetNumber), "--body", body], {
       timeout: API_TIMEOUT_MS9,
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -10062,7 +10234,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
 }
 
 // src/scripts/syncFlow.ts
-import { execFileSync as execFileSync26 } from "child_process";
+import { execFileSync as execFileSync27 } from "child_process";
 init_issue();
 var syncFlow = async (ctx, _profile, args) => {
   const announceOnSuccess = Boolean(args?.announceOnSuccess);
@@ -10127,21 +10299,15 @@ function bail2(ctx, prNumber, reason) {
 }
 function revParseHead(cwd) {
   try {
-    return execFileSync26("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+    return execFileSync27("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
   } catch {
     return "";
   }
 }
 function pushBranch(branch, cwd) {
-  const env = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
-  try {
-    execFileSync26("git", ["push", "-u", "origin", branch], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
-  } catch {
-    execFileSync26("git", ["push", "--force-with-lease", "-u", "origin", branch], {
-      cwd,
-      env,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
+  const result = pushWithRetry({ cwd: cwd ?? process.cwd(), branch, setUpstream: true });
+  if (!result.ok) {
+    throw new Error(result.reason);
   }
 }
 function tryPostPr6(prNumber, body, cwd) {
@@ -10390,7 +10556,7 @@ var verifyWithRetry = async (ctx) => {
 
 // src/scripts/waitForCi.ts
 init_issue();
-import { execFileSync as execFileSync27 } from "child_process";
+import { execFileSync as execFileSync28 } from "child_process";
 var API_TIMEOUT_MS10 = 3e4;
 var waitForCi = async (ctx, _profile, _agentResult, args) => {
   const timeoutMinutes = numArg(args, "timeoutMinutes", 30);
@@ -10468,7 +10634,7 @@ var waitForCi = async (ctx, _profile, _agentResult, args) => {
 };
 function fetchChecks(prNumber, cwd) {
   try {
-    const raw = execFileSync27("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
+    const raw = execFileSync28("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
       encoding: "utf-8",
       timeout: API_TIMEOUT_MS10,
       cwd,
@@ -10726,7 +10892,7 @@ var writeJobStateFile = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -10748,7 +10914,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs35.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs36.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -10847,7 +11013,7 @@ var allScriptNames = /* @__PURE__ */ new Set([
 ]);
 
 // src/tools.ts
-import { execFileSync as execFileSync28 } from "child_process";
+import { execFileSync as execFileSync29 } from "child_process";
 function verifyCliTools(tools, cwd) {
   const out = [];
   for (const t of tools) out.push(verifyOne(t, cwd));
@@ -10880,7 +11046,7 @@ function verifyOne(tool2, cwd) {
 }
 function runShell(cmd, cwd, timeoutMs = 3e4) {
   try {
-    execFileSync28("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
+    execFileSync29("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
     return true;
   } catch {
     return false;
@@ -10974,9 +11140,23 @@ async function runExecutable(profileName, input) {
     data: { ...input.preloadedData ?? {} },
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path33.join(input.cwd, ".kody");
+  const taskTarget = args.issue ?? args.pr;
+  const taskArtifacts = typeof taskTarget === "number" && Number.isFinite(taskTarget) ? (() => {
+    const taskType = args.issue ? "issue" : "pr";
+    const paths = prepareTaskArtifactsDir(input.cwd, taskTarget);
+    return {
+      ...paths,
+      taskType,
+      promptAddendum: taskArtifactsPromptAddendum({
+        taskId: paths.taskId,
+        taskType,
+        relDir: paths.relDir
+      })
+    };
+  })() : null;
+  const ndjsonDir = path34.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path33.isAbsolute(p) ? p : path33.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path34.isAbsolute(p) ? p : path34.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -10994,7 +11174,7 @@ async function runExecutable(profileName, input) {
       maxTurns: profile.claudeCode.maxTurns,
       maxThinkingTokens: profile.claudeCode.maxThinkingTokens,
       maxTurnTimeoutMs: typeof profile.claudeCode.maxTurnTimeoutSec === "number" ? Math.floor(profile.claudeCode.maxTurnTimeoutSec * 1e3) : void 0,
-      systemPromptAppend: profile.claudeCode.systemPromptAppend,
+      systemPromptAppend: [profile.claudeCode.systemPromptAppend, taskArtifacts?.promptAddendum].filter((s) => typeof s === "string" && s.length > 0).join("\n\n") || void 0,
       cacheable: profile.claudeCode.cacheable,
       enableVerifyTool: profile.claudeCode.enableVerifyTool,
       verifyToolMaxAttempts: profile.claudeCode.verifyAttempts ?? null,
@@ -11149,6 +11329,18 @@ async function runExecutable(profileName, input) {
     });
   } finally {
     clearStampedLifecycleLabels(profile, ctx);
+    if (taskArtifacts) {
+      try {
+        const missing2 = verifyTaskArtifacts(taskArtifacts.absDir);
+        if (missing2.length > 0) {
+          process.stderr.write(
+            `[task-artifacts] task ${taskArtifacts.taskId} missing: ${missing2.join(", ")}
+`
+          );
+        }
+      } catch {
+      }
+    }
     try {
       litellm?.kill();
     } catch {
@@ -11171,7 +11363,7 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs36.existsSync(profilePath)) return null;
+    if (!fs37.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -11180,17 +11372,17 @@ function getProfileInputsForChild(profileName, _cwd) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path33.dirname(new URL(import.meta.url).pathname);
+  const here = path34.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path33.join(here, "executables", profileName, "profile.json"),
+    path34.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path33.join(here, "..", "executables", profileName, "profile.json"),
+    path34.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path33.join(here, "..", "src", "executables", profileName, "profile.json")
+    path34.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs36.existsSync(c)) return c;
+    if (fs37.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -11290,8 +11482,8 @@ function resolveShellTimeoutMs(entry) {
 var SIGKILL_GRACE_MS = 5e3;
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path33.join(profile.dir, shellName);
-  if (!fs36.existsSync(shellPath)) {
+  const shellPath = path34.join(profile.dir, shellName);
+  if (!fs37.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -11618,7 +11810,7 @@ async function runContainerLoop(profile, ctx, input) {
 }
 function resetWorkingTree2(cwd) {
   try {
-    execFileSync29("git", ["reset", "--hard", "HEAD"], {
+    execFileSync30("git", ["reset", "--hard", "HEAD"], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 3e4
@@ -11770,14 +11962,14 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs37.existsSync(path34.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs37.existsSync(path34.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs37.existsSync(path34.join(cwd, "bun.lockb"))) return "bun";
+  if (fs38.existsSync(path35.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs38.existsSync(path35.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs38.existsSync(path35.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
   try {
-    execFileSync30(cmd, args, {
+    execFileSync31(cmd, args, {
       cwd,
       stdio: stream ? "inherit" : "pipe",
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" }
@@ -11790,7 +11982,7 @@ function shellOut(cmd, args, cwd, stream = true) {
 }
 function isOnPath(bin) {
   try {
-    execFileSync30("which", [bin], { stdio: "pipe" });
+    execFileSync31("which", [bin], { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -11831,7 +12023,7 @@ function installLitellmIfNeeded(cwd) {
   } catch {
   }
   try {
-    execFileSync30("python3", ["-c", "import litellm"], { stdio: "pipe" });
+    execFileSync31("python3", ["-c", "import litellm"], { stdio: "pipe" });
     process.stdout.write("\u2192 kody: litellm already installed\n");
     return 0;
   } catch {
@@ -11841,16 +12033,16 @@ function installLitellmIfNeeded(cwd) {
 }
 function configureGitIdentity(cwd) {
   try {
-    const name = execFileSync30("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    const name = execFileSync31("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
     if (name) return;
   } catch {
   }
   try {
-    execFileSync30("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
+    execFileSync31("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
   } catch {
   }
   try {
-    execFileSync30("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
+    execFileSync31("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
       cwd,
       stdio: "pipe"
     });
@@ -11859,11 +12051,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path34.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path35.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs37.existsSync(logPath)) {
-      const content = fs37.readFileSync(logPath, "utf-8");
+    if (fs38.existsSync(logPath)) {
+      const content = fs38.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -11888,7 +12080,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path34.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path35.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -11898,9 +12090,9 @@ async function runCi(argv) {
   const eventName = process.env.GITHUB_EVENT_NAME;
   const dispatchEventPath = process.env.GITHUB_EVENT_PATH;
   let manualWorkflowDispatch = false;
-  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs37.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs38.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs37.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs38.readFileSync(dispatchEventPath, "utf-8"));
       const issueInput = parseInt(String(evt?.inputs?.issue_number ?? ""), 10);
       const sessionInput = String(evt?.inputs?.sessionId ?? "");
       manualWorkflowDispatch = !sessionInput && !(Number.isFinite(issueInput) && issueInput > 0);
@@ -12159,19 +12351,28 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path35.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path35.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionFile, eventsFile].filter((p) => fs38.existsSync(path35.join(cwd, p)));
+  const sessionFile = path36.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path36.relative(cwd, eventsFilePath(cwd, sessionId));
+  const safeSession = sessionId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const tasksDir = path36.join(".kody", "tasks", safeSession);
+  const candidatePaths = [sessionFile, eventsFile, tasksDir];
+  const paths = candidatePaths.filter((p) => fs39.existsSync(path36.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
-    execFileSync31("git", ["add", "-f", ...paths], opts);
-    execFileSync31("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
-    execFileSync31("git", ["push", "--quiet", "origin", "HEAD"], opts);
+    execFileSync32("git", ["add", "-f", ...paths], opts);
+    execFileSync32("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[kody:chat] commit/push skipped: ${msg}
+    process.stderr.write(`[kody:chat] commit skipped: ${msg}
 `);
+    return;
+  }
+  const result = pushWithRetry({ cwd });
+  if (!result.ok) {
+    process.stderr.write(`[kody:chat] push FAILED after ${result.attempts} attempt(s): ${result.reason}
+`);
+    throw new Error(`chat push failed: ${result.reason}`);
   }
 }
 function tryLoadConfig(cwd) {
@@ -12199,7 +12400,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path35.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path36.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -12251,7 +12452,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs38.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs39.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {