// 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";

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);

}

}

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 {