@songsid/agend 2.3.0-beta.9 → 2.3.1

package/dist/outbound-handlers.js

@@ -93,6 +93,30 @@ function targetState(ctx, name) {
         return "running";
     return "stopped";
 }
+/**
+ * #2327: the sender's warning about a recipient in an error state, naming only what is known. One detected error
+ * pattern puts a daemon in that state, so it is "showed … and is waiting to recover" — "paused" only when the
+ * recipient is actually paused, and never "repeated" (nothing counts occurrences).
+ */
+function recipientWarning(daemon, targetName, paused) {
+    if (!daemon?.isErrorState)
+        return undefined;
+    if (daemon.isCrashLoop)
+        return t("delivery.target_crash", targetName);
+    if (daemon.errorStateCause === "unsupervised")
+        return t("delivery.target_unsupervised", targetName);
+    if (daemon.errorStateCause === "tmux_recovering")
+        return t("delivery.target_tmux", targetName);
+    if (daemon.errorStateCause !== "error_detected")
+        return undefined;
+    const type = daemon.lastErrorType;
+    const seen = t(type === "rate_limit" || type === "timeout" ? "delivery.seen_limit"
+        : type === "quota" ? "delivery.seen_quota"
+            : type === "auth_error" ? "delivery.seen_auth"
+                : "delivery.seen_error");
+    const warning = t(paused ? "delivery.target_paused_after" : "delivery.target_detected", targetName, seen);
+    return type === "auth_error" ? `${warning} ${t("delivery.check_credentials")}` : warning;
+}
 /** Cross-instance delivery retries: same shape the scheduler already uses. */
 const CROSS_INSTANCE_RETRY_DEFAULTS = { retries: 3, intervalMs: 30_000 };
 let crossInstanceRetry = { ...CROSS_INSTANCE_RETRY_DEFAULTS };
@@ -413,17 +437,12 @@ const sendToInstance = async (ctx, rawArgs, respond, meta) => {
     ctx.logger.info(`✉ ${senderLabel} → ${targetName}: ${(message ?? "").slice(0, 100)} [msg=${ipcMeta.message_id} sha=${deliveryContentDigest(message ?? "").slice(0, 12)}]`);
     const taskSummary = ipcMeta.task_summary || (message ?? "").slice(0, 200);
     ctx.eventLog?.logActivity("message", senderLabel, taskSummary, targetName, ipcMeta.request_kind);
+    // #2293: indexed for the dashboard's search as the outbox keeps it (a retried call the outbox admitted before: not again).
+    if (!durableReceipt?.duplicate)
+        ctx.indexCrossInstance?.({ messageId: ipcMeta.message_id, from: senderLabel, to: targetName, kind: ipcMeta.request_kind,
+            correlationId: ipcMeta.correlation_id, taskSummary: ipcMeta.task_summary, content: message ?? "", ts: ipcMeta.ts });
     ctx.queueMirrorMessage?.(`${displayLabel(senderLabel)} → ${displayLabel(targetName)}: ${truncatePreview(message ?? "", 500)}`);
-    const targetDaemon = ctx.lifecycle.daemons.get(targetInstanceName);
-    const targetStateWarning = targetDaemon?.isErrorState
-        ? targetDaemon.isCrashLoop
-            ? t("delivery.target_crash", targetName)
-            : targetDaemon.lastErrorType === "rate_limit" || targetDaemon.lastErrorType === "timeout"
-                ? t("delivery.target_limit", targetName)
-                : targetDaemon.lastErrorType === "auth_error"
-                    ? t("delivery.target_auth", targetName)
-                    : t("delivery.target_error", targetName)
-        : undefined;
+    const targetStateWarning = recipientWarning(ctx.lifecycle.daemons.get(targetInstanceName), targetName, state === "paused");
     const warnings = [steerFallbackWarning, targetStateWarning].filter((value) => !!value);
     respond({ sent: true, queued: true, target: targetName, target_state: state,
         ...(forwards?.length ? { forwards } : {}),
@@ -672,7 +691,7 @@ const startInstance = async (ctx, rawArgs, respond) => {
     // marker is cleared and the next state snapshot is visible to `agend ls`.
     if (ctx.lifecycle.isPaused?.(targetName)) {
         try {
-            await (ctx.explicitWake ? ctx.explicitWake(targetName, 30_000) : ctx.lifecycle.wake(targetName, 30_000));
+            await (ctx.explicitWake ? ctx.explicitWake(targetName, 30_000, true) : ctx.lifecycle.wake(targetName, 30_000));
             respond({ success: true, status: "started" });
         }
         catch (err) {
@@ -686,7 +705,7 @@ const startInstance = async (ctx, rawArgs, respond) => {
         const status = ctx.getInstanceStatus?.(targetName);
         if (status === "crashed" || status === "stopped") {
             try {
-                await ctx.restartSingleInstance(targetName);
+                await ctx.restartSingleInstance(targetName, { explicit: true });
                 respond({ success: true, status: "started" });
             }
             catch (err) {
@@ -700,7 +719,7 @@ const startInstance = async (ctx, rawArgs, respond) => {
     const targetConfig = ctx.fleetConfig?.instances[targetName];
     if (targetConfig) {
         try {
-            await ctx.startInstance(targetName, targetConfig, true);
+            await ctx.startInstance(targetName, targetConfig, true, "fleet-topic", true);
             await ctx.connectIpcToInstance(targetName);
             respond({ success: true, status: "started" });
         }
@@ -713,7 +732,7 @@ const startInstance = async (ctx, rawArgs, respond) => {
     const channelId = ctx.classicChannels?.getChannelIdByInstance?.(targetName);
     if (channelId) {
         try {
-            await ctx.restartSingleInstance(targetName);
+            await ctx.restartSingleInstance(targetName, { explicit: true });
             respond({ success: true, status: "started" });
         }
         catch (err) {
@@ -763,7 +782,7 @@ const wakeInstance = async (ctx, rawArgs, respond) => {
         return;
     }
     try {
-        await (ctx.explicitWake ? ctx.explicitWake(v.data.name) : ctx.lifecycle.wake(v.data.name));
+        await (ctx.explicitWake ? ctx.explicitWake(v.data.name, 30_000, true) : ctx.lifecycle.wake(v.data.name));
         respond({ success: true, status: "waking" });
     }
     catch (err) {
@@ -792,11 +811,37 @@ const stopInstance = async (ctx, rawArgs, respond) => {
 };
 const getFleetStatus = (ctx, rawArgs, respond) => {
     const instances = ctx.fleetConfig?.instances ?? {};
-    const names = Object.keys(instances);
-    const running = names.filter(n => ctx.lifecycle.daemons.has(n) && !ctx.lifecycle.isPaused(n)).length;
-    const paused = names.filter(n => ctx.lifecycle.isPaused(n)).length;
-    const stopped = names.length - running - paused;
-    respond({ total: names.length, running, paused, stopped });
+    const fleetNames = Object.keys(instances);
+    const fleetRunning = fleetNames.filter(n => ctx.lifecycle.daemons.has(n) && !ctx.lifecycle.isPaused(n)).length;
+    const fleetPaused = fleetNames.filter(n => ctx.lifecycle.isPaused(n)).length;
+    const fleetStopped = fleetNames.length - fleetRunning - fleetPaused;
+    // Classic channels — same status source as list_instances and agend ls.
+    // Dedup: skip names already in the fleet (same-name fleet instance wins),
+    // AND skip classic names already seen (two channels can share an instanceName).
+    const fleetNameSet = new Set(fleetNames);
+    const seenClassic = new Set();
+    const classicAll = [];
+    if (ctx.classicChannels) {
+        for (const ch of ctx.classicChannels.getAll()) {
+            if (fleetNameSet.has(ch.instanceName))
+                continue;
+            if (seenClassic.has(ch.instanceName))
+                continue;
+            seenClassic.add(ch.instanceName);
+            classicAll.push(ch.instanceName);
+        }
+    }
+    const classicRunning = classicAll.filter(n => ctx.lifecycle.daemons.has(n) && !ctx.lifecycle.isPaused(n)).length;
+    const classicPaused = classicAll.filter(n => ctx.lifecycle.isPaused(n)).length;
+    const classicStopped = classicAll.length - classicRunning - classicPaused;
+    respond({
+        total: fleetNames.length + classicAll.length,
+        running: fleetRunning + classicRunning,
+        paused: fleetPaused + classicPaused,
+        stopped: fleetStopped + classicStopped,
+        fleet: { total: fleetNames.length, running: fleetRunning, paused: fleetPaused, stopped: fleetStopped },
+        classic: { total: classicAll.length, running: classicRunning, paused: classicPaused, stopped: classicStopped },
+    });
 };
 const kiroEngineStatusHandler = (ctx, rawArgs, respond) => {
     const v = validateArgs(KiroEngineStatusArgs, rawArgs, "kiro_engine_status");
@@ -1554,7 +1599,10 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
     const senderLabel = meta.senderSessionName ?? meta.instanceName;
     const operationId = ctx.admitDurableDelivery ? meta.operationId ?? randomUUID() : meta.operationId;
     const senderDisplay = ctx.fleetConfig?.instances[senderLabel]?.display_name;
-    const makeBroadcastMeta = (correlationId, messageId = `bcast-${Date.now()}`) => {
+    // One message id for this broadcast — every target's row shares it (delivery_status by message_id finds them all) —
+    // and no other broadcast's: a millisecond alone is not unique (#2295 review; the search index keys on it).
+    const broadcastMessageId = `bcast-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const makeBroadcastMeta = (correlationId, messageId = broadcastMessageId) => {
         const ipcMeta = {
             chat_id: "", message_id: messageId, user: `instance:${senderLabel}`,
             user_id: `instance:${senderLabel}`, ts: new Date().toISOString(), thread_id: "",
@@ -1573,7 +1621,7 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
     // Validate once before dispatching any target. The placeholders are the
     // longest values generated below, so every real per-target envelope fits if
     // this one does. Keeping this outside the loop prevents partial broadcasts.
-    if (rejectOversizedCrossInstanceEnvelope(message, makeBroadcastMeta("bcast-9999999999999-zzzzzz", "bcast-9999999999999"), respond, "either"))
+    if (rejectOversizedCrossInstanceEnvelope(message, makeBroadcastMeta("bcast-9999999999999-zzzzzz", "bcast-9999999999999-zzzzzz"), respond, "either"))
         return;
     // Resolve target list: team, explicit targets, tag filter, or all running
     let targetNames;
@@ -1603,6 +1651,7 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
     // target's idle gate blocked for as long as the BUSIEST recipient. Connectivity
     // is decided synchronously (that's the real failure), delivery runs in background.
     const sentTo = [];
+    const sentMeta = new Map();
     const failed = [];
     for (const targetName of targetNames) {
         const hostInstance = ctx.instanceIpcClients.has(targetName) ? targetName : ctx.sessionRegistry.get(targetName);
@@ -1613,9 +1662,10 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
         const correlationId = `bcast-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         const ipcMeta = makeBroadcastMeta(correlationId);
         const payload = { type: "fleet_inbound", targetSession: targetName, content: message, meta: ipcMeta };
+        let duplicate = false;
         if (ctx.admitDurableDelivery) {
             try {
-                ctx.admitDurableDelivery({
+                duplicate = ctx.admitDurableDelivery({
                     operationId: operationId,
                     sourceDaemonBootId: meta.sourceDaemonBootId ?? ctx.getDaemonBootId?.(meta.instanceName),
                     sourceInstance: meta.instanceName,
@@ -1624,7 +1674,7 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
                     kind: "broadcast",
                     correlationId,
                     payload,
-                });
+                })?.duplicate === true;
             }
             catch (err) {
                 ctx.logger.error({ err, target: targetName, source: meta.instanceName }, "Durable broadcast admission failed closed");
@@ -1637,11 +1687,18 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
             void deliverCrossInstanceWithRetry(ctx, hostInstance, targetName, senderLabel, correlationId, payload);
         }
         sentTo.push(targetName);
+        // #2293: indexed as the outbox keeps it — a retried call the outbox admitted before keeps the first call's row.
+        if (!duplicate)
+            sentMeta.set(targetName, ipcMeta);
     }
     ctx.logger.info(`📢 ${senderLabel} broadcast to ${sentTo.length} instances: ${(message).slice(0, 80)}`);
     const summary = task_summary || message.slice(0, 200);
     for (const target of sentTo) {
         ctx.eventLog?.logActivity("message", senderLabel, summary, target);
+        const sent = sentMeta.get(target);
+        if (sent)
+            ctx.indexCrossInstance?.({ messageId: sent.message_id, from: senderLabel, to: target, kind: sent.request_kind ?? "broadcast",
+                correlationId: sent.correlation_id, taskSummary: task_summary, content: message, ts: sent.ts });
     }
     // Mirror Topic is user-facing: display labels, never long ids (#1301),
     // unique across the fleet (#1305 P2-1).