laohuang 0.9.2 → 0.9.4

package/dist/bin.js

@@ -7368,342 +7368,156 @@ var require_dist = __commonJS({
   }
 });
 
+// src/sqlite-warning-filter.ts
+var sqliteWarning = "SQLite is an experimental feature and might change at any time";
+process.emit = new Proxy(process.emit, {
+  apply(target, receiver, args) {
+    const [event, warning] = args;
+    if (event === "warning" && warning instanceof Error && warning.name === "ExperimentalWarning" && warning.message === sqliteWarning && !("code" in warning)) {
+      return false;
+    }
+    return Reflect.apply(target, receiver, args);
+  }
+});
+
 // src/main.ts
 import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
-import { dirname as dirname13, join as join20 } from "node:path";
+import { dirname as dirname13, join as join21 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../../packages/session/session-context/dist/conversation-history.js
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // ../../packages/session/session-context/dist/token-estimator.js
-import { createHash } from "node:crypto";
-var TEXT_BYTES_PER_TOKEN = 4;
-var BLOCK_OVERHEAD = 4;
-var MESSAGE_OVERHEAD = 4;
-var DefaultTokenEstimator = class {
-  estimateMessages(messages) {
-    return messages.reduce((total, message) => total + this.estimateMessage(message), 0);
-  }
-  estimateTools(tools) {
-    if (tools.length === 0) {
-      return 0;
-    }
-    return this.estimateText(canonicalJson(tools.map(({ name, description, parameters }) => ({ name, description, parameters })))) + BLOCK_OVERHEAD;
-  }
-  estimateText(text3) {
-    return Math.ceil(Buffer.byteLength(text3, "utf8") / TEXT_BYTES_PER_TOKEN);
-  }
-  measure(input) {
-    const anchor = input.anchor ?? null;
-    if (anchor !== null && this.isValidAnchor(input, anchor)) {
-      const trailingEntries = input.entries.filter((entry) => entry.seq > anchor.throughSeq);
-      const trailingTokens = this.estimateMessages(messagesForEntries(trailingEntries));
-      return {
-        totalTokens: anchor.contextTokens + trailingTokens,
-        anchorTokens: anchor.contextTokens,
-        trailingTokens,
-        source: "provider_usage"
-      };
-    }
-    const totalTokens = this.estimateMessages(input.messages) + this.estimateTools(input.tools);
-    return {
-      totalTokens,
-      anchorTokens: 0,
-      trailingTokens: totalTokens,
-      source: "estimated"
-    };
+import { createHash as createHash2 } from "node:crypto";
+
+// ../../packages/attachment/attachment/dist/errors.js
+var AttachmentError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "AttachmentError";
+    this.code = code;
   }
-  estimateMessage(message) {
-    const attachmentTokens = message.role === "user" || message.role === "tool-result" ? (message.attachments ?? []).reduce((sum, block, index) => sum + (block.type === "image" && !message.omittedImageIndexes?.includes(index) ? 85 + 170 * Math.ceil(block.ref.width / 512) * Math.ceil(block.ref.height / 512) : 32), 0) : 0;
-    if (message.role === "system" && message.toolDefinitions !== void 0)
-      return 0;
-    if (message.role === "system" || message.role === "user") {
-      return MESSAGE_OVERHEAD + BLOCK_OVERHEAD + this.estimateText(message.content) + attachmentTokens;
-    }
-    if (message.role === "tool-result") {
-      return MESSAGE_OVERHEAD + BLOCK_OVERHEAD + this.estimateText(message.content) + attachmentTokens;
+};
+
+// ../../packages/attachment/attachment/dist/types.js
+var DEFAULT_IMAGE_LIMITS = Object.freeze({
+  maxBytes: 20 * 1024 ** 2,
+  maxImages: 20,
+  maxBatchBytes: 200 * 1024 ** 2,
+  maxPixels: 64e6,
+  maxDimension: 8192
+});
+var RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var CLEANUP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function assertAttachmentContent(value) {
+  if (!value || typeof value !== "object")
+    throw new AttachmentError("INVALID_REFERENCE", "Invalid attachment content");
+  const block = value;
+  if (block.type !== "image" && block.type !== "file")
+    throw new AttachmentError("INVALID_REFERENCE", "Invalid attachment kind");
+  assertFileRef(block.ref);
+  if (block.type === "image") {
+    const ref = block.ref;
+    if (!["image/png", "image/jpeg", "image/webp", "image/gif"].includes(String(ref.mimeType)) || !Number.isSafeInteger(ref.width) || Number(ref.width) < 1 || !Number.isSafeInteger(ref.height) || Number(ref.height) < 1 || typeof ref.animated !== "boolean") {
+      throw new AttachmentError("INVALID_REFERENCE", "Invalid image reference");
     }
-    return MESSAGE_OVERHEAD + message.content.reduce((total, block) => {
-      if (block.type === "text" || block.type === "reasoning") {
-        return total + BLOCK_OVERHEAD + this.estimateText(block.text);
-      }
-      return total + BLOCK_OVERHEAD + this.estimateText(`${block.call.name}${canonicalJson(block.call.arguments)}`);
-    }, 0);
-  }
-  isValidAnchor(input, anchor) {
-    return anchor.provider === input.provider && anchor.model === input.model && anchor.systemFingerprint === input.systemFingerprint && anchor.projectInstructionsFingerprint === input.projectInstructionsFingerprint && anchor.toolsFingerprint === input.toolsFingerprint && input.entries.some((entry) => entry.id === anchor.throughEntryId && entry.seq === anchor.throughSeq);
+    if (block.view !== void 0)
+      assertImageView(block.view);
   }
-};
-function normalizeProviderUsage(usage) {
-  return usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0) + usage.outputTokens;
-}
-function fingerprintContextPart(value) {
-  return createHash("sha256").update(canonicalJson(value)).digest("hex");
-}
-function canonicalJson(value) {
-  return JSON.stringify(sortStable(value));
 }
-function sortStable(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortStable);
-  }
-  if (value !== null && typeof value === "object") {
-    const record = value;
-    const sorted = {};
-    for (const key of Object.keys(record).sort()) {
-      sorted[key] = sortStable(record[key]);
-    }
-    return sorted;
+function assertFileRef(value) {
+  const ref = value;
+  if (!ref || typeof ref !== "object" || typeof ref.id !== "string" || !/^sha256:[a-f0-9]{64}$/.test(ref.id) || !Number.isSafeInteger(ref.bytes) || Number(ref.bytes) < 0 || typeof ref.name !== "string") {
+    throw new AttachmentError("INVALID_REFERENCE", "Invalid attachment reference");
   }
-  return value;
 }
-function messagesForEntries(entries) {
-  return entries.flatMap((entry) => {
-    if (entry.entryType === "tool_definitions" || entry.entryType === "tool_catalog" || entry.entryType === "skill_context")
-      return [entry.payload.message];
-    if (entry.entryType === "system_context") {
-      return [entry.payload.message];
-    }
-    if (entry.entryType === "project_instructions" || entry.entryType === "user_message" || entry.entryType === "reminder") {
-      return [entry.payload.message];
-    }
-    if (entry.entryType === "assistant_message") {
-      return [entry.payload.message];
-    }
-    if (entry.entryType === "tool_result") {
-      return [entry.payload.message];
+function assertImageView(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new AttachmentError("INVALID_REFERENCE", "Invalid image view");
+  const view = value;
+  if (view.fullResolution !== void 0 && typeof view.fullResolution !== "boolean")
+    throw new AttachmentError("INVALID_REFERENCE", "Invalid fullResolution");
+  if (view.region !== void 0) {
+    const r = view.region;
+    if (!r || typeof r !== "object" || !["x", "y", "width", "height"].every((k) => Number.isSafeInteger(r[k])) || Number(r.x) < 0 || Number(r.y) < 0 || Number(r.width) < 1 || Number(r.height) < 1) {
+      throw new AttachmentError("INVALID_REFERENCE", "Invalid crop region");
     }
-    return [];
-  });
+  }
 }
 
-// ../../packages/session/session-context/dist/context-usage.js
-var ContextUsage = class {
-  #tokens = 0;
-  constructor(entries = []) {
-    for (const entry of entries)
-      this.append(entry);
+// ../../packages/attachment/attachment/dist/attachment-store.js
+var AttachmentStore = class {
+};
+
+// ../../packages/session/session-store/dist/session-metadata.js
+function normalizeSessionTitle(input) {
+  if (new RegExp("\\p{Cc}|\\u2028|\\u2029", "u").test(input)) {
+    throw new Error("Session name must be a single line without control characters.");
   }
-  get tokens() {
-    return this.#tokens;
+  const title = input.trim();
+  if (title.length === 0) {
+    throw new Error("Session name must not be empty.");
   }
-  /** Histories are append-only and ordered; process each committed entry once. */
-  append(entry) {
-    if (entry.entryType === "compaction" || entry.entryType === "image_offload") {
-      this.#tokens = null;
-      return;
+  return title;
+}
+function sessionTitleAt(items, throughSeq = Infinity) {
+  let title = null;
+  for (const item of items) {
+    if (item.seq > throughSeq) {
+      break;
     }
-    if (entry.entryType === "assistant_message") {
-      const usage = validUsageTokens(entry.payload.usage);
-      if (usage !== null) {
-        this.#tokens = usage;
-        return;
+    if (item.kind === "record" && item.recordType === "session_name_changed") {
+      const value = item.payload["title"];
+      if (typeof value !== "string") {
+        throw new Error("Invalid session name record.");
       }
-    }
-    if (this.#tokens === null)
-      return;
-    if (entry.entryType === "user_message" || entry.entryType === "assistant_message" || entry.entryType === "tool_result" || entry.entryType === "reminder" || entry.entryType === "skill_context") {
-      this.#tokens += estimateMessage(entry.payload.message);
+      title = normalizeSessionTitle(value);
     }
   }
-};
-function validUsageTokens(usage) {
-  if (usage === void 0 || usage === null)
-    return null;
-  const fields = [
-    usage.inputTokens,
-    usage.outputTokens,
-    usage.cacheReadTokens ?? 0,
-    usage.cacheWriteTokens ?? 0
-  ];
-  if (!fields.every((value) => Number.isSafeInteger(value) && value >= 0))
-    return null;
-  const total = normalizeProviderUsage(usage);
-  return Number.isSafeInteger(total) && total > 0 ? total : null;
-}
-function estimateMessage(message) {
-  if (message.role === "system")
-    return 0;
-  if (message.role !== "assistant")
-    return Math.ceil(message.content.length / 4);
-  const chars = message.content.reduce((sum, block) => {
-    if (block.type === "tool-call") {
-      return sum + block.call.name.length + JSON.stringify(block.call.arguments).length;
-    }
-    return sum + block.text.length;
-  }, 0);
-  return Math.ceil(chars / 4);
+  return title;
 }
 
-// ../../packages/session/session-context/dist/conversation-history.js
-var ConversationHistory = class _ConversationHistory {
-  #journal;
-  #entries;
-  #staged = /* @__PURE__ */ new Map();
-  #contextUsage;
-  #listeners = /* @__PURE__ */ new Set();
-  constructor(entries, journal) {
-    this.#entries = [...entries];
-    this.#journal = journal;
-    this.#contextUsage = new ContextUsage(entries);
-  }
-  static fromReplay(replay, journal) {
-    const history = new _ConversationHistory(replay.items.filter((item) => item.kind === "entry"), journal);
-    for (const open6 of replay.openToolCalls) {
-      const entry = history.appendToolResults({
-        requestId: "recovered",
-        recovered: true,
-        messages: [{
-          role: "tool-result",
-          toolCallId: open6.toolCallId,
-          toolName: open6.toolName,
-          content: JSON.stringify({
-            ok: false,
-            status: "interrupted",
-            error: "Tool execution was interrupted before a result was recorded."
-          }),
-          isError: true
-        }]
-      })[0];
-      journal.appendRecord({
-        recordType: "error",
-        payload: {
-          type: "interrupted_tool_call",
-          toolCallId: open6.toolCallId,
-          repairedEntryId: entry?.id ?? null
-        }
-      });
-    }
-    return history;
-  }
-  appendSystemContext(input) {
-    return this.append({
-      entryType: "system_context",
-      payload: input
-    });
-  }
-  appendProjectInstructions(input) {
-    if (input.message.content === "") {
-      return null;
-    }
-    return this.append({
-      entryType: "project_instructions",
-      payload: {
-        message: input.message,
-        files: input.files,
-        supersedesEntryIds: input.supersedesEntryIds ?? []
-      }
-    });
-  }
-  appendUser(input) {
-    return this.append({
-      entryType: "user_message",
-      payload: input
-    });
-  }
-  stageUser(input) {
-    const token = randomUUID().replaceAll("-", "");
-    this.#staged.set(token, input);
-    return {
-      token,
-      message: input.message,
-      inputEventIds: input.inputEventIds
-    };
-  }
-  commitStagedUser(token) {
-    const staged = this.#staged.get(token);
-    if (staged === void 0) {
-      throw new Error(`unknown staged user message: ${token}`);
-    }
-    this.#staged.delete(token);
-    return this.appendUser(staged);
-  }
-  discardStagedUser(token) {
-    this.#staged.delete(token);
-  }
-  appendAssistant(input) {
-    return this.append({
-      entryType: "assistant_message",
-      payload: input
-    });
-  }
-  appendToolResults(input) {
-    return input.messages.map((message) => this.append({
-      entryType: "tool_result",
-      payload: {
-        message,
-        requestId: input.requestId,
-        recovered: input.recovered
-      }
-    }));
-  }
-  appendReminder(input) {
-    return this.append({
-      entryType: "reminder",
-      payload: input
-    });
-  }
-  appendToolDefinitions(input) {
-    return this.append({ entryType: "tool_definitions", payload: input });
-  }
-  appendToolCatalog(input) {
-    return this.append({ entryType: "tool_catalog", payload: input });
-  }
-  appendSkillContext(input) {
-    return this.append({ entryType: "skill_context", payload: input });
-  }
-  appendCompaction(input) {
-    return this.append({
-      entryType: "compaction",
-      payload: input
-    });
-  }
-  entries() {
-    return [...this.#entries];
-  }
-  offloadImages(keys2) {
-    if (keys2.length === 0)
-      return;
-    this.append({ entryType: "image_offload", payload: { keys: [...keys2] } });
-    this.#journal.flush();
-  }
-  get contextTokens() {
-    return this.#contextUsage.tokens;
-  }
-  onChange(listener) {
-    this.#listeners.add(listener);
-    return () => {
-      this.#listeners.delete(listener);
-    };
-  }
-  append(input) {
-    const entry = this.#journal.appendEntry(input);
-    this.#entries.push(entry);
-    this.#contextUsage.append(entry);
-    for (const listener of this.#listeners)
-      listener();
-    return entry;
-  }
-};
-
-// ../../packages/llm/llm/dist/model-contracts.js
-var ModelStreamError = class extends Error {
-  /** True when the stream had already delivered deltas before failing. */
-  hadDelta;
-  constructor(message, options = {}) {
-    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
-    this.name = "ModelStreamError";
-    this.hadDelta = options.hadDelta ?? false;
-  }
-};
-var ModelStreamCancelled = class extends ModelStreamError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ModelStreamCancelled";
-  }
-};
-var REASONING_EFFORTS = [
+// ../../packages/session/session-store/dist/schema.js
+var ENTRY_TYPES = /* @__PURE__ */ new Set([
+  "context_reset",
+  "image_offload",
+  "skill_context",
+  "tool_definitions",
+  "tool_catalog",
+  "system_context",
+  "project_instructions",
+  "user_message",
+  "assistant_message",
+  "tool_result",
+  "reminder",
+  "compaction"
+]);
+var RECORD_TYPES = /* @__PURE__ */ new Set([
+  "turn_started",
+  "turn_finished",
+  "model_request",
+  "model_response",
+  "tool_started",
+  "tool_finished",
+  "provider_changed",
+  "model_changed",
+  "reasoning_effort_changed",
+  "cwd_changed",
+  "usage",
+  "error",
+  "cancelled",
+  "queue_enqueued",
+  "queue_started",
+  "queue_finished",
+  "compaction_started",
+  "compaction_finished",
+  "session_name_changed",
+  "session_closed"
+]);
+var ORIGINS = /* @__PURE__ */ new Set(["new", "fork", "clone", "import"]);
+var REASONING_EFFORTS = /* @__PURE__ */ new Set([
   "off",
   "minimal",
   "low",
@@ -7711,1590 +7525,1812 @@ var REASONING_EFFORTS = [
   "high",
   "xhigh",
   "max"
-];
-function isReasoningEffort(value) {
-  return REASONING_EFFORTS.includes(value);
-}
-function clampReasoningEffort(supported, requested) {
-  const available = supported.length === 0 ? ["off"] : supported;
-  if (available.includes(requested)) {
-    return requested;
+]);
+var SessionSchemaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SessionSchemaError";
   }
-  const requestedIndex = REASONING_EFFORTS.indexOf(requested);
-  for (let index = requestedIndex; index < REASONING_EFFORTS.length; index += 1) {
-    const candidate = REASONING_EFFORTS[index];
-    if (available.includes(candidate)) {
-      return candidate;
-    }
+};
+function parseSessionHeader(value) {
+  const input = objectOf(value, "session header");
+  if (input["schemaVersion"] !== 1) {
+    throw new SessionSchemaError("unsupported session schema version");
   }
-  for (let index = requestedIndex - 1; index >= 0; index -= 1) {
-    const candidate = REASONING_EFFORTS[index];
-    if (available.includes(candidate)) {
-      return candidate;
-    }
+  if (input["type"] !== "session_header") {
+    throw new SessionSchemaError("invalid session header type");
   }
-  return "off";
-}
-function projectImageOffloads(message, keys2) {
-  if (message.role !== "user" && message.role !== "tool-result" || !message.attachments?.length)
-    return message;
-  const omittedImageIndexes = message.attachments.flatMap((block, index) => block.type === "image" && keys2.has(`${message.attachmentKey}:${index}`) ? [index] : []);
-  if (!omittedImageIndexes.length)
-    return message;
-  return { ...message, omittedImageIndexes };
-}
-var ModelError = class extends ModelStreamError {
-  kind;
-  constructor(message, options) {
-    super(message, { hadDelta: options.hadDelta ?? false, cause: options.cause });
-    this.name = "ModelError";
-    this.kind = options.kind;
+  requireString(input, "sessionId");
+  requireString(input, "createdAt");
+  requireString(input, "initialCwd");
+  requireString(input, "projectRoot");
+  requireString(input, "projectKey");
+  requireString(input, "appVersion");
+  requireString(input, "provider");
+  requireString(input, "model");
+  if (!REASONING_EFFORTS.has(stringValue(input, "reasoningEffort"))) {
+    throw new SessionSchemaError("invalid reasoning effort");
   }
-};
-var CONTEXT_OVERFLOW_PATTERN = /context length|maximum context|context window|too many tokens|reduce the length/i;
-var NETWORK_PATTERN = /fetch failed|network|econnreset|econnrefused|etimedout|socket hang up|timed out/i;
-function readStatus(record) {
-  let status = record["status_code"];
-  if (status === null || status === void 0) {
-    const response = record["response"];
-    if (response !== null && typeof response === "object") {
-      status = response["status_code"];
-    }
+  if (!ORIGINS.has(stringValue(input, "origin"))) {
+    throw new SessionSchemaError("invalid session origin");
   }
-  if (status === null || status === void 0) {
-    status = record["status"];
+  if (input["parentSessionId"] !== void 0) {
+    requireString(input, "parentSessionId");
   }
-  return status;
-}
-function classifyModelError(error) {
-  let current = error;
-  const seen = /* @__PURE__ */ new Set();
-  while (current !== null && current !== void 0 && (typeof current === "object" || typeof current === "function") && !seen.has(current)) {
-    seen.add(current);
-    const record = current;
-    const status = readStatus(record);
-    if (status === 401 || status === 403 || record["name"] === "AuthenticationError") {
-      return "authentication";
+  if (input["forkedFrom"] !== void 0) {
+    const forkedFrom = objectOf(input["forkedFrom"], "forkedFrom");
+    requireString(forkedFrom, "sessionId");
+    if (forkedFrom["seq"] !== void 0) {
+      requirePositiveInteger(forkedFrom, "seq");
     }
-    if (status === 429 || record["name"] === "RateLimitError") {
-      return "rate_limited";
+    if (forkedFrom["entryId"] !== void 0) {
+      requireString(forkedFrom, "entryId");
     }
-    const message = typeof record["message"] === "string" ? record["message"] : "";
-    if (status === 408 || status === 504 || record["name"] === "TimeoutError" || /\btimeout\b|\btimed out\b/i.test(message)) {
-      return "timeout";
-    }
-    if (CONTEXT_OVERFLOW_PATTERN.test(message)) {
-      return "context_overflow";
-    }
-    if (typeof status === "number" && status >= 500) {
-      return "server";
-    }
-    if (record["name"] === "APIConnectionError" || NETWORK_PATTERN.test(message)) {
-      return "retryable";
+    const mode = stringValue(forkedFrom, "mode");
+    if (mode !== "before" && mode !== "at" && mode !== "clone") {
+      throw new SessionSchemaError("invalid fork mode");
     }
-    current = record["cause"];
   }
-  return "retryable";
-}
-function modelErrorKind(error) {
-  return error instanceof ModelError ? error.kind : classifyModelError(error);
+  return input;
 }
-function portableModelMessage(message) {
-  if (message.role !== "assistant") {
-    return message;
+function parseSessionItem(value, expectedSessionId) {
+  const input = objectOf(value, "session item");
+  if (input["schemaVersion"] !== 1) {
+    throw new SessionSchemaError("unsupported session schema version");
   }
-  return {
-    role: "assistant",
-    provider: message.provider,
-    model: message.model,
-    content: message.content
-  };
-}
-
-// ../../packages/llm/llm/dist/model-runtime.js
-var ModelRuntime = class {
-  adapter;
-  retryDelaysMs;
-  sleep;
-  constructor(adapter, options = {}) {
-    this.adapter = adapter;
-    this.retryDelaysMs = validateRetryDelays(options.retryDelaysMs ?? [250, 1e3]);
-    this.sleep = options.sleep ?? defaultSleep;
+  const sessionId = requireString(input, "sessionId");
+  if (expectedSessionId !== void 0 && sessionId !== expectedSessionId) {
+    throw new SessionSchemaError("session id does not match header");
   }
-  async complete(request) {
-    if (request.cancelToken?.isCancelled()) {
-      throw new ModelStreamCancelled(request.cancelToken.reason || "cancelled");
+  requirePositiveInteger(input, "seq");
+  requireString(input, "id");
+  requireString(input, "timestamp");
+  const kind = stringValue(input, "kind");
+  if (kind === "entry") {
+    const entryType = stringValue(input, "entryType");
+    if (!ENTRY_TYPES.has(entryType)) {
+      throw new SessionSchemaError("invalid session entry type");
     }
-    const maxAttempts = validateMaxAttempts(request.maxAttempts ?? 3);
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-      const adapterRequest = {
-        ...request.imageContext === void 0 ? {} : { imageContext: request.imageContext },
-        provider: request.provider,
-        model: request.model,
-        ...request.baseUrl === void 0 ? {} : { baseUrl: request.baseUrl },
-        messages: request.messages,
-        tools: request.tools,
-        ...request.reasoningEffort === void 0 ? {} : { reasoningEffort: request.reasoningEffort },
-        ...request.temperature === void 0 ? {} : { temperature: request.temperature },
-        ...request.maxOutputTokens === void 0 ? {} : { maxOutputTokens: request.maxOutputTokens },
-        ...request.timeoutMs === void 0 ? {} : { timeoutMs: request.timeoutMs },
-        ...request.requestId === void 0 ? {} : { requestId: request.requestId },
-        ...request.cancelToken == null ? {} : { cancelToken: request.cancelToken },
-        ...request.isRequestActive == null ? {} : { isRequestActive: request.isRequestActive },
-        ...request.onDelta == null ? {} : { onEvent: (event) => forwardEvent(event, request.onDelta) },
-        ...request.onRequestOpened == null ? {} : { onRequestOpened: request.onRequestOpened }
-      };
+    const entryPayload = objectOf(input["payload"], "entry payload");
+    if (entryType === "context_reset") {
+      const boundary = entryPayload.resetThroughSeq;
+      if (typeof boundary !== "number" || !Number.isSafeInteger(boundary) || boundary < 0 || boundary >= input.seq || entryPayload.reason !== "user_clear" || Object.keys(entryPayload).some((key) => key !== "resetThroughSeq" && key !== "reason")) {
+        throw new SessionSchemaError("invalid legacy context reset");
+      }
+    }
+    if (entryType === "image_offload" && (!Array.isArray(entryPayload.keys) || entryPayload.keys.some((key) => typeof key !== "string"))) {
+      throw new SessionSchemaError("invalid image offload keys");
+    }
+    if (entryPayload.message !== void 0) {
+      const message = objectOf(entryPayload.message, "message");
+      if (message.attachments !== void 0) {
+        if (message.role !== "user" && message.role !== "tool-result" || !Array.isArray(message.attachments))
+          throw new SessionSchemaError("invalid message attachments");
+        for (const attachment of message.attachments)
+          assertAttachmentContent(attachment);
+        if (typeof message.attachmentKey !== "string" || !message.attachmentKey)
+          throw new SessionSchemaError("missing attachment occurrence key");
+      }
+    }
+    if (entryType === "skill_context") {
+      const payload = objectOf(input["payload"], "skill payload");
+      const message = objectOf(payload["message"], "skill message");
+      const metadata2 = objectOf(message["skillContext"], "skill metadata");
+      if (message["role"] !== "user" || typeof message["content"] !== "string" || !["catalog", "activation", "invalidation"].includes(String(metadata2["kind"])) || typeof metadata2["key"] !== "string")
+        throw new SessionSchemaError("invalid skill context");
+    }
+    if (entryType === "tool_definitions" || entryType === "tool_catalog") {
+      const payload = objectOf(input["payload"], "tool context payload");
+      const message = objectOf(payload["message"], "tool context message");
+      if (typeof message["content"] !== "string")
+        throw new SessionSchemaError("tool context content must be text");
+      if (entryType === "tool_definitions") {
+        if (message["role"] !== "system" || !Array.isArray(message["toolDefinitions"]))
+          throw new SessionSchemaError("invalid tool definitions message");
+        for (const raw of message["toolDefinitions"]) {
+          const definition = objectOf(raw, "loaded tool");
+          requireString(definition, "version");
+          const spec2 = objectOf(definition["spec"], "tool spec");
+          requireString(spec2, "name");
+          if (typeof spec2["description"] !== "string" || !Array.isArray(spec2["promptGuidelines"]) || spec2["promptGuidelines"].some((value2) => typeof value2 !== "string"))
+            throw new SessionSchemaError("invalid tool spec");
+          objectOf(spec2["parameters"], "tool parameters");
+          if (spec2["catalog"] !== void 0) {
+            const catalog = objectOf(spec2["catalog"], "tool catalog metadata");
+            for (const key of ["source", "originalName", "binding"])
+              requireString(catalog, key);
+            if (catalog["exposure"] !== "direct" && catalog["exposure"] !== "deferred")
+              throw new SessionSchemaError("invalid exposure");
+          }
+        }
+      } else {
+        if (message["role"] !== "user")
+          throw new SessionSchemaError("invalid catalog message role");
+        const catalog = objectOf(message["toolCatalog"], "tool catalog");
+        if (catalog["mode"] !== "full" && catalog["mode"] !== "deferred")
+          throw new SessionSchemaError("invalid tool mode");
+        for (const version of Object.values(objectOf(catalog["tools"], "tool versions")))
+          if (typeof version !== "string")
+            throw new SessionSchemaError("invalid tool version");
+      }
+    }
+    return input;
+  }
+  if (kind === "record") {
+    const recordType = stringValue(input, "recordType");
+    if (!RECORD_TYPES.has(recordType)) {
+      throw new SessionSchemaError("invalid session record type");
+    }
+    const payload = objectOf(input["payload"], "record payload");
+    if (recordType === "session_name_changed") {
+      const title = payload["title"];
+      if (typeof title !== "string") {
+        throw new SessionSchemaError("invalid session name record");
+      }
       try {
-        return await this.adapter.runAttempt(adapterRequest);
+        if (normalizeSessionTitle(title) !== title) {
+          throw new SessionSchemaError("session name must already be normalized");
+        }
       } catch (error) {
-        const normalized = normalizeRuntimeError(error, request.cancelToken ?? null);
-        if (!shouldRetry(normalized, attempt, maxAttempts)) {
-          throw normalized;
+        if (error instanceof SessionSchemaError) {
+          throw error;
         }
-        const delayMs = this.retryDelaysMs[Math.min(attempt - 1, this.retryDelaysMs.length - 1)];
-        request.onDelta?.("model_retry_scheduled", {
-          attempt: attempt + 1,
-          max_attempts: maxAttempts,
-          delay_ms: delayMs,
-          error_kind: normalized.kind
-        });
-        await this.sleep(delayMs, request.cancelToken ?? null);
+        throw new SessionSchemaError("invalid session name record");
       }
     }
-    throw new ModelError("model retry loop exhausted", { kind: "protocol" });
-  }
-};
-function forwardEvent(event, handler) {
-  if (event.type === "text-delta") {
-    handler?.("model_text_delta", { text: event.text });
-  } else if (event.type === "reasoning-delta") {
-    handler?.("model_reasoning_delta", { text: event.text });
-  } else if (event.type === "tool-call-delta") {
-    handler?.("model_tool_call_delta", {
-      index: event.index,
-      id: event.id,
-      name: event.name ?? null,
-      arguments: event.argumentsDelta
-    });
-  } else {
-    handler?.("model_response_validating", {});
+    return input;
   }
+  throw new SessionSchemaError("invalid session item kind");
 }
-function normalizeRuntimeError(error, cancelToken) {
-  if (error instanceof ModelStreamCancelled) {
-    return error;
-  }
-  if (cancelToken?.isCancelled()) {
-    return new ModelStreamCancelled(cancelToken.reason || "cancelled", { cause: error });
-  }
-  if (error instanceof ModelError) {
-    return error;
-  }
-  if (error instanceof ModelStreamError) {
-    return new ModelError(error.message, {
-      kind: modelErrorKind(error),
-      hadDelta: error.hadDelta,
-      cause: error
-    });
-  }
-  return new ModelError(errorMessage(error), {
-    kind: modelErrorKind(error),
-    cause: error
-  });
+function contextResetBoundary(entries) {
+  return entries.reduce((boundary, entry) => entry.entryType === "context_reset" ? Math.max(boundary, entry.payload.resetThroughSeq) : boundary, 0);
 }
-function shouldRetry(error, attempt, maxAttempts) {
-  if (!(error instanceof ModelError) || attempt >= maxAttempts) {
-    return false;
-  }
-  if (error.hadDelta) {
-    return false;
+function objectOf(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new SessionSchemaError(`${label} must be an object`);
   }
-  return error.kind === "timeout" || error.kind === "rate_limited" || error.kind === "server" || error.kind === "retryable";
+  return value;
 }
-function validateMaxAttempts(value) {
-  if (!Number.isInteger(value) || value < 1 || value > 10) {
-    throw new RangeError("maxAttempts must be an integer from 1 through 10");
+function requireString(input, key) {
+  const value = input[key];
+  if (typeof value !== "string" || value === "") {
+    throw new SessionSchemaError(`${key} must be a non-empty string`);
   }
   return value;
 }
-function validateRetryDelays(value) {
-  if (value.length === 0) {
-    throw new RangeError("retryDelaysMs must not be empty");
-  }
-  for (const delay2 of value) {
-    if (!Number.isInteger(delay2) || delay2 < 0 || !Number.isFinite(delay2)) {
-      throw new RangeError("retryDelaysMs must contain finite non-negative integers");
-    }
-  }
-  return [...value];
+function stringValue(input, key) {
+  const value = requireString(input, key);
+  return value;
 }
-async function defaultSleep(delayMs, cancelToken) {
-  if (cancelToken?.isCancelled()) {
-    throw new ModelStreamCancelled(cancelToken.reason || "cancelled");
-  }
-  const cancelled = await cancelToken?.wait(delayMs);
-  if (cancelled) {
-    throw new ModelStreamCancelled(cancelToken?.reason || "cancelled");
-  }
-  if (cancelToken === null) {
-    await new Promise((resolve15) => setTimeout(resolve15, delayMs));
+function requirePositiveInteger(input, key) {
+  const value = input[key];
+  if (!Number.isInteger(value) || typeof value !== "number" || value < 1) {
+    throw new SessionSchemaError(`${key} must be a positive integer`);
   }
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
+  return value;
 }
 
-// ../../packages/session/session-context/dist/context-builder.js
-var ContextBuildError = class extends Error {
-  entryId;
-  constructor(entryId, message) {
-    super(`${entryId}: ${message}`);
-    this.name = "ContextBuildError";
-    this.entryId = entryId;
+// ../../packages/session/session-store/dist/attachment-references.js
+import { lstatSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+// ../../packages/session/session-store/dist/session-reader.js
+import { readFileSync } from "node:fs";
+var SessionCorruptError = class extends Error {
+  path;
+  line;
+  constructor(path5, line2, message, options = {}) {
+    super(`${path5}:${line2}: ${message}`, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "SessionCorruptError";
+    this.path = path5;
+    this.line = line2;
   }
 };
-var ContextBuilder = class {
-  build(input) {
-    const sorted = [...input.entries].sort((left, right) => left.seq - right.seq);
-    const superseded = supersededEntryIds(sorted);
-    const activeCompaction = latestCompaction(sorted);
-    const selected = [];
-    const system = latestActive(sorted, "system_context", superseded);
-    if (system !== null) {
-      selected.push({ entryId: system.id, message: system.payload.message });
-    }
-    for (const entry of sorted) {
-      if (entry.entryType === "project_instructions" && !superseded.has(entry.id)) {
-        selected.push({ entryId: entry.id, message: entry.payload.message });
-      }
-    }
-    if (activeCompaction !== null) {
-      selected.push({
-        entryId: activeCompaction.id,
-        message: {
-          role: "user",
-          content: `<conversation_summary>
-${activeCompaction.payload.summary}
-</conversation_summary>`
-        }
-      });
-    }
-    for (const entry of conversationTail(sorted, activeCompaction)) {
-      const message = modelMessageForEntry(entry, input.currentProvider, input.currentModel);
-      if (message !== null) {
-        selected.push({ entryId: entry.id, message });
-      }
-    }
-    validateToolPairs(selected);
-    const offloaded = new Set(sorted.flatMap((entry) => entry.entryType === "image_offload" ? entry.payload.keys : []));
-    return {
-      messages: selected.map((item) => projectImageOffloads(item.message, offloaded)),
-      sourceEntryIds: selected.map((item) => item.entryId),
-      activeCompactionId: activeCompaction?.id ?? null
-    };
+function readSessionFile(path5) {
+  const text3 = readFileSync(path5, "utf8");
+  const endsWithNewline = text3.endsWith("\n");
+  const rawLines = text3.split("\n");
+  if (endsWithNewline) {
+    rawLines.pop();
   }
-};
-function supersededEntryIds(entries) {
-  const superseded = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    if (entry.entryType === "system_context" && entry.payload.supersedesEntryId !== void 0) {
-      superseded.add(entry.payload.supersedesEntryId);
+  if (rawLines.length === 0 || rawLines[0] === "") {
+    throw new SessionCorruptError(path5, 1, "missing session header");
+  }
+  const header = parseLine(path5, 1, rawLines[0], parseSessionHeader);
+  const items = [];
+  let ignoredTornTail = false;
+  let previousSeq = 0;
+  for (let index = 1; index < rawLines.length; index += 1) {
+    const lineNumber = index + 1;
+    const line2 = rawLines[index];
+    if (line2.trim() === "") {
+      continue;
     }
-    if (entry.entryType === "project_instructions") {
-      for (const id of entry.payload.supersedesEntryIds) {
-        superseded.add(id);
+    try {
+      const item = parseSessionItem(JSON.parse(line2), header.sessionId);
+      if (item.seq !== previousSeq + 1) {
+        throw new SessionSchemaError("session item seq must be contiguous");
       }
+      previousSeq = item.seq;
+      items.push(item);
+    } catch (error) {
+      if (!endsWithNewline && index === rawLines.length - 1) {
+        ignoredTornTail = true;
+        break;
+      }
+      throw corrupt(path5, lineNumber, error);
     }
   }
-  return superseded;
-}
-function latestActive(entries, entryType, superseded) {
-  for (let index = entries.length - 1; index >= 0; index -= 1) {
-    const entry = entries[index];
-    if (entry.entryType === entryType && !superseded.has(entry.id)) {
-      return entry;
-    }
-  }
-  return null;
+  return {
+    header,
+    items,
+    lastSeq: previousSeq,
+    ignoredTornTail,
+    openToolCalls: findOpenToolCalls(items)
+  };
 }
-function latestCompaction(entries) {
-  for (let index = entries.length - 1; index >= 0; index -= 1) {
-    const entry = entries[index];
-    if (entry.entryType === "compaction") {
-      return entry;
-    }
+function parseLine(path5, line2, raw, parse3) {
+  try {
+    return parse3(JSON.parse(raw));
+  } catch (error) {
+    throw corrupt(path5, line2, error);
   }
-  return null;
-}
-function conversationTail(entries, activeCompaction) {
-  const boundary = activeCompaction?.payload.retainedFromSeq ?? 1;
-  return entries.filter((entry) => entry.seq >= boundary && entry.entryType !== "system_context" && entry.entryType !== "project_instructions" && entry.entryType !== "compaction");
 }
-function modelMessageForEntry(entry, currentProvider, currentModel) {
-  if (entry.entryType === "tool_definitions" || entry.entryType === "tool_catalog" || entry.entryType === "skill_context")
-    return entry.payload.message;
-  if (entry.entryType === "user_message" || entry.entryType === "reminder") {
-    return entry.payload.message;
-  }
-  if (entry.entryType === "assistant_message") {
-    const message = entry.payload.message;
-    if (message.provider !== currentProvider || message.model !== currentModel) {
-      return portableModelMessage(message);
-    }
-    return message;
-  }
-  if (entry.entryType === "tool_result") {
-    return entry.payload.message;
+function corrupt(path5, line2, error) {
+  if (error instanceof SessionCorruptError) {
+    return error;
   }
-  return null;
+  return new SessionCorruptError(path5, line2, error instanceof Error ? error.message : "invalid session JSONL", { cause: error });
 }
-function validateToolPairs(selected) {
-  let expected = [];
-  let ownerEntryId = null;
-  for (const item of selected) {
-    if (item.message.role === "assistant") {
-      if (expected.length > 0) {
-        throw new ContextBuildError(ownerEntryId ?? item.entryId, "missing tool result");
+function findOpenToolCalls(items) {
+  const calls = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.kind === "entry" && item.entryType === "context_reset") {
+      for (const [id, call] of calls) {
+        if (call.seq <= item.payload.resetThroughSeq)
+          calls.delete(id);
       }
-      expected = item.message.content.filter((block) => block.type === "tool-call").map((block) => block.call.id);
-      ownerEntryId = expected.length === 0 ? null : item.entryId;
-      continue;
     }
-    if (item.message.role === "tool-result") {
-      const [next, ...rest] = expected;
-      if (next === void 0) {
-        throw new ContextBuildError(item.entryId, "orphan tool result");
-      }
-      if (item.message.toolCallId !== next) {
-        throw new ContextBuildError(item.entryId, "tool result order does not match tool call order");
+    if (item.kind === "entry" && item.entryType === "assistant_message") {
+      for (const block of item.payload.message.content) {
+        if (block.type === "tool-call") {
+          calls.set(block.call.id, {
+            entryId: item.id,
+            seq: item.seq,
+            toolCallId: block.call.id,
+            toolName: block.call.name
+          });
+        }
       }
-      expected = rest;
-      ownerEntryId = expected.length === 0 ? null : ownerEntryId;
-      continue;
     }
-    if (expected.length > 0) {
-      throw new ContextBuildError(ownerEntryId ?? item.entryId, "missing tool result");
+    if (item.kind === "entry" && item.entryType === "tool_result") {
+      calls.delete(item.payload.message.toolCallId);
     }
   }
-  if (expected.length > 0) {
-    throw new ContextBuildError(ownerEntryId ?? "unknown", "missing tool result");
-  }
+  return [...calls.values()];
 }
 
-// ../../packages/session/session-context/dist/summary-prompt.js
-var COMPACTION_SYSTEM_PROMPT = "Summarize the conversation for continuation. Preserve user goals, explicit constraints, completed work, modified files, architectural decisions, tool outcomes, failures, current TODOs, and concrete state needed to continue. Do not include credentials. Do not invent results.";
-
-// ../../packages/session/session-context/dist/compaction.js
-function selectCompactionPlan(input) {
-  const units = semanticUnits(input.entries);
-  const retained = [];
-  let tokens = 0;
-  for (let index = units.length - 1; index >= 0; index -= 1) {
-    const unit = units[index];
-    const unitTokens = input.estimator.estimateMessages(unit.messages);
-    retained.unshift(unit);
-    tokens += unitTokens;
-    if (tokens >= input.retainTokens) {
-      break;
+// ../../packages/session/session-store/dist/attachment-references.js
+function attachmentReferences(entries) {
+  const result = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.entryType === "compaction" || entry.entryType === "image_offload" || entry.entryType === "context_reset")
+      continue;
+    if (!("message" in entry.payload) || !entry.payload.message || typeof entry.payload.message !== "object")
+      throw new Error("Incomplete session message during attachment scan");
+    const message = entry.payload.message;
+    if (!("attachments" in message))
+      continue;
+    for (const block of message.attachments ?? []) {
+      assertAttachmentContent(block);
+      result.add(block.ref.id);
     }
   }
-  if (retained.length === 0 && units.length > 0) {
-    retained.push(units.at(-1));
-  }
-  const currentTurn = input.protectedFromSeq ?? [...input.entries].reverse().find((entry) => entry.entryType === "user_message")?.seq ?? 0;
-  const hasCurrentImages = input.entries.some((entry) => entry.seq >= currentTurn && "message" in entry.payload && "attachments" in entry.payload.message && entry.payload.message.attachments?.some((block) => block.type === "image"));
-  const retainedFirst = Math.min(retained[0]?.entries[0]?.seq ?? Number.MAX_SAFE_INTEGER, hasCurrentImages ? currentTurn : Number.MAX_SAFE_INTEGER);
-  const retainedUnits = units.filter((unit) => unit.entries[0].seq >= retainedFirst);
-  const summarized = units.filter((unit) => unit.entries[0].seq < retainedFirst);
-  return {
-    summarizedEntries: summarized.flatMap((unit) => unit.entries),
-    retainedEntries: retainedUnits.flatMap((unit) => unit.entries),
-    retainedFromSeq: retainedUnits[0]?.entries[0]?.seq ?? 1
+  return result;
+}
+function scanAttachmentReferences(sessionsRoot) {
+  const result = /* @__PURE__ */ new Set();
+  const visit = (directory) => {
+    for (const file of readdirSync(directory, { withFileTypes: true })) {
+      const path5 = join(directory, file.name);
+      if (file.isSymbolicLink())
+        throw new Error(`Cannot scan symbolic session path: ${path5}`);
+      if (file.isDirectory())
+        visit(path5);
+      else if (file.name.endsWith(".jsonl")) {
+        if (!lstatSync(path5).isFile())
+          throw new Error(`Invalid session file: ${path5}`);
+        const replay = readSessionFile(path5);
+        if (replay.ignoredTornTail)
+          throw new Error(`Incomplete session journal: ${path5}`);
+        for (const id of attachmentReferences(replay.items.filter((item) => item.kind === "entry")))
+          result.add(id);
+      }
+    }
   };
+  visit(sessionsRoot);
+  return result;
 }
-function serializeConversation(entries) {
-  const lines2 = ["<conversation>"];
-  for (const entry of entries) {
-    lines2.push(`<entry id="${entry.id}" seq="${entry.seq}" type="${entry.entryType}">`);
-    if (entry.entryType === "assistant_message") {
-      for (const block of entry.payload.message.content) {
-        if (block.type === "tool-call") {
-          lines2.push(`[assistant tool-call ${block.call.id} ${block.call.name}] ${JSON.stringify(block.call.arguments)}`);
-        } else {
-          lines2.push(`[assistant ${block.type}] ${block.text}`);
-        }
-      }
-    } else if (entry.entryType === "tool_result") {
-      lines2.push(`[tool-result ${entry.payload.message.toolCallId} ${entry.payload.message.toolName}] ${entry.payload.message.content}`);
-    } else if (entry.entryType === "tool_definitions") {
-      lines2.push(`[loaded tool definitions] ${(entry.payload.message.toolDefinitions ?? []).map((tool) => tool.spec.name).join(", ")}`);
-    } else if (entry.entryType === "user_message" || entry.entryType === "skill_context" || entry.entryType === "reminder" || entry.entryType === "project_instructions") {
-      lines2.push(`[${entry.payload.message.role}] ${entry.payload.message.content}`);
-    }
-    if ("message" in entry.payload && "attachments" in entry.payload.message) {
-      for (const block of entry.payload.message.attachments ?? [])
-        lines2.push(`[attachment metadata only; not visual interpretation] ${JSON.stringify(block)}`);
-    }
-    lines2.push("</entry>");
+
+// ../../packages/session/session-store/dist/session-paths.js
+import { createHash } from "node:crypto";
+import { mkdirSync, realpathSync } from "node:fs";
+import { basename, join as join2, resolve } from "node:path";
+function canonicalProjectRoot(projectRoot) {
+  try {
+    return realpathSync.native(projectRoot);
+  } catch {
+    return resolve(projectRoot);
   }
-  lines2.push("</conversation>");
-  return lines2.join("\n");
 }
-function semanticUnits(entries) {
-  const units = [];
-  const groupedDefinitions = /* @__PURE__ */ new Set();
-  for (let index = 0; index < entries.length; index += 1) {
-    const entry = entries[index];
-    if (groupedDefinitions.has(entry.id))
-      continue;
-    if (entry.entryType === "image_offload" || entry.entryType === "system_context" || entry.entryType === "project_instructions" || entry.entryType === "compaction") {
-      continue;
-    }
-    if (entry.entryType === "assistant_message") {
-      const toolCallIds = entry.payload.message.content.filter((block) => block.type === "tool-call").map((block) => block.call.id);
-      if (toolCallIds.length > 0) {
-        const grouped = [entry];
-        for (const id of toolCallIds) {
-          const resultIndex = entries.findIndex((candidate) => candidate.entryType === "tool_result" && candidate.payload.message.toolCallId === id);
-          if (resultIndex < 0) {
-            throw new Error(`cannot compact incomplete tool call: ${id}`);
-          }
-          grouped.push(entries[resultIndex]);
-        }
-        const lastResultIndex = entries.findIndex((candidate) => candidate.id === grouped.at(-1).id);
-        const definitions = entries[lastResultIndex + 1];
-        if (definitions?.entryType === "tool_definitions") {
-          grouped.push(definitions);
-          groupedDefinitions.add(definitions.id);
-        }
-        units.push({ entries: grouped, messages: grouped.map(messageForEntry) });
-        continue;
-      }
-    }
-    if (entry.entryType === "tool_result") {
-      continue;
-    }
-    units.push({ entries: [entry], messages: [messageForEntry(entry)] });
-  }
-  return units;
+function projectKeyForRoot(projectRoot) {
+  const canonical = canonicalProjectRoot(projectRoot);
+  const digest = createHash("sha256").update(canonical).digest("hex").slice(0, 12);
+  return `${sanitizePathPart(basename(canonical) || "project")}-${digest}`;
 }
-function messageForEntry(entry) {
-  if (entry.entryType === "tool_definitions" || entry.entryType === "tool_catalog" || entry.entryType === "skill_context")
-    return entry.payload.message;
-  if (entry.entryType === "assistant_message") {
-    return entry.payload.message;
-  }
-  if (entry.entryType === "tool_result") {
-    return entry.payload.message;
-  }
-  if (entry.entryType === "user_message" || entry.entryType === "reminder" || entry.entryType === "project_instructions") {
-    return entry.payload.message;
-  }
-  throw new Error(`entry has no model message: ${entry.entryType}`);
+function ensureSessionDirectory(sessionsRoot, projectKey) {
+  const directory = join2(sessionsRoot, projectKey);
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  return directory;
+}
+function sessionPathForHeader(sessionsRoot, projectKey, createdAt, sessionId) {
+  const safeCreatedAt = createdAt.replaceAll(":", "").replaceAll(".", "");
+  return join2(ensureSessionDirectory(sessionsRoot, projectKey), `${safeCreatedAt}_${sessionId}.jsonl`);
+}
+function sanitizePathPart(value) {
+  const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized || "project";
 }
 
-// ../../packages/session/session-context/dist/context-governor.js
-var ContextBudgetError = class extends Error {
+// ../../packages/session/session-store/dist/session-journal.js
+import { closeSync, existsSync, fsyncSync, openSync, readFileSync as readFileSync2, unlinkSync, writeSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+var SessionJournalLockError = class extends Error {
   constructor(message) {
     super(message);
-    this.name = "ContextBudgetError";
+    this.name = "SessionJournalLockError";
   }
 };
-var ContextGovernor = class {
-  #builder;
-  #estimator;
-  #summarize;
-  #appendCompaction;
-  constructor(options) {
-    this.#builder = options.builder ?? new ContextBuilder();
-    this.#estimator = options.estimator ?? new DefaultTokenEstimator();
-    this.#summarize = options.summarize;
-    this.#appendCompaction = options.appendCompaction;
+var FileSessionJournal = class {
+  attachments;
+  header;
+  path;
+  #fd;
+  #lockPath;
+  #nextSeq;
+  #closed = false;
+  constructor(input) {
+    this.attachments = input.attachments;
+    this.header = input.header;
+    this.path = input.path;
+    this.#nextSeq = input.nextSeq;
+    this.#fd = input.fd;
+    this.#lockPath = `${input.path}.lock`;
   }
-  async prepare(input) {
-    let built = this.#builder.build(input);
-    let tokens = this.measure(input, built);
-    const calculated = calculateModelBudget({ budget: input.budget, policy: input.policy });
-    if (!input.policy.auto || tokens <= calculated.autoTrigger) {
-      if (tokens > calculated.hardInputLimit)
-        throw new ContextBudgetError("context exceeds hard input limit");
-      return { built, messages: built.messages, compacted: false, tokens };
+  get nextSeq() {
+    return this.#nextSeq;
+  }
+  appendEntry(input) {
+    const item = this.makeBase(input);
+    const entry = {
+      ...item,
+      kind: "entry",
+      entryType: input.entryType,
+      payload: input.payload
+    };
+    const message = "message" in entry.payload ? entry.payload.message : void 0;
+    const attachments = message && "attachments" in message ? message.attachments : void 0;
+    if (attachments?.length) {
+      for (const attachment of attachments)
+        assertAttachmentContent(attachment);
+      if (!this.attachments)
+        throw new Error("Attachment persistence requires an attachment store");
+      if (!("attachmentKey" in message) || !message.attachmentKey)
+        throw new Error("Attachment message requires an occurrence key");
+      this.attachments.commit(attachments.map((block) => block.ref), () => {
+        this.writeItem(entry);
+        this.flush();
+      });
+    } else
+      this.writeItem(entry);
+    if (entry.entryType === "compaction") {
+      this.flush();
     }
-    const result = await this.compact({ ...input, trigger: "automatic" });
-    const entries = [...input.entries, result.entry];
-    built = this.#builder.build({ ...input, entries });
-    tokens = this.measure({ ...input, entries }, built);
-    if (tokens > calculated.hardInputLimit) {
-      throw new ContextBudgetError("context remains over hard input limit after compaction");
+    return entry;
+  }
+  appendRecord(input) {
+    const record = {
+      ...this.makeBase(input),
+      kind: "record",
+      recordType: input.recordType,
+      payload: input.payload ?? {}
+    };
+    this.writeItem(record);
+    if (record.recordType === "turn_finished" || record.recordType === "compaction_finished" || record.recordType === "session_closed") {
+      this.flush();
     }
-    return { built, messages: built.messages, compacted: true, tokens };
+    return record;
   }
-  async compact(input) {
-    const calculated = calculateModelBudget({ budget: input.budget, policy: input.policy });
-    const plan = selectCompactionPlan({
-      protectedFromSeq: input.protectedFromSeq,
-      entries: input.entries,
-      // A search preflight reserves the pending call/result/definition unit.
-      // Keep the latest completed unit and summarize older units to make room.
-      retainTokens: input.reserveTokens === void 0 ? calculated.retainTokens : 1,
-      estimator: this.#estimator
-    });
-    if (input.trigger === "manual" && plan.summarizedEntries.length === 0) {
-      throw new Error("No messages to compact in current history.");
+  flush() {
+    if (!this.#closed) {
+      fsyncSync(this.#fd);
     }
-    const summarizedFromSeq = plan.summarizedEntries[0]?.seq ?? 1;
-    const summarizedThroughSeq = plan.summarizedEntries.at(-1)?.seq ?? Math.max(0, summarizedFromSeq - 1);
-    const activeCompaction = [...input.entries].reverse().find((entry) => entry.entryType === "compaction");
-    const messagesBefore = this.#builder.build(input).messages;
-    const tokensBefore = this.#estimator.estimateMessages(messagesBefore) + this.#estimator.estimateTools(input.projectTools?.(messagesBefore) ?? input.tools);
-    const summary = plan.summarizedEntries.length === 0 ? {
-      summary: "No prior conversation needed compaction.",
-      inputTokens: 0,
-      outputTokens: 0
-    } : await this.#summarize({
-      serialized: serializeConversation(plan.summarizedEntries),
-      maxSummaryTokens: input.policy.maxSummaryTokens
-    });
-    const payload = {
-      summary: summary.summary,
-      summarizedFromSeq,
-      summarizedThroughSeq,
-      retainedFromSeq: plan.retainedFromSeq,
-      ...activeCompaction === void 0 ? {} : { supersedesCompactionId: activeCompaction.id },
-      tokensBefore,
-      retainedTokens: calculated.retainTokens,
-      summaryInputTokens: summary.inputTokens,
-      summaryOutputTokens: summary.outputTokens,
-      provider: input.currentProvider,
-      model: input.currentModel,
-      trigger: input.trigger
-    };
-    return { entry: this.#appendCompaction(payload) };
   }
-  async completeWithOverflowRecovery(input, send) {
-    let prepared = await this.prepare(input);
-    try {
-      return await send(prepared);
-    } catch (error) {
-      if (!(error instanceof ModelError) || modelErrorKind(error) !== "context_overflow" || error.hadDelta) {
-        throw error;
-      }
+  close() {
+    if (this.#closed) {
+      return;
+    }
+    this.flush();
+    closeSync(this.#fd);
+    this.#closed = true;
+    if (existsSync(this.#lockPath)) {
+      unlinkSync(this.#lockPath);
     }
-    const compaction = await this.compact({ ...input, trigger: "provider_overflow" });
-    prepared = await this.prepare({ ...input, entries: [...input.entries, compaction.entry] });
-    return await send(prepared);
   }
-  measure(input, built) {
-    const tools = input.projectTools?.(built.messages) ?? input.tools;
-    return this.#estimator.measure({
-      messages: built.messages,
-      tools,
-      entries: input.entries,
-      anchor: input.anchor ?? null,
-      provider: input.currentProvider,
-      model: input.currentModel,
-      systemFingerprint: fingerprintContextPart(built.messages.find((message) => message.role === "system") ?? null),
-      projectInstructionsFingerprint: fingerprintContextPart(built.messages.filter((message, index) => index > 0 && message.role === "user")),
-      toolsFingerprint: fingerprintContextPart(tools)
-    }).totalTokens + (input.reserveTokens ?? 0);
+  makeBase(input) {
+    return {
+      schemaVersion: 1,
+      sessionId: this.header.sessionId,
+      seq: this.#nextSeq,
+      id: randomUUID().replaceAll("-", ""),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...input.taskId === void 0 ? {} : { taskId: input.taskId },
+      ...input.turnId === void 0 ? {} : { turnId: input.turnId },
+      ...input.copiedFrom === void 0 ? {} : { copiedFrom: input.copiedFrom }
+    };
+  }
+  writeItem(item) {
+    if (this.#closed) {
+      throw new Error("session journal is closed");
+    }
+    writeLine(this.#fd, item);
+    this.#nextSeq += 1;
   }
 };
-function calculateModelBudget(input) {
-  const hardInputLimit = input.budget.contextWindow - input.budget.maxOutputTokens;
-  const safetyTokens = Math.ceil(input.budget.contextWindow * input.policy.safetyRatio);
-  const autoTrigger = Math.min(Math.floor(input.budget.contextWindow * input.policy.thresholdRatio), hardInputLimit - safetyTokens);
-  const retainTokens = input.policy.retainTokens ?? Math.floor(input.budget.contextWindow * input.policy.retainRatio);
-  return { hardInputLimit, safetyTokens, autoTrigger, retainTokens };
+function createSessionJournal(options) {
+  const header = options.header ?? makeHeader(options);
+  const path5 = options.path ?? sessionPathForHeader(options.sessionsRoot, header.projectKey, header.createdAt, header.sessionId);
+  const existing = existsSync(path5);
+  const lockPath = `${path5}.lock`;
+  acquireLock(lockPath, header.sessionId);
+  try {
+    const fd = openSync(path5, existing ? "a" : "wx", 384);
+    if (!existing) {
+      writeLine(fd, header);
+      fsyncSync(fd);
+      return new FileSessionJournal({ header, path: path5, nextSeq: 1, fd, attachments: options.attachments });
+    }
+    const replay = readSessionFile(path5);
+    return new FileSessionJournal({
+      header: replay.header,
+      path: path5,
+      nextSeq: replay.lastSeq + 1,
+      fd,
+      attachments: options.attachments
+    });
+  } catch (error) {
+    releaseLock(lockPath);
+    throw error;
+  }
+}
+function makeHeader(options) {
+  const projectRoot = canonicalProjectRoot(required(options.projectRoot, "projectRoot"));
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    schemaVersion: 1,
+    type: "session_header",
+    sessionId: randomUUID().replaceAll("-", ""),
+    createdAt,
+    initialCwd: required(options.initialCwd, "initialCwd"),
+    projectRoot,
+    projectKey: projectKeyForRoot(projectRoot),
+    appVersion: required(options.appVersion, "appVersion"),
+    provider: required(options.provider, "provider"),
+    model: required(options.model, "model"),
+    reasoningEffort: options.reasoningEffort ?? "high",
+    origin: options.origin ?? "new",
+    ...options.parentSessionId === void 0 ? {} : { parentSessionId: options.parentSessionId },
+    ...options.forkedFrom === void 0 ? {} : { forkedFrom: options.forkedFrom }
+  };
+}
+function acquireLock(path5, sessionId) {
+  try {
+    const fd = openSync(path5, "wx", 384);
+    writeLine(fd, { pid: process.pid, sessionId, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    closeSync(fd);
+  } catch (error) {
+    if (!isLiveLock(path5)) {
+      releaseLock(path5);
+      const fd = openSync(path5, "wx", 384);
+      writeLine(fd, { pid: process.pid, sessionId, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      closeSync(fd);
+      return;
+    }
+    throw new SessionJournalLockError(`session journal is locked: ${path5}`);
+  }
+}
+function isLiveLock(path5) {
+  if (!existsSync(path5)) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync2(path5, "utf8"));
+    if (typeof parsed.pid !== "number" || !Number.isInteger(parsed.pid)) {
+      return false;
+    }
+    process.kill(parsed.pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code === "EPERM";
+  }
+}
+function releaseLock(path5) {
+  if (existsSync(path5)) {
+    unlinkSync(path5);
+  }
+}
+function writeLine(fd, value) {
+  writeSync(fd, `${JSON.stringify(value)}
+`);
+}
+function required(value, label) {
+  if (value === void 0 || value === "") {
+    throw new Error(`${label} is required`);
+  }
+  return value;
 }
 
-// ../../packages/attachment/attachment/dist/errors.js
-var AttachmentError = class extends Error {
-  code;
-  constructor(code, message, options) {
-    super(message, options);
-    this.name = "AttachmentError";
-    this.code = code;
+// ../../packages/session/session-store/dist/session-manager.js
+import { existsSync as existsSync2, readdirSync as readdirSync2, statSync } from "node:fs";
+import { join as join3 } from "node:path";
+
+// ../../packages/session/session-store/dist/session-tree.js
+function buildSessionTree(sessions) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    nodes.set(session.sessionId, { session, children: [] });
   }
-};
+  const roots = [];
+  for (const session of sessions) {
+    const node = nodes.get(session.sessionId);
+    const parentId = session.parentSessionId;
+    const parent = parentId === void 0 ? void 0 : nodes.get(parentId);
+    if (parent === void 0) {
+      roots.push(node);
+    } else {
+      parent.children.push(node);
+    }
+  }
+  const sortNodes = (items) => items.sort((left, right) => right.session.createdAt.localeCompare(left.session.createdAt)).map((item) => ({
+    session: item.session,
+    children: sortNodes(item.children)
+  }));
+  return sortNodes(roots);
+}
 
-// ../../packages/attachment/attachment/dist/types.js
-var DEFAULT_IMAGE_LIMITS = Object.freeze({
-  maxBytes: 20 * 1024 ** 2,
-  maxImages: 20,
-  maxBatchBytes: 200 * 1024 ** 2,
-  maxPixels: 64e6,
-  maxDimension: 8192
-});
-var RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
-var CLEANUP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-function assertAttachmentContent(value) {
-  if (!value || typeof value !== "object")
-    throw new AttachmentError("INVALID_REFERENCE", "Invalid attachment content");
-  const block = value;
-  if (block.type !== "image" && block.type !== "file")
-    throw new AttachmentError("INVALID_REFERENCE", "Invalid attachment kind");
-  assertFileRef(block.ref);
-  if (block.type === "image") {
-    const ref = block.ref;
-    if (!["image/png", "image/jpeg", "image/webp", "image/gif"].includes(String(ref.mimeType)) || !Number.isSafeInteger(ref.width) || Number(ref.width) < 1 || !Number.isSafeInteger(ref.height) || Number(ref.height) < 1 || typeof ref.animated !== "boolean") {
-      throw new AttachmentError("INVALID_REFERENCE", "Invalid image reference");
+// ../../packages/session/session-store/dist/session-manager.js
+var SessionManager = class {
+  #attachments;
+  #sessionsRoot;
+  #appVersion;
+  constructor(options) {
+    this.#attachments = options.attachments;
+    this.#sessionsRoot = options.sessionsRoot;
+    this.#appVersion = options.appVersion;
+  }
+  create(options) {
+    const journal = createSessionJournal({
+      attachments: this.#attachments,
+      sessionsRoot: this.#sessionsRoot,
+      projectRoot: options.projectRoot,
+      initialCwd: options.initialCwd,
+      appVersion: this.#appVersion,
+      provider: options.provider,
+      model: options.model,
+      reasoningEffort: options.reasoningEffort,
+      origin: "new"
+    });
+    return {
+      header: journal.header,
+      journal,
+      replay: {
+        header: journal.header,
+        items: [],
+        lastSeq: 0,
+        ignoredTornTail: false,
+        openToolCalls: []
+      }
+    };
+  }
+  open(sessionId) {
+    const summary = this.list().find((item) => item.sessionId === sessionId);
+    if (summary === void 0 || summary.status === "corrupt") {
+      throw new Error(`unknown session: ${sessionId}`);
     }
-    if (block.view !== void 0)
-      assertImageView(block.view);
+    const replay = readSessionFile(summary.path);
+    const journal = createSessionJournal({
+      attachments: this.#attachments,
+      sessionsRoot: this.#sessionsRoot,
+      header: replay.header,
+      path: summary.path
+    });
+    return { header: replay.header, journal, replay };
+  }
+  continueLatest(projectRoot) {
+    const latest = this.list(projectRoot).find((item) => item.status !== "corrupt");
+    return latest === void 0 ? null : this.open(latest.sessionId);
+  }
+  list(projectRoot) {
+    const canonical = projectRoot === void 0 ? null : canonicalProjectRoot(projectRoot);
+    return this.sessionPaths().map((path5) => summaryForPath(path5)).filter((summary) => canonical === null || summary.projectRoot === canonical).sort((left, right) => {
+      const updated = right.updatedAt.localeCompare(left.updatedAt);
+      return updated === 0 ? right.createdAt.localeCompare(left.createdAt) : updated;
+    });
+  }
+  tree(projectRoot) {
+    return buildSessionTree(this.list(projectRoot).filter((item) => item.status !== "corrupt"));
+  }
+  fork(options) {
+    const parent = this.parentReplay(options.parentSessionId);
+    const target = parent.items.find((item) => item.kind === "entry" && item.entryType === "user_message" && item.id === options.entryId);
+    if (target === void 0) {
+      throw new Error("fork target must be a user_message entry");
+    }
+    const child = createSessionJournal({
+      attachments: this.#attachments,
+      sessionsRoot: this.#sessionsRoot,
+      projectRoot: parent.header.projectRoot,
+      initialCwd: parent.header.initialCwd,
+      appVersion: this.#appVersion,
+      provider: parent.header.provider,
+      model: parent.header.model,
+      reasoningEffort: parent.header.reasoningEffort,
+      origin: "fork",
+      parentSessionId: parent.header.sessionId,
+      forkedFrom: {
+        sessionId: parent.header.sessionId,
+        seq: target.seq,
+        entryId: target.id,
+        mode: options.mode
+      }
+    });
+    const throughSeq = options.mode === "before" ? target.seq - 1 : target.seq;
+    copyEntries(child, parent.items.filter(isEntry).filter((item) => item.seq <= throughSeq));
+    appendTitleSnapshot(child, sessionTitleAt(parent.items, throughSeq));
+    child.close();
+    return {
+      sessionId: child.header.sessionId,
+      path: child.path,
+      editorText: options.mode === "before" ? target.payload.message.skillContext?.input ?? target.payload.message.content : ""
+    };
+  }
+  clone(options) {
+    const parent = this.parentReplay(options.parentSessionId);
+    const lastEntry = [...parent.items].reverse().find((item) => item.kind === "entry");
+    const child = createSessionJournal({
+      attachments: this.#attachments,
+      sessionsRoot: this.#sessionsRoot,
+      projectRoot: parent.header.projectRoot,
+      initialCwd: parent.header.initialCwd,
+      appVersion: this.#appVersion,
+      provider: parent.header.provider,
+      model: parent.header.model,
+      reasoningEffort: parent.header.reasoningEffort,
+      origin: "clone",
+      parentSessionId: parent.header.sessionId,
+      forkedFrom: {
+        sessionId: parent.header.sessionId,
+        ...lastEntry === void 0 ? {} : { seq: lastEntry.seq, entryId: lastEntry.id },
+        mode: "clone"
+      }
+    });
+    copyEntries(child, parent.items.filter(isEntry));
+    appendTitleSnapshot(child, sessionTitleAt(parent.items));
+    child.close();
+    return { sessionId: child.header.sessionId, path: child.path };
+  }
+  parentReplay(sessionId) {
+    const summary = this.list().find((item) => item.sessionId === sessionId);
+    if (summary === void 0 || summary.status === "corrupt") {
+      throw new Error(`unknown session: ${sessionId}`);
+    }
+    return readSessionFile(summary.path);
+  }
+  sessionPaths() {
+    if (!existsSync2(this.#sessionsRoot)) {
+      return [];
+    }
+    const paths = [];
+    const visit = (directory) => {
+      for (const entry of readdirSync2(directory)) {
+        const absolute = join3(directory, entry);
+        const stat6 = statSync(absolute);
+        if (stat6.isDirectory()) {
+          visit(absolute);
+        } else if (absolute.endsWith(".jsonl")) {
+          paths.push(absolute);
+        }
+      }
+    };
+    visit(this.#sessionsRoot);
+    return paths.sort();
+  }
+};
+function summaryForPath(path5) {
+  try {
+    const replay = readSessionFile(path5);
+    const last = replay.items.at(-1);
+    const title = sessionTitleAt(replay.items);
+    return {
+      sessionId: replay.header.sessionId,
+      path: path5,
+      createdAt: replay.header.createdAt,
+      updatedAt: last?.timestamp ?? replay.header.createdAt,
+      projectRoot: replay.header.projectRoot,
+      cwd: cwdFrom(replay),
+      provider: replay.header.provider,
+      model: replay.header.model,
+      origin: replay.header.origin,
+      ...replay.header.parentSessionId === void 0 ? {} : { parentSessionId: replay.header.parentSessionId },
+      ...title === null ? {} : { title },
+      lastUserText: lastUserText(replay.items),
+      status: last?.kind === "record" && last.recordType === "session_closed" ? "closed" : existsSync2(`${path5}.lock`) ? "open" : "interrupted"
+    };
+  } catch {
+    return {
+      sessionId: path5,
+      path: path5,
+      createdAt: "",
+      updatedAt: "",
+      projectRoot: "",
+      cwd: "",
+      provider: "",
+      model: "",
+      origin: "import",
+      lastUserText: "",
+      status: "corrupt"
+    };
   }
 }
-function assertFileRef(value) {
-  const ref = value;
-  if (!ref || typeof ref !== "object" || typeof ref.id !== "string" || !/^sha256:[a-f0-9]{64}$/.test(ref.id) || !Number.isSafeInteger(ref.bytes) || Number(ref.bytes) < 0 || typeof ref.name !== "string") {
-    throw new AttachmentError("INVALID_REFERENCE", "Invalid attachment reference");
+function cwdFrom(replay) {
+  for (const item of [...replay.items].reverse()) {
+    if (item.kind === "entry" && item.entryType === "system_context") {
+      return item.payload.cwd;
+    }
   }
+  return replay.header.initialCwd;
 }
-function assertImageView(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    throw new AttachmentError("INVALID_REFERENCE", "Invalid image view");
-  const view = value;
-  if (view.fullResolution !== void 0 && typeof view.fullResolution !== "boolean")
-    throw new AttachmentError("INVALID_REFERENCE", "Invalid fullResolution");
-  if (view.region !== void 0) {
-    const r = view.region;
-    if (!r || typeof r !== "object" || !["x", "y", "width", "height"].every((k) => Number.isSafeInteger(r[k])) || Number(r.x) < 0 || Number(r.y) < 0 || Number(r.width) < 1 || Number(r.height) < 1) {
-      throw new AttachmentError("INVALID_REFERENCE", "Invalid crop region");
+function lastUserText(items) {
+  for (const item of [...items].reverse()) {
+    if (item.kind === "entry" && item.entryType === "user_message") {
+      return item.payload.message.skillContext?.input ?? item.payload.message.content;
     }
   }
+  return "";
 }
-
-// ../../packages/attachment/attachment/dist/attachment-store.js
-var AttachmentStore = class {
-};
-
-// ../../packages/session/session-store/dist/session-metadata.js
-function normalizeSessionTitle(input) {
-  if (new RegExp("\\p{Cc}|\\u2028|\\u2029", "u").test(input)) {
-    throw new Error("Session name must be a single line without control characters.");
+function copyEntries(journal, entries) {
+  for (const entry of entries) {
+    const input = {
+      entryType: entry.entryType,
+      payload: entry.entryType === "context_reset" ? { ...entry.payload, resetThroughSeq: entries.filter((candidate) => candidate.seq <= entry.payload.resetThroughSeq).length } : entry.payload,
+      ...entry.taskId === void 0 ? {} : { taskId: entry.taskId },
+      ...entry.turnId === void 0 ? {} : { turnId: entry.turnId },
+      copiedFrom: {
+        sessionId: entry.sessionId,
+        itemId: entry.id,
+        seq: entry.seq
+      }
+    };
+    journal.appendEntry(input);
   }
-  const title = input.trim();
-  if (title.length === 0) {
-    throw new Error("Session name must not be empty.");
+}
+function isEntry(item) {
+  return item.kind === "entry";
+}
+function appendTitleSnapshot(journal, title) {
+  if (title !== null) {
+    journal.appendRecord({
+      recordType: "session_name_changed",
+      payload: { title }
+    });
   }
-  return title;
 }
-function sessionTitleAt(items, throughSeq = Infinity) {
-  let title = null;
-  for (const item of items) {
-    if (item.seq > throughSeq) {
-      break;
-    }
-    if (item.kind === "record" && item.recordType === "session_name_changed") {
-      const value = item.payload["title"];
-      if (typeof value !== "string") {
-        throw new Error("Invalid session name record.");
+
+// ../../packages/session/session-store/dist/transcript-projector.js
+function projectTranscript(entries) {
+  const items = [];
+  const skillNames = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.entryType === "user_message") {
+      items.push({ kind: "user", text: entry.payload.message.skillContext?.input ?? entry.payload.message.content });
+    } else if (entry.entryType === "assistant_message") {
+      for (const block of entry.payload.message.content) {
+        if (block.type !== "tool-call" || block.call.name !== "skill")
+          continue;
+        try {
+          const args = JSON.parse(block.call.arguments);
+          if (args && typeof args === "object" && "name" in args && typeof args.name === "string") {
+            skillNames.set(block.call.id, args.name);
+          }
+        } catch {
+        }
       }
-      title = normalizeSessionTitle(value);
+      const text3 = entry.payload.message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+      const reasoning = entry.payload.message.content.filter((block) => block.type === "reasoning").map((block) => block.text).join("");
+      items.push({
+        kind: "assistant",
+        text: text3,
+        ...reasoning === "" ? {} : { reasoning }
+      });
+    } else if (entry.entryType === "tool_result") {
+      const message = entry.payload.message;
+      let result = message.content;
+      if (message.toolName === "skill") {
+        try {
+          const value = JSON.parse(result);
+          if (value && typeof value === "object") {
+            if ("content" in value && typeof value.content === "string")
+              result = value.content;
+            else if ("error" in value && typeof value.error === "string")
+              result = value.error;
+          }
+        } catch {
+        }
+      }
+      items.push({
+        kind: "tool",
+        callId: entry.payload.message.toolCallId,
+        name: entry.payload.message.toolName,
+        subject: message.toolName === "skill" ? skillNames.get(message.toolCallId) ?? "" : message.toolCallId,
+        result,
+        isError: entry.payload.message.isError
+      });
+    } else if (entry.entryType === "context_reset") {
+      items.push({ kind: "notice", text: "Conversation context was cleared.", tone: "info" });
+    } else if (entry.entryType === "compaction") {
+      items.push({
+        kind: "notice",
+        text: "Conversation context was compacted.",
+        tone: "info"
+      });
     }
   }
-  return title;
+  return items;
 }
 
-// ../../packages/session/session-store/dist/schema.js
-var ENTRY_TYPES = /* @__PURE__ */ new Set([
-  "image_offload",
-  "skill_context",
-  "tool_definitions",
-  "tool_catalog",
-  "system_context",
-  "project_instructions",
-  "user_message",
-  "assistant_message",
-  "tool_result",
-  "reminder",
-  "compaction"
-]);
-var RECORD_TYPES = /* @__PURE__ */ new Set([
-  "turn_started",
-  "turn_finished",
-  "model_request",
-  "model_response",
-  "tool_started",
-  "tool_finished",
-  "provider_changed",
-  "model_changed",
-  "reasoning_effort_changed",
-  "cwd_changed",
-  "usage",
-  "error",
-  "cancelled",
-  "queue_enqueued",
-  "queue_started",
-  "queue_finished",
-  "compaction_started",
-  "compaction_finished",
-  "session_name_changed",
-  "session_closed"
-]);
-var ORIGINS = /* @__PURE__ */ new Set(["new", "fork", "clone", "import"]);
-var REASONING_EFFORTS2 = /* @__PURE__ */ new Set([
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-]);
-var SessionSchemaError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SessionSchemaError";
+// ../../packages/session/session-context/dist/token-estimator.js
+var TEXT_BYTES_PER_TOKEN = 4;
+var BLOCK_OVERHEAD = 4;
+var MESSAGE_OVERHEAD = 4;
+var DefaultTokenEstimator = class {
+  estimateMessages(messages) {
+    return messages.reduce((total, message) => total + this.estimateMessage(message), 0);
   }
-};
-function parseSessionHeader(value) {
-  const input = objectOf(value, "session header");
-  if (input["schemaVersion"] !== 1) {
-    throw new SessionSchemaError("unsupported session schema version");
+  estimateTools(tools) {
+    if (tools.length === 0) {
+      return 0;
+    }
+    return this.estimateText(canonicalJson(tools.map(({ name, description, parameters }) => ({ name, description, parameters })))) + BLOCK_OVERHEAD;
   }
-  if (input["type"] !== "session_header") {
-    throw new SessionSchemaError("invalid session header type");
+  estimateText(text3) {
+    return Math.ceil(Buffer.byteLength(text3, "utf8") / TEXT_BYTES_PER_TOKEN);
   }
-  requireString(input, "sessionId");
-  requireString(input, "createdAt");
-  requireString(input, "initialCwd");
-  requireString(input, "projectRoot");
-  requireString(input, "projectKey");
-  requireString(input, "appVersion");
-  requireString(input, "provider");
-  requireString(input, "model");
-  if (!REASONING_EFFORTS2.has(stringValue(input, "reasoningEffort"))) {
-    throw new SessionSchemaError("invalid reasoning effort");
+  measure(input) {
+    const anchor = input.anchor ?? null;
+    if (anchor !== null && this.isValidAnchor(input, anchor)) {
+      const trailingEntries = input.entries.filter((entry) => entry.seq > anchor.throughSeq);
+      const trailingTokens = this.estimateMessages(messagesForEntries(trailingEntries));
+      return {
+        totalTokens: anchor.contextTokens + trailingTokens,
+        anchorTokens: anchor.contextTokens,
+        trailingTokens,
+        source: "provider_usage"
+      };
+    }
+    const totalTokens = this.estimateMessages(input.messages) + this.estimateTools(input.tools);
+    return {
+      totalTokens,
+      anchorTokens: 0,
+      trailingTokens: totalTokens,
+      source: "estimated"
+    };
   }
-  if (!ORIGINS.has(stringValue(input, "origin"))) {
-    throw new SessionSchemaError("invalid session origin");
+  estimateMessage(message) {
+    const attachmentTokens = message.role === "user" || message.role === "tool-result" ? (message.attachments ?? []).reduce((sum, block, index) => sum + (block.type === "image" && !message.omittedImageIndexes?.includes(index) ? 85 + 170 * Math.ceil(block.ref.width / 512) * Math.ceil(block.ref.height / 512) : 32), 0) : 0;
+    if (message.role === "system" && message.toolDefinitions !== void 0)
+      return 0;
+    if (message.role === "system" || message.role === "user") {
+      return MESSAGE_OVERHEAD + BLOCK_OVERHEAD + this.estimateText(message.content) + attachmentTokens;
+    }
+    if (message.role === "tool-result") {
+      return MESSAGE_OVERHEAD + BLOCK_OVERHEAD + this.estimateText(message.content) + attachmentTokens;
+    }
+    return MESSAGE_OVERHEAD + message.content.reduce((total, block) => {
+      if (block.type === "text" || block.type === "reasoning") {
+        return total + BLOCK_OVERHEAD + this.estimateText(block.text);
+      }
+      return total + BLOCK_OVERHEAD + this.estimateText(`${block.call.name}${canonicalJson(block.call.arguments)}`);
+    }, 0);
+  }
+  isValidAnchor(input, anchor) {
+    return anchor.provider === input.provider && anchor.throughSeq > contextResetBoundary(input.entries) && anchor.model === input.model && anchor.systemFingerprint === input.systemFingerprint && anchor.projectInstructionsFingerprint === input.projectInstructionsFingerprint && anchor.toolsFingerprint === input.toolsFingerprint && input.entries.some((entry) => entry.id === anchor.throughEntryId && entry.seq === anchor.throughSeq);
+  }
+};
+function normalizeProviderUsage(usage) {
+  return usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0) + usage.outputTokens;
+}
+function fingerprintContextPart(value) {
+  return createHash2("sha256").update(canonicalJson(value)).digest("hex");
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortStable(value));
+}
+function sortStable(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortStable);
   }
-  if (input["parentSessionId"] !== void 0) {
-    requireString(input, "parentSessionId");
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    const sorted = {};
+    for (const key of Object.keys(record).sort()) {
+      sorted[key] = sortStable(record[key]);
+    }
+    return sorted;
   }
-  if (input["forkedFrom"] !== void 0) {
-    const forkedFrom = objectOf(input["forkedFrom"], "forkedFrom");
-    requireString(forkedFrom, "sessionId");
-    if (forkedFrom["seq"] !== void 0) {
-      requirePositiveInteger(forkedFrom, "seq");
+  return value;
+}
+function messagesForEntries(entries) {
+  return entries.flatMap((entry) => {
+    if (entry.entryType === "tool_definitions" || entry.entryType === "tool_catalog" || entry.entryType === "skill_context")
+      return [entry.payload.message];
+    if (entry.entryType === "system_context") {
+      return [entry.payload.message];
     }
-    if (forkedFrom["entryId"] !== void 0) {
-      requireString(forkedFrom, "entryId");
+    if (entry.entryType === "project_instructions" || entry.entryType === "user_message" || entry.entryType === "reminder") {
+      return [entry.payload.message];
     }
-    const mode = stringValue(forkedFrom, "mode");
-    if (mode !== "before" && mode !== "at" && mode !== "clone") {
-      throw new SessionSchemaError("invalid fork mode");
+    if (entry.entryType === "assistant_message") {
+      return [entry.payload.message];
     }
-  }
-  return input;
+    if (entry.entryType === "tool_result") {
+      return [entry.payload.message];
+    }
+    return [];
+  });
 }
-function parseSessionItem(value, expectedSessionId) {
-  const input = objectOf(value, "session item");
-  if (input["schemaVersion"] !== 1) {
-    throw new SessionSchemaError("unsupported session schema version");
+
+// ../../packages/session/session-context/dist/context-usage.js
+var ContextUsage = class {
+  #tokens = 0;
+  constructor(entries = []) {
+    for (const entry of entries)
+      this.append(entry);
   }
-  const sessionId = requireString(input, "sessionId");
-  if (expectedSessionId !== void 0 && sessionId !== expectedSessionId) {
-    throw new SessionSchemaError("session id does not match header");
+  get tokens() {
+    return this.#tokens;
   }
-  requirePositiveInteger(input, "seq");
-  requireString(input, "id");
-  requireString(input, "timestamp");
-  const kind = stringValue(input, "kind");
-  if (kind === "entry") {
-    const entryType = stringValue(input, "entryType");
-    if (!ENTRY_TYPES.has(entryType)) {
-      throw new SessionSchemaError("invalid session entry type");
-    }
-    const entryPayload = objectOf(input["payload"], "entry payload");
-    if (entryType === "image_offload" && (!Array.isArray(entryPayload.keys) || entryPayload.keys.some((key) => typeof key !== "string"))) {
-      throw new SessionSchemaError("invalid image offload keys");
+  /** Histories are append-only and ordered; process each committed entry once. */
+  append(entry) {
+    if (entry.entryType === "context_reset" || entry.entryType === "compaction" || entry.entryType === "image_offload") {
+      this.#tokens = null;
+      return;
     }
-    if (entryPayload.message !== void 0) {
-      const message = objectOf(entryPayload.message, "message");
-      if (message.attachments !== void 0) {
-        if (message.role !== "user" && message.role !== "tool-result" || !Array.isArray(message.attachments))
-          throw new SessionSchemaError("invalid message attachments");
-        for (const attachment of message.attachments)
-          assertAttachmentContent(attachment);
-        if (typeof message.attachmentKey !== "string" || !message.attachmentKey)
-          throw new SessionSchemaError("missing attachment occurrence key");
+    if (entry.entryType === "assistant_message") {
+      const usage = validUsageTokens(entry.payload.usage);
+      if (usage !== null) {
+        this.#tokens = usage;
+        return;
       }
     }
-    if (entryType === "skill_context") {
-      const payload = objectOf(input["payload"], "skill payload");
-      const message = objectOf(payload["message"], "skill message");
-      const metadata2 = objectOf(message["skillContext"], "skill metadata");
-      if (message["role"] !== "user" || typeof message["content"] !== "string" || !["catalog", "activation", "invalidation"].includes(String(metadata2["kind"])) || typeof metadata2["key"] !== "string")
-        throw new SessionSchemaError("invalid skill context");
+    if (this.#tokens === null)
+      return;
+    if (entry.entryType === "user_message" || entry.entryType === "assistant_message" || entry.entryType === "tool_result" || entry.entryType === "reminder" || entry.entryType === "skill_context") {
+      this.#tokens += estimateMessage(entry.payload.message);
     }
-    if (entryType === "tool_definitions" || entryType === "tool_catalog") {
-      const payload = objectOf(input["payload"], "tool context payload");
-      const message = objectOf(payload["message"], "tool context message");
-      if (typeof message["content"] !== "string")
-        throw new SessionSchemaError("tool context content must be text");
-      if (entryType === "tool_definitions") {
-        if (message["role"] !== "system" || !Array.isArray(message["toolDefinitions"]))
-          throw new SessionSchemaError("invalid tool definitions message");
-        for (const raw of message["toolDefinitions"]) {
-          const definition = objectOf(raw, "loaded tool");
-          requireString(definition, "version");
-          const spec2 = objectOf(definition["spec"], "tool spec");
-          requireString(spec2, "name");
-          if (typeof spec2["description"] !== "string" || !Array.isArray(spec2["promptGuidelines"]) || spec2["promptGuidelines"].some((value2) => typeof value2 !== "string"))
-            throw new SessionSchemaError("invalid tool spec");
-          objectOf(spec2["parameters"], "tool parameters");
-          if (spec2["catalog"] !== void 0) {
-            const catalog = objectOf(spec2["catalog"], "tool catalog metadata");
-            for (const key of ["source", "originalName", "binding"])
-              requireString(catalog, key);
-            if (catalog["exposure"] !== "direct" && catalog["exposure"] !== "deferred")
-              throw new SessionSchemaError("invalid exposure");
-          }
+  }
+};
+function validUsageTokens(usage) {
+  if (usage === void 0 || usage === null)
+    return null;
+  const fields = [
+    usage.inputTokens,
+    usage.outputTokens,
+    usage.cacheReadTokens ?? 0,
+    usage.cacheWriteTokens ?? 0
+  ];
+  if (!fields.every((value) => Number.isSafeInteger(value) && value >= 0))
+    return null;
+  const total = normalizeProviderUsage(usage);
+  return Number.isSafeInteger(total) && total > 0 ? total : null;
+}
+function estimateMessage(message) {
+  if (message.role === "system")
+    return 0;
+  if (message.role !== "assistant")
+    return Math.ceil(message.content.length / 4);
+  const chars = message.content.reduce((sum, block) => {
+    if (block.type === "tool-call") {
+      return sum + block.call.name.length + JSON.stringify(block.call.arguments).length;
+    }
+    return sum + block.text.length;
+  }, 0);
+  return Math.ceil(chars / 4);
+}
+
+// ../../packages/session/session-context/dist/conversation-history.js
+var ConversationHistory = class _ConversationHistory {
+  #journal;
+  #entries;
+  #staged = /* @__PURE__ */ new Map();
+  #contextUsage;
+  #listeners = /* @__PURE__ */ new Set();
+  constructor(entries, journal) {
+    this.#entries = [...entries];
+    this.#journal = journal;
+    this.#contextUsage = new ContextUsage(entries);
+  }
+  static fromReplay(replay, journal) {
+    const history = new _ConversationHistory(replay.items.filter((item) => item.kind === "entry"), journal);
+    for (const open6 of replay.openToolCalls) {
+      const entry = history.appendToolResults({
+        requestId: "recovered",
+        recovered: true,
+        messages: [{
+          role: "tool-result",
+          toolCallId: open6.toolCallId,
+          toolName: open6.toolName,
+          content: JSON.stringify({
+            ok: false,
+            status: "interrupted",
+            error: "Tool execution was interrupted before a result was recorded."
+          }),
+          isError: true
+        }]
+      })[0];
+      journal.appendRecord({
+        recordType: "error",
+        payload: {
+          type: "interrupted_tool_call",
+          toolCallId: open6.toolCallId,
+          repairedEntryId: entry?.id ?? null
         }
-      } else {
-        if (message["role"] !== "user")
-          throw new SessionSchemaError("invalid catalog message role");
-        const catalog = objectOf(message["toolCatalog"], "tool catalog");
-        if (catalog["mode"] !== "full" && catalog["mode"] !== "deferred")
-          throw new SessionSchemaError("invalid tool mode");
-        for (const version of Object.values(objectOf(catalog["tools"], "tool versions")))
-          if (typeof version !== "string")
-            throw new SessionSchemaError("invalid tool version");
-      }
+      });
     }
-    return input;
+    return history;
   }
-  if (kind === "record") {
-    const recordType = stringValue(input, "recordType");
-    if (!RECORD_TYPES.has(recordType)) {
-      throw new SessionSchemaError("invalid session record type");
+  appendSystemContext(input) {
+    return this.append({
+      entryType: "system_context",
+      payload: input
+    });
+  }
+  appendProjectInstructions(input) {
+    if (input.message.content === "") {
+      return null;
     }
-    const payload = objectOf(input["payload"], "record payload");
-    if (recordType === "session_name_changed") {
-      const title = payload["title"];
-      if (typeof title !== "string") {
-        throw new SessionSchemaError("invalid session name record");
-      }
-      try {
-        if (normalizeSessionTitle(title) !== title) {
-          throw new SessionSchemaError("session name must already be normalized");
-        }
-      } catch (error) {
-        if (error instanceof SessionSchemaError) {
-          throw error;
-        }
-        throw new SessionSchemaError("invalid session name record");
+    return this.append({
+      entryType: "project_instructions",
+      payload: {
+        message: input.message,
+        files: input.files,
+        supersedesEntryIds: input.supersedesEntryIds ?? []
       }
+    });
+  }
+  appendUser(input) {
+    return this.append({
+      entryType: "user_message",
+      payload: input
+    });
+  }
+  stageUser(input) {
+    const token = randomUUID2().replaceAll("-", "");
+    this.#staged.set(token, input);
+    return {
+      token,
+      message: input.message,
+      inputEventIds: input.inputEventIds
+    };
+  }
+  commitStagedUser(token) {
+    const staged = this.#staged.get(token);
+    if (staged === void 0) {
+      throw new Error(`unknown staged user message: ${token}`);
     }
-    return input;
+    this.#staged.delete(token);
+    return this.appendUser(staged);
   }
-  throw new SessionSchemaError("invalid session item kind");
-}
-function objectOf(value, label) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new SessionSchemaError(`${label} must be an object`);
+  discardStagedUser(token) {
+    this.#staged.delete(token);
   }
-  return value;
-}
-function requireString(input, key) {
-  const value = input[key];
-  if (typeof value !== "string" || value === "") {
-    throw new SessionSchemaError(`${key} must be a non-empty string`);
+  appendAssistant(input) {
+    return this.append({
+      entryType: "assistant_message",
+      payload: input
+    });
   }
-  return value;
-}
-function stringValue(input, key) {
-  const value = requireString(input, key);
-  return value;
-}
-function requirePositiveInteger(input, key) {
-  const value = input[key];
-  if (!Number.isInteger(value) || typeof value !== "number" || value < 1) {
-    throw new SessionSchemaError(`${key} must be a positive integer`);
+  appendToolResults(input) {
+    return input.messages.map((message) => this.append({
+      entryType: "tool_result",
+      payload: {
+        message,
+        requestId: input.requestId,
+        recovered: input.recovered
+      }
+    }));
   }
-  return value;
-}
-
-// ../../packages/session/session-store/dist/attachment-references.js
-import { lstatSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-
-// ../../packages/session/session-store/dist/session-reader.js
-import { readFileSync } from "node:fs";
-var SessionCorruptError = class extends Error {
-  path;
-  line;
-  constructor(path5, line2, message, options = {}) {
-    super(`${path5}:${line2}: ${message}`, options.cause === void 0 ? void 0 : { cause: options.cause });
-    this.name = "SessionCorruptError";
-    this.path = path5;
-    this.line = line2;
+  appendReminder(input) {
+    return this.append({
+      entryType: "reminder",
+      payload: input
+    });
   }
-};
-function readSessionFile(path5) {
-  const text3 = readFileSync(path5, "utf8");
-  const endsWithNewline = text3.endsWith("\n");
-  const rawLines = text3.split("\n");
-  if (endsWithNewline) {
-    rawLines.pop();
+  appendToolDefinitions(input) {
+    return this.append({ entryType: "tool_definitions", payload: input });
   }
-  if (rawLines.length === 0 || rawLines[0] === "") {
-    throw new SessionCorruptError(path5, 1, "missing session header");
+  appendToolCatalog(input) {
+    return this.append({ entryType: "tool_catalog", payload: input });
   }
-  const header = parseLine(path5, 1, rawLines[0], parseSessionHeader);
-  const items = [];
-  let ignoredTornTail = false;
-  let previousSeq = 0;
-  for (let index = 1; index < rawLines.length; index += 1) {
-    const lineNumber = index + 1;
-    const line2 = rawLines[index];
-    if (line2.trim() === "") {
-      continue;
-    }
-    try {
-      const item = parseSessionItem(JSON.parse(line2), header.sessionId);
-      if (item.seq !== previousSeq + 1) {
-        throw new SessionSchemaError("session item seq must be contiguous");
-      }
-      previousSeq = item.seq;
-      items.push(item);
-    } catch (error) {
-      if (!endsWithNewline && index === rawLines.length - 1) {
-        ignoredTornTail = true;
-        break;
-      }
-      throw corrupt(path5, lineNumber, error);
-    }
+  appendSkillContext(input) {
+    return this.append({ entryType: "skill_context", payload: input });
   }
-  return {
-    header,
-    items,
-    lastSeq: previousSeq,
-    ignoredTornTail,
-    openToolCalls: findOpenToolCalls(items)
-  };
-}
-function parseLine(path5, line2, raw, parse3) {
-  try {
-    return parse3(JSON.parse(raw));
-  } catch (error) {
-    throw corrupt(path5, line2, error);
+  appendCompaction(input) {
+    return this.append({
+      entryType: "compaction",
+      payload: input
+    });
   }
-}
-function corrupt(path5, line2, error) {
-  if (error instanceof SessionCorruptError) {
-    return error;
+  entries() {
+    return [...this.#entries];
   }
-  return new SessionCorruptError(path5, line2, error instanceof Error ? error.message : "invalid session JSONL", { cause: error });
-}
-function findOpenToolCalls(items) {
-  const calls = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    if (item.kind === "entry" && item.entryType === "assistant_message") {
-      for (const block of item.payload.message.content) {
-        if (block.type === "tool-call") {
-          calls.set(block.call.id, {
-            entryId: item.id,
-            seq: item.seq,
-            toolCallId: block.call.id,
-            toolName: block.call.name
-          });
-        }
-      }
-    }
-    if (item.kind === "entry" && item.entryType === "tool_result") {
-      calls.delete(item.payload.message.toolCallId);
-    }
+  offloadImages(keys2) {
+    if (keys2.length === 0)
+      return;
+    this.append({ entryType: "image_offload", payload: { keys: [...keys2] } });
+    this.#journal.flush();
   }
-  return [...calls.values()];
-}
-
-// ../../packages/session/session-store/dist/attachment-references.js
-function attachmentReferences(entries) {
-  const result = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    if (entry.entryType === "compaction" || entry.entryType === "image_offload")
-      continue;
-    if (!("message" in entry.payload) || !entry.payload.message || typeof entry.payload.message !== "object")
-      throw new Error("Incomplete session message during attachment scan");
-    const message = entry.payload.message;
-    if (!("attachments" in message))
-      continue;
-    for (const block of message.attachments ?? []) {
-      assertAttachmentContent(block);
-      result.add(block.ref.id);
-    }
+  get contextTokens() {
+    return this.#contextUsage.tokens;
   }
-  return result;
-}
-function scanAttachmentReferences(sessionsRoot) {
-  const result = /* @__PURE__ */ new Set();
-  const visit = (directory) => {
-    for (const file of readdirSync(directory, { withFileTypes: true })) {
-      const path5 = join(directory, file.name);
-      if (file.isSymbolicLink())
-        throw new Error(`Cannot scan symbolic session path: ${path5}`);
-      if (file.isDirectory())
-        visit(path5);
-      else if (file.name.endsWith(".jsonl")) {
-        if (!lstatSync(path5).isFile())
-          throw new Error(`Invalid session file: ${path5}`);
-        const replay = readSessionFile(path5);
-        if (replay.ignoredTornTail)
-          throw new Error(`Incomplete session journal: ${path5}`);
-        for (const id of attachmentReferences(replay.items.filter((item) => item.kind === "entry")))
-          result.add(id);
-      }
-    }
-  };
-  visit(sessionsRoot);
-  return result;
-}
-
-// ../../packages/session/session-store/dist/session-paths.js
-import { createHash as createHash2 } from "node:crypto";
-import { mkdirSync, realpathSync } from "node:fs";
-import { basename, join as join2, resolve } from "node:path";
-function canonicalProjectRoot(projectRoot) {
-  try {
-    return realpathSync.native(projectRoot);
-  } catch {
-    return resolve(projectRoot);
+  onChange(listener) {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
   }
-}
-function projectKeyForRoot(projectRoot) {
-  const canonical = canonicalProjectRoot(projectRoot);
-  const digest = createHash2("sha256").update(canonical).digest("hex").slice(0, 12);
-  return `${sanitizePathPart(basename(canonical) || "project")}-${digest}`;
-}
-function ensureSessionDirectory(sessionsRoot, projectKey) {
-  const directory = join2(sessionsRoot, projectKey);
-  mkdirSync(directory, { recursive: true, mode: 448 });
-  return directory;
-}
-function sessionPathForHeader(sessionsRoot, projectKey, createdAt, sessionId) {
-  const safeCreatedAt = createdAt.replaceAll(":", "").replaceAll(".", "");
-  return join2(ensureSessionDirectory(sessionsRoot, projectKey), `${safeCreatedAt}_${sessionId}.jsonl`);
-}
-function sanitizePathPart(value) {
-  const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-  return sanitized || "project";
-}
-
-// ../../packages/session/session-store/dist/session-journal.js
-import { closeSync, existsSync, fsyncSync, openSync, readFileSync as readFileSync2, unlinkSync, writeSync } from "node:fs";
-import { randomUUID as randomUUID2 } from "node:crypto";
-var SessionJournalLockError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SessionJournalLockError";
+  append(input) {
+    const entry = this.#journal.appendEntry(input);
+    this.#entries.push(entry);
+    this.#contextUsage.append(entry);
+    for (const listener of this.#listeners)
+      listener();
+    return entry;
   }
 };
-var FileSessionJournal = class {
-  attachments;
-  header;
-  path;
-  #fd;
-  #lockPath;
-  #nextSeq;
-  #closed = false;
-  constructor(input) {
-    this.attachments = input.attachments;
-    this.header = input.header;
-    this.path = input.path;
-    this.#nextSeq = input.nextSeq;
-    this.#fd = input.fd;
-    this.#lockPath = `${input.path}.lock`;
+
+// ../../packages/llm/llm/dist/model-contracts.js
+var ModelStreamError = class extends Error {
+  /** True when the stream had already delivered deltas before failing. */
+  hadDelta;
+  constructor(message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "ModelStreamError";
+    this.hadDelta = options.hadDelta ?? false;
   }
-  get nextSeq() {
-    return this.#nextSeq;
+};
+var ModelStreamCancelled = class extends ModelStreamError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ModelStreamCancelled";
   }
-  appendEntry(input) {
-    const item = this.makeBase(input);
-    const entry = {
-      ...item,
-      kind: "entry",
-      entryType: input.entryType,
-      payload: input.payload
-    };
-    const message = "message" in entry.payload ? entry.payload.message : void 0;
-    const attachments = message && "attachments" in message ? message.attachments : void 0;
-    if (attachments?.length) {
-      for (const attachment of attachments)
-        assertAttachmentContent(attachment);
-      if (!this.attachments)
-        throw new Error("Attachment persistence requires an attachment store");
-      if (!("attachmentKey" in message) || !message.attachmentKey)
-        throw new Error("Attachment message requires an occurrence key");
-      this.attachments.commit(attachments.map((block) => block.ref), () => {
-        this.writeItem(entry);
-        this.flush();
-      });
-    } else
-      this.writeItem(entry);
-    if (entry.entryType === "compaction") {
-      this.flush();
-    }
-    return entry;
+};
+var REASONING_EFFORTS2 = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function isReasoningEffort(value) {
+  return REASONING_EFFORTS2.includes(value);
+}
+function clampReasoningEffort(supported, requested) {
+  const available = supported.length === 0 ? ["off"] : supported;
+  if (available.includes(requested)) {
+    return requested;
   }
-  appendRecord(input) {
-    const record = {
-      ...this.makeBase(input),
-      kind: "record",
-      recordType: input.recordType,
-      payload: input.payload ?? {}
-    };
-    this.writeItem(record);
-    if (record.recordType === "turn_finished" || record.recordType === "compaction_finished" || record.recordType === "session_closed") {
-      this.flush();
+  const requestedIndex = REASONING_EFFORTS2.indexOf(requested);
+  for (let index = requestedIndex; index < REASONING_EFFORTS2.length; index += 1) {
+    const candidate = REASONING_EFFORTS2[index];
+    if (available.includes(candidate)) {
+      return candidate;
     }
-    return record;
   }
-  flush() {
-    if (!this.#closed) {
-      fsyncSync(this.#fd);
+  for (let index = requestedIndex - 1; index >= 0; index -= 1) {
+    const candidate = REASONING_EFFORTS2[index];
+    if (available.includes(candidate)) {
+      return candidate;
     }
   }
-  close() {
-    if (this.#closed) {
-      return;
-    }
-    this.flush();
-    closeSync(this.#fd);
-    this.#closed = true;
-    if (existsSync(this.#lockPath)) {
-      unlinkSync(this.#lockPath);
+  return "off";
+}
+function projectImageOffloads(message, keys2) {
+  if (message.role !== "user" && message.role !== "tool-result" || !message.attachments?.length)
+    return message;
+  const omittedImageIndexes = message.attachments.flatMap((block, index) => block.type === "image" && keys2.has(`${message.attachmentKey}:${index}`) ? [index] : []);
+  if (!omittedImageIndexes.length)
+    return message;
+  return { ...message, omittedImageIndexes };
+}
+var ModelError = class extends ModelStreamError {
+  kind;
+  constructor(message, options) {
+    super(message, { hadDelta: options.hadDelta ?? false, cause: options.cause });
+    this.name = "ModelError";
+    this.kind = options.kind;
+  }
+};
+var CONTEXT_OVERFLOW_PATTERN = /context length|maximum context|context window|too many tokens|reduce the length/i;
+var NETWORK_PATTERN = /fetch failed|network|econnreset|econnrefused|etimedout|socket hang up|timed out/i;
+function readStatus(record) {
+  let status = record["status_code"];
+  if (status === null || status === void 0) {
+    const response = record["response"];
+    if (response !== null && typeof response === "object") {
+      status = response["status_code"];
     }
   }
-  makeBase(input) {
-    return {
-      schemaVersion: 1,
-      sessionId: this.header.sessionId,
-      seq: this.#nextSeq,
-      id: randomUUID2().replaceAll("-", ""),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      ...input.taskId === void 0 ? {} : { taskId: input.taskId },
-      ...input.turnId === void 0 ? {} : { turnId: input.turnId },
-      ...input.copiedFrom === void 0 ? {} : { copiedFrom: input.copiedFrom }
-    };
+  if (status === null || status === void 0) {
+    status = record["status"];
   }
-  writeItem(item) {
-    if (this.#closed) {
-      throw new Error("session journal is closed");
+  return status;
+}
+function classifyModelError(error) {
+  let current = error;
+  const seen = /* @__PURE__ */ new Set();
+  while (current !== null && current !== void 0 && (typeof current === "object" || typeof current === "function") && !seen.has(current)) {
+    seen.add(current);
+    const record = current;
+    const status = readStatus(record);
+    if (status === 401 || status === 403 || record["name"] === "AuthenticationError") {
+      return "authentication";
     }
-    writeLine(this.#fd, item);
-    this.#nextSeq += 1;
-  }
-};
-function createSessionJournal(options) {
-  const header = options.header ?? makeHeader(options);
-  const path5 = options.path ?? sessionPathForHeader(options.sessionsRoot, header.projectKey, header.createdAt, header.sessionId);
-  const existing = existsSync(path5);
-  const lockPath = `${path5}.lock`;
-  acquireLock(lockPath, header.sessionId);
-  try {
-    const fd = openSync(path5, existing ? "a" : "wx", 384);
-    if (!existing) {
-      writeLine(fd, header);
-      fsyncSync(fd);
-      return new FileSessionJournal({ header, path: path5, nextSeq: 1, fd, attachments: options.attachments });
+    if (status === 429 || record["name"] === "RateLimitError") {
+      return "rate_limited";
     }
-    const replay = readSessionFile(path5);
-    return new FileSessionJournal({
-      header: replay.header,
-      path: path5,
-      nextSeq: replay.lastSeq + 1,
-      fd,
-      attachments: options.attachments
-    });
-  } catch (error) {
-    releaseLock(lockPath);
-    throw error;
+    const message = typeof record["message"] === "string" ? record["message"] : "";
+    if (status === 408 || status === 504 || record["name"] === "TimeoutError" || /\btimeout\b|\btimed out\b/i.test(message)) {
+      return "timeout";
+    }
+    if (CONTEXT_OVERFLOW_PATTERN.test(message)) {
+      return "context_overflow";
+    }
+    if (typeof status === "number" && status >= 500) {
+      return "server";
+    }
+    if (record["name"] === "APIConnectionError" || NETWORK_PATTERN.test(message)) {
+      return "retryable";
+    }
+    current = record["cause"];
   }
+  return "retryable";
 }
-function makeHeader(options) {
-  const projectRoot = canonicalProjectRoot(required(options.projectRoot, "projectRoot"));
-  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+function modelErrorKind(error) {
+  return error instanceof ModelError ? error.kind : classifyModelError(error);
+}
+function portableModelMessage(message) {
+  if (message.role !== "assistant") {
+    return message;
+  }
   return {
-    schemaVersion: 1,
-    type: "session_header",
-    sessionId: randomUUID2().replaceAll("-", ""),
-    createdAt,
-    initialCwd: required(options.initialCwd, "initialCwd"),
-    projectRoot,
-    projectKey: projectKeyForRoot(projectRoot),
-    appVersion: required(options.appVersion, "appVersion"),
-    provider: required(options.provider, "provider"),
-    model: required(options.model, "model"),
-    reasoningEffort: options.reasoningEffort ?? "high",
-    origin: options.origin ?? "new",
-    ...options.parentSessionId === void 0 ? {} : { parentSessionId: options.parentSessionId },
-    ...options.forkedFrom === void 0 ? {} : { forkedFrom: options.forkedFrom }
+    role: "assistant",
+    provider: message.provider,
+    model: message.model,
+    content: message.content
   };
 }
-function acquireLock(path5, sessionId) {
-  try {
-    const fd = openSync(path5, "wx", 384);
-    writeLine(fd, { pid: process.pid, sessionId, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
-    closeSync(fd);
-  } catch (error) {
-    if (!isLiveLock(path5)) {
-      releaseLock(path5);
-      const fd = openSync(path5, "wx", 384);
-      writeLine(fd, { pid: process.pid, sessionId, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
-      closeSync(fd);
-      return;
+
+// ../../packages/llm/llm/dist/model-runtime.js
+var ModelRuntime = class {
+  adapter;
+  retryDelaysMs;
+  sleep;
+  constructor(adapter, options = {}) {
+    this.adapter = adapter;
+    this.retryDelaysMs = validateRetryDelays(options.retryDelaysMs ?? [250, 1e3]);
+    this.sleep = options.sleep ?? defaultSleep;
+  }
+  async complete(request) {
+    if (request.cancelToken?.isCancelled()) {
+      throw new ModelStreamCancelled(request.cancelToken.reason || "cancelled");
+    }
+    const maxAttempts = validateMaxAttempts(request.maxAttempts ?? 3);
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      const adapterRequest = {
+        ...request.imageContext === void 0 ? {} : { imageContext: request.imageContext },
+        provider: request.provider,
+        model: request.model,
+        ...request.baseUrl === void 0 ? {} : { baseUrl: request.baseUrl },
+        messages: request.messages,
+        tools: request.tools,
+        ...request.reasoningEffort === void 0 ? {} : { reasoningEffort: request.reasoningEffort },
+        ...request.temperature === void 0 ? {} : { temperature: request.temperature },
+        ...request.maxOutputTokens === void 0 ? {} : { maxOutputTokens: request.maxOutputTokens },
+        ...request.timeoutMs === void 0 ? {} : { timeoutMs: request.timeoutMs },
+        ...request.requestId === void 0 ? {} : { requestId: request.requestId },
+        ...request.cancelToken == null ? {} : { cancelToken: request.cancelToken },
+        ...request.isRequestActive == null ? {} : { isRequestActive: request.isRequestActive },
+        ...request.onDelta == null ? {} : { onEvent: (event) => forwardEvent(event, request.onDelta) },
+        ...request.onRequestOpened == null ? {} : { onRequestOpened: request.onRequestOpened }
+      };
+      try {
+        return await this.adapter.runAttempt(adapterRequest);
+      } catch (error) {
+        const normalized = normalizeRuntimeError(error, request.cancelToken ?? null);
+        if (!shouldRetry(normalized, attempt, maxAttempts)) {
+          throw normalized;
+        }
+        const delayMs = this.retryDelaysMs[Math.min(attempt - 1, this.retryDelaysMs.length - 1)];
+        request.onDelta?.("model_retry_scheduled", {
+          attempt: attempt + 1,
+          max_attempts: maxAttempts,
+          delay_ms: delayMs,
+          error_kind: normalized.kind
+        });
+        await this.sleep(delayMs, request.cancelToken ?? null);
+      }
     }
-    throw new SessionJournalLockError(`session journal is locked: ${path5}`);
+    throw new ModelError("model retry loop exhausted", { kind: "protocol" });
+  }
+};
+function forwardEvent(event, handler) {
+  if (event.type === "text-delta") {
+    handler?.("model_text_delta", { text: event.text });
+  } else if (event.type === "reasoning-delta") {
+    handler?.("model_reasoning_delta", { text: event.text });
+  } else if (event.type === "tool-call-delta") {
+    handler?.("model_tool_call_delta", {
+      index: event.index,
+      id: event.id,
+      name: event.name ?? null,
+      arguments: event.argumentsDelta
+    });
+  } else {
+    handler?.("model_response_validating", {});
   }
 }
-function isLiveLock(path5) {
-  if (!existsSync(path5)) {
-    return false;
+function normalizeRuntimeError(error, cancelToken) {
+  if (error instanceof ModelStreamCancelled) {
+    return error;
   }
-  try {
-    const parsed = JSON.parse(readFileSync2(path5, "utf8"));
-    if (typeof parsed.pid !== "number" || !Number.isInteger(parsed.pid)) {
-      return false;
-    }
-    process.kill(parsed.pid, 0);
-    return true;
-  } catch (error) {
-    const code = error.code;
-    return code === "EPERM";
+  if (cancelToken?.isCancelled()) {
+    return new ModelStreamCancelled(cancelToken.reason || "cancelled", { cause: error });
   }
-}
-function releaseLock(path5) {
-  if (existsSync(path5)) {
-    unlinkSync(path5);
+  if (error instanceof ModelError) {
+    return error;
   }
+  if (error instanceof ModelStreamError) {
+    return new ModelError(error.message, {
+      kind: modelErrorKind(error),
+      hadDelta: error.hadDelta,
+      cause: error
+    });
+  }
+  return new ModelError(errorMessage(error), {
+    kind: modelErrorKind(error),
+    cause: error
+  });
 }
-function writeLine(fd, value) {
-  writeSync(fd, `${JSON.stringify(value)}
-`);
+function shouldRetry(error, attempt, maxAttempts) {
+  if (!(error instanceof ModelError) || attempt >= maxAttempts) {
+    return false;
+  }
+  if (error.hadDelta) {
+    return false;
+  }
+  return error.kind === "timeout" || error.kind === "rate_limited" || error.kind === "server" || error.kind === "retryable";
 }
-function required(value, label) {
-  if (value === void 0 || value === "") {
-    throw new Error(`${label} is required`);
+function validateMaxAttempts(value) {
+  if (!Number.isInteger(value) || value < 1 || value > 10) {
+    throw new RangeError("maxAttempts must be an integer from 1 through 10");
   }
   return value;
 }
-
-// ../../packages/session/session-store/dist/session-manager.js
-import { existsSync as existsSync2, readdirSync as readdirSync2, statSync } from "node:fs";
-import { join as join3 } from "node:path";
-
-// ../../packages/session/session-store/dist/session-tree.js
-function buildSessionTree(sessions) {
-  const nodes = /* @__PURE__ */ new Map();
-  for (const session of sessions) {
-    nodes.set(session.sessionId, { session, children: [] });
+function validateRetryDelays(value) {
+  if (value.length === 0) {
+    throw new RangeError("retryDelaysMs must not be empty");
   }
-  const roots = [];
-  for (const session of sessions) {
-    const node = nodes.get(session.sessionId);
-    const parentId = session.parentSessionId;
-    const parent = parentId === void 0 ? void 0 : nodes.get(parentId);
-    if (parent === void 0) {
-      roots.push(node);
-    } else {
-      parent.children.push(node);
+  for (const delay2 of value) {
+    if (!Number.isInteger(delay2) || delay2 < 0 || !Number.isFinite(delay2)) {
+      throw new RangeError("retryDelaysMs must contain finite non-negative integers");
     }
   }
-  const sortNodes = (items) => items.sort((left, right) => right.session.createdAt.localeCompare(left.session.createdAt)).map((item) => ({
-    session: item.session,
-    children: sortNodes(item.children)
-  }));
-  return sortNodes(roots);
+  return [...value];
 }
-
-// ../../packages/session/session-store/dist/session-manager.js
-var SessionManager = class {
-  #attachments;
-  #sessionsRoot;
-  #appVersion;
-  constructor(options) {
-    this.#attachments = options.attachments;
-    this.#sessionsRoot = options.sessionsRoot;
-    this.#appVersion = options.appVersion;
-  }
-  create(options) {
-    const journal = createSessionJournal({
-      attachments: this.#attachments,
-      sessionsRoot: this.#sessionsRoot,
-      projectRoot: options.projectRoot,
-      initialCwd: options.initialCwd,
-      appVersion: this.#appVersion,
-      provider: options.provider,
-      model: options.model,
-      reasoningEffort: options.reasoningEffort,
-      origin: "new"
-    });
-    return {
-      header: journal.header,
-      journal,
-      replay: {
-        header: journal.header,
-        items: [],
-        lastSeq: 0,
-        ignoredTornTail: false,
-        openToolCalls: []
-      }
-    };
-  }
-  open(sessionId) {
-    const summary = this.list().find((item) => item.sessionId === sessionId);
-    if (summary === void 0 || summary.status === "corrupt") {
-      throw new Error(`unknown session: ${sessionId}`);
-    }
-    const replay = readSessionFile(summary.path);
-    const journal = createSessionJournal({
-      attachments: this.#attachments,
-      sessionsRoot: this.#sessionsRoot,
-      header: replay.header,
-      path: summary.path
-    });
-    return { header: replay.header, journal, replay };
+async function defaultSleep(delayMs, cancelToken) {
+  if (cancelToken?.isCancelled()) {
+    throw new ModelStreamCancelled(cancelToken.reason || "cancelled");
   }
-  continueLatest(projectRoot) {
-    const latest = this.list(projectRoot).find((item) => item.status !== "corrupt");
-    return latest === void 0 ? null : this.open(latest.sessionId);
+  const cancelled = await cancelToken?.wait(delayMs);
+  if (cancelled) {
+    throw new ModelStreamCancelled(cancelToken?.reason || "cancelled");
   }
-  list(projectRoot) {
-    const canonical = projectRoot === void 0 ? null : canonicalProjectRoot(projectRoot);
-    return this.sessionPaths().map((path5) => summaryForPath(path5)).filter((summary) => canonical === null || summary.projectRoot === canonical).sort((left, right) => {
-      const updated = right.updatedAt.localeCompare(left.updatedAt);
-      return updated === 0 ? right.createdAt.localeCompare(left.createdAt) : updated;
-    });
+  if (cancelToken === null) {
+    await new Promise((resolve15) => setTimeout(resolve15, delayMs));
   }
-  tree(projectRoot) {
-    return buildSessionTree(this.list(projectRoot).filter((item) => item.status !== "corrupt"));
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../../packages/session/session-context/dist/context-builder.js
+var ContextBuildError = class extends Error {
+  entryId;
+  constructor(entryId, message) {
+    super(`${entryId}: ${message}`);
+    this.name = "ContextBuildError";
+    this.entryId = entryId;
   }
-  fork(options) {
-    const parent = this.parentReplay(options.parentSessionId);
-    const target = parent.items.find((item) => item.kind === "entry" && item.entryType === "user_message" && item.id === options.entryId);
-    if (target === void 0) {
-      throw new Error("fork target must be a user_message entry");
+};
+var ContextBuilder = class {
+  build(input) {
+    const sorted = [...input.entries].sort((left, right) => left.seq - right.seq);
+    const superseded = supersededEntryIds(sorted);
+    const boundary = contextResetBoundary(sorted);
+    const activeCompaction = latestCompaction(sorted.filter((entry) => entry.seq > boundary));
+    const selected = [];
+    const system = latestActive(sorted, "system_context", superseded);
+    if (system !== null) {
+      selected.push({ entryId: system.id, message: system.payload.message });
     }
-    const child = createSessionJournal({
-      attachments: this.#attachments,
-      sessionsRoot: this.#sessionsRoot,
-      projectRoot: parent.header.projectRoot,
-      initialCwd: parent.header.initialCwd,
-      appVersion: this.#appVersion,
-      provider: parent.header.provider,
-      model: parent.header.model,
-      reasoningEffort: parent.header.reasoningEffort,
-      origin: "fork",
-      parentSessionId: parent.header.sessionId,
-      forkedFrom: {
-        sessionId: parent.header.sessionId,
-        seq: target.seq,
-        entryId: target.id,
-        mode: options.mode
+    for (const entry of sorted) {
+      if (entry.entryType === "project_instructions" && !superseded.has(entry.id)) {
+        selected.push({ entryId: entry.id, message: entry.payload.message });
       }
-    });
-    const throughSeq = options.mode === "before" ? target.seq - 1 : target.seq;
-    copyEntries(child, parent.items.filter(isEntry).filter((item) => item.seq <= throughSeq));
-    appendTitleSnapshot(child, sessionTitleAt(parent.items, throughSeq));
-    child.close();
+    }
+    if (activeCompaction !== null) {
+      selected.push({
+        entryId: activeCompaction.id,
+        message: {
+          role: "user",
+          content: `<conversation_summary>
+${activeCompaction.payload.summary}
+</conversation_summary>`
+        }
+      });
+    }
+    for (const entry of conversationTail(sorted, activeCompaction).filter((entry2) => entry2.seq > boundary)) {
+      const message = modelMessageForEntry(entry, input.currentProvider, input.currentModel);
+      if (message !== null) {
+        selected.push({ entryId: entry.id, message });
+      }
+    }
+    validateToolPairs(selected);
+    const offloaded = new Set(sorted.flatMap((entry) => entry.entryType === "image_offload" ? entry.payload.keys : []));
     return {
-      sessionId: child.header.sessionId,
-      path: child.path,
-      editorText: options.mode === "before" ? target.payload.message.skillContext?.input ?? target.payload.message.content : ""
+      messages: selected.map((item) => projectImageOffloads(item.message, offloaded)),
+      sourceEntryIds: selected.map((item) => item.entryId),
+      activeCompactionId: activeCompaction?.id ?? null
     };
   }
-  clone(options) {
-    const parent = this.parentReplay(options.parentSessionId);
-    const lastEntry = [...parent.items].reverse().find((item) => item.kind === "entry");
-    const child = createSessionJournal({
-      attachments: this.#attachments,
-      sessionsRoot: this.#sessionsRoot,
-      projectRoot: parent.header.projectRoot,
-      initialCwd: parent.header.initialCwd,
-      appVersion: this.#appVersion,
-      provider: parent.header.provider,
-      model: parent.header.model,
-      reasoningEffort: parent.header.reasoningEffort,
-      origin: "clone",
-      parentSessionId: parent.header.sessionId,
-      forkedFrom: {
-        sessionId: parent.header.sessionId,
-        ...lastEntry === void 0 ? {} : { seq: lastEntry.seq, entryId: lastEntry.id },
-        mode: "clone"
+};
+function supersededEntryIds(entries) {
+  const superseded = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.entryType === "system_context" && entry.payload.supersedesEntryId !== void 0) {
+      superseded.add(entry.payload.supersedesEntryId);
+    }
+    if (entry.entryType === "project_instructions") {
+      for (const id of entry.payload.supersedesEntryIds) {
+        superseded.add(id);
       }
-    });
-    copyEntries(child, parent.items.filter(isEntry));
-    appendTitleSnapshot(child, sessionTitleAt(parent.items));
-    child.close();
-    return { sessionId: child.header.sessionId, path: child.path };
+    }
   }
-  parentReplay(sessionId) {
-    const summary = this.list().find((item) => item.sessionId === sessionId);
-    if (summary === void 0 || summary.status === "corrupt") {
-      throw new Error(`unknown session: ${sessionId}`);
+  return superseded;
+}
+function latestActive(entries, entryType, superseded) {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry.entryType === entryType && !superseded.has(entry.id)) {
+      return entry;
     }
-    return readSessionFile(summary.path);
   }
-  sessionPaths() {
-    if (!existsSync2(this.#sessionsRoot)) {
-      return [];
+  return null;
+}
+function latestCompaction(entries) {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry.entryType === "compaction") {
+      return entry;
     }
-    const paths = [];
-    const visit = (directory) => {
-      for (const entry of readdirSync2(directory)) {
-        const absolute = join3(directory, entry);
-        const stat6 = statSync(absolute);
-        if (stat6.isDirectory()) {
-          visit(absolute);
-        } else if (absolute.endsWith(".jsonl")) {
-          paths.push(absolute);
-        }
-      }
-    };
-    visit(this.#sessionsRoot);
-    return paths.sort();
   }
-};
-function summaryForPath(path5) {
-  try {
-    const replay = readSessionFile(path5);
-    const last = replay.items.at(-1);
-    const title = sessionTitleAt(replay.items);
-    return {
-      sessionId: replay.header.sessionId,
-      path: path5,
-      createdAt: replay.header.createdAt,
-      updatedAt: last?.timestamp ?? replay.header.createdAt,
-      projectRoot: replay.header.projectRoot,
-      cwd: cwdFrom(replay),
-      provider: replay.header.provider,
-      model: replay.header.model,
-      origin: replay.header.origin,
-      ...replay.header.parentSessionId === void 0 ? {} : { parentSessionId: replay.header.parentSessionId },
-      ...title === null ? {} : { title },
-      lastUserText: lastUserText(replay.items),
-      status: last?.kind === "record" && last.recordType === "session_closed" ? "closed" : existsSync2(`${path5}.lock`) ? "open" : "interrupted"
-    };
-  } catch {
-    return {
-      sessionId: path5,
-      path: path5,
-      createdAt: "",
-      updatedAt: "",
-      projectRoot: "",
-      cwd: "",
-      provider: "",
-      model: "",
-      origin: "import",
-      lastUserText: "",
-      status: "corrupt"
-    };
+  return null;
+}
+function conversationTail(entries, activeCompaction) {
+  const boundary = activeCompaction?.payload.retainedFromSeq ?? 1;
+  return entries.filter((entry) => entry.seq >= boundary && entry.entryType !== "system_context" && entry.entryType !== "project_instructions" && entry.entryType !== "compaction");
+}
+function modelMessageForEntry(entry, currentProvider, currentModel) {
+  if (entry.entryType === "tool_definitions" || entry.entryType === "tool_catalog" || entry.entryType === "skill_context")
+    return entry.payload.message;
+  if (entry.entryType === "user_message" || entry.entryType === "reminder") {
+    return entry.payload.message;
+  }
+  if (entry.entryType === "assistant_message") {
+    const message = entry.payload.message;
+    if (message.provider !== currentProvider || message.model !== currentModel) {
+      return portableModelMessage(message);
+    }
+    return message;
   }
+  if (entry.entryType === "tool_result") {
+    return entry.payload.message;
+  }
+  return null;
 }
-function cwdFrom(replay) {
-  for (const item of [...replay.items].reverse()) {
-    if (item.kind === "entry" && item.entryType === "system_context") {
-      return item.payload.cwd;
+function validateToolPairs(selected) {
+  let expected = [];
+  let ownerEntryId = null;
+  for (const item of selected) {
+    if (item.message.role === "assistant") {
+      if (expected.length > 0) {
+        throw new ContextBuildError(ownerEntryId ?? item.entryId, "missing tool result");
+      }
+      expected = item.message.content.filter((block) => block.type === "tool-call").map((block) => block.call.id);
+      ownerEntryId = expected.length === 0 ? null : item.entryId;
+      continue;
+    }
+    if (item.message.role === "tool-result") {
+      const [next, ...rest] = expected;
+      if (next === void 0) {
+        throw new ContextBuildError(item.entryId, "orphan tool result");
+      }
+      if (item.message.toolCallId !== next) {
+        throw new ContextBuildError(item.entryId, "tool result order does not match tool call order");
+      }
+      expected = rest;
+      ownerEntryId = expected.length === 0 ? null : ownerEntryId;
+      continue;
+    }
+    if (expected.length > 0) {
+      throw new ContextBuildError(ownerEntryId ?? item.entryId, "missing tool result");
     }
   }
-  return replay.header.initialCwd;
+  if (expected.length > 0) {
+    throw new ContextBuildError(ownerEntryId ?? "unknown", "missing tool result");
+  }
 }
-function lastUserText(items) {
-  for (const item of [...items].reverse()) {
-    if (item.kind === "entry" && item.entryType === "user_message") {
-      return item.payload.message.skillContext?.input ?? item.payload.message.content;
+
+// ../../packages/session/session-context/dist/summary-prompt.js
+var COMPACTION_SYSTEM_PROMPT = "Summarize the conversation for continuation. Preserve user goals, explicit constraints, completed work, modified files, architectural decisions, tool outcomes, failures, current TODOs, and concrete state needed to continue. Do not include credentials. Do not invent results.";
+
+// ../../packages/session/session-context/dist/compaction.js
+function selectCompactionPlan(input) {
+  const boundary = contextResetBoundary(input.entries);
+  input = { ...input, entries: input.entries.filter((entry) => entry.seq > boundary) };
+  const units = semanticUnits(input.entries);
+  const retained = [];
+  let tokens = 0;
+  for (let index = units.length - 1; index >= 0; index -= 1) {
+    const unit = units[index];
+    const unitTokens = input.estimator.estimateMessages(unit.messages);
+    retained.unshift(unit);
+    tokens += unitTokens;
+    if (tokens >= input.retainTokens) {
+      break;
     }
   }
-  return "";
+  if (retained.length === 0 && units.length > 0) {
+    retained.push(units.at(-1));
+  }
+  const currentTurn = input.protectedFromSeq ?? [...input.entries].reverse().find((entry) => entry.entryType === "user_message")?.seq ?? 0;
+  const hasCurrentImages = input.entries.some((entry) => entry.seq >= currentTurn && "message" in entry.payload && "attachments" in entry.payload.message && entry.payload.message.attachments?.some((block) => block.type === "image"));
+  const retainedFirst = Math.min(retained[0]?.entries[0]?.seq ?? Number.MAX_SAFE_INTEGER, hasCurrentImages ? currentTurn : Number.MAX_SAFE_INTEGER);
+  const retainedUnits = units.filter((unit) => unit.entries[0].seq >= retainedFirst);
+  const summarized = units.filter((unit) => unit.entries[0].seq < retainedFirst);
+  return {
+    summarizedEntries: summarized.flatMap((unit) => unit.entries),
+    retainedEntries: retainedUnits.flatMap((unit) => unit.entries),
+    retainedFromSeq: retainedUnits[0]?.entries[0]?.seq ?? 1
+  };
 }
-function copyEntries(journal, entries) {
+function serializeConversation(entries) {
+  const lines2 = ["<conversation>"];
   for (const entry of entries) {
-    const input = {
-      entryType: entry.entryType,
-      payload: entry.payload,
-      ...entry.taskId === void 0 ? {} : { taskId: entry.taskId },
-      ...entry.turnId === void 0 ? {} : { turnId: entry.turnId },
-      copiedFrom: {
-        sessionId: entry.sessionId,
-        itemId: entry.id,
-        seq: entry.seq
+    lines2.push(`<entry id="${entry.id}" seq="${entry.seq}" type="${entry.entryType}">`);
+    if (entry.entryType === "assistant_message") {
+      for (const block of entry.payload.message.content) {
+        if (block.type === "tool-call") {
+          lines2.push(`[assistant tool-call ${block.call.id} ${block.call.name}] ${JSON.stringify(block.call.arguments)}`);
+        } else {
+          lines2.push(`[assistant ${block.type}] ${block.text}`);
+        }
+      }
+    } else if (entry.entryType === "tool_result") {
+      lines2.push(`[tool-result ${entry.payload.message.toolCallId} ${entry.payload.message.toolName}] ${entry.payload.message.content}`);
+    } else if (entry.entryType === "tool_definitions") {
+      lines2.push(`[loaded tool definitions] ${(entry.payload.message.toolDefinitions ?? []).map((tool) => tool.spec.name).join(", ")}`);
+    } else if (entry.entryType === "user_message" || entry.entryType === "skill_context" || entry.entryType === "reminder" || entry.entryType === "project_instructions") {
+      lines2.push(`[${entry.payload.message.role}] ${entry.payload.message.content}`);
+    }
+    if ("message" in entry.payload && "attachments" in entry.payload.message) {
+      for (const block of entry.payload.message.attachments ?? [])
+        lines2.push(`[attachment metadata only; not visual interpretation] ${JSON.stringify(block)}`);
+    }
+    lines2.push("</entry>");
+  }
+  lines2.push("</conversation>");
+  return lines2.join("\n");
+}
+function semanticUnits(entries) {
+  const units = [];
+  const groupedDefinitions = /* @__PURE__ */ new Set();
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (groupedDefinitions.has(entry.id))
+      continue;
+    if (entry.entryType === "context_reset" || entry.entryType === "image_offload" || entry.entryType === "system_context" || entry.entryType === "project_instructions" || entry.entryType === "compaction") {
+      continue;
+    }
+    if (entry.entryType === "assistant_message") {
+      const toolCallIds = entry.payload.message.content.filter((block) => block.type === "tool-call").map((block) => block.call.id);
+      if (toolCallIds.length > 0) {
+        const grouped = [entry];
+        for (const id of toolCallIds) {
+          const resultIndex = entries.findIndex((candidate) => candidate.entryType === "tool_result" && candidate.payload.message.toolCallId === id);
+          if (resultIndex < 0) {
+            throw new Error(`cannot compact incomplete tool call: ${id}`);
+          }
+          grouped.push(entries[resultIndex]);
+        }
+        const lastResultIndex = entries.findIndex((candidate) => candidate.id === grouped.at(-1).id);
+        const definitions = entries[lastResultIndex + 1];
+        if (definitions?.entryType === "tool_definitions") {
+          grouped.push(definitions);
+          groupedDefinitions.add(definitions.id);
+        }
+        units.push({ entries: grouped, messages: grouped.map(messageForEntry) });
+        continue;
       }
-    };
-    journal.appendEntry(input);
+    }
+    if (entry.entryType === "tool_result") {
+      continue;
+    }
+    units.push({ entries: [entry], messages: [messageForEntry(entry)] });
   }
+  return units;
 }
-function isEntry(item) {
-  return item.kind === "entry";
-}
-function appendTitleSnapshot(journal, title) {
-  if (title !== null) {
-    journal.appendRecord({
-      recordType: "session_name_changed",
-      payload: { title }
-    });
+function messageForEntry(entry) {
+  if (entry.entryType === "tool_definitions" || entry.entryType === "tool_catalog" || entry.entryType === "skill_context")
+    return entry.payload.message;
+  if (entry.entryType === "assistant_message") {
+    return entry.payload.message;
+  }
+  if (entry.entryType === "tool_result") {
+    return entry.payload.message;
+  }
+  if (entry.entryType === "user_message" || entry.entryType === "reminder" || entry.entryType === "project_instructions") {
+    return entry.payload.message;
   }
+  throw new Error(`entry has no model message: ${entry.entryType}`);
 }
 
-// ../../packages/session/session-store/dist/transcript-projector.js
-function projectTranscript(entries) {
-  const items = [];
-  const skillNames = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    if (entry.entryType === "user_message") {
-      items.push({ kind: "user", text: entry.payload.message.skillContext?.input ?? entry.payload.message.content });
-    } else if (entry.entryType === "assistant_message") {
-      for (const block of entry.payload.message.content) {
-        if (block.type !== "tool-call" || block.call.name !== "skill")
-          continue;
-        try {
-          const args = JSON.parse(block.call.arguments);
-          if (args && typeof args === "object" && "name" in args && typeof args.name === "string") {
-            skillNames.set(block.call.id, args.name);
-          }
-        } catch {
-        }
-      }
-      const text3 = entry.payload.message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
-      const reasoning = entry.payload.message.content.filter((block) => block.type === "reasoning").map((block) => block.text).join("");
-      items.push({
-        kind: "assistant",
-        text: text3,
-        ...reasoning === "" ? {} : { reasoning }
-      });
-    } else if (entry.entryType === "tool_result") {
-      const message = entry.payload.message;
-      let result = message.content;
-      if (message.toolName === "skill") {
-        try {
-          const value = JSON.parse(result);
-          if (value && typeof value === "object") {
-            if ("content" in value && typeof value.content === "string")
-              result = value.content;
-            else if ("error" in value && typeof value.error === "string")
-              result = value.error;
-          }
-        } catch {
-        }
+// ../../packages/session/session-context/dist/context-governor.js
+var ContextBudgetError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ContextBudgetError";
+  }
+};
+var ContextGovernor = class {
+  #builder;
+  #estimator;
+  #summarize;
+  #appendCompaction;
+  constructor(options) {
+    this.#builder = options.builder ?? new ContextBuilder();
+    this.#estimator = options.estimator ?? new DefaultTokenEstimator();
+    this.#summarize = options.summarize;
+    this.#appendCompaction = options.appendCompaction;
+  }
+  async prepare(input) {
+    let built = this.#builder.build(input);
+    let tokens = this.measure(input, built);
+    const calculated = calculateModelBudget({ budget: input.budget, policy: input.policy });
+    if (!input.policy.auto || tokens <= calculated.autoTrigger) {
+      if (tokens > calculated.hardInputLimit)
+        throw new ContextBudgetError("context exceeds hard input limit");
+      return { built, messages: built.messages, compacted: false, tokens };
+    }
+    const result = await this.compact({ ...input, trigger: "automatic" });
+    const entries = [...input.entries, result.entry];
+    built = this.#builder.build({ ...input, entries });
+    tokens = this.measure({ ...input, entries }, built);
+    if (tokens > calculated.hardInputLimit) {
+      throw new ContextBudgetError("context remains over hard input limit after compaction");
+    }
+    return { built, messages: built.messages, compacted: true, tokens };
+  }
+  async compact(input) {
+    const calculated = calculateModelBudget({ budget: input.budget, policy: input.policy });
+    const plan = selectCompactionPlan({
+      protectedFromSeq: input.protectedFromSeq,
+      entries: input.entries,
+      // A search preflight reserves the pending call/result/definition unit.
+      // Keep the latest completed unit and summarize older units to make room.
+      retainTokens: input.reserveTokens === void 0 ? calculated.retainTokens : 1,
+      estimator: this.#estimator
+    });
+    if (input.trigger === "manual" && plan.summarizedEntries.length === 0) {
+      throw new Error("No messages to compact in current history.");
+    }
+    const summarizedFromSeq = plan.summarizedEntries[0]?.seq ?? 1;
+    const summarizedThroughSeq = plan.summarizedEntries.at(-1)?.seq ?? Math.max(0, summarizedFromSeq - 1);
+    const built = this.#builder.build(input);
+    const activeCompaction = input.entries.find((entry) => entry.id === built.activeCompactionId);
+    const messagesBefore = built.messages;
+    const tokensBefore = this.#estimator.estimateMessages(messagesBefore) + this.#estimator.estimateTools(input.projectTools?.(messagesBefore) ?? input.tools);
+    const summary = plan.summarizedEntries.length === 0 ? {
+      summary: "No prior conversation needed compaction.",
+      inputTokens: 0,
+      outputTokens: 0
+    } : await this.#summarize({
+      serialized: serializeConversation(plan.summarizedEntries),
+      maxSummaryTokens: input.policy.maxSummaryTokens
+    });
+    const payload = {
+      summary: summary.summary,
+      summarizedFromSeq,
+      summarizedThroughSeq,
+      retainedFromSeq: plan.retainedFromSeq,
+      ...activeCompaction === void 0 ? {} : { supersedesCompactionId: activeCompaction.id },
+      tokensBefore,
+      retainedTokens: calculated.retainTokens,
+      summaryInputTokens: summary.inputTokens,
+      summaryOutputTokens: summary.outputTokens,
+      provider: input.currentProvider,
+      model: input.currentModel,
+      trigger: input.trigger
+    };
+    return { entry: this.#appendCompaction(payload) };
+  }
+  async completeWithOverflowRecovery(input, send) {
+    let prepared = await this.prepare(input);
+    try {
+      return await send(prepared);
+    } catch (error) {
+      if (!(error instanceof ModelError) || modelErrorKind(error) !== "context_overflow" || error.hadDelta) {
+        throw error;
       }
-      items.push({
-        kind: "tool",
-        callId: entry.payload.message.toolCallId,
-        name: entry.payload.message.toolName,
-        subject: message.toolName === "skill" ? skillNames.get(message.toolCallId) ?? "" : message.toolCallId,
-        result,
-        isError: entry.payload.message.isError
-      });
-    } else if (entry.entryType === "compaction") {
-      items.push({
-        kind: "notice",
-        text: "Conversation context was compacted.",
-        tone: "info"
-      });
     }
+    const compaction = await this.compact({ ...input, trigger: "provider_overflow" });
+    prepared = await this.prepare({ ...input, entries: [...input.entries, compaction.entry] });
+    return await send(prepared);
   }
-  return items;
+  measure(input, built) {
+    const tools = input.projectTools?.(built.messages) ?? input.tools;
+    return this.#estimator.measure({
+      messages: built.messages,
+      tools,
+      entries: input.entries,
+      anchor: input.anchor ?? null,
+      provider: input.currentProvider,
+      model: input.currentModel,
+      systemFingerprint: fingerprintContextPart(built.messages.find((message) => message.role === "system") ?? null),
+      projectInstructionsFingerprint: fingerprintContextPart(built.messages.filter((message, index) => index > 0 && message.role === "user")),
+      toolsFingerprint: fingerprintContextPart(tools)
+    }).totalTokens + (input.reserveTokens ?? 0);
+  }
+};
+function calculateModelBudget(input) {
+  const hardInputLimit = input.budget.contextWindow - input.budget.maxOutputTokens;
+  const safetyTokens = Math.ceil(input.budget.contextWindow * input.policy.safetyRatio);
+  const autoTrigger = Math.min(Math.floor(input.budget.contextWindow * input.policy.thresholdRatio), hardInputLimit - safetyTokens);
+  const retainTokens = input.policy.retainTokens ?? Math.floor(input.budget.contextWindow * input.policy.retainRatio);
+  return { hardInputLimit, safetyTokens, autoTrigger, retainTokens };
 }
 
 // ../../packages/llm/llm-pi-ai/dist/adapter.js
@@ -23486,7 +23522,8 @@ var CONTROL_KEYS = /* @__PURE__ */ new Map([
   [12, makeKeyInput("ctrl_l", { ctrl: true })],
   [15, makeKeyInput("character", { text: "o", ctrl: true })],
   [19, makeKeyInput("character", { text: "s", ctrl: true })],
-  [20, makeKeyInput("character", { text: "t", ctrl: true })]
+  [20, makeKeyInput("character", { text: "t", ctrl: true })],
+  [22, makeKeyInput("character", { text: "v", ctrl: true })]
 ]);
 var ESCAPE_INCOMPLETE = { status: "incomplete" };
 var ESCAPE_CONSUMED = { status: "consumed" };
@@ -23633,6 +23670,10 @@ var RawInputDecoder = class {
       this.buffer = this.buffer.subarray(3);
       return kind !== void 0 ? { status: "action", action: inputAction(kind) } : ESCAPE_CONSUMED;
     }
+    if (second === 118) {
+      this.buffer = this.buffer.subarray(2);
+      return { status: "action", action: inputAction(InputActionKind.Key, "", makeKeyInput("character", { text: "v", alt: true })) };
+    }
     this.buffer = this.buffer.subarray(1);
     return ESCAPE_CONSUMED;
   }
@@ -23920,7 +23961,7 @@ function decodeSpecialEscapeAction(sequence) {
   return kind !== void 0 ? inputAction(kind) : null;
 }
 function decodeModifiedControlKey(sequence) {
-  const kitty = /^\x1b\[(13|57414|9|117)(?::\d*)?(?::\d+)?;(\d+)(?::(\d+))?u$/.exec(sequence);
+  const kitty = /^\x1b\[(13|57414|9|117|118)(?::\d*)?(?::\d+)?;(\d+)(?::(\d+))?u$/.exec(sequence);
   if (kitty !== null) {
     const code = kitty[1];
     const modifier2 = Number.parseInt(kitty[2], 10) - 1;
@@ -23930,6 +23971,9 @@ function decodeModifiedControlKey(sequence) {
     if (!isKittyPressEvent(kitty[3])) {
       return null;
     }
+    if (code === "118" && (matchesKittyModifiers(modifier2, 4) || matchesKittyModifiers(modifier2, 2))) {
+      return inputAction(InputActionKind.Key, "", makeKeyInput("character", { text: "v", ctrl: matchesKittyModifiers(modifier2, 4), alt: matchesKittyModifiers(modifier2, 2) }));
+    }
     if ((code === "13" || code === "57414") && matchesKittyModifiers(modifier2, 2)) {
       return inputAction(InputActionKind.Key, "", makeKeyInput("enter", { alt: true }));
     }
@@ -23944,6 +23988,9 @@ function decodeModifiedControlKey(sequence) {
   }
   const modifier = Number.parseInt(modifyOtherKeys[1], 10) - 1;
   const codepoint = Number.parseInt(modifyOtherKeys[2], 10);
+  if (codepoint === 118 && (modifier === 4 || modifier === 2)) {
+    return inputAction(InputActionKind.Key, "", makeKeyInput("character", { text: "v", ctrl: modifier === 4, alt: modifier === 2 }));
+  }
   if (codepoint === 117 && modifier === 4) {
     return inputAction(InputActionKind.DeleteToLineStart);
   }
@@ -24294,6 +24341,7 @@ var TerminalInputDecoder = class {
 
 // ../../packages/terminal/tui/dist/keybindings/default-keybindings.js
 var DEFAULT_KEYBINDINGS = [
+  { context: "editor", key: process.platform === "win32" ? "alt+v" : "ctrl+v", action: "paste_clipboard" },
   { context: "terminal", key: "ctrl+o", action: "toggle_tool_output" },
   { context: "terminal", key: "ctrl+l", action: "select_model" },
   { context: "terminal", key: "ctrl+t", action: "toggle_thinking" },
@@ -27462,6 +27510,7 @@ var InteractiveTerminalLoop = class _InteractiveTerminalLoop {
   #renderTimer = null;
   #lastRenderAt = 0;
   #disposeResize = null;
+  #clipboard = null;
   writeError = null;
   constructor(ui, driver, editor, decoderFactory) {
     this.#ui = ui;
@@ -27564,6 +27613,7 @@ var InteractiveTerminalLoop = class _InteractiveTerminalLoop {
     return this.#viewHost.render(context);
   }
   requestExit() {
+    this.invalidateClipboardPaste();
     this.#exitRequested = true;
     this.#exitResolve?.();
   }
@@ -27572,6 +27622,7 @@ var InteractiveTerminalLoop = class _InteractiveTerminalLoop {
       return;
     }
     this.#closed = true;
+    this.invalidateClipboardPaste();
     if (this.#renderTimer !== null) {
       clearTimeout(this.#renderTimer);
       this.#renderTimer = null;
@@ -27778,14 +27829,29 @@ var InteractiveTerminalLoop = class _InteractiveTerminalLoop {
         }
         changed = true;
       } else if (item.type === "open_selection") {
+        this.invalidateClipboardPaste();
         this.#viewHost.openSelection(item.request).then(item.resolve);
         changed = true;
       } else if (item.type === "open_prompt") {
+        this.invalidateClipboardPaste();
         this.#viewHost.openPrompt(item.request).then(item.resolve);
         changed = true;
       } else if (item.type === "close_view") {
         this.#viewHost.closeActive(item.value);
         changed = true;
+      } else if (item.type === "clipboard") {
+        if (this.#clipboard === item.controller)
+          this.#clipboard = null;
+        if (item.controller.signal.aborted) {
+          this.#appendNotice("Clipboard paste cancelled because input changed; paste again.");
+        } else if (item.error) {
+          this.#appendNotice(item.error);
+        } else if (item.text) {
+          this.#applyEditorAction(inputAction(InputActionKind.Insert, item.text));
+        } else {
+          this.#appendNotice("Clipboard has no image or text.");
+        }
+        changed = true;
       } else if (item.event instanceof LocalMessage) {
         const message = item.event;
         this.#ui.appendTranscript(createNoticeBlock(this.#ui.newBlockId(), message.text, message.tone));
@@ -27820,6 +27886,7 @@ var InteractiveTerminalLoop = class _InteractiveTerminalLoop {
   #applyActions(actions) {
     for (const action of actions) {
       if (action.kind === InputActionKind.Newline) {
+        this.invalidateClipboardPaste();
         if (this.#viewHost.activeId() !== null) {
           this.#viewHost.handleInput({ type: "text", text: "\n" });
           this.#needsRender = true;
@@ -27832,6 +27899,12 @@ var InteractiveTerminalLoop = class _InteractiveTerminalLoop {
     }
   }
   #applyInputEvent(event) {
+    const clipboardAction = event.type === "key" && this.#ui.keybindings.resolve(event.key, ["editor"]) === "paste_clipboard";
+    if (clipboardAction && this.#viewHost.activeId() === null) {
+      this.#pasteClipboard();
+      return;
+    }
+    this.invalidateClipboardPaste();
     if (this.#viewHost.handleInput(event)) {
       this.#needsRender = true;
       return;
@@ -27851,6 +27924,8 @@ var InteractiveTerminalLoop = class _InteractiveTerminalLoop {
     }
   }
   #applyKeyAction(action) {
+    if (action === "paste_clipboard")
+      return;
     const capability = ACTION_CAPABILITIES[action];
     if (capability !== void 0 && !this.#ui.capabilities[capability]) {
       this.#appendNotice(unavailableActionNotice(action));
@@ -27960,6 +28035,7 @@ var InteractiveTerminalLoop = class _InteractiveTerminalLoop {
     return true;
   }
   #applyEof() {
+    this.invalidateClipboardPaste();
     const effect = this.#editor.apply(inputAction(InputActionKind.Eof), { runtimeActive: this.#ui.isRunning() });
     this.#applyEffect(effect);
     this.#needsRender = true;
@@ -27982,6 +28058,27 @@ var InteractiveTerminalLoop = class _InteractiveTerminalLoop {
   #appendNotice(text3) {
     this.#ui.appendTranscript(createNoticeBlock(this.#ui.newBlockId(), text3, "warning"));
   }
+  invalidateClipboardPaste() {
+    this.#clipboard?.abort();
+  }
+  #pasteClipboard() {
+    if (this.#clipboard)
+      return;
+    const read = this.#ui.clipboardReader;
+    if (!read) {
+      this.#appendNotice("Clipboard paste is unavailable in this host.");
+      return;
+    }
+    const controller = new AbortController();
+    this.#clipboard = controller;
+    const deliver = (text3, error) => {
+      if (this.#closed || this.#exitRequested)
+        return;
+      this.#work.push({ type: "clipboard", controller, text: text3, error });
+      this.#scheduleWakeup();
+    };
+    void Promise.resolve().then(() => read(controller.signal)).then((text3) => deliver(text3), (error) => deliver(null, error instanceof Error ? error.message : "Clipboard paste failed."));
+  }
   #refreshCompletions() {
     const registry = this.#ui.commandRegistry;
     if (registry !== null) {
@@ -28040,6 +28137,7 @@ function normalizePositiveInteger(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
 }
 var TerminalUI = class {
+  clipboardReader;
   theme;
   state;
   reducer;
@@ -28070,6 +28168,7 @@ var TerminalUI = class {
   #pendingDisplayDrops = 0;
   #keyActionCallback;
   constructor(options = {}) {
+    this.clipboardReader = options.clipboardReader;
     this.theme = resolveTerminalTheme(options.theme);
     this.projectRoot = options.projectRoot ?? null;
     this.provider = options.provider ?? null;
@@ -28188,6 +28287,8 @@ var TerminalUI = class {
     Object.assign(this.capabilities, capabilities);
   }
   setSessionId(sessionId) {
+    if (sessionId !== this.#sessionId)
+      this.#loop?.invalidateClipboardPaste();
     if (sessionId !== this.#sessionId)
       this.state.contextTokens = 0;
     this.#sessionId = sessionId;
@@ -28207,6 +28308,7 @@ var TerminalUI = class {
     this.#loop?.requestRender();
   }
   setComposerText(text3) {
+    this.#loop?.invalidateClipboardPaste();
     const editor = this.#loop?.editor;
     if (editor === void 0) {
       return;
@@ -39394,6 +39496,160 @@ async function copyText(text3, options) {
   return terminalCopy(text3, options, failures);
 }
 
+// src/clipboard-paste.ts
+import { spawn as spawn4 } from "node:child_process";
+import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join20 } from "node:path";
+import { randomUUID as randomUUID18 } from "node:crypto";
+import sharp3 from "sharp";
+var MAX_OUTPUT = 30 * 1024 * 1024;
+var MAX_TEXT = 1024 * 1024;
+var MAC_CLIPBOARD_SCRIPT = `
+ObjC.import('AppKit');
+function run() {
+  var pb = $.NSPasteboard.generalPasteboard;
+  var data = pb.dataForType($.NSPasteboardTypePNG);
+  if (!data.js) {
+    var tiff = pb.dataForType($.NSPasteboardTypeTIFF);
+    if (tiff.js) {
+      var bitmap = $.NSBitmapImageRep.imageRepWithData(tiff);
+      if (!bitmap.js) throw new Error('Cannot decode clipboard image');
+      if (bitmap.pixelsWide * bitmap.pixelsHigh > 64000000) throw new Error('Clipboard image exceeds pixel limit');
+      data = bitmap.representationUsingTypeProperties($.NSPNGFileType, $({}));
+      if (!data.js) throw new Error('Cannot encode clipboard image');
+    }
+  }
+  if (data.js) {
+    if (data.length > 20971520) throw new Error('Clipboard image exceeds 20 MiB');
+    return JSON.stringify({kind:'image', base64:ObjC.unwrap(data.base64EncodedStringWithOptions(0))});
+  }
+  var text = pb.stringForType($.NSPasteboardTypeString);
+  return JSON.stringify(text.js ? {kind:'text', text:ObjC.unwrap(text)} : {kind:'empty'});
+}`;
+var WINDOWS_CLIPBOARD_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$image = [System.Windows.Forms.Clipboard]::GetImage()
+if ($null -ne $image) {
+  $stream = [System.IO.MemoryStream]::new()
+  try {
+    if ([long]$image.Width * $image.Height -gt 64000000) { throw 'Clipboard image exceeds pixel limit' }
+    $image.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)
+    if ($stream.Length -gt 20971520) { throw 'Clipboard image exceeds 20 MiB' }
+    @{kind='image'; base64=[Convert]::ToBase64String($stream.ToArray())} | ConvertTo-Json -Compress
+  } finally { $stream.Dispose(); $image.Dispose() }
+} elseif ([System.Windows.Forms.Clipboard]::ContainsText()) {
+  @{kind='text'; text=[System.Windows.Forms.Clipboard]::GetText()} | ConvertTo-Json -Compress
+} else { @{kind='empty'} | ConvertTo-Json -Compress }
+`;
+function clipboardReadCommand(platform) {
+  if (platform === "darwin") return { command: "/usr/bin/osascript", args: ["-l", "JavaScript", "-e", MAC_CLIPBOARD_SCRIPT] };
+  if (platform === "win32") return { command: "powershell.exe", args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-STA", "-EncodedCommand", Buffer.from(WINDOWS_CLIPBOARD_SCRIPT, "utf16le").toString("base64")] };
+  throw new Error("Image clipboard paste requires native macOS or Windows; use a local image path on this platform.");
+}
+function createClipboardReadRunner(env, timeoutMs = 5e3) {
+  return (command, args, signal) => new Promise((resolve15, reject) => {
+    signal.throwIfAborted();
+    const child = spawn4(command, [...args], { env: { ...env }, shell: false, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    const chunks = [];
+    let bytes = 0;
+    let settled = false;
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal.removeEventListener("abort", abort);
+      if (error) {
+        child.kill("SIGKILL");
+        reject(error);
+      } else resolve15(Buffer.concat(chunks).toString("utf8"));
+    };
+    const abort = () => finish(new Error("Clipboard paste cancelled."));
+    const timer = setTimeout(() => finish(new Error("Clipboard read timed out.")), timeoutMs);
+    signal.addEventListener("abort", abort, { once: true });
+    child.stdout.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > MAX_OUTPUT) finish(new Error("Clipboard content exceeds the size limit."));
+      else if (!settled) chunks.push(chunk);
+    });
+    child.stderr.resume();
+    child.once("error", () => finish(new Error("Cannot start the system clipboard reader.")));
+    child.once("close", (code) => finish(code === 0 ? void 0 : new Error("System clipboard read failed; check clipboard access and try again.")));
+    if (signal.aborted) abort();
+  });
+}
+function createClipboardPaste(options) {
+  const run = options.run ?? createClipboardReadRunner(options.env);
+  let directory;
+  let closed = false;
+  let pending;
+  const read = async (signal) => {
+    signal.throwIfAborted();
+    if (closed) throw new Error("Clipboard reader is closed.");
+    if (options.env.SSH_CONNECTION || options.env.SSH_TTY) throw new Error("Remote clipboard reading is unavailable over SSH; use a remote image path.");
+    const command = clipboardReadCommand(options.platform);
+    const raw = await run(command.command, command.args, signal);
+    signal.throwIfAborted();
+    let value;
+    try {
+      value = JSON.parse(raw.replace(/^\uFEFF/, ""));
+    } catch {
+      throw new Error("Invalid response from clipboard reader.");
+    }
+    if (!value || typeof value !== "object" || !("kind" in value)) throw new Error("Invalid clipboard content.");
+    if (value.kind === "empty") return null;
+    if (value.kind === "text" && "text" in value && typeof value.text === "string") {
+      if (Buffer.byteLength(value.text) > MAX_TEXT) throw new Error("Clipboard text exceeds 1 MiB.");
+      return value.text.replace(/\r\n?/g, "\n").replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "");
+    }
+    if (value.kind !== "image" || !("base64" in value) || typeof value.base64 !== "string" || value.base64.length > Math.ceil(DEFAULT_IMAGE_LIMITS.maxBytes / 3) * 4 || value.base64.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value.base64)) {
+      throw new Error("Invalid or oversized clipboard image.");
+    }
+    const data = Buffer.from(value.base64, "base64");
+    if (data.toString("base64") !== value.base64) throw new Error("Invalid clipboard image encoding.");
+    if (!data.length || data.length > DEFAULT_IMAGE_LIMITS.maxBytes) throw new Error("Clipboard image exceeds size limits.");
+    const image = sharp3(data, { limitInputPixels: DEFAULT_IMAGE_LIMITS.maxPixels });
+    try {
+      const meta = await image.metadata();
+      if (meta.format !== "png" || !meta.width || !meta.height || Math.max(meta.width, meta.height) > DEFAULT_IMAGE_LIMITS.maxDimension) {
+        throw new Error("Invalid image");
+      }
+      await image.stats();
+    } catch {
+      throw new Error("Clipboard image is invalid or exceeds image limits.");
+    }
+    signal.throwIfAborted();
+    directory ??= await mkdtemp2(join20(options.tempRoot ?? tmpdir2(), "laohuang-clipboard-"));
+    const path5 = join20(directory, `${randomUUID18()}.png`);
+    try {
+      await writeFile5(path5, data, { flag: "wx", mode: 384 });
+      signal.throwIfAborted();
+      return ` ${JSON.stringify(path5)} `;
+    } catch (error) {
+      await rm2(path5, { force: true });
+      throw error;
+    }
+  };
+  return {
+    read(signal) {
+      if (pending) return Promise.reject(new Error("Clipboard paste already in progress."));
+      pending = read(signal).finally(() => {
+        pending = void 0;
+      });
+      return pending;
+    },
+    async close() {
+      closed = true;
+      await pending?.catch(() => {
+      });
+      if (directory) await rm2(directory, { recursive: true, force: true });
+    }
+  };
+}
+
 // src/main.ts
 var VERSION = readPackageVersion();
 function readPackageVersion() {
@@ -39499,13 +39755,13 @@ async function main(argv, options = {}) {
   const configPath = options.configPath ?? defaultConfigPath(environ);
   const manager = new ConfigManager(configPath);
   const credentials = new CredentialStore(
-    options.credentialsPath ?? join20(dirname13(configPath), "credentials.json")
+    options.credentialsPath ?? join21(dirname13(configPath), "credentials.json")
   );
   const modelCatalogStore = new ModelCatalogStore(
-    options.modelsPath ?? join20(dirname13(configPath), "models.json")
+    options.modelsPath ?? join21(dirname13(configPath), "models.json")
   );
   const customModels = new CustomModelsStore(
-    options.customModelsPath ?? join20(dirname13(configPath), "custom-models.json")
+    options.customModelsPath ?? join21(dirname13(configPath), "custom-models.json")
   );
   let modelPlatform;
   let attachmentRuntime;
@@ -39683,10 +39939,11 @@ async function main(argv, options = {}) {
     return 2;
   }
   let terminalUi = null;
+  const clipboardPaste = createClipboardPaste({ platform: process.platform, env: environ });
   let terminalDriver = null;
   let selectedModel = modelPlatform.catalog.getModel(config.provider, config.model);
   attachmentRuntime = createAttachmentRuntime({
-    root: join20(getHomeDirectory({ env: environ }), ".laohuang", "attachments"),
+    root: join21(getHomeDirectory({ env: environ }), ".laohuang", "attachments"),
     sessionsRoot: defaultSessionsRoot(environ),
     onError: (error) => writeStderr(`Attachment cleanup failed: ${errorMessage11(error)}`)
   });
@@ -39728,6 +39985,7 @@ async function main(argv, options = {}) {
         version: VERSION,
         theme: args.theme,
         driver: terminalDriver,
+        clipboardReader: (signal) => clipboardPaste.read(signal),
         capabilities: { reasoning: selectedModel?.reasoning ?? false },
         contextWindow: selectedModel?.contextWindow
       });
@@ -39999,7 +40257,11 @@ Submit an empty line to retry, or enter a replacement.`);
             if (composedForCleanup) await composedForCleanup.close();
             else await sessionController.close();
           } finally {
-            attachmentRuntime.close();
+            try {
+              await clipboardPaste.close();
+            } finally {
+              attachmentRuntime.close();
+            }
           }
         }
       }
@@ -40007,7 +40269,7 @@ Submit an empty line to retry, or enter a replacement.`);
   }
 }
 function defaultSessionsRoot(environ) {
-  return join20(getHomeDirectory({ env: environ }), ".laohuang", "sessions");
+  return join21(getHomeDirectory({ env: environ }), ".laohuang", "sessions");
 }
 async function runInitialModelSelection(options) {
   let providerName = options.providerName;