@songsid/agend 2.1.5-beta.21 → 2.1.5-beta.23

package/dist/fleet-manager.d.ts

@@ -139,6 +139,16 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private topicCleanupInFlight;
     private topicCleanupGeneration;
     private topicProbeWarnings;
+    /**
+     * Consecutive unknown probe results per route (or per adapter for outage
+     * class reasons). A single transient never reaches the operator; only a
+     * streak of TOPIC_PROBE_UNKNOWN_ESCALATION does.
+     */
+    private topicProbeUnknownStreak;
+    /** Unknown results in a row before the operator is told. 3 × 5 min poller = 15 min. */
+    static readonly TOPIC_PROBE_UNKNOWN_ESCALATION = 3;
+    /** Reasons that describe the adapter, not one topic — counted once per adapter. */
+    private static readonly TOPIC_PROBE_ADAPTER_SCOPED_REASONS;
     logger: Logger;
     private topicCommands;
     sessionRegistry: Map<string, string>;
@@ -437,8 +447,14 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Fleet admin is an explicit config allowlist entry, not merely an open/paired user. */
     isFleetAdmin(userId: string, adapterId?: string): boolean;
     changeInstancePauseState(name: string, action: "pause" | "wake"): Promise<"paused" | "awake" | "not_idle">;
+    /** Deliver an already-resolved hot snapshot without depending on IPC timing. */
+    private applyHotConfigUpdate;
+    private classicBehaviorUpdate;
     /** Apply a Settings edit to a ClassicBot channel without waiting for the poller. */
-    restartClassicInstanceFromSettings(instanceName: string): Promise<void>;
+    restartClassicInstanceFromSettings(instanceName: string, changedFields?: string[]): Promise<void>;
+    /** Reload classicBot.yaml once. Kept callable so the periodic production
+     * path is covered without relying on fake timers around startAll(). */
+    private reloadClassicConfigFromDisk;
     startInstance(name: string, config: InstanceConfig, topicMode: boolean, kind?: "fleet-topic" | "classic", 
     /**
      * Explicit starts (CLI/API) may resume a paused or failed daemon.  Startup
@@ -770,7 +786,32 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private scheduleTopicCleanup;
     private confirmedProbeFence;
     private sameProbeFence;
+    private topicProbeStreakKey;
+    /** A definite answer (present or missing) ends the unknown streak for that route and its adapter. */
+    private clearTopicProbeUnknownStreak;
+    /**
+     * Record one unknown probe result. Nothing here can touch quarantine or
+     * removal: unknown is always retained data. The only question is whether
+     * the operator hears about it, and a single transient (one flaky HTTP call
+     * out of dozens per pass) must not — only a streak does.
+     *
+     * Used directly for single-route events (channelDelete, the pre-action
+     * fence). The periodic scan goes through a TopicProbePass instead, so one
+     * pass over N routes of a dead adapter counts as ONE check, not N.
+     */
     private warnTopicProbeUnknown;
+    /** One scan's worth of probe outcomes, applied to the streaks after the loop. */
+    private newTopicProbePass;
+    private passTopicProbeUnknown;
+    private passTopicProbeDefinite;
+    /**
+     * Apply a pass: a definite answer resets its keys, and an adapter that
+     * answered for any route this pass is evidently alive, so an unknown for the
+     * same adapter key in the same pass does not count — regardless of the order
+     * the routes happened to be probed in.
+     */
+    private applyTopicProbePass;
+    private noteTopicProbeUnknown;
     /** One fixed-snapshot topology pass. Automatic evidence can only quarantine. */
     private runTopicCleanup;
     /**

package/dist/fleet-manager.js

@@ -181,6 +181,7 @@ const DELIVERY_STATUS_EMOJIS = new Set(["👀", "⏳", "✅", "❌"]);
 const IGNORED_REACTION_EMOJIS = new Set(["📷"]);
 const HOT_INSTANCE_CONFIG_KEYS = new Set([
     "tool_progress",
+    "reply_completion_guard",
     "mcp_proxy_reply",
     "auto_pause_after",
     "warm_cap",
@@ -321,6 +322,29 @@ export class FleetManager {
     topicCleanupInFlight = null;
     topicCleanupGeneration = 0;
     topicProbeWarnings = new Map();
+    /**
+     * Consecutive unknown probe results per route (or per adapter for outage
+     * class reasons). A single transient never reaches the operator; only a
+     * streak of TOPIC_PROBE_UNKNOWN_ESCALATION does.
+     */
+    topicProbeUnknownStreak = new Map();
+    /** Unknown results in a row before the operator is told. 3 × 5 min poller = 15 min. */
+    static TOPIC_PROBE_UNKNOWN_ESCALATION = 3;
+    /** Reasons that describe the adapter, not one topic — counted once per adapter. */
+    static TOPIC_PROBE_ADAPTER_SCOPED_REASONS = new Set([
+        "owner-adapter-unavailable",
+        "owner-adapter-not-ready",
+        "owner-adapter-generation-changed",
+        "owner-adapter-changed-before-action",
+        "adapter-not-ready",
+        "adapter-not-initialized",
+        "adapter-generation-changed",
+        "topic-close-from-unready-adapter",
+        "topic-close-generation-changed",
+        // Telegram probe: the transport or Telegram itself is down, not one topic.
+        "transport-failed",
+        "provider-unavailable",
+    ]);
     logger = createLogger("info");
     topicCommands;
     // sessionName → instanceName mapping for external sessions
@@ -1482,8 +1506,27 @@ export class FleetManager {
         await this.lifecycle.pause(name);
         return this.lifecycle.isPaused(name) ? "paused" : "not_idle";
     }
+    /** Deliver an already-resolved hot snapshot without depending on IPC timing. */
+    applyHotConfigUpdate(instanceName, update) {
+        const daemon = this.daemons.get(instanceName);
+        if (!daemon)
+            return false;
+        const ipc = this.instanceIpcClients.get(instanceName);
+        const sent = ipc?.connected === true && ipc.send({ type: "config_update", config: update });
+        if (!sent) {
+            daemon.applyConfigUpdate(update);
+            this.logger.warn({ name: instanceName }, "Config-update IPC unavailable — applied hot config in-process");
+        }
+        return true;
+    }
+    classicBehaviorUpdate(instanceName) {
+        return {
+            tool_progress: this.classicChannels?.getToolProgressByInstance(instanceName, this.fleetConfig?.defaults?.tool_progress) ?? "off",
+            reply_completion_guard: this.classicChannels?.getReplyCompletionGuardByInstance(instanceName, this.fleetConfig?.defaults?.reply_completion_guard) ?? true,
+        };
+    }
     /** Apply a Settings edit to a ClassicBot channel without waiting for the poller. */
-    async restartClassicInstanceFromSettings(instanceName) {
+    async restartClassicInstanceFromSettings(instanceName, changedFields = []) {
         if (!this.classicChannels)
             throw new Error("Classic channel manager not initialized");
         const wasRunning = this.daemons.has(instanceName);
@@ -1495,10 +1538,77 @@ export class FleetManager {
             throw new Error("Classic channel not found after reload");
         if (!wasRunning)
             return;
+        const hotOnly = changedFields.length > 0
+            && changedFields.every(field => field === "tool_progress" || field === "reply_completion_guard");
+        if (hotOnly) {
+            this.applyHotConfigUpdate(instanceName, this.classicBehaviorUpdate(instanceName));
+            this.logger.info({ instanceName, fields: changedFields }, "Classic instance hot config reloaded");
+            return;
+        }
         await this.stopInstance(instanceName);
         await new Promise(resolve => setTimeout(resolve, 250));
         await this.startClassicInstance(instanceName, this.classicChannels.getBackendByInstance(instanceName, this.fleetConfig?.defaults?.backend), this.classicChannels.getPreTaskCommand(channel.channelId, channel.adapterId), this.classicChannels.getModel(channel.channelId, channel.adapterId, this.fleetConfig?.defaults?.model), this.classicChannels.getAutoPauseAfter(channel.channelId, channel.adapterId, this.fleetConfig?.defaults?.auto_pause_after));
     }
+    /** Reload classicBot.yaml once. Kept callable so the periodic production
+     * path is covered without relying on fake timers around startAll(). */
+    async reloadClassicConfigFromDisk() {
+        try {
+            if (!this.classicChannels)
+                return;
+            const fleetBackend = this.fleetConfig?.defaults?.backend;
+            const fleetModel = this.fleetConfig?.defaults?.model;
+            const oldBackends = new Map();
+            const oldModels = new Map();
+            const oldAutoPause = new Map();
+            const oldToolProgress = new Map();
+            const oldReplyGuard = new Map();
+            for (const ch of this.classicChannels.getAll()) {
+                oldBackends.set(ch.instanceName, this.classicChannels.getBackendByInstance(ch.instanceName, fleetBackend));
+                oldModels.set(ch.instanceName, this.classicChannels.getModel(ch.channelId, ch.adapterId, fleetModel));
+                oldAutoPause.set(ch.instanceName, this.classicChannels.getAutoPauseAfter(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.auto_pause_after));
+                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())
+                return;
+            // A reload can introduce a bad id (hand edit) or clear one; the
+            // throttle keeps a repeated report from flooding the topic.
+            this.reportClassicUnrecoverableIds();
+            this.reregisterClassicChannels();
+            for (const ch of this.classicChannels.getAll()) {
+                const newBackend = this.classicChannels.getBackendByInstance(ch.instanceName, fleetBackend);
+                const newModel = this.classicChannels.getModel(ch.channelId, ch.adapterId, fleetModel);
+                const newAutoPause = this.classicChannels.getAutoPauseAfter(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.auto_pause_after);
+                const newToolProgress = this.classicChannels.getToolProgress(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.tool_progress);
+                const newReplyGuard = this.classicChannels.getReplyCompletionGuard(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.reply_completion_guard);
+                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");
+                    await this.stopInstance(ch.instanceName).catch(() => { });
+                    // 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
+                    // unattended helper reads them from it and schedules the delayed
+                    // retry on failure like every other unattended start.
+                    await this.startClassicInstanceUnattended(ch, "classic instance after backend/model change");
+                }
+                else if (this.daemons.has(ch.instanceName)
+                    && (oldToolProgress.get(ch.instanceName) !== newToolProgress
+                        || oldReplyGuard.get(ch.instanceName) !== newReplyGuard)) {
+                    this.applyHotConfigUpdate(ch.instanceName, {
+                        tool_progress: newToolProgress,
+                        reply_completion_guard: newReplyGuard,
+                    });
+                    this.logger.info({ instanceName: ch.instanceName }, "Classic instance hot config reloaded");
+                }
+            }
+        }
+        catch (err) {
+            this.logger.warn({ err }, "classicBot.yaml reload error");
+        }
+    }
     async startInstance(name, config, topicMode, kind = "fleet-topic", 
     /**
      * Explicit starts (CLI/API) may resume a paused or failed daemon.  Startup
@@ -2356,48 +2466,8 @@ export class FleetManager {
                 this.instanceWorldBinding.set(ch.instanceName, ch.adapterId);
         }
         // Poll classicBot.yaml for external changes every 30s
-        this.classicReloadTimer = setInterval(async () => {
-            try {
-                if (!this.classicChannels)
-                    return;
-                const fleetBackend = this.fleetConfig?.defaults?.backend;
-                const fleetModel = this.fleetConfig?.defaults?.model;
-                const oldBackends = new Map();
-                const oldModels = new Map();
-                const oldAutoPause = new Map();
-                for (const ch of this.classicChannels.getAll()) {
-                    oldBackends.set(ch.instanceName, this.classicChannels.getBackendByInstance(ch.instanceName, fleetBackend));
-                    oldModels.set(ch.instanceName, this.classicChannels.getModel(ch.channelId, ch.adapterId, fleetModel));
-                    oldAutoPause.set(ch.instanceName, this.classicChannels.getAutoPauseAfter(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.auto_pause_after));
-                }
-                if (!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.
-                this.reportClassicUnrecoverableIds();
-                this.reregisterClassicChannels();
-                for (const ch of this.classicChannels.getAll()) {
-                    const newBackend = this.classicChannels.getBackendByInstance(ch.instanceName, fleetBackend);
-                    const newModel = this.classicChannels.getModel(ch.channelId, ch.adapterId, fleetModel);
-                    const newAutoPause = this.classicChannels.getAutoPauseAfter(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.auto_pause_after);
-                    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");
-                        await this.stopInstance(ch.instanceName).catch(() => { });
-                        // 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
-                        // unattended helper reads them from it and schedules the delayed
-                        // retry on failure like every other unattended start.
-                        await this.startClassicInstanceUnattended(ch, "classic instance after backend/model change");
-                    }
-                }
-            }
-            catch (err) {
-                this.logger.warn({ err }, "classicBot.yaml reload error");
-            }
+        this.classicReloadTimer = setInterval(() => {
+            void this.reloadClassicConfigFromDisk();
         }, 30_000);
         const costGuardConfig = {
             ...DEFAULT_COST_GUARD,
@@ -5488,15 +5558,74 @@ export class FleetManager {
             return false;
         return result?.generation === undefined || result.generation === after.generation;
     }
-    warnTopicProbeUnknown(instanceName, threadId, adapterId, reason) {
+    topicProbeStreakKey(threadId, adapterId, reason) {
+        return FleetManager.TOPIC_PROBE_ADAPTER_SCOPED_REASONS.has(reason)
+            ? `adapter:${adapterId ?? "unbound"}`
+            : `thread:${threadId}`;
+    }
+    /** A definite answer (present or missing) ends the unknown streak for that route and its adapter. */
+    clearTopicProbeUnknownStreak(threadId, adapterId) {
+        this.topicProbeUnknownStreak.delete(`thread:${threadId}`);
+        this.topicProbeUnknownStreak.delete(`adapter:${adapterId ?? "unbound"}`);
+    }
+    /**
+     * Record one unknown probe result. Nothing here can touch quarantine or
+     * removal: unknown is always retained data. The only question is whether
+     * the operator hears about it, and a single transient (one flaky HTTP call
+     * out of dozens per pass) must not — only a streak does.
+     *
+     * Used directly for single-route events (channelDelete, the pre-action
+     * fence). The periodic scan goes through a TopicProbePass instead, so one
+     * pass over N routes of a dead adapter counts as ONE check, not N.
+     */
+    warnTopicProbeUnknown(instanceName, threadId, adapterId, reason, detail) {
+        this.noteTopicProbeUnknown(this.topicProbeStreakKey(threadId, adapterId, reason), { instanceName, threadId, adapterId, reason, detail });
+    }
+    /** One scan's worth of probe outcomes, applied to the streaks after the loop. */
+    newTopicProbePass() {
+        return { unknown: new Map(), definite: new Set() };
+    }
+    passTopicProbeUnknown(pass, instanceName, threadId, adapterId, reason, detail) {
+        const key = this.topicProbeStreakKey(threadId, adapterId, reason);
+        // First unknown per key per pass wins; the rest of the routes on a dead
+        // adapter are the same observation, not additional checks.
+        if (!pass.unknown.has(key))
+            pass.unknown.set(key, { instanceName, threadId, adapterId, reason, detail });
+    }
+    passTopicProbeDefinite(pass, threadId, adapterId) {
+        pass.definite.add(`thread:${threadId}`);
+        pass.definite.add(`adapter:${adapterId ?? "unbound"}`);
+    }
+    /**
+     * Apply a pass: a definite answer resets its keys, and an adapter that
+     * answered for any route this pass is evidently alive, so an unknown for the
+     * same adapter key in the same pass does not count — regardless of the order
+     * the routes happened to be probed in.
+     */
+    applyTopicProbePass(pass) {
+        for (const key of pass.definite)
+            this.topicProbeUnknownStreak.delete(key);
+        for (const [key, ctx] of pass.unknown) {
+            if (pass.definite.has(key))
+                continue;
+            this.noteTopicProbeUnknown(key, ctx);
+        }
+    }
+    noteTopicProbeUnknown(streakKey, { instanceName, threadId, adapterId, reason, detail }) {
+        const streak = (this.topicProbeUnknownStreak.get(streakKey) ?? 0) + 1;
+        this.topicProbeUnknownStreak.set(streakKey, streak);
+        if (streak < FleetManager.TOPIC_PROBE_UNKNOWN_ESCALATION) {
+            this.logger.debug({ instanceName, threadId, adapterId, reason, detail, streak }, "Topic presence not confirmed this pass — transient, retaining instance and all data");
+            return;
+        }
         const key = `${adapterId ?? "unbound"}:${reason}`;
         const now = Date.now();
         const last = this.topicProbeWarnings.get(key) ?? 0;
         if (now - last < FleetManager.FLEET_ERROR_THROTTLE_MS)
             return;
         this.topicProbeWarnings.set(key, now);
-        this.logger.error({ instanceName, threadId, adapterId, reason }, "Topic presence could not be confirmed — retaining instance and all data");
-        this.notifyFleetError(t("fleet.topic_probe_unknown", instanceName, adapterId ?? "unbound"));
+        this.logger.error({ instanceName, threadId, adapterId, reason, detail, streak }, "Topic presence could not be confirmed repeatedly — retaining instance and all data");
+        this.notifyFleetError(t("fleet.topic_probe_unknown", instanceName, adapterId ?? "unbound", streak));
     }
     /** One fixed-snapshot topology pass. Automatic evidence can only quarantine. */
     async runTopicCleanup(generation) {
@@ -5504,6 +5633,8 @@ export class FleetManager {
             return;
         const snapshot = [...this.routing.entries()].filter(([, target]) => isProbeableRouteTarget(target));
         const missing = [];
+        const pass = this.newTopicProbePass();
+        const skippedOnDemand = new Set();
         for (const [threadId, target] of snapshot) {
             if (generation !== this.topicCleanupGeneration || this.shuttingDown)
                 return;
@@ -5513,12 +5644,22 @@ export class FleetManager {
             const adapterId = this.getInstanceAdapterId(target.name);
             const adapter = adapterId ? this.adapters.get(adapterId) : undefined;
             if (!adapterId || !adapter?.probeTopicPresence) {
-                this.warnTopicProbeUnknown(target.name, threadId, adapterId, "owner-adapter-unavailable");
+                this.passTopicProbeUnknown(pass, target.name, threadId, adapterId, "owner-adapter-unavailable");
+                continue;
+            }
+            // An on-demand adapter's probe is reserved for confirming a delivery
+            // failure hint (handleProviderTopicClosed); the periodic scan leaves its
+            // routes alone — no probe, no unknown, no streak, no notice.
+            if (adapter.topicProbePolicy?.() === "on-demand") {
+                if (!skippedOnDemand.has(adapterId)) {
+                    skippedOnDemand.add(adapterId);
+                    this.logger.debug({ adapterId }, "Topic scan skipping on-demand adapter — presence is confirmed only on delivery failure");
+                }
                 continue;
             }
             const before = this.confirmedProbeFence(adapterId, adapter);
             if (!before) {
-                this.warnTopicProbeUnknown(target.name, threadId, adapterId, "owner-adapter-not-ready");
+                this.passTopicProbeUnknown(pass, target.name, threadId, adapterId, "owner-adapter-not-ready");
                 continue;
             }
             let result;
@@ -5531,17 +5672,24 @@ export class FleetManager {
             if (generation !== this.topicCleanupGeneration || this.shuttingDown)
                 return;
             if (!this.sameProbeFence(adapterId, adapter, before, result)) {
-                this.warnTopicProbeUnknown(target.name, threadId, adapterId, "owner-adapter-generation-changed");
+                this.passTopicProbeUnknown(pass, target.name, threadId, adapterId, "owner-adapter-generation-changed");
                 continue;
             }
             if (result.status === "unknown") {
-                this.warnTopicProbeUnknown(target.name, threadId, adapterId, result.reason);
+                this.passTopicProbeUnknown(pass, target.name, threadId, adapterId, result.reason, result.detail);
             }
-            else if (result.status === "missing") {
-                missing.push({ threadId, target, adapterId, adapter, generation: result.generation });
+            else {
+                this.passTopicProbeDefinite(pass, threadId, adapterId);
+                if (result.status === "missing") {
+                    missing.push({ threadId, target, adapterId, adapter, generation: result.generation });
+                }
             }
         }
-        if (generation !== this.topicCleanupGeneration || this.shuttingDown || missing.length === 0)
+        if (generation !== this.topicCleanupGeneration || this.shuttingDown)
+            return;
+        // One pass, one check: streaks move by at most one per key here.
+        this.applyTopicProbePass(pass);
+        if (missing.length === 0)
             return;
         if (missing.length > 1) {
             this.logger.error({ missing: missing.map(item => ({ instanceName: item.target.name, threadId: item.threadId, adapterId: item.adapterId })) }, "Multiple topics appeared missing in one pass — treating topology evidence as untrusted and retaining all data");
@@ -5595,8 +5743,15 @@ export class FleetManager {
             this.warnTopicProbeUnknown(target.name, threadId, adapterId, "topic-close-generation-changed");
             return;
         }
+        if (result.status === "unknown") {
+            this.warnTopicProbeUnknown(target.name, threadId, adapterId, result.reason, result.detail);
+            return;
+        }
+        this.clearTopicProbeUnknownStreak(threadId, adapterId);
         if (result.status !== "missing") {
-            this.warnTopicProbeUnknown(target.name, threadId, adapterId, result.status === "unknown" ? result.reason : "topic-close-not-confirmed-missing");
+            // The gateway said deleted, REST says present: a definite answer, so it
+            // is not an unknown streak — but it is worth one debug line.
+            this.logger.debug({ instanceName: target.name, threadId, adapterId }, "channelDelete hint contradicted by REST — topic present, nothing to do");
             return;
         }
         this.topicCommands.handleTopicDeleted(threadId, {
@@ -9999,11 +10154,19 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const workDir = join(getAgendHome(), "workspaces", instanceName);
         ensureWorkspaceGit(workDir);
         const classicIdentity = this.classicChannels?.getAll().find(ch => ch.instanceName === instanceName);
+        const toolProgress = classicIdentity
+            ? this.classicChannels?.getToolProgress(classicIdentity.channelId, classicIdentity.adapterId, this.fleetConfig?.defaults?.tool_progress)
+            : this.fleetConfig?.defaults?.tool_progress;
+        const replyCompletionGuard = classicIdentity
+            ? this.classicChannels?.getReplyCompletionGuard(classicIdentity.channelId, classicIdentity.adapterId, this.fleetConfig?.defaults?.reply_completion_guard)
+            : this.fleetConfig?.defaults?.reply_completion_guard;
         const config = {
             ...DEFAULT_INSTANCE_CONFIG,
             ...this.fleetConfig?.defaults,
             working_directory: workDir,
             lightweight: true,
+            tool_progress: toolProgress ?? "off",
+            reply_completion_guard: replyCompletionGuard ?? true,
             ...(backend ? { backend } : {}),
             ...(model ? { model } : {}),
             ...(classicIdentity?.displayName ? { display_name: classicIdentity.displayName } : {}),
@@ -10396,6 +10559,30 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             this.notifyFleetError(t("fleet.reload_rejected", why));
             return;
         }
+        // Classic behavior settings share the fleet defaults but are not entries
+        // in fleet.yaml. Snapshot the old effective chain before reloading the
+        // Classic file so SIGHUP can hot-apply either source without waiting for
+        // the 30-second Classic poller.
+        const oldClassicBehavior = new Map();
+        if (this.classicChannels) {
+            for (const ch of this.classicChannels.getAll()) {
+                const runtimeConfig = this.daemons.get(ch.instanceName)?.getConfigSnapshot?.();
+                oldClassicBehavior.set(ch.instanceName, {
+                    backend: this.classicChannels.getBackend(ch.channelId, ch.adapterId, oldConfig?.defaults?.backend),
+                    model: this.classicChannels.getModel(ch.channelId, ch.adapterId, oldConfig?.defaults?.model),
+                    autoPauseAfter: this.classicChannels.getAutoPauseAfter(ch.channelId, ch.adapterId, oldConfig?.defaults?.auto_pause_after),
+                    // Settings mutates FleetManager's in-memory defaults before SIGHUP.
+                    // The live daemon is therefore the authority for the previous hot
+                    // values, exactly as in the fleet-topic reconciliation below.
+                    toolProgress: runtimeConfig?.tool_progress
+                        ?? this.classicChannels.getToolProgress(ch.channelId, ch.adapterId, oldConfig?.defaults?.tool_progress),
+                    replyCompletionGuard: runtimeConfig?.reply_completion_guard
+                        ?? this.classicChannels.getReplyCompletionGuard(ch.channelId, ch.adapterId, oldConfig?.defaults?.reply_completion_guard),
+                });
+            }
+            if (this.classicChannels.checkReload())
+                this.reportClassicUnrecoverableIds();
+        }
         this.routing.rebuild(this.fleetConfig);
         this.reregisterClassicChannels();
         this.scheduler?.reload();
@@ -10460,6 +10647,35 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 }
             }
         }
+        // A Classic channel inherits fleet defaults beneath its own two levels.
+        // Recompute that complete chain on SIGHUP. Only the two behavior switches
+        // are hot; changes to backend/model/auto-pause retain the existing restart
+        // semantics.
+        if (this.classicChannels) {
+            for (const ch of this.classicChannels.getAll()) {
+                const old = oldClassicBehavior.get(ch.instanceName);
+                if (!old || !this.daemons.has(ch.instanceName))
+                    continue;
+                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");
+                    await this.stopInstance(ch.instanceName).catch(() => { });
+                    await this.startClassicInstanceUnattended(ch, "classic instance after fleet reload");
+                    continue;
+                }
+                const toolProgress = this.classicChannels.getToolProgress(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.tool_progress);
+                const replyCompletionGuard = this.classicChannels.getReplyCompletionGuard(ch.channelId, ch.adapterId, this.fleetConfig?.defaults?.reply_completion_guard);
+                if (old.toolProgress !== toolProgress || old.replyCompletionGuard !== replyCompletionGuard) {
+                    this.applyHotConfigUpdate(ch.instanceName, {
+                        tool_progress: toolProgress,
+                        reply_completion_guard: replyCompletionGuard,
+                    });
+                    this.logger.info({ instanceName: ch.instanceName }, "Classic inherited hot config reloaded");
+                }
+            }
+        }
         // warm_cap is fleet-owned; enforce the reloaded value immediately against
         // currently idle instances instead of waiting for a future state edge.
         this.enforceWarmCap();