@songsid/agend 2.3.0-beta.19 → 2.3.0-beta.20

package/dist/fleet-manager.js

@@ -73,6 +73,8 @@ import { createLogger, rotateLogIfNeeded } from "./logger.js";
 import { processAttachments } from "./channel/attachment-handler.js";
 import { routeToolCall } from "./channel/tool-router.js";
 import { Scheduler } from "./scheduler/index.js";
+import { boardActivity, boardCardLimit, boardToolAction } from "./task-board-tool.js";
+import { TaskBoardWaker } from "./task-board-waker.js";
 import { escapeTelegramHtml, scheduleClock, scheduleRetryLabel } from "./scheduler/retry-label.js";
 import { DEFAULT_SCHEDULER_CONFIG } from "./scheduler/index.js";
 import { TopicCommands, saveCommandForBackend, parseSaveFilename, parsePauseWakeCommand, parseCompactCommand, SAVE_FILENAME_RE, resolveInstanceContext, forgetInstanceContext, readStatuslineJson, statuslineModel } from "./topic-commands.js";
@@ -103,7 +105,8 @@ export const TASK_LIST_CAP = 100;
  * #1336: the non-terminal statuses a bare `list` returns by default. `done`
  * and `cancelled` are excluded unless the caller passes `filter_status`.
  */
-export const LIVE_TASK_STATUSES = ["open", "claimed", "blocked"];
+/** Not finished: `review` is done work waiting for the person (the task board), still live. */
+export const LIVE_TASK_STATUSES = ["open", "claimed", "blocked", "review"];
 /**
  * #1336 P2: shared normalization for filter_status across both task handlers
  * and the cap helper. Trims whitespace before dropping empties, so
@@ -181,7 +184,9 @@ import { runOnLoginShell } from "./login-shell.js";
 import { tightenInstanceDirs } from "./private-dir.js";
 import { decideSlash } from "./slash-authz.js";
 import { canonicalCommand, commandSpec, decideCommand, ruleFor } from "./command-table.js";
-import { crossInstanceVisibility, runVisibilityCommand } from "./cross-instance-notice.js";
+import { crossInstanceVisibility, runVisibilityCommand, xmsgVisibility } from "./cross-instance-notice.js";
+import { SEARCH_RETENTION_DAYS, SearchIndex } from "./search/search-index.js";
+import { chatDoc, taskDoc, xmsgDoc } from "./search/search-docs.js";
 import { WebSettingsTools } from "./web-settings-tools.js";
 import { bindGuestRequest, guestRouteDecision } from "./web-guest-access.js";
 import { GUEST_ROOM_TICK_MS, GuestRoomMembership, guestGroupRooms } from "./web-guest-rooms.js";
@@ -666,6 +671,8 @@ export class FleetManager {
     statuslineWatcher;
     dailySummary = null;
     dailyTipScheduler = null;
+    /** The task board's wakes (step 2): an instance hears when someone else changes a card it owns or handed out. */
+    taskBoardWaker = null;
     webhookEmitter = null;
     // Topic icon + auto-archive state
     topicIcons = {};
@@ -904,6 +911,8 @@ export class FleetManager {
     webChatHistory = new WebChatHistory();
     /** #1565: the web chat history's files (set at fleet start, once the home and the instances are known). */
     webChatStore = null;
+    /** #2293: the dashboard's global search (null: web.search.enabled is false, or the fleet has not started). */
+    searchIndex = null;
     /** Uploaded files and the files the dashboard may fetch back (uploads, reply attachments). */
     // #1937: the upload limits are the config's, read on each use (agend reload applies a change to the next upload).
     webFiles = new WebFileLedger({ limits: () => uploadLimits(this.fleetConfig?.web) });
@@ -1787,7 +1796,10 @@ export class FleetManager {
                         : t(`delivery.fleet_${row.state}`, row.targetInstance, row.operationId, row.deliveryId);
                     this.logger.error({ deliveryId: row.deliveryId, operationId: row.operationId, target: row.targetInstance, state: row.state,
                         cause: row.lastError, ...(silent ? { silentSchedule: true } : {}) }, notice);
-                    this.notifyFleetError(notice);
+                    // A self-scheduled silent heartbeat stays log-only, including the
+                    // operator alert; another source still receives the normal notice.
+                    if (!silent || row.sourceInstance !== row.targetInstance)
+                        this.notifyFleetError(notice);
                 }
             }
         });
@@ -7037,6 +7049,7 @@ export class FleetManager {
         // #1565: the web chat as it was before this process — the configured instances' only (fleet.yaml and ClassicBot
         // rooms), before the dashboard serves anything; from now on every change is written back (off the loop).
         this.restoreWebChat(fleet);
+        this.startSearchIndex(fleet);
         // Poll classicBot.yaml for external changes every 30s
         this.classicReloadTimer = setInterval(() => {
             // Attributes the synchronous part, up to the reload's first await (#1235).
@@ -7181,7 +7194,9 @@ export class FleetManager {
             };
             this.scheduler = new Scheduler(join(this.dataDir, "scheduler.db"), (schedule, runId, retry) => this.handleScheduleTrigger(schedule, runId, retry), schedulerConfig, (name) => this.fleetConfig?.instances?.[name] != null || !!this.classicChannels?.getAll().some(ch => ch.instanceName === name), (schedule, retry, reason) => this.scheduleRetryDropped(schedule, retry, reason), this.logger);
             this.scheduler.init();
+            this.scheduler.db.onTaskChange = (task) => this.searchIndex?.record(taskDoc(task));
             this.logger.info("Scheduler initialized");
+            this.attachTaskBoard(this.scheduler.db);
             // Tips share the daily-report clock but remain an independent internal
             // job: disabling daily_summary must not disable tips (and vice versa).
             // The callback checks defaults.tips at fire time, so /tips on|off is hot.
@@ -10650,14 +10665,20 @@ export class FleetManager {
             return (v === "low" || v === "normal" || v === "high" || v === "urgent") ? v : undefined;
         };
         const asStatus = (v) => {
-            return (v === "open" || v === "claimed" || v === "done" || v === "blocked" || v === "cancelled") ? v : undefined;
+            return (v === "open" || v === "claimed" || v === "review" || v === "done" || v === "blocked" || v === "cancelled") ? v : undefined;
         };
         // #1336 P2: use the shared normalizer — trims whitespace AND drops empties,
         // so " \t " / [" ","\t"] are treated identically to undefined.
         const asStatusFilter = normalizeStatusFilter;
         // #1336: small write ack — identifying fields only.
         const ack = (t) => ({ id: t.id, status: t.status, updated_at: t.updated_at });
+        // The board's notes for the write (a send-back reason, a comment the assignee had not seen): with the ack when any.
+        const noted = (a) => { const notes = db.board.takeNotes(); return notes.length ? { ...a, notes } : a; };
         try {
+            // The task board's own actions and fields (task-board-tool.ts); the rest is the tool's plain task, below.
+            const onBoard = boardToolAction(db, instance, args);
+            if (onBoard !== undefined)
+                return onBoard;
             switch (action) {
                 case "create": {
                     const title = asStr(args.title);
@@ -10696,24 +10717,24 @@ export class FleetManager {
                     const id = asStr(args.id);
                     if (!id)
                         return { error: "id is required" };
-                    return ack(db.claimTask(db.getTaskByPrefix(id).id, instance));
+                    return noted(ack(db.claimTask(db.getTaskByPrefix(id).id, instance, { kind: "instance", name: instance })));
                 }
                 case "done": {
                     const id = asStr(args.id);
                     if (!id)
                         return { error: "id is required" };
-                    return ack(db.completeTask(db.getTaskByPrefix(id).id, asStr(args.result)));
+                    return noted(ack(db.completeTask(db.getTaskByPrefix(id).id, asStr(args.result), { kind: "instance", name: instance })));
                 }
                 case "update": {
                     const id = asStr(args.id);
                     if (!id)
                         return { error: "id is required" };
-                    return ack(db.updateTask(db.getTaskByPrefix(id).id, {
+                    return noted(ack(db.updateTask(db.getTaskByPrefix(id).id, {
                         status: asStatus(args.status),
                         assignee: asStr(args.assignee),
                         result: asStr(args.result),
                         priority: asPriority(args.priority),
-                    }));
+                    }, { kind: "instance", name: instance })));
                 }
                 default: return { error: `Unknown task action: ${action}` };
             }
@@ -10807,7 +10828,18 @@ export class FleetManager {
         // so " \t " / [" ","\t"] are treated identically to undefined.
         const asStatusFilter = normalizeStatusFilter;
         const ack = (t) => ({ id: t.id, status: t.status, updated_at: t.updated_at });
+        const noted = (a) => { const notes = db.board.takeNotes(); return notes.length ? { ...a, notes } : a; };
         try {
+            // The task board's own actions and fields (task-board-tool.ts); the rest is the tool's plain task, below.
+            const onBoard = boardToolAction(db, meta.instance_name || instanceName, payload);
+            if (onBoard !== undefined) {
+                ipc.send({ type: "fleet_task_response", fleetRequestId, result: onBoard });
+                // The activity log hears of board work as it does of plain tasks.
+                const what = boardActivity(payload);
+                if (what)
+                    this.eventLog?.logActivity("task_update", instanceName, what);
+                return;
+            }
             let result;
             // Full task kept for activity logging; the IPC reply uses the compact ack.
             let logTask;
@@ -10843,12 +10875,12 @@ export class FleetManager {
                     result = db.getTaskByPrefix(payload.id);
                     break;
                 case "claim":
-                    logTask = db.claimTask(db.getTaskByPrefix(payload.id).id, meta.instance_name || instanceName);
-                    result = ack(logTask);
+                    logTask = db.claimTask(db.getTaskByPrefix(payload.id).id, meta.instance_name || instanceName, { kind: "instance", name: meta.instance_name || instanceName });
+                    result = noted(ack(logTask));
                     break;
                 case "done":
-                    logTask = db.completeTask(db.getTaskByPrefix(payload.id).id, payload.result);
-                    result = ack(logTask);
+                    logTask = db.completeTask(db.getTaskByPrefix(payload.id).id, payload.result, { kind: "instance", name: meta.instance_name || instanceName });
+                    result = noted(ack(logTask));
                     break;
                 case "update":
                     logTask = db.updateTask(db.getTaskByPrefix(payload.id).id, {
@@ -10856,8 +10888,8 @@ export class FleetManager {
                         assignee: payload.assignee,
                         result: payload.result,
                         priority: payload.priority,
-                    });
-                    result = ack(logTask);
+                    }, { kind: "instance", name: meta.instance_name || instanceName });
+                    result = noted(ack(logTask));
                     break;
                 default:
                     throw new Error(`Unknown task action: ${action}`);
@@ -11480,6 +11512,7 @@ export class FleetManager {
         // Its web chat goes with it (only after the removal succeeded): a later instance of the same name
         // must not be shown the old one's conversation, and deleted names must not pile up.
         this.webChatHistory.forget(name);
+        this.searchIndex?.removeInstance(name);
         this.webFiles.forget(name);
         this.compactWatchService?.forget(name);
         // #1664: and it is nobody's favorite any more (every device sees that at its next status frame).
@@ -16110,6 +16143,36 @@ export class FleetManager {
         const failure = await this.promptLoginBackends(chat);
         await data.respond(failure ?? t("login.chooser_posted"));
     }
+    /** #2293: whose cross-instance messages search leaves out now (web-api /ui/search). */
+    searchVisibility() { return xmsgVisibility(this.fleetConfig); }
+    /** #2293: a cross-instance message for the search index (outbound-handlers, after it was admitted). */
+    indexCrossInstance(record) {
+        this.searchIndex?.record(xmsgDoc(record));
+    }
+    /**
+     * #2293: the global search index, at fleet start — after the web chat is restored (the backfill reads it). Its worker
+     * owns search.db; see search-index.ts. Off with web.search.enabled: false.
+     */
+    startSearchIndex(fleet) {
+        const config = fleet.web?.search;
+        if (config?.enabled === false || this.searchIndex)
+            return;
+        const history = this.webChatHistory;
+        this.searchIndex = new SearchIndex({
+            path: join(this.dataDir, "search.db"),
+            retentionDays: config?.retention_days ?? SEARCH_RETENTION_DAYS,
+            outboxPath: join(this.dataDir, "delivery-outbox.db"),
+            schedulerPath: join(this.dataDir, "scheduler.db"),
+            chatDocs: function* () { for (const name of history.instances())
+                for (const m of history.list(name)) {
+                    const doc = chatDoc(m);
+                    if (doc)
+                        yield doc;
+                } },
+            log: (level, msg) => this.logger[level](msg),
+        });
+        this.searchIndex.start();
+    }
     queueMirrorMessage(text) {
         const mirrorTopicId = this.fleetConfig?.channel?.mirror_topic_id;
         if (mirrorTopicId == null || !this.adapter)
@@ -16207,6 +16270,7 @@ export class FleetManager {
                 replyTo: m.replyTo,
             });
             broadcastSseEvent(this.sseClients, event, recorded, onError, this.webChatHistory.cursorOf(recorded));
+            this.searchIndex?.record(chatDoc(recorded));
             // #1629: live-only receipt after the recorded agent reply. Never persist/replay it or give it an SSE cursor.
             if (recorded.role === "agent")
                 broadcastSseEvent(this.sseClients, "agent_reply_live", { v: 1, boot: recorded.boot, id: recorded.id, instance: recorded.instance }, onError);
@@ -16219,6 +16283,38 @@ export class FleetManager {
         }
         broadcastSseEvent(this.sseClients, event, data, onError);
     }
+    /**
+     * The task board's live side: every committed change goes to the open pages (never to a guest) — the board's new
+     * revision and the card numbers it touched; not who touched them (the page does not need it, and a public-link page
+     * must not learn a hidden instance's name from it). Its news goes to the instances whose cards someone else changed:
+     * one "[Task board]" notice per instance, gathered for 10 s, held by the delivery outbox until it is taken
+     * (task-board-waker.ts).
+     */
+    attachTaskBoard(db) {
+        this.taskBoardWaker?.stop();
+        // #2303: each instance's cards at once, read at every claim (a fleet.yaml edit applies to the next one).
+        db.board.setCardLimit((name) => boardCardLimit(this.fleetConfig, name));
+        const waker = this.taskBoardWaker = new TaskBoardWaker({
+            deliver: (instance, message, key) => this.admitTaskBoardNotice(instance, message, key),
+            isInstance: (name) => this.fleetConfig?.instances?.[name] != null,
+            holds: (wake) => db.board.wakeHolds(wake),
+            card: (uuid) => db.board.findCard(uuid),
+            log: (level, message, extra) => this.logger[level](extra ?? {}, message),
+        });
+        db.board.onChange(({ rev, ids, projects, wakes }) => {
+            this.emitSseEvent("tasks", { rev, ids, projects });
+            waker.note(wakes);
+        });
+    }
+    /** A task board notice, as AgEnD's own (not a person's words): through the delivery outbox, held until delivered. */
+    admitTaskBoardNotice(instance, message, key) {
+        this.ensureDeliveryOutbox();
+        const outbox = this.deliveryOutbox;
+        if (!outbox)
+            return false;
+        outbox.admitSystemNotice(instance, key, message, new Date());
+        return true;
+    }
     listClaimedTasks(assignee) {
         try {
             return this.scheduler?.db.listTasks({ assignee, status: "claimed" }) ?? [];
@@ -19188,7 +19284,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // this is the last moment the prompts can be collapsed.
         await this.retirePendingNoncePrompts();
         this.topicArchiver.stop();
+        this.taskBoardWaker?.stop();
         this.scheduler?.shutdown();
+        // What it was sent is written first (bounded: search-index.ts close()).
+        const search = this.searchIndex;
+        this.searchIndex = null;
+        await search?.close();
         // Stop instances in parallel batches to avoid long sequential waits.
         // Concurrency scales with fleet size — larger fleets tolerate more parallel
         // tmux ops, while small fleets stay conservative to avoid overwhelming the