@kody-ade/kody-engine 0.2.22 → 0.2.27

package/dist/bin/kody2.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.2.22",
+  version: "0.2.27",
   description: "kody2 \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -49,18 +49,82 @@ var package_default = {
   bugs: "https://github.com/aharonyaircohen/kody-engine/issues"
 };
 
-// src/executor.ts
-import * as fs14 from "fs";
-import * as path12 from "path";
+// src/chat-cli.ts
+import { execFileSync as execFileSync16 } from "child_process";
+import * as fs19 from "fs";
+import * as path16 from "path";
+
+// src/chat/events.ts
+import * as fs from "fs";
+import * as path from "path";
+function eventsFilePath(cwd, sessionId) {
+  return path.join(cwd, ".kody", "events", `${sessionId}.jsonl`);
+}
+var FileSink = class {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  async emit(event) {
+    fs.mkdirSync(path.dirname(this.file), { recursive: true });
+    fs.appendFileSync(this.file, `${JSON.stringify(event)}
+`);
+  }
+};
+var HttpSink = class {
+  constructor(baseUrl, sessionId, logger = {
+    warn: (m) => process.stderr.write(`[kody2:chat] ${m}
+`)
+  }) {
+    this.baseUrl = baseUrl;
+    this.sessionId = sessionId;
+    this.logger = logger;
+  }
+  baseUrl;
+  sessionId;
+  logger;
+  async emit(event) {
+    const url = withSessionParam(this.baseUrl, this.sessionId);
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(event),
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) {
+        this.logger.warn(`HttpSink POST ${url} \u2192 ${res.status}`);
+      }
+    } catch (err) {
+      this.logger.warn(`HttpSink POST ${url} failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+var TeeSink = class {
+  constructor(sinks) {
+    this.sinks = sinks;
+  }
+  sinks;
+  async emit(event) {
+    await Promise.all(this.sinks.map((s) => s.emit(event)));
+  }
+};
+function withSessionParam(baseUrl, sessionId) {
+  const joiner = baseUrl.includes("?") ? "&" : "?";
+  return `${baseUrl}${joiner}sessionId=${encodeURIComponent(sessionId)}`;
+}
+function makeRunId(sessionId, suffix) {
+  return `chat-${sessionId}-${suffix}`;
+}
 
 // src/agent.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
 // src/config.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 var LITELLM_DEFAULT_PORT = 4e3;
 var LITELLM_DEFAULT_URL = `http://localhost:${LITELLM_DEFAULT_PORT}`;
 function parseProviderModel(s) {
@@ -78,13 +142,13 @@ function needsLitellmProxy(model) {
   return model.provider !== "claude" && model.provider !== "anthropic";
 }
 function loadConfig(projectDir = process.cwd()) {
-  const configPath = path.join(projectDir, "kody.config.json");
-  if (!fs.existsSync(configPath)) {
+  const configPath = path2.join(projectDir, "kody.config.json");
+  if (!fs2.existsSync(configPath)) {
     throw new Error(`kody.config.json not found at ${configPath}`);
   }
   let raw;
   try {
-    raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    raw = JSON.parse(fs2.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}`);
@@ -261,10 +325,10 @@ function formatBytes(bytes) {
 // src/agent.ts
 var DEFAULT_ALLOWED_TOOLS = ["Bash", "Edit", "Read", "Write", "Glob", "Grep"];
 async function runAgent(opts) {
-  const ndjsonDir = opts.ndjsonDir ?? path2.join(opts.cwd, ".kody2");
-  fs2.mkdirSync(ndjsonDir, { recursive: true });
-  const ndjsonPath = path2.join(ndjsonDir, "last-run.jsonl");
-  const fullLog = fs2.createWriteStream(ndjsonPath, { flags: "w" });
+  const ndjsonDir = opts.ndjsonDir ?? path3.join(opts.cwd, ".kody2");
+  fs3.mkdirSync(ndjsonDir, { recursive: true });
+  const ndjsonPath = path3.join(ndjsonDir, "last-run.jsonl");
+  const fullLog = fs3.createWriteStream(ndjsonPath, { flags: "w" });
   const env = {
     ...process.env,
     SKIP_HOOKS: "1",
@@ -336,11 +400,228 @@ async function runAgent(opts) {
   return { outcome, finalText, error: errorMessage, ndjsonPath };
 }
 
+// src/chat/session.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+function sessionFilePath(cwd, sessionId) {
+  return path4.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
+}
+function readSession(file) {
+  if (!fs4.existsSync(file)) return [];
+  const raw = fs4.readFileSync(file, "utf-8").trim();
+  if (!raw) return [];
+  const turns = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed.role !== "user" && parsed.role !== "assistant") continue;
+      if (typeof parsed.content !== "string") continue;
+      turns.push(parsed);
+    } catch {
+    }
+  }
+  return turns;
+}
+function appendTurn(file, turn) {
+  fs4.mkdirSync(path4.dirname(file), { recursive: true });
+  const line = JSON.stringify({
+    role: turn.role,
+    content: turn.content,
+    timestamp: turn.timestamp,
+    toolCalls: turn.toolCalls ?? []
+  });
+  fs4.appendFileSync(file, `${line}
+`);
+}
+function seedInitialMessage(file, message) {
+  if (!message.trim()) return false;
+  const turns = readSession(file);
+  const lastUser = [...turns].reverse().find((t) => t.role === "user");
+  if (lastUser && lastUser.content === message) return false;
+  appendTurn(file, {
+    role: "user",
+    content: message,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return true;
+}
+
+// src/chat/loop.ts
+var CHAT_SYSTEM_PROMPT = [
+  "You are Kody, an AI assistant for the Kody Operations Dashboard. Reply to the user's",
+  "latest message using the full conversation below as context. Keep replies focused,",
+  "technical when appropriate, and formatted in Markdown. Use the available tools to",
+  "read repository code or execute small checks when it helps you answer \u2014 otherwise",
+  "reply directly. Do not invent file paths, commit SHAs, or command output."
+].join("\n");
+async function runChatTurn(opts) {
+  const turns = readSession(opts.sessionFile);
+  if (turns.length === 0) {
+    const error = "session file is empty \u2014 nothing to reply to";
+    await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
+    return { exitCode: 64, error };
+  }
+  const lastTurn = turns[turns.length - 1];
+  if (lastTurn.role !== "user") {
+    const error = "last turn is not a user message \u2014 assistant already replied";
+    await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
+    return { exitCode: 64, error };
+  }
+  const prompt = buildPrompt(turns, opts.systemPrompt ?? CHAT_SYSTEM_PROMPT);
+  const invoke = opts.invokeAgent ?? ((p) => runAgent({
+    prompt: p,
+    model: opts.model,
+    cwd: opts.cwd,
+    litellmUrl: opts.litellmUrl,
+    verbose: opts.verbose,
+    quiet: opts.quiet
+  }));
+  let result;
+  try {
+    result = await invoke(prompt);
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
+    return { exitCode: 99, error };
+  }
+  if (result.outcome !== "completed") {
+    const error = result.error ?? "agent did not complete";
+    await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
+    return { exitCode: 99, error };
+  }
+  const reply = result.finalText.trim();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  appendTurn(opts.sessionFile, {
+    role: "assistant",
+    content: reply,
+    timestamp: now
+  });
+  await emit(opts.sink, "chat.message", opts.sessionId, "message", {
+    sessionId: opts.sessionId,
+    role: "assistant",
+    content: reply,
+    timestamp: now
+  });
+  await emit(opts.sink, "chat.done", opts.sessionId, "done", { sessionId: opts.sessionId });
+  return { exitCode: 0, reply };
+}
+function buildPrompt(turns, systemPrompt) {
+  const header = `System: ${systemPrompt}`;
+  const body = turns.map((t) => `${t.role === "user" ? "User" : "Assistant"}: ${t.content}`).join("\n\n");
+  return `${header}
+
+${body}
+
+Assistant:`;
+}
+async function emit(sink, type, sessionId, suffix, payload) {
+  await sink.emit({
+    event: type,
+    payload,
+    runId: makeRunId(sessionId, suffix),
+    emittedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
+// src/kody2-cli.ts
+import { execFileSync as execFileSync15 } from "child_process";
+import * as fs18 from "fs";
+import * as path15 from "path";
+
+// src/dispatch.ts
+import * as fs5 from "fs";
+function autoDispatch(opts) {
+  const explicit = opts?.explicit;
+  if (explicit?.issueNumber && explicit.issueNumber > 0) {
+    return {
+      executable: "run",
+      cliArgs: { issue: explicit.issueNumber },
+      target: explicit.issueNumber
+    };
+  }
+  const eventName = process.env.GITHUB_EVENT_NAME;
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventName || !eventPath || !fs5.existsSync(eventPath)) return null;
+  let event = {};
+  try {
+    event = JSON.parse(fs5.readFileSync(eventPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (eventName === "workflow_dispatch") {
+    const n = parseInt(String(event.inputs?.issue_number ?? ""), 10);
+    if (!Number.isNaN(n) && n > 0) {
+      return { executable: "run", cliArgs: { issue: n }, target: n };
+    }
+    return null;
+  }
+  if (eventName !== "issue_comment") return null;
+  const body = String(event.comment?.body ?? "").toLowerCase();
+  const targetNum = Number(event.issue?.number ?? 0);
+  const isPr = !!event.issue?.pull_request;
+  if (!targetNum) return null;
+  const afterTag = extractAfterTag(body);
+  if (isPr) {
+    if (/\bfix-ci\b/.test(afterTag)) {
+      return { executable: "fix-ci", cliArgs: { pr: targetNum }, target: targetNum };
+    }
+    if (/\bresolve\b/.test(afterTag)) {
+      return { executable: "resolve", cliArgs: { pr: targetNum }, target: targetNum };
+    }
+    if (/\breview\b/.test(afterTag)) {
+      return { executable: "review", cliArgs: { pr: targetNum }, target: targetNum };
+    }
+    if (/\bsync\b/.test(afterTag)) {
+      return { executable: "sync", cliArgs: { pr: targetNum }, target: targetNum };
+    }
+    const feedback = extractFeedback(afterTag);
+    return {
+      executable: "fix",
+      cliArgs: { pr: targetNum, ...feedback ? { feedback } : {} },
+      target: targetNum
+    };
+  }
+  const sub = extractSubcommand(afterTag);
+  const defaultExec = opts?.config?.defaultExecutable ?? "run";
+  if (!sub) {
+    return asDispatch(defaultExec, targetNum);
+  }
+  if (sub === "orchestrate" || sub === "orchestrator") {
+    return { executable: "orchestrator", cliArgs: { issue: targetNum }, target: targetNum };
+  }
+  if (sub === "build") {
+    return { executable: "run", cliArgs: { issue: targetNum }, target: targetNum };
+  }
+  return asDispatch(sub, targetNum);
+}
+function asDispatch(executable, target) {
+  return { executable, cliArgs: { issue: target }, target };
+}
+function extractAfterTag(body) {
+  const idx = body.indexOf("@kody2");
+  if (idx === -1) return body;
+  return body.slice(idx + "@kody2".length).trim();
+}
+function extractSubcommand(afterTag) {
+  const match = afterTag.match(/^([a-z][a-z0-9-]{1,40})\b/);
+  if (!match) return null;
+  return match[1];
+}
+function extractFeedback(afterTag) {
+  const cleaned = afterTag.replace(/^(fix|please|kindly)[\s:,.-]+/i, "").trim();
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+
+// src/executor.ts
+import * as fs17 from "fs";
+import * as path14 from "path";
+
 // src/litellm.ts
 import { execFileSync, spawn } from "child_process";
-import * as fs3 from "fs";
+import * as fs6 from "fs";
 import * as os from "os";
-import * as path3 from "path";
+import * as path5 from "path";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -380,20 +661,20 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
       throw new Error("litellm not installed \u2014 run: pip install 'litellm[proxy]'");
     }
   }
-  const configPath = path3.join(os.tmpdir(), `kody2-litellm-${Date.now()}.yaml`);
-  fs3.writeFileSync(configPath, generateLitellmConfigYaml(model));
+  const configPath = path5.join(os.tmpdir(), `kody2-litellm-${Date.now()}.yaml`);
+  fs6.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 = path3.join(os.tmpdir(), `kody2-litellm-${Date.now()}.log`);
-  const outFd = fs3.openSync(logPath, "w");
+  const logPath = path5.join(os.tmpdir(), `kody2-litellm-${Date.now()}.log`);
+  const outFd = fs6.openSync(logPath, "w");
   const child = spawn(cmd, args, {
     stdio: ["ignore", outFd, outFd],
     detached: true,
     env: stripBlockingEnv({ ...process.env, ...dotenvVars })
   });
-  fs3.closeSync(outFd);
+  fs6.closeSync(outFd);
   for (let i = 0; i < 30; i++) {
     await new Promise((r) => setTimeout(r, 2e3));
     if (await checkLitellmHealth(url)) {
@@ -410,7 +691,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   }
   let logTail = "";
   try {
-    logTail = fs3.readFileSync(logPath, "utf-8").slice(-2e3);
+    logTail = fs6.readFileSync(logPath, "utf-8").slice(-2e3);
   } catch {
   }
   try {
@@ -421,10 +702,10 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
 ${logTail}`);
 }
 function readDotenvApiKeys(projectDir) {
-  const dotenvPath = path3.join(projectDir, ".env");
-  if (!fs3.existsSync(dotenvPath)) return {};
+  const dotenvPath = path5.join(projectDir, ".env");
+  if (!fs6.existsSync(dotenvPath)) return {};
   const result = {};
-  for (const rawLine of fs3.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  for (const rawLine of fs6.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)=(.*)$/);
@@ -447,8 +728,8 @@ function stripBlockingEnv(env) {
 }
 
 // src/profile.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs7 from "fs";
+import * as path6 from "path";
 var VALID_INPUT_TYPES = /* @__PURE__ */ new Set(["int", "string", "bool", "enum"]);
 var VALID_PERMISSION_MODES = /* @__PURE__ */ new Set(["default", "acceptEdits", "plan", "bypassPermissions"]);
 var ProfileError = class extends Error {
@@ -461,12 +742,12 @@ var ProfileError = class extends Error {
   profilePath;
 };
 function loadProfile(profilePath) {
-  if (!fs4.existsSync(profilePath)) {
+  if (!fs7.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs4.readFileSync(profilePath, "utf-8"));
+    raw = JSON.parse(fs7.readFileSync(profilePath, "utf-8"));
   } catch (err) {
     throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -490,7 +771,7 @@ function loadProfile(profilePath) {
     outputContract: r.outputContract,
     inputArtifacts: parseInputArtifacts(profilePath, r.input),
     outputArtifacts: parseOutputArtifacts(profilePath, r.output),
-    dir: path4.dirname(profilePath)
+    dir: path6.dirname(profilePath)
   };
   return profile;
 }
@@ -669,21 +950,21 @@ function parseScriptList(p, key, raw) {
 }
 
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs5 from "fs";
+import * as fs8 from "fs";
 import * as os2 from "os";
-import * as path5 from "path";
+import * as path7 from "path";
 function getPluginsCatalogRoot() {
-  const here = path5.dirname(new URL(import.meta.url).pathname);
+  const here = path7.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path5.join(here, "..", "plugins"),
+    path7.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path5.join(here, "..", "..", "plugins"),
+    path7.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path5.join(here, "..", "..", "src", "plugins")
+    path7.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs5.existsSync(c) && fs5.statSync(c).isDirectory()) return c;
+    if (fs8.existsSync(c) && fs8.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
@@ -693,50 +974,50 @@ 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 = path5.join(os2.tmpdir(), `kody2-synth-${runId}`);
-  fs5.mkdirSync(path5.join(root, ".claude-plugin"), { recursive: true });
+  const root = path7.join(os2.tmpdir(), `kody2-synth-${runId}`);
+  fs8.mkdirSync(path7.join(root, ".claude-plugin"), { recursive: true });
   if (cc.skills.length > 0) {
-    const dst = path5.join(root, "skills");
-    fs5.mkdirSync(dst, { recursive: true });
+    const dst = path7.join(root, "skills");
+    fs8.mkdirSync(dst, { recursive: true });
     for (const name of cc.skills) {
-      const src = path5.join(catalog, "skills", name);
-      if (!fs5.existsSync(src)) throw new Error(`buildSyntheticPlugin: skill not found in catalog: ${name}`);
-      copyDir(src, path5.join(dst, name));
+      const src = path7.join(catalog, "skills", name);
+      if (!fs8.existsSync(src)) throw new Error(`buildSyntheticPlugin: skill not found in catalog: ${name}`);
+      copyDir(src, path7.join(dst, name));
     }
   }
   if (cc.commands.length > 0) {
-    const dst = path5.join(root, "commands");
-    fs5.mkdirSync(dst, { recursive: true });
+    const dst = path7.join(root, "commands");
+    fs8.mkdirSync(dst, { recursive: true });
     for (const name of cc.commands) {
-      const src = path5.join(catalog, "commands", `${name}.md`);
-      if (!fs5.existsSync(src)) throw new Error(`buildSyntheticPlugin: command not found in catalog: ${name}`);
-      fs5.copyFileSync(src, path5.join(dst, `${name}.md`));
+      const src = path7.join(catalog, "commands", `${name}.md`);
+      if (!fs8.existsSync(src)) throw new Error(`buildSyntheticPlugin: command not found in catalog: ${name}`);
+      fs8.copyFileSync(src, path7.join(dst, `${name}.md`));
     }
   }
   if (cc.subagents.length > 0) {
-    const dst = path5.join(root, "agents");
-    fs5.mkdirSync(dst, { recursive: true });
+    const dst = path7.join(root, "agents");
+    fs8.mkdirSync(dst, { recursive: true });
     for (const name of cc.subagents) {
-      const src = path5.join(catalog, "agents", `${name}.md`);
-      if (!fs5.existsSync(src)) throw new Error(`buildSyntheticPlugin: subagent not found in catalog: ${name}`);
-      fs5.copyFileSync(src, path5.join(dst, `${name}.md`));
+      const src = path7.join(catalog, "agents", `${name}.md`);
+      if (!fs8.existsSync(src)) throw new Error(`buildSyntheticPlugin: subagent not found in catalog: ${name}`);
+      fs8.copyFileSync(src, path7.join(dst, `${name}.md`));
     }
   }
   if (cc.hooks.length > 0) {
-    const dst = path5.join(root, "hooks");
-    fs5.mkdirSync(dst, { recursive: true });
+    const dst = path7.join(root, "hooks");
+    fs8.mkdirSync(dst, { recursive: true });
     const merged = { hooks: {} };
     for (const name of cc.hooks) {
-      const src = path5.join(catalog, "hooks", `${name}.json`);
-      if (!fs5.existsSync(src)) throw new Error(`buildSyntheticPlugin: hook not found in catalog: ${name}`);
-      const parsed = JSON.parse(fs5.readFileSync(src, "utf-8"));
+      const src = path7.join(catalog, "hooks", `${name}.json`);
+      if (!fs8.existsSync(src)) throw new Error(`buildSyntheticPlugin: hook not found in catalog: ${name}`);
+      const parsed = JSON.parse(fs8.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);
       }
     }
-    fs5.writeFileSync(path5.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+    fs8.writeFileSync(path7.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
   }
   const manifest = {
@@ -747,17 +1028,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`);
-  fs5.writeFileSync(path5.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+  fs8.writeFileSync(path7.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
   ctx.data.syntheticPluginPath = root;
 };
 function copyDir(src, dst) {
-  fs5.mkdirSync(dst, { recursive: true });
-  for (const ent of fs5.readdirSync(src, { withFileTypes: true })) {
-    const s = path5.join(src, ent.name);
-    const d = path5.join(dst, ent.name);
+  fs8.mkdirSync(dst, { recursive: true });
+  for (const ent of fs8.readdirSync(src, { withFileTypes: true })) {
+    const s = path7.join(src, ent.name);
+    const d = path7.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs5.copyFileSync(s, d);
+    else if (ent.isFile()) fs8.copyFileSync(s, d);
   }
 }
 
@@ -823,18 +1104,18 @@ function formatMissesForFeedback(misses) {
 }
 
 // src/prompt.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs9 from "fs";
+import * as path8 from "path";
 var CONVENTIONS_PER_FILE_MAX_BYTES = 3e4;
 var CONVENTION_FILES = ["CLAUDE.md", "AGENTS.md"];
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path6.join(projectDir, rel);
-    if (!fs6.existsSync(abs)) continue;
+    const abs = path8.join(projectDir, rel);
+    if (!fs9.existsSync(abs)) continue;
     let content;
     try {
-      content = fs6.readFileSync(abs, "utf-8");
+      content = fs9.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -848,23 +1129,49 @@ function loadProjectConventions(projectDir) {
 }
 function parseAgentResult(finalText) {
   const text = (finalText || "").trim();
-  if (!text) return { done: false, commitMessage: "", prSummary: "", failureReason: "agent produced no final message" };
+  if (!text)
+    return {
+      done: false,
+      commitMessage: "",
+      prSummary: "",
+      feedbackActions: "",
+      failureReason: "agent produced no final message"
+    };
   const failedMatch = text.match(/(?:^|\n)\s*FAILED\s*:\s*(.+?)\s*$/s);
   if (failedMatch) {
-    return { done: false, commitMessage: "", prSummary: "", failureReason: failedMatch[1].trim() };
+    return { done: false, commitMessage: "", prSummary: "", feedbackActions: "", failureReason: failedMatch[1].trim() };
   }
   if (!/(^|\n)\s*DONE\b/i.test(text)) {
-    return { done: false, commitMessage: "", prSummary: "", failureReason: "no DONE or FAILED marker in agent output" };
+    return {
+      done: false,
+      commitMessage: "",
+      prSummary: "",
+      feedbackActions: "",
+      failureReason: "no DONE or FAILED marker in agent output"
+    };
   }
   const commitMatch = text.match(/^[ \t]*COMMIT_MSG\s*:\s*(.+)$/im);
   const commitMessage = commitMatch ? commitMatch[1].trim() : "";
+  const feedbackActions = extractBlock(
+    text,
+    /(?:^|\n)[ \t]*FEEDBACK_ACTIONS\s*:[ \t]*\n/i,
+    /(?:^|\n)[ \t]*(?:COMMIT_MSG|PR_SUMMARY)\s*:/i
+  );
   const summaryStart = text.search(/(^|\n)[ \t]*PR_SUMMARY\s*:[ \t]*\n/i);
   let prSummary = "";
   if (summaryStart !== -1) {
     const afterMarker = text.slice(summaryStart).replace(/^[\s\S]*?PR_SUMMARY\s*:[ \t]*\n/i, "");
     prSummary = afterMarker.replace(/\n\s*```\s*$/g, "").replace(/```\s*$/g, "").trim();
   }
-  return { done: true, commitMessage, prSummary, failureReason: "" };
+  return { done: true, commitMessage, prSummary, feedbackActions, failureReason: "" };
+}
+function extractBlock(text, startMarker, endMarker) {
+  const startIdx = text.search(startMarker);
+  if (startIdx === -1) return "";
+  const afterStart = text.slice(startIdx).replace(startMarker, "");
+  const endIdx = afterStart.search(endMarker);
+  const body = endIdx === -1 ? afterStart : afterStart.slice(0, endIdx);
+  return body.replace(/\n\s*```\s*$/g, "").trim();
 }
 
 // src/scripts/checkCoverageWithRetry.ts
@@ -911,8 +1218,8 @@ import { execFileSync as execFileSync4 } from "child_process";
 
 // src/commit.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs10 from "fs";
+import * as path9 from "path";
 var FORBIDDEN_PATH_PREFIXES = [
   ".kody/",
   ".kody-engine/",
@@ -967,18 +1274,18 @@ function tryGit(args, cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path7.join(cwd ?? process.cwd(), ".git");
-  if (!fs7.existsSync(gitDir)) return aborted;
-  if (fs7.existsSync(path7.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path9.join(cwd ?? process.cwd(), ".git");
+  if (!fs10.existsSync(gitDir)) return aborted;
+  if (fs10.existsSync(path9.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs7.existsSync(path7.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs10.existsSync(path9.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs7.existsSync(path7.join(gitDir, "REVERT_HEAD"))) {
+  if (fs10.existsSync(path9.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs7.existsSync(path7.join(gitDir, "rebase-merge")) || fs7.existsSync(path7.join(gitDir, "rebase-apply"))) {
+  if (fs10.existsSync(path9.join(gitDir, "rebase-merge")) || fs10.existsSync(path9.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -1020,7 +1327,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs7.existsSync(path7.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs10.existsSync(path9.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -1110,20 +1417,20 @@ function defaultCommitMessage(mode, data) {
 }
 
 // src/scripts/composePrompt.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
+import * as fs11 from "fs";
+import * as path10 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 ? path8.join(profile.dir, explicit) : null,
-    mode ? path8.join(profile.dir, "prompts", `${mode}.md`) : null,
-    path8.join(profile.dir, "prompt.md")
+    explicit ? path10.join(profile.dir, explicit) : null,
+    mode ? path10.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path10.join(profile.dir, "prompt.md")
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
-    if (fs8.existsSync(c)) {
+    if (fs11.existsSync(c)) {
       templatePath = c;
       break;
     }
@@ -1131,7 +1438,7 @@ var composePrompt = async (ctx, profile) => {
   if (!templatePath) {
     throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
   }
-  const template = fs8.readFileSync(templatePath, "utf-8");
+  const template = fs11.readFileSync(templatePath, "utf-8");
   const tokens = {
     ...stringifyAll(ctx.args, "args."),
     ...stringifyAll(ctx.data, ""),
@@ -1603,7 +1910,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd) {
 
 // src/gha.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import * as fs9 from "fs";
+import * as fs12 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -1614,10 +1921,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs9.existsSync(eventPath)) return;
+  if (!eventPath || !fs12.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs9.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs12.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -1843,35 +2150,35 @@ function tryPostPr2(prNumber, body, cwd) {
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import * as fs11 from "fs";
-import * as path10 from "path";
+import * as fs14 from "fs";
+import * as path12 from "path";
 
 // src/registry.ts
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs13 from "fs";
+import * as path11 from "path";
 function getExecutablesRoot() {
-  const here = path9.dirname(new URL(import.meta.url).pathname);
+  const here = path11.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path9.join(here, "executables"),
+    path11.join(here, "executables"),
     // dev: src/
-    path9.join(here, "..", "executables"),
+    path11.join(here, "..", "executables"),
     // built: dist/bin → dist/executables
-    path9.join(here, "..", "src", "executables")
+    path11.join(here, "..", "src", "executables")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs10.existsSync(c) && fs10.statSync(c).isDirectory()) return c;
+    if (fs13.existsSync(c) && fs13.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function listExecutables(root = getExecutablesRoot()) {
-  if (!fs10.existsSync(root)) return [];
-  const entries = fs10.readdirSync(root, { withFileTypes: true });
+  if (!fs13.existsSync(root)) return [];
+  const entries = fs13.readdirSync(root, { withFileTypes: true });
   const out = [];
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
-    const profilePath = path9.join(root, ent.name, "profile.json");
-    if (fs10.existsSync(profilePath) && fs10.statSync(profilePath).isFile()) {
+    const profilePath = path11.join(root, ent.name, "profile.json");
+    if (fs13.existsSync(profilePath) && fs13.statSync(profilePath).isFile()) {
       out.push({ name: ent.name, profilePath });
     }
   }
@@ -1879,8 +2186,8 @@ function listExecutables(root = getExecutablesRoot()) {
 }
 function hasExecutable(name, root = getExecutablesRoot()) {
   if (!isSafeName(name)) return false;
-  const profilePath = path9.join(root, name, "profile.json");
-  return fs10.existsSync(profilePath) && fs10.statSync(profilePath).isFile();
+  const profilePath = path11.join(root, name, "profile.json");
+  return fs13.existsSync(profilePath) && fs13.statSync(profilePath).isFile();
 }
 function isSafeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
@@ -1909,9 +2216,9 @@ function parseGenericFlags(argv) {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  if (fs11.existsSync(path10.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs11.existsSync(path10.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs11.existsSync(path10.join(cwd, "bun.lockb"))) return "bun";
+  if (fs14.existsSync(path12.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs14.existsSync(path12.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs14.existsSync(path12.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -2032,22 +2339,22 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path10.join(cwd, "kody.config.json");
-  if (fs11.existsSync(configPath) && !force) {
+  const configPath = path12.join(cwd, "kody.config.json");
+  if (fs14.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs11.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs14.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path10.join(cwd, ".github", "workflows");
-  const workflowPath = path10.join(workflowDir, "kody2.yml");
-  if (fs11.existsSync(workflowPath) && !force) {
+  const workflowDir = path12.join(cwd, ".github", "workflows");
+  const workflowPath = path12.join(workflowDir, "kody2.yml");
+  if (fs14.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody2.yml");
   } else {
-    fs11.mkdirSync(workflowDir, { recursive: true });
-    fs11.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs14.mkdirSync(workflowDir, { recursive: true });
+    fs14.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody2.yml");
   }
   for (const exe of listExecutables()) {
@@ -2058,12 +2365,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path10.join(workflowDir, `kody2-${exe.name}.yml`);
-    if (fs11.existsSync(target) && !force) {
+    const target = path12.join(workflowDir, `kody2-${exe.name}.yml`);
+    if (fs14.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody2-${exe.name}.yml`);
       continue;
     }
-    fs11.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs14.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody2-${exe.name}.yml`);
   }
   return { wrote, skipped };
@@ -2277,17 +2584,19 @@ function renderStateComment(state) {
   lines.push(STATE_BEGIN);
   lines.push("");
   lines.push("```json");
-  lines.push(JSON.stringify(
-    {
-      schemaVersion: state.schemaVersion,
-      core: state.core,
-      artifacts: state.artifacts ?? {},
-      executables: state.executables,
-      history: state.history
-    },
-    null,
-    2
-  ));
+  lines.push(
+    JSON.stringify(
+      {
+        schemaVersion: state.schemaVersion,
+        core: state.core,
+        artifacts: state.artifacts ?? {},
+        executables: state.executables,
+        history: state.history
+      },
+      null,
+      2
+    )
+  );
   lines.push("```");
   lines.push("");
   lines.push(STATE_END);
@@ -2337,11 +2646,7 @@ function writeTaskState(target, number, state, cwd) {
   const existing = findStateComment(target, number, cwd);
   try {
     if (existing) {
-      gh3(
-        ["api", `repos/{owner}/{repo}/issues/comments/${existing.id}`, "-X", "PATCH", "-F", "body=@-"],
-        body,
-        cwd
-      );
+      gh3(["api", `repos/{owner}/{repo}/issues/comments/${existing.id}`, "-X", "PATCH", "-F", "body=@-"], body, cwd);
     } else {
       const sub = target === "issue" ? "issue" : "pr";
       gh3([sub, "comment", String(number), "--body-file", "-"], body, cwd);
@@ -2376,6 +2681,7 @@ var parseAgentResult2 = async (ctx, profile, agentResult) => {
   ctx.data.agentDone = parsed.done;
   ctx.data.commitMessage = parsed.commitMessage;
   ctx.data.prSummary = parsed.prSummary;
+  ctx.data.feedbackActions = parsed.feedbackActions;
   ctx.data.agentFailureReason = parsed.failureReason;
   ctx.data.agentOutcome = agentResult.outcome;
   ctx.data.agentError = agentResult.error;
@@ -2545,15 +2851,17 @@ var postReviewResult = async (ctx, _profile, agentResult) => {
   const verdict = detectVerdict(reviewBody);
   ctx.data.reviewVerdict = verdict;
   ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
-  process.stdout.write(`
+  process.stdout.write(
+    `
 REVIEW_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}/pull/${prNumber} (verdict: ${verdict})
-`);
+`
+  );
 };
 
 // src/scripts/releaseFlow.ts
 import { execFileSync as execFileSync11, spawnSync } from "child_process";
-import * as fs12 from "fs";
-import * as path11 from "path";
+import * as fs15 from "fs";
+import * as path13 from "path";
 function bumpVersion(current, bump) {
   const m = current.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
   if (!m) throw new Error(`cannot parse version '${current}' (expected x.y.z[-suffix])`);
@@ -2569,12 +2877,12 @@ function bumpVersion(current, bump) {
   return `${major}.${minor}.${patch}`;
 }
 function updateVersionInFile(file, newVersion, cwd) {
-  const abs = path11.join(cwd, file);
-  if (!fs12.existsSync(abs)) return false;
-  const content = fs12.readFileSync(abs, "utf-8");
+  const abs = path13.join(cwd, file);
+  if (!fs15.existsSync(abs)) return false;
+  const content = fs15.readFileSync(abs, "utf-8");
   const updated = content.replace(/"version"\s*:\s*"[^"]+"/, `"version": "${newVersion}"`);
   if (updated === content) return false;
-  fs12.writeFileSync(abs, updated);
+  fs15.writeFileSync(abs, updated);
   return true;
 }
 function generateChangelog(cwd, newVersion, lastTag) {
@@ -2622,19 +2930,19 @@ function generateChangelog(cwd, newVersion, lastTag) {
   return parts.join("\n");
 }
 function prependChangelog(cwd, entry) {
-  const p = path11.join(cwd, "CHANGELOG.md");
+  const p = path13.join(cwd, "CHANGELOG.md");
   const header = "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n";
-  if (fs12.existsSync(p)) {
-    const prior = fs12.readFileSync(p, "utf-8");
+  if (fs15.existsSync(p)) {
+    const prior = fs15.readFileSync(p, "utf-8");
     if (/^#\s*Changelog\b/m.test(prior)) {
       const idx = prior.indexOf("\n", prior.indexOf("# Changelog"));
-      fs12.writeFileSync(p, `${prior.slice(0, idx + 1)}
+      fs15.writeFileSync(p, `${prior.slice(0, idx + 1)}
 ${entry}${prior.slice(idx + 1)}`);
     } else {
-      fs12.writeFileSync(p, `${header}${entry}${prior}`);
+      fs15.writeFileSync(p, `${header}${entry}${prior}`);
     }
   } else {
-    fs12.writeFileSync(p, `${header}${entry}`);
+    fs15.writeFileSync(p, `${header}${entry}`);
   }
 }
 function git3(args, cwd, timeout = 6e4) {
@@ -2685,13 +2993,13 @@ var releaseFlow = async (ctx) => {
 };
 async function runPrepare(args) {
   const { cwd, bump, dryRun, versionFiles, ctx } = args;
-  const pkgPath = path11.join(cwd, "package.json");
-  if (!fs12.existsSync(pkgPath)) {
+  const pkgPath = path13.join(cwd, "package.json");
+  if (!fs15.existsSync(pkgPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release prepare: package.json not found";
     return;
   }
-  const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+  const pkg = JSON.parse(fs15.readFileSync(pkgPath, "utf-8"));
   if (typeof pkg.version !== "string") {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release prepare: package.json has no version";
@@ -2745,10 +3053,10 @@ ${entry}
 Merge this and then run \`kody2 release --mode finalize\`.`;
   let prUrl = "";
   try {
-    prUrl = gh(
-      ["pr", "create", "--head", releaseBranch, "--base", base, "--title", title, "--body-file", "-"],
-      { input: body, cwd }
-    ).trim();
+    prUrl = gh(["pr", "create", "--head", releaseBranch, "--base", base, "--title", title, "--body-file", "-"], {
+      input: body,
+      cwd
+    }).trim();
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     ctx.output.exitCode = 4;
@@ -2762,8 +3070,8 @@ Merge this and then run \`kody2 release --mode finalize\`.`;
 }
 async function runFinalize(args) {
   const { cwd, dryRun, timeoutMs, releaseCfg, ctx } = args;
-  const pkgPath = path11.join(cwd, "package.json");
-  const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path13.join(cwd, "package.json");
+  const pkg = JSON.parse(fs15.readFileSync(pkgPath, "utf-8"));
   if (typeof pkg.version !== "string") {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release finalize: package.json has no version";
@@ -2820,20 +3128,14 @@ ${truncate2(r.stderr, 2e3)}
   }
   let releaseUrl = "";
   try {
-    const releaseArgs = [
-      "release",
-      "create",
-      tag,
-      "--title",
-      tag,
-      "--notes",
-      `Release ${tag} \u2014 automated by kody2.`
-    ];
+    const releaseArgs = ["release", "create", tag, "--title", tag, "--notes", `Release ${tag} \u2014 automated by kody2.`];
     if (releaseCfg.draftRelease) releaseArgs.push("--draft");
     releaseUrl = gh(releaseArgs, { cwd }).trim();
   } catch (err) {
-    process.stderr.write(`[kody2 release] gh release create failed: ${err instanceof Error ? err.message : String(err)}
-`);
+    process.stderr.write(
+      `[kody2 release] gh release create failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
   }
   if (releaseCfg.notifyCommand && releaseCfg.notifyCommand.trim().length > 0) {
     const cmd = releaseCfg.notifyCommand.replace(/\$VERSION/g, version);
@@ -2852,6 +3154,35 @@ ${truncate2(r.stderr, 2e3)}
 `);
 }
 
+// src/scripts/requireFeedbackActions.ts
+var MIN_ITEMS = 1;
+var requireFeedbackActions = async (ctx, profile) => {
+  if (!ctx.data.agentDone) return;
+  const actions = String(ctx.data.feedbackActions ?? "").trim();
+  const items = countActionItems(actions);
+  if (items >= MIN_ITEMS) return;
+  const reason = actions.length === 0 ? "agent omitted required FEEDBACK_ACTIONS block \u2014 cannot verify that review feedback was addressed" : "agent FEEDBACK_ACTIONS block listed no items \u2014 cannot verify that review feedback was addressed";
+  ctx.data.agentDone = false;
+  ctx.data.agentFailureReason = reason;
+  const modeSeg = profile.name.replace(/-/g, "_").toUpperCase();
+  const failedAction = {
+    type: `${modeSeg}_FAILED`,
+    payload: { reason },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  ctx.data.action = failedAction;
+};
+function countActionItems(block) {
+  if (!block.trim()) return 0;
+  const lines = block.split("\n");
+  let count = 0;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (/^[-*]\s+/.test(line)) count++;
+  }
+  return count;
+}
+
 // src/scripts/resolveArtifacts.ts
 var resolveArtifacts = async (ctx, profile) => {
   if (profile.inputArtifacts.length === 0) return;
@@ -3101,11 +3432,7 @@ var syncFlow = async (ctx) => {
   ctx.output.reason = `merged origin/${baseBranch} into ${ctx.data.branch}`;
   const runUrl = getRunUrl();
   const runSuffix = runUrl ? ` ([logs](${runUrl}))` : "";
-  tryPostPr5(
-    prNumber,
-    `\u2705 kody2 sync: merged \`origin/${baseBranch}\` into \`${ctx.data.branch}\`${runSuffix}`,
-    ctx.cwd
-  );
+  tryPostPr5(prNumber, `\u2705 kody2 sync: merged \`origin/${baseBranch}\` into \`${ctx.data.branch}\`${runSuffix}`, ctx.cwd);
 };
 function bail2(ctx, prNumber, reason) {
   ctx.output.exitCode = 1;
@@ -3145,7 +3472,7 @@ import { spawn as spawn2 } from "child_process";
 var TAIL_CHARS = 4e3;
 var COMMAND_TIMEOUT_MS = 10 * 60 * 1e3;
 function runCommand(command, cwd) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const start = Date.now();
     const child = spawn2(command, {
       cwd,
@@ -3174,11 +3501,11 @@ function runCommand(command, cwd) {
     child.on("exit", (code) => {
       clearTimeout(timer);
       const tail = Buffer.concat(buffers).toString("utf-8").slice(-TAIL_CHARS);
-      resolve3({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
+      resolve4({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve3({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
+      resolve4({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
     });
   });
 }
@@ -3237,19 +3564,7 @@ function readWatchConfig(ctx) {
 function findStalePrs(cwd, staleDays, now = /* @__PURE__ */ new Date()) {
   let raw = "";
   try {
-    raw = gh(
-      [
-        "pr",
-        "list",
-        "--state",
-        "open",
-        "--limit",
-        "100",
-        "--json",
-        "number,title,url,updatedAt"
-      ],
-      { cwd }
-    );
+    raw = gh(["pr", "list", "--state", "open", "--limit", "100", "--json", "number,title,url,updatedAt"], { cwd });
   } catch {
     return [];
   }
@@ -3295,8 +3610,10 @@ var watchStalePrsFlow = async (ctx) => {
     try {
       postIssueComment(reportIssueNumber, report, ctx.cwd);
     } catch (err) {
-      process.stderr.write(`[kody2 watch] failed to post to issue #${reportIssueNumber}: ${err instanceof Error ? err.message : String(err)}
-`);
+      process.stderr.write(
+        `[kody2 watch] failed to post to issue #${reportIssueNumber}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
     }
   }
   ctx.output.exitCode = 0;
@@ -3304,7 +3621,7 @@ var watchStalePrsFlow = async (ctx) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs13 from "fs";
+import * as fs16 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -3326,7 +3643,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs13.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs16.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -3353,6 +3670,7 @@ var preflightScripts = {
 };
 var postflightScripts = {
   parseAgentResult: parseAgentResult2,
+  requireFeedbackActions,
   verify,
   checkCoverageWithRetry,
   commitAndPush: commitAndPush2,
@@ -3471,9 +3789,9 @@ async function runExecutable(profileName, input) {
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path12.join(input.cwd, ".kody2");
+  const ndjsonDir = path14.join(input.cwd, ".kody2");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path12.isAbsolute(p) ? p : path12.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path14.isAbsolute(p) ? p : path14.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -3539,17 +3857,17 @@ async function runExecutable(profileName, input) {
   }
 }
 function resolveProfilePath(profileName) {
-  const here = path12.dirname(new URL(import.meta.url).pathname);
+  const here = path14.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path12.join(here, "executables", profileName, "profile.json"),
+    path14.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path12.join(here, "..", "executables", profileName, "profile.json"),
+    path14.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path12.join(here, "..", "src", "executables", profileName, "profile.json")
+    path14.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs14.existsSync(c)) return c;
+    if (fs17.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -3640,95 +3958,6 @@ function finish(out) {
   return out;
 }
 
-// src/kody2-cli.ts
-import { execFileSync as execFileSync15 } from "child_process";
-import * as fs16 from "fs";
-import * as path13 from "path";
-
-// src/dispatch.ts
-import * as fs15 from "fs";
-function autoDispatch(opts) {
-  const explicit = opts?.explicit;
-  if (explicit?.issueNumber && explicit.issueNumber > 0) {
-    return {
-      executable: "run",
-      cliArgs: { issue: explicit.issueNumber },
-      target: explicit.issueNumber
-    };
-  }
-  const eventName = process.env.GITHUB_EVENT_NAME;
-  const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs15.existsSync(eventPath)) return null;
-  let event = {};
-  try {
-    event = JSON.parse(fs15.readFileSync(eventPath, "utf-8"));
-  } catch {
-    return null;
-  }
-  if (eventName === "workflow_dispatch") {
-    const n = parseInt(String(event.inputs?.issue_number ?? ""), 10);
-    if (!Number.isNaN(n) && n > 0) {
-      return { executable: "run", cliArgs: { issue: n }, target: n };
-    }
-    return null;
-  }
-  if (eventName !== "issue_comment") return null;
-  const body = String(event.comment?.body ?? "").toLowerCase();
-  const targetNum = Number(event.issue?.number ?? 0);
-  const isPr = !!event.issue?.pull_request;
-  if (!targetNum) return null;
-  const afterTag = extractAfterTag(body);
-  if (isPr) {
-    if (/\bfix-ci\b/.test(afterTag)) {
-      return { executable: "fix-ci", cliArgs: { pr: targetNum }, target: targetNum };
-    }
-    if (/\bresolve\b/.test(afterTag)) {
-      return { executable: "resolve", cliArgs: { pr: targetNum }, target: targetNum };
-    }
-    if (/\breview\b/.test(afterTag)) {
-      return { executable: "review", cliArgs: { pr: targetNum }, target: targetNum };
-    }
-    if (/\bsync\b/.test(afterTag)) {
-      return { executable: "sync", cliArgs: { pr: targetNum }, target: targetNum };
-    }
-    const feedback = extractFeedback(afterTag);
-    return {
-      executable: "fix",
-      cliArgs: { pr: targetNum, ...feedback ? { feedback } : {} },
-      target: targetNum
-    };
-  }
-  const sub = extractSubcommand(afterTag);
-  const defaultExec = opts?.config?.defaultExecutable ?? "run";
-  if (!sub) {
-    return asDispatch(defaultExec, targetNum);
-  }
-  if (sub === "orchestrate" || sub === "orchestrator") {
-    return { executable: "orchestrator", cliArgs: { issue: targetNum }, target: targetNum };
-  }
-  if (sub === "build") {
-    return { executable: "run", cliArgs: { issue: targetNum }, target: targetNum };
-  }
-  return asDispatch(sub, targetNum);
-}
-function asDispatch(executable, target) {
-  return { executable, cliArgs: { issue: target }, target };
-}
-function extractAfterTag(body) {
-  const idx = body.indexOf("@kody2");
-  if (idx === -1) return body;
-  return body.slice(idx + "@kody2".length).trim();
-}
-function extractSubcommand(afterTag) {
-  const match = afterTag.match(/^([a-z][a-z0-9-]{1,40})\b/);
-  if (!match) return null;
-  return match[1];
-}
-function extractFeedback(afterTag) {
-  const cleaned = afterTag.replace(/^(fix|please|kindly)[\s:,.-]+/i, "").trim();
-  return cleaned.length > 0 ? cleaned : void 0;
-}
-
 // src/kody2-cli.ts
 var CI_HELP = `kody2 ci \u2014 minimal-YAML autonomous engineer (CI preflight + run)
 
@@ -3814,9 +4043,9 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs16.existsSync(path13.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs16.existsSync(path13.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs16.existsSync(path13.join(cwd, "bun.lockb"))) return "bun";
+  if (fs18.existsSync(path15.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs18.existsSync(path15.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs18.existsSync(path15.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -3896,11 +4125,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path13.join(cwd, ".kody2", "last-run.jsonl");
+  const logPath = path15.join(cwd, ".kody2", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs16.existsSync(logPath)) {
-      const content = fs16.readFileSync(logPath, "utf-8");
+    if (fs18.existsSync(logPath)) {
+      const content = fs18.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -3925,7 +4154,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path13.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path15.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -4013,6 +4242,148 @@ ${CI_HELP}`);
   }
 }
 
+// src/chat-cli.ts
+var DEFAULT_MODEL = "claude/claude-haiku-4-5-20251001";
+var CHAT_HELP = `kody2 chat \u2014 dashboard-driven chat session
+
+Usage:
+  kody2 chat [--session <id>] [--message <text>] [--model <provider/model>]
+             [--dashboard-url <url>] [--cwd <path>] [--verbose|--quiet]
+
+All inputs may also come from env: SESSION_ID, INIT_MESSAGE, MODEL, DASHBOARD_URL.
+CLI flags take precedence over env. SESSION_ID is required.
+
+Exit codes:
+  0   reply emitted successfully
+  64  bad inputs (missing session, empty history)
+  99  runtime failure (agent crash, LiteLLM failure)
+`;
+function parseChatArgs(argv, env = process.env) {
+  const result = { errors: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--session") result.sessionId = argv[++i];
+    else if (arg === "--message") result.initMessage = argv[++i];
+    else if (arg === "--model") result.model = argv[++i];
+    else if (arg === "--dashboard-url") result.dashboardUrl = argv[++i];
+    else if (arg === "--cwd") result.cwd = argv[++i];
+    else if (arg === "--verbose") result.verbose = true;
+    else if (arg === "--quiet") result.quiet = true;
+    else if (arg === "--help" || arg === "-h") result.errors.push("__HELP__");
+    else if (arg?.startsWith("--")) result.errors.push(`unknown arg: ${arg}`);
+    else if (arg) result.errors.push(`unexpected positional: ${arg}`);
+  }
+  result.sessionId = result.sessionId ?? env.SESSION_ID ?? void 0;
+  result.initMessage = result.initMessage ?? env.INIT_MESSAGE ?? void 0;
+  result.model = result.model ?? env.MODEL ?? void 0;
+  result.dashboardUrl = result.dashboardUrl ?? env.DASHBOARD_URL ?? void 0;
+  for (const key of ["sessionId", "initMessage", "model", "dashboardUrl"]) {
+    const v = result[key];
+    if (typeof v === "string" && v.trim() === "") result[key] = void 0;
+  }
+  if (!result.sessionId && !result.errors.includes("__HELP__")) {
+    result.errors.push("--session <id> (or SESSION_ID env) is required");
+  }
+  return result;
+}
+function commitChatFiles(cwd, sessionId, verbose) {
+  const sessionFile = path16.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path16.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionFile, eventsFile].filter((p) => fs19.existsSync(path16.join(cwd, p)));
+  if (paths.length === 0) return;
+  const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
+  try {
+    execFileSync16("git", ["add", ...paths], opts);
+    execFileSync16("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
+    execFileSync16("git", ["push", "--quiet", "origin", "HEAD"], opts);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[kody2:chat] commit/push skipped: ${msg}
+`);
+  }
+}
+function tryLoadConfig(cwd) {
+  try {
+    return loadConfig(cwd);
+  } catch {
+    return null;
+  }
+}
+function buildSink(cwd, sessionId, dashboardUrl) {
+  const sinks = [new FileSink(eventsFilePath(cwd, sessionId))];
+  if (dashboardUrl) sinks.push(new HttpSink(dashboardUrl, sessionId));
+  return new TeeSink(sinks);
+}
+async function runChat(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    process.stdout.write(CHAT_HELP);
+    return 0;
+  }
+  const args = parseChatArgs(argv);
+  if (args.errors.length > 0 && !args.errors.includes("__HELP__")) {
+    for (const e of args.errors) process.stderr.write(`error: ${e}
+`);
+    process.stderr.write(`
+${CHAT_HELP}`);
+    return 64;
+  }
+  const cwd = args.cwd ? path16.resolve(args.cwd) : process.cwd();
+  const sessionId = args.sessionId;
+  const unpackedSecrets = unpackAllSecrets();
+  if (unpackedSecrets > 0) {
+    process.stdout.write(`\u2192 kody2: unpacked ${unpackedSecrets} secret(s) from ALL_SECRETS
+`);
+  }
+  resolveAuthToken();
+  configureGitIdentity(cwd);
+  const config = tryLoadConfig(cwd);
+  const modelSpec = args.model ?? config?.agent.model ?? DEFAULT_MODEL;
+  let model;
+  try {
+    model = parseProviderModel(modelSpec);
+  } catch (err) {
+    process.stderr.write(`error: invalid model '${modelSpec}': ${err instanceof Error ? err.message : String(err)}
+`);
+    return 64;
+  }
+  let litellm = null;
+  try {
+    litellm = await startLitellmIfNeeded(model, cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const sink2 = buildSink(cwd, sessionId, args.dashboardUrl);
+    await sink2.emit({
+      event: "chat.error",
+      payload: { sessionId, error: `litellm startup failed: ${msg}` },
+      runId: makeRunId(sessionId, "error"),
+      emittedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return 99;
+  }
+  const sessionFile = sessionFilePath(cwd, sessionId);
+  if (args.initMessage) seedInitialMessage(sessionFile, args.initMessage);
+  const sink = buildSink(cwd, sessionId, args.dashboardUrl);
+  try {
+    const result = await runChatTurn({
+      sessionId,
+      sessionFile,
+      cwd,
+      model,
+      litellmUrl: litellm?.url ?? null,
+      sink,
+      verbose: args.verbose,
+      quiet: args.quiet
+    });
+    commitChatFiles(cwd, sessionId, args.verbose ?? false);
+    return result.exitCode;
+  } finally {
+    try {
+      litellm?.kill();
+    } catch {
+    }
+  }
+}
+
 // src/entry.ts
 var HELP_TEXT = `kody2 \u2014 single-session autonomous engineer
 
@@ -4024,6 +4395,7 @@ Usage:
   kody2 review  --pr    <N>                    [--cwd <path>] [--verbose|--quiet]
   kody2 <other>                                [--cwd <path>] [--verbose|--quiet]
   kody2 ci      --issue <N> [preflight flags \u2014 see: kody2 ci --help]
+  kody2 chat    [chat flags \u2014 see: kody2 chat --help]
   kody2 help
   kody2 version
 
@@ -4050,6 +4422,9 @@ function parseArgs(argv) {
   if (cmd === "ci") {
     return { ...result, command: "ci", ciArgv: argv.slice(1) };
   }
+  if (cmd === "chat") {
+    return { ...result, command: "chat", chatArgv: argv.slice(1) };
+  }
   if (hasExecutable(cmd)) {
     result.command = "__executable__";
     result.executableName = cmd;
@@ -4090,6 +4465,18 @@ ${HELP_TEXT}`);
       process.stderr.write(`[kody2] fatal: ${msg}
 `);
       if (err instanceof Error && err.stack) process.stderr.write(`${err.stack}
+`);
+      return 99;
+    }
+  }
+  if (args.command === "chat") {
+    try {
+      return await runChat(args.chatArgv ?? []);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[kody2] fatal: ${msg}
+`);
+      if (err instanceof Error && err.stack) process.stderr.write(`${err.stack}
 `);
       return 99;
     }