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

package/dist/fleet-context.d.ts

@@ -1,5 +1,5 @@
 import type { FleetConfig, InstanceConfig } from "./types.js";
-import type { ChannelAdapter } from "./channel/types.js";
+import type { ChannelAdapter, InboundMessage } from "./channel/types.js";
 import type { IpcClient } from "./channel/ipc-bridge.js";
 import type { Scheduler } from "./scheduler/index.js";
 import type { Logger } from "./logger.js";
@@ -89,6 +89,15 @@ export interface FleetContext {
     isFleetAdmin(userId: string, adapterId?: string): boolean;
     /** Whether the adapter has any fleet admin at all (an empty allowlist turns the admin commands off). */
     hasFleetAdmins(adapterId?: string): boolean;
+    /** Telegram-only General command; owns admin/route checks and completion notice. */
+    runProfileCommand?(msg: InboundMessage, seconds?: string): Promise<void>;
+    /**
+     * #1346: the adapter that owns an instance's topic. Text commands resolve
+     * permission and replies through the owner, never the adapter whose copy
+     * happened to win the cross-adapter dedup race. Optional so older stubs
+     * keep working (they fall back to the receiving adapter).
+     */
+    getInstanceAdapterId?(instanceName: string): string | undefined;
     changeInstancePauseState(name: string, action: "pause" | "wake"): Promise<"paused" | "awake" | "not_idle">;
     startInstance(name: string, config: InstanceConfig, topicMode: boolean): Promise<void>;
     stopInstance(name: string): Promise<void>;

package/dist/fleet-manager.d.ts

@@ -1,3 +1,5 @@
+import { type ProfileTicket } from "./runtime-cpu-profile.js";
+import type { CpuProfile } from "./cpu-profile.js";
 import { type FleetMemory } from "./process-memory.js";
 import { MemoryPressure, type MemoryPressureSnapshot } from "./memory-pressure.js";
 import { ReplyDeduper } from "./reply-dedup.js";
@@ -8,7 +10,7 @@ import { EventLog } from "./event-log.js";
 import { AdapterWorld } from "./adapter-world.js";
 import { CostGuard } from "./cost-guard.js";
 import { IpcClient } from "./channel/ipc-bridge.js";
-import type { AdapterHealthSnapshot, ChannelAdapter, InboundReaction } from "./channel/types.js";
+import type { AdapterHealthSnapshot, ChannelAdapter, InboundMessage, InboundReaction } from "./channel/types.js";
 import { type BackendCliVersionSnapshot } from "./backend/types.js";
 import { type Logger } from "./logger.js";
 import { Scheduler } from "./scheduler/index.js";
@@ -564,6 +566,10 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** SIGUSR1: full process reload. Names who asked (#1120). */
     private onFullRestartSignal;
     private handleUpdateSlash;
+    private handleProfileSlash;
+    /** Typed /profile belongs only to Telegram's General dispatcher. */
+    runProfileCommand(msg: InboundMessage, seconds?: string): Promise<void>;
+    private handleGeneralProfile;
     private handleRestartSlash;
     /** #1302: `/visibility [mode]`. The dispatcher has already applied the command table's fleet-admin gate. */
     private handleVisibilitySlash;
@@ -607,7 +613,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * Fleet instances without channel_id and legacy Classic entries both belong
      * to channels[0]. Runtime bindings remain available for external sessions.
      */
-    private getInstanceAdapterId;
+    getInstanceAdapterId(name: string): string | undefined;
     /**
      * Bind an instance to a specific world (the bot that answers for it).
      * fromInbound=true (binding inferred from which adapter received a message)
@@ -704,6 +710,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * type a slash command could `/update` the host.
      */
     fleetAdminGate(userId: string, adapterId?: string): "ok" | "disabled" | "denied";
+    private runtimeCpuProfiler;
+    private cpuProfileControl;
+    private getCpuProfiler;
+    /** Called only by cold CLI startup, after claiming the fleet singleton. */
+    startCpuProfileControl(): Promise<void>;
+    startEnvironmentCpuProfile(): Promise<CpuProfile | null>;
+    startCpuProfile(seconds?: string | number): Promise<ProfileTicket>;
     /**
      * Every Discord slash command, for every adapter, in one place (it used to be two copies that could drift).
      *
@@ -1110,6 +1123,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * the message came from — its own world's group_id. Two Telegram fleet
      * worlds can number topics alike; a coincidence is dropped, never delivered.
      */
+    /**
+     * #1346: whether this copy may claim the shared dedup key for
+     * command-like text. Fleet topics resolve an owning adapter and only its
+     * copy proceeds; anything else (classic targets, unknown routing, no
+     * identity) passes through to the existing handling.
+     */
+    private isOwnerCommandCopy;
     private resolveInboundTarget;
     private handleInboundMessage;
     /** Handle outbound tool calls from a daemon instance */
@@ -2059,6 +2079,16 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     touchActivity(instanceName: string): void;
     /** Start periodic idle archive checker */
     private clearStatuslineWatchers;
+    /**
+     * #1346: on Discord, plain-text /xxx is never a command — the slash menu
+     * is. Both fleet call sites run this BEFORE the command handlers, so even
+     * the owning adapter's copy never executes text. The owning adapter posts
+     * one system note and consumes the message so it never reaches the agent;
+     * other adapters' copies stay silent (and the shared dedup key means
+     * exactly one copy gets here). Telegram keeps text commands working —
+     * text is its command path — and other sources pass through untouched.
+     */
+    private replyDiscordNotACommand;
     /** Handle a message in a classic channel: log it, forward only /chat messages */
     private handleClassicChannelMessage;
     /** Download photo or document attachment to classic instance workspace inbox. Returns { path, kind } or undefined. */

package/dist/fleet-manager.js

@@ -1,4 +1,6 @@
 import { measureSyncWork } from "./sync-work-attribution.js";
+import { RuntimeCpuProfiler, ProfileBusyError, profileDuration } from "./runtime-cpu-profile.js";
+import { ProfileControlServer } from "./profile-control.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";
@@ -1589,6 +1591,85 @@ export class FleetManager {
         child.once("error", err => this.failUpdateProgress(err.message));
         child.unref();
     }
+    async handleProfileSlash(data, adapterId) {
+        const route = this.routing.resolve(data.channelId);
+        await this.handleGeneralProfile(route?.kind === "general" ? route.name : undefined, data.userId, adapterId, data.options?.seconds, data.respond);
+    }
+    /** Typed /profile belongs only to Telegram's General dispatcher. */
+    async runProfileCommand(msg, seconds) {
+        if (msg.source !== "telegram")
+            return;
+        const adapterId = msg.adapterId ?? this.getPrimaryAdapterId();
+        const route = msg.threadId ? this.routing.resolve(msg.threadId) : undefined;
+        const general = msg.threadId ? (route?.kind === "general" ? route.name : undefined)
+            : Object.keys(this.fleetConfig?.instances ?? {}).find(name => this.fleetConfig.instances[name].general_topic
+                && this.getInstanceAdapterId(name) === adapterId);
+        const adapter = adapterId ? this.adapters.get(adapterId) : this.adapter;
+        if (!adapter)
+            return;
+        await this.handleGeneralProfile(general, msg.userId, adapterId, seconds, async (text) => (await adapter.sendText(msg.chatId, text, { threadId: msg.threadId })).messageId);
+    }
+    async handleGeneralProfile(general, userId, ingressAdapterId, seconds, respond) {
+        if (!general || !this.fleetConfig?.instances[general]?.general_topic) {
+            await respond(t("profile.general_only"));
+            return;
+        }
+        const ownerId = this.getInstanceAdapterId(general);
+        if (!ownerId || ownerId !== ingressAdapterId) {
+            await respond(t("not_authorized"));
+            return;
+        }
+        const gate = this.fleetAdminGate(userId, ownerId);
+        if (gate !== "ok") {
+            await respond(t(gate === "disabled" ? "profile.disabled" : "not_authorized"));
+            return;
+        }
+        const adapter = this.getAdapterForInstance(general);
+        const group = String(this.getGroupIdForInstance(general) ?? "");
+        const topic = this.fleetConfig.instances[general].topic_id?.toString();
+        if (!adapter || this.worlds.get(ownerId)?.adapter !== adapter || !group) {
+            await respond(t("profile.unavailable"));
+            return;
+        }
+        let duration;
+        try {
+            duration = profileDuration(seconds);
+        }
+        catch {
+            await respond(t("profile.invalid"));
+            return;
+        }
+        let ticket;
+        try {
+            ticket = await this.startCpuProfile(duration);
+        }
+        catch (err) {
+            await respond(err instanceof ProfileBusyError ? t("profile.busy", String(err.remainingSeconds)) : t("profile.unavailable"));
+            return;
+        }
+        // A long recording must not hold a Discord interaction (or the inbound handler) open.
+        const initial = Promise.resolve().then(() => respond(t("profile.started", String(ticket.seconds))));
+        void (async () => {
+            await initial.catch(err => this.logger.warn({ err }, "CPU profile acknowledgement failed"));
+            let message;
+            try {
+                const result = await ticket.done;
+                const size = result.bytes === null ? t("profile.size_unknown") : `${(result.bytes / 1048576).toFixed(2)} MiB`;
+                message = t("profile.saved", result.path, size);
+            }
+            catch {
+                message = t("profile.failed");
+            }
+            // Never send a delayed artifact path to a replacement adapter/topic/world.
+            if (this.shuttingDown || this.getInstanceAdapterId(general) !== ownerId
+                || this.getAdapterForInstance(general) !== adapter || String(this.getGroupIdForInstance(general) ?? "") !== group
+                || this.fleetConfig?.instances[general]?.topic_id?.toString() !== topic
+                || !this.fleetConfig?.instances[general]?.general_topic)
+                return;
+            await adapter.sendText(group, message, { threadId: topic });
+        })().catch(err => this.logger.warn({ err }, "CPU profile General notice failed"));
+        await initial.catch(() => { });
+    }
     async handleRestartSlash(data, adapterId) {
         if (!this.isFleetAdmin(data.userId, adapterId)) {
             await data.respond(t("not_authorized"));
@@ -2360,6 +2441,36 @@ export class FleetManager {
             return "disabled";
         return this.isFleetAdmin(userId, adapterId) ? "ok" : "denied";
     }
+    runtimeCpuProfiler = null;
+    cpuProfileControl = null;
+    getCpuProfiler() {
+        if (!this.runtimeCpuProfiler || (this.runtimeCpuProfiler.closed && !this.shuttingDown)) {
+            this.runtimeCpuProfiler = new RuntimeCpuProfiler({ dataDir: this.dataDir,
+                logger: { info: message => this.logger.info(message), warn: message => this.logger.warn(message) } });
+        }
+        return this.runtimeCpuProfiler;
+    }
+    /** Called only by cold CLI startup, after claiming the fleet singleton. */
+    async startCpuProfileControl() {
+        if (this.shuttingDown || this.cpuProfileControl)
+            return;
+        const control = new ProfileControlServer(this.dataDir, this.getCpuProfiler());
+        this.cpuProfileControl = control; // shutdown owns even an in-flight listen
+        try {
+            await control.listen();
+        }
+        catch (err) {
+            if (this.cpuProfileControl === control)
+                this.cpuProfileControl = null;
+            throw err;
+        }
+    }
+    startEnvironmentCpuProfile() { return this.getCpuProfiler().startFromEnvironment(); }
+    startCpuProfile(seconds) {
+        if (this.shuttingDown)
+            return Promise.reject(new Error("Fleet is stopping."));
+        return this.getCpuProfiler().start(seconds);
+    }
     /**
      * Every Discord slash command, for every adapter, in one place (it used to be two copies that could drift).
      *
@@ -2492,6 +2603,9 @@ export class FleetManager {
         else if (data.command === "update") {
             await this.handleUpdateSlash(data, adapterId);
         }
+        else if (data.command === "profile") {
+            await this.handleProfileSlash(data, adapterId);
+        }
         else if (data.command === "doctor") {
             await data.respond(await this.runBackendDoctor());
         }
@@ -5325,6 +5439,35 @@ export class FleetManager {
      * the message came from — its own world's group_id. Two Telegram fleet
      * worlds can number topics alike; a coincidence is dropped, never delivered.
      */
+    /**
+     * #1346: whether this copy may claim the shared dedup key for
+     * command-like text. Fleet topics resolve an owning adapter and only its
+     * copy proceeds; anything else (classic targets, unknown routing, no
+     * identity) passes through to the existing handling.
+     */
+    isOwnerCommandCopy(msg, threadId) {
+        if (!msg.adapterId || threadId === undefined)
+            return true;
+        const target = this.resolveInboundTarget(msg, threadId);
+        if (!target || target.kind === "classic")
+            return true;
+        const owner = this.getInstanceAdapterId(target.name);
+        if (owner && msg.adapterId !== owner)
+            return false;
+        // #1346 6b: /cmd@otherbot is addressed elsewhere — ignore it even on the
+        // owner's copy. An unknown username can't be judged: let it through (the
+        // receiver gate above still applies). Same case-insensitive rule as the
+        // Telegram classic branch.
+        // Hyphenated aliases count too (e.g. /install-cli): Telegram command
+        // names cannot contain "-", but typed aliases can.
+        const suffix = msg.text?.trim().match(/^\/[\w-]+@(\S+)/)?.[1];
+        if (suffix && owner) {
+            const ownerUser = this.worlds.get(owner)?.botUsername;
+            if (ownerUser && suffix.toLowerCase() !== ownerUser.toLowerCase())
+                return false;
+        }
+        return true;
+    }
     resolveInboundTarget(msg, threadId) {
         if (msg.source !== "telegram")
             return this.routing.resolve(threadId);
@@ -5388,6 +5531,16 @@ export class FleetManager {
         // EXCEPTION — classic channels with same-channel multi-bot: two bots may own
         // separate agents in one channel, so each bot must process its OWN copy of
         // the message (the @mention filter downstream decides who actually forwards).
+        // #1346: a non-owner adapter's copy of command-like text must not burn
+        // the shared dedup key — the owner's copy still has to run the command.
+        // (Non-command input keeps first-wins delivery.) Classic channels keep
+        // per-adapter keys — first-/start-contact onboarding needs every copy
+        // to flow — so only fleet targets are judged here; the in-handler gates
+        // (owner entry check, Discord ignore) cover classic instead.
+        if (msg.messageId && /^\/\w/.test(msg.text?.trim() ?? "") && !this.isOwnerCommandCopy(msg, threadId)) {
+            this.logger.debug({ adapterId: msg.adapterId, threadId }, "Non-owner command copy — skipping before dedup claim");
+            return;
+        }
         // Key the dedup per-adapter there so a sibling bot's copy isn't dropped.
         if (msg.messageId) {
             const classicCid = threadId || msg.chatId;
@@ -5716,11 +5869,14 @@ export class FleetManager {
                 // Unregistered group: ignore
                 return;
             }
-            // General topic: check /ctx /compact /collab first, then admin commands
+            // General topic: Discord /xxx gets the system note first (never a
+            // command); other sources fall through to the handlers below.
             const generalInstance = this.findGeneralInstance(msg.adapterId);
+            if (generalInstance && await this.replyDiscordNotACommand(msg, generalInstance))
+                return;
             if (generalInstance && await this.topicCommands.handleInstanceCommand(msg, generalInstance))
                 return;
-            if (await this.topicCommands.handleGeneralCommand(msg))
+            if (generalInstance && await this.topicCommands.handleGeneralCommand(msg, generalInstance))
                 return;
             // Forward to General Topic instance if configured
             if (generalInstance) {
@@ -5805,13 +5961,18 @@ export class FleetManager {
             return;
         }
         const instanceName = target.name;
+        // #1346: on Discord, plain-text /xxx runs no command — the owner posts
+        // the system note before the handlers below ever see the text.
+        if (await this.replyDiscordNotACommand(msg, instanceName)) {
+            return;
+        }
         // Intercept /ctx /compact /collab in ANY topic (including general)
         if (await this.topicCommands.handleInstanceCommand(msg, instanceName)) {
             return;
         }
         // Intercept admin commands (/status, /restart, /sysinfo) in general topics
         const instanceConfig = this.fleetConfig?.instances[instanceName];
-        if (instanceConfig?.general_topic && await this.topicCommands.handleGeneralCommand(msg)) {
+        if (instanceConfig?.general_topic && await this.topicCommands.handleGeneralCommand(msg, instanceName)) {
             return;
         }
         // Bind instance to the adapter that delivered this message
@@ -11077,13 +11238,50 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         this.failoverActive.clear();
     }
     // ── Classic Channel Methods ──────────────────────────────────────────
+    /**
+     * #1346: on Discord, plain-text /xxx is never a command — the slash menu
+     * is. Both fleet call sites run this BEFORE the command handlers, so even
+     * the owning adapter's copy never executes text. The owning adapter posts
+     * one system note and consumes the message so it never reaches the agent;
+     * other adapters' copies stay silent (and the shared dedup key means
+     * exactly one copy gets here). Telegram keeps text commands working —
+     * text is its command path — and other sources pass through untouched.
+     */
+    async replyDiscordNotACommand(msg, instanceName) {
+        if (msg.source !== "discord")
+            return false;
+        if (!/^\/\w/.test(msg.text?.trim() ?? ""))
+            return false;
+        const owner = this.getInstanceAdapterId(instanceName);
+        if (msg.adapterId && owner && msg.adapterId !== owner)
+            return false;
+        const adapter = this.worlds.get(owner ?? msg.adapterId ?? "")?.adapter ?? this.adapter;
+        if (!adapter)
+            return false;
+        await adapter.sendText(msg.chatId, t("cmd.not_a_command"), { threadId: msg.threadId });
+        return true;
+    }
     /** Handle a message in a classic channel: log it, forward only /chat messages */
     async handleClassicChannelMessage(instanceName, msg) {
         const text = msg.text ?? "";
         const channelId = msg.threadId ?? msg.chatId;
         const isCollabMode = this.classicChannels?.isCollab(channelId, msg.adapterId) ?? false;
-        // Handle /ctx in classic mode — always, regardless of collab mode
+        // #1346: Discord ClassicBot channels ignore plain-text /xxx silently —
+        // no warning (multi-bot groups must not all warn), no command, and no
+        // forward to the agent either. The received-reaction and chat-log paths
+        // below still run (a /chat ack is not a reply). Telegram keeps working
+        // (text is its command path there).
+        const discordSlashText = msg.source === "discord" && /^\/\w/.test(text.trim());
+        // Handle /ctx in classic mode — always, regardless of collab mode.
+        // Only the adapter that owns an entry in this channel answers; the
+        // per-adapter dedup key already scopes copies, this guards the rest.
+        // Discord /chat still flows through (its received-reaction below is an
+        // ack, not a reply); only its forward is skipped.
+        if (discordSlashText && !/^\/chat(\s|$)/.test(text.trim()))
+            return;
         if (text === "/ctx" || text.startsWith("/ctx@")) {
+            if (!this.classicChannels?.getInstanceByChannel(channelId, msg.adapterId))
+                return;
             const reply = await this.topicCommands.getCtxText(instanceName);
             const classicAdapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
             if (classicAdapter)
@@ -11185,7 +11383,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                     finalText = `${tags}\n${finalText}`;
                 }
             }
-            await this.forwardToClassicInstance(instanceName, finalText, msg, extraMeta);
+            // #1346: Discord typed /xxx is never forwarded (reacts above already ran).
+            if (!discordSlashText)
+                await this.forwardToClassicInstance(instanceName, finalText, msg, extraMeta);
             return;
         }
         // Normal mode: /chat trigger
@@ -11252,7 +11452,10 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                     .catch(e => this.logger.debug({ err: e.message }, "Auto-react failed"));
             }
         }
-        await this.forwardToClassicInstance(instanceName, finalText, msg, extraMeta);
+        // #1346: Discord typed /chat gets its received-reaction above but is
+        // never forwarded to the agent.
+        if (!discordSlashText)
+            await this.forwardToClassicInstance(instanceName, finalText, msg, extraMeta);
     }
     /** Download photo or document attachment to classic instance workspace inbox. Returns { path, kind } or undefined. */
     async saveClassicAttachment(instanceName, msg) {
@@ -12690,6 +12893,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // because we asked it to. Set synchronously — doStopAll runs to its first
         // await in the same tick as the signal handler, so no event can slip in.
         this.shuttingDown = true;
+        const profileStopped = this.runtimeCpuProfiler?.shutdown("fleet shutdown");
         this.ipcStoppingInstances.add("__fleet_stopping__");
         // Release held delivery promises before awaiting daemon shutdown, then
         // reject spawn work which has not started. Otherwise a storm backoff could
@@ -12718,6 +12922,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // A login/install window is a dedicated tmux server with its own TTL
         // timer and HTTP listener living in THIS process: without an explicit
         // shutdown it would outlive us as an owner-less login CLI (sol B3).
+        await profileStopped;
+        await this.cpuProfileControl?.close();
+        this.cpuProfileControl = null;
         await this.shutdownLoginWindows();
         // Cancel adapter retry timers
         for (const state of this.adapterState.values()) {