clawdbot-d02.1.9.1.39: add task session registry maintenance seam (#93734)

jalehman · web-flow · commit 784518241040 · 2026-06-18T14:36:10.000-07:00
diff --git a/scripts/check-session-accessor-boundary.mjs b/scripts/check-session-accessor-boundary.mjs
@@ -68,6 +68,7 @@ export const migratedSessionAccessorFiles = new Set([
   "src/commands/sessions.ts",
   "src/commands/status.agent-local.ts",
   "src/commands/status.summary.ts",
+  "src/commands/tasks.ts",
   "src/config/sessions/combined-store-gateway.ts",
   "src/cron/isolated-agent/delivery-target.ts",
   "src/cron/service/timer.ts",
@@ -108,9 +109,10 @@ export const migratedSessionAccessorWriteFiles = new Set([
   "src/auto-reply/reply/session-reset-model.ts",
   "src/auto-reply/reply/session-updates.ts",
   "src/auto-reply/reply/session-usage.ts",
-  "src/tui/embedded-backend.ts",
+  "src/commands/tasks.ts",
   "src/config/sessions/cleanup-service.ts",
   "src/plugins/host-hook-cleanup.ts",
+  "src/tui/embedded-backend.ts",
 ]);
 
 export const migratedTranscriptWriterFiles = new Set([
@@ -336,6 +338,7 @@ export async function main() {
   const writeSourceRoots = resolveSourceRoots(repoRoot, [
     "src/agents",
     "src/auto-reply",
+    "src/commands",
     "src/config/sessions",
     "src/plugins",
     "src/tui",
diff --git a/src/commands/tasks.ts b/src/commands/tasks.ts
@@ -1,23 +1,18 @@
 // Human-facing background task commands.
 // Handles task listing/show/cancel/notify/audit plus registry maintenance for tasks, flows, and sessions.
 
-import fs from "node:fs";
 import { timestampMsToIsoString } from "@openclaw/normalization-core/number-coercion";
 import { normalizeOptionalString } from "@openclaw/normalization-core/string-coerce";
 import { isRich, theme } from "../../packages/terminal-core/src/theme.js";
 import { formatCliCommand } from "../cli/command-format.js";
 import { formatLookupMiss } from "../cli/error-format.js";
 import { getRuntimeConfig } from "../config/config.js";
 import {
-  loadSessionStore,
-  pruneStaleEntries,
   resolveAllAgentSessionStoreTargetsSync,
-  updateSessionStore,
-  type SessionEntry,
+  runSessionRegistryMaintenanceForStore,
 } from "../config/sessions.js";
 import { loadCronJobsStoreSync, resolveCronJobsStorePath } from "../cron/store.js";
 import type { RuntimeEnv } from "../runtime.js";
-import { parseAgentSessionKey } from "../sessions/session-key-utils.js";
 import { getTaskById, updateTaskNotifyPolicyById } from "../tasks/runtime-internal.js";
 import { cancelDetachedTaskRunById } from "../tasks/task-executor.js";
 import { listTaskFlowAuditFindings } from "../tasks/task-flow-registry.audit.js";
@@ -133,14 +128,6 @@ type SessionRegistryMaintenanceSummary = {
   stores: SessionRegistryMaintenanceStoreSummary[];
 };
 
-function parseCronRunSessionJobId(sessionKey: string): string | undefined {
-  const parsed = parseAgentSessionKey(sessionKey);
-  if (!parsed) {
-    return undefined;
-  }
-  return /^cron:([^:]+):run:[^:]+$/u.exec(parsed.rest)?.[1];
-}
-
 function readRunningCronJobIds(): Set<string> {
   try {
     const cronStorePath = resolveCronJobsStorePath(getRuntimeConfig().cron?.store);
@@ -155,95 +142,26 @@ function readRunningCronJobIds(): Set<string> {
   }
 }
 
-function buildSessionRegistryPreserveKeys(params: {
-  store: Record<string, SessionEntry>;
-  runningCronJobIds: ReadonlySet<string>;
-}): { preserveKeys: Set<string>; preservedRunning: number } {
-  const preserveKeys = new Set<string>();
-  let preservedRunning = 0;
-  for (const key of Object.keys(params.store)) {
-    const jobId = parseCronRunSessionJobId(key);
-    if (!jobId) {
-      // Non-cron session rows are outside this maintenance pass; preserve them.
-      preserveKeys.add(key);
-      continue;
-    }
-    if (params.runningCronJobIds.has(jobId)) {
-      preserveKeys.add(key);
-      preservedRunning += 1;
-    }
-  }
-  return { preserveKeys, preservedRunning };
-}
-
 async function runSessionRegistryMaintenance(params: {
   apply: boolean;
 }): Promise<SessionRegistryMaintenanceSummary> {
   const cfg = getRuntimeConfig();
   const runningCronJobIds = readRunningCronJobIds();
   const stores: SessionRegistryMaintenanceStoreSummary[] = [];
   for (const target of resolveAllAgentSessionStoreTargetsSync(cfg)) {
-    if (!fs.existsSync(target.storePath)) {
-      stores.push({
-        agentId: target.agentId,
-        storePath: target.storePath,
-        beforeCount: 0,
-        afterCount: 0,
-        pruned: 0,
-        preservedRunning: 0,
-      });
-      continue;
-    }
-    const beforeStore = loadSessionStore(target.storePath, { skipCache: true });
-    const beforeCount = Object.keys(beforeStore).length;
-    if (params.apply) {
-      // Apply mode mutates each store atomically through updateSessionStore.
-      const applied = await updateSessionStore(
-        target.storePath,
-        (store) => {
-          const { preserveKeys, preservedRunning } = buildSessionRegistryPreserveKeys({
-            store,
-            runningCronJobIds,
-          });
-          const pruned = pruneStaleEntries(store, SESSION_REGISTRY_RETENTION_MS, {
-            log: false,
-            preserveKeys,
-          });
-          return {
-            pruned,
-            afterCount: Object.keys(store).length,
-            preservedRunning,
-          };
-        },
-        { skipMaintenance: true },
-      );
-      stores.push({
-        agentId: target.agentId,
-        storePath: target.storePath,
-        beforeCount,
-        afterCount: applied.afterCount,
-        pruned: applied.pruned,
-        preservedRunning: applied.preservedRunning,
-      });
-      continue;
-    }
-    const previewStore = structuredClone(beforeStore);
-    // Preview mode runs pruning against a clone so dry-run output cannot change stores.
-    const { preserveKeys, preservedRunning } = buildSessionRegistryPreserveKeys({
-      store: previewStore,
+    const result = await runSessionRegistryMaintenanceForStore({
+      apply: params.apply,
+      retentionMs: SESSION_REGISTRY_RETENTION_MS,
       runningCronJobIds,
-    });
-    const pruned = pruneStaleEntries(previewStore, SESSION_REGISTRY_RETENTION_MS, {
-      log: false,
-      preserveKeys,
+      storePath: target.storePath,
     });
     stores.push({
       agentId: target.agentId,
       storePath: target.storePath,
-      beforeCount,
-      afterCount: Object.keys(previewStore).length,
-      pruned,
-      preservedRunning,
+      beforeCount: result.beforeCount,
+      afterCount: result.afterCount,
+      pruned: result.pruned,
+      preservedRunning: result.preservedRunning,
     });
   }
   return {
diff --git a/src/config/sessions.ts b/src/config/sessions.ts
@@ -26,6 +26,7 @@ export * from "./sessions/types.js";
 export * from "./sessions/transcript.js";
 export * from "./sessions/session-file.js";
 export * from "./sessions/session-file-rotation.js";
+export * from "./sessions/session-registry-maintenance.js";
 export * from "./sessions/delivery-info.js";
 export * from "./sessions/disk-budget.js";
 export * from "./sessions/targets.js";
diff --git a/src/config/sessions/session-registry-maintenance.test.ts b/src/config/sessions/session-registry-maintenance.test.ts
@@ -0,0 +1,126 @@
+// Session registry maintenance tests cover the task-owned cron-run pruning seam.
+import fs from "node:fs/promises";
+import path from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { createFixtureSuite } from "../../test-utils/fixture-suite.js";
+import { runSessionRegistryMaintenanceForStore } from "./session-registry-maintenance.js";
+import { loadSessionStore, saveSessionStore } from "./store.js";
+import type { SessionEntry } from "./types.js";
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const fixtureSuite = createFixtureSuite("openclaw-session-registry-maintenance-");
+
+beforeAll(async () => {
+  await fixtureSuite.setup();
+});
+
+afterAll(async () => {
+  await fixtureSuite.cleanup();
+});
+
+function sessionEntry(sessionId: string, updatedAt: number): SessionEntry {
+  return { sessionId, updatedAt };
+}
+
+async function createStore(entries: Record<string, SessionEntry>): Promise<string> {
+  const dir = await fixtureSuite.createCaseDir("store");
+  const storePath = path.join(dir, "sessions.json");
+  await fs.mkdir(dir, { recursive: true });
+  await saveSessionStore(storePath, entries, { skipMaintenance: true });
+  return storePath;
+}
+
+describe("runSessionRegistryMaintenanceForStore", () => {
+  it("summarizes a missing store without creating it", async () => {
+    const dir = await fixtureSuite.createCaseDir("missing-store");
+    const storePath = path.join(dir, "sessions.json");
+
+    const result = await runSessionRegistryMaintenanceForStore({
+      apply: true,
+      retentionMs: 7 * DAY_MS,
+      runningCronJobIds: new Set(),
+      storePath,
+    });
+
+    expect(result).toEqual({
+      beforeCount: 0,
+      afterCount: 0,
+      preservedRunning: 0,
+      pruned: 0,
+    });
+    await expect(fs.stat(storePath)).rejects.toMatchObject({ code: "ENOENT" });
+  });
+
+  it("previews stale cron-run pruning without mutating the store", async () => {
+    const now = Date.now();
+    const storePath = await createStore({
+      "agent:main:cron:done-job:run:old-run": sessionEntry("old-run", now - 8 * DAY_MS),
+      "agent:main:cron:done-job:run:recent-run": sessionEntry("recent-run", now),
+    });
+
+    const result = await runSessionRegistryMaintenanceForStore({
+      apply: false,
+      retentionMs: 7 * DAY_MS,
+      runningCronJobIds: new Set(),
+      storePath,
+    });
+
+    expect(result).toEqual({
+      beforeCount: 2,
+      afterCount: 1,
+      preservedRunning: 0,
+      pruned: 1,
+    });
+    expect(loadSessionStore(storePath, { skipCache: true })).toHaveProperty(
+      "agent:main:cron:done-job:run:old-run",
+    );
+  });
+
+  it("applies one store-sized pruning transaction and preserves running cron rows", async () => {
+    const now = Date.now();
+    const storePath = await createStore({
+      "agent:main:cron:done-job:run:old-run": sessionEntry("done-run", now - 8 * DAY_MS),
+      "agent:main:cron:running-job:run:old-run": sessionEntry("running-run", now - 8 * DAY_MS),
+      "agent:main:cron:done-job:run:recent-run": sessionEntry("recent-run", now),
+    });
+
+    const result = await runSessionRegistryMaintenanceForStore({
+      apply: true,
+      retentionMs: 7 * DAY_MS,
+      runningCronJobIds: new Set(["running-job"]),
+      storePath,
+    });
+
+    expect(result).toEqual({
+      beforeCount: 3,
+      afterCount: 2,
+      preservedRunning: 1,
+      pruned: 1,
+    });
+    const updated = loadSessionStore(storePath, { skipCache: true });
+    expect(updated["agent:main:cron:done-job:run:old-run"]).toBeUndefined();
+    expect(updated).toHaveProperty("agent:main:cron:running-job:run:old-run");
+    expect(updated).toHaveProperty("agent:main:cron:done-job:run:recent-run");
+  });
+
+  it("skips generic session maintenance while applying task registry pruning", async () => {
+    const now = Date.now();
+    const oldOrdinaryKey = "agent:main:subagent:old-worker";
+    const storePath = await createStore({
+      "agent:main:cron:done-job:run:old-run": sessionEntry("done-run", now - 8 * DAY_MS),
+      [oldOrdinaryKey]: sessionEntry("old-worker", now - 40 * DAY_MS),
+    });
+
+    const result = await runSessionRegistryMaintenanceForStore({
+      apply: true,
+      retentionMs: 7 * DAY_MS,
+      runningCronJobIds: new Set(),
+      storePath,
+    });
+
+    expect(result.pruned).toBe(1);
+    const updated = loadSessionStore(storePath, { skipCache: true });
+    expect(updated["agent:main:cron:done-job:run:old-run"]).toBeUndefined();
+    expect(updated).toHaveProperty(oldOrdinaryKey);
+  });
+});
diff --git a/src/config/sessions/session-registry-maintenance.ts b/src/config/sessions/session-registry-maintenance.ts
diff --git a/test/scripts/check-session-accessor-boundary.test.ts b/test/scripts/check-session-accessor-boundary.test.ts
