@adhdev/daemon-standalone 1.0.29 → 1.0.30-rc.2

package/dist/index.js

@@ -2887,6 +2887,7 @@ var require_dist = __commonJS({
       isDefaultInstanceConfigDir: () => isDefaultInstanceConfigDir,
       isSessionHostLiveRuntime: () => isSessionHostLiveRuntime2,
       isSessionHostRecoverySnapshot: () => isSessionHostRecoverySnapshot2,
+      isTerminalRecord: () => isTerminalRecord,
       partitionSessionHostDiagnosticsSessions: () => partitionSessionHostDiagnosticsSessions2,
       partitionSessionHostRecords: () => partitionSessionHostRecords2,
       resolveAttachableRuntimeRecord: () => resolveAttachableRuntimeRecord,
@@ -3062,10 +3063,17 @@ var require_dist = __commonJS({
       return candidate;
     }
     var LIVE_LIFECYCLES = /* @__PURE__ */ new Set(["starting", "running", "stopping", "interrupted"]);
+    var TERMINAL_LIFECYCLES = /* @__PURE__ */ new Set(["stopped", "failed"]);
+    function isTerminalRecord(record2) {
+      if (!record2) return false;
+      if (record2.termination) return true;
+      return TERMINAL_LIFECYCLES.has(String(record2.lifecycle || "").trim());
+    }
     function isSessionHostLiveRuntime2(record2) {
       if (!record2) return false;
       if (record2.surfaceKind === "live_runtime") return true;
       if (record2.surfaceKind === "recovery_snapshot" || record2.surfaceKind === "inactive_record") return false;
+      if (record2.termination) return false;
       const lifecycle = String(record2.lifecycle || "").trim();
       return LIVE_LIFECYCLES.has(lifecycle);
     }
@@ -33311,10 +33319,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "949f72794613d4854c7cf869992acbf9b003675b" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "949f727" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.29" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-02T08:25:35.500Z" : void 0);
+      const commit = readInjected(true ? "db8aa7a995a36bb687757d1ebcac1e394ee764a6" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "db8aa7a9" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.30-rc.2" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-03T02:08:19.187Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -35574,11 +35582,15 @@ ${error48.message || ""}`;
     __export2(dist_exports, {
       CANONICAL_MESH_TOOL_COUNT: () => CANONICAL_MESH_TOOL_COUNT,
       CANONICAL_MESH_TOOL_NAMES: () => CANONICAL_MESH_TOOL_NAMES,
+      CLI_SLOT_RECIPES: () => CLI_SLOT_RECIPES,
       DEFAULT_DIFFICULTY_BRAINS: () => DEFAULT_DIFFICULTY_BRAINS,
       MAGI_RAW_ANSWER_CAP: () => MAGI_RAW_ANSWER_CAP,
       MESH_TASK_DIFFICULTIES: () => MESH_TASK_DIFFICULTIES,
       STATUS_PROBE_ARG_KEY: () => STATUS_PROBE_ARG_KEY,
+      UNKNOWN_CLI_SLOT_RECIPE: () => UNKNOWN_CLI_SLOT_RECIPE,
       argsCarryStatusProbeMarker: () => argsCarryStatusProbeMarker,
+      buildMagiPanelProposal: () => buildMagiPanelProposal,
+      buildSlotProposal: () => buildSlotProposal,
       canonicalDaemonId: () => canonicalDaemonId,
       daemonIdsEquivalent: () => daemonIdsEquivalent,
       deriveSlotsFromLegacy: () => deriveSlotsFromLegacy,
@@ -36033,6 +36045,93 @@ ${error48.message || ""}`;
         };
       });
     }
+    function slotKey(slot) {
+      return [
+        slot.provider,
+        slot.model ?? "",
+        slot.thinkingLevel ?? "",
+        [...slot.difficulty ?? []].sort().join("|"),
+        [...slot.capability ?? []].sort().join("|"),
+        slot.maxParallel ?? ""
+      ].join("\0");
+    }
+    function dedupeDetected(detected) {
+      const seen = /* @__PURE__ */ new Set();
+      const out = [];
+      for (const d of detected) {
+        const type2 = typeof d?.type === "string" ? d.type.trim() : "";
+        if (!type2 || seen.has(type2)) continue;
+        seen.add(type2);
+        out.push({ ...d, type: type2 });
+      }
+      return out;
+    }
+    function buildSlotProposal(detected, currentSlots = []) {
+      const providers = dedupeDetected(detected ?? []);
+      const proposedSlots = [];
+      const entries = [];
+      const unknownProviders = [];
+      const provisionalProviders = [];
+      for (const provider of providers) {
+        const known = CLI_SLOT_RECIPES[provider.type];
+        const recipes = known ?? [UNKNOWN_CLI_SLOT_RECIPE];
+        const isUnknown = !known;
+        if (isUnknown) unknownProviders.push(provider.type);
+        let providerProvisional = false;
+        for (const recipe of recipes) {
+          const slot = normalizeNodeCapabilitySlot({
+            provider: provider.type,
+            model: recipe.model,
+            thinkingLevel: recipe.thinkingLevel,
+            difficulty: recipe.difficulty,
+            maxParallel: recipe.maxParallel
+          });
+          if (!slot) continue;
+          const provisional = recipe.provisional === true;
+          if (provisional) providerProvisional = true;
+          proposedSlots.push(slot);
+          entries.push({
+            slot,
+            unknownProvider: isUnknown,
+            provisional,
+            ...recipe.rationale ? { rationale: recipe.rationale } : {}
+          });
+        }
+        if (providerProvisional) provisionalProviders.push(provider.type);
+      }
+      const proposedKeys = new Set(proposedSlots.map(slotKey));
+      const droppedSlots = currentSlots.filter((slot) => !proposedKeys.has(slotKey(slot)));
+      const proposedProviders = new Set(proposedSlots.map((s2) => s2.provider));
+      const droppedProviders = [...new Set(
+        droppedSlots.map((s2) => s2.provider).filter((p) => !proposedProviders.has(p))
+      )];
+      return {
+        proposedSlots,
+        entries,
+        unknownProviders,
+        provisionalProviders,
+        droppedSlots,
+        droppedProviders,
+        destructive: droppedSlots.length > 0
+      };
+    }
+    function buildMagiPanelProposal(detected, opts = {}) {
+      const providers = dedupeDetected(detected ?? []);
+      const tableOrder = Object.keys(CLI_SLOT_RECIPES);
+      const rank = (type2) => {
+        const i = tableOrder.indexOf(type2);
+        return i === -1 ? Number.MAX_SAFE_INTEGER : i;
+      };
+      const ordered = [...providers].sort((a, b) => rank(a.type) - rank(b.type));
+      const limit = Number.isFinite(opts.maxSlots) && opts.maxSlots > 0 ? Math.floor(opts.maxSlots) : ordered.length;
+      return ordered.slice(0, limit).map((p) => ({
+        ...opts.nodeId ? { nodeId: opts.nodeId } : {},
+        provider: p.type
+        // A model is intentionally NOT pinned: the panel's job is cross-provider
+        // independence, and pinning models here would silently couple the panel
+        // to this table's cost assumptions rather than to review quality.
+      }));
+    }
     function interpolateArgs(args, context) {
       const result = {};
       for (const [k, v] of Object.entries(args)) {
@@ -36061,6 +36160,8 @@ ${error48.message || ""}`;
     var MAGI_RAW_ANSWER_CAP;
     var MESH_TASK_DIFFICULTIES;
     var DEFAULT_DIFFICULTY_BRAINS;
+    var CLI_SLOT_RECIPES;
+    var UNKNOWN_CLI_SLOT_RECIPE;
     var CANONICAL_MESH_TOOL_NAMES;
     var CANONICAL_MESH_TOOL_COUNT;
     var STATUS_PROBE_ARG_KEY;
@@ -36075,6 +36176,73 @@ ${error48.message || ""}`;
           medium: { model: "sonnet", thinkingLevel: "medium" },
           difficult: { model: "opus", thinkingLevel: "high" }
         };
+        CLI_SLOT_RECIPES = Object.freeze({
+          "claude-cli": [
+            {
+              model: "sonnet",
+              thinkingLevel: "high",
+              difficulty: ["medium", "easy"],
+              maxParallel: 5,
+              rationale: "Primary workhorse \u2014 widest parallelism for routine work."
+            },
+            {
+              model: "opus",
+              thinkingLevel: "high",
+              difficulty: ["difficult"],
+              maxParallel: 1,
+              rationale: "Reserved for hard tasks; capped at 1 to bound cost."
+            }
+          ],
+          "kimi": [
+            {
+              model: "kimi-code/k3",
+              difficulty: ["medium", "difficult"],
+              maxParallel: 2,
+              rationale: "Independent second opinion on mid/hard work."
+            }
+          ],
+          "codex-cli": [
+            {
+              difficulty: ["medium", "difficult", "freeform"],
+              maxParallel: 2,
+              rationale: "Broad range including freeform; no model pin."
+            }
+          ],
+          "antigravity-cli": [
+            {
+              model: "Gemini 3.1 Pro (High)",
+              difficulty: ["easy"],
+              maxParallel: 2,
+              rationale: "Cheap capacity for easy tasks."
+            }
+          ],
+          "cursor-cli": [
+            {
+              model: "auto",
+              difficulty: ["easy"],
+              maxParallel: 1,
+              rationale: "Easy tasks only; auto model selection."
+            }
+          ],
+          "hermes-cli": [
+            {
+              difficulty: ["medium"],
+              maxParallel: 2,
+              provisional: true,
+              // NOTE: ESTIMATE, NOT OBSERVED. hermes-cli is absent from the live
+              // slot configuration this table was seeded from, so `medium` is a
+              // conservative placement rather than a transcription. Revisit once
+              // it has real usage data.
+              rationale: "ESTIMATE \u2014 no live slot to transcribe; conservative mid placement. Adjust after real use."
+            }
+          ]
+        });
+        UNKNOWN_CLI_SLOT_RECIPE = Object.freeze({
+          difficulty: ["medium"],
+          maxParallel: 1,
+          provisional: true,
+          rationale: "Unrecognized provider \u2014 conservative default (medium, maxParallel 1). Review before relying on it."
+        });
         CANONICAL_MESH_TOOL_NAMES = [
           "mesh_status",
           "mesh_list_nodes",
@@ -36126,7 +36294,8 @@ ${error48.message || ""}`;
           "mesh_magi_kind_panel_set",
           "mesh_magi_kind_panel_list",
           "mesh_node_slots_set",
-          "mesh_node_slots_list"
+          "mesh_node_slots_list",
+          "mesh_node_slots_propose"
         ];
         CANONICAL_MESH_TOOL_COUNT = CANONICAL_MESH_TOOL_NAMES.length;
         STATUS_PROBE_ARG_KEY = "_statusProbe";
@@ -37438,26 +37607,48 @@ Next step: ${nextStep}`;
     function getLogLevel() {
       return currentLevel;
     }
+    function resolveLogDir() {
+      const override = process.env.ADHDEV_CONFIG_DIR;
+      const home = override && override.trim() ? override.trim() : path9.join(os42.homedir(), ".adhdev");
+      return path9.join(home, "logs");
+    }
+    function ensureLogDir(dir) {
+      try {
+        fs32.mkdirSync(dir, { recursive: true });
+      } catch {
+      }
+    }
     function getDateStr() {
       return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     }
     function getDaemonLogDir() {
-      return LOG_DIR;
+      const dir = resolveLogDir();
+      prepareLogDirOnce(dir);
+      return dir;
     }
     function getCurrentDaemonLogPath(date5 = /* @__PURE__ */ new Date()) {
-      return path9.join(LOG_DIR, `daemon-${date5.toISOString().slice(0, 10)}.log`);
+      return path9.join(getDaemonLogDir(), `daemon-${date5.toISOString().slice(0, 10)}.log`);
     }
-    function checkDateRotation() {
+    function refreshCurrentLogFile() {
       const today = getDateStr();
-      if (today !== currentDate) {
-        currentDate = today;
-        currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
-        cleanOldLogs();
-      }
+      const dir = resolveLogDir();
+      const dateChanged = today !== currentDate;
+      const dirChanged = dir !== currentLogDir;
+      if (!dateChanged && !dirChanged) return false;
+      currentDate = today;
+      currentLogDir = dir;
+      currentLogDirEnv = process.env.ADHDEV_CONFIG_DIR;
+      currentLogFile = path9.join(dir, `daemon-${today}.log`);
+      if (dirChanged) prepareLogDirOnce(dir);
+      else if (dateChanged) cleanOldLogs(dir);
+      return true;
     }
-    function cleanOldLogs() {
+    function checkDateRotation() {
+      refreshCurrentLogFile();
+    }
+    function cleanOldLogs(logDir) {
       try {
-        const files = fs32.readdirSync(LOG_DIR).filter((f) => f.startsWith("daemon-") && f.endsWith(".log"));
+        const files = fs32.readdirSync(logDir).filter((f) => f.startsWith("daemon-") && f.endsWith(".log"));
         const cutoff = /* @__PURE__ */ new Date();
         cutoff.setDate(cutoff.getDate() - MAX_LOG_DAYS);
         const cutoffStr = cutoff.toISOString().slice(0, 10);
@@ -37465,7 +37656,7 @@ Next step: ${nextStep}`;
           const dateMatch = file2.match(/daemon-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs32.unlinkSync(path9.join(LOG_DIR, file2));
+              fs32.unlinkSync(path9.join(logDir, file2));
             } catch {
             }
           }
@@ -37502,12 +37693,35 @@ Next step: ${nextStep}`;
       } catch {
       }
     }
+    function prepareLogDirOnce(dir) {
+      if (preparedLogDirs.has(dir)) return;
+      preparedLogDirs.add(dir);
+      ensureLogDir(dir);
+      cleanOldLogs(dir);
+      try {
+        const oldLog = path9.join(dir, "daemon.log");
+        if (fs32.existsSync(oldLog)) {
+          const stat2 = fs32.statSync(oldLog);
+          const oldDate = stat2.mtime.toISOString().slice(0, 10);
+          fs32.renameSync(oldLog, path9.join(dir, `daemon-${oldDate}.log`));
+        }
+        const oldLogBackup = path9.join(dir, "daemon.log.old");
+        if (fs32.existsSync(oldLogBackup)) {
+          fs32.unlinkSync(oldLogBackup);
+        }
+      } catch {
+      }
+    }
     function writeToFile(line) {
       try {
         if (++writeCount % 1e3 === 0) {
           checkDateRotation();
           rotateSizeIfNeeded();
+        } else if (process.env.ADHDEV_CONFIG_DIR !== currentLogDirEnv) {
+          currentLogDirEnv = process.env.ADHDEV_CONFIG_DIR;
+          refreshCurrentLogFile();
         }
+        prepareLogDirOnce(currentLogDir);
         AsyncBatchWriter.write(currentLogFile, line + "\n");
       } catch {
       }
@@ -37602,14 +37816,15 @@ Next step: ${nextStep}`;
     var LEVEL_NUM;
     var LEVEL_LABEL;
     var currentLevel;
-    var ADHDEV_HOME;
-    var LOG_DIR;
     var MAX_LOG_SIZE;
     var MAX_LOG_DAYS;
     var MAX_SIZE_ROTATION_GENERATIONS;
     var currentDate;
+    var currentLogDir;
     var currentLogFile;
+    var preparedLogDirs;
     var writeCount;
+    var currentLogDirEnv;
     var RING_BUFFER_SIZE;
     var ringBuffer;
     var origConsoleLog;
@@ -37617,7 +37832,6 @@ Next step: ${nextStep}`;
     var origConsoleWarn;
     var LOG2;
     var interceptorInstalled;
-    var LOG_PATH;
     var init_logger = __esm2({
       "src/logging/logger.ts"() {
         "use strict";
@@ -37628,32 +37842,15 @@ Next step: ${nextStep}`;
         LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
         LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
         currentLevel = "info";
-        ADHDEV_HOME = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim() ? process.env.ADHDEV_CONFIG_DIR.trim() : path9.join(os42.homedir(), ".adhdev");
-        LOG_DIR = path9.join(ADHDEV_HOME, "logs");
         MAX_LOG_SIZE = 5 * 1024 * 1024;
         MAX_LOG_DAYS = 7;
         MAX_SIZE_ROTATION_GENERATIONS = 3;
-        try {
-          fs32.mkdirSync(LOG_DIR, { recursive: true });
-        } catch {
-        }
         currentDate = getDateStr();
-        currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
-        cleanOldLogs();
-        try {
-          const oldLog = path9.join(LOG_DIR, "daemon.log");
-          if (fs32.existsSync(oldLog)) {
-            const stat2 = fs32.statSync(oldLog);
-            const oldDate = stat2.mtime.toISOString().slice(0, 10);
-            fs32.renameSync(oldLog, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
-          }
-          const oldLogBackup = path9.join(LOG_DIR, "daemon.log.old");
-          if (fs32.existsSync(oldLogBackup)) {
-            fs32.unlinkSync(oldLogBackup);
-          }
-        } catch {
-        }
+        currentLogDir = resolveLogDir();
+        currentLogFile = path9.join(currentLogDir, `daemon-${currentDate}.log`);
+        preparedLogDirs = /* @__PURE__ */ new Set();
         writeCount = 0;
+        currentLogDirEnv = process.env.ADHDEV_CONFIG_DIR;
         RING_BUFFER_SIZE = 200;
         ringBuffer = [];
         origConsoleLog = console.log.bind(console);
@@ -37679,7 +37876,6 @@ Next step: ${nextStep}`;
           }
         };
         interceptorInstalled = false;
-        LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
       }
     });
     function loadBetterSqlite3() {
@@ -45689,6 +45885,7 @@ ${rules.join("\n")}`;
 - **Worktree affinity.** A worktree is a durable per-branch workspace; keep all of a branch's code_change/fix/review work on its worktree node by targeting \`required_tags: ["worktree=<branch>"]\` or \`target_node_id\`. Get the id/branch from the \`mesh_clone_node\` result or a live \`mesh_status\` \u2014 the Configured Nodes snapshot won't list a worktree cloned after launch. Untargeted same-branch follow-ups drift to the base node. Only \`convergence\` (merge/push) runs on the base, never pinned to the worktree.
 - **Classify task difficulty to save tokens.** For each task you enqueue, judge its execution difficulty and pass \`difficulty\`: \`easy\` (extraction, renames, doc tweaks, trivial fixes), \`medium\` (ordinary feature/bugfix work), \`difficult\` (architecture, tricky debugging, multi-file refactors, subtle reasoning), or \`freeform\`. The mesh's per-difficulty brain preset then runs easy tasks on a cheaper model at low reasoning effort and hard tasks on a stronger model at high effort \u2014 real token savings on simple work. The current presets are shown in the "Brain presets" section below. You may still pass an explicit \`model\`/\`thinkingLevel\` to override the preset for one task.
 - **Retune node profiles when routing is a poor fit \u2014 but only with approval.** A node's capability slots (its provider/model/thinking + difficulty range + capability tags, seen via \`mesh_node_slots_list\`) are what task\u2192node fitness routing matches against. If you notice a persistent mismatch \u2014 e.g. every \`difficult\` task lands on a node whose only slot is a cheap model, or a capability a node clearly has isn't declared \u2014 you MAY propose a slot change with \`mesh_node_slots_set\` (write=false). That returns current-vs-proposed; present that diff to the user with a one-line reason and apply (write=true) ONLY after they approve. It is a WHOLESALE replacement of the node's slots, so include the slots you want to keep. Never rewrite a node's profile silently or without a clear routing reason.
+- **Bootstrap a node's slots from what's actually installed.** When a node has NO slots configured (routing then falls back to "first available provider"), or CLI agents were newly installed on it, call \`mesh_node_slots_propose({ node_id })\` instead of hand-writing a profile. It detects the node's installed CLI agents and drafts a slot list from them \u2014 read-only, it never writes. Present its \`proposedSlots\` with the \`droppedSlots\` / \`destructive\` fields it reports (a wholesale write would delete any existing hand-tuned slot the draft doesn't reproduce, including providers not currently on PATH), then apply with \`mesh_node_slots_set({ slots: proposedSlots, write: true })\` after approval. It flags \`unknownProvider\` / \`provisional\` slots whose placement is a conservative guess rather than an attested one \u2014 call those out rather than presenting them as settled.
 - **Respect explicit provider requests.** Map: Hermes \u2192 \`hermes-cli\`, Claude/Claude Code \u2192 \`claude-cli\`, Codex \u2192 \`codex-cli\`, Gemini \u2192 \`gemini-cli\`, Antigravity \u2192 \`antigravity-cli\`. Never substitute the coordinator's own runtime.
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
 - **Limit parallelism.** Start with 1\u20132 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. This caps *concurrent* load \u2014 it does not mean serialize independent work: when a new, independent request arrives and there is headroom under \`maxParallelTasks\`, dispatch it right away rather than waiting for an in-flight task or a user nudge (read-only diagnosis especially, since it has no merge cost).
@@ -45707,10 +45904,8 @@ ${rules.join("\n")}`;
 
 ### Task Messaging Requirements
 
-When you compose the task message you dispatch to a node, include these requirements so the worker follows repo conventions the daemon can't enforce for it:
+When you compose the task message you dispatch to a node, include this requirement so the worker's completion report is verifiable:
 
-- **OSS English commits.** If a task commits anything under \`oss/\` (an AGPL public repo whose history external contributors read), tell the worker explicitly that commit messages in \`oss/\` MUST be English. Root-level commits (proprietary packages) may use any language.
-- **Scoped test runs.** For a validation or code-change task, instruct the worker to run only the tests covering the changed files (\`vitest run <path>\` or \`-t <name>\`), not the whole suite. Run the full suite only when the task is explicitly a full-suite gate \u2014 a broad daemon-core run is minutes of wall-clock and the biggest source of worker slowness.
 - **Branch convergence state.** For a worktree task, require the completion report to classify the touched branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. A task that ends on a non-main branch is not complete unless the report names that state and the next step.`;
     }
     var fs42;
@@ -45792,7 +45987,8 @@ When you compose the task message you dispatch to a node, include these requirem
 | \`mesh_magi_kind_panel_set\` | Bind a task_kind \u2192 MAGI kind-panel slots (the SOLE MAGI panel-resolution surface; machine-local, wholesale replacement \u2014 approve current-vs-new first) |
 | \`mesh_magi_kind_panel_list\` | List configured task_kind \u2192 MAGI kind-panel slot bindings (machine-local, read-only) |
 | \`mesh_node_slots_list\` | List a node's capability slots (its AI-tool profile: provider/model/thinking + difficulty range + capability tags), read-only |
-| \`mesh_node_slots_set\` | PROPOSE (dry-run) or APPLY a node's capability slots \u2014 how you autonomously retune a node's tool profile; WHOLESALE replacement, present current-vs-proposed and get user approval before write=true |`;
+| \`mesh_node_slots_set\` | PROPOSE (dry-run) or APPLY a node's capability slots \u2014 how you autonomously retune a node's tool profile; WHOLESALE replacement, present current-vs-proposed and get user approval before write=true |
+| \`mesh_node_slots_propose\` | AUTO-DETECT a node's installed CLI agents and DRAFT a slot profile from them (read-only, never writes) \u2014 use when a node has no slots yet or new CLIs were installed; reports droppedSlots (what a wholesale write would destroy), then apply via mesh_node_slots_set write=true after approval |`;
         TOOL_EXPOSURE_PREFLIGHT_SECTION = `## Tool Exposure Preflight
 
 Before doing any coordinator work, confirm that the actual callable tool list includes \`mesh_status\` and the other \`mesh_*\` tools from the table above. If this Repo Mesh coordinator prompt is present but the callable \`mesh_*\` tools are missing, the MCP server/tool manifest is stale or not injected yet. Do not substitute terminal/file/git tools, do not inspect or edit the repository directly, and do not continue as a non-mesh local coding agent. Stop immediately and tell the user to run \`/reload-mcp\` or start a fresh coordinator session so ADHDev can reconnect \`adhdev-mesh\`.`;
@@ -51552,10 +51748,15 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     }
     function findRecentTerminalLedgerEvidence(args) {
       if (!args.sessionId && !args.nodeId) return null;
+      const notBefore = typeof args.notBeforeMs === "number" && Number.isFinite(args.notBeforeMs) ? args.notBeforeMs : null;
       const entries = readLedgerEntries(args.meshId, { tail: 200 });
       for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
         if (entry.kind !== "task_completed" && entry.kind !== "task_failed" && entry.kind !== "task_stalled") continue;
+        if (notBefore !== null) {
+          const entryTime = new Date(entry.timestamp).getTime();
+          if (!Number.isFinite(entryTime) || entryTime < notBefore) continue;
+        }
         if (args.sessionId && sessionIdsEquivalent(entry.sessionId, args.sessionId)) {
           return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
         }
@@ -51819,19 +52020,44 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           }
         };
       }
-      const terminal = findRecentTerminalLedgerEvidence({
+      const taskId = readNonEmptyString(args.metadataEvent.taskId);
+      const terminal = taskId ? findTerminalLedgerEvidenceForTask({
         meshId: args.meshId,
+        taskId,
         sessionId: sessionId || void 0,
         nodeId: nodeId || void 0
-      });
+      }) : (() => {
+        const notBeforeMs = resolveNoProgressEvidenceFloor(args.metadataEvent);
+        if (notBeforeMs === null) return null;
+        return findRecentTerminalLedgerEvidence({
+          meshId: args.meshId,
+          sessionId: sessionId || void 0,
+          nodeId: nodeId || void 0,
+          notBeforeMs
+        });
+      })();
       if (!terminal) return null;
       return {
         ...args.metadataEvent,
         source: "no_progress_terminal_ledger_suppression",
         terminalLedgerKind: terminal.kind,
-        terminalLedgerAt: terminal.timestamp
+        terminalLedgerAt: terminal.timestamp,
+        terminalLedgerScope: taskId ? "task" : "session_recency_bounded"
       };
     }
+    function resolveNoProgressEvidenceFloor(metadataEvent) {
+      const lastOutputAt = readFiniteNumber(metadataEvent.lastOutputAt);
+      if (lastOutputAt !== null && lastOutputAt > 0) return lastOutputAt;
+      const stalledMs = readFiniteNumber(metadataEvent.stalledMs);
+      const timestamp2 = readFiniteNumber(metadataEvent.timestamp);
+      if (stalledMs !== null && stalledMs >= 0 && timestamp2 !== null && timestamp2 > 0) {
+        return timestamp2 - stalledMs;
+      }
+      return null;
+    }
+    function readFiniteNumber(value) {
+      return typeof value === "number" && Number.isFinite(value) ? value : null;
+    }
     var DIRECT_DISPATCH_RECONCILE_GRACE_MS;
     var DIRECT_DISPATCH_IDLE_SESSION_RECONCILE_GRACE_MS;
     var init_mesh_events_stale = __esm2({
@@ -58161,7 +58387,7 @@ ${cleanBody}`;
     function readRecord6(value) {
       return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
     }
-    function readFiniteNumber(value) {
+    function readFiniteNumber2(value) {
       return typeof value === "number" && Number.isFinite(value) ? value : void 0;
     }
     function identitiesMatch(metadataEvent, evidence, attempt, eventSessionId) {
@@ -58170,8 +58396,8 @@ ${cleanBody}`;
       const evidenceTaskId = readNonEmptyString(evidence.taskId);
       const evidenceAttemptId = readNonEmptyString(evidence.attemptId);
       const evidenceSessionId = readNonEmptyString(evidence.sessionId);
-      const eventNonce = readFiniteNumber(metadataEvent.dispatchNonce);
-      const evidenceNonce = readFiniteNumber(evidence.dispatchNonce);
+      const eventNonce = readFiniteNumber2(metadataEvent.dispatchNonce);
+      const evidenceNonce = readFiniteNumber2(evidence.dispatchNonce);
       if (!taskId || !attemptId || !eventSessionId) return false;
       if (taskId !== attempt.taskId || attemptId !== attempt.attemptId) return false;
       if (evidenceTaskId !== taskId || evidenceAttemptId !== attemptId) return false;
@@ -58207,16 +58433,16 @@ ${cleanBody}`;
         return { authoritative: false, reason: "evidence_source_profile_mismatch" };
       }
       const finalSummary = readNonEmptyString(metadataEvent.finalSummary);
-      const finalContentLength = readFiniteNumber(evidence.finalContentLength) ?? 0;
+      const finalContentLength = readFiniteNumber2(evidence.finalContentLength) ?? 0;
       if (!finalSummary || finalContentLength <= 0) {
         return { authoritative: false, reason: "empty_final_content" };
       }
       if (!identitiesMatch(metadataEvent, evidence, attempt, eventSessionId)) {
         return { authoritative: false, reason: "causal_identity_mismatch" };
       }
-      const observedAt = readFiniteNumber(evidence.observedAt);
-      const eventTimestamp = readFiniteNumber(metadataEvent.timestamp);
-      const turnStartedAt = readFiniteNumber(evidence.turnStartedAt);
+      const observedAt = readFiniteNumber2(evidence.observedAt);
+      const eventTimestamp = readFiniteNumber2(metadataEvent.timestamp);
+      const turnStartedAt = readFiniteNumber2(evidence.turnStartedAt);
       const acceptedAt = Date.parse(attempt.acceptedAt || attempt.createdAt);
       if (!observedAt || !eventTimestamp || !turnStartedAt) {
         return { authoritative: false, reason: "missing_evidence_timestamp" };
@@ -58258,11 +58484,11 @@ ${cleanBody}`;
       if (!attempt || attempt.terminalOutcome || isTerminalTurnStage(attempt.stage)) return false;
       const taskId = readNonEmptyString(metadataEvent.taskId);
       const attemptId = readNonEmptyString(metadataEvent.attemptId);
-      const nonce = readFiniteNumber(metadataEvent.dispatchNonce);
+      const nonce = readFiniteNumber2(metadataEvent.dispatchNonce);
       if (!taskId || taskId !== attempt.taskId || attemptId !== attempt.attemptId) return false;
       if (!attempt.sessionId || !sessionIdsEquivalent(attempt.sessionId, eventSessionId)) return false;
       if (typeof attempt.dispatchNonce !== "number" || nonce !== attempt.dispatchNonce) return false;
-      const eventTimestamp = readFiniteNumber(metadataEvent.timestamp);
+      const eventTimestamp = readFiniteNumber2(metadataEvent.timestamp);
       const acceptedAt = Date.parse(attempt.acceptedAt || attempt.createdAt);
       if (!eventTimestamp || eventTimestamp > nowMs + 2e3 || nowMs - eventTimestamp > AUTHORITATIVE_COMPLETION_MAX_AGE_MS) return false;
       if (Number.isFinite(acceptedAt) && eventTimestamp < acceptedAt - 2e3) return false;
@@ -71432,6 +71658,7 @@ ${lastSnapshot}`;
       DEFAULT_ACTIVE_CHAT_POLL_STATUSES: () => DEFAULT_ACTIVE_CHAT_POLL_STATUSES,
       DEFAULT_CDP_DISCOVERY_INTERVAL_MS: () => DEFAULT_CDP_DISCOVERY_INTERVAL_MS,
       DEFAULT_CDP_SCAN_INTERVAL_MS: () => DEFAULT_CDP_SCAN_INTERVAL_MS,
+      DEFAULT_CHAT_TAIL_MISSING_SESSION_POLICY: () => DEFAULT_CHAT_TAIL_MISSING_SESSION_POLICY,
       DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS: () => DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS2,
       DEFAULT_DAEMON_PORT: () => DEFAULT_DAEMON_PORT2,
       DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS: () => DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS,
@@ -71598,6 +71825,7 @@ ${lastSnapshot}`;
       createSessionDelivery: () => createSessionDelivery,
       createWorktree: () => createWorktree,
       daemonIdsEquivalent: () => daemonIdsEquivalent,
+      decideMissingSessionAttempt: () => decideMissingSessionAttempt2,
       delegatedWorkerAutoApproveSettings: () => delegatedWorkerAutoApproveSettings,
       deleteDirectDispatchesByTaskId: () => deleteDirectDispatchesByTaskId,
       deleteMesh: () => deleteMesh,
@@ -71695,6 +71923,7 @@ ${lastSnapshot}`;
       isManagedStatusWorking: () => isManagedStatusWorking,
       isMeshHostOwner: () => isMeshHostOwner,
       isMeshNodeHealthLaunchable: () => isMeshNodeHealthLaunchable,
+      isMissingLiveSessionResult: () => isMissingLiveSessionResult2,
       isOperatingNoteTombstoned: () => isOperatingNoteTombstoned,
       isP2pRelayTransportFailure: () => isP2pRelayTransportFailure,
       isPathInside: () => isPathInside,
@@ -71797,6 +72026,7 @@ ${lastSnapshot}`;
       recordDebugTrace: () => recordDebugTrace,
       recordDirectDispatchTask: () => recordDirectDispatchTask,
       recordMeshToolCall: () => recordMeshToolCall,
+      recordMissingSessionAttempt: () => recordMissingSessionAttempt2,
       registerExtensionProviders: () => registerExtensionProviders,
       registerMeshCoordinator: () => registerMeshCoordinator,
       removeMagiKindPanel: () => removeMagiKindPanel,
@@ -71811,6 +72041,7 @@ ${lastSnapshot}`;
       resetState: () => resetState,
       resolveAllowSendKeysDestructive: () => resolveAllowSendKeysDestructive,
       resolveAutoConvergeCodeChange: () => resolveAutoConvergeCodeChange,
+      resolveBackoffMs: () => resolveBackoffMs,
       resolveChatMessageKind: () => resolveChatMessageKind,
       resolveConvergeRequiredTags: () => resolveConvergeRequiredTags,
       resolveCurrentGlobalInstallSurface: () => resolveCurrentGlobalInstallSurface,
@@ -71856,6 +72087,7 @@ ${lastSnapshot}`;
       shouldAutoRestoreHostedSessionsOnStartup: () => shouldAutoRestoreHostedSessionsOnStartup2,
       shouldCollectTraceCategory: () => shouldCollectTraceCategory,
       shouldFireIdleReminder: () => shouldFireIdleReminder,
+      shouldWarnForMissingSession: () => shouldWarnForMissingSession2,
       shutdownDaemonComponents: () => shutdownDaemonComponents2,
       spawnDetachedDaemonUpgradeHelper: () => spawnDetachedDaemonUpgradeHelper,
       startDaemonDevSupport: () => startDaemonDevSupport2,
@@ -73532,6 +73764,12 @@ ${lastSnapshot}`;
         ambiguous: identities.length > 1 || !!remotes.find((remote) => remote.identities.length > 1)
       };
     }
+    async function deriveLocalRepoIdentity(repoRoot) {
+      const raw = await git(repoRoot, ["rev-list", "--max-parents=0", "HEAD"], true);
+      const roots = raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^[0-9a-f]{40}$/i.test(line)).sort();
+      const root = roots[0];
+      return root ? `local/${root.toLowerCase()}` : "";
+    }
     async function resolveDefaultBranch(repoRoot, remoteName, currentBranch) {
       const symbolic = await git(repoRoot, ["symbolic-ref", "--quiet", "--short", `refs/remotes/${remoteName}/HEAD`], true);
       if (symbolic.startsWith(`${remoteName}/`)) return symbolic.slice(remoteName.length + 1);
@@ -73619,12 +73857,34 @@ ${lastSnapshot}`;
         );
       }
       const remoteDiscovery = await discoverRemotes(repoRoot, currentBranch);
-      if (!remoteDiscovery.remotes.length || !remoteDiscovery.selectedRemote) {
+      if (!remoteDiscovery.remotes.length) {
+        const localIdentity = await deriveLocalRepoIdentity(repoRoot);
+        if (!localIdentity) {
+          return failure2(
+            "no_commits_for_local_identity",
+            "This repository has no remote and no commits, so a stable repository identity cannot be derived.",
+            "Create at least one commit (the root commit becomes the local identity), or pass an explicit repo identity when creating the mesh.",
+            { discovery: partial2 }
+          );
+        }
+        const localDefaultBranch = await resolveDefaultBranch(repoRoot, "", currentBranch);
+        return {
+          ...partial2,
+          remotes: [],
+          origin: void 0,
+          upstream: void 0,
+          selectedRemote: "",
+          repoIdentity: localIdentity,
+          defaultBranch: localDefaultBranch
+        };
+      }
+      if (!remoteDiscovery.selectedRemote) {
+        const detail = remoteDiscovery.remotes.map((remote) => remote.name).join(", ");
         return failure2(
-          "remote_not_found",
-          "No Git remote is configured, so a stable repository identity cannot be inferred.",
-          "Add a canonical remote (normally origin), or keep using the explicit mesh_create API with a reviewed repo identity.",
-          { discovery: partial2 }
+          "remote_not_selected",
+          `No canonical remote could be selected among multiple remotes (${detail}).`,
+          "Name one of them origin or upstream, set the current branch to track one of them, or pass an explicit repo identity when creating the mesh.",
+          { discovery: { ...partial2, remotes: remoteDiscovery.remotes, origin: remoteDiscovery.origin, upstream: remoteDiscovery.upstream } }
         );
       }
       if (remoteDiscovery.ambiguous) {
@@ -83789,8 +84049,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           if (sinceTs > 0) {
             return { success: true, logs: [], totalBuffered: 0 };
           }
-          if (fs14.existsSync(LOG_PATH)) {
-            const content = fs14.readFileSync(LOG_PATH, "utf-8");
+          const logPath = getCurrentDaemonLogPath();
+          if (fs14.existsSync(logPath)) {
+            const content = fs14.readFileSync(logPath, "utf-8");
             const allLines = content.split("\n");
             const recent = allLines.slice(-count).join("\n");
             return { success: true, logs: recent, totalLines: allLines.length };
@@ -84099,11 +84360,17 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     var http2 = __toESM2(require("http"));
     var path21 = __toESM2(require("path"));
     var import_child_process6 = require("child_process");
+    init_logger();
+    function errorText(error48) {
+      return error48 instanceof Error ? error48.message : String(error48);
+    }
+    var warnedCommandLineFailures = /* @__PURE__ */ new Set();
     function defaultExecFileSync() {
       return import_child_process6.execFileSync;
     }
     function getWindowsProcessCommandLine(pid, exec7) {
       const pidFilter = `ProcessId=${pid}`;
+      const failures = [];
       try {
         const psOut = exec7("powershell.exe", [
           "-NoProfile",
@@ -84115,7 +84382,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         ], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
         const text = String(psOut).trim();
         if (text) return text;
-      } catch {
+        failures.push("powershell Get-CimInstance returned no CommandLine");
+      } catch (error48) {
+        failures.push(`powershell Get-CimInstance failed: ${errorText(error48)}`);
       }
       try {
         const wmicOut = exec7("wmic", [
@@ -84127,7 +84396,19 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         ], { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
         const text = String(wmicOut).trim();
         if (text) return text;
-      } catch {
+        failures.push("wmic returned no CommandLine");
+      } catch (error48) {
+        failures.push(`wmic failed: ${errorText(error48)}`);
+      }
+      const signature = failures.join("; ");
+      if (!warnedCommandLineFailures.has(signature)) {
+        warnedCommandLineFailures.add(signature);
+        LOG2.warn(
+          "ProcessLifecycle",
+          `Could not read a process command line (pid ${pid}): ${signature}. Process-identity checks that depend on it will fail safe. This is logged once per distinct cause.`
+        );
+      } else {
+        LOG2.debug("ProcessLifecycle", `Could not read the command line of pid ${pid}: ${signature}`);
       }
       return null;
     }
@@ -84145,7 +84426,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           stdio: ["ignore", "pipe", "ignore"]
         })).trim();
         return text || null;
-      } catch {
+      } catch (error48) {
+        LOG2.debug("ProcessLifecycle", `ps lookup failed for pid ${pid}: ${errorText(error48)}`);
         return null;
       }
     }
@@ -84370,7 +84652,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     function packageRootForPrefix(prefix, packageName) {
       return path21.join(prefix, "node_modules", ...packageName.split("/"));
     }
-    var CONPTY_PREBUILD_RELATIVE_PATH = path21.join(
+    var CONPTY_PREBUILD_NESTED_RELATIVE_PATH = path21.join(
       "node_modules",
       "adhdev",
       "node_modules",
@@ -84379,16 +84661,28 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       "win32-x64",
       "conpty.node"
     );
-    function resolveStagedConptyPrebuildPath(stagedPrefix) {
-      return path21.join(stagedPrefix, CONPTY_PREBUILD_RELATIVE_PATH);
+    var CONPTY_PREBUILD_HOISTED_RELATIVE_PATH = path21.join(
+      "node_modules",
+      "node-pty",
+      "prebuilds",
+      "win32-x64",
+      "conpty.node"
+    );
+    function resolveConptyPrebuildCandidates(prefix) {
+      return [
+        path21.join(prefix, CONPTY_PREBUILD_NESTED_RELATIVE_PATH),
+        path21.join(prefix, CONPTY_PREBUILD_HOISTED_RELATIVE_PATH)
+      ];
     }
-    function verifyStagedConptyPrebuild(stagedPrefix) {
-      const conptyPath = resolveStagedConptyPrebuildPath(stagedPrefix);
-      if (!fs15.existsSync(conptyPath)) {
+    function verifyStagedConptyPrebuild(stagedPrefix, log) {
+      const candidates = resolveConptyPrebuildCandidates(stagedPrefix);
+      const found = candidates.find((candidate) => fs15.existsSync(candidate));
+      if (!found) {
         throw new Error(
-          `Staged install is missing required native addon: ${conptyPath}. Aborting activation to prevent a daemon boot crash.`
+          `Staged install is missing required native addon: node-pty's conpty.node prebuild (checked: ${candidates.join(", ")}). Aborting activation to prevent a daemon boot crash.`
         );
       }
+      log?.(`conpty prebuild verified at ${found}`);
     }
     function readPackageCliEntry(prefix, packageName, targetVersion) {
       const packageRoot = packageRootForPrefix(prefix, packageName);
@@ -84544,6 +84838,29 @@ exec "${portableNode}" "${cliEntry}" "$@"
       }
       atomicWrite(layout.pointerPath, versionName, "ascii");
     }
+    function removeFailedStagedPrefix(stagedPrefix, layout, log) {
+      try {
+        const staged = normalizeForCompare(stagedPrefix);
+        const protectedPrefixes = [layout.activePrefix, layout.stablePrefix, layout.installRoot];
+        if (protectedPrefixes.some((candidate) => normalizeForCompare(candidate) === staged)) {
+          log(`Refusing to clean up ${stagedPrefix}: it is the active/stable install, not a staged prefix`);
+          return;
+        }
+        if (normalizeForCompare(path21.dirname(stagedPrefix)) !== normalizeForCompare(layout.installRoot) || !path21.basename(stagedPrefix).startsWith("version-")) {
+          log(`Refusing to clean up ${stagedPrefix}: not a version-* prefix under ${layout.installRoot}`);
+          return;
+        }
+        if (!fs15.existsSync(stagedPrefix)) return;
+        removeInactivePrefix(stagedPrefix, log);
+        if (fs15.existsSync(stagedPrefix)) {
+          log(`Failed staged prefix ${stagedPrefix} could not be fully removed; a future update will retry`);
+        } else {
+          log(`Cleaned up failed staged prefix ${stagedPrefix}`);
+        }
+      } catch (error48) {
+        log(`Failed staged-prefix cleanup errored for ${stagedPrefix}: ${error48?.message || String(error48)}`);
+      }
+    }
     async function performWindowsAtomicUpgrade(options) {
       const { layout, packageName, targetVersion, portableNode, hooks } = options;
       const versionName = `version-${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}`;
@@ -84555,7 +84872,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
       try {
         hooks.log(`Installing ${packageName}@${targetVersion} into inactive prefix ${stagedPrefix}`);
         await hooks.install(stagedPrefix, portableNode);
-        verifyStagedConptyPrebuild(stagedPrefix);
+        verifyStagedConptyPrebuild(stagedPrefix, hooks.log);
         const stagedCliEntry = readPackageCliEntry(stagedPrefix, packageName, targetVersion);
         pinStagedShims(stagedPrefix, portableNode, stagedCliEntry);
         validateStagedCli(portableNode, stagedCliEntry, targetVersion);
@@ -84599,6 +84916,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
         } catch {
           hooks.log("Failed to restart the previous daemon during rollback");
         }
+        removeFailedStagedPrefix(stagedPrefix, layout, hooks.log);
         try {
           await hooks.cleanup(layout, layout.activePrefix);
         } catch {
@@ -84882,6 +85200,8 @@ exec "${portableNode}" "${cliEntry}" "$@"
       const current = env2[pathKey] || "";
       env2[pathKey] = current ? `${nodeBinDir};${current}` : nodeBinDir;
       env2.ADHDEV_BOOTSTRAP = "1";
+      env2.npm_config_build_from_source = "false";
+      env2["npm_config_build-from-source"] = "false";
       return env2;
     }
     function getNpmExecOptions(platform10 = process.platform) {
@@ -85233,6 +85553,21 @@ ${body}
       if (installOutput.trim()) {
         appendUpgradeLog(installOutput.trim());
       }
+      if (process.platform === "win32" && installCommand.surface.installPrefix) {
+        try {
+          verifyStagedConptyPrebuild(installCommand.surface.installPrefix, appendUpgradeLog);
+        } catch (error48) {
+          appendUpgradeLog(`Post-install conpty verification failed: ${error48?.message || String(error48)}`);
+          emitUpgradeFailureNotice([
+            `adhdev ${spec} installed but is missing node-pty's native addon (conpty.node).`,
+            'Starting it would break every session with "Failed to load native module: conpty.node",',
+            "so the running daemon was left on its previous version and was NOT restarted.",
+            "To recover, reinstall (this forces the shipped prebuild instead of a source rebuild):",
+            `  ${buildManualRecoveryCommand(installCommand)}`
+          ]);
+          throw error48;
+        }
+      }
       if (process.platform === "win32") {
         await new Promise((resolve29) => setTimeout(resolve29, 500));
         cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
@@ -86321,6 +86656,7 @@ ${body}
       return n;
     }
     var SUBMIT_DELAY_FLOOR_MS = 200;
+    var fsmDriverSeq = 0;
     var WIN32_SUBMIT_RESEND_GAP_MS = 350;
     var WIN32_SUBMIT_MAX_RESENDS = 14;
     var WIN32_SUBMIT_SETTLE_MS = 500;
@@ -86353,6 +86689,8 @@ ${body}
     var FsmDriver = class {
       constructor(opts) {
         this.opts = opts;
+        const sessionId = typeof opts.sessionId === "string" ? opts.sessionId.trim() : "";
+        this.sessionTag = sessionId ? sessionId.slice(0, 8) : `d${++fsmDriverSeq}`;
         this.loadSpecOrThrow();
         this.adapter = new TerminalAdapter(
           this.buildAdapterOpts(),
@@ -86442,6 +86780,8 @@ ${body}
        *  the shadow verdict currently disagrees with the real one), so the
        *  shadow log emits on FLIP only, not every frame. */
       shadowDivergenceLast = /* @__PURE__ */ new Map();
+      /** FSMLOG-SESSION-ATTRIBUTION (D3): session segment of every log line's prefix. */
+      sessionTag;
       subscribe(listener) {
         this.listeners.add(listener);
         return () => {
@@ -87405,8 +87745,16 @@ ${body}
         });
         if (this.stateHistory.length > 50) this.stateHistory.shift();
       }
+      /**
+       * FSMLOG-SESSION-ATTRIBUTION (D3): log prefix identifying BOTH the spec being driven and the
+       * session driving it. Previously spec-only, which made every concurrent session of the same
+       * provider log under an identical tag. The session segment is the owning instance's session id
+       * (short form — the leading 8 chars are what mesh ledger/trace lines carry, so logs grep-join
+       * against them), or a per-driver `d<n>` fallback when no session id was supplied.
+       */
       specTag() {
-        return this.opts.specPath.split("/").slice(-3).join("/");
+        const spec = this.opts.specPath.split(/[/\\]/).slice(-3).join("/");
+        return `${spec}|${this.sessionTag}`;
       }
       emit(ev) {
         for (const l of this.listeners) {
@@ -87583,7 +87931,7 @@ ${body}
        *  cli-state-engine's lastApprovalResolvedAt for the spec-driven adapter path
        *  (claude-cli specs/4.0.json), which previously stubbed the method to false. */
       lastApprovalResolvedAt = 0;
-      constructor(specPath, workingDir, cliArgs, extraEnv, transportFactory) {
+      constructor(specPath, workingDir, cliArgs, extraEnv, transportFactory, sessionId) {
         const raw = JSON.parse(fs222.readFileSync(specPath, "utf8"));
         this.spec = {
           id: raw.id,
@@ -87602,7 +87950,8 @@ ${body}
           hotReload: true,
           emitTrace: false,
           transportFactory,
-          extraCliArgs: cliArgs
+          extraCliArgs: cliArgs,
+          sessionId
         });
         this.driver.subscribe((ev) => this.handleEvent(ev));
       }
@@ -88592,7 +88941,7 @@ ${body}
       }
     };
     init_logger();
-    function createCliAdapter(provider, workingDir, cliArgs, extraEnv, transportFactory) {
+    function createCliAdapter(provider, workingDir, cliArgs, extraEnv, transportFactory, sessionId) {
       const resolvedSpecPath = provider._resolvedSpecPath;
       const dir = provider._resolvedProviderDir;
       let specPath = resolvedSpecPath && fs23.existsSync(resolvedSpecPath) ? resolvedSpecPath : void 0;
@@ -88603,7 +88952,7 @@ ${body}
       if (specPath) {
         try {
           LOG2.info("spec-route", `[${provider.type}] routing through SpecCliAdapter (${path27.relative(dir || "", specPath) || specPath})`);
-          return new SpecCliAdapter(specPath, workingDir, cliArgs, extraEnv, transportFactory);
+          return new SpecCliAdapter(specPath, workingDir, cliArgs, extraEnv, transportFactory, sessionId);
         } catch (err) {
           LOG2.warn("spec-route", `[${provider.type}] spec invalid, falling back to ProviderCliAdapter: ${err.message}`);
         }
@@ -89005,7 +89354,7 @@ ${body}
         this.launchMode = options?.launchMode || "new";
         this.initialThinkingLevel = options?.initialThinkingLevel;
         this.onProviderSessionResolved = options?.onProviderSessionResolved;
-        this.adapter = createCliAdapter(provider, workingDir, cliArgs, options?.extraEnv || {}, transportFactory);
+        this.adapter = createCliAdapter(provider, workingDir, cliArgs, options?.extraEnv || {}, transportFactory, this.instanceId);
         if (this.providerSessionId) {
           this.adapter.updateRuntimeMeta({ providerSessionId: this.providerSessionId });
         }
@@ -99126,19 +99475,37 @@ Run 'adhdev doctor' for detailed diagnostics.`
       * Resolve provider type by alias
       * 'claude' → 'claude-cli', 'codex' → 'codex-cli' etc
       * Returns input as-is if no match found.
+      *
+      * `categories` narrows resolution to the given provider categories. Without it
+      * the resolution order is unchanged (direct type match first, then alias scan)
+      * — every existing caller keeps its exact behaviour.
+      *
+      * The hint exists because provider types and aliases share one namespace across
+      * categories, so a direct match can shadow an alias that a category-scoped
+      * caller actually wants. Concretely: `extension/codex` declares `type: 'codex'`
+      * while `cli/codex-cli` declares `aliases: ['codex']`, so unscoped
+      * `resolveAlias('codex')` returns the IDE-webview provider. `adhdev launch`
+      * only ever starts a cli/acp session, so it passes `['cli', 'acp']` and gets
+      * `codex-cli`. Within a scope the direct-match-first order still holds.
       */
-      resolveAlias(input) {
-        if (this.providers.has(input)) return input;
+      resolveAlias(input, categories) {
+        const inScope = (p) => !!p && (!categories || categories.includes(p.category));
+        const direct = this.providers.get(input);
+        if (inScope(direct)) return input;
         for (const p of this.providers.values()) {
-          if (p.aliases?.includes(input)) return p.type;
+          if (p.aliases?.includes(input) && inScope(p)) return p.type;
         }
         return input;
       }
       /**
       * Get provider with alias resolution (get + alias fallback)
+      * `categories` narrows resolution the same way as `resolveAlias`, and also
+      * filters the returned module so an out-of-scope provider is never handed back.
       */
-      getByAlias(input) {
-        return this.providers.get(this.resolveAlias(input));
+      getByAlias(input, categories) {
+        const resolved = this.providers.get(this.resolveAlias(input, categories));
+        if (resolved && categories && !categories.includes(resolved.category)) return void 0;
+        return resolved;
       }
       /**
       * Build CLI/ACP detection list (replaces cli-detector)
@@ -104744,12 +105111,12 @@ ${ptyResult.output.slice(-2e3)}`);
     var fs37 = __toESM2(require("fs"));
     var path43 = __toESM2(require("path"));
     var os26 = __toESM2(require("os"));
-    var ADHDEV_HOME2 = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim() ? process.env.ADHDEV_CONFIG_DIR.trim() : path43.join(os26.homedir(), ".adhdev");
-    var LOG_DIR2 = path43.join(ADHDEV_HOME2, "logs");
+    var ADHDEV_HOME = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim() ? process.env.ADHDEV_CONFIG_DIR.trim() : path43.join(os26.homedir(), ".adhdev");
+    var LOG_DIR = path43.join(ADHDEV_HOME, "logs");
     var MAX_FILE_SIZE = 5 * 1024 * 1024;
     var MAX_DAYS = 7;
     try {
-      fs37.mkdirSync(LOG_DIR2, { recursive: true });
+      fs37.mkdirSync(LOG_DIR, { recursive: true });
     } catch {
     }
     var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
@@ -104783,19 +105150,19 @@ ${ptyResult.output.slice(-2e3)}`);
       return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     }
     var currentDate2 = getDateStr2();
-    var currentFile = path43.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+    var currentFile = path43.join(LOG_DIR, `commands-${currentDate2}.jsonl`);
     var writeCount2 = 0;
     function checkRotation() {
       const today = getDateStr2();
       if (today !== currentDate2) {
         currentDate2 = today;
-        currentFile = path43.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+        currentFile = path43.join(LOG_DIR, `commands-${currentDate2}.jsonl`);
         cleanOldFiles();
       }
     }
     function cleanOldFiles() {
       try {
-        const files = fs37.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
+        const files = fs37.readdirSync(LOG_DIR).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
         const cutoff = /* @__PURE__ */ new Date();
         cutoff.setDate(cutoff.getDate() - MAX_DAYS);
         const cutoffStr = cutoff.toISOString().slice(0, 10);
@@ -104803,7 +105170,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const dateMatch = file2.match(/commands-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs37.unlinkSync(path43.join(LOG_DIR2, file2));
+              fs37.unlinkSync(path43.join(LOG_DIR, file2));
             } catch {
             }
           }
@@ -110323,6 +110690,53 @@ ${e?.stderr || ""}`;
       });
       await Promise.all(runners);
     }
+    var DEFAULT_CHAT_TAIL_MISSING_SESSION_POLICY = {
+      // 10s of normal-cadence retries: comfortably longer than a session-registry
+      // attach, short enough that a genuinely dead session starts backing off well
+      // before it can produce a meaningful number of warns.
+      graceMs: 1e4,
+      initialBackoffMs: 1e3,
+      // 30s ceiling — matches the idle status heartbeat, so a lingering
+      // subscription costs at most one read per heartbeat instead of ~20/sec.
+      maxBackoffMs: 3e4,
+      // 5 min. Past this the session is not coming back under this subscription;
+      // the dashboard re-subscribes on reopen if it ever does.
+      giveUpAfterMs: 5 * 6e4
+    };
+    function decideMissingSessionAttempt2(state, now, policy = DEFAULT_CHAT_TAIL_MISSING_SESSION_POLICY) {
+      if (!state) return { action: "attempt" };
+      const missingFor = now - state.firstMissingAt;
+      if (missingFor >= policy.giveUpAfterMs) return { action: "drop" };
+      if (missingFor < policy.graceMs) return { action: "attempt" };
+      const sinceLastAttempt = now - state.lastAttemptAt;
+      return sinceLastAttempt >= resolveBackoffMs(state, policy) ? { action: "attempt" } : { action: "skip" };
+    }
+    function resolveBackoffMs(state, policy = DEFAULT_CHAT_TAIL_MISSING_SESSION_POLICY) {
+      const stepsIntoBackoff = Math.max(0, state.consecutiveMisses - 1);
+      const boundedExponent = Math.min(stepsIntoBackoff, 20);
+      const scaled = policy.initialBackoffMs * Math.pow(2, boundedExponent);
+      return Math.min(scaled, policy.maxBackoffMs);
+    }
+    function recordMissingSessionAttempt2(state, now) {
+      if (!state) {
+        return { firstMissingAt: now, lastAttemptAt: now, consecutiveMisses: 1, warned: false };
+      }
+      return {
+        firstMissingAt: state.firstMissingAt,
+        lastAttemptAt: now,
+        consecutiveMisses: state.consecutiveMisses + 1,
+        warned: state.warned
+      };
+    }
+    function shouldWarnForMissingSession2(state) {
+      return !state.warned;
+    }
+    function isMissingLiveSessionResult2(result) {
+      if (!result || typeof result !== "object") return false;
+      const { success: success2, error: error48 } = result;
+      if (success2 !== false || typeof error48 !== "string") return false;
+      return error48.startsWith("Live session not found for targetSessionId:");
+    }
     init_control_effects();
     init_provider_patch_state();
     init_chat_message_normalization();
@@ -117151,6 +117565,7 @@ data: ${JSON.stringify(msg.data)}
       const appName = options.appName;
       const timeoutMs = options.timeoutMs ?? DEFAULT_SESSION_HOST_READY_TIMEOUT_MS2;
       const isManagedPid = options.isManagedPid ?? (() => true);
+      let unverifiedStopPid = null;
       const instance = () => getProcessInstanceContext();
       const getEndpoint = () => (0, import_session_host_core15.getDefaultSessionHostEndpoint)(appName, { ipcKey: instance().ipcKey });
       function buildEnv(baseEnv) {
@@ -117228,8 +117643,25 @@ data: ${JSON.stringify(msg.data)}
         );
         return process.execPath;
       }
+      function verifyConptyPrebuildBeforeSpawn(entry) {
+        if (process.platform !== "win32") return;
+        const normalized = entry.replace(/\\/g, "/");
+        const marker = "/node_modules/adhdev/vendor/session-host-daemon/";
+        const markerIndex = normalized.lastIndexOf(marker);
+        if (markerIndex === -1) return;
+        const activePrefix = entry.slice(0, markerIndex);
+        const candidates = resolveConptyPrebuildCandidates(activePrefix);
+        const found = candidates.find((candidate) => fs47.existsSync(candidate));
+        if (!found) {
+          throw new Error(
+            `conpty.node missing at boot despite passing the install-time gate \u2014 likely deleted post-install (checked: ${candidates.join(", ")}). Every session-host spawn would crash requiring node-pty; refusing to spawn.`
+          );
+        }
+        LOG2.info("SessionHost", `conpty prebuild verified before spawn at ${found}`);
+      }
       function spawnHost() {
         const entry = resolveEntry();
+        verifyConptyPrebuildBeforeSpawn(entry);
         const nodeExecutable = resolveSessionHostNode();
         let stdio = "ignore";
         let logFd = null;
@@ -117282,7 +117714,21 @@ data: ${JSON.stringify(msg.data)}
           if (existingPid !== null) {
             const runningPath = getRunningSessionHostScriptPath(existingPid);
             const currentEntry = resolveEntry();
-            if (runningPath && !pathsEquivalent(runningPath, currentEntry)) {
+            if (runningPath === null) {
+              if (unverifiedStopPid !== existingPid) {
+                unverifiedStopPid = existingPid;
+                LOG2.warn(
+                  "SessionHost",
+                  `Could not read the command line of host pid ${existingPid}; cannot prove it runs from ${currentEntry}. Stopping it once and respawning rather than risking reuse of a stale-prefix host.`
+                );
+                stopManagedSessionHostProcess();
+              } else {
+                LOG2.warn(
+                  "SessionHost",
+                  `Host pid ${existingPid} is still unverifiable; leaving it alone (already restarted once this process) to avoid a kill/respawn loop.`
+                );
+              }
+            } else if (!pathsEquivalent(runningPath, currentEntry)) {
               LOG2.warn(
                 "SessionHost",
                 `Detected stale host pid ${existingPid} running from ${runningPath}; restarting from ${currentEntry}`
@@ -120524,6 +120970,20 @@ var StandaloneServer = class {
       ...request.historySessionId ? { historySessionId: request.historySessionId } : {},
       ...state.cursor.tailLimit > 0 ? { tailLimit: state.cursor.tailLimit } : {}
     });
+    if ((0, import_daemon_core2.isMissingLiveSessionResult)(result)) {
+      const now = Date.now();
+      const missing = (0, import_daemon_core2.recordMissingSessionAttempt)(state.missingSession, now);
+      state.missingSession = missing;
+      const message = `[chat_tail] session ${request.targetSessionId} is not in the live registry`;
+      if ((0, import_daemon_core2.shouldWarnForMissingSession)(missing)) {
+        missing.warned = true;
+        import_daemon_core2.LOG.warn("Standalone", `${message} \u2014 backing off, and dropping the subscription if it stays absent`);
+      } else {
+        import_daemon_core2.LOG.debug("Standalone", `${message} (miss #${missing.consecutiveMisses})`);
+      }
+      return null;
+    }
+    if (state.missingSession) state.missingSession = void 0;
     const prepared = (0, import_daemon_core2.prepareSessionChatTailUpdate)({
       key,
       sessionId: request.targetSessionId,
@@ -120687,6 +121147,7 @@ var StandaloneServer = class {
       const targets = targetWs ? [targetWs] : Array.from(this.clients);
       const hotSessionIds = options.onlyActive ? this.getHotChatSessionIdsForWsFlush() : null;
       const forceSessionIds = options.forceSessionIds ?? null;
+      const now = Date.now();
       const tasks = [];
       for (const ws of targets) {
         if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
@@ -120694,6 +121155,13 @@ var StandaloneServer = class {
         if (!subs || subs.size === 0) continue;
         for (const [key, sub] of subs.entries()) {
           const targetSessionId = sub.request.params.targetSessionId;
+          const decision = (0, import_daemon_core2.decideMissingSessionAttempt)(sub.missingSession, now);
+          if (decision.action === "skip") continue;
+          if (decision.action === "drop") {
+            subs.delete(key);
+            import_daemon_core2.LOG.info("Standalone", `[chat_tail] subscription dropped: session=${targetSessionId} key=${key} \u2014 live session absent for ${Math.round((now - (sub.missingSession?.firstMissingAt ?? now)) / 1e3)}s`);
+            continue;
+          }
           const isForced = forceSessionIds?.has(targetSessionId) === true;
           if (!isForced && hotSessionIds && !hotSessionIds.active.has(targetSessionId) && !hotSessionIds.finalizing.has(targetSessionId)) {
             continue;