@jun133/kitty 0.0.13 → 0.0.15

package/dist/{chunk-MMIH75OY.mjs → chunk-7FDXKNTM.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-S4QTRPZ7.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,1149 @@ 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/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: normalizeOutputText(response),
+        reasoningContent: readResponseReasoning(response),
+        streamedAssistantContent: false,
+        streamedReasoningContent: false,
+        toolCalls: readResponseToolCalls(response)
+      };
+    } finally {
+      request.onRequestMetric?.({
+        durationMs: Date.now() - startedAt,
+        usage
+      });
+    }
+  }
+};
+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;
+}
+function normalizeOutputText(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 readResponseToolCalls(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 readResponseReasoning(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;
+}
+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
@@ -1650,7 +2807,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 +2837,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 +2862,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 +2898,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 +2934,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 +2946,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 +3093,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 +3125,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 +3361,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 +3412,8 @@ async function updateSessionMemoryAfterTurn(input) {
       error
     });
     return input.session;
+  } finally {
+    input.options.callbacks?.onStatus?.("");
   }
 }
 async function updateSessionTitleAfterTurn(input) {
@@ -2299,6 +3461,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 +3513,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 +3752,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 +3783,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 +3864,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 +3979,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 +4008,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 +4126,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 +4135,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 +4175,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 +4342,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 +4354,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 +4371,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 +4423,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 +4431,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 +4458,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 +4469,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 +4518,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 +4554,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 +4577,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 +4612,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;
@@ -3492,507 +4657,125 @@ async function createBashOutputCapture(input) {
       truncated,
       outputChars: totalChars,
       outputBytes: totalBytes
-    };
-  }
-  function queueWrite(chunk) {
-    if (!absoluteOutputPath) {
-      return;
-    }
-    pendingWrite = pendingWrite.then(() => fs8.appendFile(absoluteOutputPath, chunk, "utf8"));
-  }
-  return {
-    append,
-    finalize
-  };
-}
-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`);
-}
-
-// src/utils/commandRunner/shellRuntime.ts
-function getShellRuntimeInfo(platform = process.platform) {
-  if (platform === "win32") {
-    return {
-      platform,
-      shell: "powershell",
-      executable: "powershell.exe",
-      invocation: "powershell.exe -NoLogo -NoProfile -EncodedCommand <command>",
-      guidance: "Windows runs commands through PowerShell; use PowerShell syntax, semicolon-separated commands, node -e, python -c, or an explicit bash invocation for Bash/POSIX syntax."
-    };
-  }
-  return {
-    platform,
-    shell: "bash",
-    executable: "/bin/bash",
-    invocation: "/bin/bash -lc <command>",
-    guidance: "Unix-like platforms run commands through bash -lc; use Bash syntax."
-  };
-}
-
-// src/utils/commandRunner/launch.ts
-async function launchCommand(command, cwd, timeoutMs, abortSignal) {
-  const execa4 = await loadExeca();
-  const shell = getShellRuntimeInfo();
-  const subprocess = shell.shell === "powershell" ? execa4(shell.executable, ["-NoLogo", "-NoProfile", "-EncodedCommand", encodePowerShellCommand(command)], {
-    cwd,
-    timeout: timeoutMs,
-    cancelSignal: abortSignal,
-    all: true,
-    buffer: false,
-    reject: false,
-    env: buildCommandEnvironment()
-  }) : execa4(shell.executable, ["-lc", command], {
-    cwd,
-    timeout: timeoutMs,
-    cancelSignal: abortSignal,
-    all: true,
-    buffer: false,
-    reject: false,
-    env: buildCommandEnvironment()
-  });
-  return { subprocess };
-}
-function encodePowerShellCommand(command) {
-  const wrapped = [
-    "$ProgressPreference = 'SilentlyContinue'",
-    "[Console]::InputEncoding = [System.Text.Encoding]::UTF8",
-    "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8",
-    "$OutputEncoding = [System.Text.Encoding]::UTF8",
-    "try { chcp 65001 > $null } catch { }",
-    `& { ${command} }`,
-    "$code = if ($null -ne $LASTEXITCODE) { [int]$LASTEXITCODE } elseif ($?) { 0 } else { 1 }",
-    "exit $code"
-  ].join("; ");
-  return Buffer.from(wrapped, "utf16le").toString("base64");
-}
-function buildCommandEnvironment() {
-  return {
-    ...process.env,
-    LANG: process.env.LANG || "C.UTF-8",
-    LC_ALL: process.env.LC_ALL || "C.UTF-8",
-    PYTHONIOENCODING: process.env.PYTHONIOENCODING || "utf-8"
-  };
-}
-
-// src/utils/commandRunner/platformArgs.ts
-function splitByAndAnd(command) {
-  const segments = [];
-  let current = "";
-  let inSingle = false;
-  let inDouble = false;
-  for (let index = 0; index < command.length; index += 1) {
-    const char = command.charAt(index);
-    if (char === "'" && !inDouble) {
-      inSingle = !inSingle;
-      current += char;
-      continue;
-    }
-    if (char === '"' && !inSingle) {
-      inDouble = !inDouble;
-      current += char;
-      continue;
-    }
-    if (!inSingle && !inDouble && char === "&" && command.charAt(index + 1) === "&") {
-      if (current.trim()) {
-        segments.push(current.trim());
-      }
-      current = "";
-      index += 1;
-      continue;
-    }
-    current += char;
-  }
-  if (current.trim()) {
-    segments.push(current.trim());
-  }
-  return segments.length > 0 ? segments : [command];
-}
-function joinWithAndSemantics(segments) {
-  if (segments.length <= 1) {
-    return segments[0] ?? "";
-  }
-  let script = segments[0] ?? "";
-  for (let index = 1; index < segments.length; index += 1) {
-    const segment = segments[index];
-    script += `; if ($?) { ${segment} }`;
-  }
-  return script;
-}
-function splitArgs(command) {
-  const args = [];
-  let current = "";
-  let inSingle = false;
-  let inDouble = false;
-  for (let index = 0; index < command.length; index += 1) {
-    const char = command.charAt(index);
-    if (char === "'" && !inDouble) {
-      inSingle = !inSingle;
-      continue;
-    }
-    if (char === '"' && !inSingle) {
-      inDouble = !inDouble;
-      continue;
-    }
-    if (!inSingle && !inDouble && /\s/.test(char)) {
-      if (current) {
-        args.push(current);
-        current = "";
-      }
-      continue;
-    }
-    current += char;
-  }
-  if (current) {
-    args.push(current);
-  }
-  return args;
-}
-function expandPaths(paths) {
-  return paths.flatMap((targetPath) => expandBraces(targetPath));
-}
-function normalizeWindowsPath(value) {
-  if (value.includes("://")) {
-    return value;
-  }
-  return value.replace(/\//g, "\\");
-}
-function quotePowerShell(value) {
-  const escaped = value.replace(/'/g, "''");
-  return `'${escaped}'`;
-}
-function expandBraces(input) {
-  const start = findBraceStart(input);
-  if (start === -1) {
-    return [input];
-  }
-  const end = findMatchingBrace(input, start);
-  if (end === -1) {
-    return [input];
-  }
-  const prefix = input.slice(0, start);
-  const suffix = input.slice(end + 1);
-  const body = input.slice(start + 1, end);
-  const parts = splitBraceParts(body);
-  const expandedSuffix = expandBraces(suffix);
-  const results = [];
-  for (const part of parts) {
-    for (const expandedPart of expandBraces(part)) {
-      for (const tail of expandedSuffix) {
-        results.push(`${prefix}${expandedPart}${tail}`);
-      }
-    }
-  }
-  return results;
-}
-function findBraceStart(input) {
-  let inSingle = false;
-  let inDouble = false;
-  for (let index = 0; index < input.length; index += 1) {
-    const char = input.charAt(index);
-    if (char === "'" && !inDouble) {
-      inSingle = !inSingle;
-      continue;
-    }
-    if (char === '"' && !inSingle) {
-      inDouble = !inDouble;
-      continue;
-    }
-    if (!inSingle && !inDouble && char === "{") {
-      return index;
-    }
-  }
-  return -1;
-}
-function findMatchingBrace(input, start) {
-  let depth = 0;
-  let inSingle = false;
-  let inDouble = false;
-  for (let index = start; index < input.length; index += 1) {
-    const char = input.charAt(index);
-    if (char === "'" && !inDouble) {
-      inSingle = !inSingle;
-      continue;
-    }
-    if (char === '"' && !inSingle) {
-      inDouble = !inDouble;
-      continue;
-    }
-    if (inSingle || inDouble) {
-      continue;
-    }
-    if (char === "{") {
-      depth += 1;
-    } else if (char === "}") {
-      depth -= 1;
-      if (depth === 0) {
-        return index;
-      }
-    }
-  }
-  return -1;
-}
-function splitBraceParts(input) {
-  const parts = [];
-  let current = "";
-  let depth = 0;
-  for (let index = 0; index < input.length; index += 1) {
-    const char = input.charAt(index);
-    if (char === "{") {
-      depth += 1;
-      current += char;
-      continue;
-    }
-    if (char === "}") {
-      depth -= 1;
-      current += char;
-      continue;
-    }
-    if (char === "," && depth === 0) {
-      parts.push(current);
-      current = "";
-      continue;
-    }
-    current += char;
-  }
-  if (current) {
-    parts.push(current);
-  }
-  return parts.length > 0 ? parts : [input];
-}
-
-// src/utils/commandRunner/platformTransforms.ts
-function startsWithExplicitShell(command) {
-  return /^\s*(cmd(?:\.exe)?\s+\/c|powershell(?:\.exe)?\b|pwsh\b|bash\b)/i.test(command);
-}
-function normalizeWindowsSegment(segment) {
-  const trimmed = segment.trim();
-  if (!trimmed) {
-    return segment;
-  }
-  const lowered = trimmed.toLowerCase();
-  if (lowered.startsWith("get-childitem") || lowered.startsWith("new-item")) {
-    return segment;
-  }
-  if (lowered.startsWith("ls")) {
-    return normalizeLsSegment(trimmed);
-  }
-  if (lowered.startsWith("mkdir") || lowered.startsWith("md ")) {
-    return normalizeMkdirSegment(trimmed);
-  }
-  if (lowered.startsWith("rm ")) {
-    return normalizeRemoveSegment(trimmed);
-  }
-  if (lowered.startsWith("cp ")) {
-    return normalizeCopySegment(trimmed);
-  }
-  if (lowered.startsWith("mv ")) {
-    return normalizeMoveSegment(trimmed);
-  }
-  if (lowered.startsWith("touch ")) {
-    return normalizeTouchSegment(trimmed);
+    };
   }
-  if (lowered.startsWith("cat ")) {
-    return normalizeCatSegment(trimmed);
+  function queueWrite(chunk) {
+    if (!absoluteOutputPath) {
+      return;
+    }
+    pendingWrite = pendingWrite.then(() => fs10.appendFile(absoluteOutputPath, chunk, "utf8"));
   }
-  return segment;
+  return {
+    append,
+    finalize
+  };
 }
-function normalizeLsSegment(segment) {
-  const args = splitArgs(segment).slice(1);
-  const flags = args.filter((arg) => arg.startsWith("-"));
-  const paths = args.filter((arg) => !arg.startsWith("-"));
-  const force = flags.some((flag) => flag.includes("a"));
-  const targetPath = paths[0];
-  let command = "Get-ChildItem";
-  if (force) {
-    command += " -Force";
-  }
-  if (targetPath) {
-    command += ` -LiteralPath ${quotePowerShell(normalizeWindowsPath(targetPath))}`;
-  }
-  return command;
+async function createAbsoluteOutputPath(stateRootDir, sessionId) {
+  const paths = getProjectStatePaths(stateRootDir);
+  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`);
 }
-function normalizeMkdirSegment(segment) {
-  const args = splitArgs(segment);
-  if (args.length <= 1) {
-    return segment;
+
+// src/utils/commandRunner/shellRuntime.ts
+function getShellRuntimeInfo(platform = process.platform) {
+  if (platform === "win32") {
+    return {
+      platform,
+      shell: "powershell",
+      executable: "powershell.exe",
+      invocation: "powershell.exe -NoLogo -NoProfile -EncodedCommand <command>",
+      guidance: "Windows runs commands through PowerShell; use PowerShell syntax, semicolon-separated commands, node -e, python -c, or an explicit bash invocation for Bash/POSIX syntax."
+    };
   }
-  const rest = args.slice(1);
-  let hasParents = false;
-  const paths = rest.filter((arg) => {
-    const lowered = arg.toLowerCase();
-    if (lowered === "-p" || lowered === "--parents") {
-      hasParents = true;
-      return false;
-    }
-    return true;
+  return {
+    platform,
+    shell: "bash",
+    executable: "/bin/bash",
+    invocation: "/bin/bash -lc <command>",
+    guidance: "Unix-like platforms run commands through bash -lc; use Bash syntax."
+  };
+}
+
+// src/utils/commandRunner/launch.ts
+async function launchCommand(command, cwd, timeoutMs, abortSignal) {
+  const execa4 = await loadExeca();
+  const shell = getShellRuntimeInfo();
+  const subprocess = shell.shell === "powershell" ? execa4(shell.executable, ["-NoLogo", "-NoProfile", "-EncodedCommand", encodePowerShellCommand(command)], {
+    cwd,
+    timeout: timeoutMs,
+    cancelSignal: abortSignal,
+    all: true,
+    buffer: false,
+    reject: false,
+    env: buildCommandEnvironment()
+  }) : execa4(shell.executable, ["-lc", command], {
+    cwd,
+    timeout: timeoutMs,
+    cancelSignal: abortSignal,
+    all: true,
+    buffer: false,
+    reject: false,
+    env: buildCommandEnvironment()
   });
-  const needsNormalization = hasParents || paths.some((targetPath) => targetPath.includes("{"));
-  if (!needsNormalization) {
-    return segment;
-  }
-  const expanded = expandPaths(paths);
-  if (expanded.length === 0) {
-    return segment;
-  }
-  const normalizedPaths = expanded.map((targetPath) => quotePowerShell(normalizeWindowsPath(targetPath)));
-  return `New-Item -ItemType Directory -Force -Path ${normalizedPaths.join(", ")}`;
-}
-function normalizeRemoveSegment(segment) {
-  const args = splitArgs(segment);
-  if (args.length <= 1) {
-    return segment;
-  }
-  const flags = args.slice(1).filter((arg) => arg.startsWith("-"));
-  const paths = args.slice(1).filter((arg) => !arg.startsWith("-"));
-  if (paths.length === 0) {
-    return segment;
-  }
-  const recurse = flags.some((flag) => /r/i.test(flag));
-  const force = flags.some((flag) => /f/i.test(flag));
-  let command = "Remove-Item";
-  if (recurse) {
-    command += " -Recurse";
-  }
-  if (force) {
-    command += " -Force";
-  }
-  command += ` -LiteralPath ${paths.map((targetPath) => quotePowerShell(normalizeWindowsPath(targetPath))).join(", ")}`;
-  return command;
-}
-function normalizeCopySegment(segment) {
-  const args = splitArgs(segment);
-  if (args.length < 3) {
-    return segment;
-  }
-  const flags = args.slice(1).filter((arg) => arg.startsWith("-"));
-  const paths = args.slice(1).filter((arg) => !arg.startsWith("-"));
-  if (paths.length < 2) {
-    return segment;
-  }
-  const recurse = flags.some((flag) => /r/i.test(flag));
-  const force = flags.some((flag) => /f/i.test(flag));
-  const destination = paths[paths.length - 1];
-  if (!destination) {
-    return segment;
-  }
-  const sources = paths.slice(0, -1);
-  let command = "Copy-Item";
-  if (recurse) {
-    command += " -Recurse";
-  }
-  if (force) {
-    command += " -Force";
-  }
-  command += ` -Path ${sources.map((targetPath) => quotePowerShell(normalizeWindowsPath(targetPath))).join(", ")}`;
-  command += ` -Destination ${quotePowerShell(normalizeWindowsPath(destination))}`;
-  return command;
-}
-function normalizeMoveSegment(segment) {
-  const args = splitArgs(segment);
-  if (args.length < 3) {
-    return segment;
-  }
-  const flags = args.slice(1).filter((arg) => arg.startsWith("-"));
-  const paths = args.slice(1).filter((arg) => !arg.startsWith("-"));
-  if (paths.length < 2) {
-    return segment;
-  }
-  const force = flags.some((flag) => /f/i.test(flag));
-  const destination = paths[paths.length - 1];
-  if (!destination) {
-    return segment;
-  }
-  const sources = paths.slice(0, -1);
-  let command = "Move-Item";
-  if (force) {
-    command += " -Force";
-  }
-  command += ` -Path ${sources.map((targetPath) => quotePowerShell(normalizeWindowsPath(targetPath))).join(", ")}`;
-  command += ` -Destination ${quotePowerShell(normalizeWindowsPath(destination))}`;
-  return command;
-}
-function normalizeTouchSegment(segment) {
-  const args = splitArgs(segment).slice(1);
-  if (args.length === 0) {
-    return segment;
-  }
-  const expanded = expandPaths(args);
-  if (expanded.length === 0) {
-    return segment;
-  }
-  const paths = expanded.map((targetPath) => quotePowerShell(normalizeWindowsPath(targetPath)));
-  return `New-Item -ItemType File -Force -Path ${paths.join(", ")}`;
-}
-function normalizeCatSegment(segment) {
-  const args = splitArgs(segment).slice(1);
-  if (args.length === 0) {
-    return segment;
-  }
-  const targetPath = args[0];
-  if (!targetPath) {
-    return segment;
-  }
-  return `Get-Content -LiteralPath ${quotePowerShell(normalizeWindowsPath(targetPath))}`;
-}
-
-// src/utils/commandRunner/platform.ts
-function normalizeCommandForPlatform(command) {
-  if (process.platform !== "win32") {
-    return command;
-  }
-  const trimmed = command.trim();
-  if (!trimmed) {
-    return command;
-  }
-  const normalized = normalizeWindowsCommand(trimmed);
-  return normalizeNpmCommandNames(normalized);
+  return { subprocess };
 }
-function normalizeWindowsCommand(command) {
-  if (startsWithExplicitShell(command)) {
-    return command;
-  }
-  const segments = splitByAndAnd(command);
-  const normalizedSegments = segments.map((segment) => normalizeWindowsSegment(segment));
-  return joinWithAndSemantics(normalizedSegments);
+function encodePowerShellCommand(command) {
+  const wrapped = [
+    "$ProgressPreference = 'SilentlyContinue'",
+    "$ErrorActionPreference = 'Stop'",
+    "[Console]::InputEncoding = [System.Text.Encoding]::UTF8",
+    "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8",
+    "$OutputEncoding = [System.Text.Encoding]::UTF8",
+    "try { chcp 65001 > $null } catch { }",
+    "$code = 0",
+    "try {",
+    `& { ${command} }`,
+    "$code = if ($null -ne $LASTEXITCODE) { [int]$LASTEXITCODE } elseif ($?) { 0 } else { 1 }",
+    "} catch {",
+    "[Console]::Error.WriteLine($_.Exception.Message)",
+    "$code = 1",
+    "}",
+    "exit $code"
+  ].join("\n");
+  return Buffer.from(wrapped, "utf16le").toString("base64");
 }
-function normalizeNpmCommandNames(command) {
-  const commandNames = {
-    npm: "npm.cmd",
-    npx: "npx.cmd",
-    pnpm: "pnpm.cmd",
-    yarn: "yarn.cmd"
+function buildCommandEnvironment() {
+  return {
+    ...process.env,
+    LANG: process.env.LANG || "C.UTF-8",
+    LC_ALL: process.env.LC_ALL || "C.UTF-8",
+    PYTHONIOENCODING: process.env.PYTHONIOENCODING || "utf-8"
   };
-  const pattern = /(^|[;&|]|\&\&)\s*(npm|npx|pnpm|yarn)(?=\s|$)/gi;
-  return command.replace(pattern, (match, prefix, tool) => {
-    const replacement = commandNames[String(tool).toLowerCase()];
-    if (!replacement) {
-      return match;
-    }
-    if (!prefix) {
-      return replacement;
-    }
-    return `${prefix} ${replacement}`;
-  });
+}
+
+// src/utils/commandRunner/output.ts
+function normalizeCommandOutput(output) {
+  if (!output.includes("#< CLIXML")) {
+    return output;
+  }
+  const errors = [...output.matchAll(/<S\s+S="Error">([\s\S]*?)<\/S>/g)].map((match) => decodePowerShellText(match[1] ?? "")).map((line) => line.trimEnd()).filter(Boolean);
+  if (errors.length === 0) {
+    return output;
+  }
+  return errors.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function decodePowerShellText(value) {
+  return value.replace(/_x000D__x000A_/g, "\n").replace(/_x000D_/g, "\r").replace(/_x000A_/g, "\n").replace(/_x0009_/g, "	").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
 }
 
 // src/utils/commandRunner/run.ts
 var STALL_KILL_TIMEOUT_MS = 5e3;
 async function runCommandWithPolicy(options) {
-  const normalizedCommand = normalizeCommandForPlatform(options.command);
-  return runCommandOnce({
-    ...options,
-    command: normalizedCommand
-  });
+  return runCommandOnce(options);
 }
 async function runCommandOnce(options) {
   const start = Date.now();
   let stalled = false;
   let stallTimer = null;
   let forceKillTimer = null;
-  const { subprocess } = await launchCommand(options.command, options.cwd, options.timeoutMs, options.abortSignal);
+  const launched = await launchCommand(options.command, options.cwd, options.timeoutMs, options.abortSignal);
+  const { subprocess } = launched;
   const outputCapture = await createBashOutputCapture(options.outputCapture ?? {});
   const clearTimers = () => {
     if (stallTimer) {
@@ -4045,9 +4828,11 @@ async function runCommandOnce(options) {
     const result = await subprocess;
     clearTimers();
     const shellOutput = await outputCapture.finalize();
+    const output = normalizeCommandOutput(shellOutput.outputPreview);
     return {
+      command: options.command,
       exitCode: typeof result.exitCode === "number" ? result.exitCode : null,
-      output: shellOutput.outputPreview,
+      output,
       outputPath: shellOutput.outputPath,
       truncated: shellOutput.truncated,
       outputChars: shellOutput.outputChars,
@@ -4062,9 +4847,12 @@ async function runCommandOnce(options) {
     const timedOut = isTimedOutError(error);
     clearTimers();
     const shellOutput = await outputCapture.finalize();
+    const fallbackOutput = shellOutput.outputChars > 0 ? shellOutput.outputPreview : readProcessOutput(error);
+    const output = normalizeCommandOutput(fallbackOutput);
     return {
+      command: options.command,
       exitCode: readExitCode(error),
-      output: shellOutput.outputChars > 0 ? shellOutput.outputPreview : readProcessOutput(error),
+      output,
       outputPath: shellOutput.outputPath,
       truncated: shellOutput.truncated,
       outputChars: shellOutput.outputChars,
@@ -4100,8 +4888,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
@@ -4315,15 +5103,15 @@ 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;
@@ -4625,7 +5413,7 @@ var bashToolDefinition = {
     const status = result.aborted ? "aborted" : result.stalled ? "stalled" : result.timedOut ? "timed_out" : result.exitCode === 0 ? "completed" : "failed";
     const outputGovernance = governToolOutput({
       toolName: "bash",
-      command,
+      command: result.command,
       status,
       exitCode: result.exitCode,
       durationMs: result.durationMs,
@@ -4653,7 +5441,7 @@ var bashToolDefinition = {
     return okResult(
       JSON.stringify(
         {
-          command,
+          command: result.command,
           cwd: resolvedCwd,
           exitCode: result.exitCode,
           status,
@@ -4684,7 +5472,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) {
@@ -4725,13 +5513,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, "/");
@@ -4758,8 +5546,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);
@@ -4806,7 +5594,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);
     }
@@ -4822,7 +5610,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);
@@ -4843,7 +5631,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: {
@@ -4960,7 +5748,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}`, {
@@ -4978,7 +5766,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}`,
@@ -5132,9 +5920,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
   };
@@ -5188,8 +5976,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",
@@ -5207,8 +5995,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,
@@ -5218,7 +6006,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 {
@@ -5242,11 +6030,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 [];
@@ -5263,8 +6051,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;
@@ -5429,7 +6217,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",
@@ -5465,12 +6253,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}`,
@@ -5525,7 +6313,7 @@ var writeToolDefinition = {
 };
 
 // src/tools/sendFile.ts
-import fs14 from "fs/promises";
+import fs16 from "fs/promises";
 var sendFileToolDefinition = {
   definition: {
     type: "function",
@@ -5568,7 +6356,7 @@ var sendFileToolDefinition = {
       };
     }
     try {
-      await fs14.access(filePath);
+      await fs16.access(filePath);
     } catch {
       return {
         ok: false,
@@ -6100,6 +6888,53 @@ async function executeToolBatch(params) {
   };
 }
 
+// src/session/events.ts
+import fs17 from "fs/promises";
+import path17 from "path";
+var SessionEventStore = class {
+  constructor(eventsDir) {
+    this.eventsDir = eventsDir;
+  }
+  async append(event) {
+    const record = {
+      id: createEventId(),
+      createdAt: event.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      type: event.type,
+      sessionId: event.sessionId,
+      cwd: event.cwd,
+      host: event.host,
+      message: event.message,
+      details: event.details
+    };
+    await fs17.mkdir(this.eventsDir, { recursive: true });
+    await fs17.appendFile(this.getSessionEventPath(event.sessionId), `${JSON.stringify(record)}
+`, "utf8");
+    return record;
+  }
+  async list(sessionId, limit = 100) {
+    const filePath = this.getSessionEventPath(sessionId);
+    let raw = "";
+    try {
+      raw = await fs17.readFile(filePath, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+    return raw.split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line)).slice(-limit);
+  }
+  getSessionEventPath(sessionId) {
+    return path17.join(this.eventsDir, `${sanitizeSessionId(sessionId)}.jsonl`);
+  }
+};
+function createEventId() {
+  return `${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "").slice(0, 14)}-${Math.random().toString(16).slice(2, 10)}`;
+}
+function sanitizeSessionId(sessionId) {
+  return sessionId.replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
+
 // src/agent/turn/toolFailure.ts
 function readToolFailureError(output) {
   try {
@@ -6135,9 +6970,16 @@ async function processToolCallBatch(input) {
   const batchToolMessages = [];
   const batchModelOutputs = [];
   const batchChangedPaths = /* @__PURE__ */ new Set();
+  const sessionEvents = new SessionEventStore(options.config.paths.eventsDir);
   const leadWaitExecutionsBefore = identity.kind === "lead" ? listLeadWaitExecutions(projectContext.stateRootDir) : [];
   for (const toolCall of response.toolCalls) {
     throwIfAborted(options.abortSignal, "Turn aborted by user.");
+    await sessionEvents.append({
+      type: "tool.started",
+      sessionId: session.id,
+      cwd: options.cwd,
+      details: buildToolStartedEventDetails(toolCall, identity)
+    });
     options.callbacks?.onToolCall?.(toolCall.function.name, toolCall.function.arguments);
     await recordObservabilityEvent(projectContext.stateRootDir, {
       event: "tool.execution",
@@ -6171,6 +7013,7 @@ async function processToolCallBatch(input) {
     } else if (metadata?.sessionDiff) {
       session = await options.sessionStore.save(noteSessionDiff(session, metadata.sessionDiff));
     }
+    const failureError = result.ok ? void 0 : readToolFailureError(result.output);
     await recordObservabilityEvent(projectContext.stateRootDir, {
       event: "tool.execution",
       status: result.ok ? "completed" : "failed",
@@ -6179,11 +7022,23 @@ async function processToolCallBatch(input) {
       identityName: identity.name,
       toolName: toolCall.function.name,
       durationMs,
-      error: result.ok ? void 0 : readToolFailureError(result.output),
+      error: failureError,
       details: {
         changedPathCount: metadata?.changedPaths?.length ?? 0
       }
     });
+    await sessionEvents.append({
+      type: result.ok ? "tool.completed" : "tool.failed",
+      sessionId: session.id,
+      cwd: options.cwd,
+      details: buildToolFinishedEventDetails({
+        toolCall,
+        identity,
+        durationMs,
+        changedPathCount: metadata?.changedPaths?.length ?? 0,
+        error: failureError ? formatToolFailureError(failureError) : void 0
+      })
+    });
     if (metadata?.outputGovernance) {
       await recordObservabilityEvent(projectContext.stateRootDir, {
         event: "tool.output",
@@ -6277,6 +7132,33 @@ async function processToolCallBatch(input) {
     }
   };
 }
+function buildToolStartedEventDetails(toolCall, identity) {
+  return {
+    toolName: toolCall.function.name,
+    toolCallId: toolCall.id,
+    identityKind: identity.kind,
+    identityName: identity.name,
+    argumentsPreview: previewToolArguments(toolCall.function.arguments)
+  };
+}
+function buildToolFinishedEventDetails(input) {
+  return {
+    toolName: input.toolCall.function.name,
+    toolCallId: input.toolCall.id,
+    identityKind: input.identity.kind,
+    identityName: input.identity.name,
+    durationMs: input.durationMs,
+    changedPathCount: input.changedPathCount,
+    error: input.error
+  };
+}
+function previewToolArguments(rawArgs) {
+  const normalized = rawArgs.replace(/\s+/g, " ").trim();
+  return normalized.length > 240 ? `${normalized.slice(0, 237)}...` : normalized;
+}
+function formatToolFailureError(error) {
+  return error.code ? `${error.code}: ${error.message}` : error.message;
+}
 
 // src/agent/turn/toolless.ts
 async function resolveToollessTurn(params) {
@@ -6362,9 +7244,9 @@ function normalizeToolArguments(raw) {
 }
 
 // src/agent/changes/store.ts
-import crypto2 from "crypto";
-import fs15 from "fs/promises";
-import path15 from "path";
+import crypto3 from "crypto";
+import fs18 from "fs/promises";
+import path18 from "path";
 var ChangeStore = class {
   constructor(changesDir) {
     this.changesDir = changesDir;
@@ -6372,8 +7254,8 @@ var ChangeStore = class {
   async record(input) {
     const id = createChangeId();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const blobDir = path15.join(this.changesDir, id);
-    await fs15.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(
@@ -6413,21 +7295,21 @@ var ChangeStore = class {
       preview: input.preview,
       operations
     };
-    await fs15.mkdir(this.changesDir, { recursive: true });
-    await fs15.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 fs15.mkdir(this.changesDir, { recursive: true });
-    const entries = await fs15.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(path15.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 fs15.readFile(this.getMetadataPath(id), "utf8");
+    const raw = await fs18.readFile(this.getMetadataPath(id), "utf8");
     return JSON.parse(raw);
   }
   async loadLatestUndoable() {
@@ -6451,17 +7333,17 @@ var ChangeStore = class {
       restoredPaths.push(operation.path);
       if (operation.beforeSnapshotPath) {
         const buffer = await this.readSnapshot(operation.beforeSnapshotPath);
-        await fs15.mkdir(path15.dirname(operation.path), { recursive: true });
-        await fs15.writeFile(operation.path, buffer);
+        await fs18.mkdir(path18.dirname(operation.path), { recursive: true });
+        await fs18.writeFile(operation.path, buffer);
         continue;
       }
-      await fs15.rm(operation.path, { force: true });
+      await fs18.rm(operation.path, { force: true });
     }
     const updated = {
       ...record,
       undoneAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await fs15.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,
@@ -6469,24 +7351,24 @@ var ChangeStore = class {
     };
   }
   getMetadataPath(id) {
-    return path15.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 = path15.join(blobDir, fileName);
-    await fs15.writeFile(absolutePath, buffer);
-    return path15.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 fs15.readFile(path15.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}`;
 }
 
@@ -6867,9 +7749,10 @@ var backgroundRunTool = {
     registerBackgroundProcess(job.id, subprocess);
     store.markRunning(job.id, { pid: subprocess.pid ?? 0 });
     const outputTracker = createBackgroundOutputTracker((output) => {
+      const normalizedOutput = normalizeCommandOutput(output);
       store.updateRunningOutput(job.id, {
-        output,
-        summary: summarizeBackgroundOutput(output),
+        output: normalizedOutput,
+        summary: summarizeBackgroundOutput(normalizedOutput),
         lastOutputAt: (/* @__PURE__ */ new Date()).toISOString()
       });
     });
@@ -6879,7 +7762,7 @@ var backgroundRunTool = {
     void subprocess.then(async (result) => {
       outputTracker.flush();
       const running2 = store.load(job.id);
-      const resultOutput = typeof result.all === "string" ? result.all : "";
+      const resultOutput = normalizeCommandOutput(typeof result.all === "string" ? result.all : "");
       const output = resultOutput || running2?.output || "";
       store.close(job.id, {
         status: result.exitCode === 0 ? "completed" : "failed",
@@ -6891,7 +7774,7 @@ var backgroundRunTool = {
     }, async (error) => {
       outputTracker.flush();
       const running2 = store.load(job.id);
-      const errorOutput = typeof error.all === "string" ? error.all : "";
+      const errorOutput = normalizeCommandOutput(typeof error.all === "string" ? error.all : "");
       const output = errorOutput || running2?.output || String(error.message);
       store.close(job.id, {
         status: "failed",
@@ -7059,20 +7942,20 @@ function createBackgroundTools() {
 }
 
 // src/extensions/tools/network/tools/downloadUrl.ts
-import fs17 from "fs/promises";
+import fs20 from "fs/promises";
 
 // src/extensions/shared.ts
-import fs16 from "fs/promises";
-import path16 from "path";
+import fs19 from "fs/promises";
+import path19 from "path";
 async function ensureExtensionDir(rootDir, extensionId) {
   const paths = await ensureProjectStateDirectories(rootDir);
-  const dir = path16.join(paths.extensionsDir, extensionId);
-  await fs16.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 fs16.readFile(filePath, "utf8"));
+    return JSON.parse(await fs19.readFile(filePath, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") {
       return fallback;
@@ -7081,8 +7964,8 @@ async function readJsonFile(filePath, fallback) {
   }
 }
 async function writeJsonFile(filePath, value) {
-  await fs16.mkdir(path16.dirname(filePath), { recursive: true });
-  await fs16.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) {
@@ -7098,7 +7981,7 @@ function sanitizeStateSegment(value) {
 }
 
 // src/extensions/tools/network/session.ts
-import path17 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) : [];
@@ -7123,7 +8006,7 @@ async function getHttpSessionStateFile(rootDir) {
   return sessionFile(rootDir);
 }
 async function sessionFile(rootDir) {
-  return path17.join(await ensureExtensionDir(rootDir, "network"), "http-sessions.json");
+  return path20.join(await ensureExtensionDir(rootDir, "network"), "http-sessions.json");
 }
 function normalizeSession(value) {
   return {
@@ -7352,7 +8235,7 @@ var downloadUrlTool = {
     }
     const bytes = Buffer.from(await response.arrayBuffer());
     await ensureParentDirectory(targetPath);
-    await fs17.writeFile(targetPath, bytes);
+    await fs20.writeFile(targetPath, bytes);
     return changedJsonResult({
       ok: response.ok,
       url,
@@ -7417,17 +8300,17 @@ var httpProbeTool = {
 };
 
 // src/extensions/tools/network/traceStore.ts
-import fs18 from "fs/promises";
-import path18 from "path";
+import fs21 from "fs/promises";
+import path21 from "path";
 async function writeNetworkTrace(rootDir, traceId, record) {
   const filePath = await networkTraceFilePath(rootDir, traceId);
-  await fs18.mkdir(path18.dirname(filePath), { recursive: true });
-  await fs18.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 path18.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
@@ -7827,14 +8710,14 @@ function readStringMap2(value) {
 }
 
 // src/extensions/tools/network/openapi.ts
-import fs19 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 fs19.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" });
@@ -8182,8 +9065,8 @@ async function recordSkillUse(rootDir, input) {
 }
 
 // src/extensions/tools/skills/tools/skillReadResource.ts
-import fs20 from "fs/promises";
-import path19 from "path";
+import fs23 from "fs/promises";
+import path22 from "path";
 var MAX_RESOURCE_CHARS = 24e3;
 var skillReadResourceTool = {
   definition: {
@@ -8220,8 +9103,8 @@ var skillReadResourceTool = {
     if (!resource) {
       throw new Error(`Skill "${name}" does not declare resource: ${requestedPath}`);
     }
-    const absolutePath = path19.resolve(context.projectContext.rootDir, resource.path);
-    const content = await fs20.readFile(absolutePath, "utf8");
+    const absolutePath = path22.resolve(context.projectContext.rootDir, resource.path);
+    const content = await fs23.readFile(absolutePath, "utf8");
     return jsonResult({
       ok: true,
       skill: {
@@ -8239,7 +9122,7 @@ function normalizeResourcePath(value) {
 }
 
 // src/extensions/tools/skills/tools/skillRunScript.ts
-import path20 from "path";
+import path23 from "path";
 var skillRunScriptTool = {
   definition: {
     type: "function",
@@ -8283,12 +9166,12 @@ var skillRunScriptTool = {
     if (!resource) {
       throw new Error(`Skill "${name}" does not declare script resource: ${requestedPath}`);
     }
-    const skillDir = path20.dirname(skill.path);
-    const relativeToSkill = normalizeResourcePath2(path20.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 = path20.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({
@@ -8363,7 +9246,7 @@ function quotePath(value) {
   return `"${value.replace(/"/g, '\\"')}"`;
 }
 function buildScriptCommand(scriptPath, argumentText) {
-  const extension = path20.extname(scriptPath).toLowerCase();
+  const extension = path23.extname(scriptPath).toLowerCase();
   const quoted = quotePath(scriptPath);
   const suffix = argumentText ? ` ${argumentText}` : "";
   if (extension === ".js" || extension === ".mjs" || extension === ".cjs") {
@@ -8417,12 +9300,12 @@ var subagentCheckTool = {
 
 // src/execution/launch.ts
 import { spawn } from "child_process";
-import path21 from "path";
+import path24 from "path";
 function spawnExecutionWorker(input) {
   if (process.env.KITTY_TEST_WORKER_MODE === "stub") {
     return process.pid;
   }
-  const cliEntry = path21.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.");
   }
@@ -8628,7 +9511,7 @@ function parseWorktreeBlock(block) {
 }
 
 // src/extensions/tools/worktree/state.ts
-import path22 from "path";
+import path25 from "path";
 async function readWorktreeState(rootDir) {
   return normalizeWorktreeState(await readJsonFile(await stateFile(rootDir), {
     schemaVersion: 1,
@@ -8651,7 +9534,7 @@ async function recordWorktreeEvent(rootDir, event) {
   return writeWorktreeState(rootDir, state);
 }
 async function stateFile(rootDir) {
-  return path22.join(await ensureExtensionDir(rootDir, "worktree"), "state.json");
+  return path25.join(await ensureExtensionDir(rootDir, "worktree"), "state.json");
 }
 function normalizeWorktreeState(value) {
   return {
@@ -9274,8 +10157,8 @@ function looksLikeToolProtocolText(content) {
 }
 
 // src/observability/crashRecorder.ts
-import fs21 from "fs";
-import path23 from "path";
+import fs24 from "fs";
+import path26 from "path";
 var activeCrashContexts = /* @__PURE__ */ new Map();
 var nextCrashContextId = 0;
 function enterCrashContext(context) {
@@ -9287,7 +10170,7 @@ function enterCrashContext(context) {
 }
 
 // src/observability/hostEvents.ts
-import path24 from "path";
+import path27 from "path";
 async function recordHostTurnStarted(rootDir, input) {
   await recordObservabilityEvent(rootDir, {
     event: "host.turn",
@@ -9318,53 +10201,6 @@ async function recordHostTurnFinished(rootDir, input) {
   });
 }
 
-// src/session/events.ts
-import fs22 from "fs/promises";
-import path25 from "path";
-var SessionEventStore = class {
-  constructor(eventsDir) {
-    this.eventsDir = eventsDir;
-  }
-  async append(event) {
-    const record = {
-      id: createEventId(),
-      createdAt: event.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-      type: event.type,
-      sessionId: event.sessionId,
-      cwd: event.cwd,
-      host: event.host,
-      message: event.message,
-      details: event.details
-    };
-    await fs22.mkdir(this.eventsDir, { recursive: true });
-    await fs22.appendFile(this.getSessionEventPath(event.sessionId), `${JSON.stringify(record)}
-`, "utf8");
-    return record;
-  }
-  async list(sessionId, limit = 100) {
-    const filePath = this.getSessionEventPath(sessionId);
-    let raw = "";
-    try {
-      raw = await fs22.readFile(filePath, "utf8");
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return [];
-      }
-      throw error;
-    }
-    return raw.split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line)).slice(-limit);
-  }
-  getSessionEventPath(sessionId) {
-    return path25.join(this.eventsDir, `${sanitizeSessionId(sessionId)}.jsonl`);
-  }
-};
-function createEventId() {
-  return `${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "").slice(0, 14)}-${Math.random().toString(16).slice(2, 10)}`;
-}
-function sanitizeSessionId(sessionId) {
-  return sessionId.replace(/[^a-zA-Z0-9_.-]/g, "_");
-}
-
 // src/host/toolRegistry.ts
 async function createHostToolRegistry(config, options = {}) {
   const extraTools = options.extraTools ?? [];
@@ -9685,7 +10521,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;
@@ -9693,10 +10529,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;
 }
@@ -9704,7 +10540,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);
 }
@@ -9764,24 +10600,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": {
@@ -9793,7 +10629,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";
@@ -9834,14 +10670,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;
@@ -9980,7 +10816,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) {
@@ -10006,7 +10842,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)) {
@@ -10289,10 +11125,17 @@ 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,
   ExecutionStore,
+  SessionEventStore,
   isProcessAlive,
   terminatePid,
   BackgroundExecutionStore,
@@ -10301,12 +11144,14 @@ export {
   summarizeExecution,
   summarizeExecutionSet,
   EXTENSION_ENV_KEYS,
-  SessionEventStore,
   runHostTurn,
   writeStdout,
   writeStdoutLine,
   writeStderrLine,
   createRuntimeUiEvent,
+  tryParseJson,
+  buildToolCallDisplay,
+  buildToolResultDisplay,
   colorRuntimeUiText,
   createRuntimeUiTerminalRenderer,
   formatRuntimeUiEventLine