@openacp/cli 0.6.5 → 0.6.7

package/dist/{chunk-FEWSQT3U.js → chunk-LO4Y5WQ7.js}

@@ -769,10 +769,12 @@ var Session = class extends TypedEmitter {
   voiceMode = "off";
   dangerousMode = false;
   archiving = false;
+  promptCount = 0;
   log;
   permissionGate = new PermissionGate();
   queue;
   speechService;
+  pendingContext = null;
   constructor(opts) {
     super();
     this.id = opts.id || nanoid(12);
@@ -832,6 +834,10 @@ var Session = class extends TypedEmitter {
   get promptRunning() {
     return this.queue.isProcessing;
   }
+  // --- Context Injection ---
+  setContext(markdown) {
+    this.pendingContext = markdown;
+  }
   // --- Voice Mode ---
   setVoiceMode(mode) {
     this.voiceMode = mode;
@@ -846,11 +852,23 @@ var Session = class extends TypedEmitter {
       await this.runWarmup();
       return;
     }
+    this.promptCount++;
     if (this._status === "initializing") {
       this.activate();
     }
     const promptStart = Date.now();
     this.log.debug("Prompt execution started");
+    if (this.pendingContext) {
+      text = `[CONVERSATION HISTORY - This is context from previous sessions, not current conversation]
+
+${this.pendingContext}
+
+[END CONVERSATION HISTORY]
+
+${text}`;
+      this.pendingContext = null;
+      this.log.debug("Context injected into prompt");
+    }
     const processed = await this.maybeTranscribeAudio(text, attachments);
     const ttsActive = this.voiceMode !== "off" && !!this.speechService?.isTTSAvailable();
     if (ttsActive) {
@@ -986,6 +1004,33 @@ ${result.text}` : result.text;
       this.resume();
     }
   }
+  async generateSummary(timeoutMs = 15e3) {
+    let summary = "";
+    let timer;
+    const captureHandler = (event) => {
+      if (event.type === "text") summary += event.content;
+    };
+    this.pause((event) => event !== "agent_event");
+    this.agentInstance.on("agent_event", captureHandler);
+    try {
+      const promptPromise = this.agentInstance.prompt(
+        "Summarize what you've accomplished so far in this session in 2-3 sentences. Include: key files changed, decisions made, and current status. Reply ONLY with the summary, nothing else."
+      );
+      const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("summary timeout")), timeoutMs);
+      });
+      await Promise.race([promptPromise, timeoutPromise]);
+      return summary.trim().slice(0, 500);
+    } catch {
+      this.log.warn("Failed to generate session summary");
+      return "";
+    } finally {
+      if (timer) clearTimeout(timer);
+      this.agentInstance.off("agent_event", captureHandler);
+      this.clearBuffer();
+      this.resume();
+    }
+  }
   /** Fire-and-forget warm-up: primes model cache while user types their first message */
   async warmup() {
     await this.queue.enqueue("\0__warmup__");
@@ -1322,7 +1367,8 @@ var SessionBridge = class {
             sessionId: this.session.id,
             sessionName: this.session.name,
             type: "completed",
-            summary: `Session "${this.session.name || this.session.id}" completed`
+            summary: `Session "${this.session.name || this.session.id}" completed
+\u23F1 ${Math.round((Date.now() - this.session.createdAt.getTime()) / 6e4)} min \xB7 \u{1F4AC} ${this.session.promptCount} prompts`
           });
           break;
         case "error":
@@ -1341,12 +1387,12 @@ var SessionBridge = class {
           break;
         case "image_content": {
           if (this.deps.fileService) {
-            const fs8 = this.deps.fileService;
+            const fs9 = this.deps.fileService;
             const sid = this.session.id;
             const { data, mimeType } = event;
             const buffer = Buffer.from(data, "base64");
             const ext = FileService.extensionFromMime(mimeType);
-            fs8.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
+            fs9.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
               this.adapter.sendMessage(sid, {
                 type: "attachment",
                 text: "",
@@ -1358,12 +1404,12 @@ var SessionBridge = class {
         }
         case "audio_content": {
           if (this.deps.fileService) {
-            const fs8 = this.deps.fileService;
+            const fs9 = this.deps.fileService;
             const sid = this.session.id;
             const { data, mimeType } = event;
             const buffer = Buffer.from(data, "base64");
             const ext = FileService.extensionFromMime(mimeType);
-            fs8.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
+            fs9.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
               this.adapter.sendMessage(sid, {
                 type: "attachment",
                 text: "",
@@ -1573,24 +1619,34 @@ var MessageTransformer = class {
       case "thought":
         return { type: "thought", text: event.content };
       case "tool_call": {
+        const meta = event.meta;
         const metadata = {
           id: event.id,
           name: event.name,
           kind: event.kind,
           status: event.status,
           content: event.content,
-          locations: event.locations
+          locations: event.locations,
+          rawInput: event.rawInput,
+          displaySummary: meta?.displaySummary,
+          displayTitle: meta?.displayTitle,
+          displayKind: meta?.displayKind
         };
         this.enrichWithViewerLinks(event, metadata, sessionContext);
         return { type: "tool_call", text: event.name, metadata };
       }
       case "tool_update": {
+        const meta = event.meta;
         const metadata = {
           id: event.id,
           name: event.name,
           kind: event.kind,
           status: event.status,
-          content: event.content
+          content: event.content,
+          rawInput: event.rawInput,
+          displaySummary: meta?.displaySummary,
+          displayTitle: meta?.displayTitle,
+          displayKind: meta?.displayKind
         };
         this.enrichWithViewerLinks(event, metadata, sessionContext);
         return { type: "tool_update", text: "", metadata };
@@ -2129,13 +2185,791 @@ var EdgeTTS = class {
   }
 };
 
+// src/core/context/context-manager.ts
+import * as os from "os";
+import * as path5 from "path";
+
+// src/core/context/context-cache.ts
+import * as fs5 from "fs";
+import * as path4 from "path";
+import * as crypto from "crypto";
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+var ContextCache = class {
+  constructor(cacheDir, ttlMs = DEFAULT_TTL_MS) {
+    this.cacheDir = cacheDir;
+    this.ttlMs = ttlMs;
+    fs5.mkdirSync(cacheDir, { recursive: true });
+  }
+  keyHash(repoPath, queryKey) {
+    return crypto.createHash("sha256").update(`${repoPath}:${queryKey}`).digest("hex").slice(0, 16);
+  }
+  filePath(repoPath, queryKey) {
+    return path4.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
+  }
+  get(repoPath, queryKey) {
+    const fp = this.filePath(repoPath, queryKey);
+    try {
+      const stat = fs5.statSync(fp);
+      if (Date.now() - stat.mtimeMs > this.ttlMs) {
+        fs5.unlinkSync(fp);
+        return null;
+      }
+      return JSON.parse(fs5.readFileSync(fp, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  set(repoPath, queryKey, result) {
+    fs5.writeFileSync(this.filePath(repoPath, queryKey), JSON.stringify(result));
+  }
+};
+
+// src/core/context/context-manager.ts
+var ContextManager = class {
+  providers = [];
+  cache;
+  constructor() {
+    this.cache = new ContextCache(path5.join(os.homedir(), ".openacp", "cache", "entire"));
+  }
+  register(provider) {
+    this.providers.push(provider);
+  }
+  async getProvider(repoPath) {
+    for (const provider of this.providers) {
+      if (await provider.isAvailable(repoPath)) return provider;
+    }
+    return null;
+  }
+  async listSessions(query) {
+    const provider = await this.getProvider(query.repoPath);
+    if (!provider) return null;
+    return provider.listSessions(query);
+  }
+  async buildContext(query, options) {
+    const queryKey = `${query.type}:${query.value}:${options?.limit ?? ""}:${options?.maxTokens ?? ""}`;
+    const cached = this.cache.get(query.repoPath, queryKey);
+    if (cached) return cached;
+    const provider = await this.getProvider(query.repoPath);
+    if (!provider) return null;
+    const result = await provider.buildContext(query, options);
+    if (result) this.cache.set(query.repoPath, queryKey, result);
+    return result;
+  }
+};
+
+// src/core/context/context-provider.ts
+var DEFAULT_MAX_TOKENS = 3e4;
+var TOKENS_PER_TURN_ESTIMATE = 400;
+
+// src/core/context/entire/checkpoint-reader.ts
+import { execFileSync as execFileSync2 } from "child_process";
+var ENTIRE_BRANCH = "origin/entire/checkpoints/v1";
+var CHECKPOINT_ID_RE = /^[0-9a-f]{12}$/;
+var SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var CheckpointReader = class _CheckpointReader {
+  constructor(repoPath) {
+    this.repoPath = repoPath;
+  }
+  // ─── Git execution ───────────────────────────────────────────────────────────
+  /**
+   * Run a git command in the repo directory.
+   * Returns trimmed stdout on success, empty string on failure.
+   */
+  git(...args) {
+    try {
+      return execFileSync2("git", ["-C", this.repoPath, ...args], {
+        encoding: "utf-8"
+      }).trim();
+    } catch {
+      return "";
+    }
+  }
+  // ─── Static helpers ──────────────────────────────────────────────────────────
+  /**
+   * Convert a 12-char checkpoint ID to its shard path: "f634acf05138" → "f6/34acf05138"
+   */
+  static shardPath(cpId) {
+    return `${cpId.slice(0, 2)}/${cpId.slice(2)}`;
+  }
+  /**
+   * Returns true when value looks like a 12-char lowercase hex checkpoint ID.
+   */
+  static isCheckpointId(value) {
+    return CHECKPOINT_ID_RE.test(value);
+  }
+  /**
+   * Returns true when value looks like a UUID (session ID).
+   */
+  static isSessionId(value) {
+    return SESSION_ID_RE.test(value);
+  }
+  /**
+   * Parse checkpoint-level metadata JSON. Returns null on error.
+   */
+  static parseCheckpointMeta(json) {
+    try {
+      const parsed = JSON.parse(json);
+      if (!parsed || typeof parsed !== "object") return null;
+      if (!Array.isArray(parsed.sessions)) return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Extract Entire-Checkpoint trailer IDs from `git log --format="%H|%(trailers:...)"` output.
+   * Each line is: `<hash>|<trailer_value_or_empty>`. Returns only non-empty trailer values.
+   * Uses the last pipe on each line to locate the trailer value, to be robust against
+   * subject lines that contain pipes.
+   */
+  static parseCheckpointTrailers(output) {
+    const ids = [];
+    for (const line of output.split("\n")) {
+      const pipe = line.lastIndexOf("|");
+      if (pipe === -1) continue;
+      const trailerId = line.slice(pipe + 1).trim();
+      if (trailerId) ids.push(trailerId);
+    }
+    return ids;
+  }
+  // ─── Branch check ────────────────────────────────────────────────────────────
+  async hasEntireBranch() {
+    const out = this.git("branch", "-r");
+    return out.includes("entire/checkpoints/v1");
+  }
+  // ─── Core session fetching ───────────────────────────────────────────────────
+  listAllCheckpointIds() {
+    const out = this.git(
+      "ls-tree",
+      "-r",
+      ENTIRE_BRANCH,
+      "--name-only"
+    );
+    if (!out) return [];
+    const ids = /* @__PURE__ */ new Set();
+    for (const file of out.split("\n")) {
+      const parts = file.split("/");
+      if (parts.length === 3 && parts[2] === "metadata.json") {
+        ids.add(parts[0] + parts[1]);
+      }
+    }
+    return [...ids];
+  }
+  fetchCheckpointMeta(cpId) {
+    const shard = _CheckpointReader.shardPath(cpId);
+    const raw = this.git("show", `${ENTIRE_BRANCH}:${shard}/metadata.json`);
+    if (!raw) return null;
+    return _CheckpointReader.parseCheckpointMeta(raw);
+  }
+  fetchSessionMeta(metaPath) {
+    const normalized = metaPath.startsWith("/") ? metaPath.slice(1) : metaPath;
+    const raw = this.git("show", `${ENTIRE_BRANCH}:${normalized}`);
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Build SessionInfo[] from a single checkpoint's metadata.
+   */
+  buildSessionsForCheckpoint(cpId, cpMeta) {
+    const sessions = [];
+    for (let idx = 0; idx < cpMeta.sessions.length; idx++) {
+      const sess = cpMeta.sessions[idx];
+      const transcriptPath = (sess.transcript ?? "").replace(/^\//, "");
+      const metaPath = sess.metadata ?? "";
+      const smeta = this.fetchSessionMeta(metaPath);
+      const createdAt = smeta.created_at ?? "";
+      sessions.push({
+        checkpointId: cpId,
+        sessionIndex: String(idx),
+        transcriptPath,
+        createdAt,
+        endedAt: createdAt,
+        // will be filled from JSONL by conversation builder
+        branch: smeta.branch ?? cpMeta.branch ?? "",
+        agent: smeta.agent ?? "",
+        turnCount: smeta.session_metrics?.turn_count ?? 0,
+        filesTouched: smeta.files_touched ?? cpMeta.files_touched ?? [],
+        sessionId: smeta.session_id ?? ""
+      });
+    }
+    return sessions;
+  }
+  getSessionsForCheckpoint(cpId) {
+    const meta = this.fetchCheckpointMeta(cpId);
+    if (!meta) return [];
+    return this.buildSessionsForCheckpoint(cpId, meta);
+  }
+  // ─── Public resolvers ────────────────────────────────────────────────────────
+  /**
+   * All sessions recorded on a given branch, sorted by createdAt ascending.
+   */
+  async resolveByBranch(branchName) {
+    const cpIds = this.listAllCheckpointIds();
+    const sessions = [];
+    for (const cpId of cpIds) {
+      const meta = this.fetchCheckpointMeta(cpId);
+      if (!meta) continue;
+      if (meta.branch !== branchName) continue;
+      sessions.push(...this.buildSessionsForCheckpoint(cpId, meta));
+    }
+    sessions.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return sessions;
+  }
+  /**
+   * Sessions linked to a specific commit via the Entire-Checkpoint git trailer.
+   */
+  async resolveByCommit(commitHash) {
+    const fullHash = this.git("rev-parse", commitHash);
+    if (!fullHash) return [];
+    const cpId = this.git(
+      "log",
+      "-1",
+      "--format=%(trailers:key=Entire-Checkpoint,valueonly)",
+      fullHash
+    );
+    if (!cpId) return [];
+    return this.getSessionsForCheckpoint(cpId.trim());
+  }
+  /**
+   * All sessions from a merged PR (by number or GitHub URL).
+   */
+  async resolveByPr(prInput) {
+    let prNumber;
+    if (/^\d+$/.test(prInput)) {
+      prNumber = prInput;
+    } else {
+      const m = /\/pull\/(\d+)/.exec(prInput);
+      if (!m) return [];
+      prNumber = m[1];
+    }
+    const mergeOut = this.git(
+      "log",
+      "--all",
+      "--oneline",
+      "--grep",
+      `Merge pull request #${prNumber}`
+    );
+    if (!mergeOut) return [];
+    const mergeCommit = mergeOut.split("\n")[0].split(" ")[0];
+    const logOut = this.git(
+      "log",
+      "--format=%H|%(trailers:key=Entire-Checkpoint,valueonly)",
+      `${mergeCommit}^2`,
+      "--not",
+      `${mergeCommit}^1`
+    );
+    if (!logOut) return [];
+    const cpIds = _CheckpointReader.parseCheckpointTrailers(logOut);
+    const sessions = [];
+    for (const cpId of cpIds) {
+      sessions.push(...this.getSessionsForCheckpoint(cpId));
+    }
+    sessions.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return sessions;
+  }
+  /**
+   * Sessions matching a specific checkpoint ID.
+   */
+  async resolveByCheckpoint(checkpointId) {
+    return this.getSessionsForCheckpoint(checkpointId);
+  }
+  /**
+   * Find a session by its UUID.
+   */
+  async resolveBySessionId(sessionId) {
+    const cpIds = this.listAllCheckpointIds();
+    for (const cpId of cpIds) {
+      const sessions = this.getSessionsForCheckpoint(cpId);
+      const match = sessions.find((s) => s.sessionId === sessionId);
+      if (match) return [match];
+    }
+    return [];
+  }
+  /**
+   * Latest N sessions across all checkpoints, sorted by createdAt descending.
+   */
+  async resolveLatest(count) {
+    const cpIds = this.listAllCheckpointIds();
+    const all = [];
+    for (const cpId of cpIds) {
+      all.push(...this.getSessionsForCheckpoint(cpId));
+    }
+    all.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return all.slice(0, count);
+  }
+  /**
+   * Read the full JSONL transcript content from the entire branch.
+   */
+  getTranscript(transcriptPath) {
+    const normalized = transcriptPath.startsWith("/") ? transcriptPath.slice(1) : transcriptPath;
+    return this.git("show", `${ENTIRE_BRANCH}:${normalized}`);
+  }
+};
+
+// src/core/context/entire/message-cleaner.ts
+var SYSTEM_TAG_PATTERNS = [
+  /<system-reminder>[\s\S]*?<\/system-reminder>/g,
+  /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g,
+  /<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g,
+  /<command-name>[\s\S]*?<\/command-name>/g,
+  /<command-message>[\s\S]*?<\/command-message>/g,
+  /<user-prompt-submit-hook>[\s\S]*?<\/user-prompt-submit-hook>/g,
+  /<ide_selection>[\s\S]*?<\/ide_selection>/g,
+  /<ide_context>[\s\S]*?<\/ide_context>/g,
+  /<ide_opened_file>[\s\S]*?<\/ide_opened_file>/g,
+  /<cursor_context>[\s\S]*?<\/cursor_context>/g,
+  /<attached_files>[\s\S]*?<\/attached_files>/g,
+  /<repo_context>[\s\S]*?<\/repo_context>/g,
+  /<task-notification>[\s\S]*?<\/task-notification>/g
+];
+var COMMAND_ARGS_RE = /<command-args>([\s\S]*?)<\/command-args>/;
+function cleanSystemTags(text) {
+  const argsMatch = COMMAND_ARGS_RE.exec(text);
+  const userArgs = argsMatch?.[1]?.trim() ?? "";
+  text = text.replace(/<command-args>[\s\S]*?<\/command-args>/g, "");
+  for (const pat of SYSTEM_TAG_PATTERNS) {
+    text = text.replace(new RegExp(pat.source, pat.flags), "");
+  }
+  text = text.trim();
+  if (!text && userArgs) return userArgs;
+  if (text && userArgs && text !== userArgs) return `${text}
+${userArgs}`;
+  return text || userArgs;
+}
+var SKILL_INDICATORS = [
+  "Base directory for this skill:",
+  "<HARD-GATE>",
+  "## Checklist",
+  "## Process Flow",
+  "## Key Principles",
+  "digraph brainstorming",
+  "You MUST create a task for each"
+];
+function isSkillPrompt(text) {
+  for (const indicator of SKILL_INDICATORS) {
+    if (text.includes(indicator)) return true;
+  }
+  if (text.length > 2e3) {
+    const headerCount = (text.match(/## /g) || []).length;
+    if (headerCount >= 3) return true;
+  }
+  return false;
+}
+function isNoiseMessage(text) {
+  const cleaned = cleanSystemTags(text);
+  if (!cleaned) return true;
+  if (/^(ready|ready\.)$/i.test(cleaned)) return true;
+  if (cleaned.includes("Tell your human partner that this command is deprecated")) return true;
+  if (cleaned.startsWith("Read the output file to retrieve the result:")) return true;
+  if (/^(opus|sonnet|haiku|claude)(\[.*\])?$/i.test(cleaned)) return true;
+  return false;
+}
+
+// src/core/context/entire/conversation-builder.ts
+function selectMode(totalTurns) {
+  if (totalTurns <= 10) return "full";
+  if (totalTurns <= 25) return "balanced";
+  return "compact";
+}
+function estimateTokens(text) {
+  return Math.floor(text.length / 4);
+}
+function shortenPath(fp) {
+  const parts = fp.split("/");
+  if (parts.length >= 2) return parts.slice(-2).join("/");
+  return fp;
+}
+function countLines(s) {
+  const trimmed = s.trim();
+  if (!trimmed) return 0;
+  return trimmed.split("\n").length;
+}
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((b) => typeof b === "object" && b !== null && b.type === "text").map((b) => b.text).join("\n");
+  }
+  return "";
+}
+function extractContentBlocks(content) {
+  if (typeof content === "string") return [{ type: "text", text: content }];
+  if (Array.isArray(content)) {
+    return content.filter((b) => typeof b === "object" && b !== null);
+  }
+  return [];
+}
+function isToolResultOnly(content) {
+  if (typeof content === "string") return false;
+  if (!Array.isArray(content)) return true;
+  for (const block of content) {
+    if (typeof block === "object" && block !== null) {
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string" && b.text.trim()) return false;
+      if (b.type === "image") return false;
+    }
+  }
+  return true;
+}
+function hasImage(content) {
+  if (!Array.isArray(content)) return false;
+  return content.some((b) => typeof b === "object" && b !== null && b.type === "image");
+}
+function formatEditFull(filePath, oldStr, newStr) {
+  const lines = [];
+  lines.push(`\u270F\uFE0F \`${filePath}\``);
+  lines.push("```diff");
+  for (const line of oldStr.split("\n")) lines.push(`- ${line}`);
+  for (const line of newStr.split("\n")) lines.push(`+ ${line}`);
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatEditBalanced(filePath, oldStr, newStr, maxDiffLines = 12) {
+  const oldLines = oldStr.split("\n");
+  const newLines = newStr.split("\n");
+  const total = oldLines.length + newLines.length;
+  const lines = [];
+  lines.push(`\u270F\uFE0F \`${filePath}\``);
+  lines.push("```diff");
+  if (total <= maxDiffLines) {
+    for (const line of oldLines) lines.push(`- ${line}`);
+    for (const line of newLines) lines.push(`+ ${line}`);
+  } else {
+    const half = Math.floor(maxDiffLines / 2);
+    for (const line of oldLines.slice(0, half)) lines.push(`- ${line}`);
+    if (oldLines.length > half) lines.push(`  ... (-${oldLines.length} lines total)`);
+    for (const line of newLines.slice(0, half)) lines.push(`+ ${line}`);
+    if (newLines.length > half) lines.push(`  ... (+${newLines.length} lines total)`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatEditCompact(filePath, oldStr, newStr) {
+  const oldLines = countLines(oldStr);
+  const newLines = countLines(newStr);
+  let firstNew = "";
+  for (const line of newStr.split("\n")) {
+    const stripped = line.trim();
+    if (stripped && !stripped.startsWith("//") && !stripped.startsWith("*")) {
+      firstNew = stripped.slice(0, 80);
+      break;
+    }
+  }
+  if (firstNew) {
+    return `\u270F\uFE0F \`${filePath}\` (-${oldLines}/+${newLines} lines): \`${firstNew}\``;
+  }
+  return `\u270F\uFE0F \`${filePath}\` (-${oldLines}/+${newLines} lines)`;
+}
+function formatWriteFull(filePath, content) {
+  const lines = [];
+  lines.push(`\u{1F4DD} \`${filePath}\``);
+  lines.push("```");
+  lines.push(content);
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatWriteBalanced(filePath, content, maxLines = 15) {
+  const contentLines = content.split("\n");
+  const lines = [];
+  lines.push(`\u{1F4DD} \`${filePath}\` (${contentLines.length} lines)`);
+  lines.push("```");
+  for (const line of contentLines.slice(0, maxLines)) lines.push(line);
+  if (contentLines.length > maxLines) lines.push(`... (${contentLines.length - maxLines} more lines)`);
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatWriteCompact(filePath, content) {
+  const numLines = countLines(content);
+  return `\u{1F4DD} \`${filePath}\` (${numLines} lines written)`;
+}
+function parseJsonlToTurns(jsonl) {
+  const events = [];
+  for (const rawLine of jsonl.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  let branch = "unknown";
+  for (const e of events) {
+    if (e.gitBranch) {
+      branch = e.gitBranch;
+      break;
+    }
+  }
+  const convEvents = events.filter((e) => e.type === "user" || e.type === "assistant");
+  const turns = [];
+  let currentTurn = null;
+  for (const e of convEvents) {
+    const etype = e.type;
+    const content = e.message?.content ?? [];
+    const ts = e.timestamp ?? "";
+    if (etype === "user") {
+      if (isToolResultOnly(content)) continue;
+      const text = extractText(content);
+      if (isSkillPrompt(text)) continue;
+      if (isNoiseMessage(text)) continue;
+      const cleaned = cleanSystemTags(text);
+      if (!cleaned) continue;
+      if (currentTurn) turns.push(currentTurn);
+      const imgSuffix = hasImage(content) ? " [image]" : "";
+      currentTurn = {
+        userText: cleaned + imgSuffix,
+        userTimestamp: ts,
+        assistantParts: []
+      };
+    } else if (etype === "assistant" && currentTurn) {
+      const blocks = extractContentBlocks(content);
+      let pendingText = null;
+      for (const block of blocks) {
+        const btype = block.type;
+        if (btype === "text") {
+          const text = typeof block.text === "string" ? block.text.trim() : "";
+          if (text) pendingText = text;
+        } else if (btype === "tool_use") {
+          const name = typeof block.name === "string" ? block.name : "";
+          const inp = typeof block.input === "object" && block.input !== null ? block.input : {};
+          if (name === "Edit") {
+            if (pendingText) {
+              currentTurn.assistantParts.push({ type: "text", content: pendingText });
+              pendingText = null;
+            }
+            currentTurn.assistantParts.push({
+              type: "edit",
+              file: shortenPath(inp.file_path ?? ""),
+              old: inp.old_string ?? "",
+              new: inp.new_string ?? ""
+            });
+          } else if (name === "Write") {
+            if (pendingText) {
+              currentTurn.assistantParts.push({ type: "text", content: pendingText });
+              pendingText = null;
+            }
+            currentTurn.assistantParts.push({
+              type: "write",
+              file: shortenPath(inp.file_path ?? ""),
+              fileContent: inp.content ?? ""
+            });
+          }
+        }
+      }
+      if (pendingText) {
+        currentTurn.assistantParts.push({ type: "text", content: pendingText });
+      }
+    }
+  }
+  if (currentTurn) turns.push(currentTurn);
+  const firstTimestamp = turns[0]?.userTimestamp ?? "";
+  const lastTimestamp = turns[turns.length - 1]?.userTimestamp ?? "";
+  return { turns, branch, firstTimestamp, lastTimestamp };
+}
+function buildSessionMarkdown(turns, mode) {
+  const out = [];
+  for (let i = 0; i < turns.length; i++) {
+    const turn = turns[i];
+    const userText = turn.userText.trim();
+    if (!userText) continue;
+    out.push(`**User [${i + 1}]:**`);
+    out.push(userText);
+    out.push("");
+    let hasContent = false;
+    for (const part of turn.assistantParts) {
+      if (part.type === "text") {
+        if (!hasContent) {
+          out.push("**Assistant:**");
+          hasContent = true;
+        }
+        out.push(part.content ?? "");
+        out.push("");
+      } else if (part.type === "edit") {
+        if (!hasContent) {
+          out.push("**Assistant:**");
+          hasContent = true;
+        }
+        const file = part.file ?? "";
+        const oldStr = part.old ?? "";
+        const newStr = part.new ?? "";
+        if (mode === "full") {
+          out.push(formatEditFull(file, oldStr, newStr));
+        } else if (mode === "balanced") {
+          out.push(formatEditBalanced(file, oldStr, newStr));
+        } else {
+          out.push(formatEditCompact(file, oldStr, newStr));
+        }
+        out.push("");
+      } else if (part.type === "write") {
+        if (!hasContent) {
+          out.push("**Assistant:**");
+          hasContent = true;
+        }
+        const file = part.file ?? "";
+        const content = part.fileContent ?? "";
+        if (mode === "full") {
+          out.push(formatWriteFull(file, content));
+        } else if (mode === "balanced") {
+          out.push(formatWriteBalanced(file, content));
+        } else {
+          out.push(formatWriteCompact(file, content));
+        }
+        out.push("");
+      }
+    }
+    out.push("---");
+    out.push("");
+  }
+  return out.join("\n");
+}
+var DISCLAIMER = `> **Note:** This conversation history may contain outdated information. File contents, code, and project state may have changed since these sessions were recorded. Use this as context only \u2014 always verify against current files before acting.`;
+function mergeSessionsMarkdown(sessions, mode, title) {
+  const sorted = [...sessions].sort((a, b) => a.startTime.localeCompare(b.startTime));
+  const totalTurns = sorted.reduce((sum, s) => sum + s.turns, 0);
+  const overallStart = sorted[0]?.startTime.slice(0, 16) ?? "?";
+  const overallEnd = sorted[sorted.length - 1]?.endTime.slice(0, 16) ?? "?";
+  const out = [];
+  out.push(`# Conversation History from ${title}`);
+  out.push(`${sorted.length} sessions | ${totalTurns} turns | ${overallStart} \u2192 ${overallEnd} | mode: ${mode}`);
+  out.push("");
+  for (let i = 0; i < sorted.length; i++) {
+    const s = sorted[i];
+    const start = s.startTime.slice(0, 16);
+    const end = s.endTime.slice(0, 16);
+    out.push(`## Session Conversation History ${i + 1} \u2014 ${start} \u2192 ${end} (${s.agent}, ${s.turns} turns, branch: ${s.branch})`);
+    out.push("");
+    out.push(s.markdown);
+  }
+  out.push(DISCLAIMER);
+  out.push("");
+  return out.join("\n");
+}
+
+// src/core/context/entire/entire-provider.ts
+var EntireProvider = class {
+  name = "entire";
+  async isAvailable(repoPath) {
+    return new CheckpointReader(repoPath).hasEntireBranch();
+  }
+  async listSessions(query) {
+    const reader = new CheckpointReader(query.repoPath);
+    const sessions = await this.resolveSessions(reader, query);
+    const estimatedTokens = sessions.reduce((sum, s) => sum + s.turnCount * TOKENS_PER_TURN_ESTIMATE, 0);
+    return { sessions, estimatedTokens };
+  }
+  async buildContext(query, options) {
+    const maxTokens = options?.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const reader = new CheckpointReader(query.repoPath);
+    let sessions = await this.resolveSessions(reader, query);
+    if (options?.limit && sessions.length > options.limit) {
+      sessions = sessions.slice(-options.limit);
+    }
+    if (sessions.length === 0) {
+      return { markdown: "", tokenEstimate: 0, sessionCount: 0, totalTurns: 0, mode: "full", truncated: false, timeRange: { start: "", end: "" } };
+    }
+    const parsedSessions = [];
+    for (const sess of sessions) {
+      const jsonl = reader.getTranscript(sess.transcriptPath);
+      if (jsonl) parsedSessions.push({ session: sess, jsonl });
+    }
+    if (parsedSessions.length === 0) {
+      return { markdown: "", tokenEstimate: 0, sessionCount: 0, totalTurns: 0, mode: "full", truncated: false, timeRange: { start: "", end: "" } };
+    }
+    const totalTurns = parsedSessions.reduce((sum, ps) => {
+      const parsed = parseJsonlToTurns(ps.jsonl);
+      return sum + parsed.turns.length;
+    }, 0);
+    let mode = selectMode(totalTurns);
+    const title = this.buildTitle(query);
+    let sessionMarkdowns = this.buildSessionMarkdowns(parsedSessions, mode);
+    let merged = mergeSessionsMarkdown(sessionMarkdowns, mode, title);
+    let tokens = estimateTokens(merged);
+    if (tokens > maxTokens && mode !== "compact") {
+      mode = "compact";
+      sessionMarkdowns = this.buildSessionMarkdowns(parsedSessions, "compact");
+      merged = mergeSessionsMarkdown(sessionMarkdowns, "compact", title);
+      tokens = estimateTokens(merged);
+    }
+    let truncated = false;
+    while (tokens > maxTokens && sessionMarkdowns.length > 1) {
+      sessionMarkdowns = sessionMarkdowns.slice(1);
+      truncated = true;
+      merged = mergeSessionsMarkdown(sessionMarkdowns, mode, title);
+      tokens = estimateTokens(merged);
+    }
+    const allTimes = sessionMarkdowns.flatMap((s) => [s.startTime, s.endTime]).filter(Boolean).sort();
+    const finalTurns = sessionMarkdowns.reduce((sum, s) => sum + s.turns, 0);
+    return {
+      markdown: merged,
+      tokenEstimate: tokens,
+      sessionCount: sessionMarkdowns.length,
+      totalTurns: finalTurns,
+      mode,
+      truncated,
+      timeRange: { start: allTimes[0] ?? "", end: allTimes[allTimes.length - 1] ?? "" }
+    };
+  }
+  buildSessionMarkdowns(parsedSessions, mode) {
+    return parsedSessions.map((ps) => {
+      const parsed = parseJsonlToTurns(ps.jsonl);
+      return {
+        markdown: buildSessionMarkdown(parsed.turns, mode),
+        startTime: parsed.firstTimestamp,
+        endTime: parsed.lastTimestamp,
+        agent: ps.session.agent,
+        turns: parsed.turns.length,
+        branch: ps.session.branch,
+        files: ps.session.filesTouched.map((f) => f.split("/").pop() ?? f)
+      };
+    });
+  }
+  async resolveSessions(reader, query) {
+    switch (query.type) {
+      case "branch":
+        return reader.resolveByBranch(query.value);
+      case "commit":
+        return reader.resolveByCommit(query.value);
+      case "pr":
+        return reader.resolveByPr(query.value);
+      case "checkpoint":
+        return reader.resolveByCheckpoint(query.value);
+      case "session":
+        return reader.resolveBySessionId(query.value);
+      case "latest":
+        return reader.resolveLatest(parseInt(query.value) || 5);
+      default:
+        return [];
+    }
+  }
+  buildTitle(query) {
+    switch (query.type) {
+      case "pr":
+        return `PR #${query.value.replace(/.*\/pull\//, "")}`;
+      case "branch":
+        return `branch \`${query.value}\``;
+      case "commit":
+        return `commit \`${query.value.slice(0, 8)}\``;
+      case "checkpoint":
+        return `checkpoint \`${query.value}\``;
+      case "session":
+        return `session \`${query.value.slice(0, 8)}...\``;
+      case "latest":
+        return `latest ${query.value} sessions`;
+      default:
+        return "unknown";
+    }
+  }
+};
+
 // src/core/core.ts
-import path5 from "path";
-import os from "os";
+import path7 from "path";
+import os2 from "os";
 
 // src/core/session-store.ts
-import fs5 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path6 from "path";
 var log6 = createChildLogger({ module: "session-store" });
 var DEBOUNCE_MS2 = 2e3;
 var JsonFileSessionStore = class {
@@ -2197,9 +3031,9 @@ var JsonFileSessionStore = class {
       version: 1,
       sessions: Object.fromEntries(this.records)
     };
-    const dir = path4.dirname(this.filePath);
-    if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
-    fs5.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+    const dir = path6.dirname(this.filePath);
+    if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
+    fs6.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
   }
   destroy() {
     if (this.debounceTimer) clearTimeout(this.debounceTimer);
@@ -2212,10 +3046,10 @@ var JsonFileSessionStore = class {
     }
   }
   load() {
-    if (!fs5.existsSync(this.filePath)) return;
+    if (!fs6.existsSync(this.filePath)) return;
     try {
       const raw = JSON.parse(
-        fs5.readFileSync(this.filePath, "utf-8")
+        fs6.readFileSync(this.filePath, "utf-8")
       );
       if (raw.version !== 1) {
         log6.warn(
@@ -2279,13 +3113,14 @@ var OpenACPCore = class {
   sessionFactory;
   usageStore = null;
   usageBudget = null;
+  contextManager;
   constructor(configManager) {
     this.configManager = configManager;
     const config = configManager.get();
     this.agentCatalog = new AgentCatalog();
     this.agentCatalog.load();
     this.agentManager = new AgentManager(this.agentCatalog);
-    const storePath = path5.join(os.homedir(), ".openacp", "sessions.json");
+    const storePath = path7.join(os2.homedir(), ".openacp", "sessions.json");
     this.sessionStore = new JsonFileSessionStore(
       storePath,
       config.sessionStore.ttlDays
@@ -2295,15 +3130,17 @@ var OpenACPCore = class {
     this.notificationManager = new NotificationManager(this.adapters);
     const usageConfig = config.usage;
     if (usageConfig.enabled) {
-      const usagePath = path5.join(os.homedir(), ".openacp", "usage.json");
+      const usagePath = path7.join(os2.homedir(), ".openacp", "usage.json");
       this.usageStore = new UsageStore(usagePath, usageConfig.retentionDays);
       this.usageBudget = new UsageBudget(this.usageStore, usageConfig);
     }
     this.messageTransformer = new MessageTransformer();
     this.eventBus = new EventBus();
     this.sessionManager.setEventBus(this.eventBus);
+    this.contextManager = new ContextManager();
+    this.contextManager.register(new EntireProvider());
     this.fileService = new FileService(
-      path5.join(os.homedir(), ".openacp", "files")
+      path7.join(os2.homedir(), ".openacp", "files")
     );
     const speechConfig = config.speech ?? {
       stt: { provider: null, providers: {} },
@@ -2398,22 +3235,82 @@ var OpenACPCore = class {
       this.usageStore.destroy();
     }
   }
+  // --- Summary ---
+  async summarizeSession(sessionId) {
+    const session = this.sessionManager.getSession(sessionId);
+    if (session && session.status === "active") {
+      try {
+        const summary = await session.generateSummary();
+        if (!summary) return { ok: false, error: "Agent could not generate summary" };
+        return { ok: true, summary };
+      } catch (err) {
+        return { ok: false, error: err.message };
+      }
+    }
+    const record = this.sessionManager.getSessionRecord(sessionId);
+    if (!record?.agentSessionId) {
+      return { ok: false, error: "Session not found or has no agent history" };
+    }
+    const caps = getAgentCapabilities(record.agentName);
+    if (!caps.supportsResume) {
+      return { ok: false, error: `Agent "${record.agentName}" does not support resume \u2014 cannot summarize ended session` };
+    }
+    let tempSession;
+    try {
+      const agentInstance = await this.agentManager.resume(
+        record.agentName,
+        record.workingDir,
+        record.agentSessionId
+      );
+      tempSession = new Session({
+        id: `summary-${sessionId}`,
+        channelId: record.channelId,
+        agentName: record.agentName,
+        workingDirectory: record.workingDir,
+        agentInstance
+      });
+      tempSession.activate();
+      const summary = await tempSession.generateSummary();
+      if (!summary) return { ok: false, error: "Agent could not generate summary" };
+      return { ok: true, summary };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    } finally {
+      if (tempSession) {
+        try {
+          await tempSession.destroy();
+        } catch {
+        }
+      }
+    }
+  }
   // --- Archive ---
   async archiveSession(sessionId) {
     const session = this.sessionManager.getSession(sessionId);
-    if (!session) return { ok: false, error: "Session not found" };
-    if (session.status === "initializing")
-      return { ok: false, error: "Session is still initializing" };
-    if (session.status !== "active")
-      return { ok: false, error: `Session is ${session.status}` };
-    const adapter = this.adapters.get(session.channelId);
+    const record = this.sessionManager.getSessionRecord(sessionId);
+    if (!session && !record) return { ok: false, error: "Session not found" };
+    const channelId = session?.channelId ?? record?.channelId;
+    if (!channelId) return { ok: false, error: "No channel for session" };
+    const adapter = this.adapters.get(channelId);
     if (!adapter) return { ok: false, error: "Adapter not found for session" };
     try {
-      const result = await adapter.archiveSessionTopic(session.id);
-      if (!result)
-        return { ok: false, error: "Adapter does not support archiving" };
-      return { ok: true, newThreadId: result.newThreadId };
+      if (session) {
+        await adapter.archiveSessionTopic(session.id);
+      } else {
+        await adapter.deleteSessionThread(sessionId);
+      }
+      if (session) {
+        try {
+          await this.sessionManager.cancelSession(sessionId);
+        } catch {
+        } finally {
+          session.archiving = false;
+        }
+      }
+      await this.sessionManager.removeRecord(sessionId);
+      return { ok: true };
     } catch (err) {
+      if (session) session.archiving = false;
       return { ok: false, error: err.message };
     }
   }
@@ -2654,6 +3551,27 @@ var OpenACPCore = class {
       record.workingDir
     );
   }
+  async createSessionWithContext(params) {
+    let contextResult = null;
+    try {
+      contextResult = await this.contextManager.buildContext(
+        params.contextQuery,
+        params.contextOptions
+      );
+    } catch (err) {
+      log7.warn({ err }, "Context building failed, proceeding without context");
+    }
+    const session = await this.createSession({
+      channelId: params.channelId,
+      agentName: params.agentName,
+      workingDirectory: params.workingDirectory,
+      createThread: params.createThread
+    });
+    if (contextResult) {
+      session.setContext(contextResult.markdown);
+    }
+    return { session, contextResult };
+  }
   // --- Lazy Resume ---
   /**
    * Get active session by thread, or attempt lazy resume from store.
@@ -2849,8 +3767,8 @@ data: ${JSON.stringify(data)}
 };
 
 // src/core/static-server.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 import { fileURLToPath } from "url";
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
@@ -2870,16 +3788,16 @@ var StaticServer = class {
     this.uiDir = uiDir;
     if (!this.uiDir) {
       const __filename = fileURLToPath(import.meta.url);
-      const candidate = path6.resolve(path6.dirname(__filename), "../../ui/dist");
-      if (fs6.existsSync(path6.join(candidate, "index.html"))) {
+      const candidate = path8.resolve(path8.dirname(__filename), "../../ui/dist");
+      if (fs7.existsSync(path8.join(candidate, "index.html"))) {
         this.uiDir = candidate;
       }
       if (!this.uiDir) {
-        const publishCandidate = path6.resolve(
-          path6.dirname(__filename),
+        const publishCandidate = path8.resolve(
+          path8.dirname(__filename),
           "../ui"
         );
-        if (fs6.existsSync(path6.join(publishCandidate, "index.html"))) {
+        if (fs7.existsSync(path8.join(publishCandidate, "index.html"))) {
           this.uiDir = publishCandidate;
         }
       }
@@ -2891,12 +3809,12 @@ var StaticServer = class {
   serve(req, res) {
     if (!this.uiDir) return false;
     const urlPath = (req.url || "/").split("?")[0];
-    const safePath = path6.normalize(urlPath);
-    const filePath = path6.join(this.uiDir, safePath);
-    if (!filePath.startsWith(this.uiDir + path6.sep) && filePath !== this.uiDir)
+    const safePath = path8.normalize(urlPath);
+    const filePath = path8.join(this.uiDir, safePath);
+    if (!filePath.startsWith(this.uiDir + path8.sep) && filePath !== this.uiDir)
       return false;
-    if (fs6.existsSync(filePath) && fs6.statSync(filePath).isFile()) {
-      const ext = path6.extname(filePath);
+    if (fs7.existsSync(filePath) && fs7.statSync(filePath).isFile()) {
+      const ext = path8.extname(filePath);
       const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
       const isHashed = /\.[a-zA-Z0-9]{8,}\.(js|css)$/.test(filePath);
       const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "no-cache";
@@ -2904,16 +3822,16 @@ var StaticServer = class {
         "Content-Type": contentType,
         "Cache-Control": cacheControl
       });
-      fs6.createReadStream(filePath).pipe(res);
+      fs7.createReadStream(filePath).pipe(res);
       return true;
     }
-    const indexPath = path6.join(this.uiDir, "index.html");
-    if (fs6.existsSync(indexPath)) {
+    const indexPath = path8.join(this.uiDir, "index.html");
+    if (fs7.existsSync(indexPath)) {
       res.writeHead(200, {
         "Content-Type": "text/html; charset=utf-8",
         "Cache-Control": "no-cache"
       });
-      fs6.createReadStream(indexPath).pipe(res);
+      fs7.createReadStream(indexPath).pipe(res);
       return true;
     }
     return false;
@@ -2922,29 +3840,29 @@ var StaticServer = class {
 
 // src/core/api/index.ts
 import * as http from "http";
-import * as fs7 from "fs";
-import * as path7 from "path";
-import * as os2 from "os";
-import * as crypto from "crypto";
+import * as fs8 from "fs";
+import * as path9 from "path";
+import * as os3 from "os";
+import * as crypto2 from "crypto";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/core/api/router.ts
 var Router = class {
   routes = [];
-  get(path8, handler) {
-    this.add("GET", path8, handler);
+  get(path10, handler) {
+    this.add("GET", path10, handler);
   }
-  post(path8, handler) {
-    this.add("POST", path8, handler);
+  post(path10, handler) {
+    this.add("POST", path10, handler);
   }
-  put(path8, handler) {
-    this.add("PUT", path8, handler);
+  put(path10, handler) {
+    this.add("PUT", path10, handler);
   }
-  patch(path8, handler) {
-    this.add("PATCH", path8, handler);
+  patch(path10, handler) {
+    this.add("PATCH", path10, handler);
   }
-  delete(path8, handler) {
-    this.add("DELETE", path8, handler);
+  delete(path10, handler) {
+    this.add("DELETE", path10, handler);
   }
   match(method, url) {
     const pathname = url.split("?")[0];
@@ -2960,9 +3878,9 @@ var Router = class {
     }
     return null;
   }
-  add(method, path8, handler) {
+  add(method, path10, handler) {
     const keys = [];
-    const pattern = path8.replace(/:(\w+)/g, (_, key) => {
+    const pattern = path10.replace(/:(\w+)/g, (_, key) => {
       keys.push(key);
       return "([^/]+)";
     });
@@ -3253,6 +4171,15 @@ function registerSessionRoutes(router, deps) {
       }
     });
   });
+  router.post("/api/sessions/:sessionId/summary", async (_req, res, params) => {
+    const sessionId = decodeURIComponent(params.sessionId);
+    const result = await deps.core.summarizeSession(sessionId);
+    if (result.ok) {
+      deps.sendJson(res, 200, result);
+    } else {
+      deps.sendJson(res, 400, result);
+    }
+  });
   router.post("/api/sessions/:sessionId/archive", async (_req, res, params) => {
     const sessionId = decodeURIComponent(params.sessionId);
     const result = await deps.core.archiveSession(sessionId);
@@ -3321,7 +4248,7 @@ function redactDeep(obj) {
 }
 function registerConfigRoutes(router, deps) {
   router.get("/api/config/editable", async (_req, res) => {
-    const { getSafeFields: getSafeFields2, resolveOptions: resolveOptions2, getConfigValue: getConfigValue2 } = await import("./config-registry-7I6GGDOY.js");
+    const { getSafeFields: getSafeFields2, resolveOptions: resolveOptions2, getConfigValue: getConfigValue2 } = await import("./config-registry-HDXFES2D.js");
     const config = deps.core.configManager.get();
     const safeFields = getSafeFields2();
     const fields = safeFields.map((def) => ({
@@ -3363,7 +4290,7 @@ function registerConfigRoutes(router, deps) {
       deps.sendJson(res, 400, { error: "Invalid config path" });
       return;
     }
-    const { getFieldDef: getFieldDef2 } = await import("./config-registry-7I6GGDOY.js");
+    const { getFieldDef: getFieldDef2 } = await import("./config-registry-HDXFES2D.js");
     const fieldDef = getFieldDef2(configPath);
     if (!fieldDef || fieldDef.scope !== "safe") {
       deps.sendJson(res, 403, {
@@ -3388,7 +4315,7 @@ function registerConfigRoutes(router, deps) {
     }
     const lastKey = parts[parts.length - 1];
     target[lastKey] = value;
-    const { ConfigSchema } = await import("./config-B26J3XXN.js");
+    const { ConfigSchema } = await import("./config-CQAS6YHR.js");
     const result = ConfigSchema.safeParse(cloned);
     if (!result.success) {
       deps.sendJson(res, 400, {
@@ -3408,7 +4335,7 @@ function registerConfigRoutes(router, deps) {
     }
     updateTarget[lastKey] = value;
     await deps.core.configManager.save(updates, configPath);
-    const { isHotReloadable: isHotReloadable2 } = await import("./config-registry-7I6GGDOY.js");
+    const { isHotReloadable: isHotReloadable2 } = await import("./config-registry-HDXFES2D.js");
     const needsRestart = !isHotReloadable2(configPath);
     deps.sendJson(res, 200, {
       ok: true,
@@ -3596,17 +4523,17 @@ function registerNotifyRoutes(router, deps) {
 
 // src/core/api/index.ts
 var log9 = createChildLogger({ module: "api-server" });
-var DEFAULT_PORT_FILE = path7.join(os2.homedir(), ".openacp", "api.port");
+var DEFAULT_PORT_FILE = path9.join(os3.homedir(), ".openacp", "api.port");
 var cachedVersion;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   try {
     const __filename = fileURLToPath2(import.meta.url);
-    const pkgPath = path7.resolve(
-      path7.dirname(__filename),
+    const pkgPath = path9.resolve(
+      path9.dirname(__filename),
       "../../../package.json"
     );
-    const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
     cachedVersion = pkg.version ?? "0.0.0-dev";
   } catch {
     cachedVersion = "0.0.0-dev";
@@ -3619,7 +4546,7 @@ var ApiServer = class {
     this.config = config;
     this.topicManager = topicManager;
     this.portFilePath = portFilePath ?? DEFAULT_PORT_FILE;
-    this.secretFilePath = secretFilePath ?? path7.join(os2.homedir(), ".openacp", "api-secret");
+    this.secretFilePath = secretFilePath ?? path9.join(os3.homedir(), ".openacp", "api-secret");
     this.staticServer = new StaticServer(uiDir);
     this.sseManager = new SSEManager(
       core.eventBus,
@@ -3713,24 +4640,24 @@ var ApiServer = class {
     return this.secret;
   }
   writePortFile() {
-    const dir = path7.dirname(this.portFilePath);
-    fs7.mkdirSync(dir, { recursive: true });
-    fs7.writeFileSync(this.portFilePath, String(this.actualPort));
+    const dir = path9.dirname(this.portFilePath);
+    fs8.mkdirSync(dir, { recursive: true });
+    fs8.writeFileSync(this.portFilePath, String(this.actualPort));
   }
   removePortFile() {
     try {
-      fs7.unlinkSync(this.portFilePath);
+      fs8.unlinkSync(this.portFilePath);
     } catch {
     }
   }
   loadOrCreateSecret() {
-    const dir = path7.dirname(this.secretFilePath);
-    fs7.mkdirSync(dir, { recursive: true });
+    const dir = path9.dirname(this.secretFilePath);
+    fs8.mkdirSync(dir, { recursive: true });
     try {
-      this.secret = fs7.readFileSync(this.secretFilePath, "utf-8").trim();
+      this.secret = fs8.readFileSync(this.secretFilePath, "utf-8").trim();
       if (this.secret) {
         try {
-          const stat = fs7.statSync(this.secretFilePath);
+          const stat = fs8.statSync(this.secretFilePath);
           const mode = stat.mode & 511;
           if (mode & 63) {
             log9.warn(
@@ -3745,14 +4672,14 @@ var ApiServer = class {
       }
     } catch {
     }
-    this.secret = crypto.randomBytes(32).toString("hex");
-    fs7.writeFileSync(this.secretFilePath, this.secret, { mode: 384 });
+    this.secret = crypto2.randomBytes(32).toString("hex");
+    fs8.writeFileSync(this.secretFilePath, this.secret, { mode: 384 });
   }
   authenticate(req, allowQueryParam = false) {
     const authHeader = req.headers.authorization;
     if (authHeader?.startsWith("Bearer ")) {
       const token = authHeader.slice(7);
-      if (token.length === this.secret.length && crypto.timingSafeEqual(
+      if (token.length === this.secret.length && crypto2.timingSafeEqual(
         Buffer.from(token, "utf-8"),
         Buffer.from(this.secret, "utf-8")
       )) {
@@ -3762,7 +4689,7 @@ var ApiServer = class {
     if (allowQueryParam) {
       const parsedUrl = new URL(req.url || "", "http://localhost");
       const qToken = parsedUrl.searchParams.get("token");
-      if (qToken && qToken.length === this.secret.length && crypto.timingSafeEqual(
+      if (qToken && qToken.length === this.secret.length && crypto2.timingSafeEqual(
         Buffer.from(qToken, "utf-8"),
         Buffer.from(this.secret, "utf-8")
       )) {
@@ -3940,10 +4867,14 @@ export {
   EventBus,
   SpeechService,
   GroqSTT,
+  ContextManager,
+  DEFAULT_MAX_TOKENS,
+  CheckpointReader,
+  EntireProvider,
   OpenACPCore,
   SSEManager,
   StaticServer,
   ApiServer,
   TopicManager
 };
-//# sourceMappingURL=chunk-FEWSQT3U.js.map
+//# sourceMappingURL=chunk-LO4Y5WQ7.js.map