negotium 0.6.13 → 0.6.17

package/dist/mcp-factories.js

@@ -3040,7 +3040,7 @@ var init_codex = __esm(async () => {
 });
 
 // ../../packages/core/src/version.ts
-var NEGOTIUM_VERSION = "0.6.13";
+var NEGOTIUM_VERSION = "0.6.17";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
 import { spawn as spawn2 } from "child_process";
@@ -7547,6 +7547,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
+  };
+  mkdirSync11(dirname10(path), { recursive: true });
+  appendJsonlLine(path, JSON.stringify(entry));
+}
 function readConversationPath(path) {
   const out = [];
   if (!existsSync14(path))
@@ -8084,6 +8094,35 @@ function buildClaudePrompt(opts) {
     parent_tool_use_id: null
   });
 }
+function watchClaudeProcessExit(signal) {
+  let listener;
+  const exited = new Promise((resolve11) => {
+    listener = resolve11;
+    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 signalProcessTree2(pid, signal) {
   try {
     process.kill(-pid, signal);
@@ -8145,6 +8184,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;
@@ -8155,6 +8195,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,
@@ -8202,6 +8243,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,
@@ -8212,7 +8267,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 } : {},
@@ -8450,14 +8505,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();
@@ -8472,6 +8541,7 @@ var init_claude_provider = __esm(async () => {
     "TaskUpdate",
     "TaskList",
     "TaskGet",
+    "Monitor",
     "ScheduleWakeup",
     "CronCreate",
     "CronList",
@@ -8485,6 +8555,7 @@ var init_claude_provider = __esm(async () => {
     "image/gif",
     "image/webp"
   ]);
+  claudeProcessExitListeners = new WeakMap;
 });
 
 // ../../packages/core/src/agents/codex-tree-manager.ts
@@ -10840,7 +10911,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) {
@@ -10850,7 +10921,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]
     }));
@@ -11686,8 +11757,337 @@ var init_idle_archiver = __esm(async () => {
   timers = new Map;
 });
 
+// ../../packages/core/src/storage/token-stats.ts
+import { createHash as createHash4 } from "crypto";
+import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync12 } from "fs";
+import { join as join23 } 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-${createHash4("sha256").update(rawUserId).digest("hex")}`;
+}
+function queriesPath(userId) {
+  const fileId = tokenStatsFileId(userId);
+  const logDir = resolveStorageLogDir();
+  mkdirSync14(logDir, { recursive: true });
+  return join23(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 calcCost(b) {
+  return b.estimatedCostUsd;
+}
+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(value2) {
+  if (!value2 || typeof value2 !== "object")
+    return false;
+  const record = value2;
+  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;
+      }
+    });
+    writeFileSync12(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 getStats(userId, from, to) {
+  const records = loadRecords(userId);
+  const fromTs = from ? new Date(from).getTime() : 0;
+  const toTs = to ? new Date(to).getTime() : Infinity;
+  if (from && Number.isNaN(fromTs) || to && Number.isNaN(toTs)) {
+    logger.warn({ from, to }, "token-stats: Invalid date range, returning empty");
+    return {
+      total: emptyBucket(),
+      byHour: {},
+      bySession: {},
+      currentSessions: [],
+      ignoredLegacyRecords: 0,
+      estimatedCostUsd: 0
+    };
+  }
+  const total = emptyBucket();
+  const byHour = {};
+  const bySession = {};
+  const currentSessions = new Map;
+  let ignoredLegacyRecords = 0;
+  for (const raw of records) {
+    if (!isQueryRecord(raw)) {
+      ignoredLegacyRecords += 1;
+      continue;
+    }
+    const r = raw;
+    const ts = new Date(r.timestamp).getTime();
+    if (ts < fromTs || ts > toTs)
+      continue;
+    const hourKey = r.timestamp.slice(0, 13);
+    if (!byHour[hourKey])
+      byHour[hourKey] = emptyBucket();
+    if (!bySession[r.session])
+      bySession[r.session] = emptyBucket();
+    for (const bucket of [total, byHour[hourKey], bySession[r.session]]) {
+      bucket.inputTokens += r.inputTokens;
+      bucket.outputTokens += r.outputTokens;
+      bucket.cacheCreationInputTokens += r.cacheCreationInputTokens;
+      bucket.cacheReadInputTokens += r.cacheReadInputTokens;
+      bucket.queries += 1;
+      bucket.estimatedCostUsd += r.estimatedCostUsd;
+    }
+    if (r.contextTokens !== undefined && r.contextWindow !== undefined && r.contextWindow > 0) {
+      currentSessions.set(r.topicId, {
+        timestamp: r.timestamp,
+        topicId: r.topicId,
+        topicTitle: r.session,
+        ...r.providerSessionId ? { providerSessionId: r.providerSessionId } : {},
+        agent: r.agent,
+        model: r.model,
+        contextTokens: r.contextTokens,
+        contextWindow: r.contextWindow
+      });
+    }
+  }
+  return {
+    total,
+    byHour,
+    bySession,
+    currentSessions: [...currentSessions.values()].sort((a, b) => b.timestamp.localeCompare(a.timestamp)),
+    ignoredLegacyRecords,
+    estimatedCostUsd: calcCost(total)
+  };
+}
+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);
+  if (!timer)
+    return false;
+  clearTimeout(timer);
+  timers2.delete(topicId);
+  return true;
+}
+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 value2 = Number.parseInt(process.env[name] ?? "", 10);
+  return Number.isFinite(value2) && value2 > 0 ? value2 : 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";
+}
+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, "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_MIN_CONTEXT_PERCENT = 50, timers2;
+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;
+});
+
 // ../../packages/core/src/agents/topic-cleanup.ts
-import { mkdirSync as mkdirSync14, renameSync as renameSync8, unlinkSync as unlinkSync13, writeFileSync as writeFileSync12 } from "fs";
+import { mkdirSync as mkdirSync15, renameSync as renameSync8, unlinkSync as unlinkSync13, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname15 } from "path";
 function collectSessionIdsByAgent(entries, extraSessions = []) {
   const out = new Map;
@@ -11754,8 +12154,8 @@ function createTopicLogMaintenance(host) {
       const path = runtimeHost.activeConversationPath(opts.userId, opts.topicName);
       const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
       try {
-        mkdirSync14(dirname15(path), { recursive: true });
-        writeFileSync12(tempPath, retained.length > 0 ? `${retained.map((entry) => JSON.stringify(entry)).join(`
+        mkdirSync15(dirname15(path), { recursive: true });
+        writeFileSync13(tempPath, retained.length > 0 ? `${retained.map((entry) => JSON.stringify(entry)).join(`
 `)}
 ` : "", { flag: "wx" });
         renameSync8(tempPath, path);
@@ -11915,10 +12315,149 @@ var init_usage_alert = __esm(() => {
 });
 
 // ../../packages/core/src/topics/session.ts
+var exports_session = {};
+__export(exports_session, {
+  shouldUseCompactionLog: () => shouldUseCompactionLog,
+  shouldCompactForkEntries: () => shouldCompactForkEntries,
+  restartTopicSession: () => restartTopicSession,
+  createCompactedRolloutEntries: () => createCompactedRolloutEntries,
+  compactTopicSession: () => compactTopicSession,
+  AUTO_FORK_COMPACTION_TOKENS: () => AUTO_FORK_COMPACTION_TOKENS
+});
 import { randomUUID as randomUUID10 } from "crypto";
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync4, writeFileSync as writeFileSync13 } from "fs";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync4, writeFileSync as writeFileSync14 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join23 } from "path";
+import { join as join24 } 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;
@@ -12048,7 +12587,7 @@ function formatCompactElapsed(startedAt) {
 async function summarizeTopicContext(request) {
   const startedAt = Date.now();
   const sessionIds = [];
-  const compactCwd = mkdtempSync2(join23(tmpdir4(), "negotium-compact-"));
+  const compactCwd = mkdtempSync2(join24(tmpdir4(), "negotium-compact-"));
   const abortController = new AbortController;
   const relayAbort = () => abortController.abort(request.signal?.reason);
   if (request.signal?.aborted)
@@ -12075,7 +12614,7 @@ async function summarizeTopicContext(request) {
   let error = "";
   let toolViolation = false;
   let compactionLogCalls = 0;
-  const compactionLogPath = join23(compactCwd, "conversation.log");
+  const compactionLogPath = join24(compactCwd, "conversation.log");
   try {
     const compactionMcp = useCompactionLog ? {
       compact_log: {
@@ -12089,7 +12628,7 @@ async function summarizeTopicContext(request) {
       }
     } : undefined;
     if (useCompactionLog)
-      writeFileSync13(compactionLogPath, request.source, { mode: 384 });
+      writeFileSync14(compactionLogPath, request.source, { mode: 384 });
     for await (const event of runAgent({
       agent: request.agent,
       prompt: useCompactionLog ? [
@@ -12268,33 +12807,189 @@ function shouldCompactForkEntries(entries, thresholdTokens = AUTO_FORK_COMPACTIO
   for (const pair of extractChatPairs(entries)) {
     messages.push({ role: "user", content: pair.userText }, { role: "assistant", content: pair.assistantText });
   }
-  return estimateConversationTokens(messages) >= thresholdTokens;
-}
-async function createCompactedRolloutEntries(request, summarize = summarizeTopicContext) {
-  const source = buildCompactionSource(request.topicId, request.userId, request.entries, request.visibleMessages);
-  if (!source)
-    throw new Error(`Nothing to compact in "${request.topicTitle}".`);
-  const {
-    entries: _entries,
-    visibleMessages: _visibleMessages,
-    timeoutMs = shouldUseCompactionLog(source) ? COMPACTION_LOG_TIMEOUT_MS : COMPACTION_TIMEOUT_MS,
-    summaryModel,
-    summaryEffort,
-    ...summaryRequest
-  } = request;
-  const summary = (await summarizeWithDeadline({
-    ...summaryRequest,
-    source,
-    model: summaryModel ?? summaryRequest.model,
-    effort: summaryEffort ?? summaryRequest.effort
-  }, 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 estimateConversationTokens(messages) >= thresholdTokens;
+}
+async function createCompactedRolloutEntries(request, summarize = summarizeTopicContext) {
+  const source = buildCompactionSource(request.topicId, request.userId, request.entries, request.visibleMessages);
+  if (!source)
+    throw new Error(`Nothing to compact in "${request.topicTitle}".`);
+  const {
+    entries: _entries,
+    visibleMessages: _visibleMessages,
+    timeoutMs = shouldUseCompactionLog(source) ? COMPACTION_LOG_TIMEOUT_MS : COMPACTION_TIMEOUT_MS,
+    summaryModel,
+    summaryEffort,
+    ...summaryRequest
+  } = request;
+  const summary = (await summarizeWithDeadline({
+    ...summaryRequest,
+    source,
+    model: summaryModel ?? summaryRequest.model,
+    effort: summaryEffort ?? summaryRequest.effort
+  }, summarize, timeoutMs)).trim();
+  if (!summary)
+    throw new Error("Context compaction returned an empty summary.");
+  return compactEntries(request.agent, summary.slice(0, COMPACTION_OUTPUT_CHARS));
+}
+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_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 () => {
   await init_idle_archiver();
+  await init_idle_compact();
   await init_agents();
   init_model_catalog();
   await init_registry();
@@ -12337,8 +13032,8 @@ __export(exports_derive, {
   TopicForkCompactionError: () => TopicForkCompactionError,
   TopicDeriveBusyError: () => TopicDeriveBusyError
 });
-import { createHash as createHash4, randomUUID as randomUUID11 } from "crypto";
-import { mkdirSync as mkdirSync15, rmSync as rmSync5, unlinkSync as unlinkSync14 } from "fs";
+import { createHash as createHash5, randomUUID as randomUUID11 } from "crypto";
+import { mkdirSync as mkdirSync16, rmSync as rmSync5, unlinkSync as unlinkSync14 } from "fs";
 function getTopics(opts = {}) {
   return listTopics(opts).filter((topic) => !isLegacySharedGeneral(topic.id));
 }
@@ -12403,7 +13098,7 @@ function captureForkSnapshot(sourceTopicId, userId, topicTitle) {
       maxRowid: messageRows.at(-1)?.rowid ?? 0
     },
     active: isTopicRunning(sourceTopicId),
-    canonicalDigest: createHash4("sha256").update(entries.map((entry) => JSON.stringify(entry)).join(`
+    canonicalDigest: createHash5("sha256").update(entries.map((entry) => JSON.stringify(entry)).join(`
 `)).digest("hex")
   };
 }
@@ -12471,7 +13166,7 @@ async function createDerivedTopicImpl(topic, sourceTopicId, userId, copyHistory,
   try {
     if (agent) {
       const cwd = derivedWorkspace;
-      mkdirSync15(cwd, { recursive: true });
+      mkdirSync16(cwd, { recursive: true });
       const registry = getRegistry(agent);
       const requestedRolloutModel = subagentModel ?? (subagent?.agent ? undefined : sourceConfig?.model) ?? derived.defaultModel;
       const rolloutModel = resolveModelForAgent(agent, requestedRolloutModel, registry);
@@ -12694,14 +13389,14 @@ var init_derive = __esm(async () => {
 });
 
 // ../../packages/core/src/query/session-inbox-path.ts
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 function sessionInboxPath(userId, topicId) {
   const key = Buffer.from(topicId, "utf8").toString("base64url");
-  return join24(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${JSONL_SUFFIX}`);
+  return join25(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${JSONL_SUFFIX}`);
 }
 function scheduledSessionInboxPath(userId, topicId) {
   const key = Buffer.from(topicId, "utf8").toString("base64url");
-  return join24(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${SCHEDULE_SUFFIX}`);
+  return join25(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(() => {
@@ -12709,12 +13404,12 @@ var init_session_inbox_path = __esm(() => {
 });
 
 // ../../packages/core/src/storage/session-inbox-signal.ts
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var SESSION_INBOX_WAKE_FILE, listeners;
 var init_session_inbox_signal = __esm(() => {
   init_config();
   init_logger();
-  SESSION_INBOX_WAKE_FILE = join25(SESSION_INBOX_DIR, ".wake");
+  SESSION_INBOX_WAKE_FILE = join26(SESSION_INBOX_DIR, ".wake");
   listeners = new Set;
 });
 
@@ -12750,13 +13445,13 @@ var init_session_inbox = __esm(async () => {
 
 // ../../packages/core/src/query/session-inbox-cleanup.ts
 import { unlinkSync as unlinkSync15 } from "fs";
-import { basename as basename4, join as join26 } from "path";
+import { basename as basename4, join as join27 } 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 !== ".." && basename4(legacyTopicTitle) === legacyTopicTitle) {
-    const legacyBase = join26(SESSION_INBOX_DIR, userId, legacyTopicTitle);
+    const legacyBase = join27(SESSION_INBOX_DIR, userId, legacyTopicTitle);
     for (const suffix of [".jsonl", ".jsonl.processing", ".schedule", ".schedule.processing"]) {
       candidates.add(`${legacyBase}${suffix}`);
     }
@@ -12782,28 +13477,28 @@ var init_session_inbox_cleanup = __esm(async () => {
 });
 
 // ../../packages/core/src/query/state.ts
-import { mkdirSync as mkdirSync16, renameSync as renameSync9, unlinkSync as unlinkSync16, writeFileSync as writeFileSync14 } from "fs";
-import { basename as basename5, join as join27 } from "path";
+import { mkdirSync as mkdirSync17, renameSync as renameSync9, unlinkSync as unlinkSync16, writeFileSync as writeFileSync15 } from "fs";
+import { basename as basename5, join as join28 } from "path";
 function createQueryStateStore(options) {
   const sanitize = options.sanitizeTopicId ?? sanitizeId;
-  const queryStateDirPath = (userId) => join27(options.usersLogDir, String(userId), "active-queries");
-  const queryStateFile = (userId, topicId) => join27(queryStateDirPath(userId), `${sanitize(topicId)}.json`);
+  const queryStateDirPath = (userId) => join28(options.usersLogDir, String(userId), "active-queries");
+  const queryStateFile = (userId, topicId) => join28(queryStateDirPath(userId), `${sanitize(topicId)}.json`);
   const legacyQueryStateFile = (userId, topicName) => {
     if (!topicName || topicName === "." || topicName === ".." || basename5(topicName) !== topicName) {
       return null;
     }
-    return join27(queryStateDirPath(userId), `${topicName}.json`);
+    return join28(queryStateDirPath(userId), `${topicName}.json`);
   };
   return {
     write(userId, topicId, topicName, task) {
       const dir = queryStateDirPath(userId);
-      mkdirSync16(dir, { recursive: true });
+      mkdirSync17(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`;
-      writeFileSync14(tmp, JSON.stringify(state));
+      writeFileSync15(tmp, JSON.stringify(state));
       renameSync9(tmp, target);
     },
     clear(userId, topicId, legacyTopicName) {
@@ -12942,40 +13637,40 @@ __export(exports_session_asks, {
   clearPendingAsk: () => clearPendingAsk,
   PENDING_ASK_TTL_MS: () => PENDING_ASK_TTL_MS
 });
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import {
   closeSync as closeSync3,
-  mkdirSync as mkdirSync17,
+  mkdirSync as mkdirSync18,
   openSync as openSync3,
   readdirSync as readdirSync6,
   readFileSync as readFileSync19,
   statSync as statSync8,
   unlinkSync as unlinkSync17,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync16
 } from "fs";
-import { dirname as dirname16, join as join28 } from "path";
+import { dirname as dirname16, join as join29 } 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-${createHash5("sha256").update(rawUserId).digest("hex")}`;
-  return join28(resolveStorageSessionAsksDir(), safeUserId);
+  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 join29(resolveStorageSessionAsksDir(), safeUserId);
 }
 function encodeAskKey(key) {
   return JSON.stringify([key.from, key.to]);
 }
 function pendingAskPath(key) {
-  const digest = createHash5("sha256").update(encodeAskKey(key)).digest("hex");
-  return join28(pendingAskDir(key.userId), `${ASK_FILENAME_PREFIX}${digest}.pending`);
+  const digest = createHash6("sha256").update(encodeAskKey(key)).digest("hex");
+  return join29(pendingAskDir(key.userId), `${ASK_FILENAME_PREFIX}${digest}.pending`);
 }
 function v2PendingAskPath(key) {
   const encoded = Buffer.from(encodeAskKey(key), "utf8").toString("base64url");
-  return join28(pendingAskDir(key.userId), `${V2_ASK_FILENAME_PREFIX}${encoded}.pending`);
+  return join29(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 = join28(dir, `${key.from}___${key.to}.pending`);
+  const candidate = join29(dir, `${key.from}___${key.to}.pending`);
   return dirname16(candidate) === dir ? candidate : null;
 }
 function parsePendingAskFilename(fileName) {
@@ -13048,17 +13743,17 @@ function isStale(record, path) {
 }
 function writePendingAsk(record) {
   const path = pendingAskPath(record);
-  mkdirSync17(pendingAskDir(record.userId), { recursive: true });
-  writeFileSync15(path, `${JSON.stringify(record)}
+  mkdirSync18(pendingAskDir(record.userId), { recursive: true });
+  writeFileSync16(path, `${JSON.stringify(record)}
 `);
 }
 function writePendingAskIfAbsent(record) {
   const path = pendingAskPath(record);
-  mkdirSync17(pendingAskDir(record.userId), { recursive: true });
+  mkdirSync18(pendingAskDir(record.userId), { recursive: true });
   let fd = null;
   try {
     fd = openSync3(path, "wx");
-    writeFileSync15(fd, `${JSON.stringify(record)}
+    writeFileSync16(fd, `${JSON.stringify(record)}
 `);
     return true;
   } catch (error) {
@@ -13118,12 +13813,12 @@ function createPendingAsk(args) {
     createdAt: now,
     updatedAt: now
   };
-  mkdirSync17(pendingAskDir(args.userId), { recursive: true });
+  mkdirSync18(pendingAskDir(args.userId), { recursive: true });
   for (let attempt = 0;attempt < 2; attempt++) {
     let fd = null;
     try {
       fd = openSync3(path, "wx");
-      writeFileSync15(fd, `${JSON.stringify(record)}
+      writeFileSync16(fd, `${JSON.stringify(record)}
 `);
       return { ok: true, record };
     } catch (err) {
@@ -13216,7 +13911,7 @@ function listPendingAsksForCaller(args) {
     const parsed = isV3 ? { from: args.from, to: "" } : parsePendingAskFilename(fileName);
     if (!parsed)
       continue;
-    const path = join28(dir, fileName);
+    const path = join29(dir, fileName);
     const record = readPendingAskFile(path, {
       userId: args.userId,
       from: parsed.from,
@@ -13258,7 +13953,7 @@ function deletePendingAsksForTopic(args) {
   }
   let deleted = 0;
   for (const fileName of files) {
-    const path = join28(dir, fileName);
+    const path = join29(dir, fileName);
     const parsed = parsePendingAskFilename(fileName);
     const record = readPendingAskFile(path, {
       userId: args.userId,
@@ -13693,190 +14388,6 @@ var init_self_schedules = __esm(async () => {
   });
 });
 
-// ../../packages/core/src/storage/token-stats.ts
-import { createHash as createHash6 } from "crypto";
-import { mkdirSync as mkdirSync18, writeFileSync as writeFileSync16 } from "fs";
-import { join as join29 } 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();
-  mkdirSync18(logDir, { recursive: true });
-  return join29(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 calcCost(b) {
-  return b.estimatedCostUsd;
-}
-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(value2) {
-  if (!value2 || typeof value2 !== "object")
-    return false;
-  const record = value2;
-  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;
-      }
-    });
-    writeFileSync16(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 getStats(userId, from, to) {
-  const records = loadRecords(userId);
-  const fromTs = from ? new Date(from).getTime() : 0;
-  const toTs = to ? new Date(to).getTime() : Infinity;
-  if (from && Number.isNaN(fromTs) || to && Number.isNaN(toTs)) {
-    logger.warn({ from, to }, "token-stats: Invalid date range, returning empty");
-    return {
-      total: emptyBucket(),
-      byHour: {},
-      bySession: {},
-      currentSessions: [],
-      ignoredLegacyRecords: 0,
-      estimatedCostUsd: 0
-    };
-  }
-  const total = emptyBucket();
-  const byHour = {};
-  const bySession = {};
-  const currentSessions = new Map;
-  let ignoredLegacyRecords = 0;
-  for (const raw of records) {
-    if (!isQueryRecord(raw)) {
-      ignoredLegacyRecords += 1;
-      continue;
-    }
-    const r = raw;
-    const ts = new Date(r.timestamp).getTime();
-    if (ts < fromTs || ts > toTs)
-      continue;
-    const hourKey = r.timestamp.slice(0, 13);
-    if (!byHour[hourKey])
-      byHour[hourKey] = emptyBucket();
-    if (!bySession[r.session])
-      bySession[r.session] = emptyBucket();
-    for (const bucket of [total, byHour[hourKey], bySession[r.session]]) {
-      bucket.inputTokens += r.inputTokens;
-      bucket.outputTokens += r.outputTokens;
-      bucket.cacheCreationInputTokens += r.cacheCreationInputTokens;
-      bucket.cacheReadInputTokens += r.cacheReadInputTokens;
-      bucket.queries += 1;
-      bucket.estimatedCostUsd += r.estimatedCostUsd;
-    }
-    if (r.contextTokens !== undefined && r.contextWindow !== undefined && r.contextWindow > 0) {
-      currentSessions.set(r.topicId, {
-        timestamp: r.timestamp,
-        topicId: r.topicId,
-        topicTitle: r.session,
-        ...r.providerSessionId ? { providerSessionId: r.providerSessionId } : {},
-        agent: r.agent,
-        model: r.model,
-        contextTokens: r.contextTokens,
-        contextWindow: r.contextWindow
-      });
-    }
-  }
-  return {
-    total,
-    byHour,
-    bySession,
-    currentSessions: [...currentSessions.values()].sort((a, b) => b.timestamp.localeCompare(a.timestamp)),
-    ignoredLegacyRecords,
-    estimatedCostUsd: calcCost(total)
-  };
-}
-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
@@ -13915,6 +14426,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;
@@ -14087,6 +14599,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();
@@ -15428,6 +15941,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 = "";
@@ -15796,6 +16310,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,
@@ -15812,8 +16330,18 @@ ${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);
             hub.broadcastDone(topicId, queryId, event.usage ? {
               input: event.usage.inputTokens,
               output: event.usage.outputTokens,
@@ -15969,7 +16497,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;
@@ -15981,22 +16509,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();
@@ -16679,6 +17217,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);
@@ -17267,6 +17806,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) {
@@ -21646,4 +22235,4 @@ export {
   createAgentHealthMcpServer
 };
 
-//# debugId=D003C1D3A0FFF81964756E2164756E21
+//# debugId=09B1C7A55154125B64756E2164756E21