npm - @kody-ade/kody-engine - Versions diffs - 0.4.97 → 0.4.99 - Mend

@kody-ade/kody-engine 0.4.97 → 0.4.99

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/bin/kody.js +510 -369
package/dist/executables/classify/profile.json +0 -1
package/dist/executables/goal-scheduler/scheduler.sh +0 -0
package/dist/executables/release-deploy/deploy.sh +0 -0
package/dist/executables/release-prepare/prepare.sh +0 -0
package/dist/executables/release-publish/publish.sh +0 -0
package/dist/executables/resolve/apply-prefer.sh +0 -0
package/dist/executables/revert/revert.sh +0 -0
package/package.json +19 -20
package/templates/kody.yml +1 -1

package/dist/bin/kody.js CHANGED Viewed

@@ -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.99",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -932,8 +932,8 @@ 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 * 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);
   }
 }
@@ -2255,11 +2357,11 @@ 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 * 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;
     }
@@ -2578,16 +2680,16 @@ 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 * 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)=(.*)$/);
@@ -3322,8 +3424,8 @@ function stripBlockingEnv(env) {
 // src/commit.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import * as fs13 from "fs";
-import * as path11 from "path";
+import * as fs14 from "fs";
+import * as path12 from "path";
 var FORBIDDEN_PATH_PREFIXES = [
   ".kody/",
   ".kody-engine/",
@@ -3383,18 +3485,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 {
@@ -3450,7 +3552,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: "" };
   }
@@ -3766,20 +3868,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 +3891,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 +3919,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 +3962,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 +4179,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 +4319,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 +4343,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,17 +4399,17 @@ 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);
   }
 }
@@ -4448,13 +4550,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 +4566,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 +4621,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(
           {
@@ -4541,11 +4643,11 @@ var commitAndPush2 = async (ctx, profile) => {
 // src/scripts/commitGoalState.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import * as path17 from "path";
+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" });
   } catch (err) {
@@ -4590,20 +4692,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 +4713,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, ""),
@@ -4690,8 +4792,8 @@ 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 * as fs21 from "fs";
+import * as path20 from "path";
 // src/scripts/postReviewResult.ts
 init_issue();
@@ -4944,8 +5046,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,8 +5055,8 @@ 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;
 }
@@ -5463,15 +5565,15 @@ function filterGoalTaskPrs(prs, taskIssueNumbers) {
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync11 } from "child_process";
-import * as fs21 from "fs";
+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"));
@@ -5497,17 +5599,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 +5646,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 +5659,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 +5684,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 +5698,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 +5727,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 +5746,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 +5756,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 +5771,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 +5782,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 +5790,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 +5810,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 +5861,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 +5873,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 +5882,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 +5899,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 +5907,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 +5924,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) {
@@ -6048,8 +6150,21 @@ 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], {
       cwd: ctx.cwd,
@@ -6058,7 +6173,7 @@ var dispatchClassified = async (ctx) => {
     });
   } 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 +6186,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 +6448,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 +6464,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 +6479,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 +6508,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 +6524,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 +6545,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 +6626,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 +6739,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 [];
   }
@@ -7387,7 +7502,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch2, cwd, baseBranch
 // src/gha.ts
 import { execFileSync as execFileSync16 } from "child_process";
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -7398,10 +7513,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;
   }
@@ -7694,22 +7809,22 @@ 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 * 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 +7834,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) {
@@ -7843,48 +7958,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 +8011,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 +8094,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 +8149,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 +8166,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 +8264,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 +8274,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 +8328,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 +8360,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 +8408,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 +8425,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) {
@@ -9051,7 +9166,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 +9173,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;
@@ -9676,8 +9791,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 +9804,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 +9818,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;
@@ -10726,7 +10841,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 +10863,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 {
   }
@@ -10974,9 +11089,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 +11123,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 +11278,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 +11312,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 +11321,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 +11431,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})`;
@@ -11770,9 +11911,9 @@ 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) {
@@ -11859,11 +12000,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 +12029,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 +12039,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,9 +12300,9 @@ 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 paths = [sessionFile, eventsFile].filter((p) => fs39.existsSync(path36.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
@@ -12199,7 +12340,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 +12392,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 {