@jun133/kitty 0.0.7 → 0.0.9

package/dist/chunk-3KMC6H5K.mjs

@@ -0,0 +1,2701 @@
+// src/provider/capabilities.ts
+var DEFAULT_PROVIDER = "openai-compatible";
+var DEFAULT_REQUEST_TIMEOUT_MS = 10 * 60 * 1e3;
+var DEFAULT_DOCTOR_PROBE_TIMEOUT_MS = 1e4;
+var RELAY_REQUEST_TIMEOUT_MS = 15 * 60 * 1e3;
+var RELAY_DOCTOR_PROBE_TIMEOUT_MS = 45e3;
+function resolveProviderCapabilities(input) {
+  const provider = normalizeProviderName(input.provider);
+  const model = normalizeModelName(input.model);
+  if (provider === "deepseek" || model.startsWith("deepseek-")) {
+    return {
+      provider: "deepseek",
+      model,
+      wireApi: "chat.completions",
+      supportsReasoningContent: true,
+      defaultReasoningEnabled: true,
+      defaultReasoningEffort: "high",
+      requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+      doctorProbeTimeoutMs: DEFAULT_DOCTOR_PROBE_TIMEOUT_MS
+    };
+  }
+  if (provider === "openai" || model === "gpt-5.4") {
+    return {
+      provider: "openai",
+      model,
+      wireApi: "responses",
+      supportsReasoningContent: false,
+      defaultReasoningEnabled: true,
+      defaultReasoningEffort: "xhigh",
+      requestTimeoutMs: RELAY_REQUEST_TIMEOUT_MS,
+      doctorProbeTimeoutMs: RELAY_DOCTOR_PROBE_TIMEOUT_MS
+    };
+  }
+  return {
+    provider,
+    model,
+    wireApi: "chat.completions",
+    supportsReasoningContent: false,
+    defaultReasoningEnabled: false,
+    requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+    doctorProbeTimeoutMs: DEFAULT_DOCTOR_PROBE_TIMEOUT_MS
+  };
+}
+function normalizeProviderName(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  return normalized || DEFAULT_PROVIDER;
+}
+function normalizeModelName(value) {
+  return String(value ?? "").trim();
+}
+
+// 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 fs2 from "fs/promises";
+import path2 from "path";
+
+// src/project/statePaths.ts
+import fs from "fs/promises";
+import path 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 = path.resolve(rootDir);
+  const kittyDir = path.join(normalizedRoot, PROJECT_STATE_DIR_NAME);
+  const extensionsDir = path.join(kittyDir, "extensions");
+  const memoryDir = path.join(kittyDir, "memory");
+  const observabilityDir = path.join(kittyDir, "observability");
+  return {
+    rootDir: normalizedRoot,
+    kittyDir,
+    cacheDir: path.join(kittyDir, "cache"),
+    sessionsDir: path.join(kittyDir, "sessions"),
+    changesDir: path.join(kittyDir, "changes"),
+    eventsDir: path.join(kittyDir, "events"),
+    extensionsDir,
+    memoryDir,
+    evidenceMemoryDir: path.join(memoryDir, "evidence"),
+    projectMemoryDir: path.join(memoryDir, "project"),
+    sessionMemoryDir: path.join(memoryDir, "sessions"),
+    userMemoryDir: path.join(memoryDir, "user"),
+    controlPlaneLedgerFile: path.join(kittyDir, "control-plane.sqlite"),
+    observabilityDir,
+    observabilityEventsDir: path.join(observabilityDir, "events"),
+    observabilityCrashesDir: path.join(observabilityDir, "crashes")
+  };
+}
+async function ensureProjectStateDirectories(rootDir) {
+  const paths = getProjectStatePaths(rootDir);
+  await fs.mkdir(paths.extensionsDir, { recursive: true });
+  await fs.mkdir(paths.cacheDir, { recursive: true });
+  await fs.mkdir(paths.sessionsDir, { recursive: true });
+  await fs.mkdir(paths.changesDir, { recursive: true });
+  await fs.mkdir(paths.eventsDir, { recursive: true });
+  await fs.mkdir(paths.evidenceMemoryDir, { recursive: true });
+  await fs.mkdir(paths.projectMemoryDir, { recursive: true });
+  await fs.mkdir(paths.sessionMemoryDir, { recursive: true });
+  await fs.mkdir(paths.userMemoryDir, { recursive: true });
+  await fs.mkdir(paths.observabilityEventsDir, { recursive: true });
+  await fs.mkdir(paths.observabilityCrashesDir, { recursive: true });
+  return paths;
+}
+
+// src/observability/schema.ts
+var OBSERVABILITY_VERSION = 1;
+function buildObservabilityEventRecord(input) {
+  return {
+    version: OBSERVABILITY_VERSION,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    event: normalizeText(input.event, "unknown"),
+    status: normalizeText(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 = normalizeText(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: normalizeText(value.name, "Error"),
+      message: normalizeText(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 normalizeText(String(value), "");
+}
+function normalizeText(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 normalizeText(error.message, error.name || "Unknown error");
+  }
+  if (typeof error === "object" && error !== null && "message" in error) {
+    return normalizeText(error.message, "Unknown error");
+  }
+  return normalizeText(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 = path2.join(paths.observabilityEventsDir, `${record.timestamp.slice(0, 10)}.jsonl`);
+  await fs2.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 capabilities = resolveProviderCapabilities(input);
+  if (capabilities.provider === "openai") {
+    return {
+      provider: "openai",
+      automaticPrefixCache: true,
+      promptCacheKey: buildPromptCacheKey(input)
+    };
+  }
+  if (capabilities.provider === "deepseek") {
+    return {
+      provider: "deepseek",
+      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";
+  }
+  return hasUnreplayableAssistantReasoning(messages) ? "disabled" : "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 = normalizeResponsesReasoningEffort(
+    request.reasoningEffort ?? capabilities.defaultReasoningEffort
+  );
+  if (request.forceReasoning || capabilities.defaultReasoningEnabled || reasoningEffort) {
+    body.reasoning = {
+      effort: reasoningEffort ?? "high",
+      summary: "detailed"
+    };
+  }
+  return body;
+}
+function normalizeResponsesReasoningEffort(effort) {
+  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", ensureTrailingSlash(parsed.toString())).toString()));
+    }
+  } catch {
+    return candidates;
+  }
+  return [...new Set(candidates)];
+}
+function ensureTrailingSlash(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 baseUrls = buildProviderBaseUrlCandidates(config.baseUrl);
+  const clients = /* @__PURE__ */ new Map();
+  let preferredBaseUrl;
+  return {
+    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 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 selectProviderWireAdapter(wireApi) {
+  if (wireApi === "responses") {
+    return responsesAdapter;
+  }
+  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 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/session/messages.ts
+function buildChatMessages(systemPrompt, messages, contextWindowMessages, model) {
+  const recentMessages = messages.slice(-contextWindowMessages);
+  return [
+    {
+      role: "system",
+      content: systemPrompt
+    },
+    ...recentMessages.map(
+      (message, index) => toChatMessage(message, {
+        includeReasoning: shouldIncludeStoredAssistantReasoning(recentMessages, index, model)
+      })
+    )
+  ];
+}
+function createMessage(role, content, options = {}) {
+  return {
+    role,
+    content,
+    source: options.source,
+    name: options.name,
+    tool_calls: options.toolCalls,
+    reasoningContent: options.reasoningContent,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createToolMessage(toolCallId, content, name) {
+  return {
+    role: "tool",
+    content,
+    tool_call_id: toolCallId,
+    name,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function readReasoningContent(message) {
+  const candidate = message.reasoning_content;
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
+}
+function collapseContentParts(content) {
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  const fragments = content.map((part) => {
+    if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+      return part.text;
+    }
+    return "";
+  }).filter(Boolean);
+  return fragments.length > 0 ? fragments.join("") : null;
+}
+function toChatMessage(message, options) {
+  if (message.role === "tool") {
+    return {
+      role: "tool",
+      content: message.content ?? "",
+      tool_call_id: message.tool_call_id ?? ""
+    };
+  }
+  if (message.role === "assistant" && message.tool_calls?.length) {
+    const assistantMessage = {
+      role: "assistant",
+      content: message.content,
+      tool_calls: message.tool_calls
+    };
+    if (options.includeReasoning && 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" && options.includeReasoning && message.reasoningContent !== void 0) {
+    baseMessage.reasoning_content = message.reasoningContent;
+  }
+  return baseMessage;
+}
+function findLatestUserIndex(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index]?.role === "user") {
+      return index;
+    }
+  }
+  return -1;
+}
+function expandStartToToolBoundary(messages, startIndex) {
+  let index = Math.max(0, Math.min(startIndex, messages.length - 1));
+  while (index > 0 && messages[index]?.role === "tool") {
+    index -= 1;
+  }
+  return index;
+}
+function modelUsesReasoningContent(model) {
+  return resolveProviderCapabilities({ model }).supportsReasoningContent;
+}
+function isAssistantMessageInLatestTurn(messages, index) {
+  return messages[index]?.role === "assistant" && index > findLatestUserIndex(messages);
+}
+function shouldIncludeStoredAssistantReasoning(messages, index, model) {
+  return modelUsesReasoningContent(model) && messages[index]?.role === "assistant";
+}
+
+// src/session/turnFrame.ts
+function isInternalMessage(message) {
+  if (typeof message === "object" && message !== null && "source" in message) {
+    return message.source === "internal";
+  }
+  return false;
+}
+function createInternalReminder(text) {
+  return text.trim();
+}
+function readUserInput(message) {
+  if (typeof message === "object" && message !== null) {
+    if (isInternalMessage(message)) {
+      return void 0;
+    }
+    const normalized2 = oneLine(message.content ?? "");
+    return normalized2 || void 0;
+  }
+  if (isInternalMessage(message)) {
+    return void 0;
+  }
+  const normalized = oneLine(message ?? "");
+  return normalized || void 0;
+}
+function findLatestUserInputIndex(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "user" && readUserInput(message)) {
+      return index;
+    }
+  }
+  return -1;
+}
+function sliceCurrentUserInputFrame(messages) {
+  const frameStart = findLatestUserInputIndex(messages);
+  if (frameStart < 0) {
+    return [];
+  }
+  const frame = messages.slice(frameStart);
+  return frame.filter((message) => !(message.role === "user" && isInternalMessage(message)));
+}
+function oneLine(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+// src/session/taskStateHistory.ts
+import path3 from "path";
+function collectActiveFiles(messages) {
+  const files = [];
+  for (const message of messages) {
+    if (!message) {
+      continue;
+    }
+    if (message.role === "assistant" && message.tool_calls?.length) {
+      for (const toolCall of message.tool_calls) {
+        const parsed = safeParseObject(toolCall.function.arguments);
+        collectPathsFromValue(parsed, files);
+      }
+      continue;
+    }
+    if (message.role === "tool") {
+      const parsed = safeParseObject(message.content ?? "");
+      collectPathsFromValue(parsed, files);
+    }
+  }
+  return files.map((value) => normalizeFilePath(value)).filter(Boolean);
+}
+function collectPlannedActions(messages) {
+  const actions = [];
+  for (const message of messages) {
+    if (message?.role !== "assistant" || !message.tool_calls?.length) {
+      continue;
+    }
+    const names = message.tool_calls.map((toolCall) => toolCall.function.name).join(", ");
+    if (names) {
+      actions.push(`plan ${names}`);
+    }
+  }
+  return actions;
+}
+function collectCompletedActions(messages) {
+  const actions = [];
+  for (const message of messages) {
+    if (message?.role !== "tool" || !message.name) {
+      continue;
+    }
+    const content = message.content ?? "";
+    const parsed = safeParseObject(content);
+    if (parsed && typeof parsed.error === "string" && parsed.error.length > 0) {
+      continue;
+    }
+    actions.push(formatCompletedAction(message.name, parsed));
+  }
+  return actions.filter(Boolean);
+}
+function collectBlockers(messages) {
+  const blockers = [];
+  for (const message of messages) {
+    if (message?.role !== "tool") {
+      continue;
+    }
+    const parsed = safeParseObject(message.content ?? "");
+    if (!parsed || typeof parsed.error !== "string" || parsed.error.length === 0) {
+      continue;
+    }
+    blockers.push(`${message.name ?? "tool"}: ${truncate(oneLine2(parsed.error), 180)}`);
+  }
+  return blockers;
+}
+function oneLine2(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function truncate(value, maxChars) {
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...`;
+}
+function formatCompletedAction(toolName, payload) {
+  const pathValue = normalizeFilePath(readPath(payload?.path));
+  if (toolName === "bash") {
+    const command = typeof payload?.command === "string" ? payload.command : "command";
+    const exitCode = typeof payload?.exitCode === "number" ? payload.exitCode : "unknown";
+    return `bash ${truncate(oneLine2(command), 120)} (exit ${exitCode})`;
+  }
+  return pathValue ? `${toolName} ${truncate(pathValue, 160)}` : toolName;
+}
+function collectPathsFromValue(value, bucket) {
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectPathsFromValue(item, bucket);
+    }
+    return;
+  }
+  for (const [key, item] of Object.entries(value)) {
+    if (typeof item === "string" && isPathLikeKey(key)) {
+      bucket.push(item);
+      continue;
+    }
+    if (Array.isArray(item)) {
+      for (const nested of item) {
+        collectPathsFromValue(nested, bucket);
+      }
+      continue;
+    }
+    if (item && typeof item === "object") {
+      collectPathsFromValue(item, bucket);
+    }
+  }
+}
+function isPathLikeKey(key) {
+  return key === "path" || key === "cwd" || key.endsWith("Path");
+}
+function readPath(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function safeParseObject(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeFilePath(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.startsWith("<") || trimmed.includes("\n")) {
+    return void 0;
+  }
+  if (trimmed.length > 260) {
+    return truncate(trimmed, 260);
+  }
+  return trimmed.includes(path3.sep) || trimmed.includes("/") || trimmed.includes(".") ? trimmed : void 0;
+}
+
+// src/session/taskState.ts
+var MAX_ACTIVE_FILES = 12;
+var MAX_PLANNED_ACTIONS = 8;
+var MAX_COMPLETED_ACTIONS = 12;
+var MAX_BLOCKERS = 8;
+function createEmptyTaskState(timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    activeFiles: [],
+    plannedActions: [],
+    completedActions: [],
+    blockers: [],
+    lastUpdatedAt: timestamp
+  };
+}
+function deriveTaskState(messages, previous) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const currentTurn = findCurrentTurn(messages);
+  const frameMessages = currentTurn ? messages.slice(currentTurn.startIndex) : messages;
+  return {
+    focus: previous?.focus,
+    activeFiles: takeLastUnique(collectActiveFiles(frameMessages), MAX_ACTIVE_FILES),
+    plannedActions: takeLastUnique(collectPlannedActions(frameMessages), MAX_PLANNED_ACTIONS),
+    completedActions: takeLastUnique(collectCompletedActions(frameMessages), MAX_COMPLETED_ACTIONS),
+    blockers: takeLastUnique(collectBlockers(frameMessages), MAX_BLOCKERS),
+    lastUpdatedAt: now
+  };
+}
+function normalizeTaskState(taskState) {
+  if (!taskState) {
+    return void 0;
+  }
+  return {
+    focus: typeof taskState.focus === "string" ? taskState.focus : void 0,
+    activeFiles: takeLastUnique(taskState.activeFiles ?? [], MAX_ACTIVE_FILES),
+    plannedActions: takeLastUnique(taskState.plannedActions ?? [], MAX_PLANNED_ACTIONS),
+    completedActions: takeLastUnique(taskState.completedActions ?? [], MAX_COMPLETED_ACTIONS),
+    blockers: takeLastUnique(taskState.blockers ?? [], MAX_BLOCKERS),
+    lastUpdatedAt: typeof taskState.lastUpdatedAt === "string" && taskState.lastUpdatedAt.length > 0 ? taskState.lastUpdatedAt : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function formatTaskStateBlock(taskState) {
+  if (!taskState) {
+    return "- none";
+  }
+  const parts = [
+    taskState.focus ? `- Focus: ${taskState.focus}` : "- Focus: none",
+    `- Planned actions: ${formatList(taskState.plannedActions)}`,
+    `- Blockers: ${formatList(taskState.blockers)}`,
+    `- Updated at: ${taskState.lastUpdatedAt}`
+  ];
+  return parts.join("\n");
+}
+function normalizeSessionRecord(session) {
+  return {
+    ...session,
+    messageCount: Array.isArray(session.messages) ? session.messages.length : 0,
+    messages: Array.isArray(session.messages) ? session.messages : [],
+    taskState: normalizeTaskState(deriveTaskState(Array.isArray(session.messages) ? session.messages : [], session.taskState))
+  };
+}
+function applyCurrentTurnFrame(session, input, timestamp = (/* @__PURE__ */ new Date()).toISOString(), source = "external") {
+  const userInput = readUserInput({ content: input, source });
+  if (!userInput) {
+    return {
+      ...session,
+      taskState: normalizeTaskState(session.taskState ?? createEmptyTaskState(timestamp))
+    };
+  }
+  return {
+    ...session,
+    taskState: {
+      focus: session.taskState?.focus,
+      activeFiles: [],
+      plannedActions: [],
+      completedActions: [],
+      blockers: [],
+      lastUpdatedAt: timestamp
+    }
+  };
+}
+function findCurrentTurn(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "user") {
+      continue;
+    }
+    const normalized = readUserInput(message);
+    if (normalized) {
+      return {
+        startIndex: index
+      };
+    }
+  }
+  return void 0;
+}
+function takeLastUnique(values, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (let index = values.length - 1; index >= 0; index -= 1) {
+    const value = values[index]?.trim();
+    if (!value || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    result.unshift(value);
+    if (result.length >= limit) {
+      break;
+    }
+  }
+  return result;
+}
+function formatList(values) {
+  return values.length > 0 ? values.join(" | ") : "none";
+}
+
+// src/utils/normalize.ts
+function normalizeTimestamp(value, fallback) {
+  return typeof value === "string" && value.trim().length > 0 ? value : fallback;
+}
+
+// src/session/sessionDiff.ts
+var MAX_SESSION_DIFF_CHANGES = 20;
+var MAX_SESSION_DIFF_PATHS = 24;
+var MAX_DIFF_PREVIEW_CHARS = 2e3;
+function createEmptySessionDiff(timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    version: 1,
+    changedPaths: [],
+    changes: [],
+    updatedAt: timestamp
+  };
+}
+function normalizeSessionDiff(sessionDiff, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  const normalizedChanges = (sessionDiff?.changes ?? []).map((change) => normalizeSessionDiffChange(change, timestamp)).filter((change) => Boolean(change));
+  return {
+    version: 1,
+    changedPaths: takeLastUniquePaths(sessionDiff?.changedPaths ?? []),
+    changes: normalizedChanges.slice(-MAX_SESSION_DIFF_CHANGES),
+    updatedAt: normalizeTimestamp(sessionDiff?.updatedAt, timestamp)
+  };
+}
+function normalizeSessionDiffState(session) {
+  return {
+    ...session,
+    sessionDiff: normalizeSessionDiff(session.sessionDiff)
+  };
+}
+function noteSessionDiff(session, change, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (!change) {
+    return normalizeSessionDiffState(session);
+  }
+  const current = normalizeSessionDiff(session.sessionDiff, timestamp);
+  const normalizedChange = normalizeSessionDiffChange(change, timestamp);
+  if (!normalizedChange) {
+    return {
+      ...session,
+      sessionDiff: current
+    };
+  }
+  return {
+    ...session,
+    sessionDiff: {
+      version: 1,
+      changedPaths: takeLastUniquePaths([...current.changedPaths, ...normalizedChange.changedPaths]),
+      changes: [...current.changes, normalizedChange].slice(-MAX_SESSION_DIFF_CHANGES),
+      updatedAt: timestamp
+    }
+  };
+}
+function normalizeSessionDiffChange(change, timestamp) {
+  const toolName = normalizeText2(change?.toolName);
+  const changedPaths = takeLastUniquePaths(change?.changedPaths ?? []);
+  if (!toolName || changedPaths.length === 0) {
+    return null;
+  }
+  return {
+    toolName,
+    changeId: normalizeText2(change?.changeId) || void 0,
+    changedPaths,
+    diff: truncate2(change?.diff, MAX_DIFF_PREVIEW_CHARS),
+    diagnosticsStatus: normalizeDiagnosticsStatus(change?.diagnosticsStatus),
+    errorCount: normalizeCount(change?.errorCount),
+    warningCount: normalizeCount(change?.warningCount),
+    recordedAt: normalizeTimestamp(change?.recordedAt, timestamp)
+  };
+}
+function takeLastUniquePaths(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (let index = paths.length - 1; index >= 0; index -= 1) {
+    const normalized = normalizeText2(paths[index]);
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    result.unshift(normalized);
+    if (result.length >= MAX_SESSION_DIFF_PATHS) {
+      break;
+    }
+  }
+  return result;
+}
+function normalizeDiagnosticsStatus(value) {
+  return value === "issues" || value === "unavailable" ? value : "clean";
+}
+function normalizeCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
+function normalizeText2(value) {
+  return String(value ?? "").trim();
+}
+function truncate2(value, maxChars) {
+  if (!value) {
+    return void 0;
+  }
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...`;
+}
+
+// src/agent/runtimeTransition/shared.ts
+var MAX_REASON_ITEMS = 6;
+var MAX_REASON_TEXT_CHARS = 220;
+function takeLastUnique2(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (let index = values.length - 1; index >= 0; index -= 1) {
+    const normalized = normalizeText3(values[index]);
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    result.unshift(normalized);
+    if (result.length >= MAX_REASON_ITEMS) {
+      break;
+    }
+  }
+  return result;
+}
+function truncate3(value) {
+  return value.length <= MAX_REASON_TEXT_CHARS ? value : `${value.slice(0, MAX_REASON_TEXT_CHARS)}...`;
+}
+function normalizeText3(value) {
+  return String(value ?? "").replace(/\s+/g, " ").trim();
+}
+function clampWholeNumber(value, min, max, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(min, Math.min(max, Math.trunc(value)));
+}
+
+// src/agent/runtimeTransition/builders.ts
+function createToolBatchTransition(input, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    action: "continue",
+    reason: {
+      code: "continue.after_tool_batch",
+      toolNames: takeLastUnique2(input.toolNames),
+      changedPaths: takeLastUnique2(input.changedPaths ?? [])
+    },
+    timestamp
+  };
+}
+function createEmptyAssistantResponseTransition(timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    action: "continue",
+    reason: {
+      code: "continue.empty_assistant_response"
+    },
+    timestamp
+  };
+}
+function createProviderRecoveryTransition(input, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    action: "recover",
+    reason: {
+      code: "recover.provider_request_retry",
+      consecutiveFailures: Math.max(1, Math.trunc(input.consecutiveFailures)),
+      error: truncate3(normalizeText3(input.error?.message ?? input.error) || "request failed"),
+      configuredModel: normalizeText3(input.configuredModel) || "unknown_model",
+      requestModel: normalizeText3(input.requestModel) || "unknown_model",
+      contextWindowMessages: Math.max(1, Math.trunc(input.requestConfig.contextWindowMessages)),
+      maxContextChars: Math.max(1, Math.trunc(input.requestConfig.maxContextChars)),
+      contextSummaryChars: Math.max(1, Math.trunc(input.requestConfig.contextSummaryChars)),
+      delayMs: Math.max(0, Math.trunc(input.delayMs))
+    },
+    timestamp
+  };
+}
+function createFinalizeTransition(input, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    action: "finalize",
+    reason: {
+      code: "finalize.completed",
+      changedPaths: takeLastUnique2([...input.changedPaths])
+    },
+    timestamp
+  };
+}
+function createExecutionWaitYieldTransition(input, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    action: "yield",
+    reason: {
+      code: "yield.execution_wait",
+      executionIds: takeLastUnique2([...input.executionIds]),
+      toolNames: takeLastUnique2([...input.toolNames])
+    },
+    timestamp
+  };
+}
+function buildRunTurnResult(input) {
+  return {
+    session: input.session,
+    changedPaths: [...input.changedPaths],
+    transition: input.transition
+  };
+}
+
+// src/agent/runtimeTransition/normalize.ts
+function normalizeRuntimeTransition(transition, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (!transition || typeof transition !== "object") {
+    return void 0;
+  }
+  const action = normalizeAction(transition.action);
+  const reason = transition.reason;
+  const normalizedTimestamp = normalizeTimestamp(transition.timestamp, timestamp);
+  if (!reason || typeof reason !== "object") {
+    return void 0;
+  }
+  switch (action) {
+    case "continue":
+      return normalizeContinueTransition(reason, normalizedTimestamp);
+    case "recover":
+      return normalizeRecoverTransition(reason, normalizedTimestamp);
+    case "finalize":
+      return normalizeFinalizeTransition(reason, normalizedTimestamp);
+    case "yield":
+      return normalizeYieldTransition(reason, normalizedTimestamp);
+    default:
+      return void 0;
+  }
+}
+function normalizeContinueTransition(reason, timestamp) {
+  switch (reason.code) {
+    case "continue.after_tool_batch": {
+      const toolNames = takeLastUnique2(reason.toolNames);
+      if (toolNames.length === 0) {
+        return void 0;
+      }
+      return {
+        action: "continue",
+        reason: {
+          code: reason.code,
+          toolNames,
+          changedPaths: takeLastUnique2(reason.changedPaths ?? [])
+        },
+        timestamp
+      };
+    }
+    case "continue.empty_assistant_response":
+      return {
+        action: "continue",
+        reason: {
+          code: reason.code
+        },
+        timestamp
+      };
+    default:
+      return void 0;
+  }
+}
+function normalizeRecoverTransition(reason, timestamp) {
+  if (reason.code !== "recover.provider_request_retry") {
+    return void 0;
+  }
+  return {
+    action: "recover",
+    reason: {
+      code: reason.code,
+      consecutiveFailures: clampWholeNumber(reason.consecutiveFailures, 1, 50, 1) ?? 1,
+      error: truncate3(normalizeText3(reason.error) || "request failed"),
+      configuredModel: normalizeText3(reason.configuredModel) || "unknown_model",
+      requestModel: normalizeText3(reason.requestModel) || "unknown_model",
+      contextWindowMessages: clampWholeNumber(reason.contextWindowMessages, 1, 999, 1) ?? 1,
+      maxContextChars: clampWholeNumber(reason.maxContextChars, 1, 1e6, 1) ?? 1,
+      contextSummaryChars: clampWholeNumber(reason.contextSummaryChars, 1, 1e6, 1) ?? 1,
+      delayMs: clampWholeNumber(reason.delayMs, 0, 36e5, 0) ?? 0
+    },
+    timestamp
+  };
+}
+function normalizeFinalizeTransition(reason, timestamp) {
+  if (reason.code !== "finalize.completed") {
+    return void 0;
+  }
+  return {
+    action: "finalize",
+    reason: {
+      code: reason.code,
+      changedPaths: takeLastUnique2(reason.changedPaths ?? [])
+    },
+    timestamp
+  };
+}
+function normalizeYieldTransition(reason, timestamp) {
+  if (reason.code !== "yield.execution_wait") {
+    return void 0;
+  }
+  const executionIds = takeLastUnique2(reason.executionIds ?? []);
+  if (executionIds.length === 0) {
+    return void 0;
+  }
+  return {
+    action: "yield",
+    reason: {
+      code: reason.code,
+      executionIds,
+      toolNames: takeLastUnique2(reason.toolNames ?? [])
+    },
+    timestamp
+  };
+}
+function normalizeAction(value) {
+  return value === "continue" || value === "recover" || value === "finalize" || value === "yield" ? value : void 0;
+}
+
+// src/agent/runtimeTransition/flow.ts
+function normalizeCheckpointFlow(flow, status, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  const lastTransition = normalizeRuntimeTransition(flow?.lastTransition, timestamp);
+  const phase = normalizePhase(lastTransition ? getRuntimeTransitionPhase(lastTransition) : flow?.phase, status);
+  const runState = normalizeRunState({
+    current: flow?.runState,
+    status,
+    timestamp
+  });
+  return {
+    phase,
+    reason: lastTransition ? formatRuntimeTransitionReason(lastTransition) : normalizeText3(flow?.reason) || void 0,
+    recoveryFailures: lastTransition?.action === "recover" ? lastTransition.reason.consecutiveFailures : phase === "recovery" ? clampWholeNumber(flow?.recoveryFailures, 1, 50, void 0) : void 0,
+    runState,
+    lastTransition,
+    updatedAt: normalizeTimestamp(flow?.updatedAt, timestamp)
+  };
+}
+function buildCheckpointFlow(input) {
+  const timestamp = input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const transition = normalizeRuntimeTransition(input.transition, timestamp);
+  const phase = normalizePhase(
+    transition ? getRuntimeTransitionPhase(transition) : input.defaultPhase ?? input.current?.phase,
+    input.status
+  );
+  const runState = normalizeRunState({
+    current: input.current?.runState,
+    status: input.status,
+    override: input.runState,
+    timestamp
+  });
+  return {
+    phase,
+    reason: transition ? formatRuntimeTransitionReason(transition) : void 0,
+    recoveryFailures: transition?.action === "recover" ? transition.reason.consecutiveFailures : void 0,
+    runState,
+    lastTransition: transition,
+    updatedAt: timestamp
+  };
+}
+function getTurnInputTransition(input, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return void 0;
+}
+function formatRuntimeTransitionReason(transition) {
+  return transition.reason.code;
+}
+function getRuntimeTransitionPhase(transition) {
+  if (transition.action === "recover") {
+    return "recovery";
+  }
+  return "active";
+}
+function normalizePhase(value, status) {
+  if (status === "completed") {
+    return "active";
+  }
+  return value === "recovery" ? value : "active";
+}
+function normalizeRunState(input) {
+  const normalizedStatus = input.status === "completed" ? "idle" : input.override?.status === "busy" || input.override?.status === "idle" ? input.override.status : input.current?.status === "busy" ? "busy" : "idle";
+  const source = normalizeRunStateSource(
+    input.status === "completed" ? "checkpoint" : input.override?.source ?? input.current?.source,
+    normalizedStatus
+  );
+  return {
+    status: normalizedStatus,
+    source,
+    pendingToolCallCount: 0,
+    updatedAt: input.timestamp
+  };
+}
+function normalizeRunStateSource(source, status) {
+  if (status === "idle") {
+    return source === "turn" ? "checkpoint" : source ?? "checkpoint";
+  }
+  if (source === "turn" || source === "tool_batch") {
+    return source;
+  }
+  return "checkpoint";
+}
+
+// src/session/checkpoint/shared.ts
+import crypto2 from "crypto";
+import path4 from "path";
+var MAX_COMPLETED_STEPS = 8;
+var MAX_BATCH_TOOLS = 6;
+var MAX_BATCH_PATHS = 6;
+var MAX_SUMMARY_CHARS = 220;
+function fingerprintFocus(focus) {
+  return crypto2.createHash("sha1").update(focus.trim().toLowerCase()).digest("hex");
+}
+function normalizeText4(value) {
+  return String(value ?? "").replace(/\s+/g, " ").trim();
+}
+function truncate4(value, maxChars) {
+  if (!value) {
+    return void 0;
+  }
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...`;
+}
+function takeLastUnique3(values, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (let index = values.length - 1; index >= 0; index -= 1) {
+    const normalized = normalizeText4(values[index]);
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    result.unshift(normalized);
+    if (result.length >= limit) {
+      break;
+    }
+  }
+  return result;
+}
+function safeParseObject2(raw) {
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function readString(value) {
+  const normalized = normalizeText4(value);
+  return normalized || void 0;
+}
+function normalizeToolBatch(toolBatch) {
+  if (!toolBatch) {
+    return void 0;
+  }
+  const tools = takeLastUnique3(toolBatch.tools ?? [], MAX_BATCH_TOOLS);
+  if (tools.length === 0) {
+    return void 0;
+  }
+  return {
+    tools,
+    summary: truncate4(normalizeText4(toolBatch.summary) || `Ran ${tools.join(", ")}`, MAX_SUMMARY_CHARS),
+    changedPaths: takeLastUnique3(toolBatch.changedPaths ?? [], MAX_BATCH_PATHS),
+    recordedAt: normalizeTimestamp(toolBatch.recordedAt, (/* @__PURE__ */ new Date()).toISOString())
+  };
+}
+
+// src/session/checkpoint/derivation.ts
+function deriveCompletedSteps(session) {
+  const completedActions = session.taskState?.completedActions ?? [];
+  return takeLastUnique3(completedActions, MAX_COMPLETED_STEPS);
+}
+function deriveRecentToolBatchFromMessages(messages, timestamp) {
+  let lastToolIndex = messages.length - 1;
+  while (lastToolIndex >= 0 && messages[lastToolIndex]?.role !== "tool") {
+    lastToolIndex -= 1;
+  }
+  if (lastToolIndex < 0) {
+    return void 0;
+  }
+  let startIndex = lastToolIndex;
+  while (startIndex >= 0 && messages[startIndex]?.role === "tool") {
+    startIndex -= 1;
+  }
+  const toolMessages = messages.slice(startIndex + 1, lastToolIndex + 1).filter((message) => message.role === "tool");
+  const toolNames = toolMessages.map((message) => normalizeText4(message.name)).filter(Boolean);
+  return buildToolBatch(toolNames, toolMessages, void 0, timestamp);
+}
+function buildToolBatch(toolNames, toolMessages, changedPaths, timestamp) {
+  const tools = takeLastUnique3(toolNames, MAX_BATCH_TOOLS);
+  if (tools.length === 0) {
+    return void 0;
+  }
+  const batchChangedPaths = takeLastUnique3(
+    [
+      ...changedPaths ?? [],
+      ...toolMessages.map((message) => readPathFromMessage(message)).filter(Boolean)
+    ],
+    MAX_BATCH_PATHS
+  );
+  const recordedAt = normalizeTimestamp(
+    toolMessages[toolMessages.length - 1]?.createdAt,
+    timestamp
+  );
+  return {
+    tools,
+    summary: buildToolBatchSummary(tools, batchChangedPaths),
+    changedPaths: batchChangedPaths,
+    recordedAt
+  };
+}
+function readPathFromMessage(message) {
+  const payload = safeParseObject2(message.content);
+  return readString(payload?.path) ?? readString(payload?.requestedPath);
+}
+function buildToolBatchSummary(toolNames, changedPaths) {
+  const fragments = [`Ran ${toolNames.join(", ")}`];
+  if (changedPaths.length > 0) {
+    fragments.push(`changed ${changedPaths.join(" | ")}`);
+  }
+  return truncate4(fragments.join("; "), MAX_SUMMARY_CHARS);
+}
+
+// src/session/checkpoint/base.ts
+function createEmptyCheckpoint(timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    version: 1,
+    status: "active",
+    completedSteps: [],
+    flow: {
+      phase: "active",
+      runState: {
+        status: "idle",
+        source: "checkpoint",
+        pendingToolCallCount: 0,
+        updatedAt: timestamp
+      },
+      updatedAt: timestamp
+    },
+    updatedAt: timestamp
+  };
+}
+function createCheckpointForFocus(focus, timestamp) {
+  return {
+    ...createEmptyCheckpoint(timestamp),
+    focus,
+    focusFingerprint: focus ? fingerprintFocus(focus) : void 0
+  };
+}
+function deriveCheckpointFromSession(session, timestamp) {
+  const recentToolBatch = deriveRecentToolBatchFromMessages(session.messages, timestamp);
+  return {
+    ...createCheckpointForFocus(normalizeText4(session.taskState?.focus) || void 0, timestamp),
+    completedSteps: deriveCompletedSteps(session),
+    recentToolBatch
+  };
+}
+
+// src/session/checkpoint/state.ts
+function normalizeCheckpoint(checkpoint, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (!checkpoint) {
+    return void 0;
+  }
+  const focus = normalizeText4(checkpoint.focus) || void 0;
+  const status = checkpoint.status === "completed" ? "completed" : "active";
+  return {
+    version: 1,
+    focus,
+    focusFingerprint: normalizeText4(checkpoint.focusFingerprint) || (focus ? fingerprintFocus(focus) : void 0),
+    status,
+    completedSteps: takeLastUnique3(checkpoint.completedSteps ?? [], 8),
+    recentToolBatch: normalizeToolBatch(checkpoint.recentToolBatch),
+    flow: normalizeCheckpointFlow(checkpoint.flow, status, timestamp),
+    updatedAt: normalizeTimestamp(checkpoint.updatedAt, timestamp)
+  };
+}
+function normalizeSessionCheckpoint(session) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const normalized = normalizeCheckpoint(session.checkpoint, timestamp);
+  const checkpoint = normalized ?? deriveCheckpointFromSession(session, timestamp);
+  if (checkpoint.completedSteps.length === 0) {
+    checkpoint.completedSteps = deriveCompletedSteps(session);
+  }
+  checkpoint.flow = normalizeCheckpointFlow(checkpoint.flow, checkpoint.status, timestamp);
+  checkpoint.updatedAt = normalizeTimestamp(checkpoint.updatedAt, timestamp);
+  return {
+    ...session,
+    checkpoint
+  };
+}
+function noteCheckpointTurnInput(session, input, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  const checkpoint = normalizeSessionCheckpoint(session).checkpoint ?? createEmptyCheckpoint(timestamp);
+  const transition = getTurnInputTransition(input, timestamp);
+  return {
+    ...session,
+    checkpoint: {
+      ...checkpoint,
+      flow: buildCheckpointFlow({
+        current: checkpoint.flow,
+        status: checkpoint.status,
+        transition,
+        runState: checkpoint.status === "completed" ? {
+          status: "idle",
+          source: "checkpoint"
+        } : {
+          status: "busy",
+          source: "turn"
+        },
+        defaultPhase: "active",
+        timestamp
+      }),
+      updatedAt: timestamp
+    }
+  };
+}
+function resolveCurrentFocusCheckpoint(session, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  const focus = normalizeText4(session.taskState?.focus) || void 0;
+  const fingerprint = focus ? fingerprintFocus(focus) : void 0;
+  const checkpoint = normalizeCheckpoint(session.checkpoint, timestamp) ?? createEmptyCheckpoint(timestamp);
+  if (!focus) {
+    return checkpoint;
+  }
+  if (checkpoint.focusFingerprint === fingerprint) {
+    return checkpoint;
+  }
+  return createCheckpointForFocus(focus, timestamp);
+}
+function noteCheckpointToolBatch(session, input, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  const checkpoint = resolveCurrentFocusCheckpoint(session, timestamp);
+  const recentToolBatch = buildToolBatch(input.toolNames, input.toolMessages, input.changedPaths, timestamp);
+  const phase = checkpoint.flow.phase === "recovery" ? "active" : checkpoint.flow.phase;
+  const transition = createToolBatchTransition({
+    toolNames: input.toolNames,
+    changedPaths: input.changedPaths
+  }, timestamp);
+  return {
+    ...session,
+    checkpoint: {
+      ...checkpoint,
+      completedSteps: deriveCompletedSteps(session),
+      recentToolBatch,
+      flow: buildCheckpointFlow({
+        current: checkpoint.flow,
+        status: checkpoint.status,
+        transition,
+        defaultPhase: phase,
+        timestamp
+      }),
+      updatedAt: timestamp
+    }
+  };
+}
+
+// src/session/checkpoint/transitions.ts
+function noteCheckpointTransition(session, transition, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  const checkpoint = resolveCurrentFocusCheckpoint(session, timestamp);
+  return {
+    ...session,
+    checkpoint: {
+      ...checkpoint,
+      flow: buildCheckpointFlow({
+        current: checkpoint.flow,
+        status: checkpoint.status,
+        transition,
+        defaultPhase: checkpoint.flow.phase,
+        timestamp
+      }),
+      updatedAt: timestamp
+    }
+  };
+}
+function noteCheckpointRecovery(session, transition, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  const checkpoint = resolveCurrentFocusCheckpoint(session, timestamp);
+  if (checkpoint.status === "completed") {
+    return {
+      ...session,
+      checkpoint
+    };
+  }
+  return {
+    ...session,
+    checkpoint: {
+      ...checkpoint,
+      flow: buildCheckpointFlow({
+        current: checkpoint.flow,
+        status: checkpoint.status,
+        transition,
+        defaultPhase: "recovery",
+        timestamp
+      }),
+      updatedAt: timestamp
+    }
+  };
+}
+function noteCheckpointCompleted(session, transition, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  const checkpoint = resolveCurrentFocusCheckpoint(session, timestamp);
+  return {
+    ...session,
+    checkpoint: {
+      ...checkpoint,
+      status: "completed",
+      completedSteps: checkpoint.completedSteps.length > 0 ? checkpoint.completedSteps : deriveCompletedSteps(session),
+      flow: buildCheckpointFlow({
+        current: checkpoint.flow,
+        status: "completed",
+        transition,
+        defaultPhase: "active",
+        timestamp
+      }),
+      updatedAt: timestamp
+    }
+  };
+}
+
+// src/session/todos.ts
+var MAX_TODO_ITEMS = 20;
+var MAX_TODO_TEXT_CHARS = 240;
+function deriveTodoItems(messages, previous = []) {
+  const turnBoundaryIndex = findLatestUserInputBoundaryIndex(messages);
+  const stopIndex = turnBoundaryIndex >= 0 ? turnBoundaryIndex : -1;
+  for (let index = messages.length - 1; index > stopIndex; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "tool" || message.name !== "todo_write" || typeof message.content !== "string") {
+      continue;
+    }
+    const parsed = safeParseJson(message.content);
+    if (!parsed || typeof parsed !== "object" || !("items" in parsed)) {
+      continue;
+    }
+    try {
+      return normalizeTodoItems(parsed.items);
+    } catch {
+      continue;
+    }
+  }
+  return normalizeTodoItems(previous);
+}
+function normalizeTodoItems(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  if (value.length > MAX_TODO_ITEMS) {
+    throw new Error(`Too many todo items: max ${MAX_TODO_ITEMS}.`);
+  }
+  const normalized = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  let inProgressCount = 0;
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error("Each todo item must be an object.");
+    }
+    const record = entry;
+    const id = String(record.id ?? "").trim();
+    const text = compactTodoText(record.text);
+    const status = normalizeTodoStatus(record.status);
+    if (!id) {
+      throw new Error("Todo item id is required.");
+    }
+    if (!text) {
+      throw new Error(`Todo item ${id} text is required.`);
+    }
+    if (seenIds.has(id)) {
+      throw new Error(`Duplicate todo item id: ${id}.`);
+    }
+    seenIds.add(id);
+    if (status === "in_progress") {
+      inProgressCount += 1;
+      if (inProgressCount > 1) {
+        throw new Error("Only one todo item can be in_progress.");
+      }
+    }
+    normalized.push({
+      id,
+      text,
+      status
+    });
+  }
+  return normalized;
+}
+function formatTodoBlock(items) {
+  const todos = normalizeTodoItems(items);
+  if (todos.length === 0) {
+    return "- none";
+  }
+  const lines = todos.map((item) => `${statusMarker(item.status)} #${item.id}: ${item.text}`);
+  const completed = todos.filter((item) => item.status === "completed").length;
+  lines.push(`- Progress: ${completed}/${todos.length} completed`);
+  return lines.join("\n");
+}
+function normalizeSessionTodos(session) {
+  return {
+    ...session,
+    todoItems: deriveTodoItems(session.messages ?? [], session.todoItems ?? [])
+  };
+}
+function findLatestUserInputBoundaryIndex(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "user" && readUserInput(message)) {
+      return index;
+    }
+  }
+  return -1;
+}
+function normalizeTodoStatus(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (normalized === "pending" || normalized === "in_progress" || normalized === "completed") {
+    return normalized;
+  }
+  throw new Error(`Invalid todo status: ${String(value ?? "")}.`);
+}
+function compactTodoText(value) {
+  const normalized = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (normalized.length <= MAX_TODO_TEXT_CHARS) {
+    return normalized;
+  }
+  return `${normalized.slice(0, MAX_TODO_TEXT_CHARS)}...`;
+}
+function statusMarker(status) {
+  switch (status) {
+    case "completed":
+      return "[x]";
+    case "in_progress":
+      return "[>]";
+    default:
+      return "[ ]";
+  }
+}
+function safeParseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/session/memory.ts
+var MAX_SESSION_MEMORY_CHARS = 12e3;
+var SESSION_MEMORY_SECTIONS = [
+  {
+    title: "Current Focus",
+    description: "Model-written current work focus that still affects the next turn."
+  },
+  {
+    title: "User Constraints",
+    description: "Stable user constraints or preferences that affect future action."
+  },
+  {
+    title: "Decisions",
+    description: "Decisions already made that should guide later work."
+  },
+  {
+    title: "Open Threads",
+    description: "Unresolved work, next steps, blockers, or questions."
+  },
+  {
+    title: "Verification Facts",
+    description: "Concrete tool, test, file-change, or runtime facts."
+  },
+  {
+    title: "Reusable Lessons",
+    description: "Stable lessons worth moving into spec notes or skill references."
+  }
+];
+function formatSessionMemorySectionTemplate() {
+  return SESSION_MEMORY_SECTIONS.map((section) => `## ${section.title}
+${section.description}
+Write None when no supplied fact belongs here.`).join("\n\n");
+}
+function formatSessionMemorySectionList() {
+  return SESSION_MEMORY_SECTIONS.map((section) => `- ${section.title}: ${section.description}`).join("\n");
+}
+function createSessionMemoryState(summary, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    version: 1,
+    summary: normalizeSummary(summary),
+    updatedAt: timestamp
+  };
+}
+function updateSessionMemory(session, summary, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  const memory = createSessionMemoryState(summary, timestamp);
+  const focus = readSessionMemoryCurrentFocus(memory.summary);
+  return {
+    ...session,
+    sessionMemory: memory,
+    taskState: {
+      ...session.taskState ?? {
+        activeFiles: [],
+        plannedActions: [],
+        completedActions: [],
+        blockers: [],
+        lastUpdatedAt: timestamp
+      },
+      focus,
+      lastUpdatedAt: timestamp
+    }
+  };
+}
+function normalizeSessionMemory(value, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (record.version !== 1 || typeof record.summary !== "string") {
+    return void 0;
+  }
+  return {
+    version: 1,
+    summary: normalizeSummary(record.summary),
+    updatedAt: typeof record.updatedAt === "string" && record.updatedAt.trim() ? record.updatedAt : timestamp
+  };
+}
+function normalizeSummary(value) {
+  return value.replace(/\r\n/g, "\n").trim().slice(0, MAX_SESSION_MEMORY_CHARS);
+}
+function readSessionMemoryCurrentFocus(summary) {
+  const lines = summary.split("\n");
+  let inFocusSection = false;
+  const values = [];
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      if (inFocusSection) {
+        break;
+      }
+      inFocusSection = line.slice(3).trim() === "Current Focus";
+      continue;
+    }
+    if (inFocusSection) {
+      values.push(line);
+    }
+  }
+  const focus = values.join("\n").trim();
+  return focus && focus.toLowerCase() !== "none" ? focus : void 0;
+}
+
+// src/session/workset.ts
+import path5 from "path";
+var MAX_WORKSET_FILES = 20;
+function createEmptySessionWorkset(timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    version: 1,
+    files: [],
+    updatedAt: timestamp
+  };
+}
+function normalizeSessionWorkset(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return createEmptySessionWorkset();
+  }
+  const record = value;
+  if (record.version !== 1 || !Array.isArray(record.files)) {
+    return createEmptySessionWorkset();
+  }
+  const files = record.files.map(normalizeWorksetEntry).filter((entry) => Boolean(entry)).slice(-MAX_WORKSET_FILES);
+  return {
+    version: 1,
+    files,
+    updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : latestWorksetTimestamp(files)
+  };
+}
+function recordSessionWorksetFile(session, input) {
+  const timestamp = input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const workset = normalizeSessionWorkset(session.workset) ?? createEmptySessionWorkset(timestamp);
+  const displayPath = normalizeDisplayPath(input.cwd, input.path);
+  const existing = workset.files.find((entry) => entry.path === displayPath);
+  const nextEntry = existing ? {
+    ...existing,
+    lastSeenAt: timestamp,
+    readCount: existing.readCount + (input.changed ? 0 : 1),
+    changedCount: existing.changedCount + (input.changed ? 1 : 0),
+    lastTool: input.toolName,
+    lastChangeId: input.changeId ?? existing.lastChangeId,
+    reason: input.reason ?? existing.reason
+  } : {
+    path: displayPath,
+    firstSeenAt: timestamp,
+    lastSeenAt: timestamp,
+    readCount: input.changed ? 0 : 1,
+    changedCount: input.changed ? 1 : 0,
+    lastTool: input.toolName,
+    lastChangeId: input.changeId,
+    reason: input.reason
+  };
+  const files = [
+    ...workset.files.filter((entry) => entry.path !== displayPath),
+    nextEntry
+  ].slice(-MAX_WORKSET_FILES);
+  return {
+    ...session,
+    workset: {
+      version: 1,
+      files,
+      updatedAt: timestamp
+    }
+  };
+}
+function normalizeWorksetEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  const filePath = typeof record.path === "string" ? record.path.trim() : "";
+  if (!filePath) {
+    return void 0;
+  }
+  return {
+    path: filePath,
+    firstSeenAt: readString2(record.firstSeenAt),
+    lastSeenAt: readString2(record.lastSeenAt),
+    readCount: readCount(record.readCount),
+    changedCount: readCount(record.changedCount),
+    lastTool: typeof record.lastTool === "string" && record.lastTool.trim() ? record.lastTool.trim() : "unknown",
+    lastChangeId: typeof record.lastChangeId === "string" && record.lastChangeId.trim() ? record.lastChangeId.trim() : void 0,
+    reason: typeof record.reason === "string" && record.reason.trim() ? record.reason.trim() : void 0
+  };
+}
+function normalizeDisplayPath(cwd, targetPath) {
+  const absolutePath = path5.resolve(cwd, targetPath);
+  const relative = path5.relative(cwd, absolutePath);
+  return relative && !relative.startsWith("..") && !path5.isAbsolute(relative) ? relative : absolutePath;
+}
+function readString2(value) {
+  return typeof value === "string" && value.trim() ? value : (/* @__PURE__ */ new Date()).toISOString();
+}
+function readCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
+function latestWorksetTimestamp(files) {
+  return files.map((entry) => entry.lastSeenAt).sort().at(-1) ?? (/* @__PURE__ */ new Date()).toISOString();
+}
+
+export {
+  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,
+  ensureProjectStateDirectories,
+  createEmptyAssistantResponseTransition,
+  createProviderRecoveryTransition,
+  createFinalizeTransition,
+  createExecutionWaitYieldTransition,
+  buildRunTurnResult,
+  fingerprintFocus,
+  normalizeText4 as normalizeText,
+  takeLastUnique3 as takeLastUnique,
+  createEmptyCheckpoint,
+  normalizeCheckpoint,
+  normalizeSessionCheckpoint,
+  noteCheckpointTurnInput,
+  noteCheckpointToolBatch,
+  noteCheckpointTransition,
+  noteCheckpointRecovery,
+  noteCheckpointCompleted,
+  isAbortError,
+  throwIfAborted,
+  sleepWithSignal,
+  isRetryableApiError,
+  recordObservabilityEvent,
+  createProviderClientPool,
+  fetchAssistantResponse,
+  buildChatMessages,
+  createMessage,
+  createToolMessage,
+  readReasoningContent,
+  collapseContentParts,
+  toChatMessage,
+  findLatestUserIndex,
+  expandStartToToolBoundary,
+  modelUsesReasoningContent,
+  isAssistantMessageInLatestTurn,
+  shouldIncludeStoredAssistantReasoning,
+  isInternalMessage,
+  createInternalReminder,
+  readUserInput,
+  findLatestUserInputIndex,
+  sliceCurrentUserInputFrame,
+  oneLine,
+  createEmptyTaskState,
+  deriveTaskState,
+  normalizeTaskState,
+  formatTaskStateBlock,
+  normalizeSessionRecord,
+  applyCurrentTurnFrame,
+  deriveTodoItems,
+  normalizeTodoItems,
+  formatTodoBlock,
+  normalizeSessionTodos,
+  formatSessionMemorySectionTemplate,
+  formatSessionMemorySectionList,
+  updateSessionMemory,
+  normalizeSessionMemory,
+  createEmptySessionDiff,
+  normalizeSessionDiff,
+  normalizeSessionDiffState,
+  noteSessionDiff,
+  normalizeSessionWorkset,
+  recordSessionWorksetFile
+};