@songsid/agend 2.1.11-beta.6 → 2.1.12-beta.1

package/dist/fleet-manager.js

@@ -75,6 +75,7 @@ import { handleAgentRequest, ToolNotPermittedError } from "./agent-endpoint.js";
 import { ClassicChannelManager, getClassicBackendChoices, isSelectableClassicBackend, readClassicLastActivityAt } from "./classic-channel-manager.js";
 import { assertExplicitInstanceRemoval } from "./instance-removal.js";
 import { validateFleetConfig } from "./config-validator.js";
+import { presentationState, interactionSummary } from "./interaction-observation.js";
 import { readLastInboundAt } from "./daemon.js";
 import { clearPausedMarker, readPausedAt, readPauseReason, writePausedMarker } from "./pause-marker.js";
 import { DEFAULT_WARM_OVERFLOW, WakeCoordinator } from "./wake-coordinator.js";
@@ -97,7 +98,8 @@ import { PROVIDER_SECRET_SPECS, providerSecretSpec, providerRegistryEnvKeys, isR
 /** A self-restart is a whole service restart; 120s is the apply budget, not this. */
 const SELF_RESTART_DEADLINE_MS = 300_000;
 import { APPLY_FLEET_TARGET, ApplyJobStore, viewOf, } from "./apply-job.js";
-import { instanceCredentialProfile } from "./backend/credential-profile.js";
+import { credentialSwitchStartsFresh, instanceCredentialProfile } from "./backend/credential-profile.js";
+import { mergeBackendOptions, profileKey, profileName, profileOf } from "./classic-bindings.js";
 import { classifyInstanceChange, CLASSIC_HOT_CONFIG_KEYS, HOT_INSTANCE_CONFIG_KEYS, hotConfigUpdate, } from "./instance-config-impact.js";
 import { formatRestartProgressCompletion, RESTART_PROGRESS_TERMINAL_TIMEOUT_MS, RestartProgress, } from "./restart-progress.js";
 import { launchFullRestartHelper } from "./full-restart.js";
@@ -1774,6 +1776,21 @@ export class FleetManager {
             return null;
         return this.instanceStateCache.get(name)?.state ?? null;
     }
+    /** Pure read of the single daemon-owned observation; no probe/capture or second tracker. */
+    getInstanceInteraction(name) {
+        if (this.lifecycle.isPaused(name) || this.instanceProcessStatus.has(name))
+            return null;
+        const daemon = this.lifecycle.daemons.get(name);
+        if (daemon?.getProcessStatus?.() !== "running")
+            return null;
+        return daemon.getInteractionSnapshot?.() ?? null;
+    }
+    instancePresentation(name) {
+        const execution_state = this.getInstanceExecutionState(name);
+        const interaction = this.getInstanceInteraction(name);
+        return { state: presentationState(execution_state, interaction), execution_state,
+            interaction, interaction_summary: interactionSummary(interaction) };
+    }
     /**
      * Subscription providers currently relevant to this fleet. Stopped/crashed
      * rows do not keep a usage card alive, while persisted paused instances do.
@@ -1805,6 +1822,34 @@ export class FleetManager {
         }
         return providers;
     }
+    /** #1220: the login a running classic instance was launched on, from its own config; null when not running. */
+    classicLaunchedProfile(name) {
+        const launched = this.daemons.get(name)?.getConfigSnapshot?.();
+        return launched ? profileOf(launched.backend_options, launched.backend ?? "claude-code") : null;
+    }
+    /**
+     * #1220: whether a running classic instance's login differs from what its
+     * configuration now says — compared with what it was launched on, not with an
+     * earlier reading of the config (a reload consumes that), and with an invalid
+     * setting as a value of its own rather than the shared login it would fall to.
+     * A switch on the same backend that loses the conversation (kiro) starts fresh.
+     */
+    classicProfileChange(name, backendChanged) {
+        const launched = this.classicLaunchedProfile(name);
+        if (!launched || !this.classicChannels)
+            return { changed: false, startsFresh: false };
+        const next = this.classicChannels.getCredentialProfileByInstance(name, this.fleetConfig?.defaults);
+        if (profileKey(launched) === profileKey(next))
+            return { changed: false, startsFresh: false };
+        const backend = this.classicChannels.getBackendByInstance(name, this.fleetConfig?.defaults?.backend);
+        return {
+            changed: true,
+            // A backend change keeps its own (existing) restart semantics.
+            startsFresh: !backendChanged && credentialSwitchStartsFresh(backend),
+            from: profileKey(launched),
+            to: profileKey(next),
+        };
+    }
     /** `[instance, effective backend, credential profile]` for everything that is
      * running or paused — the one place both usage views agree on who is live. */
     activeBackendBindings() {
@@ -1823,8 +1868,9 @@ export class FleetManager {
         }
         for (const channel of this.classicChannels?.getAll() ?? []) {
             const backend = this.classicChannels?.getBackendByInstance(channel.instanceName, this.fleetConfig?.defaults?.backend);
-            // Classic channels carry no backend_options, so they run the shared login.
-            add(channel.instanceName, backend, null);
+            // The login it was launched on; before a launch, the one it would get (#1220).
+            add(channel.instanceName, backend, profileName(this.classicLaunchedProfile(channel.instanceName)
+                ?? this.classicChannels.getCredentialProfileByInstance(channel.instanceName, this.fleetConfig?.defaults)));
         }
         return bindings;
     }
@@ -2693,9 +2739,15 @@ export class FleetManager {
                 const backendChanged = oldBackends.get(ch.instanceName) !== newBackend;
                 const modelChanged = oldModels.get(ch.instanceName) !== newModel;
                 const autoPauseChanged = oldAutoPause.get(ch.instanceName) !== newAutoPause;
-                if (this.daemons.has(ch.instanceName) && (backendChanged || modelChanged || autoPauseChanged)) {
-                    this.logger.info({ instanceName: ch.instanceName, backendFrom: oldBackends.get(ch.instanceName), backendTo: newBackend, modelFrom: oldModels.get(ch.instanceName), modelTo: newModel }, "Backend/model changed — restarting");
+                // #1220: a running CLI keeps the login it was launched with, so a new
+                // credential_profile only takes effect through a restart.
+                const { changed: profileChanged, startsFresh: profileSwitchStartsFresh, from: profileFrom, to: profileTo } = this.classicProfileChange(ch.instanceName, backendChanged);
+                if (this.daemons.has(ch.instanceName) && (backendChanged || modelChanged || autoPauseChanged || profileChanged)) {
+                    this.logger.info({ instanceName: ch.instanceName, backendFrom: oldBackends.get(ch.instanceName), backendTo: newBackend, modelFrom: oldModels.get(ch.instanceName), modelTo: newModel,
+                        ...(profileChanged ? { profileFrom, profileTo } : {}) }, "Backend/model/profile changed — restarting");
                     await this.stopInstance(ch.instanceName).catch(() => { });
+                    if (profileSwitchStartsFresh)
+                        this.writeFreshStartMarker(ch.instanceName);
                     // Small delay to let tmux window clean up
                     await new Promise(r => setTimeout(r, 2000));
                     // The manager already holds the new backend/model/auto-pause; the
@@ -12123,6 +12175,17 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             ...(autoPauseAfter !== undefined ? { auto_pause_after: autoPauseAfter } : {}),
             ...(preTaskCommand ? { pre_task_command: preTaskCommand } : {}),
         };
+        // #1220: a channel's own backend_options (credential_profile) override the
+        // fleet defaults' per backend, as a fleet.yaml instance's do.
+        config.backend_options = mergeBackendOptions(config.backend_options, classicIdentity?.backendOptions);
+        // ClassicBot has no validator in front of its launch, and a backend that
+        // cannot read a profile name falls back to the shared login. Refuse here,
+        // so a bad name never runs the agent on the wrong subscription.
+        const profile = profileOf(config.backend_options, config.backend ?? "claude-code");
+        if (profile.state === "invalid") {
+            throw new Error(`Classic instance '${instanceName}' has an invalid credential_profile (${profile.reason}) — `
+                + "fix it in classicBot.yaml; it will not start on another login");
+        }
         const topicMode = this.fleetConfig?.channel?.mode === "topic";
         await this.startInstance(instanceName, config, topicMode, "classic", false, transition);
     }
@@ -12631,10 +12694,13 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 const backend = this.classicChannels.getBackend(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.backend);
                 const model = this.classicChannels.getModel(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.model);
                 const autoPauseAfter = this.classicChannels.getAutoPauseAfter(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.auto_pause_after);
-                if (old.backend !== backend || old.model !== model || old.autoPauseAfter !== autoPauseAfter) {
-                    this.logger.info({ instanceName: ch.instanceName }, "Classic cold config changed — restarting");
+                const profile = this.classicProfileChange(ch.instanceName, old.backend !== backend);
+                if (old.backend !== backend || old.model !== model || old.autoPauseAfter !== autoPauseAfter || profile.changed) {
+                    this.logger.info({ instanceName: ch.instanceName, ...(profile.changed ? { profileFrom: profile.from, profileTo: profile.to } : {}) }, "Classic cold config changed — restarting");
                     observe?.(ch.instanceName, "restart", "running");
                     await this.stopInstance(ch.instanceName).catch(() => { });
+                    if (profile.startsFresh)
+                        this.writeFreshStartMarker(ch.instanceName);
                     await this.startClassicInstanceUnattended(ch, "classic instance after fleet reload");
                     observe?.(ch.instanceName, "restart", "done");
                     continue;
@@ -14247,7 +14313,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                             lastActivity,
                             currentTask,
                             idle: this.getInstanceIdle(inst.name),
-                            state: this.getInstanceExecutionState(inst.name),
+                            ...this.instancePresentation(inst.name),
                         };
                     });
                     res.setHeader("Access-Control-Allow-Origin", "*");
@@ -14504,6 +14570,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 backend,
                 effort,
                 effort_source,
+                ...this.instancePresentation(name),
             };
         });
         return {