negotium 0.6.15 → 0.7.0

package/dist/agent-helpers.js

@@ -2053,12 +2053,12 @@ ${toolBuffer.join(`
         break;
       case "tool_use": {
         const u = ev;
-        toolBuffer.push(`<!-- Tool: ${u.name} ${truncate(JSON.stringify(u.input), 200)} -->`);
+        toolBuffer.push(opts.formatToolUse?.(u) ?? `<!-- Tool: ${u.name} ${truncate(JSON.stringify(u.input), 200)} -->`);
         break;
       }
       case "tool_result": {
         const u = ev;
-        toolBuffer.push(`<!-- Tool result: ${truncate(u.content, 200)} -->`);
+        toolBuffer.push(opts.formatToolResult?.(u) ?? `<!-- Tool result: ${truncate(u.content, 200)} -->`);
         break;
       }
       case "error": {
@@ -3001,7 +3001,7 @@ var init_codex = __esm(async () => {
 });
 
 // ../../packages/core/src/version.ts
-var NEGOTIUM_VERSION = "0.6.15";
+var NEGOTIUM_VERSION = "0.7.0";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
 import { spawn as spawn2 } from "child_process";
@@ -3759,6 +3759,16 @@ function appendConversationEventStrict(userId, topicName, agent, event) {
     }
   }
 }
+function appendRawConversationEventStrict(userId, topicName, agent, event) {
+  const path = getConversationPath(userId, topicName);
+  const entry = {
+    ts: new Date().toISOString(),
+    agent,
+    event
+  };
+  mkdirSync9(dirname8(path), { recursive: true });
+  appendJsonlLine(path, JSON.stringify(entry));
+}
 function readConversationPath(path) {
   const out = [];
   if (!existsSync9(path))
@@ -4027,6 +4037,35 @@ function buildClaudePrompt(opts) {
     parent_tool_use_id: null
   });
 }
+function watchClaudeProcessExit(signal) {
+  let listener;
+  const exited = new Promise((resolve7) => {
+    listener = resolve7;
+    const listeners = claudeProcessExitListeners.get(signal) ?? new Set;
+    listeners.add(listener);
+    claudeProcessExitListeners.set(signal, listeners);
+  });
+  return {
+    exited,
+    dispose: () => {
+      if (!listener)
+        return;
+      const listeners = claudeProcessExitListeners.get(signal);
+      listeners?.delete(listener);
+      if (listeners?.size === 0)
+        claudeProcessExitListeners.delete(signal);
+      listener = undefined;
+    }
+  };
+}
+function notifyClaudeProcessExit(signal, exit) {
+  const listeners = claudeProcessExitListeners.get(signal);
+  if (!listeners)
+    return;
+  claudeProcessExitListeners.delete(signal);
+  for (const listener of listeners)
+    listener(exit);
+}
 function signalProcessTree(pid, signal) {
   try {
     process.kill(-pid, signal);
@@ -4088,6 +4127,7 @@ function spawnClaudeCodeProcessWithTreeKill(options) {
     clearKillTimer();
     options.signal.removeEventListener("abort", onAbort);
     logger.debug({ pid: child.pid, code, signal }, "Claude Code process exited");
+    notifyClaudeProcessExit(options.signal, { code, signal });
   });
   child.once("error", (err) => {
     exited = true;
@@ -4098,6 +4138,7 @@ function spawnClaudeCodeProcessWithTreeKill(options) {
       command: options.command,
       err: err instanceof Error ? err.message : String(err)
     }, "Claude Code process error event");
+    notifyClaudeProcessExit(options.signal, { code: null, signal: null });
   });
   return {
     stdin: child.stdin,
@@ -4145,6 +4186,20 @@ async function* claudeProvider(opts) {
   delete cleanEnv.CLAUDECODE;
   cleanEnv.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT ??= "300000";
   cleanEnv.CLAUDE_CODE_DISABLE_WORKFLOWS = "1";
+  const sdkAbortController = new AbortController;
+  const onCallerAbort = () => sdkAbortController.abort();
+  if (opts.abortController?.signal.aborted)
+    sdkAbortController.abort();
+  else
+    opts.abortController?.signal.addEventListener("abort", onCallerAbort, { once: true });
+  const processExitWatch = watchClaudeProcessExit(sdkAbortController.signal);
+  let unexpectedProcessExit;
+  processExitWatch.exited.then((exit) => {
+    if (opts.abortController?.signal.aborted)
+      return;
+    unexpectedProcessExit = exit;
+    sdkAbortController.abort();
+  });
   const queryOptions = {
     ...claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {},
     spawnClaudeCodeProcess: spawnClaudeCodeProcessWithTreeKill,
@@ -4155,7 +4210,7 @@ async function* claudeProvider(opts) {
     env: cleanEnv,
     mcpServers: hostedMcpServers(opts),
     ...claudeBuiltInTools(opts) ? { tools: claudeBuiltInTools(opts) } : {},
-    abortController: opts.abortController,
+    abortController: sdkAbortController,
     disallowedTools: buildClaudeDisallowedTools(opts.disallowedTools),
     ...opts.model ? { model: opts.model } : {},
     ...opts.maxBudgetUsd ? { maxBudgetUsd: opts.maxBudgetUsd } : {},
@@ -4393,14 +4448,28 @@ async function* claudeProvider(opts) {
         }
       }
     }
+    if (unexpectedProcessExit) {
+      const detail = unexpectedProcessExit.signal ? `signal ${unexpectedProcessExit.signal}` : unexpectedProcessExit.code === null ? "before it could start" : `exit code ${unexpectedProcessExit.code}`;
+      logger.error({ detail }, "claudeProvider: CLI exited before terminal SDK event");
+      yield { type: "error", content: `Claude CLI exited unexpectedly (${detail}).` };
+    }
   } catch (e) {
+    if (unexpectedProcessExit) {
+      const detail = unexpectedProcessExit.signal ? `signal ${unexpectedProcessExit.signal}` : unexpectedProcessExit.code === null ? "before it could start" : `exit code ${unexpectedProcessExit.code}`;
+      logger.error({ err: e, detail }, "claudeProvider: CLI exited before terminal SDK event");
+      yield { type: "error", content: `Claude CLI exited unexpectedly (${detail}).` };
+      return;
+    }
     if (isAbortError(e) || opts.abortController?.signal.aborted)
       return;
     logger.error({ err: e }, "claudeProvider: SDK iteration failed");
     yield { type: "error", content: errMsg(e) };
+  } finally {
+    processExitWatch.dispose();
+    opts.abortController?.signal.removeEventListener("abort", onCallerAbort);
   }
 }
-var CLAUDE_DEFAULT_DISALLOWED_TOOLS, CLAUDE_NATIVE_AGENT_TOOLS, CLAUDE_IMAGE_MAX_BYTES, CLAUDE_IMAGE_MIME_TYPES, CLAUDE_ABORT_SIGKILL_DELAY_MS = 2500;
+var CLAUDE_DEFAULT_DISALLOWED_TOOLS, CLAUDE_NATIVE_AGENT_TOOLS, CLAUDE_IMAGE_MAX_BYTES, CLAUDE_IMAGE_MIME_TYPES, CLAUDE_ABORT_SIGKILL_DELAY_MS = 2500, claudeProcessExitListeners;
 var init_claude_provider = __esm(async () => {
   init_claude_registry();
   await init_execution_host();
@@ -4415,6 +4484,7 @@ var init_claude_provider = __esm(async () => {
     "TaskUpdate",
     "TaskList",
     "TaskGet",
+    "Monitor",
     "ScheduleWakeup",
     "CronCreate",
     "CronList",
@@ -4428,6 +4498,7 @@ var init_claude_provider = __esm(async () => {
     "image/gif",
     "image/webp"
   ]);
+  claudeProcessExitListeners = new WeakMap;
 });
 
 // ../../packages/core/src/agents/codex-tree-manager.ts
@@ -8351,7 +8422,7 @@ function createArchiverRuntime(host) {
       }
     }
   };
-  const listSessions = (userId) => {
+  const listSessions = (userId, allUsers = false) => {
     const now = host.config.now().getTime();
     for (const [id, session] of activeSessions) {
       if (session.expiresAt !== undefined && session.expiresAt <= now) {
@@ -8361,7 +8432,7 @@ function createArchiverRuntime(host) {
         activeSessions.delete(id);
       }
     }
-    return [...activeSessions.values()].filter((session) => session.userId === userId).map(({ userId: _userId, expiresAt: _expiresAt, expiryTimer: _expiryTimer, ...session }) => ({
+    return [...activeSessions.values()].filter((session) => allUsers || session.userId === userId).map(({ userId: _userId, expiresAt: _expiresAt, expiryTimer: _expiryTimer, ...session }) => ({
       ...session,
       steps: [...session.steps]
     }));
@@ -12052,8 +12123,415 @@ RULES:
 - Do NOT invent file paths or facts not present in the transcript.
 - Keep the entire summary under 1500 words.`, CHARS_PER_TEXT_TOKEN = 3.5, CHARS_PER_CJK_TOKEN = 0.9;
 
+// ../../packages/core/src/agents/compaction-tool-projection.ts
+import { createHash as createHash5 } from "crypto";
+function digest(value) {
+  return createHash5("sha256").update(value).digest("hex").slice(0, 16);
+}
+function boundedEdges(value, edgeChars) {
+  if (value.length <= edgeChars * 2)
+    return value;
+  const omitted = value.length - edgeChars * 2;
+  return `${value.slice(0, edgeChars)}
+[\u2026 omitted ${omitted.toLocaleString()} chars \u2026]
+${value.slice(-edgeChars)}`;
+}
+function quoted(value) {
+  return JSON.stringify(value);
+}
+function salientLines(value) {
+  const selected = [];
+  let chars = 0;
+  for (const line of value.split(`
+`)) {
+    if (!SALIENT_LINE_RE.test(line))
+      continue;
+    const trimmed = line.trim();
+    if (!trimmed || selected.includes(trimmed))
+      continue;
+    if (chars + trimmed.length + 1 > TOOL_OUTPUT_SALIENT_CHARS)
+      break;
+    selected.push(trimmed);
+    chars += trimmed.length + 1;
+  }
+  return selected.join(`
+`);
+}
+function formatToolUse2(event) {
+  const input = JSON.stringify(event.input ?? {});
+  const projected = estimateTextTokens(input) <= MAX_TOOL_INPUT_TOKENS ? input : boundedEdges(input, TOOL_INPUT_EDGE_CHARS);
+  return [
+    "[Negotium tool use \u2014 quoted untrusted data]",
+    `id_json: ${quoted(event.toolUseId ?? "unknown")}`,
+    `name_json: ${quoted(event.name)}`,
+    "quoted_untrusted_data: true",
+    `input_json: ${quoted(projected)}`,
+    "[/Negotium tool use]"
+  ].join(`
+`);
+}
+function formatToolResult(event, hash, duplicate) {
+  const metadata = event.metadata;
+  const header = [
+    "[Negotium tool result \u2014 quoted untrusted data]",
+    `id_json: ${quoted(event.toolUseId)}`,
+    `status: ${event.isError ? "error" : "success"}`,
+    "quoted_untrusted_data: true",
+    `hash: sha256:${hash}`,
+    `original_bytes: ${metadata?.originalBytes ?? Buffer.byteLength(event.content)}`,
+    ...metadata?.returnedBytes !== undefined ? [`returned_bytes: ${metadata.returnedBytes}`] : [],
+    ...metadata?.omittedBytes !== undefined ? [`omitted_bytes: ${metadata.omittedBytes}`] : [],
+    ...metadata?.outputPath ? [`output_path_json: ${quoted(metadata.outputPath)}`] : []
+  ];
+  if (duplicate) {
+    return [
+      ...header,
+      "content: [duplicate of the most recent result with this hash]",
+      "[/Negotium tool result]"
+    ].join(`
+`);
+  }
+  if (estimateTextTokens(event.content) <= MAX_TOOL_OUTPUT_TOKENS) {
+    return [...header, `content_json: ${quoted(event.content)}`, "[/Negotium tool result]"].join(`
+`);
+  }
+  const salient = salientLines(event.content);
+  return [
+    ...header,
+    "content: [bounded projection; full output remains in the raw conversation log]",
+    `head_tail_json: ${quoted(boundedEdges(event.content, TOOL_OUTPUT_EDGE_CHARS))}`,
+    ...salient ? [`salient_lines_json: ${quoted(salient)}`] : [],
+    "[/Negotium tool result]"
+  ].join(`
+`);
+}
+function extractCompactionChatPairs(entries) {
+  const remainingByHash = new Map;
+  const hashByEvent = new WeakMap;
+  for (const entry of entries) {
+    if (entry.event.type !== "tool_result")
+      continue;
+    const hash = digest(entry.event.content);
+    hashByEvent.set(entry.event, hash);
+    remainingByHash.set(hash, (remainingByHash.get(hash) ?? 0) + 1);
+  }
+  return extractChatPairs(entries, {
+    includeToolAnnotations: true,
+    formatToolUse: formatToolUse2,
+    formatToolResult: (event) => {
+      const hash = hashByEvent.get(event) ?? digest(event.content);
+      const remaining = Math.max(0, (remainingByHash.get(hash) ?? 1) - 1);
+      remainingByHash.set(hash, remaining);
+      return formatToolResult(event, hash, remaining > 0);
+    }
+  });
+}
+var MAX_TOOL_INPUT_TOKENS = 2000, MAX_TOOL_OUTPUT_TOKENS = 8000, TOOL_INPUT_EDGE_CHARS = 1000, TOOL_OUTPUT_EDGE_CHARS = 2000, TOOL_OUTPUT_SALIENT_CHARS = 2000, SALIENT_LINE_RE;
+var init_compaction_tool_projection = __esm(() => {
+  init_shared();
+  SALIENT_LINE_RE = /\b(error|failed?|failure|warning|exit(?:ed)?|expected|received|not found|denied|passed|tests?|assert|timeout|exception)\b/i;
+});
+
+// ../../packages/core/src/storage/token-stats.ts
+import { createHash as createHash6 } from "crypto";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync10 } from "fs";
+import { join as join21 } from "path";
+function emptyBucket() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationInputTokens: 0,
+    cacheReadInputTokens: 0,
+    queries: 0,
+    estimatedCostUsd: 0
+  };
+}
+function tokenStatsFileId(userId) {
+  const rawUserId = String(userId);
+  return /^[A-Za-z0-9][A-Za-z0-9_.@-]{0,255}$/.test(rawUserId) && !rawUserId.includes("..") ? rawUserId : `sha256-${createHash6("sha256").update(rawUserId).digest("hex")}`;
+}
+function queriesPath(userId) {
+  const fileId = tokenStatsFileId(userId);
+  const logDir = resolveStorageLogDir();
+  mkdirSync12(logDir, { recursive: true });
+  return join21(logDir, `token-queries-${fileId}.jsonl`);
+}
+function loadRecords(userId) {
+  try {
+    return readJsonlLines(queriesPath(userId)).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function estimateUsageCost(agent, model, usage) {
+  const prices = TOKEN_PRICES[`${agent}:${model}`];
+  if (!prices)
+    return 0;
+  return (usage.inputTokens * prices.input + usage.outputTokens * prices.output + (agent === "claude" ? usage.cacheCreationInputTokens * (prices.cacheWrite ?? prices.input) : 0) + usage.cacheReadInputTokens * prices.cacheRead) / 1e6;
+}
+function isQueryRecord(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const record = value;
+  return record.schemaVersion === 2 && typeof record.timestamp === "string" && typeof record.session === "string" && typeof record.topicId === "string" && typeof record.agent === "string" && typeof record.model === "string" && typeof record.inputTokens === "number" && typeof record.outputTokens === "number" && typeof record.cacheCreationInputTokens === "number" && typeof record.cacheReadInputTokens === "number" && typeof record.estimatedCostUsd === "number";
+}
+function recordUsage(userId, session, usage, context) {
+  const cacheReadInputTokens = usage.cacheReadInputTokens ?? 0;
+  const inputTokens = context.agent === "claude" ? usage.inputTokens : Math.max(0, usage.inputTokens - cacheReadInputTokens);
+  const normalized = {
+    inputTokens,
+    outputTokens: usage.outputTokens,
+    cacheCreationInputTokens: usage.cacheCreationInputTokens ?? 0,
+    cacheReadInputTokens
+  };
+  const record = {
+    schemaVersion: 2,
+    timestamp: new Date().toISOString(),
+    session,
+    topicId: context.topicId,
+    ...context.providerSessionId ? { providerSessionId: context.providerSessionId } : {},
+    agent: context.agent,
+    model: context.model,
+    ...normalized,
+    ...usage.contextTokens !== undefined ? { contextTokens: usage.contextTokens } : {},
+    ...usage.contextWindow !== undefined ? { contextWindow: usage.contextWindow } : {},
+    estimatedCostUsd: usage.costUsd ?? estimateUsageCost(context.agent, context.model, normalized)
+  };
+  try {
+    appendJsonlEntry(queriesPath(userId), record);
+  } catch (e) {
+    logger.warn({ err: e, userId }, "token-stats: Failed to record");
+  }
+}
+function deleteTopicStats(userId, topicId) {
+  const path = queriesPath(userId);
+  try {
+    const kept = readJsonlLines(path).filter((line) => {
+      try {
+        const record = JSON.parse(line);
+        return record.topicId !== topicId;
+      } catch {
+        return true;
+      }
+    });
+    writeFileSync10(path, kept.length > 0 ? `${kept.join(`
+`)}
+` : "", "utf-8");
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return;
+    logger.warn({ err: e, userId, topicId }, "token-stats: Failed to delete topic stats");
+  }
+}
+function getTopicStats(userId, topicId, activeProviderSessionId = getTopicSessionId(topicId) ?? undefined) {
+  const total = emptyBucket();
+  let currentSession;
+  for (const raw of loadRecords(userId)) {
+    if (!isQueryRecord(raw) || raw.topicId !== topicId)
+      continue;
+    total.inputTokens += raw.inputTokens;
+    total.outputTokens += raw.outputTokens;
+    total.cacheCreationInputTokens += raw.cacheCreationInputTokens;
+    total.cacheReadInputTokens += raw.cacheReadInputTokens;
+    total.queries += 1;
+    total.estimatedCostUsd += raw.estimatedCostUsd;
+    if (raw.contextTokens !== undefined && raw.contextWindow !== undefined && raw.contextWindow > 0 && activeProviderSessionId !== undefined && raw.providerSessionId === activeProviderSessionId && (!currentSession || raw.timestamp > currentSession.timestamp)) {
+      currentSession = {
+        timestamp: raw.timestamp,
+        topicId: raw.topicId,
+        topicTitle: raw.session,
+        ...raw.providerSessionId ? { providerSessionId: raw.providerSessionId } : {},
+        agent: raw.agent,
+        model: raw.model,
+        contextTokens: raw.contextTokens,
+        contextWindow: raw.contextWindow
+      };
+    }
+  }
+  return { topicId, ...total, ...currentSession ? { currentSession } : {} };
+}
+var TOKEN_PRICES;
+var init_token_stats = __esm(async () => {
+  init_jsonl();
+  init_logger();
+  await init_api_topics();
+  await init_storage_host();
+  TOKEN_PRICES = {
+    "codex:gpt-5.6-sol": { input: 5, cacheRead: 0.5, output: 30 },
+    "codex:gpt-5.6-terra": { input: 2.5, cacheRead: 0.25, output: 15 },
+    "codex:gpt-5.6-luna": { input: 1, cacheRead: 0.1, output: 6 },
+    "claude:fable": { input: 10, cacheWrite: 12.5, cacheRead: 1, output: 50 },
+    "claude:opus": { input: 5, cacheWrite: 6.25, cacheRead: 0.5, output: 25 },
+    "claude:sonnet": { input: 2, cacheWrite: 2.5, cacheRead: 0.2, output: 10 },
+    "maestro:kimi-k3": { input: 3, cacheRead: 0.3, output: 15 },
+    "maestro:kimi-k2.7-code": { input: 0.95, cacheRead: 0.19, output: 4 },
+    "maestro:deepseek-pro": { input: 0.435, cacheRead: 0.003625, output: 0.87 },
+    "maestro:deepseek-flash": { input: 0.14, cacheRead: 0.0028, output: 0.28 }
+  };
+});
+
+// ../../packages/core/src/agents/idle-compact.ts
+function cancelIdleCompactForTopic(topicId) {
+  const timer = timers2.get(topicId);
+  const contextLimitTimer = contextLimitTimers.get(topicId);
+  if (timer)
+    clearTimeout(timer);
+  if (contextLimitTimer)
+    clearTimeout(contextLimitTimer);
+  timers2.delete(topicId);
+  contextLimitTimers.delete(topicId);
+  return Boolean(timer || contextLimitTimer);
+}
+function envFlagEnabled2(name, fallback) {
+  const raw = process.env[name]?.trim().toLowerCase();
+  if (!raw)
+    return fallback;
+  return !["0", "false", "off", "no"].includes(raw);
+}
+function envPositiveInt2(name, fallback) {
+  const value = Number.parseInt(process.env[name] ?? "", 10);
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function idleCompactDelayMs() {
+  return envPositiveInt2("NEGOTIUM_IDLE_COMPACT_DELAY_MS", DEFAULT_IDLE_DELAY_MS2);
+}
+function idleCompactMinContextPercent() {
+  return envPositiveInt2("NEGOTIUM_IDLE_COMPACT_MIN_CONTEXT_PERCENT", DEFAULT_MIN_CONTEXT_PERCENT);
+}
+function idleCompactEnabled() {
+  return envFlagEnabled2("NEGOTIUM_IDLE_COMPACT_ENABLED", true);
+}
+function scheduleIdleCompactForTopic(topicId, userId) {
+  if (!idleCompactEnabled())
+    return "disabled";
+  const topic = getTopic(topicId);
+  if (!topic)
+    return "topic-not-found";
+  if (!topic.agent)
+    return "not-ai-invited";
+  if (topic.aiMode === "mention")
+    return "mention-only-channel";
+  const existing = timers2.get(topicId);
+  if (existing)
+    clearTimeout(existing);
+  const timer = setTimeout(() => {
+    timers2.delete(topicId);
+    runIdleCompactForTopic(topicId, userId);
+  }, idleCompactDelayMs());
+  timer.unref?.();
+  timers2.set(topicId, timer);
+  return "scheduled";
+}
+function scheduleContextLimitCompactForTopic(topicId, userId, contextTokens, contextWindow) {
+  if (!idleCompactEnabled())
+    return "disabled";
+  if (!Number.isFinite(contextWindow) || contextWindow <= 0)
+    return "below-threshold";
+  const percent = contextTokens / contextWindow * 100;
+  if (!Number.isFinite(percent) || percent < CONTEXT_LIMIT_COMPACT_PERCENT) {
+    return "below-threshold";
+  }
+  const topic = getTopic(topicId);
+  if (!topic)
+    return "topic-not-found";
+  if (!topic.agent)
+    return "not-ai-invited";
+  if (topic.aiMode === "mention")
+    return "mention-only-channel";
+  const existing = contextLimitTimers.get(topicId);
+  if (existing)
+    clearTimeout(existing);
+  const retry = () => scheduleContextLimitCompactForTopic(topicId, userId, contextTokens, contextWindow);
+  const timer = setTimeout(() => {
+    contextLimitTimers.delete(topicId);
+    runIdleCompactForTopic(topicId, userId, {
+      minContextPercent: CONTEXT_LIMIT_COMPACT_PERCENT,
+      reason: "context-limit-compact",
+      onBusy: retry
+    });
+  }, DEFAULT_CONTEXT_LIMIT_DELAY_MS);
+  timer.unref?.();
+  contextLimitTimers.set(topicId, timer);
+  return "scheduled";
+}
+async function runIdleCompactForTopic(topicId, userId, options = {}) {
+  if (!idleCompactEnabled())
+    return "disabled";
+  const busy = options.isBusy ? options.isBusy(topicId) : Boolean(getRoomQuery(topicId) || getRuntimeTurnLease(topicId));
+  if (busy) {
+    if (options.onBusy)
+      options.onBusy(topicId, userId);
+    else
+      scheduleIdleCompactForTopic(topicId, userId);
+    return "busy";
+  }
+  const topic = getTopic(topicId);
+  if (!topic)
+    return "topic-not-found";
+  if (!topic.agent)
+    return "not-ai-invited";
+  if (topic.aiMode === "mention")
+    return "mention-only-channel";
+  const owner = topic.participants.find((participant) => participant.role === "owner")?.userId;
+  if (!owner)
+    return "no-owner";
+  const stats = (options.getStats ?? getTopicStats)(owner, topicId);
+  const currentSession = stats.currentSession;
+  if (!currentSession || currentSession.contextWindow <= 0) {
+    logger.debug({ topicId }, "idle-compact: no provider-reported context usage yet, skipping");
+    return "below-threshold";
+  }
+  const percent = currentSession.contextTokens / currentSession.contextWindow * 100;
+  const minPercent = options.minContextPercent ?? idleCompactMinContextPercent();
+  if (percent < minPercent) {
+    logger.debug({ topicId, percent: Math.round(percent), minPercent }, "idle-compact: skipped below context-usage threshold");
+    return "below-threshold";
+  }
+  const compact = options.compact ?? (async (id, actorId, reason) => {
+    const { compactTopicSession } = await init_session().then(() => exports_session);
+    return compactTopicSession(id, actorId, reason, { preemptive: false });
+  });
+  try {
+    const result = await compact(topicId, owner, options.reason ?? "idle-compact");
+    if (result.busy) {
+      logger.debug({ topicId, percent: Math.round(percent) }, "idle-compact: topic became busy, rescheduling");
+      if (options.onBusy)
+        options.onBusy(topicId, owner);
+      else
+        scheduleIdleCompactForTopic(topicId, owner);
+      return "busy";
+    }
+    if (result.isError) {
+      logger.warn({ topicId, percent: Math.round(percent), text: result.text }, "idle-compact: failed");
+      return "failed";
+    }
+    logger.info({ topicId, percent: Math.round(percent) }, "idle-compact: compacted an idle topic's context");
+    return "compacted";
+  } catch (error) {
+    logger.warn({ err: error, topicId, percent: Math.round(percent) }, "idle-compact: unexpected failure while compacting an idle topic");
+    return "failed";
+  }
+}
+var DEFAULT_IDLE_DELAY_MS2, DEFAULT_CONTEXT_LIMIT_DELAY_MS = 1000, CONTEXT_LIMIT_COMPACT_PERCENT = 90, DEFAULT_MIN_CONTEXT_PERCENT = 50, timers2, contextLimitTimers;
+var init_idle_compact = __esm(async () => {
+  init_logger();
+  await init_active_rooms();
+  await init_api_topics();
+  await init_runtime_leases();
+  await init_token_stats();
+  DEFAULT_IDLE_DELAY_MS2 = 6 * 60 * 60 * 1000;
+  timers2 = new Map;
+  contextLimitTimers = new Map;
+});
+
 // ../../packages/core/src/agents/topic-cleanup.ts
-import { mkdirSync as mkdirSync12, renameSync as renameSync6, unlinkSync as unlinkSync12, writeFileSync as writeFileSync10 } from "fs";
+import { mkdirSync as mkdirSync13, renameSync as renameSync6, unlinkSync as unlinkSync12, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname13 } from "path";
 function collectSessionIdsByAgent(entries, extraSessions = []) {
   const out = new Map;
@@ -12120,8 +12598,8 @@ function createTopicLogMaintenance(host) {
       const path = runtimeHost.activeConversationPath(opts.userId, opts.topicName);
       const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
       try {
-        mkdirSync12(dirname13(path), { recursive: true });
-        writeFileSync10(tempPath, retained.length > 0 ? `${retained.map((entry) => JSON.stringify(entry)).join(`
+        mkdirSync13(dirname13(path), { recursive: true });
+        writeFileSync11(tempPath, retained.length > 0 ? `${retained.map((entry) => JSON.stringify(entry)).join(`
 `)}
 ` : "", { flag: "wx" });
         renameSync6(tempPath, path);
@@ -12572,25 +13050,221 @@ var init_runtime_turn_requests = __esm(async () => {
 });
 
 // ../../packages/core/src/topics/session.ts
+var exports_session = {};
+__export(exports_session, {
+  splitCompactionPairs: () => splitCompactionPairs,
+  shouldUseCompactionLog: () => shouldUseCompactionLog,
+  shouldCompactForkEntries: () => shouldCompactForkEntries,
+  restartTopicSession: () => restartTopicSession,
+  createCompactedRolloutEntries: () => createCompactedRolloutEntries,
+  compactTopicSession: () => compactTopicSession,
+  COMPACTION_RETAINED_TAIL_TOKENS: () => COMPACTION_RETAINED_TAIL_TOKENS,
+  AUTO_FORK_COMPACTION_TOKENS: () => AUTO_FORK_COMPACTION_TOKENS
+});
 import { randomUUID as randomUUID11 } from "crypto";
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "fs";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync4, writeFileSync as writeFileSync12 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join21 } from "path";
-function previousCompactedSummary(entries) {
-  for (let index = entries.length - 2;index >= 0; index -= 1) {
-    const request = entries[index]?.event;
-    const response = entries[index + 1]?.event;
-    if (request?.type === "user_message" && request.synthetic === "compaction" && request.content === `${COMPACT_CONTEXT_MARKER}
-The assistant response is the authoritative summary of all earlier context.` && response?.type === "result" && response.content.trim()) {
-      return response.content.trim();
-    }
-  }
-  return;
-}
-function fitCompactionChunk(text2, limit) {
-  if (text2.length <= limit)
-    return text2;
-  const marker = `
+import { join as join22 } from "path";
+async function waitForMemoryArchive(settled, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      settled.then(() => true),
+      new Promise((resolve16) => {
+        timer = setTimeout(() => resolve16(false), timeoutMs);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+async function fenceTopicWork(topicId, maintenance) {
+  for (const queryId of cancelRuntimeUserTurnRequestsBeforeEpoch(topicId, maintenance.epoch)) {
+    WsHub.get().broadcastAborted(topicId, queryId, "stopped");
+  }
+  interSessionQueue.drop(topicId);
+  const abortedLocal = abortRoom(topicId);
+  const abortedRemote = requestRuntimeTurnAbort(topicId, "external");
+  if (abortedLocal || abortedRemote || getRuntimeTurnLease(topicId)) {
+    const deadline = Date.now() + RESET_TURN_WAIT_MS;
+    while ((getRoomQuery(topicId) || getRuntimeTurnLease(topicId)) && Date.now() < deadline) {
+      await delay(50);
+    }
+    if (getRoomQuery(topicId) || getRuntimeTurnLease(topicId)) {
+      return "The active turn did not stop in time. Try again.";
+    }
+  }
+  return maintenance.isOwned() ? null : "Topic maintenance ownership was lost. Try again.";
+}
+function hasTopicWorkInFlight(topicId) {
+  return Boolean(getRoomQuery(topicId) || getRuntimeTurnLease(topicId) || getRuntimeUserTurnRequest(topicId));
+}
+function topicIsQuiescedForNonPreemptiveWork(topicId) {
+  return !hasTopicWorkInFlight(topicId);
+}
+async function restartTopicSession(topicId, userId, reason = "topic-session-restart", options = {}) {
+  const topic = getTopic(topicId);
+  if (!topic)
+    return { text: "Topic not found.", isError: true };
+  if (isLegacySharedGeneral(topic.id)) {
+    return { text: "The legacy shared General session cannot be reset.", isError: true };
+  }
+  const owner = topic.participants.some((participant) => participant.userId === userId && participant.role === "owner");
+  if (!owner)
+    return { text: "Only the topic owner can reset the session.", isError: true };
+  const maintenance = beginRuntimeTopicMaintenance(topicId);
+  if (!maintenance)
+    return { text: "Topic maintenance is already in progress.", isError: true };
+  try {
+    const fenceError = await fenceTopicWork(topicId, maintenance);
+    if (fenceError)
+      return { text: fenceError, isError: true };
+    cancelIdleArchiveForTopic(topicId);
+    cancelIdleCompactForTopic(topicId);
+    const rawArchivePaths = [];
+    try {
+      for (const participantUserId of new Set([
+        userId,
+        ...topic.participants.map((participant) => participant.userId)
+      ])) {
+        const archived = archiveConversationEvents(topicId, topic.title, participantUserId, {
+          reason: "reset"
+        });
+        if (archived)
+          rawArchivePaths.push(archived.path);
+      }
+    } catch (error) {
+      return {
+        text: `Session reset could not archive the raw conversation: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+    let settleMemoryArchive;
+    const memoryArchiveSettled = new Promise((resolve16) => {
+      settleMemoryArchive = resolve16;
+    });
+    const archiveStatus = (options.archiveMemory ?? archiveActiveTopicForMemory)(topicId, options.memoryUserId ?? userId, {
+      reason: "reset",
+      minMessages: 1,
+      minExchanges: MIN_MEMORY_ARCHIVE_EXCHANGES,
+      allowMentionOnly: true,
+      skipBusyCheck: true,
+      rawArchivePaths,
+      onSettled: () => settleMemoryArchive?.()
+    });
+    if (archiveStatus === "archived") {
+      const archiveFinished = await waitForMemoryArchive(memoryArchiveSettled, options.memoryArchiveWaitMs ?? RESET_MEMORY_ARCHIVE_WAIT_MS);
+      if (!archiveFinished) {
+        return {
+          text: "Memory archiving did not finish in time. The session was not reset.",
+          isError: true
+        };
+      }
+    }
+    if (!maintenance.isOwned()) {
+      return { text: "Topic maintenance ownership was lost. Try again.", isError: true };
+    }
+    const sessionId = getTopicSessionId(topicId);
+    const purgeLogs = options.purgeLogs ?? purgeTopicLogs;
+    const participantUserIds = Array.from(new Set([userId, ...topic.participants.map((participant) => participant.userId)]));
+    for (const [index, participantUserId] of participantUserIds.entries()) {
+      let purged = false;
+      try {
+        purged = await purgeLogs({
+          userId: participantUserId,
+          topicName: topic.title,
+          cwd: resolveTopicWorkspaceDir(topicId),
+          extraSessions: index === 0 && topic.agent && sessionId ? [{ agent: topic.agent, sessionId }] : []
+        });
+      } catch (error) {
+        logger.warn({ err: error, topicId, userId: participantUserId }, "restartTopicSession: participant context cleanup failed");
+      }
+      if (!purged) {
+        return {
+          text: "Session reset could not remove all provider context. The current session was kept.",
+          isError: true
+        };
+      }
+    }
+    clearTopicSessionId(topicId, reason);
+    clearQueryUsageAlert(userId, topicId);
+    return { text: `Session reset for "${topic.title}". The next message starts fresh.` };
+  } finally {
+    maintenance.finish();
+  }
+}
+function previousCompactedSummary(entries) {
+  for (let index = entries.length - 2;index >= 0; index -= 1) {
+    const request = entries[index]?.event;
+    const response = entries[index + 1]?.event;
+    if (request?.type === "user_message" && request.synthetic === "compaction" && request.content === `${COMPACT_CONTEXT_MARKER}
+The assistant response is the authoritative summary of all earlier context.` && response?.type === "result" && response.content.trim()) {
+      return response.content.trim();
+    }
+  }
+  return;
+}
+function withoutCompactionSentinels(entries) {
+  const filtered = [];
+  for (let index = 0;index < entries.length; index++) {
+    const current2 = entries[index]?.event;
+    const next = entries[index + 1]?.event;
+    if (current2?.type === "user_message" && current2.synthetic === "compaction" && next?.type === "result") {
+      index += 1;
+      continue;
+    }
+    const entry = entries[index];
+    if (entry)
+      filtered.push(entry);
+  }
+  return filtered;
+}
+function pairTokens(pair) {
+  return estimateConversationTokens([{ content: pair.userText }, { content: pair.assistantText }]);
+}
+function splitCompactionPairs(entries, retainedTailTokens = COMPACTION_RETAINED_TAIL_TOKENS) {
+  const pairs = extractCompactionChatPairs(withoutCompactionSentinels(entries));
+  let retainedStart = pairs.length;
+  let retainedTokens = 0;
+  for (let index = pairs.length - 1;index >= 0; index--) {
+    const pair = pairs[index];
+    if (!pair)
+      continue;
+    const tokens = pairTokens(pair);
+    if (retainedTokens + tokens > retainedTailTokens)
+      break;
+    retainedTokens += tokens;
+    retainedStart = index;
+  }
+  if (retainedStart === 0)
+    return { summaryPairs: pairs, retainedPairs: [] };
+  return {
+    summaryPairs: pairs.slice(0, retainedStart),
+    retainedPairs: pairs.slice(retainedStart)
+  };
+}
+function retainedPairEntries(agent, pairs) {
+  const entries = [];
+  for (const pair of pairs) {
+    const now = new Date().toISOString();
+    entries.push({
+      ts: now,
+      agent,
+      event: { type: "user_message", content: pair.userText }
+    }, {
+      ts: now,
+      agent,
+      event: { type: "result", content: pair.assistantText, stopReason: "end_turn" }
+    });
+  }
+  return entries;
+}
+function fitCompactionChunk(text2, limit) {
+  if (text2.length <= limit)
+    return text2;
+  const marker = `
 [\u2026]
 `;
   if (limit <= marker.length)
@@ -12600,7 +13274,7 @@ function fitCompactionChunk(text2, limit) {
   const tailChars = available - headChars;
   return `${text2.slice(0, headChars)}${marker}${text2.slice(-tailChars)}`;
 }
-function buildCompactionSource(topicId, userId, entries, visibleMessages) {
+function buildCompactionSource(topicId, userId, entries, visibleMessages, providerPairs) {
   const sections = [];
   const previous = previousCompactedSummary(entries);
   if (previous)
@@ -12612,10 +13286,10 @@ ${previous}`);
     sections.push(`## Durable topic memory
 ${fitCompactionChunk(memory, COMPACTION_MEMORY_CHARS)}`);
   }
-  const rows = (visibleMessages ?? getAllMessagesForTopic(topicId)).filter((row) => row.author_id !== "system" && row.kind !== "system" && row.kind !== "tool" && !row.id.startsWith("tasks-") && row.text.trim());
+  const rows = (previous ? [] : visibleMessages ?? getAllMessagesForTopic(topicId)).filter((row) => row.author_id !== "system" && row.kind !== "system" && row.kind !== "tool" && !row.id.startsWith("tasks-") && row.text.trim());
   const usedByContext = sections.reduce((sum, section) => sum + section.length + 2, 0);
   const conversationBudget = Math.max(0, COMPACTION_SOURCE_CHARS - usedByContext);
-  const pairs = extractChatPairs(entries);
+  const pairs = providerPairs ?? extractCompactionChatPairs(entries);
   const hasVisibleRows = rows.length > 0;
   const providerBudget = pairs.length > 0 ? hasVisibleRows ? Math.floor(conversationBudget * 0.65) : conversationBudget : 0;
   const providerTranscript = [];
@@ -12705,7 +13379,7 @@ function formatCompactElapsed(startedAt) {
 async function summarizeTopicContext(request) {
   const startedAt = Date.now();
   const sessionIds = [];
-  const compactCwd = mkdtempSync2(join21(tmpdir4(), "negotium-compact-"));
+  const compactCwd = mkdtempSync2(join22(tmpdir4(), "negotium-compact-"));
   const abortController = new AbortController;
   const relayAbort = () => abortController.abort(request.signal?.reason);
   if (request.signal?.aborted)
@@ -12732,7 +13406,7 @@ async function summarizeTopicContext(request) {
   let error = "";
   let toolViolation = false;
   let compactionLogCalls = 0;
-  const compactionLogPath = join21(compactCwd, "conversation.log");
+  const compactionLogPath = join22(compactCwd, "conversation.log");
   try {
     const compactionMcp = useCompactionLog ? {
       compact_log: {
@@ -12746,7 +13420,7 @@ async function summarizeTopicContext(request) {
       }
     } : undefined;
     if (useCompactionLog)
-      writeFileSync11(compactionLogPath, request.source, { mode: 384 });
+      writeFileSync12(compactionLogPath, request.source, { mode: 384 });
     for await (const event of runAgent({
       agent: request.agent,
       prompt: useCompactionLog ? [
@@ -12928,12 +13602,14 @@ function shouldCompactForkEntries(entries, thresholdTokens = AUTO_FORK_COMPACTIO
   return estimateConversationTokens(messages) >= thresholdTokens;
 }
 async function createCompactedRolloutEntries(request, summarize = summarizeTopicContext) {
-  const source = buildCompactionSource(request.topicId, request.userId, request.entries, request.visibleMessages);
+  const { summaryPairs, retainedPairs } = splitCompactionPairs(request.entries, request.retainedTailTokens);
+  const source = buildCompactionSource(request.topicId, request.userId, request.entries, request.visibleMessages, summaryPairs);
   if (!source)
     throw new Error(`Nothing to compact in "${request.topicTitle}".`);
   const {
     entries: _entries,
     visibleMessages: _visibleMessages,
+    retainedTailTokens: _retainedTailTokens,
     timeoutMs = shouldUseCompactionLog(source) ? COMPACTION_LOG_TIMEOUT_MS : COMPACTION_TIMEOUT_MS,
     summaryModel,
     summaryEffort,
@@ -12947,11 +13623,171 @@ async function createCompactedRolloutEntries(request, summarize = summarizeTopic
   }, summarize, timeoutMs)).trim();
   if (!summary)
     throw new Error("Context compaction returned an empty summary.");
-  return compactEntries(request.agent, summary.slice(0, COMPACTION_OUTPUT_CHARS));
+  return [
+    ...compactEntries(request.agent, summary.slice(0, COMPACTION_OUTPUT_CHARS)),
+    ...retainedPairEntries(request.agent, retainedPairs)
+  ];
+}
+async function cleanupNewRollout(agent, cwd, sessionId) {
+  try {
+    await getRegistryOperations(agent).cleanupRollouts({ cwd, sessionIds: [sessionId] });
+  } catch (error) {
+    logger.warn({ err: error, agent, sessionId }, "compact: replacement rollout cleanup failed");
+  }
+}
+async function compactTopicSession(topicId, userId, reason = "topic-session-compact", options = {}) {
+  const topic = getTopic(topicId);
+  if (!topic)
+    return { text: "Topic not found.", isError: true };
+  const owner = topic.participants.some((participant) => participant.userId === userId && participant.role === "owner");
+  if (!owner)
+    return { text: "Only the topic owner can compact the session.", isError: true };
+  const preemptive = options.preemptive ?? true;
+  if (!preemptive && hasTopicWorkInFlight(topicId)) {
+    return { text: "A turn is active or queued; compaction skipped.", isError: true, busy: true };
+  }
+  const maintenance = beginRuntimeTopicMaintenance(topicId);
+  if (!maintenance)
+    return { text: "Topic maintenance is already in progress.", isError: true };
+  try {
+    if (preemptive) {
+      const fenceError = await fenceTopicWork(topicId, maintenance);
+      if (fenceError)
+        return { text: fenceError, isError: true };
+    } else if (!topicIsQuiescedForNonPreemptiveWork(topicId)) {
+      return {
+        text: "A turn is active or queued; compaction skipped.",
+        isError: true,
+        busy: true
+      };
+    } else if (!maintenance.isOwned()) {
+      return { text: "Topic maintenance ownership was lost. Try again.", isError: true };
+    }
+    cancelIdleCompactForTopic(topicId);
+    const agent = topic.agent ?? "maestro";
+    const registry = getRegistry(agent);
+    const config = getApiTopicConfig(topicId);
+    const model = resolveModelForAgent(agent, config?.model ?? topic.defaultModel, registry);
+    const requestedEffort = config?.effort ?? topic.defaultEffort;
+    const effort = requestedEffort && registry.validateEffort(requestedEffort) ? requestedEffort : registry.defaultEffort;
+    const compactionExecution = resolveCompactionExecution(agent, registry);
+    const cwd = resolveTopicWorkspaceDir(topicId);
+    const oldEntries = readConversation(userId, topic.title);
+    let compactEntries2;
+    try {
+      compactEntries2 = await createCompactedRolloutEntries({
+        topicId,
+        topicTitle: topic.title,
+        userId,
+        entries: oldEntries,
+        agent,
+        model,
+        ...effort ? { effort } : {},
+        summaryModel: compactionExecution.model,
+        ...compactionExecution.effort ? { summaryEffort: compactionExecution.effort } : {},
+        cwd
+      }, options.summarize);
+    } catch (error) {
+      return {
+        text: `Context compaction failed: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+    if (!maintenance.isOwned()) {
+      return { text: "Topic maintenance ownership was lost. Try again.", isError: true };
+    }
+    const now = new Date().toISOString();
+    let replacement;
+    try {
+      replacement = getRegistryOperations(agent).writeRollout({
+        cwd,
+        entries: compactEntries2,
+        model,
+        ...effort ? { effort } : {}
+      });
+    } catch (error) {
+      return {
+        text: `Context compaction failed to create a replacement session: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+    const replacementSessionEntry = {
+      ts: now,
+      agent,
+      event: { type: "session", sessionId: replacement.sessionId }
+    };
+    if (!maintenance.isOwned()) {
+      await cleanupNewRollout(agent, cwd, replacement.sessionId);
+      return { text: "Topic maintenance ownership was lost. Try again.", isError: true };
+    }
+    const previousSessionId = getTopicSessionId(topicId);
+    const priorSessionEntries = oldEntries.filter((entry) => entry.event.type === "session");
+    if (previousSessionId && topic.agent && !priorSessionEntries.some((entry) => entry.agent === topic.agent && entry.event.type === "session" && entry.event.sessionId === previousSessionId)) {
+      priorSessionEntries.push({
+        ts: now,
+        agent: topic.agent,
+        event: { type: "session", sessionId: previousSessionId }
+      });
+    }
+    try {
+      replaceConversationStrict(userId, topic.title, [
+        ...compactEntries2,
+        ...priorSessionEntries,
+        replacementSessionEntry
+      ]);
+      setTopicSessionId(topicId, replacement.sessionId, { reason, agent });
+      appendRawConversationEventStrict(userId, topic.title, agent, replacementSessionEntry.event);
+    } catch (error) {
+      try {
+        replaceConversationStrict(userId, topic.title, oldEntries);
+        if (previousSessionId) {
+          setTopicSessionId(topicId, previousSessionId, {
+            reason: `${reason}-rollback`,
+            agent
+          });
+        } else {
+          clearTopicSessionId(topicId, `${reason}-rollback`);
+        }
+      } catch (rollbackError) {
+        logger.error({ err: rollbackError, topicId, replacementSessionId: replacement.sessionId }, "compact: failed to restore prior session after commit error");
+      }
+      await cleanupNewRollout(agent, cwd, replacement.sessionId);
+      return {
+        text: `Context compaction could not commit the replacement session: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+    const oldRolloutsRemoved = await (options.cleanupOldRollouts ?? cleanupTopicRolloutsFromEntries)({
+      userId,
+      topicName: topic.title,
+      cwd,
+      extraSessions: previousSessionId && topic.agent ? [{ agent: topic.agent, sessionId: previousSessionId }] : []
+    }, oldEntries);
+    if (!oldRolloutsRemoved) {
+      logger.warn({ topicId, previousSessionId, replacementSessionId: replacement.sessionId }, "compact: replacement committed; old rollout cleanup deferred");
+    } else {
+      try {
+        replaceConversationStrict(userId, topic.title, [
+          ...compactEntries2,
+          replacementSessionEntry
+        ]);
+      } catch (manifestError) {
+        logger.warn({ err: manifestError, topicId, replacementSessionId: replacement.sessionId }, "compact: old rollout cleanup succeeded but pending manifest compaction failed");
+      }
+    }
+    clearQueryUsageAlert(userId, topicId);
+    return {
+      text: `Compacted context for "${topic.title}". Visible conversation history was preserved.`
+    };
+  } finally {
+    maintenance.finish();
+  }
 }
-var RESET_MEMORY_ARCHIVE_WAIT_MS, COMPACTION_INLINE_CHARS = 1e5, COMPACTION_SOURCE_CHARS, COMPACTION_MEMORY_CHARS = 80000, COMPACTION_OUTPUT_CHARS = 30000, COMPACTION_TIMEOUT_MS, COMPACTION_LOG_TIMEOUT_MS, COMPACTION_LOG_MAX_CALLS = 12, COMPACTION_LOG_MAX_TOTAL_BYTES, COMPACTION_LOG_MAX_CHUNK_BYTES, COMPACT_CONTEXT_MARKER = "[Negotium compacted context]", AUTO_FORK_COMPACTION_TOKENS = 28000;
+var RESET_TURN_WAIT_MS = 5000, RESET_MEMORY_ARCHIVE_WAIT_MS, COMPACTION_INLINE_CHARS = 1e5, COMPACTION_SOURCE_CHARS, COMPACTION_MEMORY_CHARS = 80000, COMPACTION_OUTPUT_CHARS = 30000, COMPACTION_RETAINED_TAIL_TOKENS = 64000, COMPACTION_TIMEOUT_MS, COMPACTION_LOG_TIMEOUT_MS, COMPACTION_LOG_MAX_CALLS = 12, COMPACTION_LOG_MAX_TOTAL_BYTES, COMPACTION_LOG_MAX_CHUNK_BYTES, COMPACT_CONTEXT_MARKER = "[Negotium compacted context]", AUTO_FORK_COMPACTION_TOKENS = 28000;
 var init_session = __esm(async () => {
+  init_compaction_tool_projection();
   await init_idle_archiver();
+  await init_idle_compact();
   await init_agents();
   init_model_catalog();
   await init_registry();
@@ -12994,8 +13830,8 @@ __export(exports_derive, {
   TopicForkCompactionError: () => TopicForkCompactionError,
   TopicDeriveBusyError: () => TopicDeriveBusyError
 });
-import { createHash as createHash5, randomUUID as randomUUID12 } from "crypto";
-import { mkdirSync as mkdirSync13, rmSync as rmSync5, unlinkSync as unlinkSync13 } from "fs";
+import { createHash as createHash7, randomUUID as randomUUID12 } from "crypto";
+import { mkdirSync as mkdirSync14, rmSync as rmSync5, unlinkSync as unlinkSync13 } from "fs";
 function getTopics(opts = {}) {
   return listTopics(opts).filter((topic) => !isLegacySharedGeneral(topic.id));
 }
@@ -13060,7 +13896,7 @@ function captureForkSnapshot(sourceTopicId, userId, topicTitle) {
       maxRowid: messageRows.at(-1)?.rowid ?? 0
     },
     active: isTopicRunning(sourceTopicId),
-    canonicalDigest: createHash5("sha256").update(entries.map((entry) => JSON.stringify(entry)).join(`
+    canonicalDigest: createHash7("sha256").update(entries.map((entry) => JSON.stringify(entry)).join(`
 `)).digest("hex")
   };
 }
@@ -13128,7 +13964,7 @@ async function createDerivedTopicImpl(topic, sourceTopicId, userId, copyHistory,
   try {
     if (agent) {
       const cwd = derivedWorkspace;
-      mkdirSync13(cwd, { recursive: true });
+      mkdirSync14(cwd, { recursive: true });
       const registry = getRegistry(agent);
       const requestedRolloutModel = subagentModel ?? (subagent?.agent ? undefined : sourceConfig?.model) ?? derived.defaultModel;
       const rolloutModel = resolveModelForAgent(agent, requestedRolloutModel, registry);
@@ -13351,14 +14187,14 @@ var init_derive = __esm(async () => {
 });
 
 // ../../packages/core/src/query/session-inbox-path.ts
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function sessionInboxPath(userId, topicId) {
   const key = Buffer.from(topicId, "utf8").toString("base64url");
-  return join22(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${JSONL_SUFFIX}`);
+  return join23(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${JSONL_SUFFIX}`);
 }
 function scheduledSessionInboxPath(userId, topicId) {
   const key = Buffer.from(topicId, "utf8").toString("base64url");
-  return join22(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${SCHEDULE_SUFFIX}`);
+  return join23(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${SCHEDULE_SUFFIX}`);
 }
 var TOPIC_ID_FILE_PREFIX = "topic-id-", JSONL_SUFFIX = ".jsonl", SCHEDULE_SUFFIX = ".schedule";
 var init_session_inbox_path = __esm(() => {
@@ -13366,12 +14202,12 @@ var init_session_inbox_path = __esm(() => {
 });
 
 // ../../packages/core/src/storage/session-inbox-signal.ts
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 var SESSION_INBOX_WAKE_FILE, listeners;
 var init_session_inbox_signal = __esm(() => {
   init_config();
   init_logger();
-  SESSION_INBOX_WAKE_FILE = join23(SESSION_INBOX_DIR, ".wake");
+  SESSION_INBOX_WAKE_FILE = join24(SESSION_INBOX_DIR, ".wake");
   listeners = new Set;
 });
 
@@ -13407,13 +14243,13 @@ var init_session_inbox = __esm(async () => {
 
 // ../../packages/core/src/query/session-inbox-cleanup.ts
 import { unlinkSync as unlinkSync14 } from "fs";
-import { basename as basename3, join as join24 } from "path";
+import { basename as basename3, join as join25 } from "path";
 function cleanupSessionInboxFiles(userId, topicId, legacyTopicTitle) {
   const live = sessionInboxPath(userId, topicId);
   const scheduled = scheduledSessionInboxPath(userId, topicId);
   const candidates = new Set([live, `${live}.processing`, scheduled, `${scheduled}.processing`]);
   if (legacyTopicTitle && legacyTopicTitle !== "." && legacyTopicTitle !== ".." && basename3(legacyTopicTitle) === legacyTopicTitle) {
-    const legacyBase = join24(SESSION_INBOX_DIR, userId, legacyTopicTitle);
+    const legacyBase = join25(SESSION_INBOX_DIR, userId, legacyTopicTitle);
     for (const suffix of [".jsonl", ".jsonl.processing", ".schedule", ".schedule.processing"]) {
       candidates.add(`${legacyBase}${suffix}`);
     }
@@ -13439,28 +14275,28 @@ var init_session_inbox_cleanup = __esm(async () => {
 });
 
 // ../../packages/core/src/query/state.ts
-import { mkdirSync as mkdirSync14, renameSync as renameSync7, unlinkSync as unlinkSync15, writeFileSync as writeFileSync12 } from "fs";
-import { basename as basename4, join as join25 } from "path";
+import { mkdirSync as mkdirSync15, renameSync as renameSync7, unlinkSync as unlinkSync15, writeFileSync as writeFileSync13 } from "fs";
+import { basename as basename4, join as join26 } from "path";
 function createQueryStateStore(options) {
   const sanitize = options.sanitizeTopicId ?? sanitizeId;
-  const queryStateDirPath = (userId) => join25(options.usersLogDir, String(userId), "active-queries");
-  const queryStateFile = (userId, topicId) => join25(queryStateDirPath(userId), `${sanitize(topicId)}.json`);
+  const queryStateDirPath = (userId) => join26(options.usersLogDir, String(userId), "active-queries");
+  const queryStateFile = (userId, topicId) => join26(queryStateDirPath(userId), `${sanitize(topicId)}.json`);
   const legacyQueryStateFile = (userId, topicName) => {
     if (!topicName || topicName === "." || topicName === ".." || basename4(topicName) !== topicName) {
       return null;
     }
-    return join25(queryStateDirPath(userId), `${topicName}.json`);
+    return join26(queryStateDirPath(userId), `${topicName}.json`);
   };
   return {
     write(userId, topicId, topicName, task) {
       const dir = queryStateDirPath(userId);
-      mkdirSync14(dir, { recursive: true });
+      mkdirSync15(dir, { recursive: true });
       const state = { topicId, topicName, since: new Date().toISOString() };
       if (task)
         state.task = [...task.replace(/\n+/g, " ").trim()].slice(0, 100).join("");
       const target = queryStateFile(userId, topicId);
       const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
-      writeFileSync12(tmp, JSON.stringify(state));
+      writeFileSync13(tmp, JSON.stringify(state));
       renameSync7(tmp, target);
     },
     clear(userId, topicId, legacyTopicName) {
@@ -13599,40 +14435,40 @@ __export(exports_session_asks, {
   clearPendingAsk: () => clearPendingAsk,
   PENDING_ASK_TTL_MS: () => PENDING_ASK_TTL_MS
 });
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import {
   closeSync as closeSync2,
-  mkdirSync as mkdirSync15,
+  mkdirSync as mkdirSync16,
   openSync as openSync2,
   readdirSync as readdirSync4,
   readFileSync as readFileSync16,
   statSync as statSync8,
   unlinkSync as unlinkSync16,
-  writeFileSync as writeFileSync13
+  writeFileSync as writeFileSync14
 } from "fs";
-import { dirname as dirname14, join as join26 } from "path";
+import { dirname as dirname14, join as join27 } from "path";
 function pendingAskDir(userId) {
   const rawUserId = String(userId);
-  const safeUserId = /^[A-Za-z0-9][A-Za-z0-9_.@-]{0,255}$/.test(rawUserId) && !rawUserId.includes("..") ? rawUserId : `sha256-${createHash6("sha256").update(rawUserId).digest("hex")}`;
-  return join26(resolveStorageSessionAsksDir(), safeUserId);
+  const safeUserId = /^[A-Za-z0-9][A-Za-z0-9_.@-]{0,255}$/.test(rawUserId) && !rawUserId.includes("..") ? rawUserId : `sha256-${createHash8("sha256").update(rawUserId).digest("hex")}`;
+  return join27(resolveStorageSessionAsksDir(), safeUserId);
 }
 function encodeAskKey(key) {
   return JSON.stringify([key.from, key.to]);
 }
 function pendingAskPath(key) {
-  const digest = createHash6("sha256").update(encodeAskKey(key)).digest("hex");
-  return join26(pendingAskDir(key.userId), `${ASK_FILENAME_PREFIX}${digest}.pending`);
+  const digest2 = createHash8("sha256").update(encodeAskKey(key)).digest("hex");
+  return join27(pendingAskDir(key.userId), `${ASK_FILENAME_PREFIX}${digest2}.pending`);
 }
 function v2PendingAskPath(key) {
   const encoded = Buffer.from(encodeAskKey(key), "utf8").toString("base64url");
-  return join26(pendingAskDir(key.userId), `${V2_ASK_FILENAME_PREFIX}${encoded}.pending`);
+  return join27(pendingAskDir(key.userId), `${V2_ASK_FILENAME_PREFIX}${encoded}.pending`);
 }
 function legacyPendingAskPath(key) {
   if (key.from.includes("/") || key.from.includes("\\") || key.to.includes("/") || key.to.includes("\\") || key.from.includes("\x00") || key.to.includes("\x00")) {
     return null;
   }
   const dir = pendingAskDir(key.userId);
-  const candidate = join26(dir, `${key.from}___${key.to}.pending`);
+  const candidate = join27(dir, `${key.from}___${key.to}.pending`);
   return dirname14(candidate) === dir ? candidate : null;
 }
 function parsePendingAskFilename(fileName) {
@@ -13705,17 +14541,17 @@ function isStale(record, path) {
 }
 function writePendingAsk(record) {
   const path = pendingAskPath(record);
-  mkdirSync15(pendingAskDir(record.userId), { recursive: true });
-  writeFileSync13(path, `${JSON.stringify(record)}
+  mkdirSync16(pendingAskDir(record.userId), { recursive: true });
+  writeFileSync14(path, `${JSON.stringify(record)}
 `);
 }
 function writePendingAskIfAbsent(record) {
   const path = pendingAskPath(record);
-  mkdirSync15(pendingAskDir(record.userId), { recursive: true });
+  mkdirSync16(pendingAskDir(record.userId), { recursive: true });
   let fd = null;
   try {
     fd = openSync2(path, "wx");
-    writeFileSync13(fd, `${JSON.stringify(record)}
+    writeFileSync14(fd, `${JSON.stringify(record)}
 `);
     return true;
   } catch (error) {
@@ -13775,12 +14611,12 @@ function createPendingAsk(args) {
     createdAt: now,
     updatedAt: now
   };
-  mkdirSync15(pendingAskDir(args.userId), { recursive: true });
+  mkdirSync16(pendingAskDir(args.userId), { recursive: true });
   for (let attempt = 0;attempt < 2; attempt++) {
     let fd = null;
     try {
       fd = openSync2(path, "wx");
-      writeFileSync13(fd, `${JSON.stringify(record)}
+      writeFileSync14(fd, `${JSON.stringify(record)}
 `);
       return { ok: true, record };
     } catch (err2) {
@@ -13873,7 +14709,7 @@ function listPendingAsksForCaller(args) {
     const parsed = isV3 ? { from: args.from, to: "" } : parsePendingAskFilename(fileName);
     if (!parsed)
       continue;
-    const path = join26(dir, fileName);
+    const path = join27(dir, fileName);
     const record = readPendingAskFile(path, {
       userId: args.userId,
       from: parsed.from,
@@ -13915,7 +14751,7 @@ function deletePendingAsksForTopic(args) {
   }
   let deleted = 0;
   for (const fileName of files) {
-    const path = join26(dir, fileName);
+    const path = join27(dir, fileName);
     const parsed = parsePendingAskFilename(fileName);
     const record = readPendingAskFile(path, {
       userId: args.userId,
@@ -14312,94 +15148,6 @@ body{font-family:system-ui,-apple-system,"Segoe UI",sans-serif;background:var(--
 </style>`;
 });
 
-// ../../packages/core/src/storage/token-stats.ts
-import { createHash as createHash7 } from "crypto";
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync14 } from "fs";
-import { join as join27 } from "path";
-function tokenStatsFileId(userId) {
-  const rawUserId = String(userId);
-  return /^[A-Za-z0-9][A-Za-z0-9_.@-]{0,255}$/.test(rawUserId) && !rawUserId.includes("..") ? rawUserId : `sha256-${createHash7("sha256").update(rawUserId).digest("hex")}`;
-}
-function queriesPath(userId) {
-  const fileId = tokenStatsFileId(userId);
-  const logDir = resolveStorageLogDir();
-  mkdirSync16(logDir, { recursive: true });
-  return join27(logDir, `token-queries-${fileId}.jsonl`);
-}
-function estimateUsageCost(agent, model, usage) {
-  const prices = TOKEN_PRICES[`${agent}:${model}`];
-  if (!prices)
-    return 0;
-  return (usage.inputTokens * prices.input + usage.outputTokens * prices.output + (agent === "claude" ? usage.cacheCreationInputTokens * (prices.cacheWrite ?? prices.input) : 0) + usage.cacheReadInputTokens * prices.cacheRead) / 1e6;
-}
-function recordUsage(userId, session, usage, context) {
-  const cacheReadInputTokens = usage.cacheReadInputTokens ?? 0;
-  const inputTokens = context.agent === "claude" ? usage.inputTokens : Math.max(0, usage.inputTokens - cacheReadInputTokens);
-  const normalized = {
-    inputTokens,
-    outputTokens: usage.outputTokens,
-    cacheCreationInputTokens: usage.cacheCreationInputTokens ?? 0,
-    cacheReadInputTokens
-  };
-  const record = {
-    schemaVersion: 2,
-    timestamp: new Date().toISOString(),
-    session,
-    topicId: context.topicId,
-    ...context.providerSessionId ? { providerSessionId: context.providerSessionId } : {},
-    agent: context.agent,
-    model: context.model,
-    ...normalized,
-    ...usage.contextTokens !== undefined ? { contextTokens: usage.contextTokens } : {},
-    ...usage.contextWindow !== undefined ? { contextWindow: usage.contextWindow } : {},
-    estimatedCostUsd: usage.costUsd ?? estimateUsageCost(context.agent, context.model, normalized)
-  };
-  try {
-    appendJsonlEntry(queriesPath(userId), record);
-  } catch (e) {
-    logger.warn({ err: e, userId }, "token-stats: Failed to record");
-  }
-}
-function deleteTopicStats(userId, topicId) {
-  const path = queriesPath(userId);
-  try {
-    const kept = readJsonlLines(path).filter((line) => {
-      try {
-        const record = JSON.parse(line);
-        return record.topicId !== topicId;
-      } catch {
-        return true;
-      }
-    });
-    writeFileSync14(path, kept.length > 0 ? `${kept.join(`
-`)}
-` : "", "utf-8");
-  } catch (e) {
-    if (e.code === "ENOENT")
-      return;
-    logger.warn({ err: e, userId, topicId }, "token-stats: Failed to delete topic stats");
-  }
-}
-var TOKEN_PRICES;
-var init_token_stats = __esm(async () => {
-  init_jsonl();
-  init_logger();
-  await init_api_topics();
-  await init_storage_host();
-  TOKEN_PRICES = {
-    "codex:gpt-5.6-sol": { input: 5, cacheRead: 0.5, output: 30 },
-    "codex:gpt-5.6-terra": { input: 2.5, cacheRead: 0.25, output: 15 },
-    "codex:gpt-5.6-luna": { input: 1, cacheRead: 0.1, output: 6 },
-    "claude:fable": { input: 10, cacheWrite: 12.5, cacheRead: 1, output: 50 },
-    "claude:opus": { input: 5, cacheWrite: 6.25, cacheRead: 0.5, output: 25 },
-    "claude:sonnet": { input: 2, cacheWrite: 2.5, cacheRead: 0.2, output: 10 },
-    "maestro:kimi-k3": { input: 3, cacheRead: 0.3, output: 15 },
-    "maestro:kimi-k2.7-code": { input: 0.95, cacheRead: 0.19, output: 4 },
-    "maestro:deepseek-pro": { input: 0.435, cacheRead: 0.003625, output: 0.87 },
-    "maestro:deepseek-flash": { input: 0.14, cacheRead: 0.0028, output: 0.28 }
-  };
-});
-
 // ../../packages/core/src/storage/topic-tool-capabilities.ts
 function getTopicToolCapabilities(topicId) {
   const row = db.query(`SELECT visual_tools, file_delivery_tools
@@ -14438,6 +15186,7 @@ import { rmSync as rmSync6 } from "fs";
 async function abortAndWaitForTopic(topicId) {
   interSessionQueue.drop(topicId);
   cancelIdleArchiveForTopic(topicId);
+  cancelIdleCompactForTopic(topicId);
   const aborted = abortRoom(topicId);
   if (!aborted)
     return true;
@@ -14610,6 +15359,7 @@ var DELETE_TURN_WAIT_MS = 5000, TopicArchiveRequiredError, TopicTurnStillActiveE
 var init_lifecycle = __esm(async () => {
   await init_archiver();
   await init_idle_archiver();
+  await init_idle_compact();
   await init_spawn_subagent();
   await init_topic_cleanup();
   await init_bus();
@@ -15405,6 +16155,7 @@ async function runTurnEventStream(topicId, topicTitle, queryId, events, control,
   const peerBridge = execution?.peerBridge ?? control.injectParams?.peerBridge;
   let errorOccurred = false;
   let terminalEmitted = false;
+  const streamStartedAt = Date.now();
   let lastEventType = null;
   let pendingSawDelta = false;
   let accumulatedText = "";
@@ -15773,6 +16524,10 @@ ${JSON.stringify(event.input ?? {})}`);
         case "result":
           if (event.usage)
             recordEventUsage(event.usage);
+          if (!accumulatedText.trim() && event.content.trim()) {
+            accumulatedText = event.content;
+            pendingText = event.content;
+          }
           {
             const usage = event.usage ? {
               input: event.usage.inputTokens,
@@ -15789,8 +16544,21 @@ ${JSON.stringify(event.input ?? {})}`);
               }
             }
           }
+          if (!accumulatedText.trim()) {
+            const error = "Provider completed without an assistant response";
+            terminalEmitted = true;
+            outcome = silent ? { kind: "provider-error", error } : { kind: "empty-response", error };
+            logger.warn({ topicId, queryId, agentType, model, silent }, "ai: provider completed without assistant text");
+            if (silent)
+              deliverAskError(queryId, topicTitle, error);
+            return outcome;
+          }
           if (!silent) {
             scheduleIdleArchiveForTopic(topicId, execution?.actorUserId ?? userId);
+            scheduleIdleCompactForTopic(topicId, execution?.actorUserId ?? userId);
+            if (event.usage?.contextTokens !== undefined && event.usage.contextWindow !== undefined) {
+              scheduleContextLimitCompactForTopic(topicId, execution?.actorUserId ?? userId, event.usage.contextTokens, event.usage.contextWindow);
+            }
             hub.broadcastDone(topicId, queryId, event.usage ? {
               input: event.usage.inputTokens,
               output: event.usage.outputTokens,
@@ -15946,7 +16714,7 @@ ${JSON.stringify(event.input ?? {})}`);
         hadToolActivity: syntheticToolCounter > 0 || providerToolIds.size > 0
       }, "ai: provider stream ended without result, error, or abort");
     }
-    const discardIncompleteSegments = outcome.kind === "session-expired" || outcome.kind === "provider-error" || !terminalEmitted && !abortController.signal.aborted;
+    const discardIncompleteSegments = outcome.kind === "session-expired" || outcome.kind === "provider-error" || outcome.kind === "empty-response" || !terminalEmitted && !abortController.signal.aborted;
     if (discardIncompleteSegments)
       discardVisibleAssistantMessages();
     const stillCurrent = getRoomQuery(roomId)?.queryId === queryId;
@@ -15958,22 +16726,32 @@ ${JSON.stringify(event.input ?? {})}`);
       hub.broadcastTyping(topicId, "");
     const forkHandle = control.injectParams?.forkHandle;
     const forkRequestId = control.injectParams?.requestId;
-    if (forkHandle && outcome.kind !== "session-expired" && (!forkRequestId || !interSessionQueue.hasRequest(topicId, forkRequestId))) {
+    if (forkHandle && outcome.kind !== "session-expired" && outcome.kind !== "empty-response" && (!forkRequestId || !interSessionQueue.hasRequest(topicId, forkRequestId))) {
       cleanupAgentFork(forkHandle);
     }
     const queuedUserTurn = roomId === topicId ? getRuntimeUserTurnRequest(topicId) : null;
     const hasReplacementUserTurn = queuedUserTurn !== null && queuedUserTurn.requestId !== queryId;
-    if (roomId === topicId && outcome.kind !== "session-expired" && !getRoomQuery(topicId) && !hasReplacementUserTurn) {
+    if (roomId === topicId && outcome.kind !== "session-expired" && outcome.kind !== "empty-response" && !getRoomQuery(topicId) && !hasReplacementUserTurn) {
       const next = takeDeferredInject(topicId);
       if (next)
         redispatchInject(next);
     }
+    logger.info({
+      topicId,
+      queryId,
+      outcomeKind: outcome.kind,
+      assistantMessageCount: visibleMessageIds.length,
+      assistantTextChars: accumulatedText.length,
+      durationMs: Date.now() - streamStartedAt,
+      lastEventType
+    }, "ai: turn settled");
   }
   return outcome;
 }
 var init_turn_event_stream = __esm(async () => {
   await init_fork();
   await init_idle_archiver();
+  await init_idle_compact();
   await init_ask_user();
   await init_spawn_subagent();
   init_model_catalog();
@@ -16656,6 +17434,7 @@ function startAiTurn(params) {
   const peerBridge = params.peerBridge;
   const askReplySources = params.askReplySources;
   const sessionRetried = params._sessionRetried === true;
+  const emptyResponseRetried = params._emptyResponseRetried === true;
   const queryId = params._queryId ?? randomUUID16();
   const roomId = turnConcurrency === "isolated" ? isolatedTurnRoomId(topicId, queryId) : topicId;
   const currentRuntimeEpoch = getRuntimeTopicEpoch(topic.id);
@@ -17244,6 +18023,56 @@ function startAiTurn(params) {
         return;
       }
     }
+    if (outcome.kind === "empty-response") {
+      if (emptyResponseRetried) {
+        outcome = { kind: "provider-error", error: outcome.error };
+      } else {
+        if (!silent)
+          WsHub.get().broadcastAborted(topicId, queryId, "stopped");
+        logger.info({ topicId, prevQueryId: queryId, agent: agentKind }, "ai: retrying query after empty provider response");
+        startAiTurn({
+          topic,
+          userId,
+          vaultUserId,
+          prompt,
+          _userMessages: userMessages,
+          _conversationPrompts: conversationPrompts,
+          _loggedUserMessageCount: loggedUserMessageCount,
+          _durableRequestIds: durableRequestIds,
+          attachments: attachments2,
+          allowAutoContinue,
+          origin,
+          onDispatched,
+          requestId,
+          depth,
+          silent,
+          contextId,
+          agentOverride,
+          modelOverride,
+          effortOverride,
+          sessionId,
+          sessionScope,
+          turnConcurrency,
+          forkHandle,
+          prepareSession,
+          cwd,
+          sessionName,
+          sessionType,
+          visualTools,
+          fileDeliveryTools,
+          onSessionId,
+          onSessionReset,
+          bridgeSessionFromHistory,
+          onSettled,
+          peerBridge,
+          askReplySources,
+          _runtimeEpoch: runtimeEpoch,
+          _sessionRetried: sessionRetried,
+          _emptyResponseRetried: true
+        });
+        return;
+      }
+    }
     if (outcome.kind === "budget-capped") {
       const error = "The job reached its cost limit";
       if (!silent) {
@@ -19339,4 +20168,4 @@ export {
   DEFAULT_SELF_CONFIG_PRODUCT
 };
 
-//# debugId=F85109DD7C4C0F0464756E2164756E21
+//# debugId=5098AD5EB3D2D82464756E2164756E21