laohuang 0.7.0 → 0.8.0

package/dist/bin.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/main.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname4, join as join4 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { dirname as dirname4, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../../packages/core/agent-runtime/dist/agent.js
@@ -62,8 +62,8 @@ var CancelToken = class {
         continue;
       }
     }
-    for (const resolve of this.#waiters) {
-      resolve();
+    for (const resolve2 of this.#waiters) {
+      resolve2();
     }
     this.#waiters.clear();
     return true;
@@ -76,20 +76,20 @@ var CancelToken = class {
     if (this.#cancelled) {
       return Promise.resolve(true);
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let timer;
       const onCancel = () => {
         if (timer !== void 0) {
           clearTimeout(timer);
         }
         this.#waiters.delete(onCancel);
-        resolve(true);
+        resolve2(true);
       };
       this.#waiters.add(onCancel);
       if (timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.#waiters.delete(onCancel);
-          resolve(false);
+          resolve2(false);
         }, timeoutMs);
       }
     });
@@ -329,7 +329,11 @@ var EVENT_SPECS = new Map([
   spec(EventKind.ModelRequestStarted, {
     sources: [EventSource.Model],
     required_payload: ["request_id"],
-    payload_types: { request_id: "string" },
+    payload_types: {
+      request_id: "string",
+      context_tokens: "integer",
+      context_window: "integer"
+    },
     require_task_id: true,
     require_correlation_id: true,
     max_payload_chars: 1e5
@@ -646,8 +650,8 @@ var SubscriberMailbox = class _SubscriberMailbox {
     const deadline = timeoutMs === void 0 ? void 0 : Date.now() + timeoutMs;
     while (this.unfinished > 0) {
       if (deadline === void 0) {
-        await new Promise((resolve) => {
-          this.flushWaiters.push(resolve);
+        await new Promise((resolve2) => {
+          this.flushWaiters.push(resolve2);
         });
         continue;
       }
@@ -655,12 +659,12 @@ var SubscriberMailbox = class _SubscriberMailbox {
       if (remaining <= 0) {
         return false;
       }
-      const waiter = new Promise((resolve) => {
-        this.flushWaiters.push(resolve);
+      const waiter = new Promise((resolve2) => {
+        this.flushWaiters.push(resolve2);
       });
       let timer;
-      const timeout = new Promise((resolve) => {
-        timer = setTimeout(resolve, remaining);
+      const timeout = new Promise((resolve2) => {
+        timer = setTimeout(resolve2, remaining);
       });
       await Promise.race([waiter, timeout]);
       clearTimeout(timer);
@@ -689,22 +693,22 @@ var SubscriberMailbox = class _SubscriberMailbox {
   wake() {
     const waiters = this.wakeWaiters;
     this.wakeWaiters = [];
-    for (const resolve of waiters) {
-      resolve();
+    for (const resolve2 of waiters) {
+      resolve2();
     }
   }
   notifyFlushWaiters() {
     const waiters = this.flushWaiters;
     this.flushWaiters = [];
-    for (const resolve of waiters) {
-      resolve();
+    for (const resolve2 of waiters) {
+      resolve2();
     }
   }
   async run() {
     for (; ; ) {
       while (this.items.length === 0 && !this.closed) {
-        await new Promise((resolve) => {
-          this.wakeWaiters.push(resolve);
+        await new Promise((resolve2) => {
+          this.wakeWaiters.push(resolve2);
         });
       }
       if (this.items.length === 0 && this.closed) {
@@ -847,8 +851,8 @@ var EventBus = class {
     if (this.closed) {
       return Promise.reject(new EventBusClosedError());
     }
-    return new Promise((resolve, reject) => {
-      const waiter = { resolve, reject };
+    return new Promise((resolve2, reject) => {
+      const waiter = { resolve: resolve2, reject };
       if (timeoutMs !== void 0) {
         waiter.timer = setTimeout(() => {
           const index = this.bufferWaiters.indexOf(waiter);
@@ -1085,6 +1089,7 @@ var ModelRuntime = class {
         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 },
@@ -1185,7 +1190,7 @@ async function defaultSleep(delayMs, cancelToken) {
     throw new ModelStreamCancelled(cancelToken?.reason || "cancelled");
   }
   if (cancelToken === null) {
-    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    await new Promise((resolve2) => setTimeout(resolve2, delayMs));
   }
 }
 function errorMessage(error) {
@@ -1193,7 +1198,7 @@ function errorMessage(error) {
 }
 
 // ../../packages/core/agent-runtime/dist/system-prompt.js
-var TITLE = "You are laoHuangCode, a coding agent.";
+var TITLE = "You are a coding agent operating inside LaoHuang, the laohuang CLI harness.";
 var GENERAL_GUIDELINES = [
   "- Follow direct user instructions. Project instructions may provide additional guidance.",
   "- Inspect relevant files before changing them.",
@@ -1202,7 +1207,7 @@ var GENERAL_GUIDELINES = [
   "- Keep the final response concise and state what changed."
 ];
 var SECTION_ORDER = ["read", "write", "edit", "bash"];
-function buildSystemPrompt(registry) {
+function buildSystemPrompt(registry, options = {}) {
   const specsByName = new Map(registry.orderedSpecs.map((spec2) => [spec2.name, spec2]));
   const sections = SECTION_ORDER.map((name) => {
     const spec2 = specsByName.get(name);
@@ -1210,6 +1215,7 @@ function buildSystemPrompt(registry) {
     return `## ${name}
 ${body}`;
   });
+  const runtimeFacts = runtimeFactLines(options);
   return [
     TITLE,
     "",
@@ -1218,9 +1224,29 @@ ${body}`;
     "",
     "Tool guidelines:",
     "",
-    sections.join("\n\n")
+    sections.join("\n\n"),
+    ...runtimeFacts.length === 0 ? [] : ["", "Runtime facts:", ...runtimeFacts]
   ].join("\n");
 }
+function runtimeFactLines(options) {
+  const lines = [];
+  if (hasText(options.cliName)) {
+    lines.push(`- CLI: ${options.cliName}`);
+  }
+  if (hasText(options.cliVersion)) {
+    lines.push(`- CLI version: ${options.cliVersion}`);
+  }
+  if (hasText(options.provider) && hasText(options.model)) {
+    lines.push(`- Provider/model: ${options.provider}/${options.model}`);
+  }
+  if (hasText(options.promptCwd)) {
+    lines.push(`- Current working directory: ${options.promptCwd}`);
+  }
+  return lines;
+}
+function hasText(value) {
+  return value !== null && value !== void 0 && value.length > 0;
+}
 
 // ../../packages/context/project-instructions/dist/project-instructions.js
 import { createHash } from "node:crypto";
@@ -1236,7 +1262,7 @@ var WRAPPER_INTRO = "The following workspace instructions may be relevant to you
 var OMISSION_NOTICE = "[omitted to stay within the total instruction budget]";
 var TRUNCATION_NOTICE = "[truncated to stay within the total instruction budget]";
 var PER_FILE_CAP_NOTICE = "[truncated: file exceeds the per-file instruction cap]";
-var ProjectInstructionState = class {
+var ProjectInstructionState = class _ProjectInstructionState {
   records = /* @__PURE__ */ new Map();
   /** True when any instruction file from this directory scope was loaded. */
   hasScope(scope) {
@@ -1255,6 +1281,17 @@ var ProjectInstructionState = class {
   entry(displayPath) {
     return this.records.get(displayPath);
   }
+  /** Stable recovery snapshot of all loaded instruction records. */
+  snapshot() {
+    return [...this.records.values()];
+  }
+  static fromSnapshot(records) {
+    const state = new _ProjectInstructionState();
+    for (const record of records) {
+      state.record(record);
+    }
+    return state;
+  }
   get loadedPaths() {
     return [...this.records.keys()];
   }
@@ -1779,15 +1816,24 @@ var AgentStepRunner = class {
       modelRequests += 1;
       const requestId = modelRound === 1 && this.options.requestId !== null ? this.options.requestId : randomUUID3();
       this.options.onRequestId(requestId);
+      const candidateMessages = history.snapshot();
+      const prepared = this.options.contextGovernor === null || this.options.contextGovernor === void 0 ? { messages: candidateMessages } : await this.options.contextGovernor.prepare({
+        messages: candidateMessages,
+        tools: this.options.toolDefinitions,
+        provider: this.options.provider,
+        model: this.options.model
+      });
+      const requestMessages = [...prepared.messages];
       this.emit("model_request", {
         round: modelRound,
         request_id: requestId,
-        message_count: history.snapshot().length,
+        message_count: requestMessages.length,
         tool_rounds: toolRounds,
         model_requests: modelRequests,
-        total_tokens: totalTokens
+        total_tokens: totalTokens,
+        ...prepared.contextTokens === void 0 ? {} : { context_tokens: prepared.contextTokens },
+        ...prepared.contextWindow === void 0 ? {} : { context_window: prepared.contextWindow }
       });
-      const requestMessages = history.snapshot();
       let result;
       try {
         const modelRequestOpened = context?.modelRequestOpened;
@@ -1854,7 +1900,10 @@ Authentication failed for ${this.options.provider}. Run /login ${this.options.pr
         tool_rounds: toolRounds,
         model_requests: modelRequests
       });
-      if (!history.commitAssistant(result.message)) {
+      if (!history.commitAssistant(result.message, {
+        requestId,
+        finishReason: result.finishReason
+      })) {
         this.emit("model_response_aborted", {
           round: modelRound,
           request_id: requestId,
@@ -2003,11 +2052,13 @@ var HistoryCommitter = class {
   context;
   cancelToken;
   createCancelled;
+  conversationHistory;
   constructor(options) {
     this.messages = options.messages;
     this.context = options.context;
     this.cancelToken = options.cancelToken;
     this.createCancelled = options.createCancelled;
+    this.conversationHistory = options.conversationHistory ?? null;
   }
   commitInput(content) {
     const message = { role: "user", content };
@@ -2016,6 +2067,11 @@ var HistoryCommitter = class {
       return this.commitContextMessage((append, rollback) => commitInput.call(this.context, append, rollback), message);
     }
     this.raiseIfCancelled();
+    this.conversationHistory?.appendUser({
+      message,
+      inputEventIds: [],
+      source: "direct"
+    });
     this.messages.push(message);
     return true;
   }
@@ -2030,45 +2086,81 @@ var HistoryCommitter = class {
       return this.commitContextMessage((append, rollback) => commitPending.call(this.context, batch, append, rollback), message);
     }
     this.raiseIfCancelled();
+    this.conversationHistory?.appendUser({
+      message,
+      inputEventIds: [...batch.eventIds ?? []],
+      source: "pending"
+    });
     this.messages.push(message);
     return true;
   }
-  commitAssistant(message) {
+  commitAssistant(message, metadata) {
     const commitIfActive = this.context?.commitIfActive;
     if (typeof commitIfActive === "function") {
       return commitIfActive.call(this.context, () => {
+        if (message.role === "assistant" && metadata !== void 0) {
+          this.conversationHistory?.appendAssistant({
+            message,
+            requestId: metadata.requestId,
+            finishReason: metadata.finishReason
+          });
+        }
         this.messages.push(message);
       });
     }
     this.raiseIfCancelled();
+    if (message.role === "assistant" && metadata !== void 0) {
+      this.conversationHistory?.appendAssistant({
+        message,
+        requestId: metadata.requestId,
+        finishReason: metadata.finishReason
+      });
+    }
     this.messages.push(message);
     return true;
   }
   commitToolResults(toolCalls, toolResults) {
+    const messages = [];
     for (let index = 0; index < toolCalls.length; index += 1) {
       const call = toolCalls[index];
       const result = toolResults[index];
       if (call === void 0 || result === void 0) {
         continue;
       }
-      this.messages.push({
+      const message = {
         role: "tool-result",
         toolCallId: call.id,
         toolName: call.name,
         content: JSON.stringify(result),
         isError: result.ok !== true
-      });
+      };
+      messages.push(message);
+      this.messages.push(message);
     }
+    this.conversationHistory?.appendToolResults({
+      requestId: "tool-results",
+      messages,
+      recovered: false
+    });
   }
   commitReminder(content) {
     this.raiseIfCancelled();
-    this.messages.push({ role: "user", content });
+    const message = { role: "user", content };
+    this.conversationHistory?.appendReminder({ message, reason: "repeat_tool" });
+    this.messages.push(message);
   }
   snapshot() {
     return [...this.messages];
   }
   commitContextMessage(commit, message) {
     const append = () => {
+      if (message.role === "user") {
+        this.conversationHistory?.appendUser({
+          message,
+          inputEventIds: [],
+          source: "direct"
+        });
+      }
       this.messages.push(message);
     };
     const rollback = () => {
@@ -2129,6 +2221,8 @@ var CodingAgent = class {
   messages;
   onToolEvent;
   onAgentEvent;
+  cliName;
+  cliVersion;
   instructionRoot;
   startupCwd;
   baselineInstructionsLoaded = false;
@@ -2136,16 +2230,22 @@ var CodingAgent = class {
   turn = 0;
   activeContext = null;
   activeRequestId = null;
+  conversationHistory;
+  contextGovernor;
   constructor(options) {
     this.repeatToolReminderThresholds = normalizeReminderThresholds(options.repeatToolReminderThresholds ?? [3, 5, 8]);
     this.model = options.model;
     this.tools = options.tools;
     this.onToolEvent = options.onToolEvent ?? null;
     this.onAgentEvent = options.onAgentEvent ?? null;
+    this.cliName = options.cliName ?? null;
+    this.cliVersion = options.cliVersion ?? null;
     this.provider = options.provider;
     this.baseUrl = options.baseUrl ?? null;
     this.reasoningEffort = options.reasoningEffort ?? "high";
     this.adapter = options.modelAdapter;
+    this.conversationHistory = options.conversationHistory ?? null;
+    this.contextGovernor = options.contextGovernor ?? null;
     this.modelRuntime = new ModelRuntime(this.adapter);
     this.toolExecution = options.toolExecution ?? "parallel";
     this.toolRuntime = new ToolRuntime(this.tools, {
@@ -2153,7 +2253,12 @@ var CodingAgent = class {
     });
     this.instructionRoot = options.projectRoot == null ? null : realpathOrSelf(options.projectRoot);
     this.startupCwd = options.startupCwd == null ? null : realpathOrSelf(options.startupCwd);
-    this.messages = [{ role: "system", content: buildSystemPrompt(this.tools) }];
+    this.messages = [
+      {
+        role: "system",
+        content: this.buildSystemPrompt()
+      }
+    ];
   }
   /** Bookkeeping for loaded project instructions (never model-visible). */
   get projectInstructionState() {
@@ -2173,6 +2278,7 @@ var CodingAgent = class {
     this.provider = options.provider;
     this.model = options.model;
     this.baseUrl = options.baseUrl;
+    this.refreshSystemPrompt();
     this.emit("model_switched", {
       provider: options.provider,
       model: options.model,
@@ -2201,8 +2307,10 @@ var CodingAgent = class {
           messages: this.messages,
           context,
           cancelToken,
-          createCancelled: (message) => new AgentCancelled(message)
+          createCancelled: (message) => new AgentCancelled(message),
+          conversationHistory: this.conversationHistory
         }),
+        contextGovernor: this.contextGovernor,
         repeatToolPolicy: new RepeatToolPolicy(this.repeatToolReminderThresholds),
         userInput,
         context,
@@ -2250,6 +2358,11 @@ var CodingAgent = class {
       return;
     }
     raiseIfCancelled(cancelToken);
+    this.conversationHistory?.appendUser({
+      message: { role: "user", content: baseline.rendered },
+      inputEventIds: [],
+      source: "direct"
+    });
     this.messages.push({ role: "user", content: baseline.rendered });
   }
   /**
@@ -2288,8 +2401,32 @@ var CodingAgent = class {
     if (rendered === "") {
       return;
     }
+    this.conversationHistory?.appendUser({
+      message: { role: "user", content: rendered },
+      inputEventIds: [],
+      source: "direct"
+    });
     this.messages.push({ role: "user", content: rendered });
   }
+  buildSystemPrompt() {
+    return buildSystemPrompt(this.tools, {
+      cliName: this.cliName,
+      cliVersion: this.cliVersion,
+      provider: this.provider,
+      model: this.model,
+      promptCwd: this.startupCwd
+    });
+  }
+  refreshSystemPrompt() {
+    const first = this.messages[0];
+    if (first?.role !== "system") {
+      return;
+    }
+    this.messages[0] = {
+      role: "system",
+      content: this.buildSystemPrompt()
+    };
+  }
   // --- Events --------------------------------------------------------------------
   emit(eventType, payload) {
     const fullPayload = { turn: this.turn, ...payload };
@@ -2385,6 +2522,1273 @@ function normalizeReminderThresholds(values) {
   return [...unique].sort((left, right) => left - right);
 }
 
+// ../../packages/session/session-context/dist/conversation-history.js
+import { randomUUID as randomUUID4 } from "node:crypto";
+var ConversationHistory = class _ConversationHistory {
+  #journal;
+  #entries;
+  #staged = /* @__PURE__ */ new Map();
+  constructor(entries, journal) {
+    this.#entries = [...entries];
+    this.#journal = journal;
+  }
+  static fromReplay(replay, journal) {
+    const history = new _ConversationHistory(replay.items.filter((item) => item.kind === "entry"), journal);
+    for (const open of replay.openToolCalls) {
+      const entry = history.appendToolResults({
+        requestId: "recovered",
+        recovered: true,
+        messages: [{
+          role: "tool-result",
+          toolCallId: open.toolCallId,
+          toolName: open.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: open.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 = randomUUID4().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
+    });
+  }
+  appendCompaction(input) {
+    return this.append({
+      entryType: "compaction",
+      payload: input
+    });
+  }
+  entries() {
+    return [...this.#entries];
+  }
+  append(input) {
+    const entry = this.#journal.appendEntry(input);
+    this.#entries.push(entry);
+    return entry;
+  }
+};
+
+// ../../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;
+  }
+};
+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);
+    return {
+      messages: selected.map((item) => item.message),
+      sourceEntryIds: selected.map((item) => item.entryId),
+      activeCompactionId: activeCompaction?.id ?? null
+    };
+  }
+};
+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);
+      }
+    }
+  }
+  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;
+}
+function latestCompaction(entries) {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry.entryType === "compaction") {
+      return entry;
+    }
+  }
+  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 === "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 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");
+    }
+  }
+  if (expected.length > 0) {
+    throw new ContextBuildError(ownerEntryId ?? "unknown", "missing tool result");
+  }
+}
+
+// ../../packages/session/session-context/dist/token-estimator.js
+import { createHash as createHash2 } 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)) + BLOCK_OVERHEAD;
+  }
+  estimateText(text) {
+    return Math.ceil(Buffer.byteLength(text, "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"
+    };
+  }
+  estimateMessage(message) {
+    if (message.role === "system" || message.role === "user") {
+      return MESSAGE_OVERHEAD + BLOCK_OVERHEAD + this.estimateText(message.content);
+    }
+    if (message.role === "tool-result") {
+      return MESSAGE_OVERHEAD + BLOCK_OVERHEAD + this.estimateText(message.content);
+    }
+    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);
+  }
+};
+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 (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;
+  }
+  return value;
+}
+function messagesForEntries(entries) {
+  return entries.flatMap((entry) => {
+    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];
+    }
+    return [];
+  });
+}
+
+// ../../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;
+    }
+  }
+  if (retained.length === 0 && units.length > 0) {
+    retained.push(units.at(-1));
+  }
+  const retainedFirst = retained[0]?.entries[0]?.seq ?? Number.MAX_SAFE_INTEGER;
+  const summarized = units.filter((unit) => unit.entries[0].seq < retainedFirst);
+  return {
+    summarizedEntries: summarized.flatMap((unit) => unit.entries),
+    retainedEntries: retained.flatMap((unit) => unit.entries),
+    retainedFromSeq: retained[0]?.entries[0]?.seq ?? 1
+  };
+}
+function serializeConversation(entries) {
+  const lines = ["<conversation>"];
+  for (const entry of entries) {
+    lines.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") {
+          lines.push(`[assistant tool-call ${block.call.id} ${block.call.name}] ${JSON.stringify(block.call.arguments)}`);
+        } else {
+          lines.push(`[assistant ${block.type}] ${block.text}`);
+        }
+      }
+    } else if (entry.entryType === "tool_result") {
+      lines.push(`[tool-result ${entry.payload.message.toolCallId} ${entry.payload.message.toolName}] ${entry.payload.message.content}`);
+    } else if (entry.entryType === "user_message" || entry.entryType === "reminder" || entry.entryType === "project_instructions") {
+      lines.push(`[${entry.payload.message.role}] ${entry.payload.message.content}`);
+    }
+    lines.push("</entry>");
+  }
+  lines.push("</conversation>");
+  return lines.join("\n");
+}
+function semanticUnits(entries) {
+  const units = [];
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (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]);
+        }
+        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 messageForEntry(entry) {
+  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-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) {
+      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({
+      entries: input.entries,
+      retainTokens: calculated.retainTokens,
+      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 activeCompaction = [...input.entries].reverse().find((entry) => entry.entryType === "compaction");
+    const tokensBefore = this.#estimator.estimateMessages(this.#builder.build(input).messages) + this.#estimator.estimateTools(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;
+      }
+    }
+    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) {
+    return this.#estimator.measure({
+      messages: built.messages,
+      tools: input.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(input.tools)
+    }).totalTokens;
+  }
+};
+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/session/session-store/dist/schema.js
+var ENTRY_TYPES = /* @__PURE__ */ new Set([
+  "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_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";
+  }
+};
+function parseSessionHeader(value) {
+  const input = objectOf(value, "session header");
+  if (input["schemaVersion"] !== 1) {
+    throw new SessionSchemaError("unsupported session schema version");
+  }
+  if (input["type"] !== "session_header") {
+    throw new SessionSchemaError("invalid session header type");
+  }
+  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");
+  }
+  if (!ORIGINS.has(stringValue(input, "origin"))) {
+    throw new SessionSchemaError("invalid session origin");
+  }
+  if (input["parentSessionId"] !== void 0) {
+    requireString(input, "parentSessionId");
+  }
+  if (input["forkedFrom"] !== void 0) {
+    const forkedFrom = objectOf(input["forkedFrom"], "forkedFrom");
+    requireString(forkedFrom, "sessionId");
+    if (forkedFrom["seq"] !== void 0) {
+      requirePositiveInteger(forkedFrom, "seq");
+    }
+    if (forkedFrom["entryId"] !== void 0) {
+      requireString(forkedFrom, "entryId");
+    }
+    const mode = stringValue(forkedFrom, "mode");
+    if (mode !== "before" && mode !== "at" && mode !== "clone") {
+      throw new SessionSchemaError("invalid fork mode");
+    }
+  }
+  return input;
+}
+function parseSessionItem(value, expectedSessionId) {
+  const input = objectOf(value, "session item");
+  if (input["schemaVersion"] !== 1) {
+    throw new SessionSchemaError("unsupported session schema version");
+  }
+  const sessionId = requireString(input, "sessionId");
+  if (expectedSessionId !== void 0 && sessionId !== expectedSessionId) {
+    throw new SessionSchemaError("session id does not match header");
+  }
+  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");
+    }
+    objectOf(input["payload"], "entry payload");
+    return input;
+  }
+  if (kind === "record") {
+    const recordType = stringValue(input, "recordType");
+    if (!RECORD_TYPES.has(recordType)) {
+      throw new SessionSchemaError("invalid session record type");
+    }
+    objectOf(input["payload"], "record payload");
+    return input;
+  }
+  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`);
+  }
+  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`);
+  }
+  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`);
+  }
+  return value;
+}
+
+// ../../packages/session/session-store/dist/session-paths.js
+import { createHash as createHash3 } from "node:crypto";
+import { mkdirSync, realpathSync as realpathSync2 } from "node:fs";
+import { basename, join, resolve } from "node:path";
+function canonicalProjectRoot(projectRoot) {
+  try {
+    return realpathSync2.native(projectRoot);
+  } catch {
+    return resolve(projectRoot);
+  }
+}
+function projectKeyForRoot(projectRoot) {
+  const canonical = canonicalProjectRoot(projectRoot);
+  const digest = createHash3("sha256").update(canonical).digest("hex").slice(0, 12);
+  return `${sanitizePathPart(basename(canonical) || "project")}-${digest}`;
+}
+function ensureSessionDirectory(sessionsRoot, projectKey) {
+  const directory = join(sessionsRoot, projectKey);
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  return directory;
+}
+function sessionPathForHeader(sessionsRoot, projectKey, createdAt, sessionId) {
+  const safeCreatedAt = createdAt.replaceAll(":", "").replaceAll(".", "");
+  return join(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-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;
+  }
+};
+function readSessionFile(path5) {
+  const text = readFileSync(path5, "utf8");
+  const endsWithNewline = text.endsWith("\n");
+  const rawLines = text.split("\n");
+  if (endsWithNewline) {
+    rawLines.pop();
+  }
+  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;
+    }
+    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 {
+    header,
+    items,
+    lastSeq: previousSeq,
+    ignoredTornTail,
+    openToolCalls: findOpenToolCalls(items)
+  };
+}
+function parseLine(path5, line2, raw, parse) {
+  try {
+    return parse(JSON.parse(raw));
+  } catch (error) {
+    throw corrupt(path5, line2, error);
+  }
+}
+function corrupt(path5, line2, error) {
+  if (error instanceof SessionCorruptError) {
+    return error;
+  }
+  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);
+    }
+  }
+  return [...calls.values()];
+}
+
+// ../../packages/session/session-store/dist/session-journal.js
+import { closeSync as closeSync2, existsSync as existsSync2, fsyncSync, openSync as openSync2, readFileSync as readFileSync2, unlinkSync, writeSync } from "node:fs";
+import { randomUUID as randomUUID5 } from "node:crypto";
+var SessionJournalLockError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SessionJournalLockError";
+  }
+};
+var FileSessionJournal = class {
+  header;
+  path;
+  #fd;
+  #lockPath;
+  #nextSeq;
+  #closed = false;
+  constructor(input) {
+    this.header = input.header;
+    this.path = input.path;
+    this.#nextSeq = input.nextSeq;
+    this.#fd = input.fd;
+    this.#lockPath = `${input.path}.lock`;
+  }
+  get nextSeq() {
+    return this.#nextSeq;
+  }
+  appendEntry(input) {
+    const item = this.makeBase(input);
+    const entry = {
+      ...item,
+      kind: "entry",
+      entryType: input.entryType,
+      payload: input.payload
+    };
+    this.writeItem(entry);
+    if (entry.entryType === "compaction") {
+      this.flush();
+    }
+    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 record;
+  }
+  flush() {
+    if (!this.#closed) {
+      fsyncSync(this.#fd);
+    }
+  }
+  close() {
+    if (this.#closed) {
+      return;
+    }
+    this.flush();
+    closeSync2(this.#fd);
+    this.#closed = true;
+    if (existsSync2(this.#lockPath)) {
+      unlinkSync(this.#lockPath);
+    }
+  }
+  makeBase(input) {
+    return {
+      schemaVersion: 1,
+      sessionId: this.header.sessionId,
+      seq: this.#nextSeq,
+      id: randomUUID5().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 createSessionJournal(options) {
+  const header = options.header ?? makeHeader(options);
+  const path5 = options.path ?? sessionPathForHeader(options.sessionsRoot, header.projectKey, header.createdAt, header.sessionId);
+  const existing = existsSync2(path5);
+  const lockPath = `${path5}.lock`;
+  acquireLock(lockPath, header.sessionId);
+  try {
+    const fd = openSync2(path5, existing ? "a" : "wx", 384);
+    if (!existing) {
+      writeLine(fd, header);
+      fsyncSync(fd);
+      return new FileSessionJournal({ header, path: path5, nextSeq: 1, fd });
+    }
+    const replay = readSessionFile(path5);
+    return new FileSessionJournal({
+      header: replay.header,
+      path: path5,
+      nextSeq: replay.lastSeq + 1,
+      fd
+    });
+  } 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: randomUUID5().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 = openSync2(path5, "wx", 384);
+    writeLine(fd, { pid: process.pid, sessionId, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    closeSync2(fd);
+  } catch (error) {
+    if (!isLiveLock(path5)) {
+      releaseLock(path5);
+      const fd = openSync2(path5, "wx", 384);
+      writeLine(fd, { pid: process.pid, sessionId, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      closeSync2(fd);
+      return;
+    }
+    throw new SessionJournalLockError(`session journal is locked: ${path5}`);
+  }
+}
+function isLiveLock(path5) {
+  if (!existsSync2(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 (existsSync2(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/session/session-store/dist/session-manager.js
+import { existsSync as existsSync3, readdirSync, statSync as statSync2 } from "node:fs";
+import { join as join2 } 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/session/session-store/dist/session-manager.js
+var SessionManager = class {
+  #sessionsRoot;
+  #appVersion;
+  constructor(options) {
+    this.#sessionsRoot = options.sessionsRoot;
+    this.#appVersion = options.appVersion;
+  }
+  create(options) {
+    const journal = createSessionJournal({
+      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({
+      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({
+      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));
+    child.close();
+    return {
+      sessionId: child.header.sessionId,
+      path: child.path,
+      editorText: options.mode === "before" ? 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({
+      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));
+    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 (!existsSync3(this.#sessionsRoot)) {
+      return [];
+    }
+    const paths = [];
+    const visit = (directory) => {
+      for (const entry of readdirSync(directory)) {
+        const absolute = join2(directory, entry);
+        const stat = statSync2(absolute);
+        if (stat.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);
+    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 },
+      lastUserText: lastUserText(replay.items),
+      status: last?.kind === "record" && last.recordType === "session_closed" ? "closed" : existsSync3(`${path5}.lock`) ? "open" : "interrupted"
+    };
+  } catch {
+    return {
+      sessionId: path5,
+      path: path5,
+      createdAt: "",
+      updatedAt: "",
+      projectRoot: "",
+      cwd: "",
+      provider: "",
+      model: "",
+      origin: "import",
+      lastUserText: "",
+      status: "corrupt"
+    };
+  }
+}
+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 lastUserText(items) {
+  for (const item of [...items].reverse()) {
+    if (item.kind === "entry" && item.entryType === "user_message") {
+      return item.payload.message.content;
+    }
+  }
+  return "";
+}
+function copyEntries(journal, entries) {
+  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
+      }
+    };
+    journal.appendEntry(input);
+  }
+}
+function isEntry(item) {
+  return item.kind === "entry";
+}
+
+// ../../packages/session/session-store/dist/transcript-projector.js
+function projectTranscript(entries) {
+  const items = [];
+  for (const entry of entries) {
+    if (entry.entryType === "user_message") {
+      items.push({ kind: "user", text: entry.payload.message.content });
+    } else if (entry.entryType === "assistant_message") {
+      const text = 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,
+        ...reasoning === "" ? {} : { reasoning }
+      });
+    } else if (entry.entryType === "tool_result") {
+      items.push({
+        kind: "tool",
+        callId: entry.payload.message.toolCallId,
+        name: entry.payload.message.toolName,
+        subject: entry.payload.message.toolCallId,
+        result: entry.payload.message.content,
+        isError: entry.payload.message.isError
+      });
+    } else if (entry.entryType === "compaction") {
+      items.push({
+        kind: "notice",
+        text: "Conversation context was compacted.",
+        tone: "info"
+      });
+    }
+  }
+  return items;
+}
+
 // ../../packages/llm/llm-pi-ai/dist/adapter.js
 import { clampThinkingLevel, ModelsError } from "@earendil-works/pi-ai";
 import { builtinModels } from "@earendil-works/pi-ai/providers/all";
@@ -2811,6 +4215,7 @@ var PiAiAdapter = class {
     const options = {
       ...request.cancelToken === void 0 ? {} : { signal: request.cancelToken.signal },
       ...request.temperature === void 0 ? {} : { temperature: request.temperature },
+      ...request.maxOutputTokens === void 0 ? {} : { maxTokens: request.maxOutputTokens },
       ...request.timeoutMs === void 0 ? {} : { timeoutMs: request.timeoutMs },
       ...thinkingOption(model, request.reasoningEffort ?? "high"),
       maxRetries: 0
@@ -3273,10 +4678,10 @@ function errorMessage6(error) {
 }
 
 // ../../packages/storage/local-config/dist/config.js
-import { randomUUID as randomUUID4 } from "node:crypto";
-import { chmodSync, existsSync as existsSync2, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname, join } from "node:path";
+import { basename as basename2, dirname, join as join3 } from "node:path";
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -3288,7 +4693,7 @@ function expandUser(input) {
     return homedir();
   }
   if (input.startsWith("~/")) {
-    return join(homedir(), input.slice(2));
+    return join3(homedir(), input.slice(2));
   }
   return input;
 }
@@ -3298,8 +4703,8 @@ function defaultConfigPath(environ = process.env) {
     return expandUser(explicit);
   }
   const configHome = environ["XDG_CONFIG_HOME"];
-  const root = configHome ? expandUser(configHome) : join(homedir(), ".config");
-  return join(root, "laohuang", "config.json");
+  const root = configHome ? expandUser(configHome) : join3(homedir(), ".config");
+  return join3(root, "laohuang", "config.json");
 }
 var ConfigManager = class {
   path;
@@ -3373,7 +4778,7 @@ var ConfigManager = class {
     });
   }
   readDocument(options = {}) {
-    if (!existsSync2(this.path)) {
+    if (!existsSync4(this.path)) {
       if (options.optional) {
         return {};
       }
@@ -3381,7 +4786,7 @@ var ConfigManager = class {
     }
     let value;
     try {
-      value = JSON.parse(readFileSync(this.path, "utf8"));
+      value = JSON.parse(readFileSync3(this.path, "utf8"));
     } catch (error) {
       throw new Error(`Cannot read configuration: ${errorMessage7(error)}`);
     }
@@ -3393,9 +4798,9 @@ var ConfigManager = class {
   }
   writeDocument(document) {
     const parent = dirname(this.path);
-    mkdirSync(parent, { recursive: true, mode: 448 });
+    mkdirSync2(parent, { recursive: true, mode: 448 });
     const content = JSON.stringify(document, null, 2) + "\n";
-    const temporary = join(parent, `.${basename(this.path)}.${process.pid}.${randomUUID4()}.tmp`);
+    const temporary = join3(parent, `.${basename2(this.path)}.${process.pid}.${randomUUID6()}.tmp`);
     writeFileSync(temporary, content, { encoding: "utf8", mode: 384 });
     chmodSync(temporary, 384);
     renameSync(temporary, this.path);
@@ -3437,9 +4842,9 @@ function validateDocument(document) {
 }
 
 // ../../packages/storage/local-config/dist/credentials.js
-import { randomUUID as randomUUID5 } from "node:crypto";
-import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename as basename2, dirname as dirname2, join as join2 } from "node:path";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { chmodSync as chmodSync2, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename as basename3, dirname as dirname2, join as join4 } from "node:path";
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -3563,12 +4968,12 @@ var CredentialStore = class {
     await operation;
   }
   readDocument() {
-    if (!existsSync3(this.path)) {
+    if (!existsSync5(this.path)) {
       return { version: 2, providers: {} };
     }
     let document;
     try {
-      document = JSON.parse(readFileSync2(this.path, "utf8"));
+      document = JSON.parse(readFileSync4(this.path, "utf8"));
     } catch (error) {
       throw new Error(`Cannot read credentials: ${errorMessage8(error)}`);
     }
@@ -3594,8 +4999,8 @@ var CredentialStore = class {
   }
   writeDocument(document) {
     const parent = dirname2(this.path);
-    const parentExisted = existsSync3(parent);
-    mkdirSync2(parent, { recursive: true, mode: 448 });
+    const parentExisted = existsSync5(parent);
+    mkdirSync3(parent, { recursive: true, mode: 448 });
     if (!parentExisted) {
       chmodSync2(parent, 448);
     }
@@ -3603,7 +5008,7 @@ var CredentialStore = class {
       version: 2,
       providers: document.providers
     }, null, 2) + "\n";
-    const temporary = join2(parent, `.${basename2(this.path)}.${process.pid}.${randomUUID5()}.tmp`);
+    const temporary = join4(parent, `.${basename3(this.path)}.${process.pid}.${randomUUID7()}.tmp`);
     writeFileSync2(temporary, content, { encoding: "utf8", mode: 384 });
     chmodSync2(temporary, 384);
     renameSync2(temporary, this.path);
@@ -3618,9 +5023,9 @@ function normalizeStoredCredential(credential) {
 }
 
 // ../../packages/storage/local-config/dist/model-catalog-store.js
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { chmodSync as chmodSync3, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename3, dirname as dirname3, join as join3 } from "node:path";
+import { randomUUID as randomUUID8 } from "node:crypto";
+import { chmodSync as chmodSync3, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync as renameSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename4, dirname as dirname3, join as join5 } from "node:path";
 function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -3651,12 +5056,12 @@ var ModelCatalogStore = class {
     }
   }
   readDocument() {
-    if (!existsSync4(this.path)) {
+    if (!existsSync6(this.path)) {
       return { version: 1, providers: {} };
     }
     let document;
     try {
-      document = JSON.parse(readFileSync3(this.path, "utf8"));
+      document = JSON.parse(readFileSync5(this.path, "utf8"));
     } catch (error) {
       throw new Error(`Cannot read model catalog: ${errorMessage9(error)}`);
     }
@@ -3678,13 +5083,13 @@ var ModelCatalogStore = class {
   }
   writeDocument(document) {
     const parent = dirname3(this.path);
-    const parentExisted = existsSync4(parent);
-    mkdirSync3(parent, { recursive: true, mode: 448 });
+    const parentExisted = existsSync6(parent);
+    mkdirSync4(parent, { recursive: true, mode: 448 });
     if (!parentExisted) {
       chmodSync3(parent, 448);
     }
     const content = JSON.stringify(document, null, 2) + "\n";
-    const temporary = join3(parent, `.${basename3(this.path)}.${process.pid}.${randomUUID6()}.tmp`);
+    const temporary = join5(parent, `.${basename4(this.path)}.${process.pid}.${randomUUID8()}.tmp`);
     writeFileSync3(temporary, content, { encoding: "utf8", mode: 384 });
     chmodSync3(temporary, 384);
     renameSync3(temporary, this.path);
@@ -3725,7 +5130,7 @@ function normalizeEntry(providerId, entry) {
   return normalized;
 }
 
-// ../../packages/core/session-runtime/dist/core/task-lifecycle.js
+// ../../packages/session/session-runtime/dist/core/task-lifecycle.js
 var TaskState = {
   RunningModel: "running_model",
   RunningTools: "running_tools",
@@ -3982,7 +5387,7 @@ var TaskLifecycle = class {
   }
 };
 
-// ../../packages/core/session-runtime/dist/core/agent-turn-loop.js
+// ../../packages/session/session-runtime/dist/core/agent-turn-loop.js
 var AgentTurnLoop = class {
   lifecycle;
   bridge;
@@ -4047,7 +5452,7 @@ var AgentTurnLoop = class {
   }
 };
 
-// ../../packages/core/session-runtime/dist/core/human-intent-router.js
+// ../../packages/session/session-runtime/dist/core/human-intent-router.js
 function splitHumanCommand(text) {
   const tokens = [];
   let current = "";
@@ -4137,7 +5542,7 @@ function routeHumanIntent(intent, state) {
   }
 }
 
-// ../../packages/core/session-runtime/dist/routing.js
+// ../../packages/session/session-runtime/dist/routing.js
 function estimateTokens(text) {
   if (!text) {
     return 0;
@@ -4645,7 +6050,7 @@ ${content}`);
   return "Please handle all of these pending messages in one response:\n\n" + parts.join("\n\n");
 }
 
-// ../../packages/core/session-runtime/dist/core/queue-dispatcher.js
+// ../../packages/session/session-runtime/dist/core/queue-dispatcher.js
 var QueueDispatchStatus = {
   StartNow: "start_now",
   Pending: "pending",
@@ -4759,8 +6164,8 @@ function makeQueueDispatchResult(status, actionId2, options = {}) {
   };
 }
 
-// ../../packages/core/session-runtime/dist/session.js
-import { randomUUID as randomUUID7 } from "node:crypto";
+// ../../packages/session/session-runtime/dist/session.js
+import { randomUUID as randomUUID9 } from "node:crypto";
 var SessionState = {
   Idle: "idle",
   Running: "running",
@@ -4872,7 +6277,7 @@ var TaskContext = class {
   }
 };
 var AgentSession = class {
-  sessionId;
+  #sessionId;
   eventBus;
   taskLifecycle;
   taskRegistry;
@@ -4894,7 +6299,7 @@ var AgentSession = class {
   #idleWaiters = /* @__PURE__ */ new Set();
   #finalizePromise = null;
   constructor(runner, options = {}) {
-    this.sessionId = options.sessionId ?? randomUUID7().replaceAll("-", "");
+    this.#sessionId = options.sessionId ?? randomUUID9().replaceAll("-", "");
     this.eventBus = options.eventBus ?? new EventBus();
     this.taskRegistry = options.taskRegistry ?? new TaskRegistry();
     this.queueDispatcher = new QueueDispatcher();
@@ -4931,6 +6336,12 @@ var AgentSession = class {
       payload: {}
     });
   }
+  get sessionId() {
+    return this.#sessionId;
+  }
+  setSessionId(sessionId) {
+    this.#sessionId = sessionId;
+  }
   get state() {
     return this.#state;
   }
@@ -5198,20 +6609,20 @@ var AgentSession = class {
     if (timeoutMs !== void 0 && timeoutMs <= 0) {
       return Promise.resolve(false);
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let timer;
       const onIdle = () => {
         if (timer !== void 0) {
           clearTimeout(timer);
         }
         this.#idleWaiters.delete(onIdle);
-        resolve(true);
+        resolve2(true);
       };
       this.#idleWaiters.add(onIdle);
       if (timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.#idleWaiters.delete(onIdle);
-          resolve(false);
+          resolve2(false);
         }, timeoutMs);
         timer.unref();
       }
@@ -5326,7 +6737,7 @@ var AgentSession = class {
     });
   }
   startTask(content, inputEventId) {
-    const taskId = randomUUID7().replaceAll("-", "");
+    const taskId = randomUUID9().replaceAll("-", "");
     this.taskLifecycle.createTask(taskId, { correlationId: inputEventId });
     this.setIdle(false);
     this.setSessionState(SessionState.Running);
@@ -5525,13 +6936,108 @@ var AgentSession = class {
     if (value) {
       const waiters = [...this.#idleWaiters];
       this.#idleWaiters.clear();
-      for (const resolve of waiters) {
-        resolve();
+      for (const resolve2 of waiters) {
+        resolve2();
       }
     }
   }
 };
 
+// ../../packages/session/session-runtime/dist/session-recorder.js
+var SessionRecorder = class {
+  #journal;
+  #unsubscribe;
+  #projector = new EventProjector();
+  constructor(options) {
+    this.#journal = options.journal;
+    this.#unsubscribe = options.eventBus.subscribe((event) => {
+      this.recordEvent(event);
+    });
+  }
+  recordEvent(event) {
+    const records = [];
+    for (const record of this.recordsFor(event)) {
+      const journal = this.journal();
+      if (journal === null) {
+        continue;
+      }
+      records.push(journal.appendRecord(record));
+    }
+    return records;
+  }
+  async close() {
+    await this.#unsubscribe();
+  }
+  journal() {
+    return typeof this.#journal === "function" ? this.#journal() : this.#journal;
+  }
+  recordsFor(event) {
+    const payload = this.projectPayload(event);
+    const base = {
+      taskId: event.task_id ?? void 0,
+      turnId: event.correlation_id ?? void 0
+    };
+    const record = (recordType, extra = {}) => ({
+      ...base,
+      recordType,
+      payload: {
+        eventId: event.event_id,
+        eventKind: event.kind,
+        eventSequence: event.sequence,
+        ...payload,
+        ...extra
+      }
+    });
+    switch (event.kind) {
+      case EventKind.TaskStarted:
+        return [record("turn_started")];
+      case EventKind.TaskCompleted:
+        return [record("turn_finished", { status: "completed" })];
+      case EventKind.TaskFailed:
+        return [
+          record("error", { status: "failed" }),
+          record("turn_finished", { status: "failed" })
+        ];
+      case EventKind.TaskCancelled:
+        return [
+          record("cancelled"),
+          record("turn_finished", { status: "cancelled" })
+        ];
+      case EventKind.ModelRequestStarted:
+        return [record("model_request")];
+      case EventKind.ModelResponseCommitted:
+      case EventKind.ModelResponseSummary: {
+        const usage = payload["usage"];
+        return usage === void 0 ? [record("model_response")] : [record("model_response"), record("usage", { usage })];
+      }
+      case EventKind.ModelRequestFailed:
+      case EventKind.ModelResponseAborted:
+        return [record("error")];
+      case EventKind.ToolStarted:
+        return [record("tool_started")];
+      case EventKind.ToolFinished:
+        return [record("tool_finished")];
+      case EventKind.InputPending:
+      case EventKind.InputHeld:
+        return [record("queue_enqueued")];
+      case EventKind.ModelSwitched:
+        return [
+          record("provider_changed", { provider: payload["provider"] ?? null }),
+          record("model_changed", { model: payload["model"] ?? null })
+        ];
+      default:
+        return [];
+    }
+  }
+  projectPayload(event) {
+    const projected = this.#projector.project(event, "log").payload;
+    if (projected !== null && typeof projected === "object" && !Array.isArray(projected)) {
+      return projected;
+    }
+    return { value: projected };
+  }
+};
+
 // ../../packages/terminal/tui/dist/capabilities.js
 var DEFAULT_RUNTIME_CAPABILITIES = {
   streaming: true,
@@ -7387,7 +8893,9 @@ function createUIState() {
     model: "",
     totalTokens: 0,
     inputTokens: 0,
-    outputTokens: 0
+    outputTokens: 0,
+    contextTokens: 0,
+    contextWindow: 0
   };
 }
 function createUpdate(kind, fields = {}) {
@@ -7447,6 +8955,7 @@ var UIEventReducer = class _UIEventReducer {
     }
     if (kind === "model.request_started") {
       this.state.sessionState = "RUNNING_MODEL";
+      this.#updateContextUsage(payload);
       this.state.activeResponse = {
         requestId: correlationId,
         text: "",
@@ -7537,6 +9046,7 @@ var UIEventReducer = class _UIEventReducer {
     if (kind === "model.switched") {
       this.state.provider = String("provider" in payload ? payload.provider : this.state.provider);
       this.state.model = String("model" in payload ? payload.model : this.state.model);
+      this.#updateContextUsage(payload);
       return createUpdate(kind, { payload });
     }
     return null;
@@ -7549,6 +9059,14 @@ var UIEventReducer = class _UIEventReducer {
       this.state.heldCount = toInt(payload.held_count);
     }
   }
+  #updateContextUsage(payload) {
+    if ("context_tokens" in payload) {
+      this.state.contextTokens = toInt(payload.context_tokens);
+    }
+    if ("context_window" in payload) {
+      this.state.contextWindow = toInt(payload.context_window);
+    }
+  }
   static #kindOf(event) {
     const raw = "kind" in event ? event.kind : event.type ?? "";
     return String(unwrapValue(raw) ?? "");
@@ -7728,19 +9246,20 @@ var DisplayPolicy = class {
 
 // ../../packages/terminal/tui/dist/tui/transcript-store.js
 function createUserBlock(key, text) {
-  return { kind: "user", key, text, mutable: false };
+  return { kind: "user", key, text, mutable: false, revision: 0 };
 }
 function createAssistantBlock(key, text = "", mutable = true) {
-  return { kind: "assistant", key, text, mutable };
+  return { kind: "assistant", key, text, mutable, revision: 0 };
 }
 function createThinkingBlock(key, text = "", mutable = true) {
-  return { kind: "thinking", key, text, mutable };
+  return { kind: "thinking", key, text, mutable, revision: 0 };
 }
 function createToolBlock(key, fields) {
   return {
     kind: "tool",
     key,
     mutable: true,
+    revision: 0,
     name: redactToolText(fields.name),
     subject: redactToolText(fields.subject),
     status: fields.status,
@@ -7752,10 +9271,10 @@ function createToolBlock(key, fields) {
   };
 }
 function createNoticeBlock(key, text, tone = "info") {
-  return { kind: "notice", key, text, tone, mutable: false };
+  return { kind: "notice", key, text, tone, mutable: false, revision: 0 };
 }
 function createWelcomeBlock(title, details) {
-  return { kind: "welcome", key: "welcome", title, details, mutable: false };
+  return { kind: "welcome", key: "welcome", title, details, mutable: false, revision: 0 };
 }
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -7772,6 +9291,9 @@ function noticeTone(style) {
     return "dim";
   return "info";
 }
+function touchBlock(block) {
+  block.revision = (block.revision ?? 0) + 1;
+}
 var TranscriptStore = class {
   #blocks = [];
   #byCorrelation = /* @__PURE__ */ new Map();
@@ -7796,6 +9318,34 @@ var TranscriptStore = class {
     if (block.key)
       this.#byCorrelation.set(`${block.kind}:${block.key}`, block);
   }
+  replace(items) {
+    this.#blocks.splice(0);
+    this.#byCorrelation.clear();
+    this.#nextBlockId = 0;
+    for (const item of items) {
+      if (item.kind === "user") {
+        this.append(createUserBlock(this.newBlockId(), item.text));
+      } else if (item.kind === "assistant") {
+        if (item.reasoning !== void 0 && item.reasoning !== "") {
+          this.append(createThinkingBlock(this.newBlockId(), item.reasoning, false));
+        }
+        this.append(createAssistantBlock(this.newBlockId(), item.text, false));
+      } else if (item.kind === "tool") {
+        const block = createToolBlock(item.callId, {
+          name: item.name,
+          subject: item.subject,
+          status: item.isError ? "failed" : "completed",
+          expanded: this.#toolOutputExpanded
+        });
+        block.stdout = item.isError ? "" : item.result;
+        block.stderr = item.isError ? item.result : "";
+        block.mutable = false;
+        this.append(block);
+      } else {
+        this.append(createNoticeBlock(this.newBlockId(), item.text, item.tone));
+      }
+    }
+  }
   blockFor(kind, key) {
     const block = this.#byCorrelation.get(`${kind}:${key}`);
     if (block === void 0)
@@ -7815,14 +9365,18 @@ var TranscriptStore = class {
     if (kind === "model.text_delta") {
       this.freezeThinking();
       const item = this.#getOrCreateAssistant(correlationId);
-      if (item.mutable)
+      if (item.mutable) {
         item.text += update.text;
+        touchBlock(item);
+      }
       return;
     }
     if (kind === "model.reasoning_delta") {
       const item = this.#getOrCreateThinking(correlationId);
-      if (item.mutable)
+      if (item.mutable) {
         item.text += update.text;
+        touchBlock(item);
+      }
       return;
     }
     if (["model.response_committed", "model.response_aborted", "model.request_failed"].includes(kind)) {
@@ -7850,8 +9404,10 @@ var TranscriptStore = class {
       if (item?.kind === "tool") {
         if (update.stream === "stdout") {
           item.stdout = (item.stdout + this.#toolOutputRedactor.redact(correlationId, "stdout", update.text)).slice(-this.#toolBufferLimit);
+          touchBlock(item);
         } else if (update.stream === "stderr") {
           item.stderr = (item.stderr + this.#toolOutputRedactor.redact(correlationId, "stderr", update.text)).slice(-this.#toolBufferLimit);
+          touchBlock(item);
         }
       }
       return;
@@ -7862,6 +9418,7 @@ var TranscriptStore = class {
       item.exitCode = typeof update.payload.exit_code === "number" ? Math.trunc(update.payload.exit_code) : null;
       item.durationMs = typeof update.payload.duration_ms === "number" ? Math.trunc(update.payload.duration_ms) : null;
       item.mutable = false;
+      touchBlock(item);
       this.#toolOutputRedactor.clear(correlationId);
       return;
     }
@@ -7882,8 +9439,10 @@ var TranscriptStore = class {
   setToolOutputExpanded(expanded) {
     this.#toolOutputExpanded = expanded;
     for (const block of this.#blocks) {
-      if (block.kind === "tool")
+      if (block.kind === "tool" && block.expanded !== expanded) {
         block.expanded = expanded;
+        touchBlock(block);
+      }
     }
   }
   toolOutputExpanded() {
@@ -8042,13 +9601,11 @@ var Composer = class {
 // ../../packages/terminal/tui/dist/tui/components/status-line.js
 var StatusLine = class {
   #state;
-  #cwd;
   #provider;
   #model;
   #effort;
   constructor(options) {
     this.#state = options.state;
-    this.#cwd = options.cwd ?? null;
     this.#provider = options.provider ?? null;
     this.#model = options.model ?? null;
     this.#effort = options.effort ?? null;
@@ -8056,15 +9613,11 @@ var StatusLine = class {
   render(context) {
     const width = Math.max(1, context.width);
     const queue = this.#state.pendingCount || this.#state.heldCount ? `queue ${this.#state.pendingCount} pending / ${this.#state.heldCount} held` : null;
-    const tokens = this.#state.totalTokens ? `\u2191${this.#state.inputTokens} \u2193${this.#state.outputTokens}` : null;
-    const cwd = this.#cwd === null ? null : clippedCwd(this.#cwd);
+    const contextUsage = contextUsageLabel(this.#state.contextTokens, this.#state.contextWindow);
     const right = this.#rightLine();
-    let leftItems = [cwd, queue, tokens].filter((value) => value !== null);
-    if (!fits(leftItems, right, width) && cwd !== null) {
-      leftItems = leftItems.filter((value) => value !== cwd);
-    }
-    if (!fits(leftItems, right, width) && tokens !== null) {
-      leftItems = leftItems.filter((value) => value !== tokens);
+    let leftItems = [contextUsage, queue].filter((value) => value !== null);
+    if (!fits(leftItems, right, width) && queue !== null) {
+      leftItems = leftItems.filter((value) => value !== queue);
     }
     const left = metadataLine(leftItems);
     if (lineText(left).length === 0 && lineText(right).length === 0) {
@@ -8097,8 +9650,29 @@ var StatusLine = class {
     return line(...spans);
   }
 };
-function clippedCwd(path5) {
-  return path5.length <= 40 ? path5 : `\u2026${path5.slice(-39)}`;
+function contextUsageLabel(tokens, contextWindow) {
+  const window = normalizedCount(contextWindow);
+  if (window <= 0) {
+    return null;
+  }
+  const used = normalizedCount(tokens);
+  const percent = Math.max(0, Math.min(100, Math.floor(used / window * 100)));
+  return `context: ${percent}% (${formatCompactCount(used)}/${formatCompactCount(window)})`;
+}
+function normalizedCount(value) {
+  return Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
+}
+function formatCompactCount(value) {
+  if (value >= 1e6) {
+    return `${formatScaled(value / 1e6)}M`;
+  }
+  if (value >= 1e3) {
+    return `${formatScaled(value / 1e3)}K`;
+  }
+  return String(value);
+}
+function formatScaled(value) {
+  return value.toFixed(1).replace(/\.0$/u, "");
 }
 function metadataLine(items) {
   return line(...items.flatMap((value, index) => [
@@ -8177,8 +9751,7 @@ function renderBlocks(text, layoutWidth) {
       const fence = trimmed.slice(0, 3);
       index += 1;
       const codeStyle = {
-        foreground: "code",
-        background: "card"
+        foreground: "code"
       };
       const codeLines = [];
       while (index < lines.length) {
@@ -8424,7 +9997,7 @@ var INLINE_PATTERNS = [
   {
     // Inline code: no further parsing inside backticks.
     pattern: /`([^`]+)`/,
-    style: () => ({ foreground: "code", background: "card" })
+    style: () => ({ foreground: "code" })
   },
   {
     pattern: /\*\*([^*]+)\*\*/,
@@ -8790,12 +10363,17 @@ var Box = class {
     const child = this.#child.render({ ...context, width: Math.max(1, width - this.#paddingX * 2) });
     const blank = () => line(span(" ".repeat(width), backgroundStyle2(this.#background)));
     const lines = child.lines.map((value) => this.#renderLine(value, width));
+    const cursor = child.cursor === void 0 ? void 0 : {
+      row: child.cursor.row + this.#paddingY,
+      column: child.cursor.column + this.#paddingX
+    };
     return {
       lines: [
         ...Array.from({ length: this.#paddingY }, blank),
         ...lines,
         ...Array.from({ length: this.#paddingY }, blank)
-      ]
+      ],
+      ...cursor === void 0 ? {} : { cursor }
     };
   }
   invalidate() {
@@ -8826,7 +10404,7 @@ var ToolMessage = class {
     const subject = redactToolText(options.subject);
     const stdout = redactToolText(options.stdout);
     const stderr = redactToolText(options.stderr);
-    const tone = options.status === "running" ? { background: "tool_pending_bg", title: "accent" } : options.status === "completed" ? { background: "tool_success_bg", title: "success" } : { background: "tool_error_bg", title: "warning" };
+    const tone = options.status === "running" ? { title: "accent" } : options.status === "completed" ? { title: "success" } : { title: "warning" };
     const title = [{ text: `\u25CF ${name || "tool"}`, style: { foreground: tone.title } }];
     if (subject) {
       title.push({
@@ -8844,7 +10422,6 @@ var ToolMessage = class {
     ].filter(Boolean).join(" \xB7 ");
     const output = options.expanded ? [stderr && clip(stderr, 1200), stdout && clip(stdout, 1200)].filter(Boolean) : [];
     this.#content = new Box({
-      background: tone.background,
       child: new Text({
         spans: [...title, { text: `
 ${[metadata, ...output].join("\n")}` }]
@@ -9041,6 +10618,7 @@ function counterLine(label, value) {
 // ../../packages/terminal/tui/dist/tui/components/transcript.js
 var Transcript = class {
   #blocks;
+  #cache = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#blocks = options.blocks;
   }
@@ -9051,42 +10629,87 @@ var Transcript = class {
     const usableWidth = Math.max(12, context.width);
     const lines = [];
     let activeStart = null;
+    const seenKeys = /* @__PURE__ */ new Set();
     for (const block of this.#blocks) {
+      if (lines.length > 0) {
+        lines.push(plainLine(""));
+      }
       if (block.mutable && activeStart === null)
         activeStart = lines.length;
-      lines.push(...this.#renderBlock(block, { ...context, width: usableWidth }));
+      seenKeys.add(cacheKey(block));
+      lines.push(...this.#renderBlockCached(block, { ...context, width: usableWidth }));
+    }
+    for (const key of this.#cache.keys()) {
+      if (!seenKeys.has(key))
+        this.#cache.delete(key);
     }
     return { lines, activeStart };
   }
   invalidate() {
+    this.#cache.clear();
+  }
+  #renderBlockCached(block, context) {
+    const key = cacheKey(block);
+    const signature = blockSignature(block);
+    const cached = this.#cache.get(key);
+    if (cached !== void 0 && cached.width === context.width && cached.signature === signature) {
+      return cached.lines;
+    }
+    if (cached !== void 0 && cached.signature === signature) {
+      const lines2 = cached.component.render(context).lines;
+      this.#cache.set(key, {
+        ...cached,
+        width: context.width,
+        lines: lines2
+      });
+      return lines2;
+    }
+    const component = this.#createBlockComponent(block);
+    const lines = component.render(context).lines;
+    this.#cache.set(key, {
+      component,
+      width: context.width,
+      signature,
+      lines
+    });
+    return lines;
   }
-  #renderBlock(block, context) {
+  #createBlockComponent(block) {
     switch (block.kind) {
       case "assistant":
-        return new AssistantMessage(block).render(context).lines;
+        return new AssistantMessage(block);
       case "user":
-        return new UserMessage(block).render(context).lines;
+        return new UserMessage(block);
       case "thinking":
-        return new ThinkingMessage(block).render(context).lines;
+        return new ThinkingMessage(block);
       case "tool":
-        return new ToolMessage(block).render(context).lines;
+        return new ToolMessage(block);
       case "notice":
-        return new NoticeMessage(block).render(context).lines;
+        return new NoticeMessage(block);
       case "welcome":
-        return new WelcomeMessage(block).render(context).lines;
+        return new WelcomeMessage(block);
       case "help":
-        return new HelpView(block).render(context).lines;
+        return new HelpView(block);
       case "provider_list":
-        return new ProviderStatusView(block).render(context).lines;
+        return new ProviderStatusView(block);
       case "provider_detail":
-        return new ProviderDetailView(block.provider).render(context).lines;
+        return new ProviderDetailView(block.provider);
       case "queue_status":
-        return new QueueStatusView(block.queue).render(context).lines;
+        return new QueueStatusView(block.queue);
       default:
         return assertNever(block);
     }
   }
 };
+function cacheKey(block) {
+  return `${block.kind}:${block.key}`;
+}
+function blockSignature(block) {
+  if (block.revision !== void 0) {
+    return `revision:${block.revision}`;
+  }
+  return `content:${JSON.stringify(block)}`;
+}
 function assertNever(value) {
   throw new Error(`unknown transcript block: ${String(value)}`);
 }
@@ -9301,8 +10924,10 @@ var MainScreen = class {
       row: Math.max(0, dock.lines.length - 1),
       column: 0
     };
+    const dockGap = transcript.lines.length > 0 && dock.lines.length > 0 ? [plainLine("")] : [];
     const contentLines = [
       ...transcript.lines,
+      ...dockGap,
       ...dock.lines,
       ...completion.lines,
       ...status.lines
@@ -9310,7 +10935,7 @@ var MainScreen = class {
     return {
       lines: contentLines,
       cursor: {
-        row: transcript.lines.length + dockCursor.row,
+        row: transcript.lines.length + dockGap.length + dockCursor.row,
         column: Math.min(width - 1, dockCursor.column)
       },
       activeStart: transcript.activeStart ?? transcript.lines.length
@@ -9590,13 +11215,28 @@ var VStack = class {
   }
   render(context) {
     const lines = [];
+    let cursor;
+    let rowOffset = 0;
     for (const [index, child] of this.#children.entries()) {
       if (index > 0) {
-        lines.push(...Array.from({ length: this.#gap }, () => plainLine("")));
+        const gaps = Array.from({ length: this.#gap }, () => plainLine(""));
+        lines.push(...gaps);
+        rowOffset += gaps.length;
+      }
+      const rendered = child.render(context);
+      if (cursor === void 0 && rendered.cursor !== void 0) {
+        cursor = {
+          row: rowOffset + rendered.cursor.row,
+          column: rendered.cursor.column
+        };
       }
-      lines.push(...child.render(context).lines);
+      lines.push(...rendered.lines);
+      rowOffset += rendered.lines.length;
     }
-    return { lines };
+    return {
+      lines,
+      ...cursor === void 0 ? {} : { cursor }
+    };
   }
   invalidate() {
     for (const child of this.#children) {
@@ -9648,8 +11288,7 @@ var AuthDialog = class {
         gap: 1
       }),
       paddingX: 2,
-      paddingY: 1,
-      background: "card"
+      paddingY: 1
     }).render(context);
   }
   handleInput(event) {
@@ -9778,7 +11417,7 @@ var ModelSelectorView = class {
       this.#selectList.setSelectedValue(options.currentValue);
     }
     this.#searchInput = new SearchInput({
-      placeholder: "Search models",
+      placeholder: options.searchPlaceholder ?? "Search models",
       onChange: (value) => this.#filterModels(value)
     });
     this.#syncFocus();
@@ -9841,19 +11480,19 @@ var ViewHost = class {
     this.#overlays = overlays;
   }
   openSelection(request) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const component = this.#selectionComponent(request);
-      this.#open({ id: request.id, component, resolve }, "selector");
+      this.#open({ id: request.id, component, resolve: resolve2 }, "selector");
     });
   }
   openPrompt(request) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const component = new AuthDialog({
         request,
         onSubmit: (value) => this.#close(request.id, value),
         onCancel: () => this.#close(request.id, null)
       });
-      this.#open({ id: request.id, component, resolve }, "modal");
+      this.#open({ id: request.id, component, resolve: resolve2 }, "modal");
     });
   }
   handleInput(event) {
@@ -10328,8 +11967,8 @@ var InteractiveTerminalLoop = class {
       this.#wakeupEnabled = true;
       try {
         if (!this.#exitRequested) {
-          await new Promise((resolve) => {
-            this.#exitResolve = resolve;
+          await new Promise((resolve2) => {
+            this.#exitResolve = resolve2;
           });
         }
       } finally {
@@ -10519,7 +12158,7 @@ var InteractiveTerminalLoop = class {
     } else if (action === "submit_follow_up") {
       this.#applyFollowUpSubmit();
     } else if (action === "dismiss") {
-      this.#applyEditorAction(inputAction(InputActionKind.Dismiss));
+      this.#applyDismissAction();
     } else if (action === "cancel") {
       this.#applyEditorAction(inputAction(InputActionKind.Cancel));
     } else if (action === "toggle_tool_output") {
@@ -10530,6 +12169,18 @@ var InteractiveTerminalLoop = class {
       this.#needsRender = true;
     }
   }
+  #applyDismissAction() {
+    if (this.#applyCompletionAction(inputAction(InputActionKind.Dismiss))) {
+      this.#needsRender = true;
+      return;
+    }
+    if (this.#ui.isRunning()) {
+      this.#ui.cancelFromKeybinding();
+      this.#needsRender = true;
+      return;
+    }
+    this.#applyEditorAction(inputAction(InputActionKind.Dismiss));
+  }
   #applyFollowUpSubmit() {
     if (this.#applyCompletionAction(inputAction(InputActionKind.Submit))) {
       this.#needsRender = true;
@@ -10643,18 +12294,18 @@ var InteractiveTerminalLoop = class {
     if (this.#closed || !this.#running) {
       return Promise.resolve(null);
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       if (type === "open_selection") {
         this.#work.push({
           type,
           request,
-          resolve
+          resolve: resolve2
         });
       } else {
         this.#work.push({
           type,
           request,
-          resolve
+          resolve: resolve2
         });
       }
       this.#scheduleWakeup();
@@ -10678,6 +12329,9 @@ function resolveFallbackMarkdownWidth() {
   const columns = process.stdout?.columns;
   return typeof columns === "number" && columns > 0 ? columns : FALLBACK_MARKDOWN_WIDTH;
 }
+function normalizePositiveInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
 var TerminalUI = class {
   theme;
   state;
@@ -10697,6 +12351,7 @@ var TerminalUI = class {
   #askFallback;
   #loop = null;
   #transcript;
+  #transcriptView;
   #showReasoning = true;
   #displayPolicy = new DisplayPolicy({
     audience: "terminal",
@@ -10724,10 +12379,14 @@ var TerminalUI = class {
     this.state = createUIState();
     this.state.provider = options.provider ?? "";
     this.state.model = options.model ?? "";
+    this.state.contextWindow = normalizePositiveInteger(options.contextWindow);
     this.reducer = new UIEventReducer(this.state);
     this.#transcript = new TranscriptStore({
       errorStyle: `bold ${this.theme.color("error")}`
     });
+    this.#transcriptView = new Transcript({
+      blocks: this.#transcript.blocks()
+    });
     this.#frameBuilder = new FrameBuilder({
       state: this.state,
       transcript: this.#transcript,
@@ -10824,6 +12483,21 @@ var TerminalUI = class {
     this.#sessionId = sessionId;
     this.#loop?.requestRender();
   }
+  replaceTranscript(items) {
+    this.#transcript.replace(items);
+    this.#transcriptView.invalidate();
+    this.#loop?.requestRender();
+  }
+  setComposerText(text) {
+    const editor = this.#loop?.editor;
+    if (editor === void 0) {
+      return;
+    }
+    editor.text = text;
+    editor.cursor = text.length;
+    editor.setCompletions([]);
+    this.#loop?.requestRender();
+  }
   setKeyActionCallback(callback) {
     this.#keyActionCallback = callback;
   }
@@ -10935,9 +12609,7 @@ var TerminalUI = class {
     return this.#buildHistoryFrameParts(width).lines;
   }
   #buildHistoryFrameParts(width) {
-    const rendered = new Transcript({
-      blocks: this.#transcript.blocks()
-    }).renderWithMetadata({ width, theme: this.theme });
+    const rendered = this.#transcriptView.renderWithMetadata({ width, theme: this.theme });
     return {
       lines: compileStyledLines(rendered.lines, Math.max(12, width), this.theme),
       activeStart: rendered.activeStart
@@ -10951,7 +12623,7 @@ var TerminalUI = class {
       theme: this.theme
     });
     const rendered = new MainScreen({
-      transcript: new Transcript({ blocks: this.#transcript.blocks() }),
+      transcript: this.#transcriptView,
       composer: new Composer({
         editor,
         prompt: options.prompt ?? "> ",
@@ -11248,7 +12920,7 @@ var StdTerminalDriver = class {
 
 // ../../packages/fs/tool-fs/dist/file-tools.js
 import { promises as fs } from "node:fs";
-import { realpathSync as realpathSync2 } from "node:fs";
+import { realpathSync as realpathSync3 } from "node:fs";
 import path3 from "node:path";
 var DEFAULT_IO = {
   readFile: (target) => fs.readFile(target, "utf8"),
@@ -11437,8 +13109,8 @@ async function executeEdit(args, execution, resolvePath2, io) {
 async function withFileMutationLock(key, fn) {
   const previous = mutationLocks.get(key) ?? Promise.resolve();
   let release;
-  const current = new Promise((resolve) => {
-    release = resolve;
+  const current = new Promise((resolve2) => {
+    release = resolve2;
   });
   const tail = previous.then(() => current);
   mutationLocks.set(key, tail);
@@ -11477,7 +13149,7 @@ function resolveNonStrictSync(pathname) {
   let current = pathname;
   for (; ; ) {
     try {
-      const real = realpathSync2(current);
+      const real = realpathSync3(current);
       return missing.length === 0 ? real : path3.join(real, ...missing.reverse());
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -11523,7 +13195,7 @@ function editsArgument(args) {
 
 // ../../packages/shell/tool-bash/dist/tool-bash.js
 import { promises as fs2 } from "node:fs";
-import { realpathSync as realpathSync3 } from "node:fs";
+import { realpathSync as realpathSync4 } from "node:fs";
 import path4 from "node:path";
 
 // ../../packages/shell/bash-local/dist/bash-runner.js
@@ -11730,7 +13402,7 @@ var TerminalSanitizer = class {
   }
 };
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function errnoCode(error) {
   return error?.code;
@@ -11807,9 +13479,9 @@ async function runBash(command, options) {
     stdio: ["ignore", "pipe", "pipe"],
     detached: true
   });
-  const spawnError = await new Promise((resolve) => {
-    child.once("spawn", () => resolve(null));
-    child.once("error", (error) => resolve(error));
+  const spawnError = await new Promise((resolve2) => {
+    child.once("spawn", () => resolve2(null));
+    child.once("error", (error) => resolve2(error));
   });
   if (spawnError) {
     const result2 = new BashResult({
@@ -11866,8 +13538,8 @@ async function runBash(command, options) {
   };
   const stdoutDone = readPipe("stdout", child.stdout);
   const stderrDone = readPipe("stderr", child.stderr);
-  const exitInfo = new Promise((resolve) => {
-    child.once("exit", (code2, signal2) => resolve({ code: code2, signal: signal2 }));
+  const exitInfo = new Promise((resolve2) => {
+    child.once("exit", (code2, signal2) => resolve2({ code: code2, signal: signal2 }));
   });
   let terminalStatus = null;
   const startedAt = performance.now();
@@ -12045,7 +13717,7 @@ function resolveNonStrictSync2(pathname) {
   let current = pathname;
   for (; ; ) {
     try {
-      const real = realpathSync3(current);
+      const real = realpathSync4(current);
       return missing.length === 0 ? real : path4.join(real, ...missing.reverse());
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -12282,6 +13954,63 @@ var tones = {
 function errorMessage10(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function sessionDisplayTitle(session) {
+  const title = cleanSingleLine(session.title);
+  if (title !== "") {
+    return title;
+  }
+  const lastUserText2 = cleanSingleLine(session.lastUserText);
+  return lastUserText2 === "" ? "Untitled session" : lastUserText2;
+}
+function sessionDisplayDescription(session, options) {
+  const displayPath = displayPathFor(session.cwd ?? session.projectRoot ?? "", options.homeDirectory);
+  const updated = relativeTimeLabel(session.updatedAt, options.now);
+  return displayPath === "" ? updated : `${updated}  ${displayPath}`;
+}
+function cleanSingleLine(value) {
+  return value?.replace(/\s+/g, " ").trim() ?? "";
+}
+function displayPathFor(path5, homeDirectory) {
+  if (path5 === "" || homeDirectory === null || homeDirectory === "") {
+    return path5;
+  }
+  const home = homeDirectory.endsWith("/") ? homeDirectory.slice(0, -1) : homeDirectory;
+  if (path5 === home) {
+    return "~";
+  }
+  return path5.startsWith(`${home}/`) ? `~/${path5.slice(home.length + 1)}` : path5;
+}
+function relativeTimeLabel(updatedAt, now) {
+  const updated = new Date(updatedAt);
+  const timestamp = updated.getTime();
+  if (!Number.isFinite(timestamp)) {
+    return updatedAt;
+  }
+  const elapsedMs = Math.max(0, now.getTime() - timestamp);
+  const elapsedSeconds = Math.floor(elapsedMs / 1e3);
+  if (elapsedSeconds < 60) {
+    return "just now";
+  }
+  const elapsedMinutes = Math.floor(elapsedSeconds / 60);
+  if (elapsedMinutes < 60) {
+    return `${elapsedMinutes} ${elapsedMinutes === 1 ? "minute" : "minutes"} ago`;
+  }
+  const elapsedHours = Math.floor(elapsedMinutes / 60);
+  if (elapsedHours < 24) {
+    return `${elapsedHours} ${elapsedHours === 1 ? "hour" : "hours"} ago`;
+  }
+  const elapsedDays = Math.floor(elapsedHours / 24);
+  if (elapsedDays === 1) {
+    return `yesterday ${twoDigits(updated.getHours())}:${twoDigits(updated.getMinutes())}`;
+  }
+  if (elapsedDays < 365) {
+    return `${twoDigits(updated.getMonth() + 1)}-${twoDigits(updated.getDate())} ${twoDigits(updated.getHours())}:${twoDigits(updated.getMinutes())}`;
+  }
+  return `${updated.getFullYear()}-${twoDigits(updated.getMonth() + 1)}-${twoDigits(updated.getDate())} ${twoDigits(updated.getHours())}:${twoDigits(updated.getMinutes())}`;
+}
+function twoDigits(value) {
+  return value.toString().padStart(2, "0");
+}
 var SessionCommands = class {
   registry;
   #agent;
@@ -12290,7 +14019,12 @@ var SessionCommands = class {
   #providerAuth;
   #presenter;
   #session;
+  #sessionController;
   #onModelSelected;
+  #onComposerText;
+  #onSessionChanged;
+  #homeDirectory;
+  #now;
   #currentConfig;
   constructor(options) {
     this.#agent = options.agent;
@@ -12300,7 +14034,12 @@ var SessionCommands = class {
     this.#currentConfig = options.currentConfig;
     this.#presenter = options.presenter;
     this.#session = options.session ?? null;
+    this.#sessionController = options.sessionController ?? null;
     this.#onModelSelected = options.onModelSelected ?? null;
+    this.#onComposerText = options.onComposerText ?? null;
+    this.#onSessionChanged = options.onSessionChanged ?? null;
+    this.#homeDirectory = options.homeDirectory ?? null;
+    this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.registry = new CommandRegistry([
       {
         name: "/model",
@@ -12365,10 +14104,53 @@ var SessionCommands = class {
         argumentCompleter: queueCompletions
       },
       {
-        name: "/clear",
-        description: "\u6E05\u7A7A\u5F53\u524D\u5BF9\u8BDD\u4E0A\u4E0B\u6587",
-        usage: "/clear",
-        handler: (args) => this.handleClear(args),
+        name: "/new",
+        description: "\u521B\u5EFA\u65B0\u4F1A\u8BDD",
+        usage: "/new",
+        handler: (args) => this.handleNew(args),
+        allowedStates: IDLE_ONLY
+      },
+      {
+        name: "/session",
+        description: "\u67E5\u770B\u5F53\u524D\u4F1A\u8BDD",
+        usage: "/session",
+        handler: (args) => this.handleSession(args),
+        allowedStates: ALL_STATES
+      },
+      {
+        name: "/sessions",
+        description: "\u5217\u51FA\u5F53\u524D\u9879\u76EE\u4F1A\u8BDD",
+        usage: "/sessions",
+        handler: (args) => this.handleSessions(args),
+        allowedStates: ALL_STATES
+      },
+      {
+        name: "/resume",
+        description: "\u9009\u62E9\u6216\u6062\u590D\u6307\u5B9A\u4F1A\u8BDD",
+        usage: "/resume [session-id]",
+        handler: (args) => this.handleResume(args),
+        allowedStates: IDLE_ONLY,
+        argumentCompleter: (args) => this.resumeCompletions(args)
+      },
+      {
+        name: "/fork",
+        description: "\u4ECE\u7528\u6237\u6D88\u606F\u5206\u53C9\u4F1A\u8BDD",
+        usage: "/fork <entry-id> [before|at]",
+        handler: (args) => this.handleFork(args),
+        allowedStates: IDLE_ONLY
+      },
+      {
+        name: "/clone",
+        description: "\u514B\u9686\u5F53\u524D\u4F1A\u8BDD",
+        usage: "/clone",
+        handler: (args) => this.handleClone(args),
+        allowedStates: IDLE_ONLY
+      },
+      {
+        name: "/compact",
+        description: "\u624B\u52A8\u538B\u7F29\u5F53\u524D\u4E0A\u4E0B\u6587",
+        usage: "/compact",
+        handler: (args) => this.handleCompact(args),
         allowedStates: IDLE_ONLY
       },
       {
@@ -12489,18 +14271,149 @@ var SessionCommands = class {
     });
     return true;
   }
-  handleClear(args) {
+  handleSession(args) {
+    if (args.length > 0) {
+      this.notice("Usage: /session", tones.invalid);
+      return true;
+    }
+    const controller = this.#sessionController;
+    if (controller === null || controller.currentSessionId === null) {
+      this.notice("No active session.", "warning");
+      return true;
+    }
+    this.notice(
+      `Current session: ${controller.currentSessionId}
+Path: ${controller.currentPath ?? ""}`,
+      "info"
+    );
+    return true;
+  }
+  async handleNew(args) {
+    if (args.length > 0) {
+      this.notice("Usage: /new", tones.invalid);
+      return true;
+    }
+    const controller = this.#sessionController;
+    if (controller === null) {
+      this.notice("Session creation is unavailable.", "error");
+      return true;
+    }
+    await controller.createNew();
+    await this.#onSessionChanged?.();
+    this.notice("Started a new session.", tones.switched);
+    return true;
+  }
+  handleSessions(args) {
+    if (args.length > 0) {
+      this.notice("Usage: /sessions", tones.invalid);
+      return true;
+    }
+    const sessions = this.#sessionController?.list() ?? [];
+    if (sessions.length === 0) {
+      this.notice("No sessions for this project.", "info");
+      return true;
+    }
+    const now = this.#now();
+    for (const session of sessions) {
+      this.notice(
+        `${sessionDisplayTitle(session)}
+${sessionDisplayDescription(session, {
+          homeDirectory: this.#homeDirectory,
+          now
+        })}`,
+        "info"
+      );
+    }
+    return true;
+  }
+  async handleResume(args) {
+    if (args.length > 1) {
+      this.notice("Usage: /resume [session-id]", tones.invalid);
+      return true;
+    }
+    const controller = this.#sessionController;
+    if (controller === null) {
+      this.notice("Session resume is unavailable.", "error");
+      return true;
+    }
+    let sessionId = args[0];
+    if (sessionId === void 0) {
+      const sessions = controller.list();
+      if (sessions.length === 0) {
+        this.notice("No sessions for this project.", "info");
+        return true;
+      }
+      const now = this.#now();
+      sessionId = await this.#presenter.select({
+        id: "session-resume",
+        title: "Resume session",
+        items: sessions.map((session) => ({
+          value: session.sessionId,
+          label: sessionDisplayTitle(session),
+          description: sessionDisplayDescription(session, {
+            homeDirectory: this.#homeDirectory,
+            now
+          })
+        })),
+        currentValue: controller.currentSessionId ?? void 0,
+        searchable: true,
+        searchPlaceholder: "Search sessions",
+        maxVisible: 20
+      }) ?? void 0;
+      if (sessionId === void 0) {
+        return true;
+      }
+    }
+    await controller.resume(sessionId);
+    await this.#onSessionChanged?.();
+    this.notice("Resumed session.", tones.switched);
+    return true;
+  }
+  async handleFork(args) {
+    if (args.length < 1 || args.length > 2 || args[1] !== void 0 && args[1] !== "before" && args[1] !== "at") {
+      this.notice("Usage: /fork <entry-id> [before|at]", tones.invalid);
+      return true;
+    }
+    const controller = this.#sessionController;
+    if (controller === null) {
+      this.notice("Session fork is unavailable.", "error");
+      return true;
+    }
+    const result = await controller.fork(args[0], args[1] ?? "before");
+    await this.#onSessionChanged?.();
+    if (result.editorText !== "") {
+      this.#onComposerText?.(result.editorText);
+    }
+    this.notice(`Forked session ${result.sessionId}.`, tones.switched);
+    return true;
+  }
+  async handleClone(args) {
     if (args.length > 0) {
-      this.notice("Usage: /clear", tones.invalid);
+      this.notice("Usage: /clone", tones.invalid);
       return true;
     }
-    const clear = this.#agent.clearHistory;
-    if (typeof clear === "function") {
-      clear.call(this.#agent);
-    } else if (this.#agent.messages !== void 0 && this.#agent.messages.length > 0) {
-      this.#agent.messages.splice(1);
+    const controller = this.#sessionController;
+    if (controller === null) {
+      this.notice("Session clone is unavailable.", "error");
+      return true;
+    }
+    const result = await controller.clone();
+    await this.#onSessionChanged?.();
+    this.notice(`Cloned session ${result.sessionId}.`, tones.switched);
+    return true;
+  }
+  async handleCompact(args) {
+    if (args.length > 0) {
+      this.notice("Usage: /compact", tones.invalid);
+      return true;
+    }
+    if (this.#sessionController === null) {
+      this.notice("Session compaction is unavailable.", "error");
+      return true;
     }
-    this.notice("Conversation cleared.", tones.cleared);
+    await this.#sessionController.compact();
+    await this.#onSessionChanged?.();
+    this.notice("Compacted current session.", tones.switched);
     return true;
   }
   async handleModel(args) {
@@ -12796,6 +14709,10 @@ var SessionCommands = class {
       payload: {
         provider: this.#currentConfig.provider,
         model: this.#currentConfig.model,
+        context_window: this.#catalog.getModel(
+          this.#currentConfig.provider,
+          this.#currentConfig.model
+        )?.contextWindow ?? 0,
         previous_provider: previousProvider,
         previous_model: previousModel
       }
@@ -12881,6 +14798,15 @@ var SessionCommands = class {
       yield [effort, effort === "off" ? "\u5173\u95ED\u601D\u8003" : "\u8BBE\u7F6E\u601D\u8003\u7B49\u7EA7"];
     }
   }
+  *resumeCompletions(args) {
+    if (args.length > 0) {
+      return;
+    }
+    for (const session of this.#sessionController?.list() ?? []) {
+      const description = session.lastUserText === void 0 || session.lastUserText === "" ? session.updatedAt : `${session.updatedAt}  ${session.lastUserText}`;
+      yield [session.sessionId, description];
+    }
+  }
   currentReasoningEffort() {
     return this.#agent.getReasoningEffort?.() ?? "high";
   }
@@ -13325,7 +15251,7 @@ var TerminalCommandPresenter = class {
 // src/args.ts
 var CliUsageError = class extends Error {
 };
-var USAGE = "usage: laohuang [--version] [--profile PROFILE] [--model MODEL] [--base-url BASE_URL] [--theme {auto,dark,light}] [config ...] [doctor]";
+var USAGE = "usage: laohuang [--version] [--profile PROFILE] [--model MODEL] [--base-url BASE_URL] [--theme {auto,dark,light}] [--continue | --resume SESSION_ID] [config ...] [doctor]";
 var HELP = `${USAGE}
 
 A minimal coding agent
@@ -13337,6 +15263,8 @@ options:
   --model MODEL      model override for this session
   --base-url URL     API base URL override for this session
   --theme THEME      interactive terminal theme: auto, dark, light (default: auto)
+  --continue         resume the latest session for this project
+  --resume ID        resume a specific session id
 
 subcommands:
   config [set|list|use] [target] [--profile P] [--provider P] [--model M] [--base-url U]
@@ -13362,7 +15290,9 @@ function parseArgs(argv) {
     configProfile: "default",
     provider: null,
     configModel: null,
-    configBaseUrl: null
+    configBaseUrl: null,
+    continueSession: false,
+    resumeSessionId: null
   };
   let index = 0;
   const takeValue = (option, inline) => {
@@ -13409,10 +15339,19 @@ function parseArgs(argv) {
         args.theme = theme;
         break;
       }
+      case "--continue":
+        args.continueSession = true;
+        break;
+      case "--resume":
+        args.resumeSessionId = takeValue(name, inline);
+        break;
       default:
         throw new CliUsageError(`unrecognized arguments: ${token}`);
     }
   }
+  if (args.continueSession && args.resumeSessionId !== null) {
+    throw new CliUsageError("--continue and --resume cannot be used together");
+  }
   if (args.command === "config") {
     const positionals = [];
     for (; index < argv.length; index += 1) {
@@ -13471,6 +15410,130 @@ function parseArgs(argv) {
   return { kind: "run", args };
 }
 
+// src/session-controller.ts
+var SessionController = class {
+  #manager;
+  #projectRoot;
+  #initialCwd;
+  #provider;
+  #model;
+  #reasoningEffort;
+  #sessionsRoot;
+  #compactor = null;
+  #opened = null;
+  #history = null;
+  presentationEventBus = new EventBus();
+  constructor(options) {
+    this.#sessionsRoot = options.sessionsRoot;
+    this.#manager = new SessionManager({
+      sessionsRoot: options.sessionsRoot,
+      appVersion: options.appVersion
+    });
+    this.#projectRoot = canonicalProjectRoot(options.projectRoot);
+    this.#initialCwd = options.initialCwd;
+    this.#provider = options.provider;
+    this.#model = options.model;
+    this.#reasoningEffort = options.reasoningEffort;
+  }
+  get sessionsRoot() {
+    return this.#sessionsRoot;
+  }
+  get currentSessionId() {
+    return this.#opened?.header.sessionId ?? null;
+  }
+  get currentPath() {
+    return this.#opened?.journal.path ?? null;
+  }
+  get history() {
+    return this.#history;
+  }
+  get currentJournal() {
+    return this.#opened?.journal ?? null;
+  }
+  async createNew() {
+    await this.close();
+    this.#opened = this.#manager.create({
+      projectRoot: this.#projectRoot,
+      initialCwd: this.#initialCwd,
+      provider: this.#provider,
+      model: this.#model,
+      reasoningEffort: this.#reasoningEffort
+    });
+    this.#history = ConversationHistory.fromReplay(
+      this.#opened.replay,
+      this.#opened.journal
+    );
+  }
+  async resume(sessionId) {
+    await this.close();
+    const opened = this.#manager.open(sessionId);
+    if (opened.header.projectRoot !== this.#projectRoot) {
+      opened.journal.close();
+      throw new Error("project root mismatch for resumed session");
+    }
+    this.#opened = opened;
+    this.#history = ConversationHistory.fromReplay(opened.replay, opened.journal);
+  }
+  async continueLatest() {
+    await this.close();
+    const opened = this.#manager.continueLatest(this.#projectRoot);
+    if (opened === null) {
+      await this.createNew();
+      return;
+    }
+    this.#opened = opened;
+    this.#history = ConversationHistory.fromReplay(opened.replay, opened.journal);
+  }
+  list() {
+    return this.#manager.list(this.#projectRoot);
+  }
+  async fork(entryId, mode) {
+    if (this.currentSessionId === null) {
+      throw new Error("no active session");
+    }
+    const result = this.#manager.fork({
+      parentSessionId: this.currentSessionId,
+      entryId,
+      mode
+    });
+    await this.resume(result.sessionId);
+    return result;
+  }
+  async clone() {
+    if (this.currentSessionId === null) {
+      throw new Error("no active session");
+    }
+    const result = this.#manager.clone({ parentSessionId: this.currentSessionId });
+    await this.resume(result.sessionId);
+    return result;
+  }
+  setCompactor(compactor) {
+    this.#compactor = compactor;
+  }
+  async compact() {
+    if (this.#history === null) {
+      throw new Error("no active session");
+    }
+    if (this.#compactor === null) {
+      throw new Error("manual compaction requires runtime wiring");
+    }
+    return this.#compactor();
+  }
+  async close() {
+    if (this.#opened === null) {
+      return true;
+    }
+    this.#opened.journal.appendRecord({
+      recordType: "session_closed",
+      payload: { reason: "normal" }
+    });
+    this.#opened.journal.close();
+    this.#opened = null;
+    this.#history = null;
+    return true;
+  }
+};
+
 // src/repl.ts
 import { readSync as readSync2 } from "node:fs";
 function errorMessage11(error) {
@@ -13727,8 +15790,8 @@ function startCoordinator(session, commandHandler, presenter, suggestCommand) {
   const done = (async () => {
     for (; ; ) {
       if (queue.length === 0) {
-        await new Promise((resolve) => {
-          wake = resolve;
+        await new Promise((resolve2) => {
+          wake = resolve2;
         });
         wake = null;
       }
@@ -13774,14 +15837,14 @@ function startCoordinator(session, commandHandler, presenter, suggestCommand) {
   };
 }
 function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
   });
 }
 async function settlesWithin(promise, ms) {
   let timer;
-  const timeout = new Promise((resolve) => {
-    timer = setTimeout(() => resolve(false), ms);
+  const timeout = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2(false), ms);
   });
   const settled = promise.then(
     () => true,
@@ -13953,7 +16016,7 @@ function readPackageVersion() {
     const packageJsonPath = fileURLToPath(
       new URL("../package.json", import.meta.url)
     );
-    const parsed = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
     if (typeof parsed === "object" && parsed !== null && typeof parsed.version === "string") {
       return parsed.version;
     }
@@ -13965,6 +16028,10 @@ function writeStderr(message) {
   process.stderr.write(`${message}
 `);
 }
+function resetEmptySessionTranscript(terminalUi) {
+  terminalUi?.replaceTranscript([]);
+  terminalUi?.showWelcome();
+}
 async function main(argv, options = {}) {
   let parsed;
   try {
@@ -14003,10 +16070,10 @@ async function main(argv, options = {}) {
   const configPath = options.configPath ?? defaultConfigPath(environ);
   const manager = new ConfigManager(configPath);
   const credentials = new CredentialStore(
-    options.credentialsPath ?? join4(dirname4(configPath), "credentials.json")
+    options.credentialsPath ?? join6(dirname4(configPath), "credentials.json")
   );
   const modelCatalogStore = new ModelCatalogStore(
-    options.modelsPath ?? join4(dirname4(configPath), "models.json")
+    options.modelsPath ?? join6(dirname4(configPath), "models.json")
   );
   const modelPlatform = await createPiAiPlatform({
     credentials,
@@ -14119,12 +16186,12 @@ async function main(argv, options = {}) {
     outputFn(`Verified: ${provider.verified ? "yes" : "no"}`);
     outputFn(`Configuration: ${configPath}`);
     outputFn(`Node: ${process.version}`);
-    outputFn(`Bash: ${existsSync5("/bin/bash") ? "available" : "missing"}`);
+    outputFn(`Bash: ${existsSync7("/bin/bash") ? "available" : "missing"}`);
     return provider !== void 0 && auth.configured && refreshOk && model !== void 0 ? 0 : 1;
   }
   let config;
   try {
-    if (existsSync5(configPath)) {
+    if (existsSync7(configPath)) {
       config = manager.resolve({
         environ,
         profile: args.profile,
@@ -14168,7 +16235,28 @@ async function main(argv, options = {}) {
   }
   let terminalUi = null;
   let terminalDriver = null;
-  const selectedModel = modelPlatform.catalog.getModel(config.provider, config.model);
+  let selectedModel = modelPlatform.catalog.getModel(config.provider, config.model);
+  const sessionController = new SessionController({
+    sessionsRoot: defaultSessionsRoot(environ),
+    projectRoot,
+    initialCwd: process.cwd(),
+    appVersion: VERSION,
+    provider: config.provider,
+    model: config.model,
+    reasoningEffort: "high"
+  });
+  try {
+    if (args.resumeSessionId !== null) {
+      await sessionController.resume(args.resumeSessionId);
+    } else if (args.continueSession) {
+      await sessionController.continueLatest();
+    } else {
+      await sessionController.createNew();
+    }
+  } catch (error) {
+    writeStderr(`Session error: ${errorMessage11(error)}`);
+    return 2;
+  }
   if (interactive) {
     terminalDriver = new StdTerminalDriver();
     terminalUi = new TerminalUI({
@@ -14178,22 +16266,151 @@ async function main(argv, options = {}) {
       version: VERSION,
       theme: args.theme,
       driver: terminalDriver,
-      capabilities: { reasoning: selectedModel?.reasoning ?? false }
+      capabilities: { reasoning: selectedModel?.reasoning ?? false },
+      contextWindow: selectedModel?.contextWindow
     });
     terminalUi.state.provider = config.provider;
     terminalUi.state.model = config.model;
   }
+  const toolRegistry = new ToolRegistry([
+    ...createFileToolDefinitions({ projectRoot }),
+    createBashToolDefinition({ projectRoot })
+  ]);
+  const activeConversationHistory = {
+    appendUser: (input) => {
+      const activeHistory = sessionController.history;
+      if (activeHistory === null) throw new Error("no active session");
+      return activeHistory.appendUser(input);
+    },
+    appendAssistant: (input) => {
+      const activeHistory = sessionController.history;
+      if (activeHistory === null) throw new Error("no active session");
+      return activeHistory.appendAssistant(input);
+    },
+    appendToolResults: (input) => {
+      const activeHistory = sessionController.history;
+      if (activeHistory === null) throw new Error("no active session");
+      return activeHistory.appendToolResults(input);
+    },
+    appendReminder: (input) => {
+      const activeHistory = sessionController.history;
+      if (activeHistory === null) throw new Error("no active session");
+      return activeHistory.appendReminder(input);
+    }
+  };
+  const createContextGovernor = (history2) => {
+    const modelInfo2 = selectedModel;
+    if (modelInfo2 === void 0) {
+      throw new Error("selected model metadata is unavailable");
+    }
+    return new ContextGovernor({
+      appendCompaction: (payload) => history2.appendCompaction(payload),
+      summarize: async ({ serialized, maxSummaryTokens }) => {
+        const summary = await modelRuntime.complete({
+          provider: config.provider,
+          model: config.model,
+          ...config.baseUrl === null ? {} : { baseUrl: config.baseUrl },
+          messages: [
+            { role: "system", content: COMPACTION_SYSTEM_PROMPT },
+            { role: "user", content: serialized }
+          ],
+          tools: [],
+          reasoningEffort: "off",
+          temperature: 0,
+          maxOutputTokens: Math.min(maxSummaryTokens, modelInfo2.maxTokens),
+          maxAttempts: 1
+        });
+        return {
+          summary: summary.message.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
+          inputTokens: summary.usage.inputTokens,
+          outputTokens: summary.usage.outputTokens
+        };
+      }
+    });
+  };
   const agent = new CodingAgent({
     modelAdapter: modelPlatform.adapter,
     model: config.model,
-    tools: new ToolRegistry([
-      ...createFileToolDefinitions({ projectRoot }),
-      createBashToolDefinition({ projectRoot })
-    ]),
+    tools: toolRegistry,
+    cliName: "laohuang",
+    cliVersion: VERSION,
     provider: config.provider,
     baseUrl: config.baseUrl,
     projectRoot: instructionRoot,
-    startupCwd: process.cwd()
+    startupCwd: process.cwd(),
+    conversationHistory: activeConversationHistory,
+    contextGovernor: selectedModel === void 0 || sessionController.history === null ? null : {
+      prepare: async ({ tools }) => {
+        const history2 = sessionController.history;
+        if (history2 === null || selectedModel === void 0) {
+          return { messages: [], contextTokens: 0, contextWindow: 0 };
+        }
+        const governor = createContextGovernor(history2);
+        const prepared = await governor.prepare({
+          entries: history2.entries(),
+          currentProvider: config.provider,
+          currentModel: config.model,
+          tools,
+          budget: {
+            contextWindow: selectedModel.contextWindow,
+            maxOutputTokens: selectedModel.maxTokens
+          },
+          policy: defaultContextPolicy()
+        });
+        return {
+          messages: prepared.messages,
+          contextTokens: prepared.tokens,
+          contextWindow: selectedModel.contextWindow
+        };
+      }
+    }
+  });
+  const history = sessionController.history;
+  if (history !== null) {
+    if (history.entries().length === 0) {
+      const system = agent.messages.find((message) => message.role === "system");
+      if (system !== void 0) {
+        history.appendSystemContext({
+          message: system,
+          cwd: process.cwd()
+        });
+      }
+    } else {
+      agent.messages = [...new ContextBuilder().build({
+        entries: history.entries(),
+        currentProvider: config.provider,
+        currentModel: config.model
+      }).messages];
+      terminalUi?.replaceTranscript(projectTranscript(history.entries()));
+    }
+  }
+  sessionController.setCompactor(async () => {
+    const activeHistory = sessionController.history;
+    if (activeHistory === null) {
+      throw new Error("no active session");
+    }
+    if (selectedModel === void 0) {
+      throw new Error("selected model metadata is unavailable");
+    }
+    const result = await createContextGovernor(activeHistory).compact({
+      entries: activeHistory.entries(),
+      currentProvider: config.provider,
+      currentModel: config.model,
+      tools: toolRegistry.definitions,
+      budget: {
+        contextWindow: selectedModel.contextWindow,
+        maxOutputTokens: selectedModel.maxTokens
+      },
+      policy: defaultContextPolicy(),
+      trigger: "manual"
+    });
+    agent.messages = [...new ContextBuilder().build({
+      entries: activeHistory.entries(),
+      currentProvider: config.provider,
+      currentModel: config.model
+    }).messages];
+    terminalUi?.replaceTranscript(projectTranscript(activeHistory.entries()));
+    return result;
   });
   const semanticClassifier = new SmallModelSemanticClassifier({
     modelRuntime,
@@ -14205,9 +16422,14 @@ async function main(argv, options = {}) {
   });
   let commandDispatcher;
   const runtime = new AgentSession(agent, {
+    sessionId: sessionController.currentSessionId ?? void 0,
     semanticClassifier,
     commandDispatcher: (command) => commandDispatcher?.(command) ?? { status: "not_found", command }
   });
+  const sessionRecorder = new SessionRecorder({
+    eventBus: runtime.eventBus,
+    journal: () => sessionController.currentJournal
+  });
   terminalUi?.setSessionId(runtime.sessionId);
   const plainSink = terminalUi === null ? new PlainEventSink(outputFn) : null;
   const sessionSink = terminalUi ?? plainSink;
@@ -14236,6 +16458,36 @@ async function main(argv, options = {}) {
     input: presenterInput,
     secretInput: presenterSecretInput
   }) : new TerminalCommandPresenter(terminalUi);
+  const refreshSessionView = () => {
+    const currentSessionId = sessionController.currentSessionId;
+    if (currentSessionId !== null) {
+      runtime.setSessionId(currentSessionId);
+      terminalUi?.setSessionId(currentSessionId);
+    }
+    const activeHistory = sessionController.history;
+    if (activeHistory === null) {
+      return;
+    }
+    const entries = activeHistory.entries();
+    if (entries.length === 0) {
+      const system = agent.messages.find((message) => message.role === "system");
+      if (system !== void 0) {
+        activeHistory.appendSystemContext({
+          message: system,
+          cwd: process.cwd()
+        });
+        agent.messages = [system];
+      }
+      resetEmptySessionTranscript(terminalUi);
+      return;
+    }
+    agent.messages = [...new ContextBuilder().build({
+      entries,
+      currentProvider: config.provider,
+      currentModel: config.model
+    }).messages];
+    terminalUi?.replaceTranscript(projectTranscript(entries));
+  };
   const commands = new SessionCommands({
     agent,
     selector,
@@ -14248,17 +16500,28 @@ async function main(argv, options = {}) {
     providerAuth,
     presenter: commandPresenter,
     session: runtime,
+    sessionController,
+    onComposerText: (text) => terminalUi?.setComposerText(text),
+    onSessionChanged: refreshSessionView,
+    homeDirectory: environ["HOME"],
     onModelSelected: (selection) => {
       semanticClassifier.configure({
         provider: selection.config.provider,
         model: selection.config.model,
         baseUrl: selection.config.baseUrl
       });
+      config = {
+        ...config,
+        provider: selection.config.provider,
+        model: selection.config.model,
+        baseUrl: selection.config.baseUrl
+      };
+      selectedModel = modelPlatform.catalog.getModel(
+        selection.config.provider,
+        selection.config.model
+      );
       if (terminalUi !== null) {
-        const model = modelPlatform.catalog.getModel(
-          selection.config.provider,
-          selection.config.model
-        );
+        const model = selectedModel;
         terminalUi.state.provider = selection.config.provider;
         terminalUi.state.model = selection.config.model;
         terminalUi.setRuntimeCapabilities({ reasoning: model?.reasoning ?? false });
@@ -14286,10 +16549,6 @@ async function main(argv, options = {}) {
         void commandDispatcher?.("/model");
         return;
       }
-      if (action === "clear_screen") {
-        void commandDispatcher?.("/clear");
-        return;
-      }
       if (action === "toggle_thinking") {
         terminalUi.toggleReasoningFromKeybinding();
         return;
@@ -14331,9 +16590,23 @@ async function main(argv, options = {}) {
     for (const unsubscribe of unsubscribers) {
       unsubscribe();
     }
+    await sessionRecorder.close();
+    await sessionController.close();
   }
   return cleanShutdown ? 0 : 1;
 }
+function defaultSessionsRoot(environ) {
+  return join6(environ["HOME"] ?? process.cwd(), ".laohuang", "sessions");
+}
+function defaultContextPolicy() {
+  return {
+    auto: true,
+    thresholdRatio: 0.8,
+    retainRatio: 0.16,
+    maxSummaryTokens: 8192,
+    safetyRatio: 0.05
+  };
+}
 async function runInitialModelSelection(options) {
   let providerName = options.providerName;
   if (providerName === void 0) {