very-happy-cli 0.2.178 → 0.2.180

package/dist/{runClaudeDeps-CVBCokOS.mjs → runClaudeDeps-BcZ68cX3.mjs}

@@ -1,86 +1,91 @@
-import { l as logger } from './logger--vAVtXB_.mjs';
-import { q as notifyDaemonSessionEvent, t as notifyDaemonClaudeAuthFailed } from './controlClient-BYKyGyxj.mjs';
-export { j as reportSessionEditToDaemon } from './controlClient-BYKyGyxj.mjs';
-import { s as sameBackgroundTasks, e as createBackgroundTaskTracker } from './backgroundTaskActivity-BVwJBl02.mjs';
+import { l as logger } from './logger-BUngm5Xg.mjs';
+import { o as notifyDaemonSessionEvent, q as notifyDaemonClaudeAuthFailed } from './controlClient-DoeYovwP.mjs';
+export { j as reportSessionEditToDaemon } from './controlClient-DoeYovwP.mjs';
+import { s as sameBackgroundTasks, c as createBackgroundTaskTracker } from './backgroundTaskActivity-8PdPxrvy.mjs';
+import { c as createProjectInjector, h as hashObject } from './deterministicJson-CTEJDqtS.mjs';
+export { s as startHappyServer } from './deterministicJson-CTEJDqtS.mjs';
+import { s as sharedProjectsClient } from './client-Ca5Pcgy_.mjs';
 import { randomInt, randomUUID, createHash } from 'node:crypto';
-import { M as MessageBuffer } from './messageBuffer-BWlGgR3A.mjs';
-import { query } from './index-CEjJnq05.mjs';
+import { M as MessageBuffer } from './sessionExitLifecycle-CzkLIgNZ.mjs';
+export { S as SessionExitGate, e as exitIntentFromArchiveFlag, s as settleSessionOnExit } from './sessionExitLifecycle-CzkLIgNZ.mjs';
+import { q as query } from './query-ywZbQUzR.mjs';
 import { AbortError } from '@anthropic-ai/claude-agent-sdk';
 import { m as mapToClaudeMode, p as parseClaudePermissionMode, c as resolveRemoteClaudePermissionMode } from './permissionMode-CH4FoZfU.mjs';
-import { c as claudeCheckSession, s as systemPrompt } from './systemPrompt-CQcuUmVp.mjs';
+import { c as claudeCheckSession, s as systemPrompt } from './systemPrompt-CIZcJuJF.mjs';
 import { join, resolve, dirname } from 'node:path';
-import { p as parseSpecialCommand, w as wrapperRateLimitReporter } from './specialCommands-C6W-rVyh.mjs';
+import { p as parseSpecialCommand, w as wrapperRateLimitReporter } from './specialCommands-D3ND9bdg.mjs';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
-import { A as AsyncLock } from './attachmentLimits-UyFn8fkQ.mjs';
+import { A as AsyncLock } from './pushNotifications-DCiBEVeC.mjs';
 import 'tweetnacl';
-import { c as configuration, e as ensurePrivateDirectory } from './configuration-DVrb61aY.mjs';
-import './index-Clqlu17M.mjs';
-import './registerCommonHandlers-CvIedVRf.mjs';
+import { c as configuration, e as ensurePrivateDirectory } from './configuration-PxzEJumr.mjs';
+import './index-C6Vn5Eac.mjs';
+import './registerCommonHandlers-CTkCvjxt.mjs';
 import 'os';
 import 'child_process';
 import '@paralleldrive/cuid2';
-import './persistence-DTk4sNpd.mjs';
+import './persistence-BFUOHW5h.mjs';
 import { c as contentLogMetadata } from './contentLogMetadata-BlWI0egu.mjs';
 import 'chalk';
-export { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
+import { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
 import { g as getProjectPath } from './path-D2wdaNSk.mjs';
 import { access } from 'fs/promises';
-import { d as delay } from './time-BuGWTVP6.mjs';
+import { d as delay } from './time-D3ETL7Jb.mjs';
 import { mkdirSync, writeFileSync, readFileSync, unlinkSync, renameSync, statSync, existsSync } from 'node:fs';
-import { h as hashObject } from './deterministicJson-C5ZwZ7hu.mjs';
-export { s as startHappyServer } from './deterministicJson-C5ZwZ7hu.mjs';
-import { F as Future, d as describeClaudeProcessExit } from './sessionScanner-BtxoeluY.mjs';
-export { c as createSessionScanner } from './sessionScanner-BtxoeluY.mjs';
+import { F as Future, d as describeClaudeProcessExit } from './sessionScanner-Bm57LEXe.mjs';
+export { c as createSessionScanner } from './sessionScanner-Bm57LEXe.mjs';
 import { execSync } from 'node:child_process';
-import { S as StreamRelay } from './streamRelay-CJoMk_d2.mjs';
-import { C as CLAUDE_ATTACHMENT_KINDS, c as chatAttachmentDirectory, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-DkkdpSSJ.mjs';
+import { S as StreamRelay } from './streamRelay-DnMCMMfV.mjs';
+import { C as CLAUDE_ATTACHMENT_KINDS, c as chatAttachmentDirectory, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-CIn4iPEk.mjs';
 import { writeFile, rename, unlink, readFile } from 'node:fs/promises';
-import { F as ForkSourceMissingError } from './claudeSessionFork-DvxMKAmY.mjs';
-export { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-gwJ5lTf0.mjs';
-export { a as getEnvironmentInfo } from './doctor-0BiGwJXk.mjs';
+import { F as ForkSourceMissingError } from './claudeSessionFork-GAVWhiKG.mjs';
+export { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-CaqqRYq6.mjs';
+export { g as getEnvironmentInfo } from './doctor-IctjVh9T.mjs';
 import { createServer } from 'node:http';
 export { E as EditReportThrottle, b as extractClaudeEditPaths } from './editPaths-BVfS_FFL.mjs';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
-import { r as resolveClaudeBinary, a as runClaudeOneShot } from './titleGenerator-BGEzNWC9.mjs';
-export { T as TitleGenerator } from './titleGenerator-BGEzNWC9.mjs';
+export { s as snapshotTree, t as terminateSurvivors } from './processTreeSnapshot-CuLJDNC-.mjs';
+import { r as resolveClaudeBinary, a as runClaudeOneShot } from './titleGenerator-Uzbd4utr.mjs';
+export { T as TitleGenerator } from './titleGenerator-Uzbd4utr.mjs';
 import { B as BOARD_ANALYZER_PROMPT_PREFIX } from './oneShotPrompts-DT4p6RNd.mjs';
-import { i as isSelfReportFresh } from './reportProgressTool-D5tEoXMW.mjs';
-export { c as createSelfReportState } from './reportProgressTool-D5tEoXMW.mjs';
+import { i as isSelfReportFresh } from './reportProgressTool-ZOCNjWHr.mjs';
+export { c as createSelfReportState } from './reportProgressTool-ZOCNjWHr.mjs';
 import 'node:util';
-import './smallFastModel-BLNgMrwR.mjs';
-import './trimIdent-BAjmv_TG.mjs';
-import 'node:os';
-import './agentGuidance-BDYt2Qy2.mjs';
-import './rateLimitWindows-XrJiiBpU.mjs';
+import './prompt-BOouDaTM.mjs';
 import 'zod';
-import './package-B7B03ejW.mjs';
-import 'util';
-import 'crypto';
-import 'path';
-import 'cross-spawn';
+import './client-D4uPb1uu.mjs';
+import './context-CJGRRGWW.mjs';
+import './sessionOps-C58iDeD5.mjs';
 import './authRelay-DhQhkBvX.mjs';
-import './client-BTX9hsbr.mjs';
-import './context-B3XPVJlj.mjs';
-import './sessionOps-BVoXe12O.mjs';
-import './resources-BdFBQi8r.mjs';
-import './tools-BtsrQnNS.mjs';
-import './peerTools-3R9RUARX.mjs';
+import './resources-y9jfyO-_.mjs';
+import './tools-Cho7iIWf.mjs';
+import './peerTools-BOlDRyhi.mjs';
+import 'node:os';
 import './ids-DU6sLx4C.mjs';
-import './remoteSessionClient-DRb2Jr5s.mjs';
+import './remoteSessionClient-PP-mOKmw.mjs';
 import '@modelcontextprotocol/sdk/server/mcp.js';
 import '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import './limits-DIo7rEBR.mjs';
-import './downloadTarget-DJPwAZlu.mjs';
+import './downloadTarget-jbOz1egC.mjs';
 import './terminals-Dlg0x3nY.mjs';
 import './terminalTitleSuggest-CeKsX_V6.mjs';
 import './tmuxSocket-B8Yx20sT.mjs';
-import './bootstrap-BUagGC_-.mjs';
+import './bootstrap-Dt5I1SOl.mjs';
+import './package-7Ld1YMhh.mjs';
+import './agentGuidance-BDYt2Qy2.mjs';
+import './trimIdent-BAjmv_TG.mjs';
+import './webPanels-B2_C2-3g.mjs';
 import './previewPath-CXN4Vag0.mjs';
-import './sync-DbW07iQS.mjs';
+import 'crypto';
+import './smallFastModel-BLNgMrwR.mjs';
+import './rateLimitWindows-BkfuUB1a.mjs';
+import 'util';
+import 'path';
+import 'cross-spawn';
+import './sync-BvVhDO40.mjs';
 import './transcriptCursor-B7T_gkQ0.mjs';
-import './startFileWatcher-CR09Snmz.mjs';
+import './startFileWatcher-DXJ7yB5v.mjs';
 import 'node:readline';
 import './doctor-BPkYWSuq.mjs';
 import 'ps-list';
@@ -88,11 +93,11 @@ import './doctorReadiness-C208SMN9.mjs';
 import './detectCLI-CSGMlV51.mjs';
 import 'fs';
 import './cliUpdate-Y34VGe9Y.mjs';
-import './piRunnerArgs-AT8QJY7x.mjs';
-import './sessionModeFile-ByLbXTbg.mjs';
+import './piRunnerArgs-H2pgpA5z.mjs';
+import './acpSessionResume-B9l54P-X.mjs';
 import 'url';
 import 'node:module';
-import './client-CnlkkrZO.mjs';
+import './client-CnB7kRCT.mjs';
 import './precheckCompat-DeEbilbr.mjs';
 
 const SCHEDULE_WAKEUP_GRACE_MS = 6e4;
@@ -130,6 +135,41 @@ function createScheduledWakeupTracker() {
   return { observe, pending };
 }
 
+function modelTarget(model) {
+  return model == null || model === "" ? void 0 : model;
+}
+function needsModelSwitch(current, next) {
+  return modelTarget(current) !== modelTarget(next);
+}
+function modelSwitchFailureNotice(model, error) {
+  const name = modelTarget(model) ?? "default";
+  const detail = error instanceof Error ? error.message : String(error);
+  return `\u26A0\uFE0F Could not switch to model "${name}" \u2014 continuing with the previous model. ${detail}`;
+}
+
+const CLAUDE_MODEL_NOT_FOUND = "model_not_found";
+function retiredModelFrom(message, runningModel) {
+  const m = message;
+  if (!m || m.type !== "assistant" || m.error !== CLAUDE_MODEL_NOT_FOUND) return null;
+  if ((m.parent_tool_use_id ?? null) !== null) return null;
+  return modelTarget(runningModel) ?? null;
+}
+function createRetiredModels() {
+  const retired = /* @__PURE__ */ new Set();
+  return {
+    retire(model) {
+      retired.add(model);
+    },
+    effective(model) {
+      const target = modelTarget(model);
+      return target !== void 0 && retired.has(target) ? void 0 : target;
+    }
+  };
+}
+function retiredModelNotice(model) {
+  return `\u26A0\uFE0F Model "${model}" is no longer available \u2014 switched this session to the default model. Pick another model to change it, then send your message again.`;
+}
+
 class Session {
   path;
   logPath;
@@ -158,6 +198,8 @@ class Session {
   backgroundTasks = [];
   /** B-587 review P3-4: CronCreate / ScheduleWakeup pending in this Claude process. */
   scheduledWakeups = createScheduledWakeupTracker();
+  /** B-634 ③: model ids Claude Code reported as model_not_found — session-scoped, survives relaunches. */
+  retiredModels = createRetiredModels();
   /**
    * Window after a user-initiated abort during which stray promise rejections
    * from tearing down the SDK query (MCP transports, in-flight tool calls,
@@ -211,6 +253,20 @@ class Session {
   sessionFoundCallbacks = [];
   /** Keep alive interval reference for cleanup */
   keepAliveInterval;
+  /**
+   * B-645: project context rides in front of real user messages (never the
+   * system prompt), so it survives relaunches without touching the mode hash
+   * or prewarm key. One per session process; created on first use.
+   */
+  _projectInjector = null;
+  get projectInjector() {
+    return this._projectInjector ??= createProjectInjector({
+      client: sharedProjectsClient(),
+      sessionId: () => this.client.sessionId,
+      metadata: () => this.client.getMetadata?.() ?? null,
+      agent: "claude"
+    });
+  }
   constructor(opts) {
     this.path = opts.path;
     this.api = opts.api;
@@ -597,6 +653,112 @@ function createRuntimeControls(isThinking) {
   return { setQuery, observe, request, stopRunningTasks };
 }
 
+const CLAUDE_COMMAND_LIFECYCLE_STATES = ["queued", "started", "completed", "cancelled", "discarded", "refused"];
+function readClaudeCommandLifecycle(frame) {
+  const m = frame;
+  if (!m) return null;
+  const isLifecycle = m.type === "command_lifecycle" || m.type === "system" && m.subtype === "command_lifecycle";
+  if (!isLifecycle || typeof m.command_uuid !== "string" || m.command_uuid.length === 0) return null;
+  const state = CLAUDE_COMMAND_LIFECYCLE_STATES.find((candidate) => candidate === m.state);
+  return state ? { uuid: m.command_uuid, state } : null;
+}
+const uuidList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.length > 0) : [];
+const INTERRUPT_CANCEL_QUEUED_CAPABILITY = "interrupt_cancel_queued_v1";
+const PENDING_MAX = 256;
+const REPORTED_MAX = 512;
+const MSG_LIFECYCLE_CAPABILITY = "msg_lifecycle_v1";
+function createClaudeCommandTracker() {
+  const pending = /* @__PURE__ */ new Map();
+  const reported = /* @__PURE__ */ new Set();
+  const drop = (uuid) => {
+    pending.delete(uuid);
+    if (reported.has(uuid)) return null;
+    reported.add(uuid);
+    if (reported.size > REPORTED_MAX) reported.delete(reported.values().next().value);
+    return uuid;
+  };
+  return {
+    /** A uuid-stamped user message (prompt or steer) was handed to the Query. */
+    track(uuid, payload) {
+      if (!pending.has(uuid) && pending.size >= PENDING_MAX) pending.delete(pending.keys().next().value);
+      pending.set(uuid, { started: false, payload });
+    },
+    isTracked(uuid) {
+      return pending.has(uuid);
+    },
+    /** A lifecycle frame; returns the uuids now known to have never run. */
+    observe(lifecycle) {
+      const entry = pending.get(lifecycle.uuid);
+      if (!entry) return [];
+      switch (lifecycle.state) {
+        case "queued":
+          return [];
+        case "started":
+          entry.started = true;
+          return [];
+        case "completed":
+          pending.delete(lifecycle.uuid);
+          return [];
+        default: {
+          if (entry.started) {
+            pending.delete(lifecycle.uuid);
+            return [];
+          }
+          const dropped = drop(lifecycle.uuid);
+          return dropped ? [dropped] : [];
+        }
+      }
+    },
+    /**
+     * An interrupt's receipt: `cancelled` members we track never ran;
+     * `still_queued` members we track are returned for the per-uuid
+     * follow-up (`cancel_async_message`) a CLI without cancel_queued needs.
+     */
+    onInterruptReceipt(receipt) {
+      const dropped = [];
+      for (const uuid of uuidList(receipt?.cancelled)) {
+        if (!pending.has(uuid)) continue;
+        const result = drop(uuid);
+        if (result) dropped.push(result);
+      }
+      const stillQueued = uuidList(receipt?.still_queued).filter((uuid) => pending.has(uuid));
+      return { dropped, stillQueued };
+    },
+    /** The answer to `cancel_async_message`: true = withdrawn before it ran; false = already dequeued, its lifecycle frames follow. */
+    onCancelResponse(uuid, cancelled) {
+      if (!cancelled || !pending.has(uuid)) return [];
+      const dropped = drop(uuid);
+      return dropped ? [dropped] : [];
+    },
+    /**
+     * B-634 ②: the Query is over — every tracked message that never
+     * `started` and was not already reported, in the order it was sent.
+     * Untracked afterwards; a later frame for one of them is ignored.
+     */
+    takeUnconfirmed() {
+      const out = [];
+      for (const [uuid, entry] of pending) {
+        if (entry.started || entry.payload === void 0 || reported.has(uuid)) continue;
+        out.push({ uuid, payload: entry.payload });
+      }
+      for (const { uuid } of out) pending.delete(uuid);
+      return out;
+    },
+    clear() {
+      pending.clear();
+    }
+  };
+}
+function planUnconfirmedCommands(commands, context) {
+  if (context.aborted || !context.parkFree) return { redeliver: null, tombstone: commands.map((c) => c.uuid) };
+  const index = commands.findIndex((c) => !context.redelivered.has(c.uuid));
+  if (index < 0) return { redeliver: null, tombstone: commands.map((c) => c.uuid) };
+  return {
+    redeliver: commands[index],
+    tombstone: commands.filter((_, i) => i !== index).map((c) => c.uuid)
+  };
+}
+
 const AUTH_FAILURE_RESULT_TEXT = /Failed to authenticate|OAuth session expired/i;
 const QUERY_RECYCLE_NOTICE = {
   authentication_failed: "\u26A0\uFE0F Claude Code could not refresh its OAuth session. This agent process was ended so your next message starts a fresh one that re-reads the credentials on this machine; if it fails again, run `claude` on the machine to log in again."
@@ -750,18 +912,6 @@ async function awaitFileExist(file, timeout = 1e4) {
   return false;
 }
 
-function modelTarget(model) {
-  return model == null || model === "" ? void 0 : model;
-}
-function needsModelSwitch(current, next) {
-  return modelTarget(current) !== modelTarget(next);
-}
-function modelSwitchFailureNotice(model, error) {
-  const name = modelTarget(model) ?? "default";
-  const detail = error instanceof Error ? error.message : String(error);
-  return `\u26A0\uFE0F Could not switch to model "${name}" \u2014 continuing with the previous model. ${detail}`;
-}
-
 const SDK_TIMING_FIELDS = ["ttft_ms", "time_to_request_ms", "time_to_request_from_spawn_ms"];
 function delta(from, to) {
   if (typeof from !== "number" || typeof to !== "number" || to < from) return "-";
@@ -1096,88 +1246,6 @@ function createClaudeTurnTracker() {
   };
 }
 
-const CLAUDE_COMMAND_LIFECYCLE_STATES = ["queued", "started", "completed", "cancelled", "discarded", "refused"];
-function readClaudeCommandLifecycle(frame) {
-  const m = frame;
-  if (!m) return null;
-  const isLifecycle = m.type === "command_lifecycle" || m.type === "system" && m.subtype === "command_lifecycle";
-  if (!isLifecycle || typeof m.command_uuid !== "string" || m.command_uuid.length === 0) return null;
-  const state = CLAUDE_COMMAND_LIFECYCLE_STATES.find((candidate) => candidate === m.state);
-  return state ? { uuid: m.command_uuid, state } : null;
-}
-const uuidList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.length > 0) : [];
-const INTERRUPT_CANCEL_QUEUED_CAPABILITY = "interrupt_cancel_queued_v1";
-const PENDING_MAX = 256;
-const REPORTED_MAX = 512;
-function createClaudeCommandTracker() {
-  const pending = /* @__PURE__ */ new Map();
-  const reported = /* @__PURE__ */ new Set();
-  const drop = (uuid) => {
-    pending.delete(uuid);
-    if (reported.has(uuid)) return null;
-    reported.add(uuid);
-    if (reported.size > REPORTED_MAX) reported.delete(reported.values().next().value);
-    return uuid;
-  };
-  return {
-    /** A uuid-stamped user message (prompt or steer) was handed to the Query. */
-    track(uuid) {
-      if (!pending.has(uuid) && pending.size >= PENDING_MAX) pending.delete(pending.keys().next().value);
-      pending.set(uuid, { started: false });
-    },
-    isTracked(uuid) {
-      return pending.has(uuid);
-    },
-    /** A lifecycle frame; returns the uuids now known to have never run. */
-    observe(lifecycle) {
-      const entry = pending.get(lifecycle.uuid);
-      if (!entry) return [];
-      switch (lifecycle.state) {
-        case "queued":
-          return [];
-        case "started":
-          entry.started = true;
-          return [];
-        case "completed":
-          pending.delete(lifecycle.uuid);
-          return [];
-        default: {
-          if (entry.started) {
-            pending.delete(lifecycle.uuid);
-            return [];
-          }
-          const dropped = drop(lifecycle.uuid);
-          return dropped ? [dropped] : [];
-        }
-      }
-    },
-    /**
-     * An interrupt's receipt: `cancelled` members we track never ran;
-     * `still_queued` members we track are returned for the per-uuid
-     * follow-up (`cancel_async_message`) a CLI without cancel_queued needs.
-     */
-    onInterruptReceipt(receipt) {
-      const dropped = [];
-      for (const uuid of uuidList(receipt?.cancelled)) {
-        if (!pending.has(uuid)) continue;
-        const result = drop(uuid);
-        if (result) dropped.push(result);
-      }
-      const stillQueued = uuidList(receipt?.still_queued).filter((uuid) => pending.has(uuid));
-      return { dropped, stillQueued };
-    },
-    /** The answer to `cancel_async_message`: true = withdrawn before it ran; false = already dequeued, its lifecycle frames follow. */
-    onCancelResponse(uuid, cancelled) {
-      if (!cancelled || !pending.has(uuid)) return [];
-      const dropped = drop(uuid);
-      return dropped ? [dropped] : [];
-    },
-    clear() {
-      pending.clear();
-    }
-  };
-}
-
 const SET_MODEL_TIMEOUT_MS = 3e4;
 const PROMPT_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function promptUuid(uuid) {
@@ -1351,9 +1419,14 @@ async function claudeRemote(opts) {
   const discardWarm = (reason) => {
     warm?.lease.discard(reason);
   };
+  const withoutRetiredModel = (next) => {
+    if (!next || !opts.retiredModels) return next;
+    const model = opts.retiredModels.effective(next.mode.model);
+    return model === next.mode.model ? next : { ...next, mode: { ...next.mode, model } };
+  };
   let initial;
   try {
-    initial = await opts.nextMessage();
+    initial = withoutRetiredModel(await opts.nextMessage());
   } catch (error) {
     discardWarm("error");
     throw error;
@@ -1513,7 +1586,7 @@ async function claudeRemote(opts) {
       steer: (message, nextMode, localKey) => {
         mode = { ...nextMode, model: mode.model };
         const uuid = promptUuid(localKey);
-        if (uuid.uuid) commandTracker.track(uuid.uuid);
+        if (uuid.uuid) commandTracker.track(uuid.uuid, { message, mode: nextMode });
         messages.push({
           type: "user",
           parent_tool_use_id: null,
@@ -1527,7 +1600,7 @@ async function claudeRemote(opts) {
   }
   let lastAssistantError;
   turn.pushed();
-  if (initialUserMessage.uuid) commandTracker.track(initialUserMessage.uuid);
+  if (initialUserMessage.uuid) commandTracker.track(initialUserMessage.uuid, { message: initial.message, mode: initial.mode });
   let modelUnconfirmed = false;
   let pullingNext = false;
   const pullNextMessage = () => {
@@ -1536,8 +1609,10 @@ async function claudeRemote(opts) {
       return;
     }
     pullingNext = true;
-    opts.nextMessage().then(async (next) => {
+    opts.nextMessage().then(async (pulled) => {
+      let next = withoutRetiredModel(pulled);
       if (!next) {
+        pullingNext = false;
         messages.end();
         return;
       }
@@ -1557,8 +1632,9 @@ async function claudeRemote(opts) {
       updateThinking(true);
       turn.pushed();
       const uuid = promptUuid(next.uuid);
-      if (uuid.uuid) commandTracker.track(uuid.uuid);
+      if (uuid.uuid) commandTracker.track(uuid.uuid, { message: next.message, mode: next.mode });
       timingMarks = { pushedAt: next.enqueuedAt ?? Date.now() };
+      pullingNext = false;
       messages.push({
         type: "user",
         parent_tool_use_id: null,
@@ -1567,9 +1643,8 @@ async function claudeRemote(opts) {
         message: { role: "user", content: next.message }
       });
     }).catch(() => {
-      messages.end();
-    }).finally(() => {
       pullingNext = false;
+      messages.end();
     });
   };
   const recycleIfPoisoned = (result) => {
@@ -1608,6 +1683,17 @@ async function claudeRemote(opts) {
       if (message.type === "assistant" && message.error) {
         lastAssistantError = message.error;
       }
+      const retired = opts.retiredModels ? retiredModelFrom(message, mode.model) : null;
+      if (retired) {
+        opts.retiredModels.retire(retired);
+        mode = { ...mode, model: void 0 };
+        logger.debug(`[claudeRemote] Model ${retired} reported model_not_found; moving the session to the default model`);
+        opts.onCompletionEvent?.(retiredModelNotice(retired));
+        void withTimeout(response.setModel(void 0), SET_MODEL_TIMEOUT_MS, "set_model").catch((e) => {
+          logger.debug(`[claudeRemote] setModel(default) after model_not_found failed: ${e instanceof Error ? e.message : String(e)}`);
+          modelUnconfirmed = true;
+        });
+      }
       if (message.type === "assistant" && timingMarks.firstAssistantAt === void 0) {
         timingMarks.firstAssistantAt = Date.now();
       } else if (message.type === "system" && message.subtype === "init" && timingMarks.initAt === void 0) {
@@ -1721,6 +1807,13 @@ async function claudeRemote(opts) {
     }
   } finally {
     updateThinking(false);
+    if (cliCapabilities.has(MSG_LIFECYCLE_CAPABILITY)) {
+      const unconfirmed = commandTracker.takeUnconfirmed();
+      if (unconfirmed.length > 0) {
+        logger.debug(`[claudeRemote] Query ended with ${unconfirmed.length} user message(s) never started: ${unconfirmed.map((c) => c.uuid).join(", ")}`);
+        opts.onCommandsUnconfirmed?.(unconfirmed, { aborted: opts.signal?.aborted === true });
+      }
+    }
   }
 }
 
@@ -3952,6 +4045,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
   }
   try {
     const modeGate = new LaunchModeGate(session.queue.modeHasher);
+    const redeliveredCommands = /* @__PURE__ */ new Set();
     let previousSessionId = null;
     await Promise.race([
       rewindReconciler.startup().catch((error) => logger.debug("[rewind] startup reconcile failed", error)),
@@ -4007,10 +4101,15 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
             return permissionHandler.isAborted(toolCallId);
           },
           nextMessage: async () => {
+            const finalize = async (text) => {
+              const out = await session.projectInjector.decorate(text);
+              onPromptFinalized?.(out);
+              return out;
+            };
             const parked = modeGate.takeParked();
             if (parked) {
               permissionHandler.handleModeChange(parked.mode.permissionMode);
-              if (typeof parked.message === "string") onPromptFinalized?.(parked.message);
+              if (typeof parked.message === "string") return { ...parked, message: await finalize(parked.message) };
               return parked;
             }
             await rewindReconciler.settled(controller.signal);
@@ -4039,8 +4138,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
                   sessionId: session.client.sessionId
                 });
                 logger.debug(`[remote] Staged ${staged.length} attachment(s) for the coding agent`);
-                const withAttachments = appendStagedAttachmentsToPrompt(msg.message, staged);
-                onPromptFinalized?.(withAttachments);
+                const withAttachments = await finalize(appendStagedAttachmentsToPrompt(msg.message, staged));
                 return {
                   message: withAttachments,
                   mode: msg.mode,
@@ -4048,9 +4146,9 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
                   uuid: promptUuidFor(msg.sourceIds)
                 };
               }
-              onPromptFinalized?.(msg.message);
+              const finalized = await finalize(msg.message);
               return {
-                message: msg.message,
+                message: finalized,
                 mode: msg.mode,
                 enqueuedAt: msg.enqueuedAt,
                 uuid: promptUuidFor(msg.sourceIds)
@@ -4124,6 +4222,25 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
           // queued behind a pre-empting steer's turn) before the model
           // read them — the same tombstone a destroyed queue item gets
           // (B-332), so the web shows them as not delivered, not answered.
+          retiredModels: session.retiredModels,
+          // B-634 ②: messages the Query ended without Claude Code ever
+          // starting them — sent once more, or tombstoned (B-332).
+          onCommandsUnconfirmed: (commands, { aborted }) => {
+            const plan = planUnconfirmedCommands(commands, {
+              aborted: aborted || exitReason !== null,
+              parkFree: !modeGate.hasParked,
+              redelivered: redeliveredCommands
+            });
+            if (plan.redeliver) {
+              redeliveredCommands.add(plan.redeliver.uuid);
+              logger.debug(`[remote]: re-sending unconfirmed user message ${plan.redeliver.uuid} into the next launch`);
+              modeGate.park({ message: plan.redeliver.payload.message, mode: plan.redeliver.payload.mode, uuid: plan.redeliver.uuid });
+            }
+            if (plan.tombstone.length > 0) {
+              logger.debug(`[remote]: ${plan.tombstone.length} user message(s) never started before the query ended`);
+              session.client.sendQueueCancelReason(plan.tombstone, "aborted");
+            }
+          },
           onCommandsDropped: (uuids) => {
             logger.debug(`[remote]: ${uuids.length} user message(s) never read before the turn ended`);
             session.client.sendQueueCancelReason(uuids, "aborted");
@@ -4266,7 +4383,7 @@ async function loop(opts) {
     logger.debug(`[loop] Iteration with mode: ${mode}`);
     switch (mode) {
       case "local": {
-        const { claudeLocalLauncher } = await import('./claudeLocalLauncher-BmrpaRYJ.mjs');
+        const { claudeLocalLauncher } = await import('./claudeLocalLauncher-BStvfa7M.mjs');
         const result = await claudeLocalLauncher(session);
         switch (result.type) {
           case "switch":
@@ -4431,71 +4548,6 @@ function cleanupHookSettingsFile(filepath) {
   }
 }
 
-async function settleSessionOnExit(sessionId, intent, deps) {
-  if (intent === "archive") {
-    deps.updateMetadata((currentMetadata) => ({
-      ...currentMetadata,
-      lifecycleState: "archived",
-      lifecycleStateSince: Date.now(),
-      archivedBy: "cli",
-      archiveReason: "User terminated"
-    }));
-  }
-  if (intent === "hibernate" && deps.hibernation) {
-    const stamp = deps.hibernation;
-    const handler = (currentMetadata) => ({ ...currentMetadata, hibernation: stamp });
-    const landed = deps.updateMetadataAndWait ? await deps.updateMetadataAndWait(handler) : (deps.updateMetadata(handler), false);
-    if (!landed) deps.log?.("[START] hibernation stamp not confirmed before going offline");
-  }
-  deps.sendSessionDeath();
-  try {
-    if (intent === "archive") await deps.archiveSession(sessionId);
-    else await deps.deactivateSession(sessionId);
-  } catch (error) {
-    deps.log?.(`[START] ${intent === "archive" ? "archiveSession" : "deactivateSession"} during cleanup failed:`, error);
-  }
-}
-class SessionExitGate {
-  decided = null;
-  hibernateCommitted = false;
-  deferred = null;
-  /** Returns the intent to act on, or null when cleanup already started. */
-  claim(intent) {
-    if (this.decided === "hibernate" && !this.hibernateCommitted && intent !== "hibernate") {
-      if (this.deferred !== "archive") this.deferred = intent;
-      return null;
-    }
-    if (this.decided !== null) return null;
-    this.decided = intent;
-    return intent;
-  }
-  get current() {
-    return this.decided;
-  }
-  /** B-587: an exit was requested while the hibernation was deciding. */
-  get exitRequested() {
-    return this.deferred !== null;
-  }
-  /** B-587: the hibernation passed its last check — no more deferral. */
-  commitHibernate() {
-    if (this.decided === "hibernate") this.hibernateCommitted = true;
-  }
-  /**
-   * B-587: a hibernation that aborted hands the exit back. Returns the exit
-   * deferred meanwhile (the caller must run it now), or null.
-   */
-  release(intent) {
-    if (this.decided !== intent || intent === "hibernate" && this.hibernateCommitted) return null;
-    this.decided = null;
-    const deferred = this.deferred;
-    this.deferred = null;
-    return deferred;
-  }
-}
-function exitIntentFromArchiveFlag(archive) {
-  return archive ?? true ? "archive" : "offline";
-}
-
 function isUnsupportedSideQuestionError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return /unknown|unsupported|not supported|unrecognized|invalid.*subtype/i.test(message);
@@ -4672,7 +4724,7 @@ function registerSideQuestionHandler(rpc, deps) {
   const retainMs = deps.retainMs ?? SIDE_QUESTION_RETAIN_MS;
   const maxRunMs = deps.maxRunMs ?? SIDE_QUESTION_MAX_RUN_MS;
   const fork = deps.run ?? (async (input) => {
-    const { query } = await import('./index-CEjJnq05.mjs');
+    const { query } = await import('./index-CMf5VbzG.mjs');
     return runSideQuestion(query, input);
   });
   const run = async (input, live) => {
@@ -4786,6 +4838,25 @@ function registerSideQuestionHandler(rpc, deps) {
   };
 }
 
+function replayClaudeForkJsonl(file, sink) {
+  let replayed = 0;
+  for (const line of file.split("\n")) {
+    if (line.trim().length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const result = RawJSONLinesSchema.safeParse(parsed);
+    if (!result.success) continue;
+    sink.send(result.data);
+    replayed += 1;
+  }
+  if (replayed > 0) sink.closeTurn();
+  return replayed;
+}
+
 const ANALYZE_MIN_INTERVAL_MS = 5 * 60 * 1e3;
 const HOURLY_LIMIT = 30;
 const HOURLY_WINDOW_MS = 60 * 60 * 1e3;
@@ -5074,4 +5145,4 @@ function resolveMessageMode(current, meta, ctx) {
   };
 }
 
-export { BoardAnalyzer, FileRateLimiter, PrewarmHookGate, SessionExitGate, acquirePrewarmSlot, claudeCheckSession, claudeModeHash, claudePrewarmEligibility, claudePrewarmSessionEligibility, cleanupHookSettingsFile, contentLogMetadata, createClaudePrewarmLease, disposeAllClaudePrewarms, evaluatePrewarmPrediction, exitIntentFromArchiveFlag, formatPrewarmLine, generateHookSettingsFile, getProjectPath, loop, parseSpecialCommand, prewarmCacheFile, prewarmPredictionMeta, prewarmSlotDir, readPrewarmCache, registerSideQuestionHandler, resolveMessageMode, settleSessionOnExit, startHookServer, withAssistantDenylist, writePrewarmCache, writeSideQuestionSettingsFile };
+export { BoardAnalyzer, FileRateLimiter, PrewarmHookGate, RawJSONLinesSchema, acquirePrewarmSlot, claudeCheckSession, claudeModeHash, claudePrewarmEligibility, claudePrewarmSessionEligibility, cleanupHookSettingsFile, contentLogMetadata, createClaudePrewarmLease, disposeAllClaudePrewarms, evaluatePrewarmPrediction, formatPrewarmLine, generateHookSettingsFile, getProjectPath, loop, parseSpecialCommand, prewarmCacheFile, prewarmPredictionMeta, prewarmSlotDir, readPrewarmCache, registerSideQuestionHandler, replayClaudeForkJsonl, resolveMessageMode, startHookServer, withAssistantDenylist, writePrewarmCache, writeSideQuestionSettingsFile };