@jun133/kitty 0.0.13 → 0.0.14

package/dist/{chunk-MMIH75OY.mjs → chunk-KROQCOWD.mjs}

@@ -3558,14 +3558,21 @@ async function launchCommand(command, cwd, timeoutMs, abortSignal) {
 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("; ");
+  ].join("\n");
   return Buffer.from(wrapped, "utf16le").toString("base64");
 }
 function buildCommandEnvironment() {
@@ -3577,422 +3584,33 @@ function buildCommandEnvironment() {
   };
 }
 
-// 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);
+// src/utils/commandRunner/output.ts
+function normalizeCommandOutput(output) {
+  if (!output.includes("#< CLIXML")) {
+    return output;
   }
-  if (lowered.startsWith("cat ")) {
-    return normalizeCatSegment(trimmed);
+  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 segment;
+  return errors.join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
-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;
-}
-function normalizeMkdirSegment(segment) {
-  const args = splitArgs(segment);
-  if (args.length <= 1) {
-    return segment;
-  }
-  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;
-  });
-  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);
-}
-function normalizeWindowsCommand(command) {
-  if (startsWithExplicitShell(command)) {
-    return command;
-  }
-  const segments = splitByAndAnd(command);
-  const normalizedSegments = segments.map((segment) => normalizeWindowsSegment(segment));
-  return joinWithAndSemantics(normalizedSegments);
-}
-function normalizeNpmCommandNames(command) {
-  const commandNames = {
-    npm: "npm.cmd",
-    npx: "npx.cmd",
-    pnpm: "pnpm.cmd",
-    yarn: "yarn.cmd"
-  };
-  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}`;
-  });
+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 +3663,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 +3682,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,
@@ -4625,7 +4248,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 +4276,7 @@ var bashToolDefinition = {
     return okResult(
       JSON.stringify(
         {
-          command,
+          command: result.command,
           cwd: resolvedCwd,
           exitCode: result.exitCode,
           status,
@@ -6100,6 +5723,53 @@ async function executeToolBatch(params) {
   };
 }
 
+// src/session/events.ts
+import fs15 from "fs/promises";
+import path15 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 fs15.mkdir(this.eventsDir, { recursive: true });
+    await fs15.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 fs15.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 path15.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 +5805,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 +5848,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 +5857,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 +5967,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) {
@@ -6363,8 +6080,8 @@ function normalizeToolArguments(raw) {
 
 // src/agent/changes/store.ts
 import crypto2 from "crypto";
-import fs15 from "fs/promises";
-import path15 from "path";
+import fs16 from "fs/promises";
+import path16 from "path";
 var ChangeStore = class {
   constructor(changesDir) {
     this.changesDir = changesDir;
@@ -6372,8 +6089,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 = path16.join(this.changesDir, id);
+    await fs16.mkdir(blobDir, { recursive: true });
     const operations = await Promise.all(
       input.operations.map(async (operation, index) => {
         const beforeSnapshotPath = await this.writeSnapshot(
@@ -6413,21 +6130,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 fs16.mkdir(this.changesDir, { recursive: true });
+    await fs16.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 fs16.mkdir(this.changesDir, { recursive: true });
+    const entries = await fs16.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(path16.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 fs16.readFile(this.getMetadataPath(id), "utf8");
     return JSON.parse(raw);
   }
   async loadLatestUndoable() {
@@ -6451,17 +6168,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 fs16.mkdir(path16.dirname(operation.path), { recursive: true });
+        await fs16.writeFile(operation.path, buffer);
         continue;
       }
-      await fs15.rm(operation.path, { force: true });
+      await fs16.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 fs16.writeFile(this.getMetadataPath(updated.id), `${JSON.stringify(updated, null, 2)}
 `, "utf8");
     return {
       record: updated,
@@ -6469,19 +6186,19 @@ var ChangeStore = class {
     };
   }
   getMetadataPath(id) {
-    return path15.join(this.changesDir, `${id}.json`);
+    return path16.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 = path16.join(blobDir, fileName);
+    await fs16.writeFile(absolutePath, buffer);
+    return path16.relative(this.changesDir, absolutePath);
   }
   async readSnapshot(relativePath) {
-    return fs15.readFile(path15.join(this.changesDir, relativePath));
+    return fs16.readFile(path16.join(this.changesDir, relativePath));
   }
 };
 function createChangeId() {
@@ -6867,9 +6584,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 +6597,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 +6609,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 +6777,20 @@ function createBackgroundTools() {
 }
 
 // src/extensions/tools/network/tools/downloadUrl.ts
-import fs17 from "fs/promises";
+import fs18 from "fs/promises";
 
 // src/extensions/shared.ts
-import fs16 from "fs/promises";
-import path16 from "path";
+import fs17 from "fs/promises";
+import path17 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 = path17.join(paths.extensionsDir, extensionId);
+  await fs17.mkdir(dir, { recursive: true });
   return dir;
 }
 async function readJsonFile(filePath, fallback) {
   try {
-    return JSON.parse(await fs16.readFile(filePath, "utf8"));
+    return JSON.parse(await fs17.readFile(filePath, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") {
       return fallback;
@@ -7081,8 +6799,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 fs17.mkdir(path17.dirname(filePath), { recursive: true });
+  await fs17.writeFile(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 function jsonResult(value) {
@@ -7098,7 +6816,7 @@ function sanitizeStateSegment(value) {
 }
 
 // src/extensions/tools/network/session.ts
-import path17 from "path";
+import path18 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 +6841,7 @@ async function getHttpSessionStateFile(rootDir) {
   return sessionFile(rootDir);
 }
 async function sessionFile(rootDir) {
-  return path17.join(await ensureExtensionDir(rootDir, "network"), "http-sessions.json");
+  return path18.join(await ensureExtensionDir(rootDir, "network"), "http-sessions.json");
 }
 function normalizeSession(value) {
   return {
@@ -7352,7 +7070,7 @@ var downloadUrlTool = {
     }
     const bytes = Buffer.from(await response.arrayBuffer());
     await ensureParentDirectory(targetPath);
-    await fs17.writeFile(targetPath, bytes);
+    await fs18.writeFile(targetPath, bytes);
     return changedJsonResult({
       ok: response.ok,
       url,
@@ -7417,17 +7135,17 @@ var httpProbeTool = {
 };
 
 // src/extensions/tools/network/traceStore.ts
-import fs18 from "fs/promises";
-import path18 from "path";
+import fs19 from "fs/promises";
+import path19 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 fs19.mkdir(path19.dirname(filePath), { recursive: true });
+  await fs19.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 path19.join(await ensureExtensionDir(rootDir, "network"), "traces", `${sanitizeStateSegment(traceId)}.json`);
 }
 
 // src/extensions/tools/network/tools/httpRequest.ts
@@ -7827,14 +7545,14 @@ function readStringMap2(value) {
 }
 
 // src/extensions/tools/network/openapi.ts
-import fs19 from "fs/promises";
+import fs20 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 fs20.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 +7900,8 @@ async function recordSkillUse(rootDir, input) {
 }
 
 // src/extensions/tools/skills/tools/skillReadResource.ts
-import fs20 from "fs/promises";
-import path19 from "path";
+import fs21 from "fs/promises";
+import path20 from "path";
 var MAX_RESOURCE_CHARS = 24e3;
 var skillReadResourceTool = {
   definition: {
@@ -8220,8 +7938,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 = path20.resolve(context.projectContext.rootDir, resource.path);
+    const content = await fs21.readFile(absolutePath, "utf8");
     return jsonResult({
       ok: true,
       skill: {
@@ -8239,7 +7957,7 @@ function normalizeResourcePath(value) {
 }
 
 // src/extensions/tools/skills/tools/skillRunScript.ts
-import path20 from "path";
+import path21 from "path";
 var skillRunScriptTool = {
   definition: {
     type: "function",
@@ -8283,12 +8001,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 = path21.dirname(skill.path);
+    const relativeToSkill = normalizeResourcePath2(path21.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 = path21.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 +8081,7 @@ function quotePath(value) {
   return `"${value.replace(/"/g, '\\"')}"`;
 }
 function buildScriptCommand(scriptPath, argumentText) {
-  const extension = path20.extname(scriptPath).toLowerCase();
+  const extension = path21.extname(scriptPath).toLowerCase();
   const quoted = quotePath(scriptPath);
   const suffix = argumentText ? ` ${argumentText}` : "";
   if (extension === ".js" || extension === ".mjs" || extension === ".cjs") {
@@ -8417,12 +8135,12 @@ var subagentCheckTool = {
 
 // src/execution/launch.ts
 import { spawn } from "child_process";
-import path21 from "path";
+import path22 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 = path22.resolve(process.argv[1] ?? "");
   if (!cliEntry) {
     throw new Error("Unable to locate Kitty CLI entrypoint for execution worker.");
   }
@@ -8628,7 +8346,7 @@ function parseWorktreeBlock(block) {
 }
 
 // src/extensions/tools/worktree/state.ts
-import path22 from "path";
+import path23 from "path";
 async function readWorktreeState(rootDir) {
   return normalizeWorktreeState(await readJsonFile(await stateFile(rootDir), {
     schemaVersion: 1,
@@ -8651,7 +8369,7 @@ async function recordWorktreeEvent(rootDir, event) {
   return writeWorktreeState(rootDir, state);
 }
 async function stateFile(rootDir) {
-  return path22.join(await ensureExtensionDir(rootDir, "worktree"), "state.json");
+  return path23.join(await ensureExtensionDir(rootDir, "worktree"), "state.json");
 }
 function normalizeWorktreeState(value) {
   return {
@@ -9274,8 +8992,8 @@ function looksLikeToolProtocolText(content) {
 }
 
 // src/observability/crashRecorder.ts
-import fs21 from "fs";
-import path23 from "path";
+import fs22 from "fs";
+import path24 from "path";
 var activeCrashContexts = /* @__PURE__ */ new Map();
 var nextCrashContextId = 0;
 function enterCrashContext(context) {
@@ -9287,7 +9005,7 @@ function enterCrashContext(context) {
 }
 
 // src/observability/hostEvents.ts
-import path24 from "path";
+import path25 from "path";
 async function recordHostTurnStarted(rootDir, input) {
   await recordObservabilityEvent(rootDir, {
     event: "host.turn",
@@ -9318,53 +9036,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 ?? [];
@@ -10293,6 +9964,7 @@ export {
   getErrorMessage,
   ControlPlaneLedger,
   ExecutionStore,
+  SessionEventStore,
   isProcessAlive,
   terminatePid,
   BackgroundExecutionStore,
@@ -10301,12 +9973,14 @@ export {
   summarizeExecution,
   summarizeExecutionSet,
   EXTENSION_ENV_KEYS,
-  SessionEventStore,
   runHostTurn,
   writeStdout,
   writeStdoutLine,
   writeStderrLine,
   createRuntimeUiEvent,
+  tryParseJson,
+  buildToolCallDisplay,
+  buildToolResultDisplay,
   colorRuntimeUiText,
   createRuntimeUiTerminalRenderer,
   formatRuntimeUiEventLine