arisa 5.2.7 → 5.2.17

package/src/transport/telegram/task-dispatcher.js

@@ -38,6 +38,14 @@ function failureDestination(task) {
 }
 
 function buildFailureNotice({ task, result, error }) {
+  if (result?.authBlockedNew === true) {
+    return [
+      "⚠️ Arisa automation paused for authentication",
+      `Tool: ${task.payload?.toolName || "unknown"}`,
+      `Reason: ${safeErrorSummary(error)}`,
+      `Next authentication check: ${result.runAt}`
+    ].join("\n");
+  }
   const uncertain = result?.status === "outcome_uncertain" || result?.lastOutcome === "outcome_uncertain";
   const recurring = result?.terminalFailure === true && result?.status === "pending";
   const lines = [
@@ -72,7 +80,8 @@ export function createTelegramTaskDispatcher({
       prompt: await buildAsyncTaskPrompt({ task, artifactStore, toolRegistry, resourceNotes, logger }),
       label: `scheduled task ${task.id}`,
       route: task.route,
-      timeoutMs: agentTimeoutMs
+      timeoutMs: agentTimeoutMs,
+      priority: task.source?.toolName === "whatsapp-web" ? "interactive" : "background"
     });
   }
 
@@ -92,7 +101,8 @@ export function createTelegramTaskDispatcher({
       prompt: await buildAsyncEventPrompt(task, resourceNotes),
       label: `agent event ${task.id}`,
       route: task.route,
-      timeoutMs: eventTimeoutMs
+      timeoutMs: eventTimeoutMs,
+      priority: task.source?.toolName === "process-retrospective" ? "background" : "interactive"
     });
   }
 
@@ -100,20 +110,35 @@ export function createTelegramTaskDispatcher({
     const toolName = task.payload?.toolName;
     if (!toolName) throw new NonRetryableTaskError("poll_tool missing toolName");
     logger?.log("tasks", `polling tool ${toolName} (task ${task.id}) for chat ${chatId}`);
-    const result = await agentManager.runTool({
-      name: toolName,
-      request: { args: task.payload.args || {} },
-      chatId
-    });
-    if (result?.ok === false) {
-      const error = new Error(result.error || `poll_tool ${toolName} failed`);
-      if (result.status === "needs_config") error.retryable = false;
-      if (result.status === "outcome_uncertain") {
+
+    const runTool = (args) => agentManager.runTurn({
+      priority: "background",
+      label: `poll tool ${toolName}`
+    }, () => agentManager.runTool({ name: toolName, request: { args }, chatId }));
+
+    function throwFailure(result, fallbackResolution) {
+      const error = new Error(result?.error || `poll_tool ${toolName} failed`);
+      if (result?.status === "blocked_auth" || fallbackResolution) {
+        error.retryable = false;
+        error.authBlocked = true;
+        error.authResolution = result?.resolution || fallbackResolution;
+      } else if (result?.status === "needs_config") {
+        error.retryable = false;
+      } else if (result?.status === "outcome_uncertain") {
         error.retryable = false;
         error.outcomeUncertain = true;
       }
       throw error;
     }
+
+    if (task.authBlock) {
+      const probe = await runTool(task.authBlock.probeArgs || {});
+      if (probe?.ok === false) throwFailure(probe, task.authBlock);
+      logger?.log("tasks", `authentication restored for ${toolName} (task ${task.id})`);
+    }
+
+    const result = await runTool(task.payload.args || {});
+    if (result?.ok === false) throwFailure(result);
   }
 
   async function dispatchTask(task) {

package/src/transport/telegram/telegram-prompt-controller.js

@@ -157,8 +157,14 @@ export function createTelegramPromptController({
       });
     };
 
-    if (ctx) return withTyping(ctx, work);
-    return work();
+    return agentManager.runTurn({
+      priority: executionReceipt?.priority || "interactive",
+      label: executionReceipt?.label || `interactive prompt for ${sessionId}`,
+      queueTtlMs: executionReceipt?.queueTtlMs
+    }, () => {
+      executionReceipt?.start?.();
+      return ctx ? withTyping(ctx, work) : work();
+    });
   }
 
   function processChatPromptQueue({ chatId, prompt, label, ctx = null, beforeInitialPrompt, initialReceipt = null }) {
@@ -193,10 +199,17 @@ export function createTelegramPromptController({
     busyMessageMode = "queue",
     waitForExecution = false,
     onExecutionStart = null,
-    coalesceQueued = false
+    coalesceQueued = false,
+    turnPriority = "interactive",
+    turnQueueTtlMs = undefined
   }) {
     const chatState = getChatState(chatId);
-    const receipt = waitForExecution ? createPromptExecutionReceipt(onExecutionStart) : null;
+    const receipt = waitForExecution ? createPromptExecutionReceipt(onExecutionStart, {
+      priority: turnPriority,
+      label,
+      queueTtlMs: turnQueueTtlMs,
+      deferStart: true
+    }) : null;
 
     if (chatState.processing) {
       const incomingRoute = ctx ? contextRoute(ctx) : null;

package/test/agent-turn-coordinator.test.js

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { AgentTurnCoordinator } from "../src/core/agent/agent-turn-coordinator.js";
+
+test("interactive turns run before queued background turns without overlapping", async () => {
+  const coordinator = new AgentTurnCoordinator();
+  const releaseActive = await coordinator.acquire({ priority: "background", label: "active background" });
+  let backgroundStarted = false;
+  const background = coordinator.acquire({ priority: "background", label: "queued background" }).then((release) => {
+    backgroundStarted = true;
+    return release;
+  });
+  const interactive = coordinator.acquire({ priority: "interactive", label: "interactive" });
+
+  releaseActive();
+  const releaseInteractive = await interactive;
+  assert.equal(backgroundStarted, false);
+  assert.equal(coordinator.diagnostic().active.priority, "interactive");
+  releaseInteractive();
+  const releaseBackground = await background;
+  assert.equal(backgroundStarted, true);
+  releaseBackground();
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(coordinator.diagnostic().active, null);
+  assert.equal(coordinator.diagnostic().completed, 3);
+});
+
+test("background turns expire safely before execution when their queue TTL elapses", async () => {
+  const coordinator = new AgentTurnCoordinator();
+  const releaseActive = await coordinator.acquire({ priority: "interactive", label: "active" });
+  await assert.rejects(
+    coordinator.acquire({ priority: "background", label: "stale batch", queueTtlMs: 10 }),
+    (error) => error.code === "AGENT_TURN_QUEUE_EXPIRED" && error.retryable === true && error.outcomeUncertain === false
+  );
+  assert.equal(coordinator.diagnostic().expired, 1);
+  releaseActive();
+});
+
+test("run releases exclusive admission after failures", async () => {
+  const coordinator = new AgentTurnCoordinator();
+  await assert.rejects(coordinator.run({ priority: "background" }, async () => { throw new Error("failed"); }), /failed/);
+  const result = await coordinator.run({ priority: "interactive" }, async () => "ok");
+  assert.equal(result, "ok");
+  assert.equal(coordinator.diagnostic().completed, 2);
+});

package/test/context-and-task-bounds.test.js

@@ -395,6 +395,7 @@ test("selectScheduledTasks bounds history while keeping active tasks", () => {
     status: "done"
   }));
   tasks[0] = { id: "pending-1", status: "pending" };
+  tasks[1] = { id: "blocked-1", status: "blocked_auth" };
 
   const result = selectScheduledTasks(tasks);
 
@@ -402,7 +403,7 @@ test("selectScheduledTasks bounds history while keeping active tasks", () => {
   assert.equal(result.returned, 50);
   assert.equal(result.limit, 50);
   assert.equal(result.truncated, true);
-  assert.equal(result.tasks[0].id, "pending-1");
+  assert.deepEqual(result.tasks.slice(0, 2).map((task) => task.id), ["blocked-1", "pending-1"]);
 });
 
 test("selectScheduledTasks honors an explicit status and limit", () => {

package/test/daemon-runtime.test.js

@@ -244,7 +244,7 @@ test("supervisor ignores invalid chat directories and recovers valid daemons", a
   }
 });
 
-test("does not restart registrations whose scope no longer matches the tool manifest", async () => {
+test("removes stopped registrations whose scope no longer matches the tool manifest", async () => {
   const runtime = runtimeFor({ type: "global" }, { autoStart: true });
   const registry = new ToolRegistry();
   registry.tools.set("fake-daemon", {
@@ -267,11 +267,9 @@ test("does not restart registrations whose scope no longer matches the tool mani
   const results = await supervisor.repair();
   const result = results.find((item) => item.record.toolName === "fake-daemon" && item.record.instanceId === "global");
 
-  assert.equal(result.outcome, "stale-registration");
+  assert.equal(result.outcome, "obsolete-removed");
   assert.match(result.reason, /global scope does not match manifest chat scope/);
   assert.equal(isProcessAlive(await runtime.getPid()), false);
-
-  await unregisterManagedDaemon({ toolName: "fake-daemon", scope: { type: "global" } });
   assert.deepEqual(await readJson(runtime.paths.metaFile, null), null);
 });
 

package/test/doctor.test.js

@@ -121,6 +121,25 @@ test("lists each checked daemon with its scope and state", async () => {
   assert.ok(formatted.split("\n").every((line) => [...line].length <= 35));
 });
 
+test("reports automatic obsolete daemon cleanup and unverifiable leftovers", async () => {
+  const { report } = await run({
+    repairs: [
+      {
+        record: { toolName: "removed", instanceId: "global", scope: { type: "global" } },
+        outcome: "obsolete-removed",
+        reason: "tool is no longer installed"
+      },
+      {
+        record: { toolName: "unknown-pid", instanceId: "global", scope: { type: "global" } },
+        outcome: "obsolete-unverified"
+      }
+    ]
+  });
+
+  assert.match(report.repairs.join("\n"), /Removed obsolete daemon removed/);
+  assert.match(report.attention.join("\n"), /unknown-pid.*could not be verified/);
+});
+
 test("reports missing tool dependencies as attention items", async () => {
   const report = await runDoctor({
     agentManager: { getRuntimeDiagnostic: async () => runtime() },

package/test/memory-pressure.test.js

@@ -28,9 +28,14 @@ test("classifies each configured memory pressure boundary", () => {
     swapTotalBytes: 0,
     swapUsedPercent: 0
   }, policy), /worker RSS/);
+  assert.equal(memoryPressureReason({
+    workerRssBytes: 400 * 1024 * 1024,
+    swapTotalBytes: 0,
+    swapUsedPercent: 0
+  }, policy, { ignoreWorkerRss: true }), "");
   assert.match(memoryPressureReason({
-    workerRssBytes: 100 * 1024 * 1024,
+    workerRssBytes: 400 * 1024 * 1024,
     swapTotalBytes: 100,
     swapUsedPercent: 96
-  }, policy), /swap use/);
+  }, policy, { ignoreWorkerRss: true }), /swap use/);
 });

package/test/obsolete-daemon-reaper.test.js

@@ -0,0 +1,61 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { reapObsoleteDaemon } from "../src/runtime/obsolete-daemon-reaper.js";
+
+const record = {
+  toolName: "removed-tool",
+  instanceId: "global",
+  entryPath: "/tools/removed-tool/index.js",
+  scope: { type: "global" }
+};
+
+test("purges an obsolete daemon with no live process", async () => {
+  const purged = [];
+  const result = await reapObsoleteDaemon({
+    record,
+    diagnostic: { pid: null },
+    reason: "tool is no longer installed",
+    purgeDaemon: async (identity) => purged.push(identity)
+  });
+
+  assert.equal(result.outcome, "obsolete-removed");
+  assert.deepEqual(purged, [{ toolName: "removed-tool", scope: { type: "global" } }]);
+});
+
+test("terminates only a verified obsolete daemon process before purging", async () => {
+  const stopped = [];
+  const purged = [];
+  const result = await reapObsoleteDaemon({
+    record,
+    diagnostic: { pid: 321 },
+    reason: "tool is no longer installed",
+    timeoutMs: 100,
+    stopTimeoutMs: 50,
+    inspectProcesses: async () => [{ pid: 321, command: `${process.execPath} ${record.entryPath} daemon` }],
+    stopProcess: async (pid, options) => stopped.push([pid, options]),
+    purgeDaemon: async (identity) => purged.push(identity)
+  });
+
+  assert.equal(result.outcome, "obsolete-removed");
+  assert.deepEqual(stopped, [[321, { forceAfterMs: 50 }]]);
+  assert.equal(purged.length, 1);
+});
+
+test("leaves an unverifiable live PID untouched", async () => {
+  let stopped = false;
+  let purged = false;
+  const result = await reapObsoleteDaemon({
+    record,
+    diagnostic: { pid: 321 },
+    reason: "registered entry does not match the installed tool",
+    timeoutMs: 100,
+    stopTimeoutMs: 50,
+    inspectProcesses: async () => [{ pid: 321, command: "node /some/other/process.js daemon" }],
+    stopProcess: async () => { stopped = true; },
+    purgeDaemon: async () => { purged = true; }
+  });
+
+  assert.equal(result.outcome, "obsolete-unverified");
+  assert.equal(stopped, false);
+  assert.equal(purged, false);
+});

package/test/official-tool-dependencies.test.js

@@ -10,9 +10,14 @@ test("official orchestrators declare their hard tool dependencies", async () =>
   assert.deepEqual((await manifest("magnific-mcp")).toolDependencies, { "mcp-client": "^0.2.0" });
   assert.deepEqual((await manifest("campaign-draft-runner")).toolDependencies, {
     "pr-campaign": "^0.1.0",
-    "gmail-workspace": "^0.1.0"
+    "gmail-workspace": "^0.1.0",
+    "lightpanda-browser": "^0.10.0"
+  });
+  assert.deepEqual((await manifest("browser-session-bridge")).toolDependencies, { "lightpanda-browser": "^0.11.5" });
+  assert.deepEqual((await manifest("x-campaign-runner")).toolDependencies, {
+    "x-dm": "^0.4.0",
+    "lightpanda-browser": "^0.11.0"
   });
-  assert.deepEqual((await manifest("x-campaign-runner")).toolDependencies, { "x-dm": "^0.4.0" });
   assert.deepEqual((await manifest("x-dm")).toolDependencies, { "browser-session-bridge": "^0.1.0" });
   assert.deepEqual((await manifest("x-session-reader")).toolDependencies, { "browser-session-bridge": "^0.1.0" });
   assert.deepEqual((await manifest("official-tool-sync")).toolDependencies, { trash: "^1.0.0" });

package/test/pi-compaction.test.js

@@ -23,6 +23,27 @@ test("merges partial resident session cache overrides with defaults", () => {
   });
 });
 
+test("merges partial session rotation overrides with defaults", () => {
+  const config = applyConfigDefaults({ pi: { sessionRotation: { enabled: false } } });
+
+  assert.deepEqual(config.pi.sessionRotation, {
+    enabled: false,
+    compactAtPersistedBytes: 24 * 1024 * 1024,
+    maxPersistedBytes: 32 * 1024 * 1024
+  });
+});
+
+test("merges partial exclusive turn coordinator overrides with defaults", () => {
+  const config = applyConfigDefaults({ pi: { turnCoordinator: { backgroundQueueTtlMs: 30_000 } } });
+
+  assert.deepEqual(config.pi.turnCoordinator, {
+    enabled: true,
+    backgroundQueueTtlMs: 30_000,
+    interactiveQueueTtlMs: 0,
+    maxQueued: 100
+  });
+});
+
 test("merges partial Pi compaction overrides with defaults", () => {
   const config = applyConfigDefaults({
     pi: { compaction: { reserveTokens: 8_192 } }

package/test/session-history-reader.test.js

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { inspectSessionForPreloadMigration } from "../src/core/agent/session-history-reader.js";
+
+function writeSession(entries) {
+  const dir = mkdtempSync(path.join(tmpdir(), "arisa-session-reader-"));
+  const file = path.join(dir, "session.jsonl");
+  writeFileSync(file, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf8");
+  return { dir, file };
+}
+
+const header = {
+  type: "session",
+  version: 3,
+  id: "session-id",
+  timestamp: "2026-08-28T00:00:00.000Z",
+  cwd: "/workspace"
+};
+
+function message(id, parentId, text) {
+  return {
+    type: "message",
+    id,
+    parentId,
+    timestamp: "2026-08-28T00:00:00.000Z",
+    message: { role: "user", content: [{ type: "text", text }] }
+  };
+}
+
+test("discovers the latest valid compaction on the active branch without retaining divergent payloads", () => {
+  const entries = [
+    header,
+    message("kept", null, "kept context"),
+    {
+      type: "compaction",
+      id: "active-compaction",
+      parentId: "kept",
+      firstKeptEntryId: "kept",
+      summary: "active summary"
+    },
+    message("after", "active-compaction", "recent context"),
+    {
+      type: "compaction",
+      id: "divergent-compaction",
+      parentId: "kept",
+      firstKeptEntryId: "kept",
+      summary: "divergent summary"
+    },
+    message("leaf", "after", "active leaf")
+  ];
+  const { dir, file } = writeSession(entries);
+  try {
+    const result = inspectSessionForPreloadMigration(file, 1);
+    assert.equal(result.compactionId, "active-compaction");
+    assert.equal(result.summary, "active summary");
+    assert.deepEqual(result.contextEntries.map((entry) => entry.id), ["kept", "after", "leaf"]);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("does not migrate a small, unsupported, or structurally invalid session", () => {
+  const cases = [
+    [header, message("one", null, "small")],
+    [{ ...header, version: 2 }, message("kept", null, "old"), {
+      type: "compaction", id: "comp", parentId: "kept", firstKeptEntryId: "kept", summary: "summary"
+    }],
+    [header, message("leaf", "missing-parent", "broken"), {
+      type: "compaction", id: "comp", parentId: "leaf", firstKeptEntryId: "leaf", summary: "summary"
+    }]
+  ];
+  for (const entries of cases) {
+    const { dir, file } = writeSession(entries);
+    try {
+      const threshold = entries === cases[0] ? 1024 * 1024 : 1;
+      assert.equal(inspectSessionForPreloadMigration(file, threshold), null);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+});

package/test/session-preload-migration.test.js

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import {
+  createPreloadMigrationChild,
+  migrateRecentSessionBeforeLoad
+} from "../src/core/agent/session-preload-migration.js";
+
+function sourceMessage(id, parentId, role, text) {
+  return {
+    type: "message",
+    id,
+    parentId,
+    timestamp: "2026-08-28T00:00:00.000Z",
+    message: { role, content: [{ type: "text", text }] }
+  };
+}
+
+function writeEntries(file, entries) {
+  writeFileSync(file, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf8");
+}
+
+test("atomically creates a valid child session with a durable parent reference", () => {
+  const sessionDir = mkdtempSync(path.join(tmpdir(), "arisa-session-migration-"));
+  try {
+    const result = createPreloadMigrationChild({
+      sessionDir,
+      cwd: "/workspace",
+      migration: {
+        sourceFile: path.join(sessionDir, "historical.jsonl"),
+        sourceBytes: 80 * 1024 * 1024,
+        summary: "compacted history",
+        contextEntries: [
+          sourceMessage("old-user", null, "user", "recent question"),
+          { type: "label", id: "ignored", parentId: "old-user", targetId: "old-user", label: "old" },
+          sourceMessage("old-assistant", "old-user", "assistant", "recent answer")
+        ]
+      },
+      operationalNotes: "Durable operating notes:\n- keep history",
+      now: new Date("2026-08-28T12:00:00.000Z")
+    });
+
+    assert.equal(result.copiedEntries, 2);
+    assert.equal(readdirSync(sessionDir).some((name) => name.endsWith(".tmp")), false);
+    const entries = readFileSync(result.targetFile, "utf8").trim().split("\n").map(JSON.parse);
+    assert.equal(entries[0].parentSession, result.sourceFile);
+    assert.deepEqual(entries.slice(1).map((entry) => entry.parentId), [
+      null,
+      entries[1].id,
+      entries[2].id,
+      entries[3].id
+    ]);
+    assert.equal(entries[2].details.source, "preload-migration");
+
+    const manager = SessionManager.open(result.targetFile, sessionDir, "/workspace");
+    const messages = manager.buildSessionContext().messages;
+    assert.deepEqual(messages.map((message) => message.role), ["custom", "custom", "user", "assistant"]);
+    assert.match(messages[1].content, /compacted history/);
+  } finally {
+    rmSync(sessionDir, { recursive: true, force: true });
+  }
+});
+
+test("pre-load migration commits once and a restart selects the compact child", () => {
+  const sessionDir = mkdtempSync(path.join(tmpdir(), "arisa-session-recovery-"));
+  const sourceFile = path.join(sessionDir, "historical.jsonl");
+  try {
+    writeEntries(sourceFile, [
+      { type: "session", version: 3, id: "old", timestamp: "2026-08-28T00:00:00.000Z", cwd: "/workspace" },
+      sourceMessage("historical", null, "user", "x".repeat(8_000)),
+      sourceMessage("kept", "historical", "user", "recent"),
+      {
+        type: "compaction",
+        id: "compaction",
+        parentId: "kept",
+        firstKeptEntryId: "kept",
+        summary: "bounded summary"
+      },
+      sourceMessage("leaf", "compaction", "assistant", "answer")
+    ]);
+
+    const first = migrateRecentSessionBeforeLoad({
+      sessionDir,
+      cwd: "/workspace",
+      policy: { maxPersistedBytes: 2_000 },
+      operationalNotes: "notes"
+    });
+    assert.equal(first.sourceFile, sourceFile);
+    assert.ok(first.targetBytes < 2_000);
+    assert.equal(migrateRecentSessionBeforeLoad({
+      sessionDir,
+      cwd: "/workspace",
+      policy: { maxPersistedBytes: 2_000 }
+    }), null);
+    const resumed = SessionManager.continueRecent("/workspace", sessionDir);
+    assert.equal(resumed.getSessionFile(), first.targetFile);
+  } finally {
+    rmSync(sessionDir, { recursive: true, force: true });
+  }
+});
+
+test("refuses to load an oversized session when no safe compaction checkpoint exists", () => {
+  const sessionDir = mkdtempSync(path.join(tmpdir(), "arisa-session-refusal-"));
+  try {
+    writeEntries(path.join(sessionDir, "unsafe.jsonl"), [
+      { type: "session", version: 3, id: "unsafe", timestamp: "2026-08-28T00:00:00.000Z", cwd: "/workspace" },
+      sourceMessage("leaf", null, "user", "x".repeat(4_000))
+    ]);
+    assert.throws(() => migrateRecentSessionBeforeLoad({
+      sessionDir,
+      cwd: "/workspace",
+      policy: { maxPersistedBytes: 1_000 }
+    }), (error) => error.code === "PI_SESSION_PRELOAD_MIGRATION_UNAVAILABLE");
+  } finally {
+    rmSync(sessionDir, { recursive: true, force: true });
+  }
+});

package/test/session-rotation.test.js

@@ -0,0 +1,110 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { applyConfigDefaults } from "../src/core/config/config-defaults.js";
+import { AgentManager } from "../src/core/agent/agent-manager.js";
+import { compactionRotationRequest, normalizeSessionRotationPolicy } from "../src/core/agent/session-rotation.js";
+
+const mebibyte = 1024 * 1024;
+
+function compactionEvent(summary = "checkpoint") {
+  return {
+    type: "compaction_end",
+    aborted: false,
+    errorMessage: "",
+    result: { summary }
+  };
+}
+
+test("normalizes the automatic session rotation policy", () => {
+  assert.deepEqual(normalizeSessionRotationPolicy(), {
+    enabled: true,
+    compactAtPersistedBytes: 24 * mebibyte,
+    maxPersistedBytes: 32 * mebibyte
+  });
+  assert.deepEqual(normalizeSessionRotationPolicy({
+    enabled: false,
+    compactAtPersistedBytes: 8,
+    maxPersistedBytes: 12
+  }), {
+    enabled: false,
+    compactAtPersistedBytes: 8,
+    maxPersistedBytes: 12
+  });
+});
+
+test("requests rotation only after a successful oversized compaction", () => {
+  assert.equal(compactionRotationRequest(compactionEvent(), 24 * mebibyte), null);
+  assert.equal(compactionRotationRequest({ ...compactionEvent(), aborted: true }, 25 * mebibyte), null);
+  assert.equal(compactionRotationRequest(compactionEvent(), 25 * mebibyte, { enabled: false }), null);
+  const request = compactionRotationRequest(compactionEvent("latest summary"), 25 * mebibyte);
+  assert.equal(request.persistedBytes, 25 * mebibyte);
+  assert.match(request.handoff, /latest summary/);
+});
+
+test("compacts at the preventive persisted-size threshold and then rotates", async () => {
+  const config = applyConfigDefaults({ telegram: {}, pi: { provider: "test", model: "test" } });
+  const manager = new AgentManager({
+    config,
+    artifactStore: {},
+    toolRegistry: {},
+    taskStore: {},
+    logger: null
+  });
+  let compactions = 0;
+  const context = {
+    activeUsers: 1,
+    session: {
+      sessionFile: "/sessions/preventive.jsonl",
+      async compact() {
+        compactions += 1;
+        manager.scheduleCompactionRotationCheck("chat", context, compactionEvent("preventive summary"));
+      },
+      async close() {}
+    },
+    rotationCheckPromise: Promise.resolve(),
+    rotationRequest: null
+  };
+  manager.sessions.set("chat", context);
+  manager.estimatePersistedSessionBytes = async () => 25 * mebibyte;
+
+  await manager.releaseSessionContext("chat", context);
+
+  assert.equal(compactions, 1);
+  assert.equal(manager.sessions.has("chat"), false);
+  assert.equal(manager.pendingNewSessions.has("chat"), true);
+});
+
+test("rotates after active work releases and preserves the parent session path", async () => {
+  const config = applyConfigDefaults({ telegram: {}, pi: { provider: "test", model: "test" } });
+  let closes = 0;
+  const manager = new AgentManager({
+    config,
+    artifactStore: {},
+    toolRegistry: {},
+    taskStore: {},
+    logger: null
+  });
+  const context = {
+    activeUsers: 1,
+    session: {
+      sessionFile: "/sessions/oversized.jsonl",
+      async close() { closes += 1; }
+    },
+    rotationCheckPromise: Promise.resolve(),
+    rotationRequest: null
+  };
+  manager.sessions.set("chat", context);
+  manager.estimatePersistedSessionBytes = async () => 65 * mebibyte;
+
+  manager.scheduleCompactionRotationCheck("chat", context, compactionEvent("handoff summary"));
+  await manager.releaseSessionContext("chat", context);
+
+  assert.equal(closes, 1);
+  assert.equal(manager.sessions.has("chat"), false);
+  assert.equal(manager.pendingNewSessions.has("chat"), true);
+  assert.deepEqual(manager.pendingSessionHandoffs.get("chat"), {
+    text: "Automatic session rotation after compaction. Continue from this checkpoint:\n\nhandoff summary",
+    parentSession: "/sessions/oversized.jsonl",
+    source: "compaction-rotation"
+  });
+});