charness 3.5.0 → 3.6.1

package/dist/bot.js

@@ -70,8 +70,11 @@ const terminalAdapter_1 = require("./adapters/terminalAdapter");
 const openCodeQuestionFlow_1 = require("./openCodeQuestionFlow");
 const pendingQuestionRepost_1 = require("./pendingQuestionRepost");
 const rateLimiter_1 = require("./rateLimiter");
+const testTimings_1 = require("./testTimings");
 const installManager_1 = require("./installManager");
 const startupReadiness_1 = require("./utils/startupReadiness");
+const doctorLine_1 = require("./utils/doctorLine");
+const nativeWindows_1 = require("./utils/nativeWindows");
 const state_1 = require("./state");
 const instanceLock_1 = require("./instanceLock");
 const shutdown_1 = require("./shutdown");
@@ -85,6 +88,7 @@ const timezoneRecompute_1 = require("./scheduler/timezoneRecompute");
 const validation_1 = require("./validation");
 const bindPicker_1 = require("./connectors/telegram/bindPicker");
 const topicCommand_1 = require("./connectors/telegram/commands/topicCommand");
+const forumTopicCreated_1 = require("./connectors/telegram/forumTopicCreated");
 const providerDisconnectPlan_1 = require("./utils/providerDisconnectPlan");
 const folderName_1 = require("./folderName");
 const threadRouting_1 = require("./threadRouting");
@@ -138,6 +142,8 @@ const backendUnavailableError_1 = require("./adapters/backendUnavailableError");
 const claudeCodeVersion_1 = require("./utils/claudeCodeVersion");
 const keyedTransitionQueue_1 = require("./utils/keyedTransitionQueue");
 const adoptedToolList_1 = require("./utils/adoptedToolList");
+const lostWork_1 = require("./utils/lostWork");
+const jsonStreamPendingWork_1 = require("./utils/jsonStreamPendingWork");
 const compactOnIdle_1 = require("./utils/compactOnIdle");
 const fileSendService_1 = require("./utils/fileSendService");
 const messageSendService_1 = require("./utils/messageSendService");
@@ -319,12 +325,17 @@ function parseEnv() {
         const code = e.code ?? 'unknown';
         errors.push(`WORK_ROOT="${workRoot}" is not accessible (${code})`);
     }
+    // A test instance's timing overrides (never a setting); an unknown key or a bad value stops the boot, naming it.
+    const testTimingsParse = (0, testTimings_1.parseTestTimings)(process.env[testTimings_1.testTimingsEnvName]);
+    if (!testTimingsParse.ok)
+        errors.push(...testTimingsParse.errors);
     if (errors.length > 0) {
         for (const err of errors)
             console.error(`[startup] ${err}`);
         process.exit(1);
     }
     return {
+        testTimings: testTimingsParse.ok ? testTimingsParse.timings : {},
         botToken,
         servedPlatforms: (0, connectorSet_1.getServedPlatforms)(connectors),
         isTelegramServed,
@@ -336,6 +347,15 @@ function parseEnv() {
     };
 }
 const ENV = parseEnv();
+const testTimingsBootLine = (0, testTimings_1.formatTestTimingsBootLine)(ENV.testTimings);
+if (testTimingsBootLine !== null)
+    console.log(testTimingsBootLine);
+if (ENV.testTimings.telegramSendIntervalMs !== undefined)
+    (0, rateLimiter_1.configureGlobalSendInterval)(ENV.testTimings.telegramSendIntervalMs);
+if (ENV.testTimings.backgroundHoldMaxMs !== undefined)
+    (0, createAdapter_1.registerPendingWorkHoldMs)(ENV.testTimings.backgroundHoldMaxMs);
+/** The short retry that probes an unconfirmed usage limit (a test instance may shorten it). */
+const limitProbeDelayMs = ENV.testTimings.limitProbeDelayMs ?? apiErrorRetry_1.unconfirmedLimitProbeDelayMs;
 // The instance default effort (`/effort` in General) is `settings.json`'s `defaultEffort`, re-read when the file changes.
 (0, effortLevels_1.setInstanceDefaultEffortReader)((0, instanceSettings_1.createInstanceDefaultEffortReader)(() => (0, instanceSettings_1.getInstanceSettingsPath)(), (line) => console.error(line)));
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -1292,9 +1312,9 @@ function handleUnconfirmedLimit(key) {
         return false;
     }
     console.log(`[apiRetry] ${k}: an unconfirmed usage limit — probing with a short retry before waiting for the reset`);
-    void replyToThread(key, (0, i18n_1.t)('apiRetry.transientNotice', { minutes: Math.round(apiErrorRetry_1.unconfirmedLimitProbeDelayMs / apiRetryMsPerMinute), attempt: 1 }));
+    void replyToThread(key, (0, i18n_1.t)('apiRetry.transientNotice', { minutes: Math.round(limitProbeDelayMs / apiRetryMsPerMinute), attempt: 1 }));
     const now = Date.now();
-    armApiRetryTimer(key, { kind: 'transient', attempt: 1, fireAt: now + apiErrorRetry_1.unconfirmedLimitProbeDelayMs, delayMs: apiErrorRetry_1.unconfirmedLimitProbeDelayMs, isLimitProbe: true });
+    armApiRetryTimer(key, { kind: 'transient', attempt: 1, fireAt: now + limitProbeDelayMs, delayMs: limitProbeDelayMs, isLimitProbe: true });
     return true;
 }
 /**
@@ -3683,6 +3703,9 @@ async function releaseThreadSession(key) {
  * adapters can't end up polling/streaming the same thread at once — that
  * desync caused mixed output, silent `/stop`, and the "I keep getting
  * 'Login successful' on every message" bug reported 2026-05-15.
+ *
+ * Resolves the work the stop cut off that the agent's next prompt is told about (`null`: none), so a caller's line to
+ * the operator is derived from the very record the note lists.
  */
 async function switchThreadAdapter(key, newName) {
     const prevName = (0, createAdapter_1.getThreadAdapterNameRaw)(key);
@@ -3691,9 +3714,13 @@ async function switchThreadAdapter(key, newName) {
     // reminding (or, in a terminal, TYPING into) a session that never saw it.
     if (prevName && !(0, createAdapter_1.checkIsSameConversationSwitch)(prevName, newName))
         cancelConversationRequest(key);
+    let switchCutOffWork = null;
     if (prevName && prevName !== newName) {
         try {
             const prev = (0, createAdapter_1.getAdapter)(prevName);
+            // What dies with the stopped process: its own background work and the turn it was in (an explicit stop records nothing).
+            if (prev.checkIsActive(key))
+                switchCutOffWork = prev.getPendingWork?.(key) ?? null;
             if (prev.checkIsActive(key)) {
                 // `stopSession` is `void` in the AgentAdapter contract — OpenCode
                 // queues teardown behind its lifecycle lock and returns
@@ -3715,7 +3742,7 @@ async function switchThreadAdapter(key, newName) {
     (0, createAdapter_1.setThreadAdapter)(key, newName);
     const agent = state.getAgent(key);
     if (!agent)
-        return;
+        return null;
     // Wipe ids that don't belong to the new adapter. We persist via
     // setAgent (which merges), so build a fresh record with only the
     // surviving fields.
@@ -3733,13 +3760,25 @@ async function switchThreadAdapter(key, newName) {
     // fallback switch or a plain /claude ↔ /opencode comes back to the conversation it left
     // (L-D4: a sleeping conversation is woken, `/new` is the fresh start). The reattach loop never reads the parked
     // slot, so the audit S12 bug (both ids on the live row) stays fixed.
-    const switched = (0, adapterSwitchSessionIds_1.getAdapterSwitchSessionIds)({ previousName: prevName, nextName: newName, agent, parked: state.getParkedSession(key), parkedAt: new Date().toISOString() });
+    const parkedBefore = state.getParkedSession(key);
+    const switched = (0, adapterSwitchSessionIds_1.getAdapterSwitchSessionIds)({ previousName: prevName, nextName: newName, agent, parked: parkedBefore, parkedAt: new Date().toISOString() });
     if (switched.ids.claudeSessionId)
         next.claudeSessionId = switched.ids.claudeSessionId;
     if (switched.ids.opencodeSessionId)
         next.opencodeSessionId = switched.ids.opencodeSessionId;
+    // Work the switch cut off is told twice, once to each agent: the next prompt (the hand-over bridge, the next message)
+    // tells the agent the topic moves to, and the parked conversation keeps it for its own agent's first prompt back.
+    const cutOffRecord = switchCutOffWork ? { ...switchCutOffWork, reason: 'switched', lostAt: Date.now() } : null;
+    // The parked copy knows the agent the topic moves to hears it first (it may restart some of the work itself).
+    const parkedLoss = switchCutOffWork && cutOffRecord ? { ...cutOffRecord, otherAgentTold: switchCutOffWork } : null;
     if (switched.parked !== undefined)
-        await state.setParkedSession(key, switched.parked);
+        await state.setParkedSession(key, switched.parked && parkedLoss ? { ...switched.parked, lostWork: parkedLoss } : switched.parked);
+    // Back to a parked conversation (the side being left may be parked in the same step): what its agent was never told
+    // rides its first prompt.
+    if (switched.isRestored && parkedBefore?.lostWork)
+        await foldLostWorkIntoNextPrompt(key, parkedBefore.lostWork);
+    if (cutOffRecord)
+        await foldLostWorkIntoNextPrompt(key, cutOffRecord);
     // The watermark is scoped to its session: it rides along while that session is kept. Every wake of a sleeping
     // conversation passes through here, and the wake reads it as the proof the conversation took a turn.
     if (agent.seenWatermark && [next.claudeSessionId, next.opencodeSessionId].includes(agent.seenWatermark.sessionId)) {
@@ -3749,6 +3788,7 @@ async function switchThreadAdapter(key, newName) {
     // fields we kept.
     await state.removeAgent(key);
     await state.setAgent(key, next);
+    return switchCutOffWork;
 }
 /**
  * @description The post-start "ready" notice for an agent that just came up — or
@@ -3853,21 +3893,20 @@ async function persistSessionStart(key, adapter) {
     }
 }
 /**
- * @description An adopted json-stream process whose tool list is stale (L4) is
- * stopped at its next idle point: now when idle, else once it stops working —
- * polled, since the bot gets no "turn ended" event it can hang this on. The next
- * trigger resumes the conversation with the current tools. The first look waits
- * for the adopt's replay: until the tail has consumed what stdout held at the
- * adopt, the live state is the persisted one plus nothing, and a turn that ended
- * or began during the downtime would be misread.
+ * @description A per-turn json-stream process that outlived the bot (L5) is stopped as soon as it is idle — its turn
+ * (if any) ended and none of its own work is pending — the per-turn backend's after-turn stop, which the downtime
+ * swallowed. Polled, since the turn may have ended before the adopt. The first look waits for the adopt's replay:
+ * until the tail has consumed what stdout held at the adopt, the live state is the persisted one plus nothing, and a
+ * turn that ended or began during the downtime would be misread. The idle-lifecycle backend has no such stop: its
+ * adopted process, stale tool list or not, is stopped by the idle fire after the compaction.
  */
-function stopAdoptedSessionWhenIdle(key, adapter, reason) {
+function stopAdoptedPerTurnSessionWhenIdle(key, adapter) {
     const kStr = (0, sessionKey_1.keyToString)(key);
     const tick = () => {
         if (!adapter.checkIsActive(key))
-            return; // gone meanwhile (a stop, a crash): nothing to refresh
+            return; // gone meanwhile (a stop, a crash): nothing left to stop
         if (adapter.checkIsWorking?.(key)) {
-            const timer = setTimeout(tick, adoptedToolListRefreshPollMs);
+            const timer = setTimeout(tick, adoptedPerTurnStopPollMs);
             timer.unref?.();
             return;
         }
@@ -3875,22 +3914,22 @@ function stopAdoptedSessionWhenIdle(key, adapter, reason) {
         // the suspend would decline on every poll. Stop looking: a later turn's `init` reports the version,
         // and the lifecycle's own stop (the idle timer, the per-turn `turnEnded`) takes over from there.
         if (!adapter.checkIsAutoStopSupported(key)) {
-            console.log(`[reattach] ${kStr}: the adopted process is kept (${reason}): its Claude Code version is unknown or too old for the auto-stop; its own lifecycle stop takes over once a turn reports it`);
+            console.log(`[reattach] ${kStr}: the adopted process is kept (the per-turn lifecycle): its Claude Code version is unknown or too old for the auto-stop; its own lifecycle stop takes over once a turn reports it`);
             return;
         }
-        console.log(`[reattach] ${kStr}: stopping the adopted process (${reason}); the next trigger resumes it`);
+        console.log(`[reattach] ${kStr}: stopping the adopted process (the per-turn lifecycle); the next trigger resumes it`);
         void suspendThreadSession(key)
             .then(() => {
             // The suspend declines when a turn began between the look and the transition: look again.
             if (adapter.checkIsActive(key))
-                setTimeout(tick, adoptedToolListRefreshPollMs).unref?.();
+                setTimeout(tick, adoptedPerTurnStopPollMs).unref?.();
         })
-            .catch((e) => console.warn(`[reattach] ${kStr}: the stale-tool-list stop failed:`, e instanceof Error ? e.message : e));
+            .catch((e) => console.warn(`[reattach] ${kStr}: the per-turn stop of the adopted process failed:`, e instanceof Error ? e.message : e));
     };
     void adapter.whenAdoptReplayed(key).then(tick);
 }
-/** How often an adopted, stale-tool-list process that is still working is re-checked for idleness (L4). */
-const adoptedToolListRefreshPollMs = 5000;
+/** How often an adopted per-turn process that is still working is re-checked for idleness (L5). */
+const adoptedPerTurnStopPollMs = 5000;
 async function startAgentSession(key, args) {
     const kStr = (0, sessionKey_1.keyToString)(key);
     // The bound folder IS the agent's cwd — refuse to start without one. The
@@ -4159,6 +4198,8 @@ async function suspendThreadSession(key) {
     }
     autoStopUnsupportedLoggedKeys.delete(kStr);
     await sessionTransitions.run(kStr, async () => {
+        // Decide on what the process wrote up to now, not on the last tail poll: a background task's turn may have just begun.
+        adapter.refreshWorkingState?.(key);
         if (!adapter.checkIsActive(key) || adapter.checkIsWorking?.(key))
             return;
         startupPromptBuffer.markStarting(kStr);
@@ -4179,13 +4220,20 @@ async function suspendThreadSession(key) {
 /** Conversations already told once that their CLI is too old for the auto-stop (L-D10). */
 const autoStopUnsupportedLoggedKeys = new Set();
 /**
- * @description `turnEnded` from a json-stream adapter: in the per-turn lifecycle
- * (L5, L-D3) the process is stopped right after the turn — unless a deferred
- * compaction is armed (its drain compacts first, and that turn ends here too) or
- * the process still works (a background task, input not yet taken in). The
- * session sleeps; the next trigger resumes it with the prompt cache warm.
+ * @description `turnEnded` from a json-stream adapter. The idle countdown runs from
+ * the end of the last turn: an idle fire that found the turn still running is not
+ * rescheduled (D2), and a turn whose answer went out through `answer_request`
+ * produces no later output to re-arm it — the process would never reach its idle
+ * compaction and stop, and its pending-work hold would never be enforced. (A
+ * bot-issued compaction's own turn end is skipped by the arming's loop guard.)
+ * In the per-turn lifecycle (L5, L-D3) the process is then stopped right after
+ * the turn — unless a deferred compaction is armed (its drain compacts first,
+ * and that turn ends here too) or the process still works (a background task,
+ * input not yet taken in). The session sleeps; the next trigger resumes it with
+ * the prompt cache warm.
  */
 function handleAgentTurnEnded(key) {
+    noteThreadActivity(key);
     const adapter = (0, createAdapter_1.getThreadAdapter)(key);
     if (adapter.name !== adapterNames_1.claudePerTurnAdapterName)
         return;
@@ -4289,7 +4337,10 @@ async function forwardPromptToAgent(key, adapter, text, sentAtMs, options = {})
     });
     // The request header (S7) leads the per-message body, like the reply quote and
     // unlike the once-per-change thread preamble: it names THIS message's request.
-    const body = options.requestHeader ? `${options.requestHeader}${quotedBody}` : quotedBody;
+    const messageBody = options.requestHeader ? `${options.requestHeader}${quotedBody}` : quotedBody;
+    // A loss the agent was not told about yet (`utils/lostWork.ts`) rides the first real prompt, once, ahead of it.
+    const lostWorkRecord = isReplayable && adapter.name !== 'terminal' ? state.getLostWork(key) : undefined;
+    const body = lostWorkRecord ? `${(0, lostWork_1.buildLostWorkNote)(lostWorkRecord, (0, i18n_1.getLocaleEndonym)((0, i18n_1.getActiveLang)()))}\n\n${messageBody}` : messageBody;
     // Cache the (reply-folded) prompt so a wedged OpenCode session can be recovered
     // by restarting fresh and replaying it — replaying WITH the quote is correct.
     // A genuine new prompt also opens a fresh recovery episode (clears the guard).
@@ -4341,6 +4392,9 @@ async function forwardPromptToAgent(key, adapter, text, sentAtMs, options = {})
         await adapter.detachRunningSubagents(key);
     }
     adapter.sendInput(key, promptText);
+    // Told only once the prompt carrying the note reached a live session: a forward that failed keeps it for the next.
+    if (lostWorkRecord && adapter.checkIsActive(key))
+        void state.clearLostWork(key);
     // S2 busy-onset arm: start the Claude liveness loop the moment the prompt is
     // forwarded — driven by `checkIsBusy`, not by waiting for an opportunistic
     // scrape emit that may never come during a long quiet think. The arming grace
@@ -5478,13 +5532,9 @@ bot.action('open_sessions', async (ctx) => {
     await ctx.answerCbQuery();
     await handleSessionsList(key);
 });
-function formatDoctorLine(line) {
-    if (line.status === 'ok')
-        return (0, i18n_1.t)('doctor.ok', { label: line.label });
-    if (line.status === 'warn')
-        return (0, i18n_1.t)('doctor.warn', { label: line.label, hint: line.hint ?? '' });
-    return (0, i18n_1.t)('doctor.fail', { label: line.label, hint: line.hint ?? '' });
-}
+// ═══════════════════════════════════════════════════════════════════════════════
+//  /doctor — self-diagnostics (plan §20.1)
+// ═══════════════════════════════════════════════════════════════════════════════
 async function checkCliPresent(cmd) {
     try {
         await execFileAsync(cmd, ['--version'], { timeout: 1500 });
@@ -5496,6 +5546,10 @@ async function checkCliPresent(cmd) {
 }
 async function runDoctor() {
     const lines = [];
+    // 0. Native Windows runs with limits (no tmux, no self-update restart, no hot mode, no local speech install).
+    const nativeWindowsLine = (0, nativeWindows_1.getNativeWindowsDoctorLine)(process.platform, i18n_1.t);
+    if (nativeWindowsLine)
+        lines.push(nativeWindowsLine);
     // 1. Bot admin permissions in the configured group.
     const groupId = getAllowedGroupId();
     if (groupId === null) {
@@ -5602,7 +5656,7 @@ command('doctor', async (_ctx, key) => {
     // Single big edit-in-place would be nicer, but doctor is rarely run and
     // gathering the report in series keeps it dead simple.
     const lines = await runDoctor();
-    const body = lines.map(formatDoctorLine).join('\n');
+    const body = lines.map((line) => (0, doctorLine_1.formatDoctorLine)(line, i18n_1.t)).join('\n');
     await replyToThread(key, `${(0, i18n_1.t)('doctor.header')}\n\n${body}`, { parse_mode: 'Markdown' });
 });
 function loadMcpFile(filePath) {
@@ -5763,12 +5817,14 @@ async function applyClaudeBackendSwitch(key, target) {
     const wasActive = (0, createAdapter_1.getThreadAdapter)(key).checkIsActive(key);
     const sessionId = state.getAgent(key)?.claudeSessionId;
     // Stops the previous backend, records the pick, keeps `claudeSessionId`.
-    await switchThreadAdapter(key, target);
+    const cutOffWork = await switchThreadAdapter(key, target);
+    // The operator hears that the background work died with the stopped process; the agent hears it in its next prompt.
+    const backgroundStoppedSuffix = (0, lostWork_1.checkHasLostBackgroundWork)(cutOffWork) ? `\n${(0, i18n_1.t)('fallback.backgroundStopped')}` : '';
     if (!wasActive)
         return (0, i18n_1.t)('claudeMode.set_idle', { label });
     const decision = getWorkDirStartDecision(key);
     if (!decision.ok)
-        return decision.message;
+        return `${decision.message}${backgroundStoppedSuffix}`;
     const targetAdapter = (0, createAdapter_1.getThreadAdapter)(key);
     sendThreadTypingIndicator(key).catch(() => { });
     if (sessionId && targetAdapter.resumeSession) {
@@ -5777,14 +5833,14 @@ async function applyClaudeBackendSwitch(key, target) {
         try {
             await targetAdapter.resumeSession(key, decision.workDir, sessionId, { isWithRecentContext: true });
             await persistSessionStart(key, targetAdapter);
-            return (0, i18n_1.t)('claudeMode.switched_resumed', { label });
+            return `${(0, i18n_1.t)('claudeMode.switched_resumed', { label })}${backgroundStoppedSuffix}`;
         }
         catch (e) {
             console.error('[claude_mode] resume failed, starting fresh:', e instanceof Error ? e.message : e);
         }
     }
     const msg = await startAgentSession(key);
-    return msg || (0, i18n_1.t)('claudeMode.switched_fresh', { label });
+    return `${msg || (0, i18n_1.t)('claudeMode.switched_fresh', { label })}${backgroundStoppedSuffix}`;
 }
 command('claude_mode', async (_ctx, key, parsed) => {
     if (checkIsGeneral(key)) {
@@ -6276,15 +6332,25 @@ async function switchTopicToFallbackEntry(key, from, to, options) {
         if (from.profile !== to.profile)
             await state.setClaudeProfileOverride(key, to.profile);
         // The turn is dead after a limit: re-spawn now, even over background work (it is stopped; the notice says so).
-        const adapter = (0, createAdapter_1.getThreadAdapter)(key);
-        isStoppingBackground = adapter instanceof claudeJsonStreamAdapter_1.ClaudeJsonStreamAdapter && adapter.checkHasBackgroundWork(key);
-        const outcome = await applyClaudeProfileToThread(key, { isAfterLimit: true });
+        lostWorkFoldingKeys.add(k);
+        let outcome;
+        try {
+            outcome = await applyClaudeProfileToThread(key, { isAfterLimit: true });
+        }
+        finally {
+            lostWorkFoldingKeys.delete(k);
+        }
         if (outcome === 'deferred' || outcome === 'restartRequired') {
             fallbackSwitchOffers.delete(k);
             const notice = (0, fallbackSwitchNotice_1.buildFallbackDeferredNotice)(from, to);
             await say(notice);
             return { isSwitched: false, notice };
         }
+        // The re-spawn took the old process's background work: the notice below says so, the continue nudge tells the agent.
+        const cutOffWork = takeLostWorkOf(key);
+        isStoppingBackground = (0, lostWork_1.checkHasLostBackgroundWork)(cutOffWork);
+        if (cutOffWork)
+            await foldLostWorkIntoNextPrompt(key, { ...cutOffWork, reason: 'restarted', lostAt: Date.now() });
     }
     else if (isSameFamily && to.backend === 'opencode') {
         const error = await (0, createAdapter_1.getThreadAdapter)(key).setModel?.(key, (0, fallbackChain_1.buildOpenCodeModelLabel)(to));
@@ -6298,7 +6364,7 @@ async function switchTopicToFallbackEntry(key, from, to, options) {
             reason: 'limit',
             resetsAtText: getFallbackResetTime(from),
         });
-        await moveTopicToOtherBackend(key, to.backend, to.backend === 'claude' ? to.profile : null);
+        isStoppingBackground = await moveTopicToOtherBackend(key, to.backend, to.backend === 'claude' ? to.profile : null);
         if (to.backend === 'opencode') {
             const error = await (0, createAdapter_1.getThreadAdapter)(key).setModel?.(key, (0, fallbackChain_1.buildOpenCodeModelLabel)(to));
             if (error)
@@ -6325,12 +6391,13 @@ async function switchTopicToFallbackEntry(key, from, to, options) {
  * half: record `account` as the topic's own Claude pick when one is given (the chain's rung, the operator's pick — a
  * switch that only names the account the topic follows passes `null`), then `switchThreadAdapter` stops the old
  * session, parks its id and brings back the target family's parked one. The context bridge is built BEFORE this, while
- * the adapter being left still runs.
+ * the adapter being left still runs. Resolves whether the stop took background work with it — the caller tells the
+ * operator (the agent is told by the next prompt, `switchThreadAdapter`).
  */
 async function moveTopicToOtherBackend(key, backend, account) {
     if (account !== null)
         await state.setClaudeProfileOverride(key, account);
-    await switchThreadAdapter(key, backend === 'claude' ? (0, createAdapter_1.resolveClaudeBackendName)(key) : adapterNames_1.openCodeAdapterName);
+    return (0, lostWork_1.checkHasLostBackgroundWork)(await switchThreadAdapter(key, backend === 'claude' ? (0, createAdapter_1.resolveClaudeBackendName)(key) : adapterNames_1.openCodeAdapterName));
 }
 /**
  * @description The second half, after a move (across backends or between accounts): start or resume the topic's
@@ -6421,7 +6488,10 @@ async function executeBackendSwitch(key, target, options) {
             userMessage: options.userMessage,
         })
         : null;
-    await moveTopicToOtherBackend(key, target.backend, target.backend === 'claude' && target.isProfilePicked ? target.profile : null);
+    const isStoppingBackground = await moveTopicToOtherBackend(key, target.backend, target.backend === 'claude' && target.isProfilePicked ? target.profile : null);
+    // The operator hears that the background work died with the old session; its agent hears it in the first prompt.
+    if (isStoppingBackground)
+        await replyToThread(key, (0, i18n_1.t)('fallback.backgroundStopped'));
     cancelApiRetry(key); // a wait armed for the backend just left is over
     await resumeTopicOnNewSession(key, {
         modelToPin: (0, backendSwitchPlan_1.getBackendSwitchModelToPin)(target),
@@ -8080,7 +8150,11 @@ bot.on((0, filters_1.message)('forum_topic_created'), async (ctx) => {
     // attacker-chosen folder. Stash the topic name so a later authorised-user
     // message in the same thread can still benefit from fuzzy auto-bind.
     const userId = ctx.from?.id;
-    if (!userId || !(await checkIsAllowedUser(ctx))) {
+    const action = await (0, forumTopicCreated_1.getForumTopicCreatedAction)({ creatorId: userId, botUserId: bot.botInfo?.id, checkIsCreatorAllowed: () => checkIsAllowedUser(ctx) });
+    // `/topic` binds and greets the topic it created itself; its own service message needs nothing more.
+    if (action === 'ignoreOwn')
+        return;
+    if (action === 'cacheNameOnly') {
         if (topicName) {
             pendingTopicNames.set((0, sessionKey_1.keyToString)(key), { name: topicName, ts: Date.now() });
         }
@@ -8490,12 +8564,9 @@ bot.action(/^reask_(\d+)$/, async (ctx) => {
     // The label goes to the agent as a prompt and nothing else in the topic shows it whole (the buttons clip long
     // labels): a label too long for the toast is posted in full, as the record of the answer that was sent.
     await (0, callbackToast_1.answerCallbackWithWholeText)(ctx, label, (wholeLabel) => replyToThread(key, wholeLabel));
-    // An answer to the agent's own question is never a request (S7), even delivered as a prompt.
-    if (isStarting) {
-        noteThreadUserActivity(key);
-        await withThreadLocale(key, () => deliverPromptOrBuffer(key, label, true));
-        return;
-    }
+    // An answer to the agent's own question is never a request (S7), even delivered as a prompt. Routed at delivery,
+    // not on the `isStarting` read above: the stop may have ended during the toast, and a label buffered into its closed
+    // window was never replayed.
     const outcome = await withThreadLocale(key, () => deliverActivePrompt(key, adapter, label, null));
     // The label reached no session (the topic was told why): the question is still open, so are its buttons.
     if (outcome === 'noSession' && labels && !reAskedQuestionOptions.has((0, sessionKey_1.keyToString)(key)))
@@ -10004,6 +10075,8 @@ function handleQuestionGone(key) {
     void unpinThreadQuestion(key);
 }
 function handleAgentClosed(key) {
+    // What the process held that died with it (its own background work), taken before the cleanup below.
+    const lostWork = takeLostWorkOf(key);
     // Session is gone — drop any not-yet-sent output AND status frame so they
     // don't surface after the "session ended" notice (the trailing-output bug:
     // a 429 backlog could let queued deltas land seconds after the close).
@@ -10024,11 +10097,99 @@ function handleAgentClosed(key) {
     // A closed session has nothing to compact — drop the idle watchdog + any arm.
     clearThreadCompaction(key);
     const adapter = (0, createAdapter_1.getThreadAdapter)(key);
-    replyToThread(key, (0, i18n_1.t)('agent.session_ended', { label: adapter.label })).catch(() => { });
+    // Work died with the process: the lost-work line (and the resume it announces) replaces the bare "session ended".
+    if (lostWork)
+        scheduleLostWorkNote(key, lostWork, 'exited');
+    else
+        replyToThread(key, (0, i18n_1.t)('agent.session_ended', { label: adapter.label })).catch(() => { });
     // Banner now reads `idle`; closed sessions may also persist with the
     // wrong model/agent label otherwise.
     updatePinnedStatus(key).catch(() => { });
 }
+const msPerHour = 60 * 60 * 1000;
+/** The pending-work hold in force, in hours, as the topic line names it (`utils/jsonStreamPendingWork.ts`; a test instance's shorter one). */
+const pendingWorkHoldHours = Number(((ENV.testTimings.backgroundHoldMaxMs ?? jsonStreamPendingWork_1.pendingWorkHoldDefaultMs) / msPerHour).toFixed(1));
+/** What the conversation's last process took with it when it ended, handed over once by its adapter. */
+function takeLostWorkOf(key, adapter = (0, createAdapter_1.getThreadAdapter)(key)) {
+    return adapter.takeLostWork?.(key) ?? null;
+}
+/**
+ * The conversations a usage-limit switch is re-spawning right now: the re-spawn's `started` leaves the loss to the
+ * switch, which folds it into its own first prompt — decided at the call site, never by which of the two ran first.
+ */
+const lostWorkFoldingKeys = new Set();
+/**
+ * @description Keep a loss for the NEXT prompt the conversation gets, with no line and no resume of its own: a move
+ * that already says so in its notice and sends a first prompt (a limit switch's continue nudge, a backend switch's
+ * hand-over bridge, a return to a parked conversation).
+ */
+async function foldLostWorkIntoNextPrompt(key, record) {
+    console.log(`[lost-work] ${(0, sessionKey_1.keyToString)(key)}: the agent's own work ended with the process (${record.reason}); the move's first prompt tells the agent`);
+    await state.setLostWork(key, (0, lostWork_1.mergeLostWorkRecords)(state.getLostWork(key), record));
+}
+/** {@link noteLostWork} from an event handler: in the conversation's locale, not awaited, a failure logged. */
+function scheduleLostWorkNote(key, lostWork, reason) {
+    if (!lostWork)
+        return;
+    void withThreadLocale(key, () => noteLostWork(key, lostWork, reason)).catch((e) => console.warn(`[lost-work] ${(0, sessionKey_1.keyToString)(key)}:`, e instanceof Error ? e.message : e));
+}
+/**
+ * @description A process ended with the agent's own work pending (`utils/lostWork.ts`): keep the loss until the agent
+ * is told, post the ONE plain line in a topic, and — unless the plan says the note waits for the next prompt — resume
+ * the conversation with the note as its prompt. Runs in the conversation's locale.
+ */
+async function noteLostWork(key, lostWork, reason) {
+    if (!lostWork)
+        return;
+    const kStr = (0, sessionKey_1.keyToString)(key);
+    const now = Date.now();
+    const record = (0, lostWork_1.mergeLostWorkRecords)(state.getLostWork(key), { ...lostWork, reason, lostAt: now });
+    await state.setLostWork(key, record);
+    const lastAutoResumeAt = state.getLostWorkResumedAt(key);
+    const isLimitWaitArmed = getArmedApiRetry(key)?.kind === 'usageLimit';
+    const plan = (0, lostWork_1.getLostWorkPlan)({
+        reason,
+        isLimitWaitArmed,
+        msSinceLastAutoResume: lastAutoResumeAt === undefined ? null : now - lastAutoResumeAt,
+        // A tracker issue's agent answers only through a request: a bare note would have nowhere to answer.
+        isRequestRequired: !(0, sessionKeyCodec_1.checkIsTelegramKey)(key),
+    });
+    console.log(`[lost-work] ${kStr}: the process ended (${reason}) with the agent's own work pending (${record.backgroundTasks.length} background task(s), ${record.scheduledJobCount} scheduled job(s)${record.hasUnreadTaskResult ? ', an unread task result' : ''}${record.wasTurnInFlight ? ', a cut-off turn' : ''}); ${plan.isAutoResume ? 'resuming it with a note' : 'the note rides the next prompt'}`);
+    let linePlan = plan;
+    if (plan.isAutoResume) {
+        await state.setLostWorkResumedAt(key, now);
+        // The line says what happened: a resume that failed leaves the note for the next prompt, worded by the same rule.
+        if (!(await resumeConversationForLostWork(key)))
+            linePlan = (0, lostWork_1.getHeldLostWorkPlan)({ reason, isLimitWaitArmed });
+    }
+    if ((0, sessionKeyCodec_1.checkIsTelegramKey)(key))
+        replyToThread(key, (0, lostWork_1.formatLostWorkTopicLine)(record, linePlan, pendingWorkHoldHours, i18n_1.t)).catch(() => { });
+}
+/**
+ * @description Resume the conversation with the lost-work note as its prompt; `false` when the post failed — the note
+ * then stays for the next prompt.
+ */
+async function resumeConversationForLostWork(key) {
+    const record = state.getLostWork(key);
+    if (!record)
+        return true;
+    await state.clearLostWork(key);
+    const posted = await (0, postToSession_1.postToSession)(createLostWorkPostDeps(), (0, sessionKey_1.keyToString)(key), (0, lostWork_1.buildLostWorkNote)(record, (0, i18n_1.getLocaleEndonym)((0, i18n_1.getActiveLang)())));
+    if (posted.ok)
+        return true;
+    console.warn(`[lost-work] ${(0, sessionKey_1.keyToString)(key)}: the resume failed (${posted.reason === 'forward-failed' ? posted.error : posted.reason}); the note rides the next prompt`);
+    await state.setLostWork(key, (0, lostWork_1.mergeLostWorkRecords)(state.getLostWork(key), record));
+    return false;
+}
+/** The session post of a lost-work note: a bot note to the agent, not a request — no request is opened for it. */
+function createLostWorkPostDeps() {
+    return {
+        ...createSessionPostDeps(),
+        forwardPrompt: async (conversationKey, text) => {
+            await deliverPromptOrBuffer((0, sessionKey_1.keyFromString)(conversationKey), text, startupPromptBuffer.checkIsStarting(conversationKey));
+        },
+    };
+}
 function handleAgentError(key, error) {
     console.error(`[Bot] adapter error ${(0, sessionKey_1.keyToString)(key)}:`, error.message);
     stopClaudeLiveness(key);
@@ -10064,6 +10225,10 @@ function handleAgentStarted(key) {
     // activity instant rather than restart at the full 55 minutes. A genuinely fresh
     // session has no persisted instant and so gets the full window anyway.
     rearmThreadIdleTimer(key);
+    // A re-spawn (model, effort, account) began without the old process's background work — unless a usage-limit switch
+    // is re-spawning it: that switch folds the loss into its own first prompt (`switchTopicToFallbackEntry`).
+    if (!lostWorkFoldingKeys.has((0, sessionKey_1.keyToString)(key)))
+        scheduleLostWorkNote(key, takeLostWorkOf(key), 'restarted');
 }
 /**
  * @description `stopped` from the adapter — flip the banner back to `idle`.
@@ -10139,6 +10304,8 @@ function dropLostConversationWatermark(key) {
 function handleAgentSuspended(key) {
     clearGoneProcessFrames(key);
     updatePinnedStatus(key).catch(() => { });
+    // An idle stop takes pending work with it only once the hold ran out.
+    scheduleLostWorkNote(key, takeLostWorkOf(key), 'holdExpired');
 }
 // ═══════════════════════════════════════════════════════════════════════════════
 //  Startup orchestration — state init, re-attach, setMyCommands, launch
@@ -10440,10 +10607,14 @@ async function reattachExistingSessions(opts = { quietReattach: false }) {
     //     json-stream thread with a persisted id but no live process SLEEPS
     //     (lifecycle plan L4): it is NOT re-spawned — its next trigger resumes it
     //     — and it gets the downtime recap read from the transcript alone. An
-    //     adopted process keeps the bot-MCP tool list it got at its own start, so
-    //     one started under an earlier bot build is stopped at its next idle point
-    //     and resumed with the current tools (`decideAdoptedToolListRefresh`).
+    //     adopted process keeps the bot-MCP tool list it got at its own start: one
+    //     started under an earlier bot build is NOT stopped early — it follows the
+    //     normal idle lifecycle (compaction at the idle mark, then the stop, never
+    //     while its own work is pending) and the next trigger resumes it with the
+    //     current tools (`checkIsAdoptedToolListStale`).
     const claudeJsonAdapter = (0, createAdapter_1.getAdapter)(adapterNames_1.claudeJsonStreamAdapterName);
+    /** The conversations whose process was gone at boot with the agent's own work pending, by key — each told once. */
+    const lostWorkFoundAtBoot = new Map();
     let jsonAdopted = 0;
     let jsonKilled = 0;
     let jsonSleeping = 0;
@@ -10477,33 +10648,31 @@ async function reattachExistingSessions(opts = { quietReattach: false }) {
                         jsonAdopted += 1;
                         if (ownerAdapter.lifecycle === 'perTurn') {
                             // A per-turn process that outlived the bot is stopped as soon as its turn (if any) ends (L5).
-                            stopAdoptedSessionWhenIdle(key, ownerAdapter, 'the per-turn lifecycle');
+                            stopAdoptedPerTurnSessionWhenIdle(key, ownerAdapter);
                         }
-                        const refresh = (0, adoptedToolList_1.decideAdoptedToolListRefresh)({
-                            persistedDigest: agent.mcpToolDigest,
-                            currentDigest: botMcpToolDigestReader?.(key.platform) ?? '',
-                            isWorking: ownerAdapter.checkIsWorking(key),
-                        });
-                        if (refresh !== 'fresh') {
-                            // Read from the persisted state (the turn-in-flight flag, the task list); the stop itself
-                            // looks again once the downtime frames have replayed.
-                            console.log(`[reattach] ${(0, sessionKey_1.keyToString)(key)}: adopted with a stale tool list (${refresh === 'stopNow' ? 'idle: stopped now' : 'working: stopped once idle'})`);
-                            if (ownerAdapter.lifecycle !== 'perTurn')
-                                stopAdoptedSessionWhenIdle(key, ownerAdapter, 'the stale tool list');
+                        if ((0, adoptedToolList_1.checkIsAdoptedToolListStale)({ persistedDigest: agent.mcpToolDigest, currentDigest: botMcpToolDigestReader?.(key.platform) ?? '' })) {
+                            console.log(`[reattach] ${(0, sessionKey_1.keyToString)(key)}: adopted with a stale tool list; it gets the current tools when it resumes after its idle stop`);
                         }
-                        // The surviving process keeps the account it was spawned with; a topic whose pick changed while the
-                        // bot was down gets it at the next idle point (the resume reads the current profile).
+                        // The surviving process keeps the account it was spawned with. A switch the user picked while it worked is
+                        // restored with the adopt and still applies at the end of its turn; any other change of the resolved
+                        // profile reaches it when it resumes after its idle stop.
                         const spawnedConfigDir = ownerAdapter.getSessionClaudeConfigDir(key);
                         if (spawnedConfigDir !== undefined && !(0, claudeProfiles_1.checkIsSameClaudeConfigDir)(spawnedConfigDir, resolveThreadClaudeConfigDir(key))) {
                             console.log(`[reattach] ${(0, sessionKey_1.keyToString)(key)}: adopted under profile dir ${spawnedConfigDir ?? 'default'}, the topic now resolves to ${resolveThreadClaudeConfigDir(key) ?? 'default'}`);
-                            if (ownerAdapter.lifecycle !== 'perTurn')
-                                stopAdoptedSessionWhenIdle(key, ownerAdapter, 'the account profile');
                         }
                     }
                     else {
                         // Dead/zombie — adopt cleaned it up itself; the thread sleeps (below)
-                        // and its next trigger resumes it from the persisted session id.
+                        // and its next trigger resumes it from the persisted session id — at once
+                        // when its own work died with it (the agent is told, once the adopts are done).
                         jsonKilled += 1;
+                        const lostWork = takeLostWorkOf(key, ownerAdapter);
+                        if (lostWork) {
+                            lostWorkFoundAtBoot.set((0, sessionKey_1.keyToString)(key), { key, lostWork });
+                            // Told once: the record it came from drops it (the pass over the sleeping conversations below reads it too).
+                            if (agent.jsonStreamTail)
+                                void state.setJsonStreamTail(key, (0, lostWork_1.getTailRecordWithoutPendingWork)(agent.jsonStreamTail));
+                        }
                     }
                 }
                 catch (e) {
@@ -10525,6 +10694,13 @@ async function reattachExistingSessions(opts = { quietReattach: false }) {
         // Sleeping (L4): no process is started — the next trigger resumes the conversation. What the agent
         // produced while the bot was down is still recapped, read from the transcript on disk.
         jsonSleeping += 1;
+        // A process that died while the bot was down (its tmux session gone with it) left its pending work in the record:
+        // the agent is told — once: the record drops it now.
+        const goneProcessLostWork = (0, lostWork_1.getLostWorkFromTailRecord)(agent.jsonStreamTail ?? null, agent.claudeSessionId);
+        if (agent.jsonStreamTail && (0, lostWork_1.checkHasLostWork)(goneProcessLostWork) && !lostWorkFoundAtBoot.has((0, sessionKey_1.keyToString)(key))) {
+            lostWorkFoundAtBoot.set((0, sessionKey_1.keyToString)(key), { key, lostWork: goneProcessLostWork });
+            void state.setJsonStreamTail(key, (0, lostWork_1.getTailRecordWithoutPendingWork)(agent.jsonStreamTail));
+        }
         // A sleeping per-turn session with a compaction due gets its idle timer from the persisted stamps (L-D7).
         if (agent.name === adapterNames_1.claudePerTurnAdapterName)
             rearmThreadIdleTimer(key);
@@ -10534,6 +10710,9 @@ async function reattachExistingSessions(opts = { quietReattach: false }) {
         void postReattachRecap(key, ownerAdapter, workDirDecision.workDir, agent.claudeSessionId, agent.seenWatermark ?? null, !opts.quietReattach).catch(() => { });
     }
     console.log(`[reattach] claude-json-stream: adopted ${jsonAdopted}, sleeping ${jsonSleeping}, killed ${jsonKilled} orphans (quiet=${opts.quietReattach})`);
+    // Not awaited: a resume must not hold up the rest of the boot (the prompt is buffered while the session starts).
+    for (const { key, lostWork } of lostWorkFoundAtBoot.values())
+        scheduleLostWorkNote(key, lostWork, 'foundDead');
     // 3. Terminal — tmux shells (`term-…`). Like the Claude scan but simpler:
     //    a terminal has no session-id to recover, so adoption keys purely on a
     //    live binding whose agent is `terminal`. The tmux name is derived from
@@ -11252,10 +11431,11 @@ async function resolveBotAdminRights(groupId, botUserId) {
     }
 }
 /**
- * @description The General topic the updater talks in: the paired group's General when a group is paired, else the owner's DM
- * General (`null` when neither exists — a Jira-only instance has no Telegram to say anything in).
+ * @description The General topic the bot speaks to the operator in (the updater, the native-Windows notice): the paired group's
+ * General when a group is paired, else the owner's DM General (`null` when neither exists — a Jira-only instance has no
+ * Telegram to say anything in).
  */
-function getUpdateGeneralKey() {
+function getOperatorGeneralKey() {
     const groupId = getAllowedGroupId();
     if (groupId !== null)
         return (0, sessionKeyCodec_1.makeTelegramKey)(groupId, threadRouting_1.GENERAL_THREAD_ID);
@@ -11270,7 +11450,7 @@ function getUpdateGeneralKey() {
 async function postUpdateMessageToGeneral(message) {
     if (!ENV.isTelegramServed)
         return;
-    const generalKey = getUpdateGeneralKey();
+    const generalKey = getOperatorGeneralKey();
     if (generalKey === null) {
         console.log(`[update] no General topic to post "${message.kind}" in`);
         return;
@@ -11395,6 +11575,20 @@ async function sendStartupStatus(isHotReload) {
     }
     console.warn('[startup-status] no reachable target — status not delivered');
 }
+/**
+ * @description On native Windows, say once per cold start in General which features do not work there and point to WSL2,
+ * worded in that chat's language. Best-effort like the readiness status: no General topic to speak in is not an error (the
+ * console line already said it), and a failed send is logged by the send path.
+ */
+async function postNativeWindowsNoticeToGeneral(isHotReload) {
+    const generalKey = getOperatorGeneralKey();
+    if (generalKey === null)
+        return;
+    const text = withThreadLocale(generalKey, () => (0, nativeWindows_1.getNativeWindowsGeneralNotice)({ platform: process.platform, isHotReload }, i18n_1.t));
+    if (text === null)
+        return;
+    await replyToThread(generalKey, text);
+}
 /**
  * @description Load and prepare the Jira connector, or end the start: a broken
  * config, a token of another account or an unknown trigger status is fatal, with
@@ -11407,6 +11601,7 @@ async function prepareJiraConnectorOrExit() {
             dataDir: path.dirname(state.stateFilePath),
             workRoot: ENV.workRoot,
             openCodeUrl: process.env.OPENCODE_URL,
+            pollIntervalMsOverride: ENV.testTimings.jiraPollIntervalMs,
         });
     }
     catch (error) {
@@ -11459,7 +11654,7 @@ async function startBot() {
     // 1. State store. The `[startup] DATA_DIR=` shape is load-bearing: the
     // README's two-instances troubleshooting tells the operator to compare this
     // exact line across instances.
-    state = await (0, state_1.getStateStore)();
+    state = await (0, state_1.getStateStore)({ saveDebounceMs: ENV.testTimings.stateSaveDebounceMs });
     console.log(`[startup] DATA_DIR=${path.dirname(state.stateFilePath)}`);
     // R13: before anything reads, rewrites or acts on the state, it must hold only
     // conversations of the platforms this instance serves.
@@ -11489,6 +11684,8 @@ async function startBot() {
     (0, createAdapter_1.registerClaudeConfigDirReader)(resolveThreadClaudeConfigDir);
     (0, createAdapter_1.registerClaudeRateLimitSink)(onClaudeRateLimitEvent);
     (0, createAdapter_1.registerClaudeTurnCostSink)(onClaudeTurnCost);
+    if (ENV.testTimings.openCodeServerUpBudgetMs !== undefined)
+        (0, createAdapter_1.registerOpenCodeServerUpBudgetMs)(ENV.testTimings.openCodeServerUpBudgetMs);
     // The usage cache: a first poll now (off the boot path), then the timer.
     claudeUsageRefresher.start();
     void claudeUsageRefresher.refreshAll();
@@ -11542,6 +11739,8 @@ async function startBot() {
             return result.ok ? (result.alertRef ?? null) : null;
         },
         backstopMs: (0, wakeUpRules_1.getRequestBackstopMs)(process.env.REQUEST_BACKSTOP_MINUTES),
+        sweepIntervalMs: ENV.testTimings.requestSweepIntervalMs,
+        firstPostRetryDelayMs: ENV.testTimings.requestFirstPostRetryDelayMs,
         // Only a Telegram topic in the answers-only view hides the stream from someone who expects to see the work.
         checkIsAnswerTailWatched: (key) => (0, sessionKeyCodec_1.checkIsTelegramKey)(key) && !(0, topicView_1.checkIsStreamShown)(state.getDisplayPrefs(key).view),
         remindAnswerTail,
@@ -11565,6 +11764,9 @@ async function startBot() {
     const bootMode = (0, bootClassifier_1.classifyBoot)(downtimeMs);
     console.log(`Boot mode:        ${bootMode.isHotReload ? 'HOT RELOAD' : 'COLD START'} ` +
         `(downtime=${downtimeMs === null ? 'unknown' : `${downtimeMs}ms`})`);
+    const nativeWindowsConsoleLine = (0, nativeWindows_1.getNativeWindowsConsoleLine)(process.platform, i18n_1.t);
+    if (nativeWindowsConsoleLine)
+        console.warn(nativeWindowsConsoleLine);
     console.log(`Chat mode:        ${getChatMode()}`);
     // In `both`, the DM surface only lights up when an OWNER_USER_ID is set;
     // otherwise the instance serves the group only. Surface that explicitly so an
@@ -11626,10 +11828,19 @@ async function startBot() {
         onApiError: (key, error) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'apiError', () => withThreadLocale(key, () => handleApiError(key, error))),
         onNoResponse: (key) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'noResponse', () => handleNoResponse(key)),
         onQuestionGone: (key) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'questionGone', () => withThreadLocale(key, () => handleQuestionGone(key))),
-        onClosed: (key) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'closed', () => withThreadLocale(key, () => handleAgentClosed(key)), () => clearForeignSessionState(key)),
-        onStarted: (key) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'started', () => withThreadLocale(key, () => handleAgentStarted(key))),
+        onClosed: (key) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'closed', () => withThreadLocale(key, () => handleAgentClosed(key)), () => {
+            const lostWork = takeLostWorkOf(key);
+            clearForeignSessionState(key);
+            scheduleLostWorkNote(key, lostWork, 'exited');
+        }),
+        // An issue's process gets the idle countdown and the lost-work note of a re-spawn: it has no banner.
+        onStarted: (key) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'started', () => withThreadLocale(key, () => handleAgentStarted(key)), () => {
+            rearmThreadIdleTimer(key);
+            if (!lostWorkFoldingKeys.has((0, sessionKey_1.keyToString)(key)))
+                scheduleLostWorkNote(key, takeLostWorkOf(key), 'restarted');
+        }),
         onStopped: (key) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'stopped', () => withThreadLocale(key, () => handleAgentStopped(key)), () => clearForeignSessionState(key)),
-        onSuspended: (key) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'suspended', () => withThreadLocale(key, () => handleAgentSuspended(key))),
+        onSuspended: (key) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'suspended', () => withThreadLocale(key, () => handleAgentSuspended(key)), () => scheduleLostWorkNote(key, takeLostWorkOf(key), 'holdExpired')),
         onTurnEnded: (key) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'turnEnded', () => handleAgentTurnEnded(key)),
         onContextCompacted: (key, trigger) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'contextCompacted', () => noteConversationContextReset(key, `compaction (${trigger ?? 'bot'})`)),
         onConversationLost: (key) => (0, adapterEventRouting_1.dispatchAdapterEvent)(key, 'conversationLost', () => withThreadLocale(key, () => handleConversationLost(key)), () => { dropLostConversationWatermark(key); noteConversationContextReset(key, 'its transcript was lost'); }),
@@ -12073,6 +12284,12 @@ async function startBot() {
     catch (e) {
         console.warn('[startup-status] failed:', e instanceof Error ? e.message : e);
     }
+    try {
+        await postNativeWindowsNoticeToGeneral(bootMode.isHotReload);
+    }
+    catch (e) {
+        console.warn('[platform] native Windows notice failed:', e instanceof Error ? e.message : e);
+    }
     await startUpdates();
     // The local speech engine: clean up after an earlier run, re-attach to / start its install. Starts no process.
     void bootSttLocalEngine().catch((e) => console.warn('[STT] boot step failed:', e instanceof Error ? e.message : e));