negotium 0.6.13 → 0.6.17

package/dist/runtime/src/topics/lifecycle.ts

@@ -8,6 +8,7 @@
 import { rmSync } from "node:fs";
 import { runArchiverTurn } from "#agents/archiver";
 import { cancelIdleArchiveForTopic } from "#agents/idle-archiver";
+import { cancelIdleCompactForTopic } from "#agents/idle-compact";
 import { cancelSubagentWatchForDeletedTopic } from "#agents/mcp-tools/spawn-subagent";
 import {
   MIN_MEMORY_ARCHIVE_EXCHANGES,
@@ -59,6 +60,7 @@ async function abortAndWaitForTopic(topicId: string): Promise<boolean> {
   // Drop first: the dying turn's finally block must not dispatch queued work.
   interSessionQueue.drop(topicId);
   cancelIdleArchiveForTopic(topicId);
+  cancelIdleCompactForTopic(topicId);
   const aborted = abortRoom(topicId);
   if (!aborted) return true;
 

package/dist/runtime/src/topics/session.ts

@@ -6,6 +6,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ACTIVE_TASK_TEMPLATE, estimateConversationTokens } from "#agents/compaction-support";
 import { archiveActiveTopicForMemory, cancelIdleArchiveForTopic } from "#agents/idle-archiver";
+import { cancelIdleCompactForTopic } from "#agents/idle-compact";
 import { runAgent } from "#agents/index";
 import { MIN_MEMORY_ARCHIVE_EXCHANGES } from "#agents/memory-archive-policy";
 import { resolveCompactionExecution, resolveModelForAgent } from "#agents/model-catalog";
@@ -40,7 +41,10 @@ import {
   beginRuntimeTopicMaintenance,
   type RuntimeTopicMaintenanceHandle,
 } from "#storage/runtime-topic-state";
-import { cancelRuntimeUserTurnRequestsBeforeEpoch } from "#storage/runtime-turn-requests";
+import {
+  cancelRuntimeUserTurnRequestsBeforeEpoch,
+  getRuntimeUserTurnRequest,
+} from "#storage/runtime-turn-requests";
 import { archiveConversationEvents } from "#storage/topic-archive";
 import { isLegacySharedGeneral } from "#topics/personal-general";
 import type { AgentKind, EffortLevel } from "#types";
@@ -62,6 +66,8 @@ export const AUTO_FORK_COMPACTION_TOKENS = 28_000;
 export interface RestartTopicSessionResult {
   text: string;
   isError?: boolean;
+  /** True when a non-preemptive compact bailed because a turn was already in flight (see `preemptive`). */
+  busy?: boolean;
 }
 
 export interface CompactSummaryRequest {
@@ -79,6 +85,15 @@ export interface CompactSummaryRequest {
 export interface CompactTopicSessionOptions {
   summarize?: (request: CompactSummaryRequest) => Promise<string>;
   cleanupOldRollouts?: typeof cleanupTopicRolloutsFromEntries;
+  /**
+   * When `false`, never interrupt work already in flight: instead of calling
+   * `fenceTopicWork` (which aborts local/remote turns and cancels queued
+   * requests), bail out as soon as maintenance reveals any turn is running or
+   * queued. Defaults to `true`, preserving `/compact`'s existing preemptive
+   * behavior — a human invoking it has implicitly accepted the interruption.
+   * Automatic/idle-triggered compaction must pass `false`.
+   */
+  preemptive?: boolean;
 }
 
 export interface CompactedRolloutRequest extends Omit<CompactSummaryRequest, "source"> {
@@ -135,6 +150,27 @@ async function fenceTopicWork(
   return maintenance.isOwned() ? null : "Topic maintenance ownership was lost. Try again.";
 }
 
+/** True when any turn is running (this process or a remote node) or queued for this topic. */
+function hasTopicWorkInFlight(topicId: string): boolean {
+  return Boolean(
+    getRoomQuery(topicId) || getRuntimeTurnLease(topicId) || getRuntimeUserTurnRequest(topicId),
+  );
+}
+
+/**
+ * Non-preemptive counterpart to `fenceTopicWork`: never abort or cancel
+ * anything. `beginRuntimeTopicMaintenance` unconditionally bumps the topic's
+ * epoch just by being called, so callers must check *before* acquiring it
+ * (skip the bump entirely in the common busy case) and check again
+ * immediately *after* acquiring it (the authoritative read — once maintenance
+ * is held, `claimRuntimeTurnLease`'s own `WHERE NOT EXISTS (...maintenance)`
+ * guarantees no *new* turn can start, so anything found here was already
+ * running before we got here). Returns `true` when it is safe to proceed.
+ */
+function topicIsQuiescedForNonPreemptiveWork(topicId: string): boolean {
+  return !hasTopicWorkInFlight(topicId);
+}
+
 /**
  * Reset provider-native and provider-neutral context without deleting the
  * topic or its visible message history. Mirrors Otium's `/new` contract.
@@ -164,6 +200,7 @@ export async function restartTopicSession(
     const fenceError = await fenceTopicWork(topicId, maintenance);
     if (fenceError) return { text: fenceError, isError: true };
     cancelIdleArchiveForTopic(topicId);
+    cancelIdleCompactForTopic(topicId);
     const rawArchivePaths: string[] = [];
     try {
       for (const participantUserId of new Set([
@@ -731,12 +768,32 @@ export async function compactTopicSession(
   );
   if (!owner) return { text: "Only the topic owner can compact the session.", isError: true };
 
+  const preemptive = options.preemptive ?? true;
+  if (!preemptive && hasTopicWorkInFlight(topicId)) {
+    // Fast path: skip acquiring maintenance at all (which would otherwise
+    // unconditionally bump the topic epoch) in the common busy case.
+    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 {
-    const fenceError = await fenceTopicWork(topicId, maintenance);
-    if (fenceError) return { text: fenceError, isError: true };
+    if (preemptive) {
+      const fenceError = await fenceTopicWork(topicId, maintenance);
+      if (fenceError) return { text: fenceError, isError: true };
+    } else if (!topicIsQuiescedForNonPreemptiveWork(topicId)) {
+      // Authoritative check, now that no *new* turn can start under this
+      // epoch. Never abort or cancel anything already running — bail instead.
+      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") as AgentKind;
     const registry = getRegistry(agent);

package/dist/runtime/src/version.ts

@@ -1 +1 @@
-export const NEGOTIUM_VERSION = "0.6.13";
+export const NEGOTIUM_VERSION = "0.6.17";

package/dist/types/packages/core/src/agents/archiver.d.ts

@@ -73,7 +73,7 @@ export interface ArchiverHost {
 }
 export interface ArchiverRuntime {
     runArchiverTurn(params: RunArchiverTurnParams): boolean;
-    listActiveMemoryArchiverSessions(userId: string): BackgroundSessionDto[];
+    listActiveMemoryArchiverSessions(userId: string, allUsers?: boolean): BackgroundSessionDto[];
 }
 export declare function createArchiverRuntime(host: ArchiverHost): ArchiverRuntime;
 /**
@@ -82,4 +82,4 @@ export declare function createArchiverRuntime(host: ArchiverHost): ArchiverRunti
  */
 export declare function findSummaryFile(storage: ArchiverStorageHost, topicTitle: string, date: string, sinceMs: number, topicId?: string): string | null;
 export declare function runArchiverTurn(params: RunArchiverTurnParams): boolean;
-export declare function listActiveMemoryArchiverSessions(userId: string): BackgroundSessionDto[];
+export declare function listActiveMemoryArchiverSessions(userId: string, allUsers?: boolean): BackgroundSessionDto[];

package/dist/types/packages/core/src/agents/idle-compact.d.ts

@@ -0,0 +1,28 @@
+import { getTopicStats } from "../storage/token-stats";
+import type { RestartTopicSessionResult } from "../topics/session";
+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>;
+}
+/** Cancel a pending idle-compact timer, e.g. before a topic is reset or deleted. */
+export declare function cancelIdleCompactForTopic(topicId: string): boolean;
+export declare function idleCompactDelayMs(): number;
+/** Percentage (0–100) of the provider's context window an idle topic must reach before it is auto-compacted. */
+export declare function idleCompactMinContextPercent(): number;
+export declare function idleCompactEnabled(): boolean;
+/**
+ * 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 declare function scheduleIdleCompactForTopic(topicId: string, userId: string): IdleCompactStatus;
+export declare function runIdleCompactForTopic(topicId: string, userId: string, options?: IdleCompactOptions): Promise<IdleCompactStatus>;
+export {};

package/dist/types/packages/core/src/runtime/background-sessions.d.ts

@@ -1,5 +1,5 @@
 import type { BackgroundSessionDto } from "../types/api";
-export type BackgroundSessionProvider = (userId: string) => BackgroundSessionDto[];
+export type BackgroundSessionProvider = (userId: string, allUsers?: boolean) => BackgroundSessionDto[];
 export interface TransientBackgroundSessionHandle {
     id: string;
     update(status: string, step?: string): void;
@@ -16,4 +16,12 @@ export declare function backgroundSessionProgress(topicId: string, queryId: stri
     status: string;
     steps: string[];
 };
-export declare function listBackgroundSessionsForUser(userId: string): BackgroundSessionDto[];
+/**
+ * `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 declare function listBackgroundSessionsForUser(userId: string, allUsers?: boolean): BackgroundSessionDto[];

package/dist/types/packages/core/src/runtime/turn-event-stream.d.ts

@@ -16,6 +16,20 @@ export type StreamAgentOutcome = {
 } | {
     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;

package/dist/types/packages/core/src/runtime/turn-runner.d.ts

@@ -197,6 +197,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 {
     /** Run the injected turn without writing the inject prompt as a visible message. */

package/dist/types/packages/core/src/topics/session.d.ts

@@ -8,6 +8,8 @@ export declare const AUTO_FORK_COMPACTION_TOKENS = 28000;
 export interface RestartTopicSessionResult {
     text: string;
     isError?: boolean;
+    /** True when a non-preemptive compact bailed because a turn was already in flight (see `preemptive`). */
+    busy?: boolean;
 }
 export interface CompactSummaryRequest {
     topicId: string;
@@ -23,6 +25,15 @@ export interface CompactSummaryRequest {
 export interface CompactTopicSessionOptions {
     summarize?: (request: CompactSummaryRequest) => Promise<string>;
     cleanupOldRollouts?: typeof cleanupTopicRolloutsFromEntries;
+    /**
+     * When `false`, never interrupt work already in flight: instead of calling
+     * `fenceTopicWork` (which aborts local/remote turns and cancels queued
+     * requests), bail out as soon as maintenance reveals any turn is running or
+     * queued. Defaults to `true`, preserving `/compact`'s existing preemptive
+     * behavior — a human invoking it has implicitly accepted the interruption.
+     * Automatic/idle-triggered compaction must pass `false`.
+     */
+    preemptive?: boolean;
 }
 export interface CompactedRolloutRequest extends Omit<CompactSummaryRequest, "source"> {
     entries: ConversationEntry[];

package/dist/types/packages/core/src/version.d.ts

@@ -1 +1 @@
-export declare const NEGOTIUM_VERSION = "0.6.13";
+export declare const NEGOTIUM_VERSION = "0.6.17";

package/dist/types/packages/module-cron/src/background-sessions.d.ts

@@ -1,2 +1,2 @@
 import { type BackgroundSessionDto } from "@negotium/core/cron-host";
-export declare function listCronBackgroundSessions(userId: string): BackgroundSessionDto[];
+export declare function listCronBackgroundSessions(userId: string, allUsers?: boolean): BackgroundSessionDto[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "negotium",
-  "version": "0.6.13",
+  "version": "0.6.17",
   "type": "module",
   "description": "Install the Negotium multi-agent runtime and CLI with one package",
   "license": "Apache-2.0",