negotium 0.6.13 → 0.6.17

package/dist/registry.js

@@ -133,7 +133,7 @@ var codexRegistryOperations = {
     return { sessionId: threadId, rolloutPath };
   },
   async forkSession({ parentSessionId }) {
-    const { forkCodexSession } = await import("./chunk-sr48tc2c.js");
+    const { forkCodexSession } = await import("./chunk-ax6tqx0s.js");
     return await forkCodexSession(parentSessionId);
   },
   async cleanupRollouts({ sessionIds }) {

package/dist/runtime/cron/background-sessions.ts

@@ -27,11 +27,14 @@ function latestRun(jobs: CronJobRecord[]): DisplayRun | undefined {
     .sort((left, right) => right.run.scheduledAt.localeCompare(left.run.scheduledAt))[0];
 }
 
-export function listCronBackgroundSessions(userId: string): BackgroundSessionDto[] {
+export function listCronBackgroundSessions(
+  userId: string,
+  allUsers = false,
+): BackgroundSessionDto[] {
   const jobsByTopic = new Map<string, CronJobRecord[]>();
   for (const job of listCronJobs()) {
     const topic = getTopic(job.topicId);
-    if (!topic || !isParticipant(topic, userId)) continue;
+    if (!topic || !(allUsers || isParticipant(topic, userId))) continue;
     const jobs = jobsByTopic.get(job.topicId) ?? [];
     jobs.push(job);
     jobsByTopic.set(job.topicId, jobs);

package/dist/runtime/src/agents/archiver.ts

@@ -149,7 +149,7 @@ export interface ArchiverHost {
 
 export interface ArchiverRuntime {
   runArchiverTurn(params: RunArchiverTurnParams): boolean;
-  listActiveMemoryArchiverSessions(userId: string): BackgroundSessionDto[];
+  listActiveMemoryArchiverSessions(userId: string, allUsers?: boolean): BackgroundSessionDto[];
 }
 
 export function createArchiverRuntime(host: ArchiverHost): ArchiverRuntime {
@@ -169,7 +169,7 @@ export function createArchiverRuntime(host: ArchiverHost): ArchiverRuntime {
     }
   };
 
-  const listSessions = (userId: string): BackgroundSessionDto[] => {
+  const listSessions = (userId: string, allUsers = false): BackgroundSessionDto[] => {
     const now = host.config.now().getTime();
     for (const [id, session] of activeSessions) {
       if (session.expiresAt !== undefined && session.expiresAt <= now) {
@@ -180,7 +180,7 @@ export function createArchiverRuntime(host: ArchiverHost): ArchiverRuntime {
       }
     }
     return [...activeSessions.values()]
-      .filter((session) => session.userId === userId)
+      .filter((session) => allUsers || session.userId === userId)
       .map(({ userId: _userId, expiresAt: _expiresAt, expiryTimer: _expiryTimer, ...session }) => ({
         ...session,
         steps: [...session.steps],
@@ -660,6 +660,9 @@ export function runArchiverTurn(params: RunArchiverTurnParams): boolean {
   return defaultArchiverRuntime.runArchiverTurn(params);
 }
 
-export function listActiveMemoryArchiverSessions(userId: string): BackgroundSessionDto[] {
-  return defaultArchiverRuntime.listActiveMemoryArchiverSessions(userId);
+export function listActiveMemoryArchiverSessions(
+  userId: string,
+  allUsers = false,
+): BackgroundSessionDto[] {
+  return defaultArchiverRuntime.listActiveMemoryArchiverSessions(userId, allUsers);
 }

package/dist/runtime/src/agents/claude-provider.ts

@@ -43,6 +43,11 @@ const CLAUDE_DEFAULT_DISALLOWED_TOOLS = [
   "TaskUpdate",
   "TaskList",
   "TaskGet",
+  // Monitor spawns a long-running background watcher tied to the CLI's own
+  // interactive session/notification loop, which our headless spawned turns
+  // don't have — it doesn't reliably deliver events back into a Negotium
+  // topic. Use the background-bash MCP tools (run/watch) instead.
+  "Monitor",
   // Native scheduling/cron tools duplicate Negotium's own runtime MCP surface
   // (`mcp__runtime__schedule_self`, the `cron-manager` server) and bypass its
   // persistence/host wiring if used directly.
@@ -215,6 +220,48 @@ type SpawnClaudeCodeResult = ReturnType<SpawnClaudeCodeProcess>;
 
 const CLAUDE_ABORT_SIGKILL_DELAY_MS = 2500;
 
+type ClaudeProcessExit = { code: number | null; signal: NodeJS.Signals | null };
+
+// The Agent SDK can keep its stdout reader open for several minutes after its
+// CLI child has gone away (CLAUDE_CODE_STREAM_CLOSE_TIMEOUT defaults to five
+// minutes in our host environment).  Keep a per-query hook so the provider
+// can abort that stuck reader and emit a normal terminal error instead of
+// leaving the room lease occupied indefinitely.
+const claudeProcessExitListeners = new WeakMap<
+  AbortSignal,
+  Set<(exit: ClaudeProcessExit) => void>
+>();
+
+function watchClaudeProcessExit(signal: AbortSignal): {
+  exited: Promise<ClaudeProcessExit>;
+  dispose: () => void;
+} {
+  let listener: ((exit: ClaudeProcessExit) => void) | undefined;
+  const exited = new Promise<ClaudeProcessExit>((resolve) => {
+    listener = resolve;
+    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: AbortSignal, exit: ClaudeProcessExit): void {
+  const listeners = claudeProcessExitListeners.get(signal);
+  if (!listeners) return;
+  claudeProcessExitListeners.delete(signal);
+  for (const listener of listeners) listener(exit);
+}
+
 function signalProcessTree(pid: number, signal: NodeJS.Signals): boolean {
   // Negative pid = "signal every process in this process group". Falls back
   // to single-pid signaling if the group call fails (e.g. on platforms where
@@ -285,6 +332,7 @@ export function spawnClaudeCodeProcessWithTreeKill(
     clearKillTimer();
     options.signal.removeEventListener("abort", onAbort);
     logger.debug({ pid: child.pid, code, signal }, "Claude Code process exited");
+    notifyClaudeProcessExit(options.signal, { code, signal });
   });
 
   // Consume the child's 'error' event. Without a listener, a spawn-level error
@@ -304,6 +352,7 @@ export function spawnClaudeCodeProcessWithTreeKill(
       },
       "Claude Code process error event",
     );
+    notifyClaudeProcessExit(options.signal, { code: null, signal: null });
   });
 
   return {
@@ -380,6 +429,22 @@ export async function* claudeProvider(opts: AgentQueryOptions): AsyncGenerator<U
   // spawns); the `settings` flag layer below covers it a second time.
   cleanEnv.CLAUDE_CODE_DISABLE_WORKFLOWS = "1";
 
+  // Use a private signal for the SDK. A premature CLI exit must wake its
+  // reader, but must not look like a user-initiated abort to the turn runner.
+  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: ClaudeProcessExit | undefined;
+  void processExitWatch.exited.then((exit) => {
+    // An exit caused by an explicit stop/supersede is expected. Its caller
+    // signal is the authoritative distinction from a CLI crash.
+    if (opts.abortController?.signal.aborted) return;
+    unexpectedProcessExit = exit;
+    sdkAbortController.abort();
+  });
+
   const queryOptions: Options = {
     ...(claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {}),
     spawnClaudeCodeProcess: spawnClaudeCodeProcessWithTreeKill,
@@ -390,7 +455,7 @@ export async function* claudeProvider(opts: AgentQueryOptions): AsyncGenerator<U
     env: cleanEnv,
     mcpServers: hostedMcpServers(opts) as Options["mcpServers"],
     ...(claudeBuiltInTools(opts) ? { tools: claudeBuiltInTools(opts) } : {}),
-    abortController: opts.abortController,
+    abortController: sdkAbortController,
     // `AskUserQuestion` is Claude Code's built-in clarification tool, but it
     // expects the SDK CLI to render a TUI prompt and read stdin for the
     // answer — neither exists in this headless Telegram bridge. Without
@@ -746,12 +811,34 @@ export async function* claudeProvider(opts: AgentQueryOptions): AsyncGenerator<U
         }
       }
     }
+    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) {
     // Abort = user moved on; don't surface as an error message. The handler
     // catches the abort signal separately via abortReason, so swallowing
     // here matches both maestro and codex behavior.
+    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);
   }
 }

package/dist/runtime/src/agents/idle-compact.ts

@@ -0,0 +1,178 @@
+import { logger } from "#platform/logger";
+import { getRoomQuery } from "#query/active-rooms";
+import { getTopic } from "#storage/api-topics";
+import { getRuntimeTurnLease } from "#storage/runtime-leases";
+import { getTopicStats } from "#storage/token-stats";
+import type { RestartTopicSessionResult } from "#topics/session";
+
+const DEFAULT_IDLE_DELAY_MS = 6 * 60 * 60 * 1000;
+// Mirrors the 80%-occupancy usage alert in `#runtime/turn-event-stream` at a
+// lower bar: an idle topic gets auto-compacted once its *last known* context
+// usage (as the provider itself reported it) has crossed the halfway mark.
+const DEFAULT_MIN_CONTEXT_PERCENT = 50;
+
+type IdleCompactStatus =
+  | "scheduled"
+  | "disabled"
+  | "busy"
+  | "topic-not-found"
+  | "not-ai-invited"
+  | "mention-only-channel"
+  | "no-owner"
+  | "below-threshold"
+  | "compacted"
+  | "failed";
+
+export interface IdleCompactOptions {
+  isBusy?: (topicId: string) => boolean;
+  onBusy?: (topicId: string, userId: string) => void;
+  minContextPercent?: number;
+  /** Injected for tests; defaults to the real `getTopicStats`. */
+  getStats?: typeof getTopicStats;
+  /** Injected for tests; defaults to the real `compactTopicSession`. */
+  compact?: (topicId: string, userId: string, reason: string) => Promise<RestartTopicSessionResult>;
+}
+
+const timers = new Map<string, ReturnType<typeof setTimeout>>();
+
+/** Cancel a pending idle-compact timer, e.g. before a topic is reset or deleted. */
+export function cancelIdleCompactForTopic(topicId: string): boolean {
+  const timer = timers.get(topicId);
+  if (!timer) return false;
+  clearTimeout(timer);
+  timers.delete(topicId);
+  return true;
+}
+
+function envFlagEnabled(name: string, fallback: boolean): boolean {
+  const raw = process.env[name]?.trim().toLowerCase();
+  if (!raw) return fallback;
+  return !["0", "false", "off", "no"].includes(raw);
+}
+
+function envPositiveInt(name: string, fallback: number): number {
+  const value = Number.parseInt(process.env[name] ?? "", 10);
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+export function idleCompactDelayMs(): number {
+  return envPositiveInt("NEGOTIUM_IDLE_COMPACT_DELAY_MS", DEFAULT_IDLE_DELAY_MS);
+}
+
+/** Percentage (0–100) of the provider's context window an idle topic must reach before it is auto-compacted. */
+export function idleCompactMinContextPercent(): number {
+  return envPositiveInt("NEGOTIUM_IDLE_COMPACT_MIN_CONTEXT_PERCENT", DEFAULT_MIN_CONTEXT_PERCENT);
+}
+
+export function idleCompactEnabled(): boolean {
+  return envFlagEnabled("NEGOTIUM_IDLE_COMPACT_ENABLED", true);
+}
+
+/**
+ * Schedule a check, `idleCompactDelayMs()` after the topic's last turn, that
+ * compacts the session if (and only if) it is still idle and its context has
+ * grown past the percent-of-window threshold. Runs alongside the memory
+ * idle-archiver — this only trims what the model sees next turn; it does not
+ * touch memory.
+ */
+export function scheduleIdleCompactForTopic(topicId: string, userId: string): IdleCompactStatus {
+  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 = timers.get(topicId);
+  if (existing) clearTimeout(existing);
+
+  const timer = setTimeout(() => {
+    timers.delete(topicId);
+    void runIdleCompactForTopic(topicId, userId);
+  }, idleCompactDelayMs());
+  timer.unref?.();
+  timers.set(topicId, timer);
+  return "scheduled";
+}
+
+export async function runIdleCompactForTopic(
+  topicId: string,
+  userId: string,
+  options: IdleCompactOptions = {},
+): Promise<IdleCompactStatus> {
+  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: string, actorId: string, reason: string) => {
+      // `preemptive: false`: idle-compact must never abort or cancel a turn
+      // already in flight, local or remote — only a human explicitly running
+      // `/compact` gets to interrupt work. See `compactTopicSession`.
+      const { compactTopicSession } = await import("#topics/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";
+  }
+}

package/dist/runtime/src/node-host.ts

@@ -77,8 +77,15 @@ export {
   getLastMessagePreviews,
   listApiMessages,
   listThreadMessages,
+  setApiMessageReactions,
   softDeleteApiMessage,
+  updateApiMessageText,
 } from "#storage/api-messages";
+export {
+  getApiTopicConfig,
+  setApiTopicConfig,
+  type TopicConfig,
+} from "#storage/api-topic-config";
 export { getTopic, upsertTopic } from "#storage/api-topics";
 export { getGlobalAiName, setGlobalAiName } from "#storage/app-settings";
 export { readDecisions, writeDecisionGraphSvg } from "#storage/decisions";
@@ -103,6 +110,6 @@ export {
 export { ensurePersonalGeneral } from "#topics/personal-general";
 export { compactTopicSession } from "#topics/session";
 export { TopicUpdateConflictError, updateTopicSettings } from "#topics/update";
-export type { AgentKind } from "#types";
+export type { AgentKind, EffortLevel } from "#types";
 export type { AiMode, AttachmentDto, TopicDto, TopicSurface } from "#types/api";
 export { NEGOTIUM_VERSION } from "#version";

package/dist/runtime/src/runtime/background-sessions.ts

@@ -6,7 +6,10 @@ import { listRuntimeTurnLeases } from "#storage/runtime-leases";
 import type { BackgroundSessionDto } from "#types/api";
 import { COMPLETED_BACKGROUND_SESSION_RETENTION_MS } from "./background-session-policy";
 
-export type BackgroundSessionProvider = (userId: string) => BackgroundSessionDto[];
+export type BackgroundSessionProvider = (
+  userId: string,
+  allUsers?: boolean,
+) => BackgroundSessionDto[];
 
 const providers = new Set<BackgroundSessionProvider>();
 interface TransientBackgroundSessionRecord extends BackgroundSessionDto {
@@ -220,8 +223,19 @@ export function backgroundSessionProgress(
   return { status, steps };
 }
 
-export function listBackgroundSessionsForUser(userId: string): BackgroundSessionDto[] {
-  const memory = listActiveMemoryArchiverSessions(userId);
+/**
+ * `allUsers` widens every section — memory archiver, compact/transient, and
+ * cron — past the caller's own participation. Meant for single-owner
+ * surfaces (terminal, Telegram) where "my view" and "everything on this
+ * node" are the same person anyway, so idle background upkeep (and compact,
+ * manual or idle-triggered) triggered under a different local userId is
+ * still visible.
+ */
+export function listBackgroundSessionsForUser(
+  userId: string,
+  allUsers = false,
+): BackgroundSessionDto[] {
+  const memory = listActiveMemoryArchiverSessions(userId, allUsers);
   const now = Date.now();
   for (const [id, session] of transientSessions) {
     if (session.expiresAt !== undefined && session.expiresAt <= now) {
@@ -230,12 +244,12 @@ export function listBackgroundSessionsForUser(userId: string): BackgroundSession
     }
   }
   const transient = [...transientSessions.values()]
-    .filter((session) => session.userId === userId)
+    .filter((session) => allUsers || session.userId === userId)
     .map(({ userId: _userId, expiresAt: _expiresAt, expiryTimer: _expiryTimer, ...session }) => ({
       ...session,
       steps: [...session.steps],
     }));
-  const provided = [...providers].flatMap((provider) => provider(userId));
+  const provided = [...providers].flatMap((provider) => provider(userId, allUsers));
   const providedCronTopicIds = new Set(
     provided
       .filter((session) => session.kind === "cron")
@@ -246,9 +260,8 @@ export function listBackgroundSessionsForUser(userId: string): BackgroundSession
     .filter((lease) => lease.origin.startsWith("cron:"))
     .flatMap((lease): BackgroundSessionDto[] => {
       const topic = getTopic(lease.topicId);
-      const isParticipant = topic?.participants.some(
-        (participant) => participant.userId === userId,
-      );
+      const isParticipant =
+        allUsers || topic?.participants.some((participant) => participant.userId === userId);
       if (!topic || !isParticipant || providedCronTopicIds.has(lease.topicId)) {
         return [];
       }

package/dist/runtime/src/runtime/turn-event-stream.ts

@@ -4,6 +4,7 @@ import { isAbsolute, resolve } from "node:path";
 import { estimateTextTokens } from "#agents/compaction-support";
 import { cleanupAgentFork } from "#agents/fork";
 import { scheduleIdleArchiveForTopic } from "#agents/idle-archiver";
+import { scheduleIdleCompactForTopic } from "#agents/idle-compact";
 import { cancelPendingAskUserQuestions } from "#agents/mcp-tools/ask-user";
 import {
   settleSubagentFailure,
@@ -83,7 +84,18 @@ export type StreamAgentOutcome =
   | { kind: "aborted" }
   | { kind: "budget-capped"; reason: "cost"; usage?: TokenUsage }
   | { kind: "session-expired"; error: string }
-  | { kind: "provider-error"; error: string };
+  | { kind: "provider-error"; error: string }
+  /**
+   * The provider's terminal result carried no assistant text at all — the
+   * "silent turn" bug: a session-level race (e.g. a queued background-task
+   * notification flushing into the CLI session at the same instant a new
+   * user turn is dispatched) makes the underlying CLI self-interrupt within
+   * ~1-2s and report a trivial zero-usage "success". Distinct from
+   * provider-error so the caller can retry once before surfacing a failure —
+   * a manual resend has reliably produced a normal reply in every observed
+   * case.
+   */
+  | { kind: "empty-response"; error: string };
 
 export interface TurnEventStreamHooks {
   appendSystemMessage: (topicId: string, text: string) => MessageDto;
@@ -146,6 +158,7 @@ export async function runTurnEventStream(
   const peerBridge = execution?.peerBridge ?? control.injectParams?.peerBridge;
   let errorOccurred = false;
   let terminalEmitted = false;
+  const streamStartedAt = Date.now();
   let lastEventType: UnifiedEvent["type"] | null = null;
   let pendingSawDelta = false;
   let accumulatedText = "";
@@ -632,6 +645,13 @@ export async function runTurnEventStream(
           break;
         case "result":
           if (event.usage) recordEventUsage(event.usage);
+          // Most providers emit assistant text before the terminal result, but
+          // accept result-only providers too. Without this fallback a valid
+          // final payload was indistinguishable from the silent-turn bug.
+          if (!accumulatedText.trim() && event.content.trim()) {
+            accumulatedText = event.content;
+            pendingText = event.content;
+          }
           {
             const usage: MessageDto["usage"] = event.usage
               ? {
@@ -654,8 +674,26 @@ export async function runTurnEventStream(
               }
             }
           }
+          if (!accumulatedText.trim()) {
+            const error = "Provider completed without an assistant response";
+            terminalEmitted = true;
+            // Silent turns (asks, subagent calls) delivered their error to the
+            // caller synchronously below and have no user-facing chat to
+            // retry into, so they skip the retry path the caller applies to
+            // "empty-response" and go straight to a reported provider-error.
+            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) void deliverAskError(queryId, topicTitle, error);
+            return outcome;
+          }
           if (!silent) {
             scheduleIdleArchiveForTopic(topicId, execution?.actorUserId ?? userId);
+            scheduleIdleCompactForTopic(topicId, execution?.actorUserId ?? userId);
             hub.broadcastDone(
               topicId,
               queryId,
@@ -873,6 +911,7 @@ export async function runTurnEventStream(
     const discardIncompleteSegments =
       outcome.kind === "session-expired" ||
       outcome.kind === "provider-error" ||
+      outcome.kind === "empty-response" ||
       (!terminalEmitted && !abortController.signal.aborted);
     if (discardIncompleteSegments) discardVisibleAssistantMessages();
     // Release the room slot — but only if a newer turn hasn't already taken it
@@ -891,6 +930,7 @@ export async function runTurnEventStream(
     if (
       forkHandle &&
       outcome.kind !== "session-expired" &&
+      outcome.kind !== "empty-response" &&
       (!forkRequestId || !interSessionQueue.hasRequest(topicId, forkRequestId))
     ) {
       cleanupAgentFork(forkHandle);
@@ -903,12 +943,25 @@ export async function runTurnEventStream(
     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;
 }

package/dist/runtime/src/runtime/turn-runner.ts

@@ -734,6 +734,8 @@ export interface StartAiTurnParams extends AiTurnExecutionOptions {
   /** Durable rows whose envelopes are already present in _userMessages. */
   _durableRequestIds?: string[];
   _sessionRetried?: boolean;
+  /** Internal only. Caps the empty-provider-response retry to a single attempt. */
+  _emptyResponseRetried?: boolean;
 }
 
 export interface TriggerTopicAiTurnOptions extends AiTurnExecutionOptions {
@@ -1028,6 +1030,7 @@ export function startAiTurn(params: StartAiTurnParams): string | null {
   const peerBridge = params.peerBridge;
   const askReplySources = params.askReplySources;
   const sessionRetried = params._sessionRetried === true;
+  const emptyResponseRetried = params._emptyResponseRetried === true;
   const queryId = params._queryId ?? randomUUID();
   const roomId = turnConcurrency === "isolated" ? isolatedTurnRoomId(topicId, queryId) : topicId;
   const currentRuntimeEpoch = getRuntimeTopicEpoch(topic.id);
@@ -1822,6 +1825,66 @@ export function startAiTurn(params: StartAiTurnParams): string | null {
         }
       }
 
+      if (outcome.kind === "empty-response") {
+        if (emptyResponseRetried) {
+          // Already retried once and still got nothing back — stop masking it
+          // and report a normal provider failure.
+          outcome = { kind: "provider-error", error: outcome.error };
+        } else {
+          // Observed cause: a queued background-task notification flushes into
+          // the CLI session at the same instant this turn is dispatched, and
+          // the CLI self-interrupts within ~1-2s with a zero-usage "success".
+          // A same-session retry has reliably produced a real reply in every
+          // case seen so far, so retry once before surfacing a failure.
+          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,
+            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) {