arisa 5.2.20 → 5.2.22

package/LOW-MEMORY.md

@@ -20,6 +20,18 @@ A committed database has schema version 1. Subsequent operations do not read or
 
 Back up the SQLite database with SQLite's backup API, or stop all writers and copy it along with any journal files. Preserve artifact files separately. A rollback to an older JSON-only core requires stopping all writers, backing up the database, and streaming `SELECT data FROM artifacts ORDER BY seq` into a new JSON array. Fsync and atomically replace the legacy index only after export succeeds. Do not simply revert the code and resume writes to the old JSON snapshot.
 
+## Task storage
+
+`tasksDatabaseFile` identifies the live global scheduler database (`tasks.sqlite`); `tasksFile` is now only the legacy `tasks.json` migration source. Tools must use task IPC rather than read either file directly.
+
+- Due claims use a partial index for pending/authentication-blocked tasks. ID mutations only load and update the selected row; an idle poll does not parse terminal history or rewrite the queue.
+- Claim/read/update occurs in one synchronous `BEGIN IMMEDIATE` transaction, including across processes. Connections close after each operation, with a 1 MiB page cache, mmap disabled, FULL synchronous commits and a 5-second lock timeout. No asynchronous work runs while holding the write lock.
+- First access imports the legacy array atomically and records schema version 1. This one-time import still loads the legacy array in memory. Startup recovery and unbounded history listing also remain proportional to history size; they are not the per-second hot path.
+- Missing legacy input means a fresh database. Malformed input, duplicate IDs, invalid identities, unsupported schemas and unreadable databases fail explicitly instead of silently becoming an empty queue.
+- The legacy file stays unchanged and is never reimported after a successful migration. Routes, auth blocks, retry state and interrupted-execution semantics are preserved. Do not run old JSON-writing workers alongside a migrated scheduler.
+
+Back up using SQLite's backup API or stop all writers before copying the database and any journal. To downgrade, stop all writers and export `SELECT data FROM tasks ORDER BY seq` into a new UTF-8 JSON array, fsync and atomically replace `tasks.json` before starting the old core. The retained legacy JSON does not include subsequent changes and is not a safe downgrade by itself.
+
 ## Daemons
 
 Keep external ingress daemons running. Request-driven tools should use `autoStart: false` in both their manifest and runtime registration, start through the shared runtime when invoked, and stop when idle. Otherwise the supervisor will repeatedly restart a daemon that deliberately stopped for inactivity. Do not disable ingress or drop sessions to improve a memory benchmark.
@@ -32,6 +44,6 @@ Run the test suite serially on 1 GiB hosts:
 node --test --test-concurrency=1
 ```
 
-`test/artifact-index-memory.test.js` migrates a 100 MiB index and runs 300 subsequent operations in a child with a 48 MiB V8 heap. Migration tests cover UTF-8 chunk boundaries, escaping, corruption, rollback/retry, stable IDs, ordering and concurrent writers in separate processes. `test/cli-memory.test.js` runs the status command with a 24 MiB heap.
+`test/artifact-index-memory.test.js` migrates a 100 MiB index and runs 300 subsequent operations in a child with a 48 MiB V8 heap. Migration tests cover UTF-8 chunk boundaries, escaping, corruption, rollback/retry, stable IDs, ordering and concurrent writers in separate processes. `test/cli-memory.test.js` runs the status command with a 24 MiB heap. `test/task-database.test.js` checks atomic migration, corruption, separate-process claims and 200 idle polls under a 32 MiB heap with approximately 60 MB of terminal history; idle polling must not rewrite the database.
 
 After deployment, check a real scheduled tool result, PID continuity, daemon health, `free -h`, `vmstat 1`, and `/proc/pressure/memory`. Short observations cannot establish long-term stability or guarantee that every browser workload fits this host.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "5.2.20",
+  "version": "5.2.22",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

package/src/core/agent/agent-turn-coordinator.js

@@ -30,6 +30,12 @@ export class AgentTurnCoordinator {
     this.expired = 0;
     this.maxObservedQueue = 0;
     this.totalWaitMs = 0;
+    this.lastInteractiveActivityAt = 0;
+    this.backgroundWakeTimer = null;
+    this.priorityStats = {
+      interactive: { queued: 0, started: 0, completed: 0, expired: 0, totalWaitMs: 0, maxWaitMs: 0 },
+      background: { queued: 0, started: 0, completed: 0, expired: 0, totalWaitMs: 0, maxWaitMs: 0 }
+    };
     this.setConfig(config);
   }
 
@@ -38,6 +44,7 @@ export class AgentTurnCoordinator {
       enabled: config.enabled !== false,
       backgroundQueueTtlMs: positiveInteger(config.backgroundQueueTtlMs, 10 * 60_000, 60 * 60_000),
       interactiveQueueTtlMs: positiveInteger(config.interactiveQueueTtlMs, 0, 60 * 60_000),
+      interactiveQuietMs: positiveInteger(config.interactiveQuietMs, 0, 60_000),
       maxQueued: Math.max(1, positiveInteger(config.maxQueued, 100, 1_000))
     };
   }
@@ -53,14 +60,24 @@ export class AgentTurnCoordinator {
   }
 
   diagnostic() {
+    const priorities = Object.fromEntries(Object.entries(this.priorityStats).map(([name, stats]) => [name, {
+      queued: stats.queued,
+      started: stats.started,
+      completed: stats.completed,
+      expired: stats.expired,
+      averageWaitMs: stats.started ? Math.round(stats.totalWaitMs / stats.started) : 0,
+      maxWaitMs: stats.maxWaitMs
+    }]));
     return {
       enabled: this.config.enabled,
       active: this.describeActive(this.active),
       queued: this.queue.length,
+      queuedInteractive: this.queue.filter((entry) => entry.priorityName === "interactive").length,
       maxObservedQueue: this.maxObservedQueue,
       completed: this.completed,
       expired: this.expired,
-      averageWaitMs: this.completed ? Math.round(this.totalWaitMs / this.completed) : 0
+      averageWaitMs: this.completed ? Math.round(this.totalWaitMs / this.completed) : 0,
+      priorities
     };
   }
 
@@ -69,14 +86,42 @@ export class AgentTurnCoordinator {
     if (index >= 0) this.queue.splice(index, 1);
   }
 
+  clearBackgroundWake() {
+    if (!this.backgroundWakeTimer) return;
+    clearTimeout(this.backgroundWakeTimer);
+    this.backgroundWakeTimer = null;
+  }
+
+  deferBackground(delayMs) {
+    if (this.backgroundWakeTimer) return;
+    this.backgroundWakeTimer = setTimeout(() => {
+      this.backgroundWakeTimer = null;
+      this.next();
+    }, delayMs);
+    this.backgroundWakeTimer.unref?.();
+  }
+
   next() {
     if (this.active || this.closed || !this.queue.length) return;
     this.queue.sort((left, right) => right.priority - left.priority || left.sequence - right.sequence);
-    const entry = this.queue.shift();
+    const entry = this.queue[0];
+    if (entry.priorityName === "background") {
+      const quietRemainingMs = this.lastInteractiveActivityAt + this.config.interactiveQuietMs - this.now();
+      if (quietRemainingMs > 0) {
+        this.deferBackground(quietRemainingMs);
+        return;
+      }
+    }
+    this.clearBackgroundWake();
+    this.queue.shift();
     if (entry.timer) clearTimeout(entry.timer);
     entry.startedAt = new Date(this.now()).toISOString();
     this.active = entry;
     const waitMs = Math.max(0, this.now() - entry.queuedAt);
+    const stats = this.priorityStats[entry.priorityName];
+    stats.started += 1;
+    stats.totalWaitMs += waitMs;
+    stats.maxWaitMs = Math.max(stats.maxWaitMs, waitMs);
     this.totalWaitMs += waitMs;
     if (waitMs > 0) this.logger?.log("agent", `${entry.label} waited ${waitMs}ms for exclusive agent execution`);
     let released = false;
@@ -85,6 +130,8 @@ export class AgentTurnCoordinator {
       released = true;
       if (this.active === entry) this.active = null;
       this.completed += 1;
+      stats.completed += 1;
+      if (entry.priorityName === "interactive") this.lastInteractiveActivityAt = this.now();
       queueMicrotask(() => this.next());
     });
   }
@@ -96,11 +143,12 @@ export class AgentTurnCoordinator {
       return Promise.reject(Object.assign(new Error("Agent turn queue is full."), { code: "AGENT_TURN_QUEUE_FULL", retryable: true }));
     }
     const priority = normalizedPriority(priorityName);
+    const normalizedPriorityName = priorityName === "interactive" ? "interactive" : "background";
     const ttlMs = this.queueTtlMs(priorityName, queueTtlMs);
     return new Promise((resolve, reject) => {
       const entry = {
         label: String(label || "Agent turn").slice(0, 160),
-        priorityName: priorityName === "interactive" ? "interactive" : "background",
+        priorityName: normalizedPriorityName,
         priority,
         sequence: this.sequence += 1,
         queuedAt: this.now(),
@@ -114,11 +162,18 @@ export class AgentTurnCoordinator {
           if (this.active === entry) return;
           this.remove(entry);
           this.expired += 1;
+          this.priorityStats[entry.priorityName].expired += 1;
           reject(queueExpiredError(entry.label));
+          queueMicrotask(() => this.next());
         }, ttlMs);
         entry.timer.unref?.();
       }
       this.queue.push(entry);
+      this.priorityStats[entry.priorityName].queued += 1;
+      if (entry.priorityName === "interactive") {
+        this.lastInteractiveActivityAt = this.now();
+        this.clearBackgroundWake();
+      }
       this.maxObservedQueue = Math.max(this.maxObservedQueue, this.queue.length);
       this.next();
     });
@@ -135,6 +190,7 @@ export class AgentTurnCoordinator {
 
   close() {
     this.closed = true;
+    this.clearBackgroundWake();
     for (const entry of this.queue.splice(0)) {
       if (entry.timer) clearTimeout(entry.timer);
       entry.reject(Object.assign(new Error("Agent turn coordinator closed before execution."), { retryable: true }));

package/src/core/agent/auth-flow.js

@@ -33,6 +33,15 @@ export function getPiAuthIssue(error) {
   return null;
 }
 
+export function buildPiRequestFailureMessage(error) {
+  const message = getErrorMessage(error);
+  const limited = /usage limit|quota|rate[ _-]?limit|too many requests|insufficient[_ ]credits|credits? (?:exhausted|depleted)/i.test(message);
+  const title = limited
+    ? "The provider's usage quota or request limit was reached. Retry when capacity is available; signing in again does not restore quota."
+    : "Pi request could not be completed. This does not establish an authentication failure.";
+  return `${title}\nDetails: ${message}`;
+}
+
 export async function getPiAuthStatus(config, chatId = null) {
   const runtime = await createPiRuntime({
     provider: config.pi.provider,

package/src/core/config/config-defaults.js

@@ -12,6 +12,9 @@ export const daemonConfigDefaults = Object.freeze({
   startupTimeoutMs: 120_000,
   stopTimeoutMs: 3_000,
   queuePollIntervalMs: 250,
+  journalRetentionMs: 24 * 60 * 60_000,
+  journalMaxCompleted: 2_048,
+  journalSweepIntervalMs: 5 * 60_000,
   streamBufferBytes: 1_048_576,
   ipcFrameBytes: 1_048_576
 });
@@ -94,6 +97,7 @@ export const piConfigDefaults = Object.freeze({
     enabled: true,
     backgroundQueueTtlMs: 10 * 60_000,
     interactiveQueueTtlMs: 0,
+    interactiveQuietMs: 2_000,
     maxQueued: 100
   }),
   compaction: Object.freeze({

package/src/core/tasks/task-database.js

@@ -0,0 +1,128 @@
+import { chmodSync, mkdirSync, readFileSync, closeSync, openSync } from "node:fs";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { tasksDatabaseFile, tasksFile } from "../../platform/paths.js";
+
+function createPrivateFile(file) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  try {
+    closeSync(openSync(file, "wx", 0o600));
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  chmodSync(file, 0o600);
+}
+
+function legacyTasks(file) {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const tasks = JSON.parse(text);
+  if (!Array.isArray(tasks)) throw new Error("Legacy task storage must contain an array");
+  return tasks;
+}
+
+function taskValues(task) {
+  if (!task || typeof task.id !== "string" || !task.id || typeof task.status !== "string") {
+    throw new Error("Invalid task identity or status");
+  }
+  return [task.id, task.status, String(task.payload?.chatId ?? ""), task.kind ?? null,
+    Number.isFinite(Date.parse(task.runAt)) ? Date.parse(task.runAt) : null,
+    Number.isFinite(Date.parse(task.createdAt)) ? Date.parse(task.createdAt) : 0,
+    JSON.stringify(task)];
+}
+
+export function insertTask(db, task) {
+  db.prepare("INSERT INTO tasks (id, status, chat_id, kind, run_at, created_at, data) VALUES (?, ?, ?, ?, ?, ?, ?)")
+    .run(...taskValues(task));
+}
+
+export function transaction(db, operation) {
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    const result = operation();
+    db.exec("COMMIT");
+    return result;
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+}
+
+function initialize(db, legacyFile, migrate) {
+  const version = () => db.prepare("PRAGMA user_version").get().user_version;
+  if (version() === 1) return;
+  if (version() !== 0) throw new Error("Unsupported task database version");
+  transaction(db, () => {
+    if (version() !== 0) return;
+    db.exec(`CREATE TABLE tasks (
+      seq INTEGER PRIMARY KEY, id TEXT NOT NULL UNIQUE, status TEXT NOT NULL,
+      chat_id TEXT NOT NULL, kind TEXT, run_at INTEGER, created_at INTEGER NOT NULL, data TEXT NOT NULL
+    );
+    CREATE INDEX tasks_due ON tasks(run_at, created_at, id) WHERE status IN ('pending', 'blocked_auth');
+    CREATE INDEX tasks_chat ON tasks(chat_id, status);
+    CREATE INDEX tasks_status ON tasks(status);`);
+    for (const task of legacyTasks(legacyFile)) insertTask(db, migrate(task));
+    db.exec("PRAGMA user_version = 1");
+  });
+}
+
+// All work is synchronous inside a connection/transaction. No lock is held across
+// an await; separate processes use SQLite locking, not an in-process promise queue.
+export function withTaskDatabase(migrate, operation, {
+  databaseFile = tasksDatabaseFile, legacyFile = tasksFile
+} = {}) {
+  createPrivateFile(databaseFile);
+  const db = new DatabaseSync(databaseFile);
+  try {
+    db.exec("PRAGMA busy_timeout = 5000; PRAGMA cache_size = -1024; PRAGMA mmap_size = 0; PRAGMA synchronous = FULL");
+    initialize(db, legacyFile, migrate);
+    return operation(db);
+  } catch (error) {
+    throw new Error(`Task storage operation failed: ${databaseFile}`, { cause: error });
+  } finally {
+    db.close();
+  }
+}
+
+export function selectTasks(db, filter = {}) {
+  if (filter.empty) return [];
+  const conditions = [];
+  const values = [];
+  for (const [key, column] of [["id", "id"], ["chatId", "chat_id"], ["status", "status"], ["kind", "kind"]]) {
+    if (filter[key]) {
+      conditions.push(`${column} = ?`);
+      values.push(String(filter[key]));
+    }
+  }
+  let order = "seq";
+  let limit = "";
+  if (filter.due) {
+    conditions.push("status IN ('pending', 'blocked_auth')", "run_at <= ?");
+    values.push(filter.due.now);
+    order = "run_at, created_at, id";
+    limit = " LIMIT ?";
+    values.push(filter.due.limit);
+  }
+  return db.prepare(`SELECT data FROM tasks ${filter.due ? "INDEXED BY tasks_due" : ""} ${conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""} ORDER BY ${order}${limit}`)
+    .all(...values).map((row) => JSON.parse(row.data));
+}
+
+export function persistTaskChanges(db, before, tasks) {
+  const remaining = new Set(tasks.map((task) => task.id));
+  for (const id of before.keys()) {
+    if (!remaining.has(id)) db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+  }
+  for (const task of tasks) {
+    if (!before.has(task.id)) insertTask(db, task);
+    else if (before.get(task.id) !== JSON.stringify(task)) {
+      const [id, ...values] = taskValues(task);
+      db.prepare("UPDATE tasks SET status = ?, chat_id = ?, kind = ?, run_at = ?, created_at = ?, data = ? WHERE id = ?")
+        .run(...values, id);
+    }
+  }
+}

package/src/core/tasks/task-store.js

@@ -1,7 +1,5 @@
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import path from "node:path";
 import crypto from "node:crypto";
-import { tasksFile } from "../../platform/paths.js";
+import { withTaskDatabase, transaction, selectTasks, persistTaskChanges } from "./task-database.js";
 
 const DEFAULT_RETRY = Object.freeze({
   maxAttempts: 3,
@@ -13,43 +11,6 @@ const DEFAULT_RETRY = Object.freeze({
 const TERMINAL_STATUSES = new Set(["done", "failed", "outcome_uncertain"]);
 const TERMINAL_PAYLOAD_KEYS = ["chatId", "toolName", "resourceId", "artifactId"];
 
-const taskFileOperations = new Map();
-
-async function serializeTaskFileOperation(operation) {
-  const previous = taskFileOperations.get(tasksFile) || Promise.resolve();
-  const current = previous.catch(() => {}).then(operation);
-  taskFileOperations.set(tasksFile, current);
-  try {
-    return await current;
-  } finally {
-    if (taskFileOperations.get(tasksFile) === current) taskFileOperations.delete(tasksFile);
-  }
-}
-
-async function waitForTaskFileOperations() {
-  await (taskFileOperations.get(tasksFile) || Promise.resolve()).catch(() => {});
-}
-
-async function loadTasksFile() {
-  try {
-    const parsed = JSON.parse(await readFile(tasksFile, "utf8"));
-    return Array.isArray(parsed) ? parsed.map(migrateTask) : [];
-  } catch {
-    return [];
-  }
-}
-
-async function saveTasksFile(tasks) {
-  await mkdir(path.dirname(tasksFile), { recursive: true });
-  const temporaryFile = `${tasksFile}.${process.pid}.${crypto.randomUUID()}.tmp`;
-  try {
-    await writeFile(temporaryFile, `${JSON.stringify(tasks, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
-    await rename(temporaryFile, tasksFile);
-  } finally {
-    await rm(temporaryFile, { force: true }).catch(() => {});
-  }
-}
-
 function taskId() {
   return crypto.randomUUID();
 }
@@ -193,64 +154,51 @@ function failTask(task, error) {
 }
 
 export class TaskStore {
-  constructor() {
-    this.tasks = null;
+  constructor(storage = {}) {
+    this.storage = storage;
   }
 
   async init() {
-    if (!this.tasks) await this.reload();
+    this.read(() => undefined);
   }
 
-  async reload() {
-    await waitForTaskFileOperations();
-    this.tasks = await loadTasksFile();
+  read(operation) {
+    return withTaskDatabase(migrateTask, operation, this.storage);
   }
 
-  async mutate(operation) {
-    return serializeTaskFileOperation(async () => {
-      this.tasks = await loadTasksFile();
-      const { result, changed = true } = await operation(this.tasks);
-      if (changed) await saveTasksFile(this.tasks);
+  async mutate(operation, filter = {}) {
+    return this.read((db) => transaction(db, () => {
+      const tasks = selectTasks(db, filter);
+      const before = new Map(tasks.map((task) => [task.id, JSON.stringify(task)]));
+      const outcome = operation(tasks);
+      if (outcome?.then) throw new Error("Task mutations must be synchronous");
+      const { result, changed = true } = outcome;
+      if (changed) persistTaskChanges(db, before, tasks);
       return result;
-    });
-  }
-
-  async save() {
-    const tasks = structuredClone(this.tasks || []);
-    return serializeTaskFileOperation(async () => {
-      this.tasks = tasks;
-      await saveTasksFile(tasks);
-    });
+    }));
   }
 
   async add(task, defaults = {}) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const normalized = normalizeTask(task, defaults);
       tasks.push(normalized);
       return { result: structuredClone(normalized) };
-    });
+    }, { empty: true });
   }
 
   async addMany(tasksToAdd = [], defaults = {}) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const created = tasksToAdd.map((task) => normalizeTask(task, defaults));
       tasks.push(...created);
       return { result: structuredClone(created), changed: created.length > 0 };
-    });
+    }, { empty: true });
   }
 
   async claimDue(limit = 10) {
-    return this.mutate(async (tasks) => {
-      const now = Date.now();
-      const due = tasks
-        .filter((task) => ["pending", "blocked_auth"].includes(task.status)
-          && task.runAt
-          && !Number.isNaN(Date.parse(task.runAt))
-          && Date.parse(task.runAt) <= now)
-        .sort((left, right) => Date.parse(left.runAt) - Date.parse(right.runAt)
-          || Date.parse(left.createdAt || 0) - Date.parse(right.createdAt || 0)
-          || String(left.id).localeCompare(String(right.id)))
-        .slice(0, limit);
+    const now = Date.now();
+    if (!Number.isSafeInteger(limit) || limit < 0) throw new Error("Invalid task claim limit");
+    return this.mutate((tasks) => {
+      const due = tasks;
 
       const claimedAt = new Date(now).toISOString();
       for (const task of due) {
@@ -263,21 +211,21 @@ export class TaskStore {
       }
 
       return { result: structuredClone(due), changed: due.length > 0 };
-    });
+    }, { due: { now, limit } });
   }
 
   async markExecutionStarted(taskId) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const task = tasks.find((item) => item.id === taskId);
       if (!task || task.status !== "running") return { result: null, changed: false };
       task.executionStartedAt = new Date().toISOString();
       task.updatedAt = task.executionStartedAt;
       return { result: structuredClone(task) };
-    });
+    }, { id: taskId });
   }
 
   async recoverInterrupted() {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const recovered = [];
       let compacted = false;
       const now = Date.now();
@@ -336,7 +284,7 @@ export class TaskStore {
   }
 
   async complete(taskId) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const task = tasks.find((item) => item.id === taskId);
       if (!task) return { result: null, changed: false };
 
@@ -366,11 +314,11 @@ export class TaskStore {
       task.updatedAt = completedAt;
       compactTerminalTask(task);
       return { result: structuredClone(task) };
-    });
+    }, { id: taskId });
   }
 
   async blockAuth(taskId, error, resolution = {}) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const task = tasks.find((item) => item.id === taskId);
       if (!task) return { result: null, changed: false };
       const now = Date.now();
@@ -395,11 +343,11 @@ export class TaskStore {
       delete task.executionStartedAt;
       delete task.error;
       return { result: { ...structuredClone(task), authBlockedNew: !wasBlocked } };
-    });
+    }, { id: taskId });
   }
 
   async retryOrFail(taskId, error, { retryable = true, outcomeUncertain = false } = {}) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const task = tasks.find((item) => item.id === taskId);
       if (!task) return { result: null, changed: false };
       const message = error instanceof Error ? error.message : String(error);
@@ -465,45 +413,38 @@ export class TaskStore {
       delete task.claimedAt;
       delete task.executionStartedAt;
       return { result: structuredClone(task) };
-    });
+    }, { id: taskId });
   }
 
   async fail(taskId, error) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const task = tasks.find((item) => item.id === taskId);
       return task
         ? { result: failTask(task, error) }
         : { result: null, changed: false };
-    });
+    }, { id: taskId });
   }
 
   async list(filter = {}) {
-    await this.reload();
-    return this.tasks.filter((task) => {
-      if (filter.chatId && String(task.payload?.chatId) !== String(filter.chatId)) return false;
-      if (filter.status && task.status !== filter.status) return false;
-      if (filter.kind && task.kind !== filter.kind) return false;
-      return true;
-    }).map((task) => structuredClone(task));
+    return this.read((db) => selectTasks(db, filter));
   }
 
   async get(taskId) {
-    await this.reload();
-    const task = this.tasks.find((item) => item.id === taskId);
-    return task ? structuredClone(task) : null;
+    if (typeof taskId !== "string" || !taskId) return null;
+    return this.read((db) => selectTasks(db, { id: taskId })[0] || null);
   }
 
   async cancel(taskId) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const index = tasks.findIndex((item) => item.id === taskId);
       if (index === -1) return { result: null, changed: false };
       const [task] = tasks.splice(index, 1);
       return { result: structuredClone(task) };
-    });
+    }, { id: taskId });
   }
 
   async cancelAll(filter = {}) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const removed = [];
       const remaining = tasks.filter((task) => {
         if (filter.chatId && String(task.payload?.chatId) !== String(filter.chatId)) return true;
@@ -514,6 +455,6 @@ export class TaskStore {
       });
       tasks.splice(0, tasks.length, ...remaining);
       return { result: removed, changed: removed.length > 0 };
-    });
+    }, filter);
   }
 }