@songsid/agend 2.1.12-beta.5 → 2.1.12-beta.7

package/dist/fleet-manager.js

@@ -1,3 +1,4 @@
+import { measureSyncWork } from "./sync-work-attribution.js";
 import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmSync, readdirSync, renameSync, copyFileSync, chmodSync, statSync, accessSync, constants as fsConstants } from "node:fs";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { spawnSync } from "node:child_process";
@@ -34,7 +35,7 @@ import { createAdapter } from "./channel/factory.js";
 import { TelegramAdapter } from "./channel/adapters/telegram.js";
 import { createBackend } from "./backend/factory.js";
 import { readEffortMetadata } from "./backend/effort-metadata.js";
-import { isModelCompatible, SYSINFO_BACKEND_IDS, UnsupportedCliError } from "./backend/types.js";
+import { CLI_ENV_TTL_MS, isModelCompatible, SYSINFO_BACKEND_IDS, UnsupportedCliError } from "./backend/types.js";
 import { createLogger, rotateLogIfNeeded } from "./logger.js";
 import { processAttachments } from "./channel/attachment-handler.js";
 import { routeToolCall } from "./channel/tool-router.js";
@@ -56,6 +57,51 @@ import { DeliveryOutbox } from "./delivery-outbox.js";
 // active manager/target generation pair owns the lane until the daemon reports
 // a state transition or that generation is replaced.
 export const DURABLE_DELIVERY_LANE_ALERT_MS = 35 * 60_000;
+/**
+ * #1335: Cap an unfiltered task list at 100 rows (most recently updated first).
+ * Exported so the production branch can be tested directly without starting a fleet.
+ * Filtered calls pass-through unchanged. Empty strings count as "not set" (P3).
+ * #1336: generic over the row shape so it works on both full Task and compact rows.
+ */
+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"];
+/**
+ * #1336 P2: shared normalization for filter_status across both task handlers
+ * and the cap helper. Trims whitespace before dropping empties, so
+ * " \t " and [" ", "\t"] both normalize to undefined (not treated as explicit
+ * filters). The same result drives the live-only default and the cap decision.
+ */
+export function normalizeStatusFilter(v) {
+    if (typeof v === "string") {
+        const s = v.trim();
+        return s || undefined;
+    }
+    if (Array.isArray(v) && v.every(x => typeof x === "string")) {
+        const arr = [...new Set(v.map(s => s.trim()).filter(s => s.length > 0))];
+        return arr.length > 0 ? arr : undefined;
+    }
+    return undefined;
+}
+export function applyTaskListCap(tasks, filterAssignee, filterStatus) {
+    // Use the shared normalizer so " \t " is treated identically to undefined.
+    const normalized = normalizeStatusFilter(filterStatus);
+    const hasStatusFilter = Array.isArray(normalized) ? normalized.length > 0 : !!normalized;
+    const isFiltered = !!filterAssignee || hasStatusFilter;
+    if (!isFiltered && tasks.length > TASK_LIST_CAP) {
+        const omitted = tasks.length - TASK_LIST_CAP;
+        tasks.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+        return {
+            tasks: tasks.slice(0, TASK_LIST_CAP),
+            omitted,
+            hint: `${omitted} older task(s) omitted — use filter_assignee or filter_status to narrow results`,
+        };
+    }
+    return tasks;
+}
 import { handleWebRequest, broadcastSseEvent } from "./web-api.js";
 import { handleViewRequest, isViewPath } from "./view-api.js";
 import { filterUsageProviders, formatDiscordUsageActivity, getUsageSnapshot, handleUsageRequest, isUsagePath, usageProviderIdForBackend } from "./usage/usage-api.js";
@@ -263,7 +309,6 @@ const NONCE_BUTTON_TIMEOUT_MS = 15 * 60_000;
 const TIP_BUTTON_TIMEOUT_MS = 24 * 60 * 60_000;
 /** How long shutdown will spend retiring still-armed button prompts. */
 const NONCE_RETIRE_BUDGET_MS = 5_000;
-const CLI_ENV_TTL_MS = 24 * 60 * 60 * 1000; // hard validity bound for the cached CLI env
 /**
  * How old the cached CLI env may be before `/model` re-probes it live.
  *
@@ -571,6 +616,7 @@ export class FleetManager {
     /** Injectable only to keep the chat→CLI reload hand-off deterministic in tests. */
     fullRestartLauncher = launchFullRestartHelper;
     eventLogPruneTimer = null;
+    outboxPruneTimer = null;
     logRotateTimer = null;
     discordPresenceTimer = null;
     discordPresenceEagerTimer = null;
@@ -2766,7 +2812,7 @@ export class FleetManager {
                 oldToolProgress.set(ch.instanceName, this.classicChannels.getToolProgress(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.tool_progress));
                 oldReplyGuard.set(ch.instanceName, this.classicChannels.getReplyCompletionGuard(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.reply_completion_guard));
             }
-            if (!this.classicChannels.checkReload())
+            if (!measureSyncWork("fleet.classicConfigReload", () => this.classicChannels.checkReload()))
                 return;
             // A reload can introduce a bad id (hand edit) or clear one; the
             // throttle keeps a repeated report from flooding the topic.
@@ -2870,7 +2916,7 @@ export class FleetManager {
             // managed independently from fleet-topic workers.
             try {
                 const skillsWorkDir = this.resolveKnowledgeWorkDir(config.working_directory, backend, name);
-                this.syncRoleSkills(skillsWorkDir, backend, "worker");
+                measureSyncWork("fleet.workerSkills", () => this.syncRoleSkills(skillsWorkDir, backend, "worker"));
             }
             catch (err) {
                 // Skill publishing is additive. A read-only or temporarily unavailable
@@ -4116,6 +4162,11 @@ export class FleetManager {
         this.pruneEventLog();
         this.eventLogPruneTimer = setInterval(() => this.pruneEventLog(), 24 * 60 * 60_000);
         this.eventLogPruneTimer.unref?.();
+        // #1335: delivery-outbox.db and Task Board retention. Same once-at-startup
+        // + daily-timer pattern; chunked DELETEs so one run cannot hold the loop.
+        void this.pruneOutboxAndTasks();
+        this.outboxPruneTimer = setInterval(() => { void this.pruneOutboxAndTasks(); }, 24 * 60 * 60_000);
+        this.outboxPruneTimer.unref?.();
         // Same shape for logs, and for the same reason: the only sweep that
         // covered them lived inside the daily-summary callback, so it did not run at
         // all when summaries were off.
@@ -6636,45 +6687,74 @@ export class FleetManager {
         const asStatus = (v) => {
             return (v === "open" || v === "claimed" || v === "done" || v === "blocked" || v === "cancelled") ? v : undefined;
         };
-        switch (action) {
-            case "create": {
-                const title = asStr(args.title);
-                if (!title)
-                    return { error: "title is required" };
-                return db.createTask({
-                    title,
-                    description: asStr(args.description),
-                    priority: asPriority(args.priority),
-                    assignee: asStr(args.assignee),
-                    depends_on: asStrArr(args.depends_on),
-                    created_by: instance,
-                });
-            }
-            case "list": return db.listTasks({ assignee: asStr(args.filter_assignee), status: asStr(args.filter_status) });
-            case "claim": {
-                const id = asStr(args.id);
-                if (!id)
-                    return { error: "id is required" };
-                return db.claimTask(id, instance);
-            }
-            case "done": {
-                const id = asStr(args.id);
-                if (!id)
-                    return { error: "id is required" };
-                return db.completeTask(id, asStr(args.result));
-            }
-            case "update": {
-                const id = asStr(args.id);
-                if (!id)
-                    return { error: "id is required" };
-                return db.updateTask(id, {
-                    status: asStatus(args.status),
-                    assignee: asStr(args.assignee),
-                    result: asStr(args.result),
-                    priority: asPriority(args.priority),
-                });
+        // #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 });
+        try {
+            switch (action) {
+                case "create": {
+                    const title = asStr(args.title);
+                    if (!title)
+                        return { error: "title is required" };
+                    return ack(db.createTask({
+                        title,
+                        description: asStr(args.description),
+                        priority: asPriority(args.priority),
+                        assignee: asStr(args.assignee),
+                        depends_on: asStrArr(args.depends_on),
+                        created_by: instance,
+                    }));
+                }
+                case "list": {
+                    const filterAssignee = asStr(args.filter_assignee) || undefined;
+                    const explicitStatus = asStatusFilter(args.filter_status);
+                    // #1336 item 1: default to live-only (no done/cancelled) unless the
+                    // caller explicitly asked for a status.
+                    const effectiveStatus = explicitStatus ?? LIVE_TASK_STATUSES;
+                    const verbose = args.verbose === true;
+                    const tasks = verbose
+                        ? db.listTasks({ assignee: filterAssignee, status: effectiveStatus, verbose: true })
+                        : db.listTasks({ assignee: filterAssignee, status: effectiveStatus });
+                    // #1335: cap unfiltered list. The default live-only filter does not
+                    // count as an explicit filter for the cap decision.
+                    return applyTaskListCap(tasks, filterAssignee, explicitStatus);
+                }
+                case "get": {
+                    const id = asStr(args.id);
+                    if (!id)
+                        return { error: "id is required" };
+                    return db.getTaskByPrefix(id);
+                }
+                case "claim": {
+                    const id = asStr(args.id);
+                    if (!id)
+                        return { error: "id is required" };
+                    return ack(db.claimTask(db.getTaskByPrefix(id).id, 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)));
+                }
+                case "update": {
+                    const id = asStr(args.id);
+                    if (!id)
+                        return { error: "id is required" };
+                    return ack(db.updateTask(db.getTaskByPrefix(id).id, {
+                        status: asStatus(args.status),
+                        assignee: asStr(args.assignee),
+                        result: asStr(args.result),
+                        priority: asPriority(args.priority),
+                    }));
+                }
+                default: return { error: `Unknown task action: ${action}` };
             }
-            default: return { error: `Unknown task action: ${action}` };
+        }
+        catch (err) {
+            return { error: err.message };
         }
     }
     async handleSetDisplayNameHttp(instance, name) {
@@ -6745,11 +6825,17 @@ export class FleetManager {
         }
         const db = this.scheduler.db;
         const action = payload.action;
+        // #1336 P2: use the shared normalizer — trims whitespace AND drops empties,
+        // 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 });
         try {
             let result;
+            // Full task kept for activity logging; the IPC reply uses the compact ack.
+            let logTask;
             switch (action) {
                 case "create":
-                    result = db.createTask({
+                    logTask = db.createTask({
                         title: payload.title,
                         description: payload.description,
                         priority: payload.priority,
@@ -6757,43 +6843,57 @@ export class FleetManager {
                         depends_on: payload.depends_on,
                         created_by: meta.instance_name || instanceName,
                     });
+                    result = ack(logTask);
                     break;
-                case "list":
-                    result = db.listTasks({
-                        assignee: payload.filter_assignee,
-                        status: payload.filter_status,
-                    });
+                case "list": {
+                    // P3: normalize empty strings to undefined — SchedulerDb.listTasks
+                    // ignores them but the cap logic must treat them as "not filtered".
+                    const filterAssignee = payload.filter_assignee || undefined;
+                    const explicitStatus = asStatusFilter(payload.filter_status);
+                    // #1336 item 1: default to live-only (no done/cancelled).
+                    const effectiveStatus = explicitStatus ?? LIVE_TASK_STATUSES;
+                    const verbose = payload.verbose === true;
+                    const tasks = verbose
+                        ? db.listTasks({ assignee: filterAssignee, status: effectiveStatus, verbose: true })
+                        : db.listTasks({ assignee: filterAssignee, status: effectiveStatus });
+                    // #1335: cap unfiltered list — the default live-only filter does not
+                    // count as an explicit filter.
+                    result = applyTaskListCap(tasks, filterAssignee, explicitStatus);
+                    break;
+                }
+                case "get":
+                    result = db.getTaskByPrefix(payload.id);
                     break;
                 case "claim":
-                    result = db.claimTask(payload.id, meta.instance_name || instanceName);
+                    logTask = db.claimTask(db.getTaskByPrefix(payload.id).id, meta.instance_name || instanceName);
+                    result = ack(logTask);
                     break;
                 case "done":
-                    result = db.completeTask(payload.id, payload.result);
+                    logTask = db.completeTask(db.getTaskByPrefix(payload.id).id, payload.result);
+                    result = ack(logTask);
                     break;
                 case "update":
-                    result = db.updateTask(payload.id, {
+                    logTask = db.updateTask(db.getTaskByPrefix(payload.id).id, {
                         status: payload.status,
                         assignee: payload.assignee,
                         result: payload.result,
                         priority: payload.priority,
                     });
+                    result = ack(logTask);
                     break;
                 default:
                     throw new Error(`Unknown task action: ${action}`);
             }
             ipc.send({ type: "fleet_task_response", fleetRequestId, result });
             // Activity log for task lifecycle events
-            if (action === "create") {
-                const t = result;
-                this.eventLog?.logActivity("task_update", instanceName, `created task: ${t.title}`, t.assignee ?? undefined);
+            if (action === "create" && logTask) {
+                this.eventLog?.logActivity("task_update", instanceName, `created task: ${logTask.title}`, logTask.assignee ?? undefined);
             }
-            else if (action === "claim") {
-                const t = result;
-                this.eventLog?.logActivity("task_update", instanceName, `claimed: ${t.title}`);
+            else if (action === "claim" && logTask) {
+                this.eventLog?.logActivity("task_update", instanceName, `claimed: ${logTask.title}`);
             }
-            else if (action === "done") {
-                const t = result;
-                this.eventLog?.logActivity("task_update", instanceName, `completed: ${t.title}`, undefined, t.result ?? undefined);
+            else if (action === "done" && logTask) {
+                this.eventLog?.logActivity("task_update", instanceName, `completed: ${logTask.title}`, undefined, logTask.result ?? undefined);
             }
         }
         catch (err) {
@@ -8165,6 +8265,42 @@ export class FleetManager {
             this.logger.warn({ err }, "Event log prune failed");
         }
     }
+    /** #1335: Prune delivery-outbox.db and Task Board in chunked async passes. */
+    async pruneOutboxAndTasks() {
+        const days = this.fleetConfig?.defaults?.retention_days ?? 30;
+        // Outbox prune
+        const outbox = this.deliveryOutbox;
+        if (outbox?.isOpen) {
+            try {
+                const { pruned, durationMs } = await outbox.prune(days);
+                if (pruned > 0) {
+                    this.logger.info({ pruned, durationMs: Math.round(durationMs) }, "Delivery outbox pruned");
+                }
+            }
+            catch (err) {
+                this.logger.warn({ err }, "Delivery outbox prune failed");
+            }
+        }
+        // Task Board prune
+        if (this.scheduler?.db) {
+            try {
+                const pruned = await this.scheduler.db.pruneOldTasks(days);
+                if (pruned > 0) {
+                    this.logger.info({ pruned }, "Task board pruned");
+                }
+            }
+            catch (err) {
+                this.logger.warn({ err }, "Task board prune failed");
+            }
+        }
+    }
+    /**
+     * #1335: True when the delivery_id was in the outbox, was pruned by
+     * retention, and the caller is the original source or target (#1340 P2 🔒).
+     */
+    wasDeliveryIdPrunedForCaller(deliveryId, callerInstance) {
+        return this.deliveryOutbox?.wasDeliveryIdPrunedForCaller(deliveryId, callerInstance) ?? false;
+    }
     openEventLog() {
         const dbPath = join(this.dataDir, "events.db");
         try {
@@ -10419,8 +10555,11 @@ export class FleetManager {
      * definition or a function name, neither of which a spawn could run.
      */
     locateBinaryOnLoginShell(binary) {
+        return measureSyncWork("fleet.installLookup", () => this.locateBinaryOnLoginShellSync(binary));
+    }
+    locateBinaryOnLoginShellSync(binary) {
         try {
-            const result = spawnSync("bash", ["-lc", `command -v ${binary}`], { timeout: 10_000, stdio: "pipe", encoding: "utf8" });
+            const result = measureSyncWork("fleet.installLoginShell", () => spawnSync("bash", ["-lc", `command -v ${binary}`], { timeout: 10_000, stdio: "pipe", encoding: "utf8" }));
             if (result.status !== 0)
                 return null;
             const path = String(result.stdout ?? "").trim().split("\n").pop()?.trim() ?? "";
@@ -10640,6 +10779,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
 `;
     /** Ensure the general instance has its project instructions file + knowledge */
     ensureGeneralInstructions(workDir, backendName, instanceName) {
+        measureSyncWork("fleet.generalInstructions", () => this.ensureGeneralInstructionsSync(workDir, backendName, instanceName));
+    }
+    ensureGeneralInstructionsSync(workDir, backendName, instanceName) {
         const backend = backendName ?? "claude-code";
         workDir = this.resolveKnowledgeWorkDir(workDir, backend, instanceName);
         const filename = FleetManager.INSTRUCTIONS_FILENAME[backend] ?? "CLAUDE.md";
@@ -11460,6 +11602,15 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             if (previous?.apiModels?.length)
                 env.apiModels = previous.apiModels;
         }
+        // Effort levels read from --help (#1328) are a capability of one binary. A help that could not be read (absent)
+        // keeps the cached levels only for that same binary: both versions known and equal, cache still valid. A help
+        // that was read and lists none ([]) is an answer and is written as is, so the fallback applies.
+        if (env.effortLevels === undefined) {
+            const previous = this.readCliEnv(backend);
+            if (previous?.effortLevels && previous.version && env.version && previous.version === env.version) {
+                env.effortLevels = previous.effortLevels;
+            }
+        }
         const path = this.cliEnvPath(backend);
         mkdirSync(dirname(path), { recursive: true });
         writeFileSync(path, JSON.stringify(env, null, 2));
@@ -12589,6 +12740,10 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             clearInterval(this.eventLogPruneTimer);
             this.eventLogPruneTimer = null;
         }
+        if (this.outboxPruneTimer) {
+            clearInterval(this.outboxPruneTimer);
+            this.outboxPruneTimer = null;
+        }
         if (this.replyObligationTimer) {
             clearInterval(this.replyObligationTimer);
             this.replyObligationTimer = null;
@@ -14804,6 +14959,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         this.healthServer.listen(port, "127.0.0.1", () => markListening());
     }
     getUiStatus() {
+        return measureSyncWork("fleet.uiStatus", () => this.getUiStatusSync());
+    }
+    getUiStatusSync() {
         const fleetNames = Object.keys(this.fleetConfig?.instances ?? {});
         // Classic rooms live only in classicBot.yaml — /api/profiles merges them into
         // the View roster, but previously getUiStatus skipped them so context_pct was