@kody-ade/kody-engine 0.2.32 → 0.2.33

package/dist/bin/kody2.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.2.32",
+  version: "0.2.33",
   description: "kody2 \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -50,81 +50,115 @@ var package_default = {
 };
 
 // src/chat-cli.ts
-import { execFileSync as execFileSync16 } from "child_process";
-import * as fs19 from "fs";
-import * as path16 from "path";
+import * as path14 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`);
+// src/chat/pull.ts
+var PullError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "PullError";
+  }
+  status;
+};
+function createPullClient(opts) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const parsed = parseUrl(opts.baseUrl);
+  const token = opts.token ?? parsed.token;
+  if (!token) {
+    throw new PullError("session token not provided (expected inline ?token= in dashboardUrl)");
+  }
+  return async function pull(since, timeoutMs) {
+    const url = new URL(parsed.origin);
+    url.pathname = "/api/kody/chat/pull";
+    url.searchParams.set("sessionId", opts.sessionId);
+    url.searchParams.set("since", String(since));
+    url.searchParams.set("timeoutMs", String(timeoutMs));
+    url.searchParams.set("token", token);
+    const abort = AbortSignal.timeout(timeoutMs + 1e4);
+    const res = await fetchFn(url.toString(), {
+      method: "GET",
+      headers: { authorization: `Bearer ${token}` },
+      signal: abort
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new PullError(`pull ${url.pathname} \u2192 ${res.status}: ${body.slice(0, 200)}`, res.status);
+    }
+    const data = await res.json();
+    return data;
+  };
 }
-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)}
-`);
+function parseUrl(baseUrl) {
+  try {
+    const u = new URL(baseUrl);
+    const token = u.searchParams.get("token");
+    const origin = `${u.protocol}//${u.host}${u.pathname !== "/" ? u.pathname : ""}`.replace(/\/$/, "");
+    return { origin: origin || u.origin, token };
+  } catch {
+    return { origin: baseUrl, token: null };
   }
-};
+}
+
+// src/chat/events.ts
 var HttpSink = class {
-  constructor(baseUrl, sessionId, logger = {
+  constructor(baseUrl, sessionId, token, fetchFn = fetch, logger = {
     warn: (m) => process.stderr.write(`[kody2:chat] ${m}
 `)
   }) {
-    this.baseUrl = baseUrl;
     this.sessionId = sessionId;
+    this.fetchFn = fetchFn;
     this.logger = logger;
+    const parsed = parseUrl(baseUrl);
+    this.origin = parsed.origin;
+    const resolved = token ?? parsed.token;
+    if (!resolved) {
+      throw new Error("HttpSink: session token not provided (expected inline ?token= in baseUrl)");
+    }
+    this.token = resolved;
   }
-  baseUrl;
   sessionId;
+  fetchFn;
   logger;
+  origin;
+  token;
   async emit(event) {
-    const url = withSessionParam(this.baseUrl, this.sessionId);
+    const url = new URL(this.origin);
+    url.pathname = "/api/kody/events/ingest";
+    url.searchParams.set("sessionId", this.sessionId);
+    url.searchParams.set("token", this.token);
     try {
-      const res = await fetch(url, {
+      const res = await this.fetchFn(url.toString(), {
         method: "POST",
-        headers: { "content-type": "application/json" },
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.token}`
+        },
         body: JSON.stringify(event),
         signal: AbortSignal.timeout(5e3)
       });
       if (!res.ok) {
-        this.logger.warn(`HttpSink POST ${url} \u2192 ${res.status}`);
+        this.logger.warn(`HttpSink POST ${url.pathname} \u2192 ${res.status}`);
       }
     } catch (err) {
-      this.logger.warn(`HttpSink POST ${url} failed: ${err instanceof Error ? err.message : String(err)}`);
+      this.logger.warn(
+        `HttpSink POST ${url.pathname} 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 fs3 from "fs";
-import * as path3 from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
 // src/config.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs from "fs";
+import * as path from "path";
 var LITELLM_DEFAULT_PORT = 4e3;
 var LITELLM_DEFAULT_URL = `http://localhost:${LITELLM_DEFAULT_PORT}`;
 function parseProviderModel(s) {
@@ -142,13 +176,13 @@ function needsLitellmProxy(model) {
   return model.provider !== "claude" && model.provider !== "anthropic";
 }
 function loadConfig(projectDir = process.cwd()) {
-  const configPath = path2.join(projectDir, "kody.config.json");
-  if (!fs2.existsSync(configPath)) {
+  const configPath = path.join(projectDir, "kody.config.json");
+  if (!fs.existsSync(configPath)) {
     throw new Error(`kody.config.json not found at ${configPath}`);
   }
   let raw;
   try {
-    raw = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    raw = JSON.parse(fs.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}`);
@@ -325,10 +359,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 ?? 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 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 env = {
     ...process.env,
     SKIP_HOOKS: "1",
@@ -359,6 +393,9 @@ async function runAgent(opts) {
     if (typeof opts.maxTurns === "number" && opts.maxTurns > 0) {
       queryOptions.maxTurns = opts.maxTurns;
     }
+    if (typeof opts.maxThinkingTokens === "number" && opts.maxThinkingTokens > 0) {
+      queryOptions.maxThinkingTokens = opts.maxThinkingTokens;
+    }
     if (typeof opts.systemPromptAppend === "string" && opts.systemPromptAppend.length > 0) {
       queryOptions.systemPrompt = { type: "preset", preset: "claude_code", append: opts.systemPromptAppend };
     }
@@ -400,53 +437,6 @@ 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",
@@ -455,20 +445,15 @@ var CHAT_SYSTEM_PROMPT = [
   "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);
+var DEFAULT_IDLE_TIMEOUT_MS = 3 * 60 * 1e3;
+var DEFAULT_HARD_TIMEOUT_MS = 5 * 60 * 60 * 1e3;
+var DEFAULT_PULL_TIMEOUT_MS = 25e3;
+async function runChatSession(opts) {
+  const now = opts.now ?? (() => Date.now());
+  const idleTimeoutMs = opts.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+  const hardTimeoutMs = opts.hardTimeoutMs ?? DEFAULT_HARD_TIMEOUT_MS;
+  const pullTimeoutMs = opts.pullTimeoutMs ?? DEFAULT_PULL_TIMEOUT_MS;
+  const systemPrompt = opts.systemPrompt ?? CHAT_SYSTEM_PROMPT;
   const invoke = opts.invokeAgent ?? ((p) => runAgent({
     prompt: p,
     model: opts.model,
@@ -477,34 +462,68 @@ async function runChatTurn(opts) {
     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 history = [];
+  let since = 0;
+  let lastActivityAt = now();
+  const startedAt = now();
+  let turnsProcessed = 0;
+  while (true) {
+    if (now() - startedAt > hardTimeoutMs) {
+      await emit(opts.sink, "chat.done", opts.sessionId, "done", {
+        sessionId: opts.sessionId,
+        reason: "hard-timeout"
+      });
+      return { exitCode: 0, turnsProcessed, reason: "hard-timeout" };
+    }
+    let response;
+    try {
+      response = await opts.pull(since, pullTimeoutMs);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      await emit(opts.sink, "chat.error", opts.sessionId, "error", { error: `pull failed: ${msg}` });
+      return { exitCode: 99, turnsProcessed, reason: `pull failed: ${msg}` };
+    }
+    if (response.turns.length === 0) {
+      if (now() - lastActivityAt > idleTimeoutMs) {
+        await emit(opts.sink, "chat.done", opts.sessionId, "done", {
+          sessionId: opts.sessionId,
+          reason: "idle-timeout"
+        });
+        return { exitCode: 0, turnsProcessed, reason: "idle-timeout" };
+      }
+      continue;
+    }
+    const newUserTurns = response.turns.filter((t) => t.role === "user");
+    for (const t of newUserTurns) history.push(t);
+    since = response.nextSince;
+    if (newUserTurns.length === 0) continue;
+    lastActivityAt = now();
+    const prompt = buildPrompt(history, systemPrompt);
+    let result;
+    try {
+      result = await invoke(prompt);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      await emit(opts.sink, "chat.error", opts.sessionId, "error", { error: msg });
+      return { exitCode: 99, turnsProcessed, reason: msg };
+    }
+    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, turnsProcessed, reason: error };
+    }
+    const reply = result.finalText.trim();
+    const replyTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    history.push({ role: "assistant", content: reply, timestamp: replyTimestamp });
+    turnsProcessed++;
+    lastActivityAt = now();
+    await emit(opts.sink, "chat.message", opts.sessionId, `message-${turnsProcessed}`, {
+      sessionId: opts.sessionId,
+      role: "assistant",
+      content: reply,
+      timestamp: replyTimestamp
+    });
   }
-  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}`;
@@ -526,11 +545,11 @@ async function emit(sink, type, sessionId, suffix, payload) {
 
 // src/kody2-cli.ts
 import { execFileSync as execFileSync15 } from "child_process";
-import * as fs18 from "fs";
-import * as path15 from "path";
+import * as fs16 from "fs";
+import * as path13 from "path";
 
 // src/dispatch.ts
-import * as fs5 from "fs";
+import * as fs3 from "fs";
 function autoDispatch(opts) {
   const explicit = opts?.explicit;
   if (explicit?.issueNumber && explicit.issueNumber > 0) {
@@ -542,10 +561,10 @@ function autoDispatch(opts) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs5.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs3.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs5.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs3.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -614,14 +633,14 @@ function extractFeedback(afterTag) {
 }
 
 // src/executor.ts
-import * as fs17 from "fs";
-import * as path14 from "path";
+import * as fs15 from "fs";
+import * as path12 from "path";
 
 // src/litellm.ts
 import { execFileSync, spawn } from "child_process";
-import * as fs6 from "fs";
+import * as fs4 from "fs";
 import * as os from "os";
-import * as path5 from "path";
+import * as path3 from "path";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -661,20 +680,20 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
       throw new Error("litellm not installed \u2014 run: pip install 'litellm[proxy]'");
     }
   }
-  const configPath = path5.join(os.tmpdir(), `kody2-litellm-${Date.now()}.yaml`);
-  fs6.writeFileSync(configPath, generateLitellmConfigYaml(model));
+  const configPath = path3.join(os.tmpdir(), `kody2-litellm-${Date.now()}.yaml`);
+  fs4.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 = path5.join(os.tmpdir(), `kody2-litellm-${Date.now()}.log`);
-  const outFd = fs6.openSync(logPath, "w");
+  const logPath = path3.join(os.tmpdir(), `kody2-litellm-${Date.now()}.log`);
+  const outFd = fs4.openSync(logPath, "w");
   const child = spawn(cmd, args, {
     stdio: ["ignore", outFd, outFd],
     detached: true,
     env: stripBlockingEnv({ ...process.env, ...dotenvVars })
   });
-  fs6.closeSync(outFd);
+  fs4.closeSync(outFd);
   for (let i = 0; i < 30; i++) {
     await new Promise((r) => setTimeout(r, 2e3));
     if (await checkLitellmHealth(url)) {
@@ -691,7 +710,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   }
   let logTail = "";
   try {
-    logTail = fs6.readFileSync(logPath, "utf-8").slice(-2e3);
+    logTail = fs4.readFileSync(logPath, "utf-8").slice(-2e3);
   } catch {
   }
   try {
@@ -702,10 +721,10 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
 ${logTail}`);
 }
 function readDotenvApiKeys(projectDir) {
-  const dotenvPath = path5.join(projectDir, ".env");
-  if (!fs6.existsSync(dotenvPath)) return {};
+  const dotenvPath = path3.join(projectDir, ".env");
+  if (!fs4.existsSync(dotenvPath)) return {};
   const result = {};
-  for (const rawLine of fs6.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  for (const rawLine of fs4.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)=(.*)$/);
@@ -728,8 +747,8 @@ function stripBlockingEnv(env) {
 }
 
 // src/profile.ts
-import * as fs7 from "fs";
-import * as path6 from "path";
+import * as fs5 from "fs";
+import * as path4 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 {
@@ -742,12 +761,12 @@ var ProfileError = class extends Error {
   profilePath;
 };
 function loadProfile(profilePath) {
-  if (!fs7.existsSync(profilePath)) {
+  if (!fs5.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs7.readFileSync(profilePath, "utf-8"));
+    raw = JSON.parse(fs5.readFileSync(profilePath, "utf-8"));
   } catch (err) {
     throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -771,7 +790,7 @@ function loadProfile(profilePath) {
     outputContract: r.outputContract,
     inputArtifacts: parseInputArtifacts(profilePath, r.input),
     outputArtifacts: parseOutputArtifacts(profilePath, r.output),
-    dir: path6.dirname(profilePath)
+    dir: path4.dirname(profilePath)
   };
   return profile;
 }
@@ -837,6 +856,7 @@ function parseClaudeCode(p, raw) {
     model: typeof r.model === "string" ? r.model : "inherit",
     permissionMode,
     maxTurns: typeof r.maxTurns === "number" ? r.maxTurns : null,
+    maxThinkingTokens: typeof r.maxThinkingTokens === "number" ? r.maxThinkingTokens : null,
     systemPromptAppend: typeof r.systemPromptAppend === "string" ? r.systemPromptAppend : null,
     tools,
     hooks: Array.isArray(r.hooks) ? r.hooks : [],
@@ -950,21 +970,21 @@ function parseScriptList(p, key, raw) {
 }
 
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs8 from "fs";
+import * as fs6 from "fs";
 import * as os2 from "os";
-import * as path7 from "path";
+import * as path5 from "path";
 function getPluginsCatalogRoot() {
-  const here = path7.dirname(new URL(import.meta.url).pathname);
+  const here = path5.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path7.join(here, "..", "plugins"),
+    path5.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path7.join(here, "..", "..", "plugins"),
+    path5.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path7.join(here, "..", "..", "src", "plugins")
+    path5.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs8.existsSync(c) && fs8.statSync(c).isDirectory()) return c;
+    if (fs6.existsSync(c) && fs6.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
@@ -974,50 +994,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 = path7.join(os2.tmpdir(), `kody2-synth-${runId}`);
-  fs8.mkdirSync(path7.join(root, ".claude-plugin"), { recursive: true });
+  const root = path5.join(os2.tmpdir(), `kody2-synth-${runId}`);
+  fs6.mkdirSync(path5.join(root, ".claude-plugin"), { recursive: true });
   if (cc.skills.length > 0) {
-    const dst = path7.join(root, "skills");
-    fs8.mkdirSync(dst, { recursive: true });
+    const dst = path5.join(root, "skills");
+    fs6.mkdirSync(dst, { recursive: true });
     for (const name of cc.skills) {
-      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));
+      const src = path5.join(catalog, "skills", name);
+      if (!fs6.existsSync(src)) throw new Error(`buildSyntheticPlugin: skill not found in catalog: ${name}`);
+      copyDir(src, path5.join(dst, name));
     }
   }
   if (cc.commands.length > 0) {
-    const dst = path7.join(root, "commands");
-    fs8.mkdirSync(dst, { recursive: true });
+    const dst = path5.join(root, "commands");
+    fs6.mkdirSync(dst, { recursive: true });
     for (const name of cc.commands) {
-      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`));
+      const src = path5.join(catalog, "commands", `${name}.md`);
+      if (!fs6.existsSync(src)) throw new Error(`buildSyntheticPlugin: command not found in catalog: ${name}`);
+      fs6.copyFileSync(src, path5.join(dst, `${name}.md`));
     }
   }
   if (cc.subagents.length > 0) {
-    const dst = path7.join(root, "agents");
-    fs8.mkdirSync(dst, { recursive: true });
+    const dst = path5.join(root, "agents");
+    fs6.mkdirSync(dst, { recursive: true });
     for (const name of cc.subagents) {
-      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`));
+      const src = path5.join(catalog, "agents", `${name}.md`);
+      if (!fs6.existsSync(src)) throw new Error(`buildSyntheticPlugin: subagent not found in catalog: ${name}`);
+      fs6.copyFileSync(src, path5.join(dst, `${name}.md`));
     }
   }
   if (cc.hooks.length > 0) {
-    const dst = path7.join(root, "hooks");
-    fs8.mkdirSync(dst, { recursive: true });
+    const dst = path5.join(root, "hooks");
+    fs6.mkdirSync(dst, { recursive: true });
     const merged = { hooks: {} };
     for (const name of cc.hooks) {
-      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"));
+      const src = path5.join(catalog, "hooks", `${name}.json`);
+      if (!fs6.existsSync(src)) throw new Error(`buildSyntheticPlugin: hook not found in catalog: ${name}`);
+      const parsed = JSON.parse(fs6.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);
       }
     }
-    fs8.writeFileSync(path7.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+    fs6.writeFileSync(path5.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
   }
   const manifest = {
@@ -1028,17 +1048,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`);
-  fs8.writeFileSync(path7.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+  fs6.writeFileSync(path5.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
   ctx.data.syntheticPluginPath = root;
 };
 function copyDir(src, dst) {
-  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);
+  fs6.mkdirSync(dst, { recursive: true });
+  for (const ent of fs6.readdirSync(src, { withFileTypes: true })) {
+    const s = path5.join(src, ent.name);
+    const d = path5.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs8.copyFileSync(s, d);
+    else if (ent.isFile()) fs6.copyFileSync(s, d);
   }
 }
 
@@ -1104,18 +1124,18 @@ function formatMissesForFeedback(misses) {
 }
 
 // src/prompt.ts
-import * as fs9 from "fs";
-import * as path8 from "path";
+import * as fs7 from "fs";
+import * as path6 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 = path8.join(projectDir, rel);
-    if (!fs9.existsSync(abs)) continue;
+    const abs = path6.join(projectDir, rel);
+    if (!fs7.existsSync(abs)) continue;
     let content;
     try {
-      content = fs9.readFileSync(abs, "utf-8");
+      content = fs7.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -1236,8 +1256,8 @@ import { execFileSync as execFileSync4 } from "child_process";
 
 // src/commit.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs8 from "fs";
+import * as path7 from "path";
 var FORBIDDEN_PATH_PREFIXES = [
   ".kody/",
   ".kody-engine/",
@@ -1292,18 +1312,18 @@ function tryGit(args, cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path9.join(cwd ?? process.cwd(), ".git");
-  if (!fs10.existsSync(gitDir)) return aborted;
-  if (fs10.existsSync(path9.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path7.join(cwd ?? process.cwd(), ".git");
+  if (!fs8.existsSync(gitDir)) return aborted;
+  if (fs8.existsSync(path7.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs10.existsSync(path9.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs8.existsSync(path7.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs10.existsSync(path9.join(gitDir, "REVERT_HEAD"))) {
+  if (fs8.existsSync(path7.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs10.existsSync(path9.join(gitDir, "rebase-merge")) || fs10.existsSync(path9.join(gitDir, "rebase-apply"))) {
+  if (fs8.existsSync(path7.join(gitDir, "rebase-merge")) || fs8.existsSync(path7.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -1345,7 +1365,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs10.existsSync(path9.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs8.existsSync(path7.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -1440,20 +1460,20 @@ function defaultCommitMessage(mode, data) {
 }
 
 // src/scripts/composePrompt.ts
-import * as fs11 from "fs";
-import * as path10 from "path";
+import * as fs9 from "fs";
+import * as path8 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 ? path10.join(profile.dir, explicit) : null,
-    mode ? path10.join(profile.dir, "prompts", `${mode}.md`) : null,
-    path10.join(profile.dir, "prompt.md")
+    explicit ? path8.join(profile.dir, explicit) : null,
+    mode ? path8.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path8.join(profile.dir, "prompt.md")
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
-    if (fs11.existsSync(c)) {
+    if (fs9.existsSync(c)) {
       templatePath = c;
       break;
     }
@@ -1461,7 +1481,7 @@ var composePrompt = async (ctx, profile) => {
   if (!templatePath) {
     throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
   }
-  const template = fs11.readFileSync(templatePath, "utf-8");
+  const template = fs9.readFileSync(templatePath, "utf-8");
   const tokens = {
     ...stringifyAll(ctx.args, "args."),
     ...stringifyAll(ctx.data, ""),
@@ -1936,7 +1956,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd) {
 
 // src/gha.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import * as fs12 from "fs";
+import * as fs10 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -1947,10 +1967,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs12.existsSync(eventPath)) return;
+  if (!eventPath || !fs10.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs12.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs10.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -2176,35 +2196,35 @@ function tryPostPr2(prNumber, body, cwd) {
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import * as fs14 from "fs";
-import * as path12 from "path";
+import * as fs12 from "fs";
+import * as path10 from "path";
 
 // src/registry.ts
-import * as fs13 from "fs";
-import * as path11 from "path";
+import * as fs11 from "fs";
+import * as path9 from "path";
 function getExecutablesRoot() {
-  const here = path11.dirname(new URL(import.meta.url).pathname);
+  const here = path9.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path11.join(here, "executables"),
+    path9.join(here, "executables"),
     // dev: src/
-    path11.join(here, "..", "executables"),
+    path9.join(here, "..", "executables"),
     // built: dist/bin → dist/executables
-    path11.join(here, "..", "src", "executables")
+    path9.join(here, "..", "src", "executables")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs13.existsSync(c) && fs13.statSync(c).isDirectory()) return c;
+    if (fs11.existsSync(c) && fs11.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function listExecutables(root = getExecutablesRoot()) {
-  if (!fs13.existsSync(root)) return [];
-  const entries = fs13.readdirSync(root, { withFileTypes: true });
+  if (!fs11.existsSync(root)) return [];
+  const entries = fs11.readdirSync(root, { withFileTypes: true });
   const out = [];
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
-    const profilePath = path11.join(root, ent.name, "profile.json");
-    if (fs13.existsSync(profilePath) && fs13.statSync(profilePath).isFile()) {
+    const profilePath = path9.join(root, ent.name, "profile.json");
+    if (fs11.existsSync(profilePath) && fs11.statSync(profilePath).isFile()) {
       out.push({ name: ent.name, profilePath });
     }
   }
@@ -2212,8 +2232,8 @@ function listExecutables(root = getExecutablesRoot()) {
 }
 function hasExecutable(name, root = getExecutablesRoot()) {
   if (!isSafeName(name)) return false;
-  const profilePath = path11.join(root, name, "profile.json");
-  return fs13.existsSync(profilePath) && fs13.statSync(profilePath).isFile();
+  const profilePath = path9.join(root, name, "profile.json");
+  return fs11.existsSync(profilePath) && fs11.statSync(profilePath).isFile();
 }
 function isSafeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
@@ -2242,9 +2262,9 @@ function parseGenericFlags(argv) {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  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";
+  if (fs12.existsSync(path10.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs12.existsSync(path10.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs12.existsSync(path10.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -2365,22 +2385,22 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path12.join(cwd, "kody.config.json");
-  if (fs14.existsSync(configPath) && !force) {
+  const configPath = path10.join(cwd, "kody.config.json");
+  if (fs12.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs14.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs12.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path12.join(cwd, ".github", "workflows");
-  const workflowPath = path12.join(workflowDir, "kody2.yml");
-  if (fs14.existsSync(workflowPath) && !force) {
+  const workflowDir = path10.join(cwd, ".github", "workflows");
+  const workflowPath = path10.join(workflowDir, "kody2.yml");
+  if (fs12.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody2.yml");
   } else {
-    fs14.mkdirSync(workflowDir, { recursive: true });
-    fs14.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs12.mkdirSync(workflowDir, { recursive: true });
+    fs12.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody2.yml");
   }
   for (const exe of listExecutables()) {
@@ -2391,12 +2411,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path12.join(workflowDir, `kody2-${exe.name}.yml`);
-    if (fs14.existsSync(target) && !force) {
+    const target = path10.join(workflowDir, `kody2-${exe.name}.yml`);
+    if (fs12.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody2-${exe.name}.yml`);
       continue;
     }
-    fs14.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs12.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody2-${exe.name}.yml`);
   }
   return { wrote, skipped };
@@ -2903,8 +2923,8 @@ REVIEW_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.
 
 // src/scripts/releaseFlow.ts
 import { execFileSync as execFileSync11, spawnSync } from "child_process";
-import * as fs15 from "fs";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as path11 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])`);
@@ -2920,12 +2940,12 @@ function bumpVersion(current, bump) {
   return `${major}.${minor}.${patch}`;
 }
 function updateVersionInFile(file, newVersion, cwd) {
-  const abs = path13.join(cwd, file);
-  if (!fs15.existsSync(abs)) return false;
-  const content = fs15.readFileSync(abs, "utf-8");
+  const abs = path11.join(cwd, file);
+  if (!fs13.existsSync(abs)) return false;
+  const content = fs13.readFileSync(abs, "utf-8");
   const updated = content.replace(/"version"\s*:\s*"[^"]+"/, `"version": "${newVersion}"`);
   if (updated === content) return false;
-  fs15.writeFileSync(abs, updated);
+  fs13.writeFileSync(abs, updated);
   return true;
 }
 function generateChangelog(cwd, newVersion, lastTag) {
@@ -2973,19 +2993,19 @@ function generateChangelog(cwd, newVersion, lastTag) {
   return parts.join("\n");
 }
 function prependChangelog(cwd, entry) {
-  const p = path13.join(cwd, "CHANGELOG.md");
+  const p = path11.join(cwd, "CHANGELOG.md");
   const header = "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n";
-  if (fs15.existsSync(p)) {
-    const prior = fs15.readFileSync(p, "utf-8");
+  if (fs13.existsSync(p)) {
+    const prior = fs13.readFileSync(p, "utf-8");
     if (/^#\s*Changelog\b/m.test(prior)) {
       const idx = prior.indexOf("\n", prior.indexOf("# Changelog"));
-      fs15.writeFileSync(p, `${prior.slice(0, idx + 1)}
+      fs13.writeFileSync(p, `${prior.slice(0, idx + 1)}
 ${entry}${prior.slice(idx + 1)}`);
     } else {
-      fs15.writeFileSync(p, `${header}${entry}${prior}`);
+      fs13.writeFileSync(p, `${header}${entry}${prior}`);
     }
   } else {
-    fs15.writeFileSync(p, `${header}${entry}`);
+    fs13.writeFileSync(p, `${header}${entry}`);
   }
 }
 function git3(args, cwd, timeout = 6e4) {
@@ -3036,13 +3056,13 @@ var releaseFlow = async (ctx) => {
 };
 async function runPrepare(args) {
   const { cwd, bump, dryRun, versionFiles, ctx } = args;
-  const pkgPath = path13.join(cwd, "package.json");
-  if (!fs15.existsSync(pkgPath)) {
+  const pkgPath = path11.join(cwd, "package.json");
+  if (!fs13.existsSync(pkgPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release prepare: package.json not found";
     return;
   }
-  const pkg = JSON.parse(fs15.readFileSync(pkgPath, "utf-8"));
+  const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
   if (typeof pkg.version !== "string") {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release prepare: package.json has no version";
@@ -3113,8 +3133,8 @@ Merge this and then run \`kody2 release --mode finalize\`.`;
 }
 async function runFinalize(args) {
   const { cwd, dryRun, timeoutMs, releaseCfg, ctx } = args;
-  const pkgPath = path13.join(cwd, "package.json");
-  const pkg = JSON.parse(fs15.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path11.join(cwd, "package.json");
+  const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
   if (typeof pkg.version !== "string") {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release finalize: package.json has no version";
@@ -3792,7 +3812,7 @@ var watchStalePrsFlow = async (ctx) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs16 from "fs";
+import * as fs14 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -3814,7 +3834,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs16.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs14.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -3962,9 +3982,9 @@ async function runExecutable(profileName, input) {
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path14.join(input.cwd, ".kody2");
+  const ndjsonDir = path12.join(input.cwd, ".kody2");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path14.isAbsolute(p) ? p : path14.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path12.isAbsolute(p) ? p : path12.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -3980,6 +4000,7 @@ async function runExecutable(profileName, input) {
       mcpServers: profile.claudeCode.mcpServers,
       pluginPaths: pluginPaths.length > 0 ? pluginPaths : void 0,
       maxTurns: profile.claudeCode.maxTurns,
+      maxThinkingTokens: profile.claudeCode.maxThinkingTokens,
       systemPromptAppend: profile.claudeCode.systemPromptAppend,
       settingSources: profile.claudeCode.settingSources
     });
@@ -4030,17 +4051,17 @@ async function runExecutable(profileName, input) {
   }
 }
 function resolveProfilePath(profileName) {
-  const here = path14.dirname(new URL(import.meta.url).pathname);
+  const here = path12.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path14.join(here, "executables", profileName, "profile.json"),
+    path12.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path14.join(here, "..", "executables", profileName, "profile.json"),
+    path12.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path14.join(here, "..", "src", "executables", profileName, "profile.json")
+    path12.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs17.existsSync(c)) return c;
+    if (fs15.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -4216,9 +4237,9 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  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";
+  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";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -4298,11 +4319,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path15.join(cwd, ".kody2", "last-run.jsonl");
+  const logPath = path13.join(cwd, ".kody2", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs18.existsSync(logPath)) {
-      const content = fs18.readFileSync(logPath, "utf-8");
+    if (fs16.existsSync(logPath)) {
+      const content = fs16.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -4327,7 +4348,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path15.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path13.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -4420,23 +4441,23 @@ 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>]
+  kody2 chat [--session <id>] [--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.
+All inputs may also come from env: SESSION_ID, MODEL, DASHBOARD_URL.
+CLI flags take precedence over env. SESSION_ID and DASHBOARD_URL are required
+(the runner long-polls the dashboard for user turns and pushes events back).
 
 Exit codes:
-  0   reply emitted successfully
-  64  bad inputs (missing session, empty history)
-  99  runtime failure (agent crash, LiteLLM failure)
+  0   session exited cleanly (idle or hard timeout)
+  64  bad inputs
+  99  runtime failure (agent crash, pull failure, 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];
@@ -4447,34 +4468,18 @@ function parseChatArgs(argv, env = process.env) {
     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"]) {
+  for (const key of ["sessionId", "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");
+  if (!result.errors.includes("__HELP__")) {
+    if (!result.sessionId) result.errors.push("--session <id> (or SESSION_ID env) is required");
+    if (!result.dashboardUrl) result.errors.push("--dashboard-url <url> (or DASHBOARD_URL 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);
@@ -4482,11 +4487,6 @@ function tryLoadConfig(cwd) {
     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);
@@ -4500,8 +4500,9 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path16.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path14.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
+  const dashboardUrl = args.dashboardUrl;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
     process.stdout.write(`\u2192 kody2: unpacked ${unpackedSecrets} secret(s) from ALL_SECRETS
@@ -4527,13 +4528,20 @@ ${CHAT_HELP}`);
       return 99;
     }
   }
+  let sink;
+  try {
+    sink = new HttpSink(dashboardUrl, sessionId);
+  } catch (err) {
+    process.stderr.write(`error: ${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({
+    await sink.emit({
       event: "chat.error",
       payload: { sessionId, error: `litellm startup failed: ${msg}` },
       runId: makeRunId(sessionId, "error"),
@@ -4541,21 +4549,33 @@ ${CHAT_HELP}`);
     });
     return 99;
   }
-  const sessionFile = sessionFilePath(cwd, sessionId);
-  if (args.initMessage) seedInitialMessage(sessionFile, args.initMessage);
-  const sink = buildSink(cwd, sessionId, args.dashboardUrl);
+  let pull;
   try {
-    const result = await runChatTurn({
+    pull = createPullClient({ baseUrl: dashboardUrl, sessionId });
+  } catch (err) {
+    process.stderr.write(`error: ${err instanceof Error ? err.message : String(err)}
+`);
+    try {
+      litellm?.kill();
+    } catch {
+    }
+    return 64;
+  }
+  process.stdout.write(`\u2192 kody2 chat: session ${sessionId}, model ${model.provider}/${model.model}
+`);
+  try {
+    const result = await runChatSession({
       sessionId,
-      sessionFile,
       cwd,
       model,
       litellmUrl: litellm?.url ?? null,
       sink,
+      pull,
       verbose: args.verbose,
       quiet: args.quiet
     });
-    commitChatFiles(cwd, sessionId, args.verbose ?? false);
+    process.stdout.write(`\u2192 kody2 chat: exited (${result.reason ?? "ok"}) after ${result.turnsProcessed} turn(s)
+`);
     return result.exitCode;
   } finally {
     try {

package/dist/executables/types.ts

@@ -87,6 +87,8 @@ export interface ClaudeCodeSpec {
   permissionMode: "default" | "acceptEdits" | "plan" | "bypassPermissions"
   /** null = unbounded. */
   maxTurns: number | null
+  /** Extended-thinking token budget. null = SDK default. */
+  maxThinkingTokens: number | null
   /** Text appended on top of Claude Code's baseline system prompt. */
   systemPromptAppend: string | null
   /** SDK built-in tools this executable is allowed to use (capability pack). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.2.32",
+  "version": "0.2.33",
   "description": "kody2 — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",
@@ -12,6 +12,18 @@
     "templates",
     "kody.config.schema.json"
   ],
+  "scripts": {
+    "kody2": "tsx bin/kody2.ts",
+    "build": "tsup && node scripts/copy-assets.cjs",
+    "test": "vitest run tests/unit tests/int --no-coverage",
+    "test:e2e": "vitest run tests/e2e --no-coverage",
+    "test:all": "vitest run tests --no-coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "format": "biome format --write",
+    "prepublishOnly": "pnpm build"
+  },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.2.92"
   },
@@ -31,16 +43,5 @@
     "url": "git+https://github.com/aharonyaircohen/kody-engine.git"
   },
   "homepage": "https://github.com/aharonyaircohen/kody-engine",
-  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues",
-  "scripts": {
-    "kody2": "tsx bin/kody2.ts",
-    "build": "tsup && node scripts/copy-assets.cjs",
-    "test": "vitest run tests/unit tests/int --no-coverage",
-    "test:e2e": "vitest run tests/e2e --no-coverage",
-    "test:all": "vitest run tests --no-coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "biome check",
-    "lint:fix": "biome check --write",
-    "format": "biome format --write"
-  }
-}
+  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues"
+}