@cydm/pie 1.0.24 → 1.0.25

package/dist/chunks/chunk-J4P2LP7K.js

@@ -1,3846 +0,0 @@
-import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import {
-  FileSystemGateway,
-  getPlatformConfig,
-  streamSimple
-} from "./chunk-HAAYC2N5.js";
-
-// ../../packages/agent-framework/src/session/compaction.ts
-var COMPACT_PROMPT = `You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.
-
-Include:
-- Current progress and key decisions made
-- Important context, constraints, or user preferences
-- What remains to be done (clear next steps)
-- Any critical data, examples, or references needed to continue
-
-Be concise, structured, and focused on helping the next LLM seamlessly continue the work.`;
-var SUMMARY_PREFIX = `Another language model started to solve this problem and produced a summary of its thinking process. You also have access to the state of the tools that were used by that language model. Use this to build on the work that has already been done and avoid duplicating work. Here is the summary produced by the other language model, use the information in this summary to assist with your own analysis:`;
-var DEFAULT_COMPACTION_CONFIG = {
-  maxMessages: 100,
-  maxTokens: 8e3,
-  keepRecentUserMessages: 3,
-  maxRetainedUserTokens: 2e4,
-  reserveTokens: 16384,
-  keepRecentTokens: 2e4,
-  autoCompact: true,
-  autoCompactTokenLimit: void 0,
-  compactPrompt: COMPACT_PROMPT,
-  summaryPrefix: SUMMARY_PREFIX
-};
-var APPROX_BYTES_PER_TOKEN = 4;
-var RESIZED_IMAGE_BYTES_ESTIMATE = 7373;
-function estimateTokens(message) {
-  return approximateBytesAsTokens(estimateModelVisibleBytes(message));
-}
-function calculateTotalTokens(messages) {
-  return messages.reduce((sum, m) => sum + estimateTokens(m), 0);
-}
-function calculateContextTokens(usage) {
-  return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
-}
-function getAssistantUsage(message) {
-  if (message.role !== "assistant") {
-    return void 0;
-  }
-  if (message.stopReason === "aborted" || message.stopReason === "error") {
-    return void 0;
-  }
-  if (calculateContextTokens(message.usage) <= 0) {
-    return void 0;
-  }
-  return message.usage;
-}
-function estimateContextTokens(messages) {
-  const localTokens = calculateTotalTokens(messages);
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const usage = getAssistantUsage(messages[i]);
-    if (!usage) {
-      continue;
-    }
-    const providerTokens = calculateContextTokens(usage);
-    const trailingTokens = calculateTotalTokens(messages.slice(i + 1));
-    const usageTokens = providerTokens;
-    return {
-      tokens: Math.max(providerTokens + trailingTokens, localTokens),
-      usageTokens,
-      providerTokens,
-      localTokens,
-      trailingTokens,
-      lastUsageIndex: i
-    };
-  }
-  return {
-    tokens: localTokens,
-    usageTokens: 0,
-    providerTokens: 0,
-    localTokens,
-    trailingTokens: localTokens,
-    lastUsageIndex: null
-  };
-}
-function getAutoCompactTokenLimit(contextWindow, reserveTokens, autoCompactTokenLimit) {
-  const explicitLimit = autoCompactTokenLimit !== void 0 && autoCompactTokenLimit > 0 ? Math.floor(autoCompactTokenLimit) : void 0;
-  if (!contextWindow || contextWindow <= 0) {
-    return explicitLimit;
-  }
-  const reserveLimit = reserveTokens >= contextWindow ? Math.floor(contextWindow * 0.8) : contextWindow - reserveTokens;
-  const windowLimit = Math.floor(contextWindow * 0.9);
-  const defaultLimit = Math.max(1, Math.min(reserveLimit, windowLimit));
-  return explicitLimit !== void 0 ? Math.min(defaultLimit, explicitLimit) : defaultLimit;
-}
-function isCompactSummaryMessage(message, summaryPrefix = SUMMARY_PREFIX) {
-  return message.startsWith(`${summaryPrefix}
-`);
-}
-function formatCompactSummaryText(summaryText, summaryPrefix = SUMMARY_PREFIX) {
-  const compactSummary = summaryText.trim() || "(no summary available)";
-  return `${summaryPrefix}
-${compactSummary}`;
-}
-function collectRealUserMessages(messages, summaryPrefix = SUMMARY_PREFIX) {
-  return messages.filter((message) => message.role === "user").map((message) => getUserMessageText(message)).filter((text) => Boolean(text)).filter((text) => !isCompactSummaryMessage(text, summaryPrefix)).filter((text) => !isSyntheticUserEnvelope(text));
-}
-function findFirstKeptEntryId(entries, options = {}) {
-  if (entries.length === 0) {
-    return null;
-  }
-  const fullConfig = { ...DEFAULT_COMPACTION_CONFIG, ...options };
-  const validCutPoints = collectValidCutPoints(entries);
-  if (validCutPoints.length === 0) {
-    return null;
-  }
-  let accumulatedTokens = 0;
-  let cutIndex = validCutPoints[0];
-  const keepRecentTokens = Math.max(1, fullConfig.keepRecentTokens);
-  for (let i = entries.length - 1; i >= 0; i--) {
-    const message = getMessageFromEntry(entries[i]);
-    if (!message) {
-      continue;
-    }
-    accumulatedTokens += estimateTokens(message);
-    if (accumulatedTokens >= keepRecentTokens) {
-      const nextCutPoint = validCutPoints.find((index) => index >= i);
-      const previousCutPoint = [...validCutPoints].reverse().find((index) => index <= i);
-      cutIndex = nextCutPoint ?? previousCutPoint ?? validCutPoints[0];
-      break;
-    }
-  }
-  return entries[cutIndex]?.id ?? null;
-}
-function createFileOps() {
-  return {
-    read: /* @__PURE__ */ new Set(),
-    written: /* @__PURE__ */ new Set(),
-    edited: /* @__PURE__ */ new Set()
-  };
-}
-function extractFileOpsFromMessage(message, fileOps) {
-  if (message.role !== "assistant") {
-    return;
-  }
-  for (const block of message.content) {
-    if (block.type !== "toolCall") {
-      continue;
-    }
-    const args = block.arguments;
-    const path = typeof args?.path === "string" ? args.path : void 0;
-    if (!path) {
-      continue;
-    }
-    switch (block.name) {
-      case "read_file":
-      case "read":
-        fileOps.read.add(path);
-        break;
-      case "write_file":
-      case "write":
-        fileOps.written.add(path);
-        break;
-      case "edit_file":
-      case "edit":
-        fileOps.edited.add(path);
-        break;
-    }
-  }
-}
-function computeFileLists(fileOps) {
-  const modified = /* @__PURE__ */ new Set([...fileOps.written, ...fileOps.edited]);
-  const readFiles = [...fileOps.read].filter((file) => !modified.has(file)).sort();
-  return {
-    readFiles,
-    modifiedFiles: [...modified].sort()
-  };
-}
-function formatFileOperations(readFiles, modifiedFiles) {
-  const sections = [];
-  if (readFiles.length > 0) {
-    sections.push(`<read-files>
-${readFiles.join("\n")}
-</read-files>`);
-  }
-  if (modifiedFiles.length > 0) {
-    sections.push(`<modified-files>
-${modifiedFiles.join("\n")}
-</modified-files>`);
-  }
-  return sections.length > 0 ? `
-
-${sections.join("\n\n")}` : "";
-}
-async function createCompactionSummary(messages, options = {}) {
-  const { model, apiKey, systemPrompt, compactPrompt, signal } = options;
-  const throwIfAborted = () => {
-    if (signal?.aborted) {
-      throw new Error("Compaction aborted");
-    }
-  };
-  if (!model) {
-    throwIfAborted();
-    return appendFileOperationsToSummary(createSimpleSummary(messages), messages);
-  }
-  try {
-    throwIfAborted();
-    const response = await streamSimple(
-      model,
-      {
-        systemPrompt,
-        messages: [
-          ...messages.filter(isCompactionCompatibleMessage),
-          {
-            role: "user",
-            content: [{ type: "text", text: compactPrompt ?? COMPACT_PROMPT }],
-            timestamp: Date.now()
-          }
-        ]
-      },
-      {
-        apiKey,
-        signal
-      }
-    ).result();
-    throwIfAborted();
-    return appendFileOperationsToSummary(getAssistantText(response) || createSimpleSummary(messages), messages);
-  } catch (error) {
-    throwIfAborted();
-    console.warn("[Compaction] Failed to create Codex-style summary:", error);
-    return appendFileOperationsToSummary(createSimpleSummary(messages), messages);
-  }
-}
-function getMessageText(message) {
-  if (message.role === "user") {
-    return getUserMessageText(message);
-  }
-  if (message.role === "assistant") {
-    return message.content.filter((c) => c.type === "text").map((c) => c.text).join(" ");
-  }
-  if (message.role === "toolResult") {
-    return message.content.filter((c) => c.type === "text").map((c) => c.text).join(" ");
-  }
-  return "";
-}
-function getMessageFromEntry(entry) {
-  if (entry.type === "message") {
-    return entry.message;
-  }
-  return void 0;
-}
-function collectValidCutPoints(entries) {
-  const cutPoints = [];
-  for (let i = 0; i < entries.length; i++) {
-    const entry = entries[i];
-    if (entry.type !== "message" || !entry.message) {
-      continue;
-    }
-    if (entry.message.role === "toolResult") {
-      continue;
-    }
-    cutPoints.push(i);
-  }
-  return cutPoints;
-}
-function getUserMessageText(message) {
-  if (typeof message.content === "string") {
-    return message.content;
-  }
-  return message.content.filter((c) => c.type === "text").map((c) => c.text).join(" ");
-}
-function getAssistantText(message) {
-  return message.content.filter((c) => c.type === "text").map((c) => c.text).join("").trim();
-}
-function createSimpleSummary(messages) {
-  const userMessages = collectRealUserMessages(messages);
-  const lastUserMessage = userMessages.at(-1);
-  const assistantCount = messages.filter((m) => m.role === "assistant").length;
-  const toolCount = messages.filter((m) => m.role === "toolResult").length;
-  return [
-    `- Conversation turns: ${messages.length}`,
-    `- Assistant responses: ${assistantCount}`,
-    `- Tool results: ${toolCount}`,
-    lastUserMessage ? `- Latest user request: ${lastUserMessage}` : ""
-  ].filter(Boolean).join("\n");
-}
-function appendFileOperationsToSummary(summary, messages) {
-  const fileOps = createFileOps();
-  for (const message of messages) {
-    extractFileOpsFromMessage(message, fileOps);
-  }
-  const { readFiles, modifiedFiles } = computeFileLists(fileOps);
-  return `${summary}${formatFileOperations(readFiles, modifiedFiles)}`;
-}
-function estimateModelVisibleBytes(message) {
-  const visibleMessage = normalizeModelVisibleMessage(message);
-  const wrapperBytes = utf8ByteLength(safeStringify(visibleMessage));
-  return wrapperBytes + estimateMessageMediaBytes(message);
-}
-function normalizeModelVisibleMessage(message) {
-  if (message.role === "user") {
-    return {
-      role: "user",
-      content: typeof message.content === "string" ? message.content : message.content.map(normalizeUserContentBlock)
-    };
-  }
-  if (message.role === "assistant") {
-    return {
-      role: "assistant",
-      content: message.content.map((block) => {
-        if (block.type === "text") {
-          return {
-            type: "text",
-            text: block.text,
-            ...block.textSignature ? { textSignature: block.textSignature } : {}
-          };
-        }
-        if (block.type === "thinking") {
-          return {
-            type: "thinking",
-            thinking: block.thinking,
-            ...block.thinkingSignature ? { thinkingSignature: block.thinkingSignature } : {}
-          };
-        }
-        if (block.type === "toolCall") {
-          return {
-            type: "toolCall",
-            id: block.id,
-            name: block.name,
-            arguments: block.arguments ?? {},
-            ...block.thoughtSignature ? { thoughtSignature: block.thoughtSignature } : {}
-          };
-        }
-        return block;
-      })
-    };
-  }
-  if (message.role === "toolResult") {
-    return {
-      role: "toolResult",
-      toolCallId: message.toolCallId,
-      toolName: message.toolName,
-      isError: message.isError,
-      content: message.content.map(normalizeUserContentBlock)
-    };
-  }
-  return {
-    role: String(message.role ?? "unknown"),
-    content: getMessageText(message)
-  };
-}
-function normalizeUserContentBlock(block) {
-  if (block.type === "text") {
-    return { type: "text", text: block.text };
-  }
-  if (block.type === "image") {
-    return { type: "image", mimeType: block.mimeType };
-  }
-  if (block.type === "audio") {
-    return { type: "audio", mimeType: block.mimeType };
-  }
-  if (block.type === "video") {
-    return { type: "video", mimeType: block.mimeType };
-  }
-  if (block.type === "fileRef") {
-    return {
-      type: "fileRef",
-      url: block.url,
-      mimeType: block.mimeType,
-      modality: block.modality
-    };
-  }
-  return block;
-}
-function estimateMessageMediaBytes(message) {
-  if (message.role === "user" && Array.isArray(message.content)) {
-    return message.content.reduce((sum, block) => sum + estimateUserContentBlockMediaBytes(block), 0);
-  }
-  if (message.role === "toolResult") {
-    return message.content.reduce((sum, block) => sum + estimateUserContentBlockMediaBytes(block), 0);
-  }
-  return 0;
-}
-function estimateUserContentBlockMediaBytes(block) {
-  if (block.type === "image") {
-    return estimateImageContentBytes(block);
-  }
-  if (block.type === "audio") {
-    return estimateInlineDataBytes(block);
-  }
-  if (block.type === "video") {
-    return estimateInlineDataBytes(block);
-  }
-  return 0;
-}
-function estimateImageContentBytes(block) {
-  return Math.max(RESIZED_IMAGE_BYTES_ESTIMATE, estimateInlineDataBytes(block));
-}
-function estimateInlineDataBytes(block) {
-  return utf8ByteLength(block.data || "");
-}
-function approximateBytesAsTokens(bytes) {
-  return Math.ceil(bytes / APPROX_BYTES_PER_TOKEN);
-}
-function safeStringify(value) {
-  try {
-    return JSON.stringify(value) ?? "";
-  } catch {
-    return String(value ?? "");
-  }
-}
-var utf8Encoder = typeof globalThis.TextEncoder === "function" ? new globalThis.TextEncoder() : void 0;
-function utf8ByteLength(text) {
-  if (utf8Encoder) {
-    return utf8Encoder.encode(text).length;
-  }
-  let bytes = 0;
-  for (const char of text) {
-    const codePoint = char.codePointAt(0) ?? 0;
-    if (codePoint <= 127) bytes += 1;
-    else if (codePoint <= 2047) bytes += 2;
-    else if (codePoint <= 65535) bytes += 3;
-    else bytes += 4;
-  }
-  return bytes;
-}
-function isSyntheticUserEnvelope(text) {
-  const trimmed = text.trimStart();
-  return trimmed.startsWith("<environment_context>") || trimmed.startsWith("<turn_aborted>") || trimmed.startsWith("# AGENTS.md instructions") || trimmed.startsWith("## Project Context\nProject-specific instructions from AGENTS.md");
-}
-function isCompactionCompatibleMessage(message) {
-  if (message.role === "user") return true;
-  if (message.role === "assistant") return true;
-  if (message.role === "toolResult") return true;
-  return false;
-}
-
-// ../../packages/agent-framework/src/session/types.ts
-function getGeneratedSessionName(createdAt) {
-  return `Session ${new Date(createdAt).toLocaleString()}`;
-}
-function generateEntryId() {
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 8);
-  return `entry-${timestamp}-${random}`;
-}
-function buildTree(entries, activeEntryId) {
-  const byId = /* @__PURE__ */ new Map();
-  const childrenMap = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    byId.set(entry.id, entry);
-    if (entry.parentId) {
-      const siblings = childrenMap.get(entry.parentId) ?? [];
-      siblings.push(entry.id);
-      childrenMap.set(entry.parentId, siblings);
-    }
-  }
-  const rootIds = entries.filter((e) => e.parentId === null).map((e) => e.id);
-  const activePath = /* @__PURE__ */ new Set();
-  if (activeEntryId) {
-    let current = activeEntryId;
-    while (current) {
-      activePath.add(current);
-      const entry = byId.get(current);
-      current = entry?.parentId ?? null;
-    }
-  }
-  function buildNode(entryId, depth) {
-    const entry = byId.get(entryId);
-    const childIds = childrenMap.get(entryId) ?? [];
-    return {
-      id: entryId,
-      parentId: entry.parentId,
-      entry,
-      children: childIds.map((id) => buildNode(id, depth + 1)),
-      depth,
-      isActive: activePath.has(entryId)
-    };
-  }
-  return rootIds.map((id) => buildNode(id, 0));
-}
-function flattenTreeToMessages(entries, activeEntryId) {
-  const byId = new Map(entries.map((e) => [e.id, e]));
-  const messages = [];
-  const path = [];
-  let current = activeEntryId;
-  while (current) {
-    path.unshift(current);
-    const entry = byId.get(current);
-    current = entry?.parentId ?? null;
-  }
-  const pathEntries = path.map((entryId) => byId.get(entryId)).filter((entry) => Boolean(entry));
-  const latestCompactionIndex = findLatestCompactionIndex(pathEntries);
-  if (latestCompactionIndex === -1) {
-    for (const entry of pathEntries) {
-      if (entry.type === "message" && entry.message) {
-        messages.push(entry.message);
-      }
-    }
-    return messages;
-  }
-  const compactionEntry = pathEntries[latestCompactionIndex];
-  const compactionData = compactionEntry.compactionData;
-  if (!compactionData) {
-    for (const entry of pathEntries) {
-      if (entry.type === "message" && entry.message) {
-        messages.push(entry.message);
-      }
-    }
-    return messages;
-  }
-  messages.push(createCompactionSummaryMessage(compactionData.summary, compactionEntry.timestamp));
-  let foundFirstKept = false;
-  for (let i = 0; i < latestCompactionIndex; i++) {
-    const entry = pathEntries[i];
-    if (entry.id === compactionData.firstKeptEntryId) {
-      foundFirstKept = true;
-    }
-    if (foundFirstKept && entry.type === "message" && entry.message) {
-      messages.push(entry.message);
-    }
-  }
-  for (let i = latestCompactionIndex + 1; i < pathEntries.length; i++) {
-    const entry = pathEntries[i];
-    if (entry.type === "message" && entry.message) {
-      messages.push(entry.message);
-    }
-  }
-  return messages;
-}
-function findLatestCompactionIndex(entries) {
-  for (let i = entries.length - 1; i >= 0; i--) {
-    if (entries[i].type === "compaction" && entries[i].compactionData) {
-      return i;
-    }
-  }
-  return -1;
-}
-function createCompactionSummaryMessage(summary, timestamp) {
-  return {
-    role: "user",
-    content: [{ type: "text", text: formatCompactSummaryText(summary) }],
-    timestamp
-  };
-}
-
-// ../../packages/agent-framework/src/session/durable-file.ts
-var DEFAULT_FILE_RETRY_DELAYS_MS = [0, 25, 75, 150];
-function durableFilePaths(filePath) {
-  return {
-    main: filePath,
-    backup: `${filePath}.bak`,
-    previous: `${filePath}.prev`
-  };
-}
-function isTransientFileError(error) {
-  const code = typeof error === "object" && error && "code" in error ? String(error.code) : "";
-  const message = error instanceof Error ? error.message : String(error);
-  return /^(EPERM|EACCES|EBUSY|ENOTEMPTY)$/.test(code) || /\b(EPERM|EACCES|EBUSY|locked|busy)\b/i.test(message);
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function retryFileOperation(operation, retryDelaysMs) {
-  let lastError;
-  for (const [index, delayMs] of retryDelaysMs.entries()) {
-    if (delayMs > 0) {
-      await sleep(delayMs);
-    }
-    try {
-      operation();
-      return;
-    } catch (error) {
-      lastError = error;
-      if (!isTransientFileError(error) || index === retryDelaysMs.length - 1) {
-        throw error;
-      }
-    }
-  }
-  throw lastError;
-}
-function retryDelays(options) {
-  return options.retryDelaysMs ?? DEFAULT_FILE_RETRY_DELAYS_MS;
-}
-function tempPathFor(filePath, operation) {
-  return `${filePath}.${operation}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-}
-async function replaceFile(gateway, filePath, content, retryDelaysMs) {
-  const tempPath = tempPathFor(filePath, "durable");
-  gateway.writeFile(tempPath, content, "utf-8");
-  try {
-    try {
-      await retryFileOperation(() => gateway.renameFile(tempPath, filePath), retryDelaysMs);
-    } catch {
-      await retryFileOperation(() => gateway.copyFile(tempPath, filePath), retryDelaysMs);
-      try {
-        gateway.deleteFile(tempPath);
-      } catch {
-      }
-    }
-  } catch (error) {
-    try {
-      gateway.deleteFile(tempPath);
-    } catch {
-    }
-    throw error;
-  }
-}
-async function copyExistingFile(gateway, sourcePath, destinationPath, retryDelaysMs) {
-  if (!gateway.exists(sourcePath)) {
-    return false;
-  }
-  await retryFileOperation(() => gateway.copyFile(sourcePath, destinationPath), retryDelaysMs);
-  return true;
-}
-function readCandidate(options, role, path) {
-  if (!options.gateway.exists(path)) {
-    return null;
-  }
-  const rawContent = options.gateway.readFile(path, "utf-8");
-  const parsed = options.parse(rawContent, path);
-  const updatedAt = Number.isFinite(parsed.updatedAt) ? parsed.updatedAt : 0;
-  return {
-    ...parsed,
-    updatedAt,
-    role,
-    path,
-    rawContent
-  };
-}
-function candidatePriority(role) {
-  if (role === "main") return 3;
-  if (role === "backup") return 2;
-  return 1;
-}
-function chooseBestDurableFileCandidate(candidates) {
-  const main = candidates.find((candidate) => candidate.role === "main");
-  if (main) {
-    const backup = candidates.find((candidate) => candidate.role === "backup");
-    const previous = candidates.find((candidate) => candidate.role === "previous");
-    if (backup && previous && backup.content !== main.content && previous.content === main.content && backup.updatedAt >= main.updatedAt) {
-      return backup;
-    }
-    return main;
-  }
-  return [...candidates].sort((a, b) => {
-    const updatedAtDiff = b.updatedAt - a.updatedAt;
-    if (updatedAtDiff !== 0) return updatedAtDiff;
-    return candidatePriority(b.role) - candidatePriority(a.role);
-  })[0];
-}
-async function writeDurableFile(options, content) {
-  const parsed = options.parse(content, options.filePath);
-  const durableContent = parsed.content;
-  const paths = durableFilePaths(options.filePath);
-  const delays = retryDelays(options);
-  if (options.gateway.exists(paths.backup)) {
-    await copyExistingFile(options.gateway, paths.backup, paths.previous, delays);
-  }
-  await replaceFile(options.gateway, paths.backup, durableContent, delays);
-  await replaceFile(options.gateway, paths.main, durableContent, delays);
-}
-async function loadDurableFile(options) {
-  const paths = durableFilePaths(options.filePath);
-  const roles = [
-    ["main", paths.main],
-    ["backup", paths.backup],
-    ["previous", paths.previous]
-  ];
-  const candidates = [];
-  for (const [role, path] of roles) {
-    try {
-      const candidate = readCandidate(options, role, path);
-      if (candidate) {
-        candidates.push(candidate);
-      }
-    } catch {
-    }
-  }
-  if (candidates.length === 0) {
-    return null;
-  }
-  const best = chooseBestDurableFileCandidate(candidates);
-  if (!best) {
-    return null;
-  }
-  const main = candidates.find((candidate) => candidate.role === "main");
-  const backup = candidates.find((candidate) => candidate.role === "backup");
-  const needsMainRestore = !main || main.rawContent !== best.content;
-  const needsBackupRefresh = !backup || backup.rawContent !== best.content;
-  let restoredMain = false;
-  let refreshedBackup = false;
-  let repairError;
-  const delays = retryDelays(options);
-  try {
-    if (needsBackupRefresh) {
-      if (backup && backup.rawContent !== best.content) {
-        await replaceFile(options.gateway, paths.previous, backup.content, delays);
-      }
-      await replaceFile(options.gateway, paths.backup, best.content, delays);
-      refreshedBackup = true;
-    }
-    if (needsMainRestore) {
-      await replaceFile(options.gateway, paths.main, best.content, delays);
-      restoredMain = true;
-    }
-  } catch (error) {
-    repairError = error;
-  }
-  return {
-    data: best.data,
-    content: best.content,
-    source: best.role,
-    restoredMain,
-    refreshedBackup,
-    repairError
-  };
-}
-function durableFileExists(gateway, filePath) {
-  const paths = durableFilePaths(filePath);
-  return gateway.exists(paths.main) || gateway.exists(paths.backup) || gateway.exists(paths.previous);
-}
-function deleteDurableFile(gateway, filePath) {
-  const paths = durableFilePaths(filePath);
-  let deleted = false;
-  for (const path of [paths.main, paths.backup, paths.previous]) {
-    if (gateway.exists(path)) {
-      gateway.deleteFile(path);
-      deleted = true;
-    }
-  }
-  return deleted;
-}
-
-// ../../packages/agent-framework/src/session/store.ts
-var SESSION_VERSION = 2;
-var METADATA_INDEX_VERSION = 3;
-var METADATA_FAST_READ_BYTES = 64 * 1024;
-function isSessionEntry(value) {
-  return !!value && typeof value === "object" && "id" in value && "type" in value;
-}
-function normalizeEntriesInput(entriesOrMessages) {
-  if (entriesOrMessages.every(isSessionEntry)) {
-    return entriesOrMessages;
-  }
-  const entries = [];
-  let parentId = null;
-  for (const message of entriesOrMessages) {
-    const entry = {
-      id: generateEntryId(),
-      parentId,
-      type: "message",
-      timestamp: Date.now(),
-      message
-    };
-    entries.push(entry);
-    parentId = entry.id;
-  }
-  return entries;
-}
-function extractJsonObjectProperty(content, propertyName) {
-  const propertyIndex = content.indexOf(`"${propertyName}"`);
-  if (propertyIndex < 0) return null;
-  const colonIndex = content.indexOf(":", propertyIndex + propertyName.length + 2);
-  if (colonIndex < 0) return null;
-  let index = colonIndex + 1;
-  while (index < content.length && /\s/.test(content[index])) index += 1;
-  if (content[index] !== "{") return null;
-  let depth = 0;
-  let inString = false;
-  let escaping = false;
-  for (let cursor = index; cursor < content.length; cursor += 1) {
-    const char = content[cursor];
-    if (inString) {
-      if (escaping) {
-        escaping = false;
-      } else if (char === "\\") {
-        escaping = true;
-      } else if (char === '"') {
-        inString = false;
-      }
-      continue;
-    }
-    if (char === '"') {
-      inString = true;
-      continue;
-    }
-    if (char === "{") {
-      depth += 1;
-    } else if (char === "}") {
-      depth -= 1;
-      if (depth === 0) {
-        return content.slice(index, cursor + 1);
-      }
-    }
-  }
-  return null;
-}
-function parseMetadataOnly(content) {
-  const metadataText = extractJsonObjectProperty(content, "metadata");
-  if (!metadataText) return null;
-  const parsed = JSON.parse(metadataText);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-  const metadata = parsed;
-  if (typeof metadata.id !== "string" || typeof metadata.name !== "string" || typeof metadata.createdAt !== "number" || typeof metadata.updatedAt !== "number" || typeof metadata.entryCount !== "number" || typeof metadata.messageCount !== "number") {
-    return null;
-  }
-  return metadata;
-}
-function durableRolePriority(role) {
-  if (role === "main") return 3;
-  if (role === "backup") return 2;
-  return 1;
-}
-var LEGACY_VERSION = 1;
-function getDefaultSessionsDir() {
-  return getPlatformConfig().sessionsPath;
-}
-function migrateV1ToV2(data) {
-  const messages = data.messages ?? [];
-  const entries = [];
-  let parentId = null;
-  for (const message of messages) {
-    const entry = {
-      id: generateEntryId(),
-      parentId,
-      type: "message",
-      timestamp: Date.now(),
-      message
-    };
-    entries.push(entry);
-    parentId = entry.id;
-  }
-  const activeEntryId = entries.length > 0 ? entries[entries.length - 1].id : null;
-  const rootEntryId = entries.length > 0 ? entries[0].id : null;
-  return {
-    version: SESSION_VERSION,
-    metadata: {
-      ...data.metadata,
-      entryCount: entries.length,
-      messageCount: messages.length,
-      activeEntryId,
-      rootEntryId
-    },
-    entries,
-    messages
-    // Keep for backward compatibility
-  };
-}
-function decodePersistedSessionContent(content) {
-  if (!content || content.trim().length === 0) {
-    throw new Error("empty session file");
-  }
-  let data = JSON.parse(content);
-  let shouldPersist = false;
-  const sourceVersion = data.version;
-  let versionMismatch;
-  if (sourceVersion === LEGACY_VERSION || !sourceVersion) {
-    if (data.metadata === null || data.metadata === void 0) {
-      throw new Error("legacy session metadata is missing");
-    }
-    data = migrateV1ToV2(data);
-    shouldPersist = true;
-  } else {
-    if (sourceVersion !== SESSION_VERSION) {
-      versionMismatch = { actual: sourceVersion, expected: SESSION_VERSION };
-    }
-    if (!data.entries) {
-      data.entries = [];
-    }
-  }
-  return {
-    data,
-    content: shouldPersist ? JSON.stringify(data, null, 2) : content,
-    updatedAt: Number.isFinite(data.metadata?.updatedAt) ? data.metadata.updatedAt : 0,
-    ...shouldPersist ? { migratedFromVersion: sourceVersion ?? 0 } : {},
-    ...versionMismatch ? { versionMismatch } : {}
-  };
-}
-var FileSessionStore = class {
-  sessionsDir;
-  gateway;
-  constructor(sessionsDir) {
-    this.sessionsDir = sessionsDir || getDefaultSessionsDir();
-    this.gateway = new FileSystemGateway({
-      allowedRoots: [this.sessionsDir, getPlatformConfig().dataPath]
-    });
-    this.ensureDirectory();
-  }
-  /**
-   * Ensure the sessions directory exists
-   */
-  ensureDirectory() {
-    try {
-      if (!this.gateway.exists(this.sessionsDir)) {
-        this.gateway.mkdir(this.sessionsDir, { recursive: true });
-      }
-    } catch (e) {
-      console.warn(`[FileSessionStore] Could not create sessions directory: ${e}`);
-    }
-  }
-  /**
-   * Get the full path for a session file
-   */
-  getSessionPath(sessionId) {
-    const safeId = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
-    return this.gateway.join(this.sessionsDir, `${safeId}.json`);
-  }
-  getMetadataIndexPath() {
-    return this.gateway.join(this.sessionsDir, ".metadata-index.json");
-  }
-  parseSessionContent(content) {
-    const decoded = decodePersistedSessionContent(content);
-    if (decoded.migratedFromVersion !== void 0) {
-      console.log(`[SessionStore] Migrating session ${decoded.data.metadata.id} from v1 to v2`);
-    }
-    if (decoded.versionMismatch) {
-      console.warn(
-        `[SessionStore] Session version mismatch: ${decoded.versionMismatch.actual} vs ${decoded.versionMismatch.expected}`
-      );
-    }
-    return decoded;
-  }
-  /**
-   * Save a session to disk (v2 format)
-   */
-  async save(sessionId, entries, metadata) {
-    const normalizedEntries = normalizeEntriesInput(entries);
-    const now = Date.now();
-    const existing = await this.load(sessionId);
-    const requestedUpdatedAt = metadata?.updatedAt ?? now;
-    const updatedAt = Math.max(requestedUpdatedAt, existing?.metadata.updatedAt ?? 0);
-    const nameOrigin = metadata?.nameOrigin ?? (metadata?.name !== void 0 && metadata.name !== existing?.metadata.name ? "explicit" : existing ? existing.metadata.nameOrigin : "generated");
-    const messageCount = normalizedEntries.filter((e) => e.type === "message" && e.message).length;
-    const rootEntry = normalizedEntries.find((e) => e.parentId === null);
-    const activeEntryId = metadata?.activeEntryId ?? existing?.metadata.activeEntryId ?? normalizedEntries[normalizedEntries.length - 1]?.id ?? null;
-    const sessionData = {
-      version: SESSION_VERSION,
-      metadata: {
-        id: sessionId,
-        name: metadata?.name ?? existing?.metadata.name ?? `Session ${sessionId.slice(0, 8)}`,
-        createdAt: existing?.metadata.createdAt ?? now,
-        entryCount: normalizedEntries.length,
-        messageCount,
-        activeEntryId: activeEntryId ?? rootEntry?.id ?? null,
-        rootEntryId: rootEntry?.id ?? null,
-        tags: metadata?.tags ?? existing?.metadata.tags,
-        ...metadata,
-        nameOrigin,
-        updatedAt
-      },
-      entries: normalizedEntries,
-      messages: flattenTreeToMessages(normalizedEntries, activeEntryId ?? null)
-    };
-    const json = JSON.stringify(sessionData, null, 2);
-    const filePath = this.getSessionPath(sessionId);
-    await writeDurableFile({
-      gateway: this.gateway,
-      filePath,
-      parse: (content) => this.parseSessionContent(content)
-    }, json);
-    await this.upsertMetadataIndexBestEffort(sessionId);
-  }
-  /**
-   * Legacy save method for backward compatibility
-   * @deprecated Use save() with entries instead
-   */
-  async saveLegacy(sessionId, messages, metadata) {
-    console.warn("[FileSessionStore] Using deprecated saveLegacy() - consider migrating to v2");
-    const entries = [];
-    let parentId = null;
-    for (const message of messages) {
-      const entry = {
-        id: generateEntryId(),
-        parentId,
-        type: "message",
-        timestamp: Date.now(),
-        message
-      };
-      entries.push(entry);
-      parentId = entry.id;
-    }
-    await this.save(sessionId, entries, metadata);
-  }
-  /**
-   * Load a session from disk
-   */
-  async load(sessionId) {
-    const filePath = this.getSessionPath(sessionId);
-    try {
-      const loaded = await loadDurableFile({
-        gateway: this.gateway,
-        filePath,
-        parse: (content) => this.parseSessionContent(content)
-      });
-      if (!loaded) {
-        return null;
-      }
-      if (loaded.restoredMain || loaded.refreshedBackup) {
-        console.warn(
-          `[SessionStore] Repaired session ${sessionId} from ${loaded.source}` + (loaded.repairError ? ` with repair warning: ${loaded.repairError}` : "")
-        );
-      } else if (loaded.repairError) {
-        console.warn(`[SessionStore] Loaded session ${sessionId} but sidecar refresh failed: ${loaded.repairError}`);
-      }
-      return loaded.data;
-    } catch (e) {
-      console.error(`[SessionStore] Failed to load session: ${sessionId}`, e);
-      return null;
-    }
-  }
-  /**
-   * Delete a session
-   */
-  async delete(sessionId) {
-    const filePath = this.getSessionPath(sessionId);
-    try {
-      const deleted = deleteDurableFile(this.gateway, filePath);
-      if (deleted) this.removeMetadataIndexEntryBestEffort(sessionId);
-      return deleted;
-    } catch (e) {
-      console.error(`[SessionStore] Failed to delete session: ${sessionId}`, e);
-      return false;
-    }
-  }
-  /**
-   * Check if a session exists
-   */
-  async exists(sessionId) {
-    const filePath = this.getSessionPath(sessionId);
-    return durableFileExists(this.gateway, filePath);
-  }
-  /**
-   * List all session IDs
-   */
-  async list() {
-    return this.listSessionIdsSync();
-  }
-  listSessionIdsSync() {
-    if (!this.gateway.exists(this.sessionsDir)) {
-      return [];
-    }
-    const files = this.gateway.readdir(this.sessionsDir);
-    const sessionIds = /* @__PURE__ */ new Set();
-    for (const file of files) {
-      if (isSessionSidecarFile(file)) {
-        continue;
-      }
-      if (file.endsWith(".json")) {
-        sessionIds.add(file.replace(/\.json$/i, ""));
-      } else if (file.endsWith(".json.bak")) {
-        sessionIds.add(file.replace(/\.json\.bak$/i, ""));
-      } else if (file.endsWith(".json.prev")) {
-        sessionIds.add(file.replace(/\.json\.prev$/i, ""));
-      }
-    }
-    return [...sessionIds];
-  }
-  /**
-   * List all session metadata
-   */
-  async listMetadata() {
-    return await this.listMetadataIndexed();
-  }
-  async listMetadataPage(input) {
-    const limit = Math.max(0, input.limit);
-    if (limit === 0) return { metadata: [], hasMore: false };
-    const result = [];
-    for (const metadata of await this.listMetadataIndexed()) {
-      if (input.after && compareMetadataListPosition(metadata, input.after) <= 0) continue;
-      if (input.filter && !input.filter(metadata)) continue;
-      result.push(metadata);
-      if (result.length > limit) break;
-    }
-    return {
-      metadata: result.slice(0, limit),
-      hasMore: result.length > limit
-    };
-  }
-  /**
-   * Get session metadata without loading full entries
-   */
-  async getMetadata(sessionId) {
-    const fastMetadata = this.getMetadataFast(sessionId);
-    if (fastMetadata) return fastMetadata;
-    const data = await this.load(sessionId);
-    return data?.metadata ?? null;
-  }
-  getMetadataFast(sessionId) {
-    const paths = durableFilePaths(this.getSessionPath(sessionId));
-    const candidates = [];
-    for (const [role, path] of [
-      ["main", paths.main],
-      ["backup", paths.backup],
-      ["previous", paths.previous]
-    ]) {
-      try {
-        if (!this.gateway.exists(path)) continue;
-        const metadata = this.readMetadataOnlyFast(path);
-        if (metadata) candidates.push({ metadata, role });
-      } catch {
-      }
-    }
-    if (candidates.length === 0) return null;
-    return chooseBestMetadataCandidate(candidates).metadata;
-  }
-  readMetadataOnlyFast(path) {
-    const fileSize = this.gateway.getFileSize(path);
-    if (fileSize <= METADATA_FAST_READ_BYTES) {
-      return parseMetadataOnly(this.gateway.readFile(path, "utf-8"));
-    }
-    const head = this.gateway.readFileHead(path, METADATA_FAST_READ_BYTES, "utf-8");
-    const metadata = parseMetadataOnly(head);
-    if (metadata) return metadata;
-    return parseMetadataOnly(this.gateway.readFile(path, "utf-8"));
-  }
-  async listMetadataIndexed() {
-    for (let attempt = 0; attempt < 2; attempt++) {
-      const sessionIds = await this.list();
-      const sessionIdSet = new Set(sessionIds);
-      const index = this.readMetadataIndexBestEffort();
-      if (index && this.metadataIndexMatchesSessionFiles(index, sessionIdSet)) {
-        return sortMetadata(index.sessions.map((entry) => entry.metadata).filter((metadata2) => sessionIdSet.has(metadata2.id)));
-      }
-      const entries = await this.readStableMetadataIndexEntries(sessionIds);
-      if (entries) {
-        this.writeMetadataIndexEntriesBestEffort(entries);
-        return sortMetadata(entries.map((entry) => entry.metadata));
-      }
-    }
-    const metadata = [];
-    for (const id of await this.list()) {
-      const item = await this.getMetadata(id);
-      if (item) metadata.push(item);
-    }
-    return sortMetadata(metadata);
-  }
-  /**
-   * Cheap recent-first listing: when the metadata index is cold, stat-sort by
-   * file mtime and parse metadata only for the most recent `limit` sessions,
-   * then rebuild the full index in the background (chunked, off the critical
-   * path). Avoids parsing thousands of session files on the first /resume.
-   */
-  async listMetadataRecent(limit) {
-    const sessionIds = await this.list();
-    const sessionIdSet = new Set(sessionIds);
-    const index = this.readMetadataIndexBestEffort();
-    if (index && this.metadataIndexMatchesSessionFiles(index, sessionIdSet)) {
-      const sorted = sortMetadata(index.sessions.map((entry) => entry.metadata).filter((metadata) => sessionIdSet.has(metadata.id)));
-      return { metadata: sorted.slice(0, limit), totalCount: sorted.length };
-    }
-    const ranked = [];
-    for (const id of sessionIds) {
-      const paths = durableFilePaths(this.getSessionPath(id));
-      let mtimeMs = 0;
-      for (const candidate of [paths.main, paths.backup, paths.previous]) {
-        try {
-          if (this.gateway.exists(candidate)) {
-            mtimeMs = this.gateway.getModifiedTime(candidate);
-            break;
-          }
-        } catch {
-        }
-      }
-      if (mtimeMs > 0) {
-        ranked.push({ id, mtimeMs });
-      }
-    }
-    ranked.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    const recent = [];
-    for (const { id } of ranked.slice(0, limit)) {
-      const meta = await this.getMetadata(id);
-      if (meta) recent.push(meta);
-    }
-    this.scheduleIndexRebuild(sessionIds);
-    return { metadata: sortMetadata(recent), totalCount: ranked.length };
-  }
-  indexRebuildInFlight = false;
-  indexRebuildPromise = null;
-  /**
-   * Resolves when the background metadata index rebuild (if any) completes.
-   * Resolves immediately when no rebuild is in flight.
-   */
-  whenIndexRebuilt() {
-    return this.indexRebuildPromise ?? Promise.resolve();
-  }
-  /** Rebuild the full metadata index in small chunks, off the critical path. */
-  scheduleIndexRebuild(sessionIds) {
-    if (this.indexRebuildInFlight) return;
-    this.indexRebuildInFlight = true;
-    this.indexRebuildPromise = (async () => {
-      try {
-        const entries = await this.readStableMetadataIndexEntries(sessionIds, 50);
-        if (!entries) return;
-        this.writeMetadataIndexEntriesBestEffort(entries);
-      } catch {
-      } finally {
-        this.indexRebuildInFlight = false;
-        this.indexRebuildPromise = null;
-      }
-    })();
-  }
-  async readStableMetadataIndexEntry(sessionId) {
-    try {
-      const before = this.sessionFileSignature(sessionId);
-      const metadata = await this.getMetadata(sessionId);
-      const after = this.sessionFileSignature(sessionId);
-      if (!metadata || !sessionFileSignaturesEqual(before, after)) return null;
-      return { metadata, files: after };
-    } catch {
-      return null;
-    }
-  }
-  async readStableMetadataIndexEntries(sessionIds, yieldEvery = 0) {
-    const entries = [];
-    for (let index = 0; index < sessionIds.length; index++) {
-      const entry = await this.readStableMetadataIndexEntry(sessionIds[index]);
-      if (!entry) return null;
-      entries.push(entry);
-      if (yieldEvery > 0 && (index + 1) % yieldEvery === 0 && index + 1 < sessionIds.length) {
-        await new Promise((resolve) => setImmediate(resolve));
-      }
-    }
-    return this.metadataIndexSnapshotStillCurrent(entries, sessionIds) ? entries : null;
-  }
-  metadataIndexSnapshotStillCurrent(entries, expectedSessionIds) {
-    try {
-      const currentIds = new Set(this.listSessionIdsSync());
-      const expectedIds = new Set(expectedSessionIds);
-      if (currentIds.size !== expectedIds.size || expectedIds.size !== entries.length) return false;
-      for (const id of expectedIds) {
-        if (!currentIds.has(id)) return false;
-      }
-      return entries.every(
-        (entry) => expectedIds.has(entry.metadata.id) && sessionFileSignaturesEqual(entry.files, this.sessionFileSignature(entry.metadata.id))
-      );
-    } catch {
-      return false;
-    }
-  }
-  readMetadataIndexBestEffort() {
-    try {
-      if (!this.gateway.exists(this.getMetadataIndexPath())) return null;
-      const parsed = JSON.parse(this.gateway.readFile(this.getMetadataIndexPath(), "utf-8"));
-      if (!isRecord(parsed) || parsed.v !== METADATA_INDEX_VERSION || !Array.isArray(parsed.sessions)) return null;
-      const sessions = parsed.sessions.filter(isMetadataIndexEntry);
-      if (sessions.length !== parsed.sessions.length) return null;
-      return {
-        v: METADATA_INDEX_VERSION,
-        sessions,
-        updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : 0
-      };
-    } catch {
-      return null;
-    }
-  }
-  writeMetadataIndexEntriesBestEffort(sessions) {
-    try {
-      this.gateway.writeFile(this.getMetadataIndexPath(), JSON.stringify({
-        v: METADATA_INDEX_VERSION,
-        updatedAt: Date.now(),
-        sessions: [...sessions].sort(
-          (left, right) => compareMetadataListPosition(left.metadata, right.metadata)
-        )
-      }, null, 2));
-    } catch {
-    }
-  }
-  async upsertMetadataIndexBestEffort(sessionId) {
-    try {
-      const savedEntry = await this.readStableMetadataIndexEntry(sessionId);
-      if (!savedEntry) {
-        this.removeMetadataIndexFileBestEffort();
-        return;
-      }
-      const current = this.readMetadataIndexBestEffort();
-      const next = (current?.sessions ?? []).filter((entry) => entry.metadata.id !== sessionId);
-      next.push(savedEntry);
-      const sessionIds = this.listSessionIdsSync();
-      if (!this.metadataIndexSnapshotStillCurrent(next, sessionIds)) {
-        this.removeMetadataIndexFileBestEffort();
-        return;
-      }
-      this.writeMetadataIndexEntriesBestEffort(next);
-    } catch {
-      this.removeMetadataIndexFileBestEffort();
-    }
-  }
-  removeMetadataIndexEntryBestEffort(sessionId) {
-    try {
-      const current = this.readMetadataIndexBestEffort();
-      if (!current) return;
-      const next = current.sessions.filter((entry) => entry.metadata.id !== sessionId);
-      if (!this.metadataIndexSnapshotStillCurrent(next, this.listSessionIdsSync())) {
-        this.removeMetadataIndexFileBestEffort();
-        return;
-      }
-      this.writeMetadataIndexEntriesBestEffort(next);
-    } catch {
-      this.removeMetadataIndexFileBestEffort();
-    }
-  }
-  removeMetadataIndexFileBestEffort() {
-    try {
-      if (this.gateway.exists(this.getMetadataIndexPath())) this.gateway.deleteFile(this.getMetadataIndexPath());
-    } catch {
-    }
-  }
-  metadataIndexMatchesSessionFiles(index, sessionIds) {
-    try {
-      if (index.sessions.length !== sessionIds.size) return false;
-      const indexedIds = new Set(index.sessions.map((entry) => entry.metadata.id));
-      if (indexedIds.size !== index.sessions.length) return false;
-      for (const id of sessionIds) {
-        if (!indexedIds.has(id)) return false;
-      }
-      return index.sessions.every(
-        (entry) => sessionFileSignaturesEqual(entry.files, this.sessionFileSignature(entry.metadata.id))
-      );
-    } catch {
-      return false;
-    }
-  }
-  sessionFileSignature(sessionId) {
-    const paths = durableFilePaths(this.getSessionPath(sessionId));
-    return {
-      ...this.gateway.exists(paths.main) ? { main: this.fileSignature(paths.main) } : {},
-      ...this.gateway.exists(paths.backup) ? { backup: this.fileSignature(paths.backup) } : {},
-      ...this.gateway.exists(paths.previous) ? { previous: this.fileSignature(paths.previous) } : {}
-    };
-  }
-  fileSignature(path) {
-    return {
-      size: this.gateway.getFileSize(path),
-      modifiedAt: this.gateway.getModifiedTime(path)
-    };
-  }
-};
-function isSessionSidecarFile(file) {
-  return file === ".metadata-index.json" || file.endsWith(".trace.json") || file.endsWith(".trace.json.bak") || file.endsWith(".trace.json.prev") || file.endsWith("-files.json") || file.endsWith("-files.json.bak") || file.endsWith("-files.json.prev") || // magic-shell channel state/inbox files share the sessions directory
-  // but are not sessions; counting them breaks the metadata index check
-  // (index size never matches id count, forcing a full rebuild every list).
-  file.includes(".magic-shell-");
-}
-function sortMetadata(metadata) {
-  return [...metadata].sort((a, b) => b.updatedAt - a.updatedAt || a.id.localeCompare(b.id));
-}
-function chooseBestMetadataCandidate(candidates) {
-  const main = candidates.find((candidate) => candidate.role === "main");
-  if (main) {
-    const backup = candidates.find((candidate) => candidate.role === "backup");
-    const previous = candidates.find((candidate) => candidate.role === "previous");
-    if (backup && previous && !metadataObjectsEqual(backup.metadata, main.metadata) && metadataObjectsEqual(previous.metadata, main.metadata) && backup.metadata.updatedAt >= main.metadata.updatedAt) {
-      return backup;
-    }
-    return main;
-  }
-  return [...candidates].sort((left, right) => {
-    const updatedAtDiff = right.metadata.updatedAt - left.metadata.updatedAt;
-    if (updatedAtDiff !== 0) return updatedAtDiff;
-    return durableRolePriority(right.role) - durableRolePriority(left.role);
-  })[0];
-}
-function metadataObjectsEqual(left, right) {
-  return stableJson(left) === stableJson(right);
-}
-function stableJson(value) {
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableJson(item)).join(",")}]`;
-  }
-  if (isRecord(value)) {
-    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-function compareMetadataListPosition(metadata, boundary) {
-  const updatedAtDiff = boundary.updatedAt - metadata.updatedAt;
-  if (updatedAtDiff !== 0) return updatedAtDiff;
-  return metadata.id.localeCompare(boundary.id);
-}
-function isSessionMetadata(value) {
-  if (!isRecord(value)) return false;
-  return typeof value.id === "string" && typeof value.name === "string" && typeof value.createdAt === "number" && typeof value.updatedAt === "number" && typeof value.entryCount === "number" && typeof value.messageCount === "number";
-}
-function isMetadataIndexEntry(value) {
-  if (!isRecord(value) || !isSessionMetadata(value.metadata) || !isRecord(value.files)) return false;
-  return optionalFileSignature(value.files.main) && optionalFileSignature(value.files.backup) && optionalFileSignature(value.files.previous);
-}
-function optionalFileSignature(value) {
-  if (value === void 0) return true;
-  return isRecord(value) && typeof value.size === "number" && Number.isFinite(value.size) && typeof value.modifiedAt === "number" && Number.isFinite(value.modifiedAt);
-}
-function sessionFileSignaturesEqual(left, right) {
-  return fileSignaturesEqual(left.main, right.main) && fileSignaturesEqual(left.backup, right.backup) && fileSignaturesEqual(left.previous, right.previous);
-}
-function fileSignaturesEqual(left, right) {
-  if (!left || !right) return left === right;
-  return left.size === right.size && left.modifiedAt === right.modifiedAt;
-}
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
-// ../../packages/agent-framework/src/session/manager.ts
-function generateSessionId() {
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 8);
-  return `${timestamp}-${random}`;
-}
-var SessionManager = class {
-  store;
-  activeSession = null;
-  options;
-  autoSaveTimer = null;
-  gateway;
-  constructor(options = {}) {
-    this.options = {
-      sessionsDir: options.sessionsDir ?? getDefaultSessionsDir(),
-      autoSaveInterval: options.autoSaveInterval ?? 0,
-      maxSessions: options.maxSessions ?? 100,
-      version: options.version ?? 2
-    };
-    this.gateway = new FileSystemGateway({
-      allowedRoots: [this.options.sessionsDir, getPlatformConfig().dataPath]
-    });
-    if (!this.gateway.exists(this.options.sessionsDir)) {
-      this.gateway.mkdir(this.options.sessionsDir, { recursive: true });
-    }
-    this.store = new FileSessionStore(this.options.sessionsDir);
-    if (this.options.autoSaveInterval > 0) {
-      this.startAutoSave();
-    }
-  }
-  /**
-   * Get the session store
-   */
-  getStore() {
-    return this.store;
-  }
-  /**
-   * Start auto-save timer
-   */
-  startAutoSave() {
-    if (this.autoSaveTimer) {
-      clearInterval(this.autoSaveTimer);
-    }
-    this.autoSaveTimer = setInterval(() => {
-      if (this.activeSession?.isDirty) {
-        this.save().catch((e) => {
-        });
-      }
-    }, this.options.autoSaveInterval);
-  }
-  /**
-   * Stop auto-save timer
-   */
-  stopAutoSave() {
-    if (this.autoSaveTimer) {
-      clearInterval(this.autoSaveTimer);
-      this.autoSaveTimer = null;
-    }
-  }
-  /**
-   * Create a new session with tree structure
-   */
-  async createSession(name, tags, sessionId) {
-    const id = sessionId || generateSessionId();
-    const now = Date.now();
-    this.activeSession = {
-      id,
-      metadata: {
-        id,
-        name: name ?? getGeneratedSessionName(now),
-        nameOrigin: name === void 0 ? "generated" : "explicit",
-        createdAt: now,
-        updatedAt: now,
-        entryCount: 0,
-        messageCount: 0,
-        activeEntryId: null,
-        rootEntryId: null,
-        tags
-      },
-      isDirty: true,
-      entries: [],
-      activeEntryId: null
-    };
-    await this.save();
-    return id;
-  }
-  /**
-   * Load an existing session
-   */
-  async loadSession(sessionId, options) {
-    const data = await this.store.load(sessionId);
-    if (!data) {
-      if (options?.warnIfMissing !== false) {
-        console.warn(`[SessionManager] Session not found: ${sessionId}`);
-      }
-      return false;
-    }
-    if (!data.entries) {
-      data.entries = [];
-    }
-    this.activeSession = {
-      id: sessionId,
-      metadata: data.metadata,
-      isDirty: false,
-      lastSavedAt: data.metadata.updatedAt,
-      entries: data.entries,
-      activeEntryId: data.metadata.activeEntryId ?? null
-    };
-    return true;
-  }
-  /**
-   * Save the current session
-   */
-  async save() {
-    if (!this.activeSession) {
-      throw new Error("No active session to save");
-    }
-    this.activeSession.metadata.entryCount = this.activeSession.entries.length;
-    this.activeSession.metadata.messageCount = this.activeSession.entries.filter(
-      (e) => e.type === "message" && e.message
-    ).length;
-    if (this.activeSession.metadata.messageCount === 0) {
-      if (await this.store.exists(this.activeSession.id)) {
-        await this.store.delete(this.activeSession.id);
-      }
-      this.activeSession.isDirty = false;
-      return;
-    }
-    this.activeSession.metadata.updatedAt = Date.now();
-    this.activeSession.metadata.activeEntryId = this.activeSession.activeEntryId;
-    this.activeSession.metadata.rootEntryId = this.activeSession.entries.find(
-      (e) => e.parentId === null
-    )?.id ?? null;
-    await this.store.save(
-      this.activeSession.id,
-      this.activeSession.entries,
-      this.activeSession.metadata
-    );
-    this.activeSession.isDirty = false;
-    this.activeSession.lastSavedAt = Date.now();
-  }
-  /**
-   * Add a new entry to the session
-   */
-  addEntry(entryType, message) {
-    if (!this.activeSession) {
-      throw new Error("No active session");
-    }
-    const entry = {
-      id: generateEntryId(),
-      parentId: this.activeSession.activeEntryId,
-      type: entryType,
-      timestamp: Date.now(),
-      message
-    };
-    this.activeSession.entries.push(entry);
-    this.activeSession.activeEntryId = entry.id;
-    this.activeSession.isDirty = true;
-    return entry;
-  }
-  /**
-   * Add a message entry to the session
-   */
-  addMessage(message) {
-    return this.addEntry("message", message);
-  }
-  /**
-   * Append a compaction checkpoint to the current active path.
-   * Full history remains in entries; active messages are reconstructed from this checkpoint onward.
-   */
-  appendCompaction(summary, firstKeptEntryId, tokensBefore) {
-    if (!this.activeSession) {
-      throw new Error("No active session");
-    }
-    const entry = {
-      id: generateEntryId(),
-      parentId: this.activeSession.activeEntryId,
-      type: "compaction",
-      timestamp: Date.now(),
-      compactionData: {
-        summary,
-        firstKeptEntryId,
-        tokensBefore
-      }
-    };
-    this.activeSession.entries.push(entry);
-    this.activeSession.activeEntryId = entry.id;
-    this.activeSession.isDirty = true;
-    return entry;
-  }
-  /**
-   * Update messages (legacy compatibility - rebuilds tree)
-   * @deprecated Use addMessage() instead
-   */
-  updateMessages(messages) {
-    if (!this.activeSession) {
-      throw new Error("No active session");
-    }
-    const newEntries = [];
-    let parentId = null;
-    for (const message of messages) {
-      const entry = {
-        id: generateEntryId(),
-        parentId,
-        type: "message",
-        timestamp: Date.now(),
-        message
-      };
-      newEntries.push(entry);
-      parentId = entry.id;
-    }
-    this.activeSession.entries = newEntries;
-    this.activeSession.activeEntryId = newEntries.length > 0 ? newEntries[newEntries.length - 1].id : null;
-    this.activeSession.isDirty = true;
-  }
-  /**
-   * Get current messages (linear path from root to active leaf)
-   */
-  getMessages() {
-    if (!this.activeSession) {
-      return [];
-    }
-    return flattenTreeToMessages(this.activeSession.entries, this.activeSession.activeEntryId);
-  }
-  /**
-   * Get current entries
-   */
-  getEntries() {
-    return this.activeSession?.entries ?? [];
-  }
-  /**
-   * Get active session info
-   */
-  getActiveSession() {
-    return this.activeSession;
-  }
-  /**
-   * Get active session ID
-   */
-  getActiveSessionId() {
-    return this.activeSession?.id ?? null;
-  }
-  /**
-   * Get current active entry ID
-   */
-  getActiveEntryId() {
-    return this.activeSession?.activeEntryId ?? null;
-  }
-  /**
-   * Set active entry (for navigation)
-   */
-  setActiveEntry(entryId) {
-    if (!this.activeSession) {
-      return false;
-    }
-    if (entryId === null) {
-      this.activeSession.activeEntryId = null;
-      this.activeSession.isDirty = true;
-      return true;
-    }
-    const entry = this.activeSession.entries.find((e) => e.id === entryId);
-    if (!entry) {
-      console.warn(`[SessionManager] Entry not found: ${entryId}`);
-      return false;
-    }
-    this.activeSession.activeEntryId = entryId;
-    this.activeSession.isDirty = true;
-    return true;
-  }
-  /**
-   * Get entry by ID
-   */
-  getEntry(entryId) {
-    if (!this.activeSession) {
-      return null;
-    }
-    return this.activeSession.entries.find((e) => e.id === entryId) ?? null;
-  }
-  /**
-   * Get children of an entry
-   */
-  getChildren(parentId) {
-    if (!this.activeSession) {
-      return [];
-    }
-    return this.activeSession.entries.filter((e) => e.parentId === parentId);
-  }
-  /**
-   * Get tree structure
-   */
-  getTree() {
-    if (!this.activeSession) {
-      return [];
-    }
-    return buildTree(this.activeSession.entries, this.activeSession.activeEntryId);
-  }
-  /**
-   * Branch from a specific entry (in-session branching)
-   * Moves the active entry pointer to the specified entry.
-   * Next addMessage() will create a child of that entry, forming a new branch.
-   * Existing entries are not modified or deleted.
-   */
-  branch(entryId) {
-    if (!this.activeSession) {
-      return false;
-    }
-    if (entryId === null) {
-      this.activeSession.activeEntryId = null;
-      this.activeSession.isDirty = true;
-      return true;
-    }
-    const entry = this.activeSession.entries.find((e) => e.id === entryId);
-    if (!entry) {
-      console.warn(`[SessionManager] Branch target not found: ${entryId}`);
-      return false;
-    }
-    this.activeSession.activeEntryId = entryId;
-    this.activeSession.isDirty = true;
-    return true;
-  }
-  /**
-   * Get all branch paths (all leaf nodes) in the session
-   * Returns array of entry IDs representing branch tips
-   */
-  getBranchTips() {
-    if (!this.activeSession) {
-      return [];
-    }
-    const hasChildren = /* @__PURE__ */ new Set();
-    for (const entry of this.activeSession.entries) {
-      if (entry.parentId) {
-        hasChildren.add(entry.parentId);
-      }
-    }
-    const leaves = this.activeSession.entries.filter((e) => !hasChildren.has(e.id)).map((e) => e.id);
-    return leaves;
-  }
-  /**
-   * Get the path from root to a specific entry
-   */
-  getPathToEntry(entryId) {
-    if (!this.activeSession) {
-      return [];
-    }
-    const path = [];
-    const byId = new Map(this.activeSession.entries.map((e) => [e.id, e]));
-    let current = entryId;
-    while (current) {
-      const entry = byId.get(current);
-      if (!entry) break;
-      path.unshift(entry);
-      current = entry.parentId;
-    }
-    return path;
-  }
-  /**
-   * Get the timestamp of the latest compaction entry on the active path.
-   */
-  getLatestCompactionTimestamp() {
-    if (!this.activeSession?.activeEntryId) {
-      return null;
-    }
-    const path = this.getPathToEntry(this.activeSession.activeEntryId);
-    for (let i = path.length - 1; i >= 0; i--) {
-      const entry = path[i];
-      if (entry.type === "compaction" && entry.compactionData) {
-        return entry.timestamp;
-      }
-    }
-    return null;
-  }
-  /**
-   * Rename the active session
-   */
-  async rename(name) {
-    if (!this.activeSession) {
-      throw new Error("No active session");
-    }
-    this.activeSession.metadata.name = name;
-    this.activeSession.metadata.nameOrigin = "explicit";
-    this.activeSession.isDirty = true;
-    await this.save();
-  }
-  /**
-   * Close the current session
-   */
-  async close() {
-    if (this.activeSession?.isDirty) {
-      await this.save();
-    }
-    this.activeSession = null;
-  }
-  /**
-   * Delete a session (active or inactive)
-   */
-  async deleteSession(sessionId) {
-    if (this.activeSession?.id === sessionId) {
-      await this.close();
-    }
-    return await this.store.delete(sessionId);
-  }
-  /**
-   * List all available sessions
-   */
-  async listSessions() {
-    return await this.store.listMetadata();
-  }
-  /**
-   * List the most recently updated sessions cheaply (stat-sorted window).
-   * Falls back to a full listing slice for stores without a fast path.
-   */
-  async listSessionsRecent(limit) {
-    if (this.store.listMetadataRecent) {
-      return await this.store.listMetadataRecent(limit);
-    }
-    const all = await this.store.listMetadata();
-    return { metadata: all.slice(0, limit), totalCount: all.length };
-  }
-  /**
-   * Resolves when a background metadata index rebuild (triggered by
-   * listSessionsRecent on a cold index) completes. Resolves immediately when
-   * the store has no such rebuild in flight.
-   */
-  async whenIndexRebuilt() {
-    await this.store.whenIndexRebuilt?.();
-  }
-  /**
-   * Check if a session exists
-   */
-  async hasSession(sessionId) {
-    return await this.store.exists(sessionId);
-  }
-  /**
-   * Fork the current session at a specific entry point
-   */
-  async forkAtEntry(entryId, newName) {
-    if (!this.activeSession) {
-      throw new Error("No active session to fork");
-    }
-    const sourceEntry = this.activeSession.entries.find((e) => e.id === entryId);
-    if (!sourceEntry) {
-      throw new Error(`Entry not found: ${entryId}`);
-    }
-    const newSessionId = generateSessionId();
-    const now = Date.now();
-    const subtreeEntries = [];
-    const forkEntry = {
-      id: generateEntryId(),
-      parentId: null,
-      type: "fork",
-      timestamp: now,
-      forkData: {
-        sourceEntryId: entryId,
-        sessionId: this.activeSession.id,
-        name: this.activeSession.metadata.name
-      }
-    };
-    subtreeEntries.push(forkEntry);
-    let currentId = entryId;
-    let newParentId = forkEntry.id;
-    while (currentId) {
-      const entry = this.activeSession.entries.find((e) => e.id === currentId);
-      if (!entry) break;
-      const newEntry = {
-        ...entry,
-        id: generateEntryId(),
-        parentId: newParentId,
-        timestamp: now
-      };
-      subtreeEntries.push(newEntry);
-      newParentId = newEntry.id;
-      const children = this.activeSession.entries.filter((e) => e.parentId === currentId);
-      if (children.length === 0) break;
-      const activePathChild = children.find((c) => {
-        let checkId = this.activeSession?.activeEntryId ?? null;
-        while (checkId) {
-          if (checkId === c.id) return true;
-          const checkEntry = this.activeSession?.entries.find((e) => e.id === checkId);
-          checkId = checkEntry?.parentId ?? null;
-        }
-        return false;
-      });
-      currentId = activePathChild?.id ?? children[0]?.id ?? null;
-    }
-    await this.store.save(
-      newSessionId,
-      subtreeEntries,
-      {
-        name: newName ?? `${this.activeSession.metadata.name} (Branch)`,
-        nameOrigin: "explicit",
-        createdAt: now,
-        updatedAt: now,
-        tags: this.activeSession.metadata.tags,
-        ...typeof this.activeSession.metadata.cwd === "string" ? { cwd: this.activeSession.metadata.cwd } : {}
-      }
-    );
-    return newSessionId;
-  }
-  /**
-   * Fork the current session (create a copy with current state)
-   */
-  async fork(newName) {
-    if (!this.activeSession) {
-      throw new Error("No active session to fork");
-    }
-    const newSessionId = generateSessionId();
-    const now = Date.now();
-    const idMap = /* @__PURE__ */ new Map();
-    const newEntries = [];
-    for (const entry of this.activeSession.entries) {
-      idMap.set(entry.id, generateEntryId());
-    }
-    for (const entry of this.activeSession.entries) {
-      const newEntry = {
-        ...entry,
-        id: idMap.get(entry.id),
-        parentId: entry.parentId ? idMap.get(entry.parentId) : null,
-        timestamp: now
-      };
-      newEntries.push(newEntry);
-    }
-    const newActiveEntryId = this.activeSession.activeEntryId ? idMap.get(this.activeSession.activeEntryId) ?? null : null;
-    await this.store.save(
-      newSessionId,
-      newEntries,
-      {
-        name: newName ?? `${this.activeSession.metadata.name} (Copy)`,
-        nameOrigin: "explicit",
-        createdAt: now,
-        updatedAt: now,
-        activeEntryId: newActiveEntryId,
-        tags: this.activeSession.metadata.tags,
-        ...typeof this.activeSession.metadata.cwd === "string" ? { cwd: this.activeSession.metadata.cwd } : {}
-      }
-    );
-    return newSessionId;
-  }
-  /**
-   * Clean up old sessions if exceeding maxSessions
-   */
-  async cleanup() {
-    if (this.options.maxSessions <= 0) {
-      return 0;
-    }
-    const sessions = await this.store.listMetadata();
-    if (sessions.length <= this.options.maxSessions) {
-      return 0;
-    }
-    const sorted = sessions.sort((a, b) => a.updatedAt - b.updatedAt);
-    const toDelete = sorted.slice(0, sessions.length - this.options.maxSessions);
-    let deleted = 0;
-    for (const session of toDelete) {
-      if (session.id !== this.activeSession?.id) {
-        await this.store.delete(session.id);
-        deleted++;
-      }
-    }
-    if (deleted > 0) {
-    }
-    return deleted;
-  }
-  /**
-   * Dispose the manager
-   */
-  dispose() {
-    this.stopAutoSave();
-  }
-};
-function createSessionManager(options) {
-  return new SessionManager(options);
-}
-
-// ../../packages/agent-framework/src/session/controller/activity.ts
-var AgentSessionActivity = class {
-  pending = /* @__PURE__ */ new Set();
-  get isBusy() {
-    return this.pending.size > 0;
-  }
-  run(action) {
-    return this.track(action());
-  }
-  track(task) {
-    let tracked;
-    tracked = task.finally(() => this.pending.delete(tracked));
-    this.pending.add(tracked);
-    return tracked;
-  }
-  async waitForIdle() {
-    while (this.pending.size > 0) {
-      await Promise.allSettled([...this.pending]);
-    }
-  }
-};
-
-// ../../packages/agent-framework/src/session/controller/auto-compact-policy.ts
-function defaultSetTimeout(callback, delay) {
-  return setTimeout(callback, delay);
-}
-function defaultClearTimeout(handle) {
-  clearTimeout(handle);
-}
-var AgentSessionAutoCompactScheduler = class {
-  constructor(options) {
-    this.options = options;
-  }
-  options;
-  autoCompactTimer;
-  pendingAutoCompact;
-  runningAutoCompact;
-  runningAbortController;
-  pendingWait;
-  resolvePendingWait;
-  get hasPendingAutoCompact() {
-    return this.autoCompactTimer !== void 0 || this.pendingAutoCompact !== void 0 || this.runningAutoCompact !== void 0;
-  }
-  waitForAutoCompact() {
-    return this.pendingWait ?? Promise.resolve();
-  }
-  schedule(decision, delayMs = 0) {
-    if (this.options.getRuntimeGuardTriggered()) {
-      return;
-    }
-    this.ensurePendingWait();
-    this.pendingAutoCompact = decision;
-    if (this.autoCompactTimer !== void 0) {
-      return;
-    }
-    const setTimer = this.options.retry?.setTimeout ?? defaultSetTimeout;
-    this.autoCompactTimer = setTimer(() => {
-      this.autoCompactTimer = void 0;
-      const pending = this.pendingAutoCompact;
-      this.pendingAutoCompact = void 0;
-      if (!pending || this.options.getDisposed()) {
-        this.resolvePending();
-        return;
-      }
-      if (this.options.isStreaming()) {
-        this.pendingAutoCompact = pending;
-        this.schedule(pending, 100);
-        return;
-      }
-      const abortController = new AbortController();
-      this.runningAbortController = abortController;
-      const running = this.options.runAutoCompact(pending, abortController.signal).catch(() => {
-      }).finally(() => {
-        if (this.runningAutoCompact === running) {
-          this.runningAutoCompact = void 0;
-          this.runningAbortController = void 0;
-          this.resolvePending();
-        }
-      });
-      this.runningAutoCompact = running;
-    }, delayMs);
-  }
-  cancel() {
-    if (this.autoCompactTimer !== void 0) {
-      const clearTimer = this.options.retry?.clearTimeout ?? defaultClearTimeout;
-      clearTimer(this.autoCompactTimer);
-      this.autoCompactTimer = void 0;
-    }
-    this.pendingAutoCompact = void 0;
-    this.runningAbortController?.abort();
-    this.runningAbortController = void 0;
-    this.runningAutoCompact = void 0;
-    this.resolvePending();
-  }
-  ensurePendingWait() {
-    if (this.pendingWait) return;
-    this.pendingWait = new Promise((resolve) => {
-      this.resolvePendingWait = resolve;
-    });
-  }
-  resolvePending() {
-    const resolve = this.resolvePendingWait;
-    this.pendingWait = void 0;
-    this.resolvePendingWait = void 0;
-    resolve?.();
-  }
-};
-
-// ../../packages/agent-framework/src/session/controller/auto-continue-policy.ts
-function defaultSetTimeout2(callback, delay) {
-  return setTimeout(callback, delay);
-}
-function defaultClearTimeout2(handle) {
-  clearTimeout(handle);
-}
-var AgentSessionAutoContinueController = class {
-  constructor(options) {
-    this.options = options;
-  }
-  options;
-  autoContinueTimer;
-  pendingAutoContinue;
-  resolvePendingAutoContinue;
-  get hasPendingAutoContinue() {
-    return this.autoContinueTimer !== void 0 || this.pendingAutoContinue !== void 0;
-  }
-  waitForAutoContinue() {
-    return this.pendingAutoContinue ?? Promise.resolve();
-  }
-  schedule(messages) {
-    if (!this.options.getAutoContinueMessage || this.options.getDisposed() || this.autoContinueTimer !== void 0) {
-      return;
-    }
-    this.ensurePending();
-    const setTimer = this.options.retry?.setTimeout ?? defaultSetTimeout2;
-    const snapshot = messages.slice();
-    this.autoContinueTimer = setTimer(() => {
-      this.autoContinueTimer = void 0;
-      void this.maybeScheduleAutoContinue(snapshot).finally(() => this.resolvePending());
-    }, 0);
-  }
-  cancel() {
-    if (this.autoContinueTimer === void 0) {
-      return;
-    }
-    const clearTimer = this.options.retry?.clearTimeout ?? defaultClearTimeout2;
-    clearTimer(this.autoContinueTimer);
-    this.autoContinueTimer = void 0;
-    this.resolvePending();
-  }
-  async maybeScheduleAutoContinue(messages) {
-    if (!this.options.getAutoContinueMessage || this.options.getDisposed() || this.options.getRuntimeGuardTriggered() || this.options.isBlockedByRuntimePolicy() || this.options.hasQueuedMessages() || this.options.isStreaming()) {
-      if (this.options.hasQueuedMessages()) {
-        this.options.emit({ type: "auto_continue_skipped", reason: "queued_messages" });
-      }
-      return;
-    }
-    const lastMessage = messages[messages.length - 1];
-    if (lastMessage?.role === "assistant" && (lastMessage.stopReason === "error" || lastMessage.stopReason === "aborted")) {
-      this.options.emit({ type: "auto_continue_skipped", reason: "last_turn_failed" });
-      return;
-    }
-    const result = await this.options.getAutoContinueMessage({
-      agent: this.options.agent,
-      sessionManager: this.options.sessionManager,
-      cwd: this.options.cwd,
-      messages,
-      hasQueuedMessages: this.options.hasQueuedMessages()
-    });
-    const message = result && "role" in result ? result : result?.message;
-    const reason = result && "role" in result ? void 0 : result?.reason;
-    if (!message) {
-      this.options.emit({ type: "auto_continue_skipped", reason: reason ?? "no_message" });
-      return;
-    }
-    if (this.options.hasQueuedMessages() || this.options.isStreaming() || this.options.isBlockedByRuntimePolicy()) {
-      this.options.emit({ type: "auto_continue_skipped", reason: "runtime_busy" });
-      return;
-    }
-    this.options.emit({ type: "auto_continue_scheduled", reason });
-    this.options.agent.followUp(message);
-    const setTimer = this.options.retry?.setTimeout ?? defaultSetTimeout2;
-    await new Promise((resolve) => {
-      this.autoContinueTimer = setTimer(() => {
-        this.autoContinueTimer = void 0;
-        if (this.options.getDisposed()) {
-          resolve();
-          return;
-        }
-        void this.options.continueTurn().catch(() => {
-        }).finally(resolve);
-      }, 0);
-    });
-  }
-  ensurePending() {
-    if (this.pendingAutoContinue) return;
-    this.pendingAutoContinue = new Promise((resolve) => {
-      this.resolvePendingAutoContinue = resolve;
-    });
-  }
-  resolvePending() {
-    const resolve = this.resolvePendingAutoContinue;
-    this.pendingAutoContinue = void 0;
-    this.resolvePendingAutoContinue = void 0;
-    resolve?.();
-  }
-};
-
-// ../../packages/agent-framework/src/session/controller/compaction-policy.ts
-function removeTrailingAssistantError(params) {
-  const messages = params.agent.state.messages;
-  const lastMessage = messages[messages.length - 1];
-  if (lastMessage?.role === "assistant" && (lastMessage.stopReason === "error" || Boolean(lastMessage.errorMessage))) {
-    params.replaceMessagesAndMarkSynced(messages.slice(0, -1), { updateSession: true });
-  }
-}
-async function runAgentSessionCompaction(params) {
-  if (!params.compaction) {
-    throw new Error("No compaction handler configured");
-  }
-  const abortedResult = () => ({ aborted: true });
-  const isAborted = () => params.signal?.aborted === true;
-  params.emit({ type: "auto_compaction_start", reason: params.reason, willRetry: params.willRetry });
-  try {
-    if (isAborted()) {
-      const result2 = abortedResult();
-      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: result2 });
-      return result2;
-    }
-    if (params.willRetry) {
-      params.removeTrailingAssistantError();
-    }
-    const result = await params.compaction.compact({
-      reason: params.reason,
-      willRetry: params.willRetry,
-      agent: params.agent,
-      sessionManager: params.sessionManager,
-      messages: params.agent.state.messages.slice(),
-      cwd: params.cwd,
-      signal: params.signal
-    });
-    if (isAborted() || result?.aborted) {
-      const aborted = { ...result, aborted: true };
-      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: aborted });
-      return aborted;
-    }
-    if (result?.summary && result.firstKeptEntryId) {
-      params.sessionManager.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore);
-      params.replaceMessagesAndMarkSynced(params.sessionManager.getMessages());
-    } else if (result?.messages) {
-      params.replaceMessagesAndMarkSynced(result.messages, { updateSession: true });
-    }
-    if (isAborted()) {
-      const aborted = { ...result, aborted: true };
-      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: aborted });
-      return aborted;
-    }
-    params.markSyncedToAgentState();
-    await params.sessionManager.save();
-    if (isAborted()) {
-      const aborted = { ...result, aborted: true };
-      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: aborted });
-      return aborted;
-    }
-    if (params.willRetry && !result?.aborted) {
-      await params.continueTurn();
-    }
-    params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result });
-    return result;
-  } catch (error) {
-    if (isAborted()) {
-      const result = abortedResult();
-      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result });
-      return result;
-    }
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, errorMessage });
-    throw error;
-  }
-}
-
-// ../../packages/agent-framework/src/session/controller/prompt.ts
-function isAgentMessage(value) {
-  return !!value && typeof value === "object" && "role" in value;
-}
-function isUserContentBlock(value) {
-  if (!value || typeof value !== "object" || !("type" in value)) {
-    return false;
-  }
-  const type = value.type;
-  return type === "text" || type === "image" || type === "audio" || type === "video" || type === "fileRef";
-}
-function normalizePromptInput(input) {
-  if (typeof input === "string") {
-    return [{ role: "user", content: input, timestamp: Date.now() }];
-  }
-  if (Array.isArray(input)) {
-    if (input.every(isAgentMessage)) {
-      return input;
-    }
-    if (input.every(isUserContentBlock)) {
-      return [{ role: "user", content: input, timestamp: Date.now() }];
-    }
-    throw new Error("Invalid prompt array: expected user content blocks or agent messages.");
-  }
-  if (isAgentMessage(input)) {
-    return [input];
-  }
-  throw new Error("Invalid prompt input.");
-}
-function textFromMessage(message) {
-  const content = message.content;
-  if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return content.filter((block) => !!block && typeof block === "object" && "type" in block).filter((block) => block.type === "text").map((block) => block.text || "").join("");
-  }
-  return "";
-}
-async function preparePromptMessages(params) {
-  if (params.baseSystemPrompt !== void 0) {
-    params.agent.setSystemPrompt(params.baseSystemPrompt);
-  }
-  if (!params.prepareTurn) {
-    return { handled: false, messages: params.messages };
-  }
-  params.emit({ type: "prepare_turn", source: params.options?.source, messageCount: params.messages.length });
-  const result = await params.prepareTurn({
-    source: params.options?.source,
-    streamingBehavior: params.options?.streamingBehavior,
-    messages: params.messages,
-    agent: params.agent,
-    sessionManager: params.sessionManager,
-    cwd: params.cwd,
-    baseSystemPrompt: params.baseSystemPrompt
-  });
-  return {
-    handled: result?.handled === true,
-    messages: result?.messages ?? params.messages,
-    systemPrompt: result?.systemPrompt
-  };
-}
-
-// ../../packages/agent-framework/src/session/controller/pre-request-policy.ts
-async function runPreRequestAutoCompact(params) {
-  if (params.disposed || params.runtimeGuardTriggered || params.isStreaming || params.recoveryActive || params.agent.state.messages.length === 0) {
-    return;
-  }
-  const decision = params.getAutoCompactDecision?.({
-    agent: params.agent,
-    sessionManager: params.sessionManager,
-    cwd: params.cwd,
-    messages: params.agent.state.messages.slice()
-  });
-  if (decision?.reason !== "threshold") {
-    return;
-  }
-  try {
-    await params.runAutoCompact();
-  } catch {
-    params.setRecoveryState("none");
-  }
-}
-
-// ../../packages/agent-framework/src/session/controller/queue.ts
-function cloneQueuedInput(input) {
-  return {
-    ...input,
-    messages: input.messages.slice()
-  };
-}
-var AgentSessionQueue = class {
-  agent;
-  getIsStreaming;
-  emit;
-  queuedInputs = [];
-  queueIdCounter = 0;
-  constructor(options) {
-    this.agent = options.agent;
-    this.getIsStreaming = options.getIsStreaming;
-    this.emit = options.emit;
-  }
-  get length() {
-    return this.queuedInputs.length;
-  }
-  get hasQueuedMessages() {
-    return this.queuedInputs.length > 0 || this.agent.hasQueuedMessages();
-  }
-  get snapshot() {
-    return this.queuedInputs.map(cloneQueuedInput);
-  }
-  peek() {
-    return this.queuedInputs[0];
-  }
-  shift() {
-    const queuedInput = this.queuedInputs.shift();
-    if (queuedInput) {
-      this.emitQueueChanged();
-    }
-    return queuedInput;
-  }
-  enqueue(messages, mode, options) {
-    if (options.dedupeKey && this.queuedInputs.some((input) => input.dedupeKey === options.dedupeKey)) {
-      return;
-    }
-    for (const message of messages) {
-      const queuedInput = {
-        id: `queued-${++this.queueIdCounter}`,
-        mode,
-        source: options.source,
-        displayText: options.displayText ?? textFromMessage(message),
-        dedupeKey: options.dedupeKey,
-        clearEditor: options.clearEditor ?? true,
-        visibility: options.visibility ?? "user",
-        deliveredToAgent: false,
-        messages: [message],
-        createdAt: Date.now()
-      };
-      this.queuedInputs.push(queuedInput);
-      if (this.getIsStreaming()) {
-        this.deliverToAgent(queuedInput);
-      }
-    }
-    this.emitQueueChanged();
-  }
-  deliverToAgent(queuedInput) {
-    if (queuedInput.deliveredToAgent) {
-      return;
-    }
-    for (const message of queuedInput.messages) {
-      if (queuedInput.mode === "steer") {
-        this.agent.steer(message);
-      } else {
-        this.agent.followUp(message);
-      }
-    }
-    queuedInput.deliveredToAgent = true;
-  }
-  markMessageDelivered(message) {
-    if (this.queuedInputs.length === 0 || message.role !== "user") {
-      return;
-    }
-    const index = this.queuedInputs.findIndex((queued) => queued.messages.includes(message));
-    if (index >= 0) {
-      const [delivered2] = this.queuedInputs.splice(index, 1);
-      if (delivered2) {
-        this.emit({ type: "queued_turn_dispatched", queuedInput: cloneQueuedInput(delivered2) });
-      }
-      this.emitQueueChanged();
-      return;
-    }
-    const delivered = this.queuedInputs.shift();
-    if (delivered) {
-      this.emit({ type: "queued_turn_dispatched", queuedInput: cloneQueuedInput(delivered) });
-    }
-    this.emitQueueChanged();
-  }
-  clear() {
-    if (this.queuedInputs.length === 0 && !this.agent.hasQueuedMessages()) {
-      return;
-    }
-    this.queuedInputs = [];
-    this.agent.clearAllQueues();
-    this.emitQueueChanged();
-  }
-  drainForEditor() {
-    const drained = this.snapshot;
-    this.queuedInputs = [];
-    this.agent.clearAllQueues();
-    this.emitQueueChanged();
-    return drained;
-  }
-  replaceText(search, replacement) {
-    if (!search || this.queuedInputs.length === 0) {
-      return;
-    }
-    let changed = false;
-    for (const input of this.queuedInputs) {
-      if (input.displayText.includes(search)) {
-        input.displayText = input.displayText.split(search).join(replacement);
-        changed = true;
-      }
-      for (const message of input.messages) {
-        if (message.role !== "user") {
-          continue;
-        }
-        const content = message.content;
-        if (typeof content === "string" && content.includes(search)) {
-          message.content = content.split(search).join(replacement);
-          changed = true;
-        } else if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block && typeof block === "object" && "type" in block && block.type === "text" && typeof block.text === "string" && block.text.includes(search)) {
-              block.text = block.text.split(search).join(replacement);
-              changed = true;
-            }
-          }
-        }
-      }
-    }
-    if (changed) {
-      this.emitQueueChanged();
-    }
-  }
-  emitQueueChanged() {
-    this.emit({ type: "queue_changed", queuedInputs: this.snapshot });
-  }
-};
-
-// ../../packages/agent-framework/src/session/controller/queue-dispatcher.ts
-function defaultSetTimeout3(callback, delay) {
-  return setTimeout(callback, delay);
-}
-function defaultClearTimeout3(handle) {
-  clearTimeout(handle);
-}
-var AgentSessionQueueDispatcher = class {
-  constructor(options) {
-    this.options = options;
-  }
-  options;
-  dispatchTimer;
-  pendingDispatch;
-  resolvePendingDispatch;
-  get hasPendingDispatch() {
-    return this.dispatchTimer !== void 0 || this.pendingDispatch !== void 0;
-  }
-  waitForDispatch() {
-    return this.pendingDispatch ?? Promise.resolve();
-  }
-  schedule(delayMs = 0) {
-    if (this.options.getDisposed() || this.options.getRuntimeGuardTriggered() || this.dispatchTimer !== void 0) {
-      return;
-    }
-    this.ensurePending();
-    const setTimer = this.options.retry?.setTimeout ?? defaultSetTimeout3;
-    this.dispatchTimer = setTimer(() => {
-      this.dispatchTimer = void 0;
-      void this.dispatchNext().finally(() => this.resolvePending());
-    }, delayMs);
-  }
-  cancel() {
-    if (this.dispatchTimer === void 0) {
-      return;
-    }
-    const clearTimer = this.options.retry?.clearTimeout ?? defaultClearTimeout3;
-    clearTimer(this.dispatchTimer);
-    this.dispatchTimer = void 0;
-    this.resolvePending();
-  }
-  async dispatchNext() {
-    if (this.options.getDisposed() || this.options.isStreaming() || this.options.isBlockedByRuntimePolicy()) {
-      return false;
-    }
-    const queuedInput = this.options.queue.peek();
-    if (!queuedInput) {
-      return false;
-    }
-    const decision = await this.options.canDispatchQueuedTurn?.({
-      agent: this.options.agent,
-      sessionManager: this.options.sessionManager,
-      cwd: this.options.cwd,
-      queuedInput: cloneQueuedInput(queuedInput)
-    });
-    const dispatchDecision = typeof decision === "boolean" ? { allowed: decision } : decision ?? { allowed: true };
-    if (!dispatchDecision.allowed) {
-      this.options.emit({
-        type: "queued_turn_blocked",
-        queuedInput: cloneQueuedInput(queuedInput),
-        reason: dispatchDecision.reason
-      });
-      if (dispatchDecision.retryAfterMs !== void 0 && dispatchDecision.retryAfterMs >= 0) {
-        this.schedule(dispatchDecision.retryAfterMs);
-      }
-      return false;
-    }
-    await this.options.runPreRequestAutoCompact();
-    if (this.options.getDisposed() || this.options.isStreaming() || this.options.isBlockedByRuntimePolicy()) {
-      this.schedule(100);
-      return false;
-    }
-    const dispatched = this.options.queue.shift();
-    if (!dispatched) {
-      return false;
-    }
-    this.options.emit({ type: "queued_turn_dispatched", queuedInput: cloneQueuedInput(dispatched) });
-    if (dispatched.deliveredToAgent || this.options.agent.state.messages.at(-1)?.role === "assistant") {
-      if (!dispatched.deliveredToAgent) {
-        this.options.queue.deliverToAgent(dispatched);
-      }
-      await this.options.continueTurn();
-    } else {
-      const prepared = await this.options.preparePromptMessages(dispatched.messages, {
-        source: dispatched.source,
-        streamingBehavior: dispatched.mode,
-        displayText: dispatched.displayText,
-        dedupeKey: dispatched.dedupeKey,
-        clearEditor: dispatched.clearEditor,
-        visibility: dispatched.visibility
-      });
-      if (!prepared.handled) {
-        if (prepared.systemPrompt !== void 0) {
-          this.options.agent.setSystemPrompt(prepared.systemPrompt);
-        }
-        await this.options.agent.prompt(prepared.messages);
-        await this.options.syncNewAgentMessages();
-      }
-    }
-    return true;
-  }
-  ensurePending() {
-    if (this.pendingDispatch) return;
-    this.pendingDispatch = new Promise((resolve) => {
-      this.resolvePendingDispatch = resolve;
-    });
-  }
-  resolvePending() {
-    const resolve = this.resolvePendingDispatch;
-    this.pendingDispatch = void 0;
-    this.resolvePendingDispatch = void 0;
-    resolve?.();
-  }
-};
-
-// ../../packages/agent-framework/src/session/controller/failure-classification.ts
-function isAssistantFailureMessage(message) {
-  return message?.role === "assistant" && (message.stopReason === "error" || message.stopReason === "aborted");
-}
-function isAssistantTerminalCompletion(message) {
-  if (message?.role !== "assistant") return false;
-  if (message.stopReason === "error" || message.stopReason === "aborted") return false;
-  if (message.stopReason === "toolUse") return false;
-  return !message.content.some((block) => block.type === "toolCall");
-}
-function createFailureClassification(context, retry, classifyFailure) {
-  const hostClassification = classifyFailure?.(context);
-  if (hostClassification) {
-    return hostClassification;
-  }
-  const retryable = retry?.isRetryableError(context.errorMessage) === true;
-  const userAbort = context.message?.role === "assistant" && context.message.stopReason === "aborted";
-  return {
-    kind: userAbort ? "user_abort" : retryable ? "provider_transient" : "unknown",
-    retryable: retryable && !userAbort,
-    compactable: false,
-    userAbort,
-    terminal: !retryable || userAbort,
-    message: context.errorMessage
-  };
-}
-function asTerminalFailure(failure, message = failure.message) {
-  return {
-    ...failure,
-    retryable: false,
-    compactable: false,
-    terminal: true,
-    message
-  };
-}
-
-// ../../packages/agent-framework/src/session/controller/retry-policy.ts
-function defaultSetTimeout4(callback, delay) {
-  return setTimeout(callback, delay);
-}
-function defaultClearTimeout4(handle) {
-  clearTimeout(handle);
-}
-var AgentSessionRetryController = class {
-  constructor(retry, emit, removeTrailingAssistantError2, continueTurn, setRecoveryState) {
-    this.retry = retry;
-    this.emit = emit;
-    this.removeTrailingAssistantError = removeTrailingAssistantError2;
-    this.continueTurn = continueTurn;
-    this.setRecoveryState = setRecoveryState;
-  }
-  retry;
-  emit;
-  removeTrailingAssistantError;
-  continueTurn;
-  setRecoveryState;
-  retryAttempt = 0;
-  retryTimer;
-  pendingRetry;
-  resolvePendingRetry;
-  get policy() {
-    return this.retry;
-  }
-  get hasPendingRetry() {
-    return this.retryTimer !== void 0 || this.pendingRetry !== void 0;
-  }
-  waitForRetry() {
-    return this.pendingRetry ?? Promise.resolve();
-  }
-  async handleTurnEnd(message, failure) {
-    if (!this.retry || !message || message.role !== "assistant") {
-      return;
-    }
-    if (!failure) {
-      if (this.retryAttempt > 0) {
-        this.emit({ type: "retry_succeeded", attempts: this.retryAttempt });
-        this.emit({ type: "turn_retry_succeeded", attempts: this.retryAttempt });
-        this.retryAttempt = 0;
-        this.setRecoveryState("none");
-        this.resolvePending();
-      }
-      return;
-    }
-    if (!failure.retryable) {
-      if (this.retryAttempt > 0) {
-        this.retryAttempt = 0;
-        this.setRecoveryState("none");
-        this.resolvePending();
-      }
-      return;
-    }
-    const maxRetries = this.retry.maxRetries ?? 3;
-    this.retryAttempt += 1;
-    if (this.retryAttempt > maxRetries) {
-      const terminalFailure = asTerminalFailure(failure);
-      this.emit({ type: "retry_exhausted", errorMessage: failure.message, maxRetries });
-      this.emit({ type: "turn_failed_terminal", failure: terminalFailure, message });
-      this.emit({ type: "turn_settled" });
-      this.retryAttempt = 0;
-      this.setRecoveryState("terminal");
-      this.resolvePending();
-      return;
-    }
-    const attempt = this.retryAttempt;
-    const delayMs = (this.retry.baseDelayMs ?? 2e3) * 2 ** (attempt - 1);
-    this.ensurePending();
-    this.setRecoveryState("retry_pending");
-    this.emit({ type: "turn_recovery_pending", recovery: "retry", failure, attempt, maxRetries, delayMs });
-    this.emit({ type: "retry_scheduled", errorMessage: failure.message, attempt, maxRetries, delayMs });
-    this.cancelTimerOnly();
-    const setTimer = this.retry.setTimeout ?? defaultSetTimeout4;
-    this.retryTimer = setTimer(() => {
-      this.retryTimer = void 0;
-      this.setRecoveryState("retrying");
-      this.emit({ type: "retry_start", attempt, maxRetries });
-      this.emit({ type: "turn_retry_started", attempt, maxRetries, failure });
-      this.removeTrailingAssistantError();
-      void this.continueTurn().catch((error) => {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const terminalFailure = asTerminalFailure(failure, errorMessage);
-        this.emit({
-          type: "retry_exhausted",
-          errorMessage,
-          maxRetries
-        });
-        this.emit({ type: "turn_failed_terminal", failure: terminalFailure, message });
-        this.emit({ type: "turn_settled" });
-        this.retryAttempt = 0;
-        this.setRecoveryState("terminal");
-        this.resolvePending();
-      });
-    }, delayMs);
-  }
-  cancel() {
-    this.cancelTimerOnly();
-    this.retryAttempt = 0;
-    this.resolvePending();
-  }
-  cancelTimerOnly() {
-    if (this.retryTimer === void 0) {
-      return;
-    }
-    const clearTimer = this.retry?.clearTimeout ?? defaultClearTimeout4;
-    clearTimer(this.retryTimer);
-    this.retryTimer = void 0;
-  }
-  ensurePending() {
-    if (this.pendingRetry) {
-      return;
-    }
-    this.pendingRetry = new Promise((resolve) => {
-      this.resolvePendingRetry = resolve;
-    });
-  }
-  resolvePending() {
-    const resolve = this.resolvePendingRetry;
-    this.pendingRetry = void 0;
-    this.resolvePendingRetry = void 0;
-    resolve?.();
-  }
-};
-
-// ../../packages/agent-framework/src/session/controller/runtime-guard.ts
-var RUNAWAY_TOOLCALL_WHITESPACE_DELTA_CHARS = 16384;
-var RUNAWAY_TOOLCALL_WHITESPACE_DELTA_EVENTS = 40;
-var TOOL_FAILURE_SIGNATURE_CHARS = 1e3;
-var TOOL_FAILURE_SIGNATURE_CONTEXT_LINES = 5;
-var FAILURE_DIAGNOSTIC_LINE_PATTERN = /\b(E2E_FAILED|AssertionError|TimeoutError|SyntaxError|ReferenceError|TypeError|Error):|(^|\b)(failed|failure|timed out|timeout|exit code|command failed|npm ERR!)/i;
-function stableStringify(value) {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value) ?? String(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map(stableStringify).join(",")}]`;
-  }
-  const record = value;
-  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
-}
-function summarizeToolResultForGuard(result) {
-  if (!result || typeof result !== "object") {
-    return String(result ?? "");
-  }
-  const content = Array.isArray(result.content) ? result.content : [];
-  const text = content.filter((block) => !!block && typeof block === "object" && "type" in block).filter((block) => block.type === "text").map((block) => block.text || "").join("\n").trim();
-  return text || stableStringify(result);
-}
-function summarizeToolFailureSignature(result) {
-  const summary = summarizeToolResultForGuard(result).replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
-  if (!summary) {
-    return "";
-  }
-  const lines = summary.split("\n");
-  for (let index = lines.length - 1; index >= 0; index--) {
-    if (!FAILURE_DIAGNOSTIC_LINE_PATTERN.test(lines[index] ?? "")) {
-      continue;
-    }
-    return lines.slice(index, Math.min(lines.length, index + TOOL_FAILURE_SIGNATURE_CONTEXT_LINES)).join("\n").slice(0, TOOL_FAILURE_SIGNATURE_CHARS);
-  }
-  return summary.slice(-TOOL_FAILURE_SIGNATURE_CHARS);
-}
-var AgentSessionRuntimeGuard = class {
-  constructor(trigger) {
-    this.trigger = trigger;
-  }
-  trigger;
-  repeatedToolFailures = /* @__PURE__ */ new Map();
-  streamGuard = {
-    whitespaceToolCallDeltaChars: 0,
-    whitespaceToolCallDeltaEvents: 0
-  };
-  isTriggered = false;
-  get triggered() {
-    return this.isTriggered;
-  }
-  reset() {
-    this.repeatedToolFailures.clear();
-    this.streamGuard = {
-      whitespaceToolCallDeltaChars: 0,
-      whitespaceToolCallDeltaEvents: 0
-    };
-    this.isTriggered = false;
-  }
-  markTriggered() {
-    this.isTriggered = true;
-  }
-  recordMessageUpdate(event) {
-    if (this.isTriggered) {
-      return;
-    }
-    const assistantEvent = event.assistantMessageEvent;
-    if (assistantEvent.type !== "toolcall_delta") {
-      this.streamGuard.whitespaceToolCallDeltaChars = 0;
-      this.streamGuard.whitespaceToolCallDeltaEvents = 0;
-      return;
-    }
-    if (assistantEvent.delta.trim().length > 0) {
-      this.streamGuard.whitespaceToolCallDeltaChars = 0;
-      this.streamGuard.whitespaceToolCallDeltaEvents = 0;
-      return;
-    }
-    this.streamGuard.whitespaceToolCallDeltaChars += assistantEvent.delta.length;
-    this.streamGuard.whitespaceToolCallDeltaEvents += 1;
-    const content = event.message.role === "assistant" && Array.isArray(event.message.content) ? event.message.content[assistantEvent.contentIndex] : void 0;
-    const partialArgs = typeof content?.partialArgs === "string" ? content.partialArgs : "";
-    const sparsePartialArgs = partialArgs.length >= RUNAWAY_TOOLCALL_WHITESPACE_DELTA_CHARS && partialArgs.replace(/\s/g, "").length / partialArgs.length < 0.05;
-    if (sparsePartialArgs || this.streamGuard.whitespaceToolCallDeltaChars >= RUNAWAY_TOOLCALL_WHITESPACE_DELTA_CHARS && this.streamGuard.whitespaceToolCallDeltaEvents >= RUNAWAY_TOOLCALL_WHITESPACE_DELTA_EVENTS) {
-      this.isTriggered = true;
-      this.trigger(
-        "assistant_stream",
-        this.streamGuard.whitespaceToolCallDeltaEvents,
-        "runaway_tool_call_arguments"
-      );
-    }
-  }
-  recordToolExecutionEnd(event) {
-    if (!event.isError) {
-      const prefix = `${event.toolName}:`;
-      for (const key2 of this.repeatedToolFailures.keys()) {
-        if (key2.startsWith(prefix)) {
-          this.repeatedToolFailures.delete(key2);
-        }
-      }
-      return;
-    }
-    const resultSummary = summarizeToolFailureSignature(event.result);
-    const key = `${event.toolName}:${stableStringify(event.args)}:${resultSummary}`;
-    const repeatCount = (this.repeatedToolFailures.get(key) ?? 0) + 1;
-    this.repeatedToolFailures.set(key, repeatCount);
-    if (repeatCount < 3 || this.isTriggered) {
-      return;
-    }
-    this.isTriggered = true;
-    this.trigger(event.toolName, repeatCount, "repeated_tool_error");
-  }
-};
-
-// ../../packages/agent-framework/src/session/controller/runtime-phase-policy.ts
-function classifyControllerRuntimeError(params) {
-  const errorMessage = params.error instanceof Error ? params.error.message : String(params.error);
-  return createFailureClassification({ errorMessage, phase: params.phase }, params.retry, params.classifyFailure);
-}
-async function runAgentSessionRuntimePhase(params) {
-  try {
-    return await params.action();
-  } catch (error) {
-    const failure = classifyControllerRuntimeError({
-      error,
-      phase: params.phase,
-      retry: params.retry,
-      classifyFailure: params.classifyFailure
-    });
-    if (failure.userAbort) {
-      params.setRecoveryState("cancelled");
-      params.emit({ type: "turn_cancelled", reason: failure.message });
-    } else {
-      params.setRecoveryState("terminal");
-      params.emit({ type: "turn_failed_terminal", failure: asTerminalFailure(failure) });
-    }
-    params.emit({ type: "turn_settled" });
-    throw error;
-  }
-}
-
-// ../../packages/agent-framework/src/session/controller/session-sync.ts
-function getConversationMessages(messages) {
-  return messages.filter(
-    (message) => message.role === "user" || message.role === "assistant" || message.role === "toolResult"
-  );
-}
-async function syncNewAgentMessages(params) {
-  const activeSession = params.sessionManager.getActiveSession();
-  const currentAgentCount = params.agent.state.messages.length;
-  if (!activeSession) {
-    params.setLastSyncedMessageCount(currentAgentCount);
-    return;
-  }
-  if (currentAgentCount <= params.lastSyncedMessageCount) {
-    return;
-  }
-  const addedMessages = params.agent.state.messages.slice(params.lastSyncedMessageCount);
-  for (const message of addedMessages) {
-    params.sessionManager.addMessage(message);
-  }
-  params.setLastSyncedMessageCount(currentAgentCount);
-  params.emit({ type: "session_synced", addedMessages, totalMessages: currentAgentCount });
-  await params.sessionManager.save();
-}
-
-// ../../packages/agent-framework/src/session/controller/lifecycle-state-machine.ts
-function createInitialAgentSessionLifecycleState() {
-  return {
-    phase: "idle",
-    queuedInputs: 0,
-    runtimeGuardTriggered: false,
-    retryPending: false,
-    autoCompactPending: false,
-    autoContinuePending: false
-  };
-}
-function reduceAgentSessionLifecycle(state, input) {
-  const next = { ...state };
-  switch (input.type) {
-    case "session_synced":
-      return createInitialAgentSessionLifecycleState();
-    case "prompt_started":
-      next.phase = "preparing_turn";
-      return next;
-    case "queued_input_added":
-      next.queuedInputs += 1;
-      next.phase = state.phase === "idle" ? "queued" : state.phase;
-      return next;
-    case "queued_input_dispatched":
-      next.queuedInputs = Math.max(0, next.queuedInputs - 1);
-      next.phase = "preparing_turn";
-      return next;
-    case "agent_start":
-      next.phase = "running";
-      return next;
-    case "turn_end_success":
-      next.phase = next.queuedInputs > 0 ? "queued" : "idle";
-      next.retryPending = false;
-      next.autoCompactPending = false;
-      return next;
-    case "turn_end_retryable_failure":
-    case "retry_scheduled":
-      next.phase = "retry_pending";
-      next.retryPending = true;
-      return next;
-    case "retry_completed":
-      next.retryPending = false;
-      next.phase = next.queuedInputs > 0 ? "queued" : "idle";
-      return next;
-    case "auto_compact_scheduled":
-      next.phase = "auto_compacting";
-      next.autoCompactPending = true;
-      return next;
-    case "auto_compact_completed":
-      next.autoCompactPending = false;
-      next.phase = next.retryPending ? "retry_pending" : next.queuedInputs > 0 ? "queued" : "idle";
-      return next;
-    case "agent_end":
-      next.phase = next.queuedInputs > 0 ? "queued" : "idle";
-      return next;
-    case "auto_continue_scheduled":
-      next.phase = "auto_continuing";
-      next.autoContinuePending = true;
-      return next;
-    case "auto_continue_completed":
-      next.autoContinuePending = false;
-      next.phase = "idle";
-      return next;
-    case "runtime_guard_triggered":
-      next.runtimeGuardTriggered = true;
-      next.phase = "runtime_blocked";
-      next.retryPending = false;
-      next.autoCompactPending = false;
-      next.autoContinuePending = false;
-      return next;
-    case "abort":
-      next.phase = "aborted";
-      next.retryPending = false;
-      next.autoCompactPending = false;
-      next.autoContinuePending = false;
-      return next;
-  }
-}
-
-// ../../packages/agent-framework/src/session/controller/turn-lifecycle-policy.ts
-function isAgentSessionRecoveryActive(state) {
-  return state === "retry_pending" || state === "retrying" || state === "compacting";
-}
-function createRuntimeGuardFailure(reason) {
-  return {
-    kind: "runtime_guard",
-    retryable: false,
-    compactable: false,
-    userAbort: false,
-    terminal: true,
-    message: reason
-  };
-}
-function classifyControllerTurnFailure(params) {
-  if (!isAssistantFailureMessage(params.message)) {
-    return void 0;
-  }
-  const errorMessage = params.message.errorMessage || (params.message.stopReason === "aborted" ? "Request was aborted" : "assistant response failed");
-  return createFailureClassification(
-    { errorMessage, message: params.message, phase: "stream" },
-    params.retry,
-    params.classifyFailure
-  );
-}
-async function handleAgentSessionTurnEndRuntimePolicies(params) {
-  if (params.disposed || params.runtimeGuardTriggered) {
-    return;
-  }
-  const failure = classifyControllerTurnFailure({
-    message: params.message,
-    retry: params.retry,
-    classifyFailure: params.classifyFailure
-  });
-  if (failure?.userAbort) {
-    params.cancelRetry();
-    params.setRecoveryState("cancelled");
-    params.emit({ type: "turn_cancelled", reason: failure.message, message: params.message });
-    params.emit({ type: "turn_settled" });
-    return;
-  }
-  const compactDecision = params.getAutoCompactDecision?.({
-    agent: params.agent,
-    sessionManager: params.sessionManager,
-    cwd: params.cwd,
-    message: params.message,
-    messages: params.agent.state.messages.slice()
-  });
-  if (failure?.compactable) {
-    params.scheduleAutoCompact(compactDecision ?? { reason: "overflow", willRetry: true }, failure);
-    return;
-  }
-  if (failure && compactDecision?.reason === "overflow") {
-    params.scheduleAutoCompact(compactDecision, failure);
-    return;
-  }
-  if (failure?.retryable && compactDecision?.reason === "threshold") {
-    params.scheduleAutoCompact({ reason: "threshold", willRetry: true }, failure);
-    return;
-  }
-  if (failure) {
-    if (failure.retryable) {
-      await params.handleRetryTurnEnd(params.message, failure);
-      return;
-    }
-    await params.handleRetryTurnEnd(params.message, failure);
-    params.setRecoveryState("terminal");
-    params.emit({ type: "turn_failed_terminal", failure: asTerminalFailure(failure), message: params.message });
-    params.emit({ type: "turn_settled" });
-    return;
-  }
-  await params.handleRetryTurnEnd(params.message);
-  if (isAssistantTerminalCompletion(params.message)) {
-    params.emit({ type: "turn_completed", message: params.message, toolResults: params.toolResults });
-    const postTurnCompactDecision = compactDecision ?? params.getAutoCompactDecision?.({
-      agent: params.agent,
-      sessionManager: params.sessionManager,
-      cwd: params.cwd,
-      message: params.message,
-      messages: params.agent.state.messages.slice()
-    });
-    if (postTurnCompactDecision?.reason === "threshold") {
-      params.scheduleAutoCompact(postTurnCompactDecision);
-      return;
-    }
-    params.setRecoveryState("none");
-    params.emit({ type: "turn_settled" });
-  }
-}
-async function runAgentSessionControllerAutoCompact(params) {
-  const emitSettled = params.emitSettled ?? true;
-  const runAfterAgentEndHook = params.runAfterAgentEndHook ?? true;
-  const cancelOnAbort = params.cancelOnAbort ?? true;
-  params.setRecoveryState("compacting");
-  params.emit({ type: "turn_compaction_started", reason: params.reason, willRetry: params.willRetry });
-  try {
-    const result = await runAgentSessionCompaction({
-      reason: params.reason,
-      willRetry: params.willRetry,
-      signal: params.signal,
-      compaction: params.compaction,
-      agent: params.agent,
-      sessionManager: params.sessionManager,
-      cwd: params.cwd,
-      emit: params.emit,
-      removeTrailingAssistantError: params.removeTrailingAssistantError,
-      replaceMessagesAndMarkSynced: params.replaceMessagesAndMarkSynced,
-      markSyncedToAgentState: params.markSyncedToAgentState,
-      continueTurn: params.continueTurn
-    });
-    if (!params.willRetry || result?.aborted) {
-      const alreadyCancelled = params.getRecoveryState?.() === "cancelled" || params.getDisposed?.() === true;
-      params.setRecoveryState(result?.aborted && cancelOnAbort ? "cancelled" : "none");
-      if (result?.aborted) {
-        params.cancelRetry();
-        if (cancelOnAbort && !alreadyCancelled) {
-          params.emit({ type: "turn_cancelled", reason: "compaction_aborted" });
-        }
-      }
-      if (emitSettled && !alreadyCancelled) {
-        params.emit({ type: "turn_settled" });
-      }
-      if (!result?.aborted && runAfterAgentEndHook) {
-        void params.handleAgentEndHook(params.agent.state.messages.slice());
-      }
-    }
-    return result;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (!params.willRetry && params.reason !== "overflow") {
-      params.setRecoveryState("none");
-      if (emitSettled) {
-        params.emit({ type: "turn_settled" });
-      }
-      if (runAfterAgentEndHook) {
-        void params.handleAgentEndHook(params.agent.state.messages.slice());
-      }
-      throw error;
-    }
-    const failure = asTerminalFailure(params.pendingFailure ?? {
-      kind: "internal_error",
-      retryable: false,
-      compactable: false,
-      userAbort: false,
-      terminal: true,
-      message: errorMessage
-    }, errorMessage);
-    params.cancelRetry();
-    params.setRecoveryState("terminal");
-    params.emit({ type: "turn_failed_terminal", failure });
-    params.emit({ type: "turn_settled" });
-    throw error;
-  } finally {
-    params.clearPendingFailure();
-  }
-}
-
-// ../../packages/agent-framework/src/session/controller.ts
-var AgentSessionController = class {
-  agent;
-  sessionManager;
-  cwd;
-  compaction;
-  listeners = /* @__PURE__ */ new Set();
-  queue;
-  queueDispatcher;
-  runtimeGuard;
-  retryController;
-  autoCompact;
-  autoContinue;
-  activity = new AgentSessionActivity();
-  unsubscribeAgent;
-  unsubscribeSemantic;
-  lastSyncedMessageCount = 0;
-  disposed = false;
-  baseSystemPrompt;
-  prepareTurn;
-  afterAgentEnd;
-  getAutoCompactDecision;
-  classifyFailure;
-  recoveryState = "none";
-  pendingCompactionFailure;
-  lifecycleState = createInitialAgentSessionLifecycleState();
-  constructor(options) {
-    this.agent = options.agent;
-    this.sessionManager = options.sessionManager;
-    this.cwd = options.cwd;
-    this.compaction = options.compaction;
-    this.baseSystemPrompt = options.baseSystemPrompt ?? this.agent.state.systemPrompt;
-    this.prepareTurn = options.prepareTurn;
-    this.afterAgentEnd = options.afterAgentEnd;
-    this.getAutoCompactDecision = options.getAutoCompactDecision;
-    this.classifyFailure = options.classifyFailure;
-    if (options.onEvent) {
-      this.listeners.add(options.onEvent);
-    }
-    this.runtimeGuard = new AgentSessionRuntimeGuard((toolName, repeatCount, reason) => {
-      this.triggerRuntimeGuard(toolName, repeatCount, reason);
-    });
-    this.queue = new AgentSessionQueue({
-      agent: this.agent,
-      getIsStreaming: () => this.isStreaming,
-      emit: (event) => this.emit(event)
-    });
-    this.retryController = new AgentSessionRetryController(
-      options.retry,
-      (event) => this.emit(event),
-      () => this.removeTrailingAssistantError(),
-      () => this.continue(),
-      (state) => {
-        this.recoveryState = state;
-      }
-    );
-    this.autoCompact = new AgentSessionAutoCompactScheduler({
-      retry: options.retry,
-      getDisposed: () => this.disposed,
-      getRuntimeGuardTriggered: () => this.runtimeGuard.triggered,
-      isStreaming: () => this.isStreaming,
-      runAutoCompact: async (decision, signal) => {
-        await this.runAutoCompact(decision.reason, decision.willRetry, { signal });
-      }
-    });
-    this.autoContinue = new AgentSessionAutoContinueController({
-      agent: this.agent,
-      sessionManager: this.sessionManager,
-      cwd: this.cwd,
-      getAutoContinueMessage: options.getAutoContinueMessage,
-      retry: options.retry,
-      emit: (event) => this.emit(event),
-      getDisposed: () => this.disposed,
-      getRuntimeGuardTriggered: () => this.runtimeGuard.triggered,
-      isBlockedByRuntimePolicy: () => this.isBlockedByRuntimePolicy(),
-      hasQueuedMessages: () => this.hasQueuedMessages,
-      isStreaming: () => this.isStreaming,
-      continueTurn: () => this.continue()
-    });
-    this.queueDispatcher = new AgentSessionQueueDispatcher({
-      agent: this.agent,
-      sessionManager: this.sessionManager,
-      cwd: this.cwd,
-      queue: this.queue,
-      retry: options.retry,
-      canDispatchQueuedTurn: options.canDispatchQueuedTurn,
-      emit: (event) => this.emit(event),
-      getDisposed: () => this.disposed,
-      getRuntimeGuardTriggered: () => this.runtimeGuard.triggered,
-      isStreaming: () => this.isStreaming,
-      isBlockedByRuntimePolicy: () => this.isBlockedByRuntimePolicy(),
-      runPreRequestAutoCompact: () => this.runPreRequestAutoCompactIfNeeded(),
-      preparePromptMessages: (messages, promptOptions) => this.preparePromptMessages(messages, promptOptions),
-      continueTurn: () => this.continue(),
-      syncNewAgentMessages: () => this.syncNewAgentMessages()
-    });
-    this.syncFromActiveSession();
-    this.unsubscribeAgent = this.agent.subscribe((event) => this.handleAgentEvent(event));
-    this.unsubscribeSemantic = this.agent.subscribeSemantic((event) => {
-      this.emit({ type: "semantic_event", event });
-    });
-  }
-  get isStreaming() {
-    return this.agent.state.isStreaming;
-  }
-  get isBusy() {
-    return this.activity.isBusy || this.isStreaming || this.isRecoveryActive() || this.hasQueuedMessages || this.hasPendingRuntimePolicy();
-  }
-  get hasQueuedMessages() {
-    return this.queue.hasQueuedMessages;
-  }
-  get pendingMessageCount() {
-    return this.queue.length;
-  }
-  get queuedInputsSnapshot() {
-    return this.queue.snapshot;
-  }
-  get turnRecoveryState() {
-    return this.recoveryState;
-  }
-  get activeSessionMetadata() {
-    const metadata = this.sessionManager.getActiveSession()?.metadata;
-    return metadata ? { ...metadata } : void 0;
-  }
-  get syncedMessageCount() {
-    return this.lastSyncedMessageCount;
-  }
-  get runtimeContext() {
-    return { systemPrompt: this.agent.state.systemPrompt, tools: this.agent.state.tools.slice() };
-  }
-  getRuntimeSnapshot() {
-    return {
-      isStreaming: this.isStreaming,
-      hasQueuedMessages: this.hasQueuedMessages,
-      pendingMessageCount: this.pendingMessageCount,
-      queuedInputs: this.queuedInputsSnapshot,
-      activeSessionMetadata: this.activeSessionMetadata,
-      syncedMessageCount: this.syncedMessageCount
-    };
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-  syncFromActiveSession(messages) {
-    const activeSession = this.sessionManager.getActiveSession();
-    this.agent.sessionId = activeSession?.id;
-    const sessionMessages = messages ?? this.sessionManager.getMessages();
-    const conversationMessages = getConversationMessages(sessionMessages);
-    this.agent.replaceMessages(conversationMessages);
-    this.lastSyncedMessageCount = conversationMessages.length;
-    this.queue.clear();
-    this.recordLifecycle({ type: "session_synced" });
-  }
-  markSyncedToAgentState() {
-    this.lastSyncedMessageCount = this.agent.state.messages.length;
-  }
-  replaceMessagesAndMarkSynced(messages, options) {
-    this.agent.replaceMessages(messages);
-    if (options?.updateSession) {
-      this.sessionManager.updateMessages(messages);
-    }
-    this.markSyncedToAgentState();
-  }
-  updateRuntimeContext(context) {
-    if (context.systemPrompt !== void 0) {
-      this.baseSystemPrompt = context.systemPrompt;
-      this.agent.setSystemPrompt(context.systemPrompt);
-    }
-    if (context.tools !== void 0) {
-      this.agent.setTools(context.tools);
-    }
-  }
-  prompt(input, options) {
-    return this.activity.run(async () => {
-      const messages = normalizePromptInput(input);
-      if (this.isRecoveryActive()) {
-        this.queue.enqueue(messages, options?.streamingBehavior ?? "followUp", {
-          ...options,
-          streamingBehavior: options?.streamingBehavior ?? "followUp"
-        });
-        this.recordLifecycle({ type: "queued_input_added" });
-        return;
-      }
-      if (this.recoveryState === "terminal" || this.recoveryState === "cancelled") this.recoveryState = "none";
-      if (options?.streamingBehavior) {
-        this.queue.enqueue(messages, options.streamingBehavior, options);
-        this.recordLifecycle({ type: "queued_input_added" });
-        if (!this.isStreaming) {
-          this.queueDispatcher.schedule();
-        }
-        return;
-      }
-      if (this.isStreaming) throw new Error("Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.");
-      await this.runPreRequestAutoCompactIfNeeded();
-      const prepared = await this.runRuntimePhase("prepare", () => this.preparePromptMessages(messages, options));
-      if (prepared.handled) return;
-      this.recordLifecycle({ type: "prompt_started" });
-      if (prepared.systemPrompt !== void 0) {
-        this.agent.setSystemPrompt(prepared.systemPrompt);
-      }
-      await this.runRuntimePhase("request", () => this.agent.prompt(prepared.messages));
-      await this.runRuntimePhase("post_turn", () => this.syncNewAgentMessages());
-    });
-  }
-  continue() {
-    return this.activity.run(async () => {
-      if (this.isStreaming) {
-        throw new Error("Agent is already processing. Wait for completion before continuing.");
-      }
-      await this.runPreRequestAutoCompactIfNeeded();
-      this.recordLifecycle({ type: "prompt_started" });
-      await this.runRuntimePhase("request", () => this.agent.continue());
-      await this.runRuntimePhase("post_turn", () => this.syncNewAgentMessages());
-    });
-  }
-  abort() {
-    this.recordLifecycle({ type: "abort" });
-    const cancelPendingRecovery = this.isRecoveryActive() && !this.isStreaming;
-    this.retryController.cancel();
-    this.autoCompact.cancel();
-    this.queueDispatcher.cancel();
-    this.autoContinue.cancel();
-    if (cancelPendingRecovery) {
-      this.recoveryState = "cancelled";
-      this.emit({ type: "turn_cancelled", reason: "user_abort" });
-      this.emit({ type: "turn_settled" });
-    }
-    this.agent.abort();
-  }
-  waitForIdle() {
-    return this.agent.waitForIdle();
-  }
-  async waitForSettled() {
-    while (true) {
-      await this.agent.waitForIdle();
-      if (!this.activity.isBusy && !this.hasPendingRuntimePolicy()) return;
-      await Promise.all([
-        this.activity.waitForIdle(),
-        this.retryController.waitForRetry(),
-        this.autoCompact.waitForAutoCompact(),
-        this.autoContinue.waitForAutoContinue(),
-        this.queueDispatcher.waitForDispatch()
-      ]);
-    }
-  }
-  async runAutoCompact(reason, willRetry = false, options) {
-    return runAgentSessionControllerAutoCompact({
-      reason,
-      willRetry,
-      signal: options?.signal,
-      compaction: this.compaction,
-      agent: this.agent,
-      sessionManager: this.sessionManager,
-      cwd: this.cwd,
-      pendingFailure: this.pendingCompactionFailure,
-      emit: (event) => this.emit(event),
-      setRecoveryState: (state) => {
-        this.recoveryState = state;
-      },
-      getRecoveryState: () => this.recoveryState,
-      getDisposed: () => this.disposed,
-      cancelRetry: () => this.retryController.cancel(),
-      clearPendingFailure: () => {
-        this.pendingCompactionFailure = void 0;
-      },
-      removeTrailingAssistantError: () => this.removeTrailingAssistantError(),
-      replaceMessagesAndMarkSynced: (messages, options2) => this.replaceMessagesAndMarkSynced(messages, options2),
-      markSyncedToAgentState: () => this.markSyncedToAgentState(),
-      continueTurn: () => this.continue(),
-      handleAgentEndHook: (messages) => this.trackAgentEndHook(messages),
-      emitSettled: options?.emitSettled,
-      runAfterAgentEndHook: options?.runAfterAgentEndHook,
-      cancelOnAbort: options?.cancelOnAbort
-    });
-  }
-  dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.retryController.cancel();
-    this.autoCompact.cancel();
-    this.queueDispatcher.cancel();
-    this.autoContinue.cancel();
-    this.unsubscribeAgent?.();
-    this.unsubscribeSemantic?.();
-    this.listeners.clear();
-    this.queue.clear();
-  }
-  drainQueuedInputsForEditor() {
-    return this.queue.drainForEditor();
-  }
-  replaceQueuedInputText(search, replacement) {
-    this.queue.replaceText(search, replacement);
-  }
-  requestQueueDispatch() {
-    if (this.queue.length > 0) this.queueDispatcher.schedule();
-  }
-  async runPreRequestAutoCompactIfNeeded() {
-    return runPreRequestAutoCompact({
-      disposed: this.disposed,
-      runtimeGuardTriggered: this.runtimeGuard.triggered,
-      isStreaming: this.isStreaming,
-      recoveryActive: this.isRecoveryActive(),
-      agent: this.agent,
-      sessionManager: this.sessionManager,
-      cwd: this.cwd,
-      getAutoCompactDecision: this.getAutoCompactDecision,
-      runAutoCompact: () => this.runAutoCompact("threshold", false, { emitSettled: false, runAfterAgentEndHook: false, cancelOnAbort: false }).then(() => void 0),
-      setRecoveryState: (state) => {
-        this.recoveryState = state;
-      }
-    });
-  }
-  handleAgentEvent(event) {
-    this.emit({ type: "agent_event", event });
-    if (event.type === "agent_start") {
-      this.runtimeGuard.reset();
-      this.recordLifecycle({ type: "agent_start" });
-      this.emit({ type: "streaming_changed", isStreaming: true });
-    }
-    if (event.type === "message_update") {
-      this.recordMessageUpdateForGuard(event);
-    }
-    if (event.type === "tool_execution_end") {
-      this.recordToolExecutionEndForGuard(event);
-    }
-    if (event.type === "message_end") {
-      this.queue.markMessageDelivered(event.message);
-    }
-    if (event.type === "turn_end") {
-      void this.syncNewAgentMessages();
-      this.recordLifecycle({ type: "turn_end_success" });
-      void this.activity.track(this.handleTurnEndRuntimePolicies(event.message, event.toolResults)).catch(() => {
-      });
-    }
-    if (event.type === "agent_end") {
-      this.recordLifecycle({ type: "agent_end" });
-      void this.trackAgentEndHook(event.messages);
-      this.emit({ type: "streaming_changed", isStreaming: false });
-    }
-  }
-  async preparePromptMessages(messages, options) {
-    return preparePromptMessages({
-      agent: this.agent,
-      sessionManager: this.sessionManager,
-      cwd: this.cwd,
-      baseSystemPrompt: this.baseSystemPrompt,
-      prepareTurn: this.prepareTurn,
-      emit: (event) => this.emit(event),
-      messages,
-      options
-    });
-  }
-  async syncNewAgentMessages() {
-    await syncNewAgentMessages({
-      agent: this.agent,
-      sessionManager: this.sessionManager,
-      lastSyncedMessageCount: this.lastSyncedMessageCount,
-      setLastSyncedMessageCount: (count) => {
-        this.lastSyncedMessageCount = count;
-      },
-      emit: (event) => this.emit(event)
-    });
-  }
-  removeTrailingAssistantError() {
-    removeTrailingAssistantError({
-      agent: this.agent,
-      replaceMessagesAndMarkSynced: (messages, options) => this.replaceMessagesAndMarkSynced(messages, options)
-    });
-  }
-  async handleTurnEndRuntimePolicies(message, toolResults = []) {
-    return handleAgentSessionTurnEndRuntimePolicies({
-      disposed: this.disposed,
-      runtimeGuardTriggered: this.runtimeGuard.triggered,
-      message,
-      toolResults,
-      agent: this.agent,
-      sessionManager: this.sessionManager,
-      cwd: this.cwd,
-      getAutoCompactDecision: this.getAutoCompactDecision,
-      classifyFailure: this.classifyFailure,
-      retry: this.retryController.policy,
-      emit: (event) => this.emit(event),
-      setRecoveryState: (state) => {
-        this.recoveryState = state;
-      },
-      handleRetryTurnEnd: (turnMessage, failure) => this.retryController.handleTurnEnd(turnMessage, failure),
-      cancelRetry: () => this.retryController.cancel(),
-      scheduleAutoCompact: (decision, failure) => this.scheduleAutoCompact(decision, failure)
-    });
-  }
-  async handleAgentEndHook(messages) {
-    if (this.disposed || this.runtimeGuard.triggered || this.isBlockedByRuntimePolicy()) {
-      return;
-    }
-    if (this.afterAgentEnd) {
-      this.emit({ type: "agent_end_hook_start", hasQueuedMessages: this.hasQueuedMessages });
-      try {
-        await this.afterAgentEnd({
-          messages,
-          agent: this.agent,
-          sessionManager: this.sessionManager,
-          cwd: this.cwd,
-          hasQueuedMessages: this.hasQueuedMessages
-        });
-        this.emit({ type: "agent_end_hook_end" });
-      } catch (error) {
-        this.emit({
-          type: "agent_end_hook_end",
-          errorMessage: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-    if (this.queue.length > 0) {
-      this.queueDispatcher.schedule();
-    }
-    if (!this.hasQueuedMessages) {
-      this.recordLifecycle({ type: "auto_continue_scheduled" });
-    }
-    this.autoContinue.schedule(messages);
-  }
-  trackAgentEndHook(messages) {
-    return this.activity.track(this.handleAgentEndHook(messages));
-  }
-  recordMessageUpdateForGuard(event) {
-    this.runtimeGuard.recordMessageUpdate(event);
-  }
-  recordToolExecutionEndForGuard(event) {
-    this.runtimeGuard.recordToolExecutionEnd(event);
-  }
-  async runRuntimePhase(phase, action) {
-    return runAgentSessionRuntimePhase({
-      phase,
-      action,
-      retry: this.retryController.policy,
-      classifyFailure: this.classifyFailure,
-      emit: (event) => this.emit(event),
-      setRecoveryState: (state) => {
-        this.recoveryState = state;
-      }
-    });
-  }
-  isRecoveryActive() {
-    return isAgentSessionRecoveryActive(this.recoveryState);
-  }
-  isBlockedByRuntimePolicy() {
-    return this.recoveryState !== "none" || this.retryController.hasPendingRetry || this.autoCompact.hasPendingAutoCompact;
-  }
-  hasPendingRuntimePolicy() {
-    return this.retryController.hasPendingRetry || this.autoCompact.hasPendingAutoCompact || this.autoContinue.hasPendingAutoContinue || this.queueDispatcher.hasPendingDispatch;
-  }
-  scheduleAutoCompact(decision, failure) {
-    this.recordLifecycle({ type: "auto_compact_scheduled" });
-    if (failure) {
-      this.pendingCompactionFailure = failure;
-      this.recoveryState = "compacting";
-      this.emit({ type: "turn_recovery_pending", recovery: "compaction", failure });
-    } else if (decision.reason === "threshold") {
-      this.recoveryState = "compacting";
-    }
-    this.autoCompact.schedule(decision);
-  }
-  triggerRuntimeGuard(toolName, repeatCount, reason) {
-    this.recordLifecycle({ type: "runtime_guard_triggered" });
-    if (this.runtimeGuard.triggered) {
-      this.runtimeGuard.markTriggered();
-    }
-    this.retryController.cancel();
-    this.autoCompact.cancel();
-    this.queueDispatcher.cancel();
-    this.autoContinue.cancel();
-    this.recoveryState = "terminal";
-    this.emit({ type: "runtime_guard_triggered", toolName, repeatCount, reason });
-    this.emit({
-      type: "turn_failed_terminal",
-      failure: createRuntimeGuardFailure(reason)
-    });
-    this.emit({ type: "turn_settled" });
-    this.agent.abort();
-  }
-  emit(event) {
-    for (const listener of this.listeners) {
-      listener(event);
-    }
-  }
-  recordLifecycle(input) {
-    this.lifecycleState = reduceAgentSessionLifecycle(this.lifecycleState, input);
-    void this.lifecycleState.phase;
-  }
-};
-
-// ../../packages/agent-framework/src/interaction.ts
-var InteractionUnavailableError = class extends Error {
-  request;
-  constructor(message, request) {
-    super(message);
-    this.name = "InteractionUnavailableError";
-    this.request = request;
-  }
-};
-var currentInteractionHandler = null;
-function registerInteractionHandler(handler) {
-  currentInteractionHandler = handler;
-}
-function hasInteractionHandler() {
-  return currentInteractionHandler !== null;
-}
-async function requestInteraction(request) {
-  if (!currentInteractionHandler) {
-    throw new InteractionUnavailableError(
-      `No interaction handler registered for request type: ${request.type}`,
-      request
-    );
-  }
-  return await currentInteractionHandler(request);
-}
-
-// ../../packages/agent-framework/src/extensions/identity.ts
-function normalizeName(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function resolveExtensionIdentity(input) {
-  return normalizeName(input.pieName) ?? normalizeName(input.packageName) ?? normalizeName(input.fallbackName);
-}
-function extensionFallbackName(pathSegment) {
-  const normalized = normalizeName(pathSegment);
-  if (!normalized) {
-    return void 0;
-  }
-  const base = normalized.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "";
-  const withoutExtension = base.replace(/\.(cjs|mjs|js|ts)$/i, "");
-  return normalizeName(withoutExtension);
-}
-
-// ../../packages/agent-framework/src/extensions/enablement.ts
-function hasOwn(object, key) {
-  return Object.prototype.hasOwnProperty.call(object, key);
-}
-function defineOwnDataProperty(target, key, value) {
-  Object.defineProperty(target, key, {
-    value,
-    enumerable: true,
-    configurable: true,
-    writable: true
-  });
-}
-function cloneOwnProperties(source) {
-  const clone = {};
-  for (const key of Object.keys(source)) {
-    defineOwnDataProperty(clone, key, source[key]);
-  }
-  return clone;
-}
-function getExtensionEnablementEntry(identity, settings) {
-  if (!settings || typeof settings !== "object") {
-    return void 0;
-  }
-  if (!hasOwn(settings, identity)) {
-    return void 0;
-  }
-  const raw = settings[identity];
-  if (typeof raw === "boolean") {
-    return raw;
-  }
-  if (raw && typeof raw === "object" && hasOwn(raw, "enabled") && typeof raw.enabled === "boolean") {
-    return raw.enabled;
-  }
-  return void 0;
-}
-function isExtensionEnabled(identity, ...layers) {
-  for (let i = layers.length - 1; i >= 0; i -= 1) {
-    const value = getExtensionEnablementEntry(identity, layers[i]);
-    if (value !== void 0) {
-      return value;
-    }
-  }
-  return true;
-}
-function extractExtensionSettings(parsed) {
-  if (!parsed || typeof parsed !== "object") {
-    return {};
-  }
-  if (!hasOwn(parsed, "extensions")) {
-    return {};
-  }
-  const extensions = parsed.extensions;
-  if (!extensions || typeof extensions !== "object" || Array.isArray(extensions)) {
-    return {};
-  }
-  return extensions;
-}
-function setExtensionEnabledInSettings(settingsObject, identity, enabled) {
-  const extensions = cloneOwnProperties(extractExtensionSettings(settingsObject));
-  const current = hasOwn(extensions, identity) ? extensions[identity] : void 0;
-  if (enabled === void 0) {
-    if (current && typeof current === "object" && !Array.isArray(current)) {
-      const next = cloneOwnProperties(current);
-      delete next.enabled;
-      if (Object.keys(next).length === 0) {
-        delete extensions[identity];
-      } else {
-        defineOwnDataProperty(extensions, identity, next);
-      }
-    } else {
-      delete extensions[identity];
-    }
-  } else {
-    const next = current && typeof current === "object" && !Array.isArray(current) ? cloneOwnProperties(current) : {};
-    defineOwnDataProperty(next, "enabled", enabled);
-    defineOwnDataProperty(extensions, identity, next);
-  }
-  if (Object.keys(extensions).length === 0) {
-    delete settingsObject.extensions;
-  } else {
-    defineOwnDataProperty(settingsObject, "extensions", extensions);
-  }
-  return settingsObject;
-}
-
-// ../../packages/agent-framework/src/context-files.ts
-var AGENTS_CONTEXT_FILE_NAME = "AGENTS.md";
-function normalizeContextPath(path) {
-  return String(path || "").replace(/\\/g, "/").replace(/^\/+/, "").trim() || AGENTS_CONTEXT_FILE_NAME;
-}
-function normalizeContextContent(content) {
-  return String(content || "").replace(/\r\n/g, "\n").trim();
-}
-function dedupeProjectContextFiles(files) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const file of files) {
-    const path = normalizeContextPath(file.path);
-    const key = path.toLowerCase();
-    const content = normalizeContextContent(file.content);
-    if (!content || seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    result.push({ path, content });
-  }
-  return result;
-}
-function buildProjectContextSection(files, options = {}) {
-  const contextFiles = dedupeProjectContextFiles(files);
-  if (contextFiles.length === 0) {
-    return "";
-  }
-  const heading = options.heading?.trim() || "Project Context";
-  const intro = options.intro?.trim() || "Project-specific instructions from AGENTS.md files. Apply them in order; later files may add narrower instructions.";
-  const lines = [`## ${heading}`, intro, ""];
-  for (const file of contextFiles) {
-    lines.push(`### ${file.path}`, file.content, "");
-  }
-  return lines.join("\n").trimEnd();
-}
-
-export {
-  estimateTokens,
-  calculateTotalTokens,
-  estimateContextTokens,
-  getAutoCompactTokenLimit,
-  findFirstKeptEntryId,
-  createCompactionSummary,
-  getGeneratedSessionName,
-  generateEntryId,
-  decodePersistedSessionContent,
-  FileSessionStore,
-  createSessionManager,
-  AgentSessionController,
-  resolveExtensionIdentity,
-  extensionFallbackName,
-  getExtensionEnablementEntry,
-  isExtensionEnabled,
-  extractExtensionSettings,
-  setExtensionEnabledInSettings,
-  InteractionUnavailableError,
-  registerInteractionHandler,
-  hasInteractionHandler,
-  requestInteraction,
-  AGENTS_CONTEXT_FILE_NAME,
-  buildProjectContextSection
-};