@jun133/kitty 0.0.14 → 0.0.16

package/dist/{chunk-KROQCOWD.mjs → chunk-7FOTCUIH.mjs}

@@ -1,27 +1,20 @@
 import {
-  PROJECT_STATE_DIR_NAME,
-  PROJECT_STATE_IGNORE_FILE_NAME,
   applyCurrentTurnFrame,
   buildRunTurnResult,
+  collapseContentParts,
   createEmptyAssistantResponseTransition,
   createExecutionWaitYieldTransition,
   createFinalizeTransition,
   createInternalReminder,
   createMessage,
-  createProviderClientPool,
   createProviderRecoveryTransition,
   createToolMessage,
-  ensureProjectStateDirectories,
   expandStartToToolBoundary,
-  fetchAssistantResponse,
   fingerprintFocus,
   formatSessionMemorySectionList,
   formatSessionMemorySectionTemplate,
   formatTodoBlock,
-  getProjectStatePaths,
-  isAbortError,
   isInternalMessage,
-  isRetryableApiError,
   normalizeCheckpoint,
   normalizeText,
   normalizeTodoItems,
@@ -31,20 +24,20 @@ import {
   noteCheckpointTransition,
   noteCheckpointTurnInput,
   noteSessionDiff,
+  readReasoningContent,
   readUserInput,
-  recordObservabilityEvent,
   recordSessionWorksetFile,
+  resolveModelProfile,
+  resolveProviderCapabilities,
   shouldIncludeStoredAssistantReasoning,
-  sleepWithSignal,
   sliceCurrentUserInputFrame,
   takeLastUnique,
-  throwIfAborted,
   updateSessionMemory
-} from "./chunk-3KMC6H5K.mjs";
+} from "./chunk-C3MFBHV3.mjs";
 
 // src/context/projectContext.ts
-import fs5 from "fs/promises";
-import path6 from "path";
+import fs6 from "fs/promises";
+import path7 from "path";
 
 // src/context/repoRoots.ts
 import fs from "fs/promises";
@@ -248,13 +241,67 @@ function formatList(values) {
 }
 
 // src/skills/discovery.ts
-import fs4 from "fs/promises";
-import path5 from "path";
+import fs5 from "fs/promises";
+import path6 from "path";
 import fg2 from "fast-glob";
 
 // src/utils/ignore.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+
+// src/project/statePaths.ts
 import fs3 from "fs/promises";
 import path3 from "path";
+var PROJECT_STATE_DIR_NAME = ".kitty";
+var PROJECT_STATE_ENV_FILE_NAME = ".env";
+var PROJECT_STATE_ENV_EXAMPLE_FILE_NAME = ".env.example";
+var PROJECT_STATE_IGNORE_FILE_NAME = ".kittyignore";
+var PRESERVED_PROJECT_STATE_ENTRY_NAMES = [
+  PROJECT_STATE_ENV_FILE_NAME,
+  PROJECT_STATE_ENV_EXAMPLE_FILE_NAME
+];
+function getProjectStatePaths(rootDir) {
+  const normalizedRoot = path3.resolve(rootDir);
+  const kittyDir = path3.join(normalizedRoot, PROJECT_STATE_DIR_NAME);
+  const extensionsDir = path3.join(kittyDir, "extensions");
+  const memoryDir = path3.join(kittyDir, "memory");
+  const observabilityDir = path3.join(kittyDir, "observability");
+  return {
+    rootDir: normalizedRoot,
+    kittyDir,
+    cacheDir: path3.join(kittyDir, "cache"),
+    sessionsDir: path3.join(kittyDir, "sessions"),
+    changesDir: path3.join(kittyDir, "changes"),
+    eventsDir: path3.join(kittyDir, "events"),
+    extensionsDir,
+    memoryDir,
+    evidenceMemoryDir: path3.join(memoryDir, "evidence"),
+    projectMemoryDir: path3.join(memoryDir, "project"),
+    sessionMemoryDir: path3.join(memoryDir, "sessions"),
+    userMemoryDir: path3.join(memoryDir, "user"),
+    controlPlaneLedgerFile: path3.join(kittyDir, "control-plane.sqlite"),
+    observabilityDir,
+    observabilityEventsDir: path3.join(observabilityDir, "events"),
+    observabilityCrashesDir: path3.join(observabilityDir, "crashes")
+  };
+}
+async function ensureProjectStateDirectories(rootDir) {
+  const paths = getProjectStatePaths(rootDir);
+  await fs3.mkdir(paths.extensionsDir, { recursive: true });
+  await fs3.mkdir(paths.cacheDir, { recursive: true });
+  await fs3.mkdir(paths.sessionsDir, { recursive: true });
+  await fs3.mkdir(paths.changesDir, { recursive: true });
+  await fs3.mkdir(paths.eventsDir, { recursive: true });
+  await fs3.mkdir(paths.evidenceMemoryDir, { recursive: true });
+  await fs3.mkdir(paths.projectMemoryDir, { recursive: true });
+  await fs3.mkdir(paths.sessionMemoryDir, { recursive: true });
+  await fs3.mkdir(paths.userMemoryDir, { recursive: true });
+  await fs3.mkdir(paths.observabilityEventsDir, { recursive: true });
+  await fs3.mkdir(paths.observabilityCrashesDir, { recursive: true });
+  return paths;
+}
+
+// src/utils/ignore.ts
 var BUILTIN_PATTERNS = [
   ".git/",
   "node_modules/",
@@ -268,11 +315,11 @@ async function loadProjectIgnoreRules(rootDir, cwd) {
   })).filter((rule) => Boolean(rule));
   const candidateFiles = uniqueIgnoreFiles([
     {
-      path: path3.join(rootDir, PROJECT_STATE_DIR_NAME, PROJECT_STATE_IGNORE_FILE_NAME),
+      path: path4.join(rootDir, PROJECT_STATE_DIR_NAME, PROJECT_STATE_IGNORE_FILE_NAME),
       baseDir: rootDir
     },
     {
-      path: path3.join(cwd, PROJECT_STATE_DIR_NAME, PROJECT_STATE_IGNORE_FILE_NAME),
+      path: path4.join(cwd, PROJECT_STATE_DIR_NAME, PROJECT_STATE_IGNORE_FILE_NAME),
       baseDir: cwd
     }
   ]);
@@ -332,7 +379,7 @@ function buildFastGlobIgnorePatterns(baseDir, rules) {
 }
 async function tryReadUtf8File(filePath) {
   try {
-    return await fs3.readFile(filePath, "utf8");
+    return await fs4.readFile(filePath, "utf8");
   } catch (error) {
     const errno = error;
     if (errno.code === "ENOENT") {
@@ -383,11 +430,11 @@ function compileIgnoreRule(rawPattern, options) {
   };
 }
 function toRelativePosix(baseDir, targetPath) {
-  const relativePath = path3.relative(path3.resolve(baseDir), path3.resolve(targetPath));
+  const relativePath = path4.relative(path4.resolve(baseDir), path4.resolve(targetPath));
   if (!relativePath || relativePath === ".") {
     return "";
   }
-  if (relativePath.startsWith("..") || path3.isAbsolute(relativePath)) {
+  if (relativePath.startsWith("..") || path4.isAbsolute(relativePath)) {
     return null;
   }
   return relativePath.replace(/\\/g, "/");
@@ -453,21 +500,21 @@ function uniqueIgnoreFiles(files) {
   const seen = /* @__PURE__ */ new Set();
   const unique = [];
   for (const file of files) {
-    const normalizedPath = path3.normalize(file.path);
+    const normalizedPath = path4.normalize(file.path);
     if (seen.has(normalizedPath)) {
       continue;
     }
     seen.add(normalizedPath);
     unique.push({
       path: normalizedPath,
-      baseDir: path3.resolve(file.baseDir)
+      baseDir: path4.resolve(file.baseDir)
     });
   }
   return unique;
 }
 
 // src/skills/schema.ts
-import path4 from "path";
+import path5 from "path";
 var FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 var SkillSchemaError = class extends Error {
   constructor(message, filePath) {
@@ -487,7 +534,7 @@ function parseSkillSource(text, input) {
   return {
     name,
     description,
-    path: path4.relative(input.rootDir, input.absolutePath) || "SKILL.md",
+    path: path5.relative(input.rootDir, input.absolutePath) || "SKILL.md",
     absolutePath: input.absolutePath,
     body,
     dependencies: parseDependencies(metadata.requires),
@@ -557,12 +604,12 @@ async function discoverSkills(rootDir, cwd, ignoreRules) {
   const seenNames = /* @__PURE__ */ new Map();
   const skills = [];
   for (const skillFile of skillFiles) {
-    const normalizedPath = path5.normalize(skillFile);
+    const normalizedPath = path6.normalize(skillFile);
     if (seenPaths.has(normalizedPath) || isPathIgnored(normalizedPath, ignoreRules)) {
       continue;
     }
     seenPaths.add(normalizedPath);
-    const skill = parseSkillSource(await fs4.readFile(normalizedPath, "utf8"), {
+    const skill = parseSkillSource(await fs5.readFile(normalizedPath, "utf8"), {
       absolutePath: normalizedPath,
       rootDir
     });
@@ -578,7 +625,7 @@ async function discoverSkills(rootDir, cwd, ignoreRules) {
   return skills.sort((left, right) => left.name.localeCompare(right.name));
 }
 async function listSkillResources(skillPath, rootDir, ignoreRules) {
-  const skillDir = path5.dirname(skillPath);
+  const skillDir = path6.dirname(skillPath);
   const files = await fg2([...SKILL_RESOURCE_GLOBS], {
     cwd: skillDir,
     absolute: true,
@@ -592,11 +639,11 @@ async function listSkillResources(skillPath, rootDir, ignoreRules) {
     if (isPathIgnored(file, ignoreRules)) {
       continue;
     }
-    const stat = await fs4.stat(file);
+    const stat = await fs5.stat(file);
     resources.push({
-      path: path5.relative(rootDir, file),
+      path: path6.relative(rootDir, file),
       size: stat.size,
-      kind: readSkillResourceKind(path5.relative(skillDir, file))
+      kind: readSkillResourceKind(path6.relative(skillDir, file))
     });
   }
   return resources;
@@ -643,14 +690,14 @@ function buildSkillPackageHealth(skill) {
 }
 async function findSkillFiles(rootDir, cwd) {
   const candidates = uniquePaths([
-    path5.join(rootDir, "SKILL.md"),
-    path5.join(cwd, "SKILL.md")
+    path6.join(rootDir, "SKILL.md"),
+    path6.join(cwd, "SKILL.md")
   ]);
   const roots = uniquePaths([
-    path5.join(rootDir, ".skills"),
-    path5.join(rootDir, "skills"),
-    path5.join(cwd, ".skills"),
-    path5.join(cwd, "skills")
+    path6.join(rootDir, ".skills"),
+    path6.join(rootDir, "skills"),
+    path6.join(cwd, ".skills"),
+    path6.join(cwd, "skills")
   ]);
   const files = [];
   for (const candidate of candidates) {
@@ -675,20 +722,20 @@ async function findSkillFiles(rootDir, cwd) {
 }
 async function isRegularFile(filePath) {
   try {
-    return (await fs4.stat(filePath)).isFile();
+    return (await fs5.stat(filePath)).isFile();
   } catch {
     return false;
   }
 }
 async function isDirectory2(filePath) {
   try {
-    return (await fs4.stat(filePath)).isDirectory();
+    return (await fs5.stat(filePath)).isDirectory();
   } catch {
     return false;
   }
 }
 function uniquePaths(paths) {
-  return [...new Set(paths.map((item) => path5.normalize(item)))];
+  return [...new Set(paths.map((item) => path6.normalize(item)))];
 }
 
 // src/context/projectContext.ts
@@ -717,8 +764,8 @@ async function getInstructionFiles(rootDir, cwd) {
   const directories = getDirectoriesFromRootToCwd(rootDir, cwd);
   const results = [];
   for (const directory of directories) {
-    const overridePath = path6.join(directory, "AGENTS.override.md");
-    const agentsPath = path6.join(directory, "AGENTS.md");
+    const overridePath = path7.join(directory, "AGENTS.override.md");
+    const agentsPath = path7.join(directory, "AGENTS.md");
     if (await isRegularFile2(overridePath)) {
       results.push(await readInstructionFile(rootDir, overridePath, "AGENTS.override.md"));
       continue;
@@ -730,22 +777,22 @@ async function getInstructionFiles(rootDir, cwd) {
   return results;
 }
 function getDirectoriesFromRootToCwd(rootDir, cwd) {
-  const absoluteRoot = path6.resolve(rootDir);
-  const absoluteCwd = path6.resolve(cwd);
-  const relativePath = path6.relative(absoluteRoot, absoluteCwd);
+  const absoluteRoot = path7.resolve(rootDir);
+  const absoluteCwd = path7.resolve(cwd);
+  const relativePath = path7.relative(absoluteRoot, absoluteCwd);
   if (!relativePath || relativePath === ".") {
     return [absoluteRoot];
   }
-  const parts = relativePath.split(path6.sep).filter(Boolean);
+  const parts = relativePath.split(path7.sep).filter(Boolean);
   const directories = [absoluteRoot];
   for (let index = 0; index < parts.length; index += 1) {
-    directories.push(path6.join(absoluteRoot, ...parts.slice(0, index + 1)));
+    directories.push(path7.join(absoluteRoot, ...parts.slice(0, index + 1)));
   }
   return directories;
 }
 async function isRegularFile2(filePath) {
   try {
-    const stat = await fs5.stat(filePath);
+    const stat = await fs6.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
@@ -754,9 +801,9 @@ async function isRegularFile2(filePath) {
 async function readInstructionFile(rootDir, absolutePath, filename) {
   return {
     path: absolutePath,
-    relativePath: path6.relative(rootDir, absolutePath) || filename,
+    relativePath: path7.relative(rootDir, absolutePath) || filename,
     filename,
-    content: await fs5.readFile(absolutePath, "utf8")
+    content: await fs6.readFile(absolutePath, "utf8")
   };
 }
 function concatInstructionFiles(files, maxBytes) {
@@ -832,7 +879,7 @@ function getErrorMessage(error) {
     return "Environment error: network connection failed; the current provider/base URL is unreachable. Check network, proxy settings, or `KITTY_BASE_URL`.";
   }
   if (status === 404 || lower.includes("returned 404")) {
-    return "User-fixable error: provider returned 404. Check whether `KITTY_BASE_URL` is the correct OpenAI-compatible API base URL.";
+    return "User-fixable error: provider endpoint returned 404. Check `KITTY_PROVIDER`, `KITTY_MODEL`, and `KITTY_BASE_URL` as one provider profile; the selected provider may use Responses instead of Chat Completions.";
   }
   if (typeof status === "number" && status >= 500) {
     return `Provider error: service returned ${status}. Retry later or confirm the provider service is healthy.`;
@@ -884,39 +931,1153 @@ async function handleCompletedAssistantResponse(params) {
       transition: transition2
     };
   }
-  const transition = createFinalizeTransition({
-    changedPaths: params.changedPaths
+  const transition = createFinalizeTransition({
+    changedPaths: params.changedPaths
+  });
+  const session = await params.options.sessionStore.save(
+    noteCheckpointCompleted(
+      await params.options.sessionStore.appendMessages(params.session, [assistantMessage]),
+      transition
+    )
+  );
+  return {
+    kind: "return",
+    result: buildRunTurnResult({
+      session,
+      changedPaths: params.changedPaths,
+      transition
+    })
+  };
+}
+function emitAssistantReasoning(response, options) {
+  if (response.reasoningContent && options.config.showReasoning && !response.streamedReasoningContent) {
+    options.callbacks?.onReasoning?.(response.reasoningContent);
+  }
+}
+function emitAssistantFinalOutput(response, options) {
+  if (response.content && !response.streamedAssistantContent) {
+    options.callbacks?.onAssistantText?.(response.content);
+  }
+  if (response.content) {
+    options.callbacks?.onAssistantDone?.(response.content);
+  }
+}
+function hasVisibleAssistantResult(content) {
+  return typeof content === "string" && content.trim().length > 0;
+}
+
+// src/utils/abort.ts
+function createAbortError(message = "Operation aborted") {
+  const error = new Error(message);
+  error.name = "AbortError";
+  error.code = "ABORT_ERR";
+  return error;
+}
+function isAbortError(error) {
+  if (!error) {
+    return false;
+  }
+  if (error instanceof Error) {
+    if (error.name === "AbortError") {
+      return true;
+    }
+    const code = String(error.code ?? "");
+    if (code === "ABORT_ERR" || code === "ERR_ABORTED" || code === "ABORTED") {
+      return true;
+    }
+    const message = error.message.toLowerCase();
+    if (message.includes("abort") || message.includes("aborted") || message.includes("cancelled") || message.includes("canceled")) {
+      return true;
+    }
+  }
+  if (typeof error === "object" && error && "cause" in error) {
+    return isAbortError(error.cause);
+  }
+  return false;
+}
+function throwIfAborted(signal, message) {
+  if (signal?.aborted) {
+    throw createAbortError(message ?? "Operation aborted");
+  }
+}
+function sleepWithSignal(ms, signal) {
+  if (!signal) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+  if (signal.aborted) {
+    return Promise.reject(createAbortError("Sleep aborted"));
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      reject(createAbortError("Sleep aborted"));
+    };
+    signal.addEventListener("abort", onAbort);
+  });
+}
+
+// src/provider/apiRetry.ts
+var API_MAX_RETRIES = 3;
+var API_RETRY_BASE_DELAY_MS = 1200;
+async function withApiRetries(operation, abortSignal) {
+  let lastError;
+  for (let attempt = 1; attempt <= API_MAX_RETRIES; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (isAbortError(error)) {
+        throw error;
+      }
+      lastError = error;
+      if (!isRetryableApiError(error) || attempt === API_MAX_RETRIES) {
+        break;
+      }
+      await sleepWithSignal(API_RETRY_BASE_DELAY_MS * attempt, abortSignal);
+    }
+  }
+  throw lastError;
+}
+function isRetryableApiError(error) {
+  const status = error.status;
+  if (typeof status === "number") {
+    return status === 408 || status === 409 || status === 429 || status >= 500;
+  }
+  const message = String(error.message ?? error).toLowerCase();
+  return message.includes("timeout") || message.includes("network") || message.includes("connection error") || message.includes("connection reset") || message.includes("econnreset") || message.includes("econnrefused") || message.includes("connect timeout") || message.includes("temporarily") || message.includes("rate limit") || message.includes("overloaded");
+}
+
+// src/provider/usageNormalizer.ts
+function normalizeProviderUsage(usage) {
+  if (!usage || typeof usage !== "object") {
+    return void 0;
+  }
+  const record = usage;
+  const promptDetails = readObject(record.prompt_tokens_details);
+  const completionDetails = readObject(record.completion_tokens_details);
+  const outputDetails = readObject(record.output_tokens_details);
+  const cacheCreation = readObject(record.cache_creation);
+  const inputTokens = readUsageNumber(record.prompt_tokens ?? record.input_tokens);
+  const outputTokens = readUsageNumber(record.completion_tokens ?? record.output_tokens);
+  const totalTokens = readUsageNumber(record.total_tokens);
+  const reasoningTokens = readUsageNumber(
+    completionDetails?.reasoning_tokens ?? outputDetails?.reasoning_tokens
+  );
+  const openAiCachedTokens = readUsageNumber(promptDetails?.cached_tokens);
+  const deepSeekHitTokens = readUsageNumber(record.prompt_cache_hit_tokens);
+  const deepSeekMissTokens = readUsageNumber(record.prompt_cache_miss_tokens);
+  const anthropicCacheReadTokens = readUsageNumber(record.cache_read_input_tokens);
+  const anthropicCacheCreationTokens = readUsageNumber(record.cache_creation_input_tokens) ?? sumUsageNumbers([
+    cacheCreation?.ephemeral_1h_input_tokens,
+    cacheCreation?.ephemeral_5m_input_tokens
+  ]);
+  const geminiCachedTokens = readUsageNumber(record.cachedContentTokenCount ?? record.cached_content_token_count);
+  const cacheReadTokens = firstNumber(
+    anthropicCacheReadTokens,
+    openAiCachedTokens,
+    geminiCachedTokens
+  );
+  const cacheHitTokens = firstNumber(deepSeekHitTokens, cacheReadTokens);
+  const cacheMissTokens = deepSeekMissTokens;
+  const cacheCreationTokens = anthropicCacheCreationTokens;
+  const snapshot = {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    reasoningTokens,
+    cacheReadTokens,
+    cacheCreationTokens,
+    cacheHitTokens,
+    cacheMissTokens
+  };
+  const cacheHitRate = computeCacheHitRate(snapshot);
+  if (cacheHitRate !== void 0) {
+    snapshot.cacheHitRate = cacheHitRate;
+  }
+  return Object.values(snapshot).some((value) => typeof value === "number") ? snapshot : void 0;
+}
+function hasProviderUsageSnapshot(usage) {
+  return Boolean(usage && Object.values(usage).some((value) => typeof value === "number"));
+}
+function computeCacheHitRate(snapshot) {
+  if (typeof snapshot.cacheHitTokens === "number" && typeof snapshot.cacheMissTokens === "number") {
+    return ratio(snapshot.cacheHitTokens, snapshot.cacheHitTokens + snapshot.cacheMissTokens);
+  }
+  if (typeof snapshot.cacheReadTokens === "number") {
+    const denominator = (snapshot.inputTokens ?? 0) + snapshot.cacheReadTokens + (snapshot.cacheCreationTokens ?? 0);
+    return ratio(snapshot.cacheReadTokens, denominator);
+  }
+  return void 0;
+}
+function ratio(numerator, denominator) {
+  if (denominator <= 0) {
+    return void 0;
+  }
+  return Math.round(numerator / denominator * 1e4) / 1e4;
+}
+function readObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function firstNumber(...values) {
+  return values.find((value) => typeof value === "number");
+}
+function sumUsageNumbers(values) {
+  const numbers = values.map(readUsageNumber).filter((value) => typeof value === "number");
+  if (numbers.length === 0) {
+    return void 0;
+  }
+  return numbers.reduce((total, value) => total + value, 0);
+}
+function readUsageNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.round(value) : void 0;
+}
+
+// src/observability/writer.ts
+import fs7 from "fs/promises";
+import path8 from "path";
+
+// src/observability/schema.ts
+var OBSERVABILITY_VERSION = 1;
+function buildObservabilityEventRecord(input) {
+  return {
+    version: OBSERVABILITY_VERSION,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    event: normalizeText2(input.event, "unknown"),
+    status: normalizeText2(input.status, "unknown"),
+    host: normalizeOptionalText(input.host),
+    sessionId: normalizeOptionalText(input.sessionId),
+    executionId: normalizeOptionalText(input.executionId),
+    identityKind: normalizeOptionalText(input.identityKind),
+    identityName: normalizeOptionalText(input.identityName),
+    durationMs: normalizeOptionalNumber(input.durationMs),
+    toolName: normalizeOptionalText(input.toolName),
+    model: normalizeOptionalText(input.model),
+    error: normalizeObservabilityError(input.error),
+    details: normalizeDetails(input.details)
+  };
+}
+function normalizeObservabilityError(error) {
+  if (error == null) {
+    return void 0;
+  }
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const record = error;
+    const message2 = normalizeText2(record.message, "");
+    if (!message2) {
+      return void 0;
+    }
+    return {
+      message: message2,
+      code: normalizeOptionalText(record.code),
+      details: normalizeValue(record.details)
+    };
+  }
+  const message = readErrorMessage(error);
+  return message ? { message } : void 0;
+}
+function normalizeDetails(details) {
+  if (!details || typeof details !== "object") {
+    return void 0;
+  }
+  const normalized = normalizeValue(details);
+  return normalized && typeof normalized === "object" && !Array.isArray(normalized) ? normalized : void 0;
+}
+function normalizeValue(value, depth = 0) {
+  if (value == null) {
+    return void 0;
+  }
+  if (depth >= 4) {
+    return "[truncated]";
+  }
+  if (typeof value === "string") {
+    return value.length <= 2e3 ? value : `${value.slice(0, 1997)}...`;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (value instanceof Error) {
+    return {
+      name: normalizeText2(value.name, "Error"),
+      message: normalizeText2(value.message, "Unknown error"),
+      stack: normalizeValue(value.stack, depth + 1)
+    };
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, 20).map((item) => normalizeValue(item, depth + 1)).filter((item) => item !== void 0);
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).slice(0, 30);
+    const normalizedEntries = entries.map(([key, item]) => [key, normalizeValue(item, depth + 1)]).filter(([, item]) => item !== void 0);
+    return Object.fromEntries(normalizedEntries);
+  }
+  return normalizeText2(String(value), "");
+}
+function normalizeText2(value, fallback) {
+  const normalized = String(value ?? "").trim();
+  return normalized || fallback;
+}
+function normalizeOptionalText(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || void 0;
+}
+function normalizeOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.round(value) : void 0;
+}
+function readErrorMessage(error) {
+  if (error instanceof Error) {
+    return normalizeText2(error.message, error.name || "Unknown error");
+  }
+  if (typeof error === "object" && error !== null && "message" in error) {
+    return normalizeText2(error.message, "Unknown error");
+  }
+  return normalizeText2(String(error ?? "Unknown error"), "Unknown error");
+}
+
+// src/observability/writer.ts
+async function appendObservabilityEvent(rootDir, input) {
+  const paths = await ensureProjectStateDirectories(rootDir);
+  const record = buildObservabilityEventRecord(input);
+  const filePath = path8.join(paths.observabilityEventsDir, `${record.timestamp.slice(0, 10)}.jsonl`);
+  await fs7.appendFile(filePath, `${JSON.stringify(record)}
+`, "utf8");
+  return record;
+}
+async function recordObservabilityEvent(rootDir, input) {
+  try {
+    await appendObservabilityEvent(rootDir, input);
+  } catch {
+  }
+}
+
+// src/provider/cachePolicy.ts
+function resolveProviderCachePolicy(input) {
+  const profile = resolveModelProfile(input);
+  if (profile.model.capabilities.cache === "prompt-cache-key") {
+    return {
+      provider: "openai",
+      automaticPrefixCache: true,
+      promptCacheKey: buildPromptCacheKey(input)
+    };
+  }
+  if (profile.model.capabilities.cache === "provider-automatic") {
+    return {
+      provider: profile.provider.id === "deepseek" ? "deepseek" : "generic",
+      automaticPrefixCache: true
+    };
+  }
+  return {
+    provider: "generic",
+    automaticPrefixCache: false
+  };
+}
+function buildPromptCacheKey(input) {
+  const seed = input.sessionId || input.projectRoot;
+  if (!seed) {
+    return void 0;
+  }
+  return `kitty:${stableHash(seed)}`;
+}
+function stableHash(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+// src/provider/chatRequestBody.ts
+function buildProviderRequestBody(input) {
+  const capabilities = resolveProviderCapabilities(input);
+  const thinking = capabilities.provider === "deepseek" ? resolveDeepSeekThinking(input.messages, input.thinking ?? "enabled") : input.thinking;
+  const body = {
+    model: input.model,
+    messages: toChatCompletionMessages(input.messages),
+    tools: input.tools,
+    stream: input.stream
+  };
+  if (capabilities.provider !== "deepseek" && input.tools?.length) {
+    body.tool_choice = "auto";
+  }
+  if (input.stream) {
+    body.stream_options = {
+      include_usage: true
+    };
+  }
+  const cachePolicy = resolveProviderCachePolicy(input);
+  if (cachePolicy.promptCacheKey) {
+    body.prompt_cache_key = cachePolicy.promptCacheKey;
+  }
+  if (typeof input.maxOutputTokens === "number" && Number.isFinite(input.maxOutputTokens)) {
+    body.max_tokens = Math.max(1, Math.trunc(input.maxOutputTokens));
+  }
+  if (capabilities.provider === "deepseek") {
+    body.thinking = { type: thinking };
+    if (thinking === "enabled") {
+      body.reasoning_effort = normalizeDeepSeekReasoningEffort(input.reasoningEffort ?? capabilities.defaultReasoningEffort);
+    }
+  } else if (input.forceReasoning || capabilities.defaultReasoningEnabled) {
+    body.thinking = { type: "enabled" };
+  }
+  return body;
+}
+function resolveDeepSeekThinking(messages, requested) {
+  if (requested === "disabled") {
+    return "disabled";
+  }
+  if (hasUnreplayableAssistantReasoning(messages)) {
+    throw new Error("DeepSeek thinking tool-call replay requires stored reasoning_content. Start a new turn or disable KITTY_THINKING.");
+  }
+  return "enabled";
+}
+function hasUnreplayableAssistantReasoning(messages) {
+  return messages.some(
+    (message) => message.role === "assistant" && Array.isArray(message.toolCalls) && message.toolCalls.length > 0 && message.reasoningContent === void 0
+  );
+}
+function normalizeDeepSeekReasoningEffort(effort) {
+  if (effort === void 0 || effort === "minimal" || effort === "low" || effort === "medium" || effort === "high") {
+    return "high";
+  }
+  if (effort === "xhigh" || effort === "max") {
+    return "max";
+  }
+  return "high";
+}
+
+// src/provider/chatCompletionsAdapter.ts
+var chatCompletionsAdapter = {
+  wireApi: "chat.completions",
+  async fetchStreaming(client, request) {
+    const startedAt = Date.now();
+    let usage;
+    throwIfAborted(request.abortSignal, "Streaming request aborted");
+    try {
+      const stream = await client.chat.completions.create(
+        {
+          ...buildProviderRequestBody({
+            provider: request.provider,
+            model: request.model,
+            messages: request.messages,
+            tools: request.tools,
+            stream: true,
+            forceReasoning: request.forceReasoning,
+            thinking: request.thinking,
+            reasoningEffort: request.reasoningEffort,
+            maxOutputTokens: request.maxOutputTokens,
+            sessionId: request.sessionId,
+            projectRoot: request.projectRoot
+          }),
+          signal: request.abortSignal
+        }
+      );
+      if (request.abortSignal?.aborted) {
+        abortStream(stream);
+        throw createAbortError("Streaming aborted");
+      }
+      let content = "";
+      let reasoningContent = "";
+      const toolCallParts = /* @__PURE__ */ new Map();
+      for await (const chunk of stream) {
+        if (request.abortSignal?.aborted) {
+          abortStream(stream);
+          throw createAbortError("Streaming aborted");
+        }
+        usage = normalizeProviderUsage(chunk.usage) ?? usage;
+        const delta = chunk.choices?.[0]?.delta;
+        if (!delta) {
+          continue;
+        }
+        if (typeof delta.content === "string" && delta.content.length > 0) {
+          content += delta.content;
+          request.callbacks?.onAssistantDelta?.(delta.content);
+        }
+        if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
+          reasoningContent += delta.reasoning_content;
+          request.callbacks?.onReasoningDelta?.(delta.reasoning_content);
+        }
+        if (Array.isArray(delta.tool_calls)) {
+          for (const toolCall of delta.tool_calls) {
+            const index = typeof toolCall.index === "number" ? toolCall.index : 0;
+            const existing = toolCallParts.get(index) ?? {
+              id: toolCall.id ?? `tool-${index}`,
+              name: "",
+              arguments: ""
+            };
+            if (toolCall.id) {
+              existing.id = toolCall.id;
+            }
+            if (toolCall.function?.name) {
+              existing.name += toolCall.function.name;
+            }
+            if (toolCall.function?.arguments) {
+              existing.arguments += toolCall.function.arguments;
+            }
+            toolCallParts.set(index, existing);
+          }
+        }
+      }
+      return {
+        content: content.length > 0 ? content : null,
+        reasoningContent: reasoningContent.length > 0 ? reasoningContent : void 0,
+        streamedAssistantContent: content.length > 0,
+        streamedReasoningContent: reasoningContent.length > 0,
+        toolCalls: [...toolCallParts.entries()].sort((left, right) => left[0] - right[0]).map(([, toolCall]) => ({
+          id: toolCall.id,
+          type: "function",
+          function: {
+            name: toolCall.name,
+            arguments: toolCall.arguments
+          }
+        }))
+      };
+    } finally {
+      request.onRequestMetric?.({
+        durationMs: Date.now() - startedAt,
+        usage
+      });
+    }
+  },
+  async fetchNonStreaming(client, request) {
+    const startedAt = Date.now();
+    let usage;
+    throwIfAborted(request.abortSignal, "Request aborted");
+    try {
+      const completion = await client.chat.completions.create(
+        {
+          ...buildProviderRequestBody({
+            provider: request.provider,
+            model: request.model,
+            messages: request.messages,
+            tools: request.tools,
+            stream: false,
+            forceReasoning: request.forceReasoning,
+            thinking: request.thinking,
+            reasoningEffort: request.reasoningEffort,
+            maxOutputTokens: request.maxOutputTokens,
+            sessionId: request.sessionId,
+            projectRoot: request.projectRoot
+          }),
+          signal: request.abortSignal
+        }
+      );
+      usage = normalizeProviderUsage(completion.usage);
+      const message = completion.choices[0]?.message;
+      if (!message) {
+        throw new Error("API returned no message.");
+      }
+      return {
+        content: typeof message.content === "string" ? message.content : collapseContentParts(message.content),
+        reasoningContent: readReasoningContent(message),
+        streamedAssistantContent: false,
+        streamedReasoningContent: false,
+        toolCalls: (message.tool_calls ?? []).filter((call) => call.type === "function").map((call) => ({
+          id: call.id,
+          type: "function",
+          function: {
+            name: call.function.name,
+            arguments: call.function.arguments
+          }
+        }))
+      };
+    } finally {
+      request.onRequestMetric?.({
+        durationMs: Date.now() - startedAt,
+        usage
+      });
+    }
+  }
+};
+function abortStream(stream) {
+  try {
+    stream?.controller?.abort();
+  } catch {
+  }
+}
+function toChatCompletionMessages(messages) {
+  return messages.map((message) => {
+    if (message.role === "tool") {
+      return {
+        role: "tool",
+        content: message.content ?? "",
+        tool_call_id: message.toolCallId ?? ""
+      };
+    }
+    if (message.role === "assistant" && message.toolCalls?.length) {
+      const assistantMessage = {
+        role: "assistant",
+        content: message.content ?? "",
+        tool_calls: message.toolCalls
+      };
+      if (message.reasoningContent !== void 0) {
+        assistantMessage.reasoning_content = message.reasoningContent;
+      }
+      return assistantMessage;
+    }
+    const baseMessage = {
+      role: message.role,
+      content: message.content ?? "",
+      name: message.name
+    };
+    if (message.role === "assistant" && message.reasoningContent !== void 0) {
+      baseMessage.reasoning_content = message.reasoningContent;
+    }
+    return baseMessage;
+  });
+}
+
+// src/provider/responsesRequest.ts
+function buildResponsesRequestBody(request) {
+  const capabilities = resolveProviderCapabilities({
+    provider: request.provider,
+    model: request.model
+  });
+  const body = {
+    model: request.model,
+    input: toResponsesInput(request.messages),
+    tools: request.tools?.map((tool) => ({
+      type: "function",
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters ?? null,
+      strict: false
+    })),
+    tool_choice: request.tools?.length ? "auto" : void 0
+  };
+  if (typeof request.maxOutputTokens === "number" && Number.isFinite(request.maxOutputTokens)) {
+    body.max_output_tokens = Math.max(1, Math.trunc(request.maxOutputTokens));
+  }
+  const cachePolicy = resolveProviderCachePolicy({
+    provider: request.provider,
+    model: request.model,
+    sessionId: request.sessionId,
+    projectRoot: request.projectRoot
+  });
+  if (cachePolicy.promptCacheKey) {
+    body.prompt_cache_key = cachePolicy.promptCacheKey;
+  }
+  const reasoningEffort = request.thinking === "disabled" ? void 0 : normalizeResponsesReasoningEffort(
+    request.reasoningEffort ?? capabilities.defaultReasoningEffort
+  );
+  if (request.thinking !== "disabled" && (request.forceReasoning || capabilities.defaultReasoningEnabled || request.thinking === "enabled" || reasoningEffort)) {
+    body.reasoning = {
+      effort: reasoningEffort ?? "high",
+      summary: "detailed"
+    };
+  }
+  return body;
+}
+function normalizeResponsesReasoningEffort(effort) {
+  if (effort === "xhigh") {
+    return "xhigh";
+  }
+  return effort === "max" ? void 0 : effort;
+}
+function toResponsesInput(messages) {
+  const items = [];
+  for (const message of messages) {
+    if (message.role === "tool") {
+      items.push({
+        type: "function_call_output",
+        call_id: message.toolCallId ?? "",
+        output: message.content ?? ""
+      });
+      continue;
+    }
+    if (message.role === "assistant" && message.toolCalls?.length) {
+      if (typeof message.content === "string" && message.content.trim().length > 0) {
+        items.push({
+          type: "message",
+          role: "assistant",
+          content: message.content
+        });
+      }
+      for (const toolCall of message.toolCalls) {
+        items.push({
+          type: "function_call",
+          call_id: toolCall.id,
+          name: toolCall.function.name,
+          arguments: toolCall.function.arguments
+        });
+      }
+      continue;
+    }
+    items.push({
+      type: "message",
+      role: message.role,
+      content: message.content ?? ""
+    });
+  }
+  return items;
+}
+
+// src/provider/responsesResponse.ts
+function normalizeResponsesOutputText(response) {
+  const outputText = response.output_text;
+  if (typeof outputText === "string" && outputText.trim().length > 0) {
+    return outputText;
+  }
+  const output = response.output;
+  if (!Array.isArray(output)) {
+    return null;
+  }
+  const fragments = output.flatMap((item) => {
+    if (!item || typeof item !== "object" || item.type !== "message") {
+      return [];
+    }
+    const content = item.content;
+    if (!Array.isArray(content)) {
+      return [];
+    }
+    return content.flatMap((part) => {
+      if (!part || typeof part !== "object" || part.type !== "output_text") {
+        return [];
+      }
+      return typeof part.text === "string" ? [part.text] : [];
+    });
+  });
+  return fragments.length > 0 ? fragments.join("") : null;
+}
+function readResponsesToolCalls(response) {
+  const output = response.output;
+  if (!Array.isArray(output)) {
+    return [];
+  }
+  return output.filter((item) => Boolean(item) && typeof item === "object" && item.type === "function_call").map((item) => ({
+    id: item.call_id ?? item.id ?? crypto.randomUUID(),
+    type: "function",
+    function: {
+      name: item.name ?? "",
+      arguments: item.arguments ?? ""
+    }
+  }));
+}
+function readResponsesReasoning(response) {
+  const output = response.output;
+  if (!Array.isArray(output)) {
+    return void 0;
+  }
+  const fragments = output.flatMap((item) => {
+    if (!item || typeof item !== "object" || item.type !== "reasoning") {
+      return [];
+    }
+    const reasoningItem = item;
+    const summary = Array.isArray(reasoningItem.summary) ? reasoningItem.summary.map((entry) => typeof entry?.text === "string" ? entry.text : "").filter(Boolean) : [];
+    const content = Array.isArray(reasoningItem.content) ? reasoningItem.content.map((entry) => typeof entry?.text === "string" ? entry.text : "").filter(Boolean) : [];
+    return [...content, ...summary];
+  });
+  return fragments.length > 0 ? fragments.join("") : void 0;
+}
+
+// src/provider/responsesAdapter.ts
+var responsesAdapter = {
+  wireApi: "responses",
+  async fetchStreaming(client, request) {
+    const startedAt = Date.now();
+    let usage;
+    throwIfAborted(request.abortSignal, "Streaming request aborted");
+    try {
+      const stream = await client.responses.create(
+        {
+          ...buildResponsesRequestBody(request),
+          stream: true
+        },
+        {
+          signal: request.abortSignal
+        }
+      );
+      if (request.abortSignal?.aborted) {
+        abortStream2(stream);
+        throw createAbortError("Streaming aborted");
+      }
+      let content = "";
+      let reasoningContent = "";
+      const toolCalls = /* @__PURE__ */ new Map();
+      for await (const event of stream) {
+        if (request.abortSignal?.aborted) {
+          abortStream2(stream);
+          throw createAbortError("Streaming aborted");
+        }
+        usage = normalizeProviderUsage(event.response?.usage) ?? usage;
+        if (event.type === "response.output_text.delta" && typeof event.delta === "string") {
+          content += event.delta;
+          request.callbacks?.onAssistantDelta?.(event.delta);
+          continue;
+        }
+        if ((event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary_text.delta") && typeof event.delta === "string") {
+          reasoningContent += event.delta;
+          request.callbacks?.onReasoningDelta?.(event.delta);
+          continue;
+        }
+        if (event.type === "response.function_call_arguments.delta" && typeof event.delta === "string") {
+          const index = typeof event.output_index === "number" ? event.output_index : 0;
+          const existing = toolCalls.get(index) ?? {
+            id: event.item_id ?? `tool-${index}`,
+            name: "",
+            arguments: ""
+          };
+          existing.arguments += event.delta;
+          toolCalls.set(index, existing);
+          continue;
+        }
+        if (event.type === "response.function_call_arguments.done") {
+          const index = typeof event.output_index === "number" ? event.output_index : 0;
+          const existing = toolCalls.get(index) ?? {
+            id: event.item_id ?? `tool-${index}`,
+            name: "",
+            arguments: ""
+          };
+          if (typeof event.name === "string") {
+            existing.name = event.name;
+          }
+          if (typeof event.arguments === "string" && event.arguments.length > 0) {
+            existing.arguments = event.arguments;
+          }
+          toolCalls.set(index, existing);
+          continue;
+        }
+        if (event.type === "response.output_item.done" && event.item?.type === "function_call") {
+          const index = typeof event.output_index === "number" ? event.output_index : 0;
+          toolCalls.set(index, {
+            id: event.item.call_id ?? event.item.id ?? `tool-${index}`,
+            name: event.item.name ?? "",
+            arguments: event.item.arguments ?? ""
+          });
+        }
+      }
+      return {
+        content: content.length > 0 ? content : null,
+        reasoningContent: reasoningContent.length > 0 ? reasoningContent : void 0,
+        streamedAssistantContent: content.length > 0,
+        streamedReasoningContent: reasoningContent.length > 0,
+        toolCalls: [...toolCalls.entries()].sort((left, right) => left[0] - right[0]).map(([, toolCall]) => ({
+          id: toolCall.id,
+          type: "function",
+          function: {
+            name: toolCall.name,
+            arguments: toolCall.arguments
+          }
+        }))
+      };
+    } finally {
+      request.onRequestMetric?.({
+        durationMs: Date.now() - startedAt,
+        usage
+      });
+    }
+  },
+  async fetchNonStreaming(client, request) {
+    const startedAt = Date.now();
+    let usage;
+    throwIfAborted(request.abortSignal, "Request aborted");
+    try {
+      const response = await client.responses.create(
+        {
+          ...buildResponsesRequestBody(request),
+          stream: false
+        },
+        {
+          signal: request.abortSignal
+        }
+      );
+      usage = normalizeProviderUsage(response.usage);
+      return {
+        content: normalizeResponsesOutputText(response),
+        reasoningContent: readResponsesReasoning(response),
+        streamedAssistantContent: false,
+        streamedReasoningContent: false,
+        toolCalls: readResponsesToolCalls(response)
+      };
+    } finally {
+      request.onRequestMetric?.({
+        durationMs: Date.now() - startedAt,
+        usage
+      });
+    }
+  }
+};
+function abortStream2(stream) {
+  try {
+    stream?.controller?.abort();
+  } catch {
+  }
+}
+
+// src/provider/client.ts
+import OpenAI from "openai";
+
+// src/provider/connection.ts
+function buildProviderBaseUrlCandidates(baseUrl) {
+  const normalized = trimTrailingSlash(baseUrl);
+  if (!normalized) {
+    return [normalized];
+  }
+  const candidates = [normalized];
+  try {
+    const parsed = new URL(normalized);
+    if (parsed.pathname === "" || parsed.pathname === "/") {
+      candidates.push(trimTrailingSlash(new URL("v1", ensureTrailingSlash2(parsed.toString())).toString()));
+    }
+  } catch {
+    return candidates;
+  }
+  return [...new Set(candidates)];
+}
+function ensureTrailingSlash2(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+function trimTrailingSlash(baseUrl) {
+  const trimmed = String(baseUrl ?? "").trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+}
+
+// src/provider/client.ts
+function createProviderClientPool(config) {
+  const capabilities = resolveProviderCapabilities({
+    provider: config.provider,
+    model: config.model
   });
-  const session = await params.options.sessionStore.save(
-    noteCheckpointCompleted(
-      await params.options.sessionStore.appendMessages(params.session, [assistantMessage]),
-      transition
-    )
-  );
+  const baseUrls = buildProviderBaseUrlCandidates(config.baseUrl);
+  const clients = /* @__PURE__ */ new Map();
+  let preferredBaseUrl;
   return {
-    kind: "return",
-    result: buildRunTurnResult({
-      session,
-      changedPaths: params.changedPaths,
-      transition
-    })
+    candidates() {
+      const ordered = preferredBaseUrl ? [preferredBaseUrl, ...baseUrls.filter((baseUrl) => baseUrl !== preferredBaseUrl)] : baseUrls;
+      return ordered.map((baseUrl) => ({
+        baseUrl,
+        client: getOrCreateClient(baseUrl)
+      }));
+    },
+    markHealthy(baseUrl) {
+      preferredBaseUrl = baseUrl;
+    }
   };
+  function getOrCreateClient(baseUrl) {
+    const existing = clients.get(baseUrl);
+    if (existing) {
+      return existing;
+    }
+    const client = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: baseUrl,
+      timeout: capabilities.requestTimeoutMs,
+      maxRetries: 0
+    });
+    clients.set(baseUrl, client);
+    return client;
+  }
 }
-function emitAssistantReasoning(response, options) {
-  if (response.reasoningContent && options.config.showReasoning && !response.streamedReasoningContent) {
-    options.callbacks?.onReasoning?.(response.reasoningContent);
+function isProviderClientPool(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.candidates === "function" && typeof value.markHealthy === "function"
+  );
+}
+
+// src/provider/request.ts
+async function fetchAssistantResponse(client, messages, request, tools, callbacks, abortSignal, onRequestMetric, observability) {
+  const capabilities = resolveProviderCapabilities(request);
+  const adapter = selectProviderWireAdapter(capabilities.wireApi);
+  return tryFetch(
+    adapter,
+    client,
+    messages,
+    request,
+    tools,
+    callbacks,
+    false,
+    abortSignal,
+    onRequestMetric,
+    observability
+  );
+}
+async function tryFetch(adapter, client, messages, request, tools, callbacks, forceReasoning, abortSignal, onRequestMetric, observability) {
+  const startedAt = Date.now();
+  let latestMetric;
+  let resolvedBaseUrl;
+  const forwardMetric = (metric) => {
+    latestMetric = metric;
+    onRequestMetric?.(metric);
+  };
+  if (observability) {
+    await recordObservabilityEvent(observability.rootDir, {
+      event: "model.request",
+      status: "started",
+      sessionId: observability.sessionId,
+      identityKind: observability.identityKind,
+      identityName: observability.identityName,
+      model: request.model,
+      details: {
+        provider: request.provider,
+        configuredModel: observability.configuredModel,
+        requestModel: request.model,
+        wireApi: adapter.wireApi,
+        baseUrl: resolvedBaseUrl
+      }
+    });
+  }
+  try {
+    const response = await withApiRetries(
+      () => invokeWithProviderClients(client, async (providerClient, baseUrl) => {
+        resolvedBaseUrl = baseUrl;
+        return adapter.fetchStreaming(providerClient, {
+          provider: request.provider,
+          model: request.model,
+          messages,
+          tools,
+          callbacks,
+          forceReasoning,
+          thinking: request.thinking,
+          reasoningEffort: request.reasoningEffort,
+          maxOutputTokens: request.maxOutputTokens,
+          sessionId: request.sessionId,
+          projectRoot: request.projectRoot,
+          abortSignal,
+          onRequestMetric: forwardMetric
+        });
+      }),
+      abortSignal
+    );
+    if (observability) {
+      await recordObservabilityEvent(observability.rootDir, {
+        event: "model.request",
+        status: "completed",
+        sessionId: observability.sessionId,
+        identityKind: observability.identityKind,
+        identityName: observability.identityName,
+        model: request.model,
+        durationMs: Date.now() - startedAt,
+        details: {
+          provider: request.provider,
+          configuredModel: observability.configuredModel,
+          requestModel: request.model,
+          wireApi: adapter.wireApi,
+          baseUrl: resolvedBaseUrl,
+          usage: latestMetric?.usage,
+          usageAvailable: hasProviderUsageSnapshot(latestMetric?.usage)
+        }
+      });
+    }
+    return response;
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw error;
+    }
+    try {
+      const response = await withApiRetries(
+        () => invokeWithProviderClients(client, async (providerClient, baseUrl) => {
+          resolvedBaseUrl = baseUrl;
+          return adapter.fetchNonStreaming(providerClient, {
+            provider: request.provider,
+            model: request.model,
+            messages,
+            tools,
+            callbacks,
+            forceReasoning,
+            thinking: request.thinking,
+            reasoningEffort: request.reasoningEffort,
+            maxOutputTokens: request.maxOutputTokens,
+            sessionId: request.sessionId,
+            projectRoot: request.projectRoot,
+            abortSignal,
+            onRequestMetric: forwardMetric
+          });
+        }),
+        abortSignal
+      );
+      if (observability) {
+        await recordObservabilityEvent(observability.rootDir, {
+          event: "model.request",
+          status: "completed",
+          sessionId: observability.sessionId,
+          identityKind: observability.identityKind,
+          identityName: observability.identityName,
+          model: request.model,
+          durationMs: Date.now() - startedAt,
+          details: {
+            provider: request.provider,
+            configuredModel: observability.configuredModel,
+            requestModel: request.model,
+            wireApi: adapter.wireApi,
+            baseUrl: resolvedBaseUrl,
+            usage: latestMetric?.usage,
+            usageAvailable: hasProviderUsageSnapshot(latestMetric?.usage)
+          }
+        });
+      }
+      return response;
+    } catch (fallbackError) {
+      if (!isAbortError(fallbackError) && observability) {
+        await recordObservabilityEvent(observability.rootDir, {
+          event: "model.request",
+          status: "failed",
+          sessionId: observability.sessionId,
+          identityKind: observability.identityKind,
+          identityName: observability.identityName,
+          model: request.model,
+          durationMs: Date.now() - startedAt,
+          error: fallbackError,
+          details: {
+            provider: request.provider,
+            configuredModel: observability.configuredModel,
+            requestModel: request.model,
+            wireApi: adapter.wireApi,
+            baseUrl: resolvedBaseUrl,
+            usage: latestMetric?.usage,
+            usageAvailable: hasProviderUsageSnapshot(latestMetric?.usage)
+          }
+        });
+      }
+      throw fallbackError;
+    }
   }
 }
-function emitAssistantFinalOutput(response, options) {
-  if (response.content && !response.streamedAssistantContent) {
-    options.callbacks?.onAssistantText?.(response.content);
+function selectProviderWireAdapter(wireApi) {
+  if (wireApi === "responses") {
+    return responsesAdapter;
   }
-  if (response.content) {
-    options.callbacks?.onAssistantDone?.(response.content);
+  return chatCompletionsAdapter;
+}
+async function invokeWithProviderClients(client, operation) {
+  if (!isProviderClientPool(client)) {
+    return operation(client, void 0);
+  }
+  let lastError;
+  const candidates = client.candidates();
+  for (let index = 0; index < candidates.length; index += 1) {
+    const candidate = candidates[index];
+    try {
+      const result = await operation(candidate.client, candidate.baseUrl);
+      client.markHealthy(candidate.baseUrl);
+      return result;
+    } catch (error) {
+      lastError = error;
+      if (isAbortError(error)) {
+        throw error;
+      }
+      const hasMoreCandidates = index < candidates.length - 1;
+      if (!hasMoreCandidates || !canRetryWithAlternateBaseUrl(error)) {
+        throw error;
+      }
+    }
   }
+  throw lastError;
 }
-function hasVisibleAssistantResult(content) {
-  return typeof content === "string" && content.trim().length > 0;
+function canRetryWithAlternateBaseUrl(error) {
+  const status = error.status;
+  const message = String(error.message ?? error).toLowerCase();
+  return status === 404 || status === 405 || message.includes("404") || message.includes("not found");
 }
 
 // src/provider/retryPolicy.ts
@@ -1097,25 +2258,25 @@ function buildSessionConversationBriefBlock(brief) {
   if (!brief?.modelSummary) {
     return void 0;
   }
-  return buildFieldBlock("Internal continuity state", [
+  return buildFieldBlock("Conversation continuity evidence", [
     {
       label: "Purpose",
       value: "Use these facts as private continuity state. Answer the current request directly. Quote prior turns only when the user asks."
     },
     brief.modelSummary ? {
-      label: "Session memory",
+      label: "Model-written session memory",
       value: brief.modelSummary
-    } : { label: "Session memory", value: void 0 },
+    } : { label: "Model-written session memory", value: void 0 },
     brief.modelSummaryUpdatedAt ? {
-      label: "Memory updated at",
+      label: "Updated",
       value: brief.modelSummaryUpdatedAt
-    } : { label: "Memory updated at", value: void 0 },
+    } : { label: "Updated", value: void 0 },
     {
-      label: "Visible turns",
+      label: "Near-field visible turns",
       value: `${brief.userTurnCount} user turn(s) with current input / ${brief.assistantTurnCount} assistant response(s)`
     },
     {
-      label: "Tool activity",
+      label: "Recent tool activity",
       value: formatSignals(brief.toolActivity)
     }
   ]);
@@ -1243,7 +2404,7 @@ function buildHistoryBoundaryBlock(memory) {
   return buildFieldBlock("History boundary", [
     {
       label: "Policy",
-      value: "Raw session history stays out of the current request. Internal continuity state and current workset are automatic facts for judgment, not text to narrate."
+      value: "Raw session history stays out of the current request. Conversation continuity evidence and current workset are automatic facts for judgment, not text to narrate."
     }
   ]);
 }
@@ -1486,6 +2647,10 @@ function buildTaskLifecyclePromptBlock(lifecycle) {
     return void 0;
   }
   const fields = [
+    {
+      label: "Purpose",
+      value: "Current task-state evidence. Use it to orient the next action; do not treat it as a new user request."
+    },
     { label: "Stage", value: lifecycle.stage },
     lifecycle.scope ? { label: "Scope", value: lifecycle.scope } : void 0,
     lifecycle.boundary ? { label: "Boundary", value: lifecycle.boundary } : void 0,
@@ -1496,14 +2661,14 @@ function buildTaskLifecyclePromptBlock(lifecycle) {
     lifecycle.completionFacts.length > 0 ? { label: "Completion facts", value: formatLimitedList(lifecycle.completionFacts, 4) } : void 0,
     { label: "Updated", value: lifecycle.updatedAt }
   ];
-  return buildFieldBlock("Task lifecycle", fields.filter((field) => Boolean(field)));
+  return buildFieldBlock("Current task scene evidence", fields.filter((field) => Boolean(field)));
 }
 function buildProjectMapPromptBlock(projectMap) {
   if (!projectMap) {
     return void 0;
   }
   const fields = [
-    { label: "Purpose", value: "Machine facts for orientation. Use as evidence, not as a route command." },
+    { label: "Purpose", value: "Project orientation evidence. Use as facts for the current turn; do not treat this block as a task route." },
     { label: "Root", value: projectMap.rootDir },
     { label: "Top-level dirs", value: formatLimitedList(projectMap.topLevelDirectories, 10) },
     { label: "Entries", value: formatLimitedList(projectMap.entryFiles, 8) },
@@ -1517,7 +2682,7 @@ function buildProjectMapPromptBlock(projectMap) {
     projectMap.git.recentChanges.length > 0 ? { label: "Recent changes", value: formatLimitedList(projectMap.git.recentChanges, 6) } : void 0,
     { label: "Updated", value: projectMap.updatedAt }
   ];
-  return buildFieldBlock("Project map", fields.filter((field) => Boolean(field)));
+  return buildFieldBlock("Project orientation evidence", fields.filter((field) => Boolean(field)));
 }
 
 // src/agent/prompt/metrics.ts
@@ -1650,7 +2815,8 @@ function buildCompressedContextRequest(systemPrompt, messages, config) {
   const safeMaxChars = Math.max(8e3, config.maxContextChars);
   const conversation = buildVisibleConversationWindow(messages);
   const conversationMessages = conversation.messages;
-  const fullMessages = composeChatMessages(systemPrompt, conversationMessages, config.model);
+  const provider = config.provider ?? "openai-compatible";
+  const fullMessages = composeChatMessages(systemPrompt, conversationMessages, config.model, provider);
   const initialEstimatedChars = estimateChatMessagesChars(fullMessages);
   const initialPromptMetrics = measureSystemPrompt(systemPrompt);
   const initialSources = buildBudgetSources(systemPrompt, conversationMessages);
@@ -1679,7 +2845,7 @@ function buildCompressedContextRequest(systemPrompt, messages, config) {
     const summary = compressedFrameHead.length > 0 ? summarizeConversation(compressedFrameHead, config.contextSummaryChars) : void 0;
     const summaryPrompt = appendSummary(systemPrompt, summary);
     let workingTail = compactTailMessages(tailMessages, "normal");
-    let requestMessages = composeChatMessages(summaryPrompt, workingTail, config.model);
+    let requestMessages = composeChatMessages(summaryPrompt, workingTail, config.model, provider);
     let estimatedChars = estimateChatMessagesChars(requestMessages);
     let promptMetrics = measureSystemPrompt(summaryPrompt);
     let cacheLayout = buildCacheLayoutReport(summaryPrompt, workingTail);
@@ -1704,7 +2870,7 @@ function buildCompressedContextRequest(systemPrompt, messages, config) {
       };
     }
     workingTail = compactTailMessages(tailMessages, "aggressive");
-    requestMessages = composeChatMessages(summaryPrompt, workingTail, config.model);
+    requestMessages = composeChatMessages(summaryPrompt, workingTail, config.model, provider);
     estimatedChars = estimateChatMessagesChars(requestMessages);
     promptMetrics = measureSystemPrompt(summaryPrompt);
     cacheLayout = buildCacheLayoutReport(summaryPrompt, workingTail);
@@ -1740,7 +2906,8 @@ function buildCompressedContextRequest(systemPrompt, messages, config) {
       const hardMessages = composeChatMessages(
         hardPrompt,
         compactedHardTail,
-        config.model
+        config.model,
+        provider
       );
       const hardEstimatedChars = estimateChatMessagesChars(hardMessages);
       const hardCacheLayout = buildCacheLayoutReport(hardPrompt, compactedHardTail);
@@ -1775,7 +2942,7 @@ function sliceTailMessages(messages, tailCount) {
   const safeStartIndex = expandStartToToolBoundary(messages, startIndex);
   return messages.slice(safeStartIndex);
 }
-function composeChatMessages(systemPrompt, messages, model) {
+function composeChatMessages(systemPrompt, messages, model, provider) {
   return [
     {
       role: "system",
@@ -1787,7 +2954,7 @@ function composeChatMessages(systemPrompt, messages, model) {
       name: message.name,
       toolCallId: message.tool_call_id,
       toolCalls: message.tool_calls,
-      reasoningContent: shouldIncludeStoredAssistantReasoning(messages, index, model) ? message.reasoningContent : void 0
+      reasoningContent: shouldIncludeStoredAssistantReasoning(messages, index, model, provider) ? message.reasoningContent : void 0
     }))
   ];
 }
@@ -1934,8 +3101,8 @@ function buildCacheLayoutReport(systemPrompt, messages) {
     }))
   });
   return {
-    stablePrefixFingerprint: stableHash(stablePrefix),
-    volatileTailFingerprint: stableHash(volatileTail),
+    stablePrefixFingerprint: stableHash2(stablePrefix),
+    volatileTailFingerprint: stableHash2(volatileTail),
     stablePrefixChars: stablePrefix.length,
     volatileTailChars: volatileTail.length,
     stableSources: typeof systemPrompt === "string" ? ["systemPrompt"] : [
@@ -1966,7 +3133,7 @@ function renderVolatileRuntimeFacts(systemPrompt) {
     joinBlocks(systemPrompt.runtimeFactBlocks)
   ].join("\n").trim();
 }
-function stableHash(value) {
+function stableHash2(value) {
   let hash = 2166136261;
   for (let index = 0; index < value.length; index += 1) {
     hash ^= value.charCodeAt(index);
@@ -2202,6 +3369,7 @@ async function updateSessionMemoryAfterTurn(input) {
     identityName: input.identity.name,
     model: input.requestModel
   });
+  input.options.callbacks?.onStatus?.("\u603B\u7ED3\u4E2D");
   try {
     const memoryResponse = input.options.fetchSessionMemoryResponse ? await input.options.fetchSessionMemoryResponse(modelRequest) : await fetchAssistantResponse(
       input.client,
@@ -2252,6 +3420,8 @@ async function updateSessionMemoryAfterTurn(input) {
       error
     });
     return input.session;
+  } finally {
+    input.options.callbacks?.onStatus?.("");
   }
 }
 async function updateSessionTitleAfterTurn(input) {
@@ -2299,6 +3469,7 @@ async function updateSessionTitleAfterTurn(input) {
     identityName: input.identity.name,
     model: input.requestModel
   });
+  input.options.callbacks?.onStatus?.("\u6807\u9898\u751F\u6210\u4E2D");
   try {
     const titleResponse = input.options.fetchSessionTitleResponse ? await input.options.fetchSessionTitleResponse(modelRequest) : await fetchAssistantResponse(
       input.client,
@@ -2350,15 +3521,17 @@ async function updateSessionTitleAfterTurn(input) {
       error
     });
     return input.session;
+  } finally {
+    input.options.callbacks?.onStatus?.("");
   }
 }
 
 // src/control/ledger.ts
 import Database from "better-sqlite3";
-import fs6 from "fs";
+import fs8 from "fs";
 
 // src/control/executions.ts
-import path7 from "path";
+import path9 from "path";
 
 // src/protocol/leadWait.ts
 var LEAD_WAIT_PROTOCOL = "kitty.lead-wait-policy";
@@ -2587,7 +3760,7 @@ var ExecutionLedgerRepo = class {
       prompt: input.prompt,
       actorName: input.actorName,
       actorRole: input.actorRole,
-      cwd: path7.resolve(input.cwd),
+      cwd: path9.resolve(input.cwd),
       requestedBy: input.requestedBy,
       sessionId: input.sessionId,
       pid: input.pid,
@@ -2618,10 +3791,10 @@ var ExecutionLedgerRepo = class {
   }
   list(input = {}) {
     const rows = this.db.prepare("SELECT * FROM executions ORDER BY created_at ASC").all();
-    const cwd = input.cwd ? path7.resolve(input.cwd) : void 0;
+    const cwd = input.cwd ? path9.resolve(input.cwd) : void 0;
     const statuses = new Set(input.statuses ?? []);
     const kinds = new Set(input.kinds ?? []);
-    return rows.map(fromExecutionRow).filter((record) => !input.kind || record.kind === input.kind).filter((record) => kinds.size === 0 || kinds.has(record.kind)).filter((record) => statuses.size === 0 || statuses.has(record.status)).filter((record) => !cwd || isSameOrDescendant(path7.resolve(record.cwd), cwd) || isSameOrDescendant(cwd, path7.resolve(record.cwd)));
+    return rows.map(fromExecutionRow).filter((record) => !input.kind || record.kind === input.kind).filter((record) => kinds.size === 0 || kinds.has(record.kind)).filter((record) => statuses.size === 0 || statuses.has(record.status)).filter((record) => !cwd || isSameOrDescendant(path9.resolve(record.cwd), cwd) || isSameOrDescendant(cwd, path9.resolve(record.cwd)));
   }
   markRunning(id, input) {
     const current = requireExecution(this.load(id), id);
@@ -2699,8 +3872,8 @@ function requireExecution(record, id) {
   return record;
 }
 function isSameOrDescendant(targetPath, possibleAncestor) {
-  const relative = path7.relative(possibleAncestor, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path7.isAbsolute(relative);
+  const relative = path9.relative(possibleAncestor, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path9.isAbsolute(relative);
 }
 
 // src/control/schema.ts
@@ -2814,7 +3987,7 @@ var TaskLifecycleLedgerRepo = class {
       stage: existing?.stage === "completed" || !existing ? "normal_work" : existing.stage,
       scope: existing?.scope,
       boundary: existing?.boundary,
-      reason: normalizeText2(input.reason) ?? existing?.reason ?? "turn_started",
+      reason: normalizeText3(input.reason) ?? existing?.reason ?? "turn_started",
       activeExecutionIds: existing?.activeExecutionIds ?? [],
       activeTodoIds: existing?.activeTodoIds ?? [],
       verificationFacts: existing?.verificationFacts ?? [],
@@ -2843,9 +4016,9 @@ var TaskLifecycleLedgerRepo = class {
     return this.save({
       ...current,
       stage: input.stage ?? current.stage,
-      scope: normalizeText2(input.scope) ?? current.scope,
-      boundary: normalizeText2(input.boundary) ?? current.boundary,
-      reason: normalizeText2(input.reason) ?? current.reason,
+      scope: normalizeText3(input.scope) ?? current.scope,
+      boundary: normalizeText3(input.boundary) ?? current.boundary,
+      reason: normalizeText3(input.reason) ?? current.reason,
       activeExecutionIds: normalizeStringList2(input.activeExecutionIds ?? current.activeExecutionIds),
       activeTodoIds: normalizeStringList2(input.activeTodoIds ?? current.activeTodoIds),
       verificationFacts: normalizeStringList2(input.verificationFacts ?? current.verificationFacts),
@@ -2961,7 +4134,7 @@ function normalizeStringList2(value) {
   const seen = /* @__PURE__ */ new Set();
   const items = [];
   for (const item of value) {
-    const text = normalizeText2(item);
+    const text = normalizeText3(item);
     if (!text || seen.has(text)) {
       continue;
     }
@@ -2970,7 +4143,7 @@ function normalizeStringList2(value) {
   }
   return items;
 }
-function normalizeText2(value) {
+function normalizeText3(value) {
   return typeof value === "string" && value.trim() ? value.replace(/\s+/g, " ").trim() : void 0;
 }
 
@@ -3010,7 +4183,7 @@ var ControlPlaneLedger = class {
   db;
   constructor(rootDir) {
     const statePaths = getProjectStatePaths(rootDir);
-    fs6.mkdirSync(statePaths.kittyDir, { recursive: true });
+    fs8.mkdirSync(statePaths.kittyDir, { recursive: true });
     this.db = new Database(statePaths.controlPlaneLedgerFile);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
@@ -3177,11 +4350,11 @@ function truncateWakeFact(value) {
 }
 
 // src/utils/fs.ts
-import fs7 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path10 from "path";
 async function fileExists(targetPath) {
   try {
-    await fs7.access(targetPath);
+    await fs9.access(targetPath);
     return true;
   } catch {
     return false;
@@ -3189,10 +4362,10 @@ async function fileExists(targetPath) {
 }
 function resolveUserPath(inputPath, cwd) {
   const cleanPath = normalizeUserPathInput(inputPath);
-  if (path8.isAbsolute(cleanPath)) {
-    return path8.normalize(cleanPath);
+  if (path10.isAbsolute(cleanPath)) {
+    return path10.normalize(cleanPath);
   }
-  return path8.resolve(cwd, cleanPath);
+  return path10.resolve(cwd, cleanPath);
 }
 function normalizeUserPathInput(inputPath) {
   const trimmed = inputPath.trim();
@@ -3206,7 +4379,7 @@ function normalizeUserPathInput(inputPath) {
   return trimmed;
 }
 async function ensureParentDirectory(filePath) {
-  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
+  await fs9.mkdir(path10.dirname(filePath), { recursive: true });
 }
 function truncateText(input, maxChars) {
   if (input.length <= maxChars) {
@@ -3258,7 +4431,7 @@ function projectToolResultForModel(input) {
   }
 }
 function projectExecutionAction(payload) {
-  const execution = readObject(payload.execution) ?? payload;
+  const execution = readObject2(payload.execution) ?? payload;
   return joinLines([
     readString(execution.id) ?? "execution",
     readString(execution.kind),
@@ -3266,7 +4439,7 @@ function projectExecutionAction(payload) {
     readString(execution.command),
     readString(execution.summary),
     readString(execution.outputPreview),
-    readObject(execution.health) ? readString(readObject(execution.health)?.message) : void 0,
+    readObject2(execution.health) ? readString(readObject2(execution.health)?.message) : void 0,
     readString(execution.error)
   ]);
 }
@@ -3293,10 +4466,10 @@ function projectExecutionCheck(payload) {
   ]);
 }
 function projectRead(payload) {
-  const path27 = readString(payload.path) ?? readString(payload.requestedPath) ?? "file";
+  const path29 = readString(payload.path) ?? readString(payload.requestedPath) ?? "file";
   if (payload.readable === false) {
     return joinLines([
-      `${path27}: not readable`,
+      `${path29}: not readable`,
       readString(payload.reason),
       readString(payload.detectedCapability) ? `capability: ${readString(payload.detectedCapability)}` : void 0
     ]);
@@ -3304,35 +4477,35 @@ function projectRead(payload) {
   const startLine = readNumber(payload.startLine);
   const endLine = readNumber(payload.endLine);
   const content = readString(payload.content) ?? "";
-  const continuation = readObject(payload.continuation);
-  const continuationArgs = readObject(continuation?.continuationArgs);
+  const continuation = readObject2(payload.continuation);
+  const continuationArgs = readObject2(continuation?.continuationArgs);
   return joinLines([
-    `${path27}${startLine && endLine ? `:${startLine}-${endLine}` : ""}`,
+    `${path29}${startLine && endLine ? `:${startLine}-${endLine}` : ""}`,
     truncateText(content, DEFAULT_MAX_CHARS),
     continuationArgs ? `next: read ${JSON.stringify(continuationArgs)}` : void 0
   ]);
 }
 function projectEdit(payload) {
-  const path27 = readString(payload.path) ?? "file";
+  const path29 = readString(payload.path) ?? "file";
   const applied = readNumber(payload.appliedEdits) ?? readNumber(payload.requestedEdits);
   const diff = readString(payload.diff) ?? readString(payload.preview);
   return joinLines([
-    `edited ${path27}${applied ? ` (${applied} replacement${applied === 1 ? "" : "s"})` : ""}`,
+    `edited ${path29}${applied ? ` (${applied} replacement${applied === 1 ? "" : "s"})` : ""}`,
     diff ? truncateText(diff, DIFF_MAX_CHARS) : void 0
   ]);
 }
 function projectWrite(payload) {
-  const path27 = readString(payload.path) ?? "file";
+  const path29 = readString(payload.path) ?? "file";
   const bytes = readNumber(payload.bytes);
   const existed = payload.existed === true;
   const diff = readString(payload.diff) ?? readString(payload.preview);
   return joinLines([
-    `${existed ? "wrote" : "created"} ${path27}${bytes !== void 0 ? ` (${bytes} bytes)` : ""}`,
+    `${existed ? "wrote" : "created"} ${path29}${bytes !== void 0 ? ` (${bytes} bytes)` : ""}`,
     diff ? truncateText(diff, DIFF_MAX_CHARS) : void 0
   ]);
 }
 function projectBash(payload) {
-  const governance = readObject(payload.outputGovernance);
+  const governance = readObject2(payload.outputGovernance);
   const projection = readString(governance?.projection);
   if (projection) {
     return projection;
@@ -3353,13 +4526,13 @@ function projectBash(payload) {
   return joinLines(lines);
 }
 function projectSkillLoad(payload) {
-  const skill = readObject(payload.skill);
+  const skill = readObject2(payload.skill);
   const name = readString(skill?.name) ?? "skill";
   const description = readString(skill?.description);
-  const path27 = readString(skill?.path);
+  const path29 = readString(skill?.path);
   const body = readString(payload.body) ?? "";
   return joinLines([
-    `loaded skill: ${name}${path27 ? ` (${path27})` : ""}`,
+    `loaded skill: ${name}${path29 ? ` (${path29})` : ""}`,
     description,
     truncateText(body, SKILL_BODY_MAX_CHARS)
   ]);
@@ -3389,8 +4562,8 @@ function projectFailure(toolName, rawOutput, payload) {
   if (!payload) {
     return truncateText(rawOutput.trim(), DEFAULT_MAX_CHARS);
   }
-  const details = readObject(payload.details);
-  const readArgs = readObject(details?.readArgs);
+  const details = readObject2(payload.details);
+  const readArgs = readObject2(details?.readArgs);
   const suggestions = readArray(details?.suggestions);
   const lines = [
     `${toolName} failed: ${readString(payload.error) ?? "unknown error"}`,
@@ -3412,7 +4585,7 @@ function parseObject(raw) {
     return null;
   }
 }
-function readObject(value) {
+function readObject2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function readArray(value) {
@@ -3447,14 +4620,14 @@ var ToolExecutionError = class extends Error {
 };
 
 // src/tools/outputCapture.ts
-import crypto from "crypto";
-import fs8 from "fs/promises";
-import path9 from "path";
+import crypto2 from "crypto";
+import fs10 from "fs/promises";
+import path11 from "path";
 var DEFAULT_BASH_OUTPUT_PREVIEW_CHARS = 12e3;
 async function createBashOutputCapture(input) {
   const maxPreviewChars = typeof input.maxPreviewChars === "number" && Number.isFinite(input.maxPreviewChars) && input.maxPreviewChars > 0 ? Math.trunc(input.maxPreviewChars) : DEFAULT_BASH_OUTPUT_PREVIEW_CHARS;
   const absoluteOutputPath = input.stateRootDir && input.sessionId ? await createAbsoluteOutputPath(input.stateRootDir, input.sessionId) : void 0;
-  const outputPath = absoluteOutputPath && input.stateRootDir ? path9.relative(input.stateRootDir, absoluteOutputPath) || void 0 : void 0;
+  const outputPath = absoluteOutputPath && input.stateRootDir ? path11.relative(input.stateRootDir, absoluteOutputPath) || void 0 : void 0;
   let preview = "";
   let bufferedOutput = "";
   let totalChars = 0;
@@ -3498,7 +4671,7 @@ async function createBashOutputCapture(input) {
     if (!absoluteOutputPath) {
       return;
     }
-    pendingWrite = pendingWrite.then(() => fs8.appendFile(absoluteOutputPath, chunk, "utf8"));
+    pendingWrite = pendingWrite.then(() => fs10.appendFile(absoluteOutputPath, chunk, "utf8"));
   }
   return {
     append,
@@ -3507,9 +4680,9 @@ async function createBashOutputCapture(input) {
 }
 async function createAbsoluteOutputPath(stateRootDir, sessionId) {
   const paths = getProjectStatePaths(stateRootDir);
-  const sessionDir = path9.join(paths.observabilityDir, "command-output", sessionId);
-  await fs8.mkdir(sessionDir, { recursive: true });
-  return path9.join(sessionDir, `${Date.now()}-bash-output-${crypto.randomUUID().slice(0, 8)}.txt`);
+  const sessionDir = path11.join(paths.observabilityDir, "command-output", sessionId);
+  await fs10.mkdir(sessionDir, { recursive: true });
+  return path11.join(sessionDir, `${Date.now()}-bash-output-${crypto2.randomUUID().slice(0, 8)}.txt`);
 }
 
 // src/utils/commandRunner/shellRuntime.ts
@@ -3723,8 +4896,8 @@ function isAbortedProcessResult(value, signal) {
 }
 
 // src/tools/core/shared.ts
-import fs9 from "fs/promises";
-import path10 from "path";
+import fs11 from "fs/promises";
+import path12 from "path";
 import { diffLines } from "diff";
 
 // src/utils/text.ts
@@ -3938,21 +5111,21 @@ function comparePathForDiscovery(root, left, right) {
   if (leftDepth !== rightDepth) {
     return leftDepth - rightDepth;
   }
-  const leftName = path10.posix.basename(leftRelative).toLowerCase();
-  const rightName = path10.posix.basename(rightRelative).toLowerCase();
+  const leftName = path12.posix.basename(leftRelative).toLowerCase();
+  const rightName = path12.posix.basename(rightRelative).toLowerCase();
   if (leftName !== rightName) {
     return leftName.localeCompare(rightName);
   }
   return leftRelative.localeCompare(rightRelative);
 }
 function toPosixRelative(root, targetPath) {
-  return (path10.relative(root, targetPath) || path10.basename(targetPath)).replace(/\\/g, "/");
+  return (path12.relative(root, targetPath) || path12.basename(targetPath)).replace(/\\/g, "/");
 }
 function pathDepth(relativePath) {
   return relativePath.split("/").filter(Boolean).length;
 }
 
-// src/tools/outputKernel/classifier.ts
+// src/tools/outputGovernance/classifier.ts
 function classifyToolOutput(source) {
   const output = source.output.trim();
   if (!output) {
@@ -3993,7 +5166,7 @@ function looksLikeBuild(command, text) {
   return /\b(build|compile|cargo check|cargo clippy|npm run build|pnpm build)\b/.test(command) || /\b(compilation failed|build failed|compiled successfully|error\[e\d+\])\b/.test(text);
 }
 
-// src/tools/outputKernel/metrics.ts
+// src/tools/outputGovernance/metrics.ts
 function estimateTextTokens(value) {
   const trimmed = value.trim();
   if (!trimmed) {
@@ -4018,7 +5191,7 @@ function computeSavings(input) {
   };
 }
 
-// src/tools/outputKernel/projectors/shared.ts
+// src/tools/outputGovernance/projectors/shared.ts
 function buildHeader(source, label) {
   return [
     `${source.toolName}: ${label}`,
@@ -4044,7 +5217,7 @@ function dedupeProjectedLines(lines) {
   return result;
 }
 
-// src/tools/outputKernel/projectors/diagnostic.ts
+// src/tools/outputGovernance/projectors/diagnostic.ts
 var STRUCTURED_MAX_LINES = 28;
 function buildDiagnosticProjection(source, label) {
   const lines = splitOutputLines(source.output);
@@ -4063,7 +5236,7 @@ function isSummaryLine(line) {
   return /\b(\d+\s+(passed|failed|skipped|errors?|warnings?)|test result|found \d+ errors?|failed tests?|build failed|compiled successfully)\b/i.test(line);
 }
 
-// src/tools/outputKernel/projectors/gitDiff.ts
+// src/tools/outputGovernance/projectors/gitDiff.ts
 var DIFF_MAX_FILES = 24;
 function buildGitDiffProjection(source) {
   const lines = splitOutputLines(source.output);
@@ -4078,7 +5251,7 @@ function buildGitDiffProjection(source) {
   ].filter((line) => Boolean(line)).join("\n");
 }
 
-// src/tools/outputKernel/projectors/generic.ts
+// src/tools/outputGovernance/projectors/generic.ts
 var GENERIC_MAX_CHARS = 1500;
 function projectEmptyOutput(source) {
   return {
@@ -4120,7 +5293,7 @@ function buildGenericPreview(source) {
   ].filter(Boolean).join("\n");
 }
 
-// src/tools/outputKernel/projectors/search.ts
+// src/tools/outputGovernance/projectors/search.ts
 var SEARCH_MAX_MATCHES = 24;
 function buildSearchProjection(source) {
   const nonEmptyLines = splitOutputLines(source.output).filter((line) => line.trim().length > 0);
@@ -4133,7 +5306,7 @@ function buildSearchProjection(source) {
   ].join("\n");
 }
 
-// src/tools/outputKernel/projectors/recovery.ts
+// src/tools/outputGovernance/projectors/recovery.ts
 function appendRecoveryHint(projection, governance) {
   if (!governance.recoveryHint) {
     return projection;
@@ -4145,7 +5318,7 @@ function appendRecoveryHint(projection, governance) {
 ${governance.recoveryHint}`;
 }
 
-// src/tools/outputKernel/projectors.ts
+// src/tools/outputGovernance/projectors.ts
 function projectOutputByKind(kind, source) {
   switch (kind) {
     case "empty":
@@ -4165,7 +5338,7 @@ function projectOutputByKind(kind, source) {
   }
 }
 
-// src/tools/outputKernel/index.ts
+// src/tools/outputGovernance/index.ts
 function governToolOutput(source) {
   const kind = classifyToolOutput(source);
   const projected = projectOutputByKind(kind, source);
@@ -4307,7 +5480,7 @@ var bashToolDefinition = {
 };
 
 // src/tools/edit.ts
-import fs11 from "fs/promises";
+import fs13 from "fs/promises";
 
 // src/tools/core/changeTracking.ts
 async function recordToolChange(context, input) {
@@ -4348,13 +5521,13 @@ function encodeUtf8(value) {
 }
 
 // src/tools/core/pathDisplay.ts
-import path11 from "path";
+import path13 from "path";
 function toToolRelativePath(cwd, targetPath) {
-  const relative = path11.relative(cwd, targetPath);
+  const relative = path13.relative(cwd, targetPath);
   if (!relative || relative === "") {
     return ".";
   }
-  if (relative.startsWith("..") || path11.isAbsolute(relative)) {
+  if (relative.startsWith("..") || path13.isAbsolute(relative)) {
     return targetPath;
   }
   return relative.replace(/\\/g, "/");
@@ -4381,8 +5554,8 @@ function buildToolChangeFeedback(input) {
 }
 
 // src/tools/writeDiagnostics.ts
-import fs10 from "fs/promises";
-import path12 from "path";
+import fs12 from "fs/promises";
+import path14 from "path";
 var TYPE_SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 async function collectWriteDiagnostics(paths) {
   const uniquePaths2 = takeUniquePaths(paths);
@@ -4429,7 +5602,7 @@ function createEmptyDiagnosticsReport(status) {
 }
 async function collectFileDiagnostics(targetPath) {
   try {
-    const extension = path12.extname(targetPath).toLowerCase();
+    const extension = path14.extname(targetPath).toLowerCase();
     if (extension === ".json") {
       return await collectJsonDiagnostics(targetPath);
     }
@@ -4445,7 +5618,7 @@ async function collectFileDiagnostics(targetPath) {
   return null;
 }
 async function collectJsonDiagnostics(targetPath) {
-  const content = await fs10.readFile(targetPath, "utf8");
+  const content = await fs12.readFile(targetPath, "utf8");
   const diagnostics = [];
   try {
     JSON.parse(content);
@@ -4466,7 +5639,7 @@ async function collectJsonDiagnostics(targetPath) {
 async function collectTypeScriptDiagnostics(targetPath) {
   const diagnostics = [];
   const TypeScript = await import("typescript");
-  const content = await fs10.readFile(targetPath, "utf8");
+  const content = await fs12.readFile(targetPath, "utf8");
   const transpiled = TypeScript.transpileModule(content, {
     fileName: targetPath,
     compilerOptions: {
@@ -4583,7 +5756,7 @@ var editToolDefinition = {
     const resolved = resolveUserPath(targetPath, context.cwd);
     const displayPath = toToolRelativePath(context.cwd, resolved);
     return withFileEditLock(resolved, async () => {
-      const beforeBuffer = await fs11.readFile(resolved);
+      const beforeBuffer = await fs13.readFile(resolved);
       const beforeEnvelope = decodeTextFileEnvelope(beforeBuffer);
       if (!beforeEnvelope) {
         throw new ToolExecutionError(`edit cannot edit binary or unsupported text encoding for ${displayPath}`, {
@@ -4601,7 +5774,7 @@ var editToolDefinition = {
         });
       }
       const diff = buildDiffPreview(before, after);
-      await fs11.writeFile(resolved, encodeTextFileEnvelope(after, beforeEnvelope));
+      await fs13.writeFile(resolved, encodeTextFileEnvelope(after, beforeEnvelope));
       const changeRecord = await recordToolChange(context, {
         toolName: "edit",
         summary: `edit ${displayPath}`,
@@ -4755,9 +5928,9 @@ function lineForOffset(input, offset) {
   }
   return line;
 }
-function buildReadArgs(path27, line) {
+function buildReadArgs(path29, line) {
   return {
-    path: path27,
+    path: path29,
     offset: Math.max(1, (line ?? 1) - 20),
     limit: 60
   };
@@ -4811,8 +5984,8 @@ async function withFileEditLock(filePath, action) {
 }
 
 // src/tools/core/fileIntrospection.ts
-import fs12 from "fs/promises";
-import path13 from "path";
+import fs14 from "fs/promises";
+import path15 from "path";
 var KNOWN_BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".epub",
   ".mobi",
@@ -4830,8 +6003,8 @@ var KNOWN_BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".bin"
 ]);
 async function inspectTextFile(filePath, _maxBytes) {
-  const stat = await fs12.stat(filePath);
-  const extension = path13.extname(filePath).toLowerCase();
+  const stat = await fs14.stat(filePath);
+  const extension = path15.extname(filePath).toLowerCase();
   if (KNOWN_BINARY_EXTENSIONS.has(extension)) {
     return {
       readable: false,
@@ -4841,7 +6014,7 @@ async function inspectTextFile(filePath, _maxBytes) {
       extension
     };
   }
-  const buffer = await fs12.readFile(filePath);
+  const buffer = await fs14.readFile(filePath);
   const decoded = decodeTextFileEnvelope(buffer);
   if (!decoded) {
     return {
@@ -4865,11 +6038,11 @@ async function inspectTextFile(filePath, _maxBytes) {
 }
 
 // src/tools/core/pathSuggestions.ts
-import path14 from "path";
+import path16 from "path";
 import fg3 from "fast-glob";
 async function findPathSuggestions(cwd, requestedPath, projectContext, limit = 8) {
   const normalized = normalizeUserPathInput(requestedPath).replace(/\\/g, "/");
-  const baseName = path14.basename(normalized).trim();
+  const baseName = path16.basename(normalized).trim();
   const needle = baseName.length > 0 ? baseName : normalized.trim();
   if (!needle) {
     return [];
@@ -4886,8 +6059,8 @@ async function findPathSuggestions(cwd, requestedPath, projectContext, limit = 8
       suppressErrors: true,
       ignore: buildFastGlobIgnorePatterns(cwd, projectContext.ignoreRules)
     });
-    for (const entry of entries.sort((left, right) => comparePathForDiscovery(cwd, path14.resolve(cwd, left), path14.resolve(cwd, right)))) {
-      const absolutePath = path14.resolve(cwd, entry);
+    for (const entry of entries.sort((left, right) => comparePathForDiscovery(cwd, path16.resolve(cwd, left), path16.resolve(cwd, right)))) {
+      const absolutePath = path16.resolve(cwd, entry);
       const isDirectory3 = entry.endsWith("/");
       if (isPathIgnored(absolutePath, projectContext.ignoreRules, isDirectory3)) {
         continue;
@@ -5052,7 +6225,7 @@ function fitWindowWithinBudget(lines, start, requestedEndExclusive, maxChars) {
 }
 
 // src/tools/write.ts
-import fs13 from "fs/promises";
+import fs15 from "fs/promises";
 var writeToolDefinition = {
   definition: {
     type: "function",
@@ -5088,12 +6261,12 @@ var writeToolDefinition = {
     const resolved = resolveUserPath(targetPath, context.cwd);
     const displayPath = toToolRelativePath(context.cwd, resolved);
     const existed = await fileExists(resolved);
-    const before = existed ? await fs13.readFile(resolved, "utf8") : "";
+    const before = existed ? await fs15.readFile(resolved, "utf8") : "";
     const preview = buildDiffPreview(before, content);
     if (createDirectories) {
       await ensureParentDirectory(resolved);
     }
-    await fs13.writeFile(resolved, content, "utf8");
+    await fs15.writeFile(resolved, content, "utf8");
     const changeRecord = await recordToolChange(context, {
       toolName: "write",
       summary: `write ${displayPath}`,
@@ -5148,7 +6321,7 @@ var writeToolDefinition = {
 };
 
 // src/tools/sendFile.ts
-import fs14 from "fs/promises";
+import fs16 from "fs/promises";
 var sendFileToolDefinition = {
   definition: {
     type: "function",
@@ -5191,7 +6364,7 @@ var sendFileToolDefinition = {
       };
     }
     try {
-      await fs14.access(filePath);
+      await fs16.access(filePath);
     } catch {
       return {
         ok: false,
@@ -5724,8 +6897,8 @@ async function executeToolBatch(params) {
 }
 
 // src/session/events.ts
-import fs15 from "fs/promises";
-import path15 from "path";
+import fs17 from "fs/promises";
+import path17 from "path";
 var SessionEventStore = class {
   constructor(eventsDir) {
     this.eventsDir = eventsDir;
@@ -5741,8 +6914,8 @@ var SessionEventStore = class {
       message: event.message,
       details: event.details
     };
-    await fs15.mkdir(this.eventsDir, { recursive: true });
-    await fs15.appendFile(this.getSessionEventPath(event.sessionId), `${JSON.stringify(record)}
+    await fs17.mkdir(this.eventsDir, { recursive: true });
+    await fs17.appendFile(this.getSessionEventPath(event.sessionId), `${JSON.stringify(record)}
 `, "utf8");
     return record;
   }
@@ -5750,7 +6923,7 @@ var SessionEventStore = class {
     const filePath = this.getSessionEventPath(sessionId);
     let raw = "";
     try {
-      raw = await fs15.readFile(filePath, "utf8");
+      raw = await fs17.readFile(filePath, "utf8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return [];
@@ -5760,7 +6933,7 @@ var SessionEventStore = class {
     return raw.split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line)).slice(-limit);
   }
   getSessionEventPath(sessionId) {
-    return path15.join(this.eventsDir, `${sanitizeSessionId(sessionId)}.jsonl`);
+    return path17.join(this.eventsDir, `${sanitizeSessionId(sessionId)}.jsonl`);
   }
 };
 function createEventId() {
@@ -6079,9 +7252,9 @@ function normalizeToolArguments(raw) {
 }
 
 // src/agent/changes/store.ts
-import crypto2 from "crypto";
-import fs16 from "fs/promises";
-import path16 from "path";
+import crypto3 from "crypto";
+import fs18 from "fs/promises";
+import path18 from "path";
 var ChangeStore = class {
   constructor(changesDir) {
     this.changesDir = changesDir;
@@ -6089,8 +7262,8 @@ var ChangeStore = class {
   async record(input) {
     const id = createChangeId();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const blobDir = path16.join(this.changesDir, id);
-    await fs16.mkdir(blobDir, { recursive: true });
+    const blobDir = path18.join(this.changesDir, id);
+    await fs18.mkdir(blobDir, { recursive: true });
     const operations = await Promise.all(
       input.operations.map(async (operation, index) => {
         const beforeSnapshotPath = await this.writeSnapshot(
@@ -6130,21 +7303,21 @@ var ChangeStore = class {
       preview: input.preview,
       operations
     };
-    await fs16.mkdir(this.changesDir, { recursive: true });
-    await fs16.writeFile(this.getMetadataPath(id), `${JSON.stringify(record, null, 2)}
+    await fs18.mkdir(this.changesDir, { recursive: true });
+    await fs18.writeFile(this.getMetadataPath(id), `${JSON.stringify(record, null, 2)}
 `, "utf8");
     return record;
   }
   async list(limit = 20) {
-    await fs16.mkdir(this.changesDir, { recursive: true });
-    const entries = await fs16.readdir(this.changesDir, { withFileTypes: true });
+    await fs18.mkdir(this.changesDir, { recursive: true });
+    const entries = await fs18.readdir(this.changesDir, { withFileTypes: true });
     const changes = await Promise.all(
-      entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => this.load(path16.basename(entry.name, ".json")))
+      entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => this.load(path18.basename(entry.name, ".json")))
     );
     return changes.sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, limit);
   }
   async load(id) {
-    const raw = await fs16.readFile(this.getMetadataPath(id), "utf8");
+    const raw = await fs18.readFile(this.getMetadataPath(id), "utf8");
     return JSON.parse(raw);
   }
   async loadLatestUndoable() {
@@ -6168,17 +7341,17 @@ var ChangeStore = class {
       restoredPaths.push(operation.path);
       if (operation.beforeSnapshotPath) {
         const buffer = await this.readSnapshot(operation.beforeSnapshotPath);
-        await fs16.mkdir(path16.dirname(operation.path), { recursive: true });
-        await fs16.writeFile(operation.path, buffer);
+        await fs18.mkdir(path18.dirname(operation.path), { recursive: true });
+        await fs18.writeFile(operation.path, buffer);
         continue;
       }
-      await fs16.rm(operation.path, { force: true });
+      await fs18.rm(operation.path, { force: true });
     }
     const updated = {
       ...record,
       undoneAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await fs16.writeFile(this.getMetadataPath(updated.id), `${JSON.stringify(updated, null, 2)}
+    await fs18.writeFile(this.getMetadataPath(updated.id), `${JSON.stringify(updated, null, 2)}
 `, "utf8");
     return {
       record: updated,
@@ -6186,24 +7359,24 @@ var ChangeStore = class {
     };
   }
   getMetadataPath(id) {
-    return path16.join(this.changesDir, `${id}.json`);
+    return path18.join(this.changesDir, `${id}.json`);
   }
   async writeSnapshot(blobDir, label, buffer) {
     if (!buffer) {
       return void 0;
     }
     const fileName = `${label}.bin`;
-    const absolutePath = path16.join(blobDir, fileName);
-    await fs16.writeFile(absolutePath, buffer);
-    return path16.relative(this.changesDir, absolutePath);
+    const absolutePath = path18.join(blobDir, fileName);
+    await fs18.writeFile(absolutePath, buffer);
+    return path18.relative(this.changesDir, absolutePath);
   }
   async readSnapshot(relativePath) {
-    return fs16.readFile(path16.join(this.changesDir, relativePath));
+    return fs18.readFile(path18.join(this.changesDir, relativePath));
   }
 };
 function createChangeId() {
   const date = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
-  const random = crypto2.randomUUID().slice(0, 8);
+  const random = crypto3.randomUUID().slice(0, 8);
   return `${date}-${random}`;
 }
 
@@ -6777,20 +7950,20 @@ function createBackgroundTools() {
 }
 
 // src/extensions/tools/network/tools/downloadUrl.ts
-import fs18 from "fs/promises";
+import fs20 from "fs/promises";
 
 // src/extensions/shared.ts
-import fs17 from "fs/promises";
-import path17 from "path";
+import fs19 from "fs/promises";
+import path19 from "path";
 async function ensureExtensionDir(rootDir, extensionId) {
   const paths = await ensureProjectStateDirectories(rootDir);
-  const dir = path17.join(paths.extensionsDir, extensionId);
-  await fs17.mkdir(dir, { recursive: true });
+  const dir = path19.join(paths.extensionsDir, extensionId);
+  await fs19.mkdir(dir, { recursive: true });
   return dir;
 }
 async function readJsonFile(filePath, fallback) {
   try {
-    return JSON.parse(await fs17.readFile(filePath, "utf8"));
+    return JSON.parse(await fs19.readFile(filePath, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") {
       return fallback;
@@ -6799,8 +7972,8 @@ async function readJsonFile(filePath, fallback) {
   }
 }
 async function writeJsonFile(filePath, value) {
-  await fs17.mkdir(path17.dirname(filePath), { recursive: true });
-  await fs17.writeFile(filePath, `${JSON.stringify(value, null, 2)}
+  await fs19.mkdir(path19.dirname(filePath), { recursive: true });
+  await fs19.writeFile(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 function jsonResult(value) {
@@ -6816,7 +7989,7 @@ function sanitizeStateSegment(value) {
 }
 
 // src/extensions/tools/network/session.ts
-import path18 from "path";
+import path20 from "path";
 async function listHttpSessions(rootDir) {
   const state = await readJsonFile(await sessionFile(rootDir), { sessions: [] });
   return Array.isArray(state.sessions) ? state.sessions.map(normalizeSession) : [];
@@ -6841,7 +8014,7 @@ async function getHttpSessionStateFile(rootDir) {
   return sessionFile(rootDir);
 }
 async function sessionFile(rootDir) {
-  return path18.join(await ensureExtensionDir(rootDir, "network"), "http-sessions.json");
+  return path20.join(await ensureExtensionDir(rootDir, "network"), "http-sessions.json");
 }
 function normalizeSession(value) {
   return {
@@ -7070,7 +8243,7 @@ var downloadUrlTool = {
     }
     const bytes = Buffer.from(await response.arrayBuffer());
     await ensureParentDirectory(targetPath);
-    await fs18.writeFile(targetPath, bytes);
+    await fs20.writeFile(targetPath, bytes);
     return changedJsonResult({
       ok: response.ok,
       url,
@@ -7135,17 +8308,17 @@ var httpProbeTool = {
 };
 
 // src/extensions/tools/network/traceStore.ts
-import fs19 from "fs/promises";
-import path19 from "path";
+import fs21 from "fs/promises";
+import path21 from "path";
 async function writeNetworkTrace(rootDir, traceId, record) {
   const filePath = await networkTraceFilePath(rootDir, traceId);
-  await fs19.mkdir(path19.dirname(filePath), { recursive: true });
-  await fs19.writeFile(filePath, `${JSON.stringify(record, null, 2)}
+  await fs21.mkdir(path21.dirname(filePath), { recursive: true });
+  await fs21.writeFile(filePath, `${JSON.stringify(record, null, 2)}
 `, "utf8");
   return filePath;
 }
 async function networkTraceFilePath(rootDir, traceId) {
-  return path19.join(await ensureExtensionDir(rootDir, "network"), "traces", `${sanitizeStateSegment(traceId)}.json`);
+  return path21.join(await ensureExtensionDir(rootDir, "network"), "traces", `${sanitizeStateSegment(traceId)}.json`);
 }
 
 // src/extensions/tools/network/tools/httpRequest.ts
@@ -7545,14 +8718,14 @@ function readStringMap2(value) {
 }
 
 // src/extensions/tools/network/openapi.ts
-import fs20 from "fs/promises";
+import fs22 from "fs/promises";
 async function loadOpenApiDocument(source, context) {
   const normalizedSource = source.trim();
   if (!normalizedSource) {
     throw new ToolExecutionError("OpenAPI source is required.", { code: "OPENAPI_SOURCE_INVALID" });
   }
   const resolvedSource = /^https?:\/\//i.test(normalizedSource) ? normalizedSource : resolveUserPath(normalizedSource, context.cwd);
-  const raw = /^https?:\/\//i.test(normalizedSource) ? await (await fetchWithTimeout(normalizedSource, { method: "GET" }, 2e4, context.abortSignal)).text() : stripBom(await fs20.readFile(resolvedSource, "utf8"));
+  const raw = /^https?:\/\//i.test(normalizedSource) ? await (await fetchWithTimeout(normalizedSource, { method: "GET" }, 2e4, context.abortSignal)).text() : stripBom(await fs22.readFile(resolvedSource, "utf8"));
   const parsed = parseOpenApiDocument(raw, normalizedSource);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new ToolExecutionError("OpenAPI document root must be an object.", { code: "OPENAPI_ROOT_INVALID" });
@@ -7900,8 +9073,8 @@ async function recordSkillUse(rootDir, input) {
 }
 
 // src/extensions/tools/skills/tools/skillReadResource.ts
-import fs21 from "fs/promises";
-import path20 from "path";
+import fs23 from "fs/promises";
+import path22 from "path";
 var MAX_RESOURCE_CHARS = 24e3;
 var skillReadResourceTool = {
   definition: {
@@ -7938,8 +9111,8 @@ var skillReadResourceTool = {
     if (!resource) {
       throw new Error(`Skill "${name}" does not declare resource: ${requestedPath}`);
     }
-    const absolutePath = path20.resolve(context.projectContext.rootDir, resource.path);
-    const content = await fs21.readFile(absolutePath, "utf8");
+    const absolutePath = path22.resolve(context.projectContext.rootDir, resource.path);
+    const content = await fs23.readFile(absolutePath, "utf8");
     return jsonResult({
       ok: true,
       skill: {
@@ -7957,7 +9130,7 @@ function normalizeResourcePath(value) {
 }
 
 // src/extensions/tools/skills/tools/skillRunScript.ts
-import path21 from "path";
+import path23 from "path";
 var skillRunScriptTool = {
   definition: {
     type: "function",
@@ -8001,12 +9174,12 @@ var skillRunScriptTool = {
     if (!resource) {
       throw new Error(`Skill "${name}" does not declare script resource: ${requestedPath}`);
     }
-    const skillDir = path21.dirname(skill.path);
-    const relativeToSkill = normalizeResourcePath2(path21.relative(skillDir, resource.path));
+    const skillDir = path23.dirname(skill.path);
+    const relativeToSkill = normalizeResourcePath2(path23.relative(skillDir, resource.path));
     if (!relativeToSkill.startsWith("scripts/")) {
       throw new Error(`Skill "${name}" resource is not executable because it is outside scripts/: ${requestedPath}`);
     }
-    const scriptPath = path21.resolve(context.projectContext.rootDir, resource.path);
+    const scriptPath = path23.resolve(context.projectContext.rootDir, resource.path);
     const argumentText = typeof args.args === "string" ? args.args.trim() : "";
     const command = buildScriptCommand(scriptPath, argumentText);
     const result = await runCommandWithPolicy({
@@ -8081,7 +9254,7 @@ function quotePath(value) {
   return `"${value.replace(/"/g, '\\"')}"`;
 }
 function buildScriptCommand(scriptPath, argumentText) {
-  const extension = path21.extname(scriptPath).toLowerCase();
+  const extension = path23.extname(scriptPath).toLowerCase();
   const quoted = quotePath(scriptPath);
   const suffix = argumentText ? ` ${argumentText}` : "";
   if (extension === ".js" || extension === ".mjs" || extension === ".cjs") {
@@ -8135,12 +9308,12 @@ var subagentCheckTool = {
 
 // src/execution/launch.ts
 import { spawn } from "child_process";
-import path22 from "path";
+import path24 from "path";
 function spawnExecutionWorker(input) {
   if (process.env.KITTY_TEST_WORKER_MODE === "stub") {
     return process.pid;
   }
-  const cliEntry = path22.resolve(process.argv[1] ?? "");
+  const cliEntry = path24.resolve(process.argv[1] ?? "");
   if (!cliEntry) {
     throw new Error("Unable to locate Kitty CLI entrypoint for execution worker.");
   }
@@ -8346,7 +9519,7 @@ function parseWorktreeBlock(block) {
 }
 
 // src/extensions/tools/worktree/state.ts
-import path23 from "path";
+import path25 from "path";
 async function readWorktreeState(rootDir) {
   return normalizeWorktreeState(await readJsonFile(await stateFile(rootDir), {
     schemaVersion: 1,
@@ -8369,7 +9542,7 @@ async function recordWorktreeEvent(rootDir, event) {
   return writeWorktreeState(rootDir, state);
 }
 async function stateFile(rootDir) {
-  return path23.join(await ensureExtensionDir(rootDir, "worktree"), "state.json");
+  return path25.join(await ensureExtensionDir(rootDir, "worktree"), "state.json");
 }
 function normalizeWorktreeState(value) {
   return {
@@ -8991,9 +10164,56 @@ function looksLikeToolProtocolText(content) {
   return text.includes("<\uFF5C\uFF5CDSML\uFF5C\uFF5Ctool_calls>") || text.includes("<tool_call>") || text.includes('"tool_calls"');
 }
 
+// src/host/delegatedCloseout.ts
+async function completeExactDelegatedCloseout(input) {
+  const answer = resolveExactDelegatedAnswer(input.executions);
+  if (!answer) {
+    return void 0;
+  }
+  const transition = createFinalizeTransition({
+    changedPaths: []
+  });
+  const sessionWithAnswer = await input.sessionStore.appendMessages(input.session, [
+    createMessage("assistant", answer)
+  ]);
+  const session = await input.sessionStore.save(noteCheckpointCompleted(sessionWithAnswer, transition));
+  const ledger = new ControlPlaneLedger(input.stateRootDir);
+  try {
+    ledger.taskLifecycle.complete({
+      sessionId: session.id,
+      reason: "finalize.delegated_exact_output",
+      completionFacts: [answer]
+    });
+  } finally {
+    ledger.close();
+  }
+  input.callbacks?.onAssistantText?.(answer);
+  input.callbacks?.onAssistantDone?.(answer);
+  return buildRunTurnResult({
+    session,
+    changedPaths: [],
+    transition
+  });
+}
+function resolveExactDelegatedAnswer(executions) {
+  if (executions.length !== 1) {
+    return void 0;
+  }
+  const [execution] = executions;
+  if (!execution || execution.status !== "completed") {
+    return void 0;
+  }
+  const expected = execution.assignment?.expectedOutput?.trim();
+  const output = execution.output?.trim();
+  if (!expected || !output || expected !== output) {
+    return void 0;
+  }
+  return output;
+}
+
 // src/observability/crashRecorder.ts
-import fs22 from "fs";
-import path24 from "path";
+import fs24 from "fs";
+import path26 from "path";
 var activeCrashContexts = /* @__PURE__ */ new Map();
 var nextCrashContextId = 0;
 function enterCrashContext(context) {
@@ -9005,7 +10225,7 @@ function enterCrashContext(context) {
 }
 
 // src/observability/hostEvents.ts
-import path25 from "path";
+import path27 from "path";
 async function recordHostTurnStarted(rootDir, input) {
   await recordObservabilityEvent(rootDir, {
     event: "host.turn",
@@ -9267,51 +10487,6 @@ async function runHostTurn(options, dependencies = {}) {
     await toolRegistry?.close?.().catch(() => void 0);
   }
 }
-async function completeExactDelegatedCloseout(input) {
-  const answer = resolveExactDelegatedAnswer(input.executions);
-  if (!answer) {
-    return void 0;
-  }
-  const transition = createFinalizeTransition({
-    changedPaths: []
-  });
-  const sessionWithAnswer = await input.sessionStore.appendMessages(input.session, [
-    createMessage("assistant", answer)
-  ]);
-  const session = await input.sessionStore.save(noteCheckpointCompleted(sessionWithAnswer, transition));
-  const ledger = new ControlPlaneLedger(input.stateRootDir);
-  try {
-    ledger.taskLifecycle.complete({
-      sessionId: session.id,
-      reason: "finalize.delegated_exact_output",
-      completionFacts: [answer]
-    });
-  } finally {
-    ledger.close();
-  }
-  input.callbacks?.onAssistantText?.(answer);
-  input.callbacks?.onAssistantDone?.(answer);
-  return buildRunTurnResult({
-    session,
-    changedPaths: [],
-    transition
-  });
-}
-function resolveExactDelegatedAnswer(executions) {
-  if (executions.length !== 1) {
-    return void 0;
-  }
-  const [execution] = executions;
-  if (!execution || execution.status !== "completed") {
-    return void 0;
-  }
-  const expected = execution.assignment?.expectedOutput?.trim();
-  const output = execution.output?.trim();
-  if (!expected || !output || expected !== output) {
-    return void 0;
-  }
-  return output;
-}
 function createToollessRegistry(registry) {
   return {
     ...registry,
@@ -9356,7 +10531,7 @@ function tryParseJson(input) {
 }
 
 // src/runtime-ui/pathDisplay.ts
-import path26 from "path";
+import path28 from "path";
 function normalizeDisplayPath(value, cwd) {
   if (!value) {
     return value;
@@ -9364,10 +10539,10 @@ function normalizeDisplayPath(value, cwd) {
   if (!cwd) {
     return value;
   }
-  const normalizedCwd = path26.resolve(cwd);
-  const normalizedValue = path26.resolve(value);
-  if (normalizedValue === normalizedCwd || normalizedValue.startsWith(`${normalizedCwd}${path26.sep}`)) {
-    return path26.relative(normalizedCwd, normalizedValue) || ".";
+  const normalizedCwd = path28.resolve(cwd);
+  const normalizedValue = path28.resolve(value);
+  if (normalizedValue === normalizedCwd || normalizedValue.startsWith(`${normalizedCwd}${path28.sep}`)) {
+    return path28.relative(normalizedCwd, normalizedValue) || ".";
   }
   return value;
 }
@@ -9375,7 +10550,7 @@ function rewriteAbsolutePaths(value, cwd) {
   if (!cwd) {
     return value;
   }
-  const normalizedCwd = path26.resolve(cwd).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const normalizedCwd = path28.resolve(cwd).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const pattern = new RegExp(`${normalizedCwd}(?:\\\\[^\\s"']*|/[^\\s"']*)*`, "g");
   return value.replace(pattern, (match) => normalizeDisplayPath(match, cwd) ?? match);
 }
@@ -9435,24 +10610,24 @@ function buildToolCallDisplay(name, rawArgs, maxChars, cwd) {
     };
   }
   const args = parsed;
-  const path27 = normalizeDisplayPath(readStringField(args, "path"), cwd);
+  const path29 = normalizeDisplayPath(readStringField(args, "path"), cwd);
   switch (name) {
     case "read": {
       const offset = typeof args.offset === "number" ? Math.trunc(args.offset) : void 0;
       const limit = typeof args.limit === "number" ? Math.trunc(args.limit) : void 0;
       const range = offset === void 0 ? "" : limit === void 0 ? `:${offset}` : `:${offset}-${Math.max(offset, offset + limit - 1)}`;
       return {
-        summary: `${name} ${path27 ?? "(missing path)"}${range}`
+        summary: `${name} ${path29 ?? "(missing path)"}${range}`
       };
     }
     case "write":
       return {
-        summary: `${name} ${path27 ?? "(missing path)"}`
+        summary: `${name} ${path29 ?? "(missing path)"}`
       };
     case "edit": {
       const edits = Array.isArray(args.edits) ? args.edits : [];
       return {
-        summary: `${name} ${path27 ?? "(missing path)"}` + (edits.length > 0 ? ` edits=${edits.length}` : "")
+        summary: `${name} ${path29 ?? "(missing path)"}` + (edits.length > 0 ? ` edits=${edits.length}` : "")
       };
     }
     case "bash": {
@@ -9464,7 +10639,7 @@ function buildToolCallDisplay(name, rawArgs, maxChars, cwd) {
     }
     case "download_url":
       return {
-        summary: `${name} ${readStringField(args, "url") ?? "(missing url)"} -> ${path27 ?? "(missing path)"}`
+        summary: `${name} ${readStringField(args, "url") ?? "(missing url)"} -> ${path29 ?? "(missing path)"}`
       };
     case "http_probe": {
       const method = readStringField(args, "method") ?? "HEAD";
@@ -9505,14 +10680,14 @@ function buildToolCallDisplay(name, rawArgs, maxChars, cwd) {
     case "worktree_create": {
       const branch = readStringField(args, "branch");
       return {
-        summary: `${name} ${path27 ?? "(missing path)"}${branch ? ` branch=${branch}` : ""}`
+        summary: `${name} ${path29 ?? "(missing path)"}${branch ? ` branch=${branch}` : ""}`
       };
     }
     case "worktree_get":
     case "worktree_keep":
     case "worktree_remove":
       return {
-        summary: `${name} ${path27 ?? "(missing path)"}`
+        summary: `${name} ${path29 ?? "(missing path)"}`
       };
     case "worktree_events": {
       const limit = typeof args.limit === "number" ? Math.trunc(args.limit) : void 0;
@@ -9651,7 +10826,7 @@ function colorizeMarker(marker) {
 }
 
 // src/utils/stdio.ts
-import fs23 from "fs";
+import fs25 from "fs";
 var stdoutBroken = false;
 var stderrBroken = false;
 function writeStdout(text) {
@@ -9677,7 +10852,7 @@ function writeToFd(fd, text, stream) {
     if (target.isTTY) {
       return target.write(text);
     }
-    fs23.writeSync(fd, text, void 0, "utf8");
+    fs25.writeSync(fd, text, void 0, "utf8");
     return true;
   } catch (error) {
     if (isIgnorableStreamError(error)) {
@@ -9960,6 +11135,12 @@ function formatRuntimeUiMessage(prefix, summary, detail) {
 export {
   resolveProjectRoots,
   buildProjectMap,
+  PROJECT_STATE_DIR_NAME,
+  PROJECT_STATE_ENV_FILE_NAME,
+  PROJECT_STATE_ENV_EXAMPLE_FILE_NAME,
+  PROJECT_STATE_IGNORE_FILE_NAME,
+  PRESERVED_PROJECT_STATE_ENTRY_NAMES,
+  getProjectStatePaths,
   loadProjectContext,
   getErrorMessage,
   ControlPlaneLedger,