mixdog 0.9.92 → 0.9.93

package/src/runtime/agent/orchestrator/tools/shell-state.mjs

@@ -9,7 +9,7 @@
 // Style mirrors shell-snapshot.mjs: files live under getPluginData(), one file
 // per session key, with a stale-file sweep on module init.
 
-import { existsSync, mkdirSync, readFileSync, statSync, utimesSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, utimesSync, writeFileSync } from 'node:fs';
 import { readdir as readdirAsync, stat as statAsync, unlink as unlinkAsync } from 'node:fs/promises';
 import { join } from 'node:path';
 import { createHash } from 'node:crypto';
@@ -30,6 +30,10 @@ function _stateFileFor(sessionKey) {
     return join(_stateDir(), `cwd-${_keyFor(sessionKey)}.txt`);
 }
 
+function _probeFileFor(sessionKey, probeId) {
+    return join(_stateDir(), `cwd-${_keyFor(sessionKey)}.probe-${_keyFor(probeId)}.txt`);
+}
+
 // Stale-file sweep on module init. Mirrors shell-snapshot's _sweepStaleSnapshots:
 // state files older than the cutoff belong to sessions that are long gone.
 const STATE_STALE_MS = 24 * 60 * 60 * 1000;
@@ -80,10 +84,13 @@ export function resolveSessionCwd(sessionKey, explicitCwd, defaultCwd) {
 // OR when there is no nonblank session key — without a real key all callers
 // would collapse onto a single shared `__default__` file and cross-contaminate
 // each other's cwd, so we skip carry-over entirely in that case.
-export function stateFilePath(sessionKey) {
+export function stateFilePath(sessionKey, probeId = null) {
     if (sessionKey == null || String(sessionKey).trim() === '') return null;
     const dir = _stateDir();
     try { mkdirSync(dir, { recursive: true }); } catch { return null; }
+    if (probeId != null && String(probeId).trim() !== '') {
+        return _probeFileFor(sessionKey, probeId);
+    }
     const file = _stateFileFor(sessionKey);
     // Refresh mtime on every write so an old-but-live session file is not
     // reaped by the stale sweep mid-session. `touch`-equivalent: bump atime/
@@ -98,6 +105,29 @@ export function stateFilePath(sessionKey) {
     return file;
 }
 
+// A parallel shell-only batch starts every call from the same cwd snapshot.
+// Each call writes its final cwd to a private probe file; the serial batch
+// result collector commits those probes in model call order, making the final
+// carried cwd deterministic and avoiding concurrent writes to one Windows
+// Out-File target.
+export function commitSessionCwdProbe(sessionKey, probeId) {
+    if (sessionKey == null || String(sessionKey).trim() === '') return false;
+    if (probeId == null || String(probeId).trim() === '') return false;
+    const probe = _probeFileFor(sessionKey, probeId);
+    try {
+        if (!existsSync(probe)) return false;
+        const stored = readFileSync(probe, 'utf-8').trim();
+        if (!stored || !statSync(stored).isDirectory()) return false;
+        mkdirSync(_stateDir(), { recursive: true });
+        writeFileSync(_stateFileFor(sessionKey), `${stored}\n`, 'utf-8');
+        return true;
+    } catch {
+        return false;
+    } finally {
+        try { unlinkSync(probe); } catch {}
+    }
+}
+
 // PowerShell single-quote escape ('' escapes a literal quote inside '...').
 function _psQuote(s) {
     return `'${String(s).replace(/'/g, "''")}'`;

package/src/runtime/channels/backends/discord-gateway.mjs

@@ -86,18 +86,6 @@ function registerEventListeners(self) {
         } catch {}
         return;
       }
-      if (interaction.isChatInputCommand() && interaction.commandName === "stop") {
-        await interaction.reply({ content: "\u23F9 Stopping...", ephemeral: true });
-        if (self.onInteraction) {
-          self.onInteraction({
-            type: "button",
-            customId: "stop_task",
-            userId: interaction.user.id,
-            channelId: interaction.channelId ?? ""
-          });
-        }
-        return;
-      }
       if (interaction.isModalSubmit()) {
         if (self.onInteraction) {
           const fields = {};
@@ -154,31 +142,17 @@ function registerSlashCommands(self) {
     process.stderr.write(`mixdog discord: gateway connected as ${c.user.tag}
 `);
     try {
-      // Plugin registers no global commands; clear the global slot so any
-      // pre-existing entry from prior installs is not surfaced to users.
+      // Mixdog registers NO application commands. Clear the global slot and
+      // every guild's set so entries from prior installs (including the old
+      // /stop) disappear from the Discord UI.
       await c.application?.commands.set([]);
-      process.stderr.write(`mixdog discord: global application commands cleared
-`);
-
-      // Replace each guild's command set with just /stop. set() overwrites,
-      // so the desired set is the only one that survives.
-      const desiredCommands = [
-        { name: "stop", description: "Stop the current Mixdog response" },
-      ];
       for (const [guildId] of c.guilds.cache) {
-        await c.application?.commands.set(desiredCommands, guildId);
-      }
-      // Register /stop globally so it is available in DM bridge contexts
-      // where there is no guild scope.
-      try {
-        await c.application?.commands.set(desiredCommands);
-      } catch (e) {
-        process.stderr.write(`mixdog discord: global /stop register failed: ${e?.message}\n`);
+        await c.application?.commands.set([], guildId);
       }
-      process.stderr.write(`mixdog discord: /stop command registered (${c.guilds.cache.size} guild(s))
+      process.stderr.write(`mixdog discord: application commands cleared (${c.guilds.cache.size} guild(s))
 `);
     } catch (err) {
-      process.stderr.write(`mixdog discord: slash command registration failed: ${err}
+      process.stderr.write(`mixdog discord: slash command cleanup failed: ${err}
 `);
     }
   });

package/src/runtime/channels/lib/inbound-handler.mjs

@@ -58,11 +58,27 @@ const inboundQueue = (() => {
 getBackend().onMessage = (msg) => {
   const receivedAtMs = Number.isFinite(msg.receivedAtMs) ? msg.receivedAtMs : Date.now();
   const onMessageAtMs = Date.now();
-  if (!getBridgeRuntimeConnected() || !getBridgeOwnershipSnapshot().owned) {
-    refreshBridgeOwnershipSafe();
+  const gateBlocked = (!getBridgeRuntimeConnected() || !getBridgeOwnershipSnapshot().owned)
+    ? "bridge-seat"
+    : (!getChannelBridgeActive() ? "bridge-inactive" : "");
+  if (gateBlocked) {
+    if (gateBlocked === "bridge-seat") refreshBridgeOwnershipSafe();
+    // CC parity: an inbound message is never silently swallowed. The bridge
+    // seat may be mid-handover or the channel bridge may still be activating
+    // (app relaunch / boot); retry with backoff before giving up, and make
+    // the final drop loud so a real loss stays diagnosable.
+    const attempt = (msg.__bridgeGateRetries || 0) + 1;
+    if (attempt <= 5) {
+      msg.__bridgeGateRetries = attempt;
+      msg.receivedAtMs = receivedAtMs;
+      setTimeout(() => {
+        try { getBackend().onMessage?.(msg); } catch { /* best-effort */ }
+      }, 2000 * attempt)?.unref?.();
+    } else {
+      try { process.stderr.write(`mixdog: inbound message dropped after ${attempt - 1} ${gateBlocked} retries (channel=${msg.chatId}, id=${msg.messageId})\n`); } catch {}
+    }
     return;
   }
-  if (!getChannelBridgeActive()) return;
   if (shouldDropDuplicateInbound(msg)) return;
   // No label concept anymore: the channel id IS the identifier.
   recordFetchedMessages(msg.chatId, msg.chatId, [{ id: msg.messageId }], { markRead: true });

package/src/runtime/channels/lib/scheduler.mjs

@@ -88,6 +88,7 @@ class Scheduler {
   running = /* @__PURE__ */ new Set();
   injectFn = null;
   sendFn = null;
+  injectReadyFn = null;
   pendingCheck = null;
   // Activity tracking
   lastActivity = 0;
@@ -114,6 +115,16 @@ class Scheduler {
   setSendHandler(fn) {
     this.sendFn = fn;
   }
+  /** Probe for a live Lead bridge seat. When set, the CC-parity interactive
+   *  inject only fires while it reports true; otherwise the visible-session
+   *  fallback keeps the fire from being lost. Unset → inject when wired. */
+  setInjectReadyCheck(fn) {
+    this.injectReadyFn = typeof fn === 'function' ? fn : null;
+  }
+  injectReady() {
+    if (!this.injectReadyFn) return true;
+    try { return !!this.injectReadyFn(); } catch { return false; }
+  }
   setPendingCheck(fn) {
     this.pendingCheck = typeof fn === 'function' ? fn : null;
   }
@@ -473,6 +484,7 @@ ${Scheduler.INSTANCE_UUID}`;
       await this.markDoneWithRetry(schedule.name);
     } catch (err) {
       process.stderr.write(`mixdog scheduler: ${schedule.name} one-shot failed: ${err} — leaving pending for retry\n`);
+      this.notifyFailure(schedule, `one-shot failed: ${err?.message || err} — left pending for retry`);
     }
   }
   restart() {
@@ -556,6 +568,7 @@ ${Scheduler.INSTANCE_UUID}`;
     if (!prompt) {
       process.stderr.write(`mixdog scheduler: prompt not found for "${schedule.name}"
 `);
+      this.notifyFailure(schedule, "prompt not found — fire skipped");
       return false;
     }
     // target 'channel' → relay the run result to the schedule's channel_id
@@ -570,14 +583,34 @@ ${Scheduler.INSTANCE_UUID}`;
   async fireTimedPrompt(schedule, type, prompt, channelId, { awaitDispatch = false } = {}) {
     logSchedule(`firing ${schedule.name} (${type})
 `);
-    // Legacy interactive Lead-session inject is retired: every schedule fire
-    // runs as its own visible session below (New-task parity, user decision).
-    if (this.running.has(schedule.name)) return false;
+    if (this.running.has(schedule.name)) {
+      // Not silent anymore: overlap skips were invisible and read as the
+      // scheduler "ignoring" a fire.
+      logSchedule(`${schedule.name}: skipped — previous run still in progress\n`);
+      return false;
+    }
+    // CC parity (reference messageQueueManager.ts): interactive schedules
+    // enqueue into the live Lead session's command queue as system-generated
+    // task notifications (priority 'later'), exactly like inbound channel
+    // messages — enqueue counts as the fire. The visible-session run below
+    // remains the non-interactive path AND the fallback when no live Lead
+    // seat is attached, so a fire is never lost.
+    if (type === "interactive" && this.injectFn && this.injectReady()) {
+      try {
+        const wrapped = this.wrapPrompt(schedule.name, prompt, type);
+        this.injectFn(channelId, `schedule:${schedule.name}`, " ", { type: "schedule", instruction: wrapped });
+        logSchedule(`${schedule.name}: injected into Lead session queue (CC-parity interactive fire)\n`);
+        return true;
+      } catch (err) {
+        logSchedule(`${schedule.name}: Lead inject failed (${err?.message || err}) — falling back to visible session run\n`);
+      }
+    }
     this.running.add(schedule.name);
     const presetId = schedule.model;
     if (!presetId) {
       this.running.delete(schedule.name);
       logSchedule(`${schedule.name}: missing required "model" in schedule config — dispatch rejected\n`);
+      this.notifyFailure(schedule, 'missing "model" in schedule config — dispatch rejected');
       return false;
     }
     // Cron (recurring) keeps the fire-and-forget contract: return truthy now
@@ -601,6 +634,10 @@ ${Scheduler.INSTANCE_UUID}`;
       .catch((err) => {
         this.running.delete(schedule.name);
         logSchedule(`${schedule.name} LLM error: ${err.message}\n`);
+        // The cron fire-and-forget contract swallowed failures entirely;
+        // surface them on the channel so a failed scheduled run is never
+        // silent (one-shots propagate via the awaitDispatch throw instead).
+        if (!awaitDispatch) this.notifyFailure(schedule, `run failed: ${err.message}`);
         if (awaitDispatch) throw err;
         return false;
       });
@@ -608,6 +645,17 @@ ${Scheduler.INSTANCE_UUID}`;
     return true;
   }
   // ── Helpers ─────────────────────────────────────────────────────────
+  /** Best-effort failure notice to the schedule's channel (or the main
+   *  channel) so scheduled fires never fail silently. Respects an explicit
+   *  channel opt-out ("false" → resolveChannel yields "" → no notice). */
+  notifyFailure(schedule, reason) {
+    try {
+      if (!this.sendFn) return;
+      const target = this.resolveChannel(schedule?.channelId);
+      if (!target) return;
+      Promise.resolve(this.sendFn(target, `schedule "${schedule?.name}": ${reason}`)).catch(() => {});
+    } catch { /* best-effort */ }
+  }
   /** Resolve prompt: inline text from the row, with a prompts-dir file
    *  fallback for legacy `<name>.md` references. */
   resolvePrompt(schedule) {

package/src/runtime/channels/lib/worker-main.mjs

@@ -435,6 +435,10 @@ function forwardLifecycleToDiscord(channelId, content) {
 scheduler.setInjectHandler((channelId, name, content, options) => {
   injectAndRecord(channelId, name, content, options);
 });
+// CC-parity interactive schedule fires may only inject while this process
+// actually holds the live bridge seat; otherwise the scheduler falls back to
+// the visible-session run so the fire is never lost.
+scheduler.setInjectReadyCheck(() => bridgeRuntimeConnected && currentOwnerState().owned);
 scheduler.setSendHandler(async (channelId, text) => {
   // Skip protocol: a scheduler-task emitting `[meta:silent]` has nothing to
   // report — suppress the channel send entirely (no noise). Mirrors the

package/src/runtime/channels/tool-defs.mjs

@@ -25,7 +25,8 @@ export const TOOL_DEFS = [
           description: "Discord components."
         }
       },
-      required: ["message"]
+      required: ["message"],
+      additionalProperties: false
     }
   },
   {
@@ -39,7 +40,8 @@ export const TOOL_DEFS = [
         channel: { type: "string", description: "Discord channel id." },
         limit: { type: "number", description: "Max messages." }
       },
-      required: ["channel"]
+      required: ["channel"],
+      additionalProperties: false
     }
   },
   // memory and recall_memory tools are now provided by memory-service.mjs via MCP

package/src/runtime/memory/lib/query-handlers.mjs

@@ -697,11 +697,15 @@ export function createQueryHandlers({
       }
       const excludeStatuses = includeArchived ? [] : ['archived']
       const VALID_LAST_CATS = new Set(['rule', 'constraint', 'decision', 'fact', 'goal', 'preference', 'task', 'issue'])
-      const catList = category == null
+      const requestedCats = category == null
         ? []
-        : (Array.isArray(category) ? category : [category])
+        : [...new Set((Array.isArray(category) ? category : [category])
             .map((c) => String(c).trim().toLowerCase())
-            .filter((c) => VALID_LAST_CATS.has(c))
+            .filter((c) => VALID_LAST_CATS.has(c)))]
+      // Asking for every public category is semantically unfiltered. Keeping
+      // it as a restrictive filter drops fresh unclassified raw turns before
+      // cycle1 assigns a category, which can hide the immediately prior chat.
+      const catList = requestedCats.length === VALID_LAST_CATS.size ? [] : requestedCats
       // 1) rank sessions by most-recent activity (MAX(ts)) over the SAME pool
       //    the fill draws from — roots (status-filtered) + unchunked raw
       //    leaves, member rows excluded — so a session ranked here can never
@@ -720,6 +724,10 @@ export function createQueryHandlers({
         selParams.push(projectScope)
         selWhere.push(`(project_id IS NULL OR project_id = $${selParams.length})`)
       }
+      if (catList.length > 0) {
+        const ph = catList.map((c) => { selParams.push(c); return `$${selParams.length}` }).join(',')
+        selWhere.push(`lower(coalesce(category, '')) IN (${ph})`)
+      }
       if (excludeStatuses.length > 0) {
         const ph = excludeStatuses.map((s) => { selParams.push(s); return `$${selParams.length}` }).join(',')
         selWhere.push(`(status IS NULL OR status NOT IN (${ph}))`)

package/src/runtime/memory/tool-defs.mjs

@@ -4,7 +4,7 @@
 // they never reach an external LLM. `aiWrapped: true` routes dispatches
 // through ai-wrapped-dispatch.mjs instead of the module's handleToolCall.
 // Shared period grammar for recall/search_memories.
-const PERIOD_DESCRIPTION = "last (recent sessions; +query topic-filter; limit=session count), Nm/Nh/Nd, today/yesterday/this_week/last_week, all, YYYY-MM-DD, date~date, HH:MM~HH:MM, or 'YYYY-MM-DD HH:MM~HH:MM'.";
+const PERIOD_DESCRIPTION = "last (recent sessions; +query topic-filter), Nm/Nh/Nd, today/yesterday/this_week/last_week, all, YYYY-MM-DD, date~date, or HH:MM~HH:MM.";
 export const TOOL_DEFS = [
   {
     name: 'memory',
@@ -48,7 +48,7 @@ export const TOOL_DEFS = [
     name: 'recall',
     title: 'Recall',
     annotations: { title: 'Recall', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    description: 'Retrieve stored memory/session history for prior-work context (resumes, earlier decisions). Query is topic/semantic, not regex; period selects the time window; id for exact follow-up.',
+    description: 'Retrieve stored memory/session history (prior work, resumes, decisions). Query is semantic, not regex; period=time window; id=exact follow-up.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -60,10 +60,10 @@ export const TOOL_DEFS = [
         sort: { type: 'string', enum: ['importance', 'date'], description: 'importance or date.' },
         category: { anyOf: [{ type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, { type: 'array', items: { type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, minItems: 1 }], description: 'Category filter.' },
         includeArchived: { type: 'boolean', description: 'Include archived entries.' },
-        includeMembers: { type: 'boolean', description: 'Include chunk members in output; does not widen the search pool.' },
-        includeRaw: { type: 'boolean', description: 'Include unchunked raw/episode rows.' },
+        includeMembers: { type: 'boolean', description: 'Include chunk members.' },
+        includeRaw: { type: 'boolean', description: 'Include raw/episode rows.' },
         sessionOnly: { type: 'boolean', description: 'Search this session only.' },
-        projectScope: { type: 'string', description: 'Project pool selector: inferred from cwd, common, all, or slug.' },
+        projectScope: { type: 'string', description: 'Pool: inferred from cwd, common, all, or slug.' },
       },
       additionalProperties: false,
     },

package/src/runtime/shared/channel-notification-routing.mjs

@@ -7,6 +7,12 @@ export function channelNotificationModelContent(params = {}) {
 }
 
 export function shouldMirrorChannelNotificationToPending(meta = {}) {
-  const type = String(meta?.type || '').trim().toLowerCase();
-  return type === 'schedule';
+  // CC parity (reference messageQueueManager.ts): every inbound channel/
+  // schedule notification flows through the single queue — when no live
+  // listener handled it (engine not subscribed yet, pane disposed, headless),
+  // it is mirrored into the session pending queue for the next turn instead
+  // of being dropped. Silent-to-agent stays excluded; the upstream content
+  // gate (channelNotificationModelContent → '') already enforces it, this is
+  // a defensive second gate.
+  return !(meta?.silent_to_agent === true || meta?.silent_to_agent === 'true');
 }

package/src/runtime/shared/llm/http-agent.mjs

@@ -88,6 +88,17 @@ export function getLlmDispatcher() {
       keepAliveTimeout: envInt('MIXDOG_LLM_KEEPALIVE_MS', 60_000),
       keepAliveMaxTimeout: envInt('MIXDOG_LLM_KEEPALIVE_MAX_MS', 90_000),
       connections: envInt('MIXDOG_LLM_CONNECTIONS', 16),
+      // undici defaults both of these to 300s, which beheaded the Anthropic
+      // NON-STREAMING stall fallback (2026-08-03 regex-chess probe:
+      // UND_ERR_HEADERS_TIMEOUT at exactly 300s) — a non-streaming completion
+      // sends NO response headers until generation finishes, so a long silent
+      // generation legitimately exceeds 300s of header wait. Raise both to
+      // 600s: first-byte/idle protection is owned by the app-level watchdogs
+      // (provider first-byte + semantic idle + agent stall abort), which all
+      // fire below this transport ceiling; this layer is only the last-resort
+      // dead-socket bound.
+      headersTimeout: envInt('MIXDOG_LLM_HEADERS_TIMEOUT_MS', 600_000),
+      bodyTimeout: envInt('MIXDOG_LLM_BODY_TIMEOUT_MS', 600_000),
     })
   }
   // mixdog standalone: separate undici instance from Node's fetch undici, so

package/src/session-runtime/lifecycle-api.mjs

@@ -322,8 +322,27 @@ export function createLifecycleApi(deps) {
       const available = listLeadSessions({ refreshFromStorage: true })
         .some(row => row.id === sessionId);
       if (!available) return false;
+      let ownedAgentSessionIds = [];
+      try {
+        const candidates = mgr.listOwnedAgentSessionIds?.(sessionId);
+        if (Array.isArray(candidates)) {
+          ownedAgentSessionIds = [...new Set(candidates
+            .map(clean)
+            .filter(childId => childId && childId !== sessionId && /^[A-Za-z0-9_-]+$/.test(childId)))];
+        }
+      } catch { /* parent deletion remains available if child enumeration fails */ }
       const current = getSession();
-      if (current?.id !== sessionId) return mgr.deleteSession(sessionId) === true;
+      if (current?.id !== sessionId) {
+        const deleted = mgr.deleteSession(sessionId) === true;
+        if (!deleted) return false;
+        // The parent is already irreversibly gone, so child cleanup is
+        // best-effort and idempotent. Any vetoed child becomes sweep-eligible
+        // because its retained-parent proof disappeared with the parent.
+        for (const childId of ownedAgentSessionIds) {
+          try { mgr.deleteSession(childId); } catch {}
+        }
+        return true;
+      }
 
       const cleanupReason = 'desktop-session-delete';
       try {
@@ -339,6 +358,12 @@ export function createLifecycleApi(deps) {
       // immediately would let a late provider/save continuation resurrect the
       // deleted conversation after the user has moved to its replacement.
       if (mgr.closeSession(sessionId, cleanupReason, { tombstone: true }) !== true) return false;
+      // Active parent deletion uses the same durable tombstone boundary for
+      // every linked child. Their files then mature with the parent instead of
+      // disappearing while the parent task is still retained.
+      for (const childId of ownedAgentSessionIds) {
+        try { mgr.closeSession(childId, cleanupReason, { tombstone: true }); } catch {}
+      }
       setSession(null);
       invalidateContextStatusCache();
       invalidatePreSessionToolSurface();

package/src/session-runtime/tool-catalog-data.mjs

@@ -26,8 +26,11 @@ export const DEFERRED_DEFAULT_READONLY_TOOLS = Object.freeze([
 ]);
 export const DEFERRED_DEFAULT_LEAD_TOOLS = Object.freeze([
   'read', 'code_graph', 'grep', 'find', 'glob', 'list', 'shell', 'task',
-  'explore', 'apply_patch', 'agent', 'recall', 'search', 'web_fetch', 'cwd',
-  'session_manage', 'Skill', 'load_tool',
+  // cwd / session_manage / web_fetch demoted to the deferred manifest 2026-08:
+  // 0 / 0 / 10 calls in a 3-day 7.6k-call trace window; they auto-load on
+  // first direct call.
+  'explore', 'apply_patch', 'agent', 'recall', 'search',
+  'Skill', 'load_tool',
 ]);
 
 export const READONLY_TOOL_NAMES = new Set([

package/src/session-runtime/workflow.mjs

@@ -208,11 +208,13 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
         if (pack && !pack.hidden) byId.set(pack.id, pack);
       }
     }
-    return [...byId.values()].sort((a, b) => {
-      if (a.id === DEFAULT_WORKFLOW_ID) return -1;
-      if (b.id === DEFAULT_WORKFLOW_ID) return 1;
-      return a.name.localeCompare(b.name);
-    });
+    // Solo leads (user decision: solo is the default working mode), the
+    // cowork pack (built-in id `default`) second, then customs alphabetically
+    // — every picker (TUI, desktop sidebar, onboarding) shares this order.
+    const weight = (pack) => pack.id === 'solo' ? 0
+      : (pack.id === DEFAULT_WORKFLOW_ID || pack.id === 'cowork') ? 1 : 2;
+    return [...byId.values()].sort((a, b) =>
+      (weight(a) - weight(b)) || a.name.localeCompare(b.name));
   }
 
   function activeWorkflowId(config) {

package/src/standalone/agent-tool/tag-registry.mjs

@@ -259,7 +259,11 @@ export function createTagRegistry({
       const tag = tagForSession(sessionId);
       tombstoneTerminalSession(tag, sessionId, session);
       clearAgentStatuslineRoute(sessionId);
-      try { mgr.closeSession(sessionId, 'terminal-reap'); } catch {}
+      // Reaping expires only the reusable tag/runtime lease. The transcript is
+      // user-visible from the parent task's agent tab, so terminal cleanup must
+      // never tombstone it ahead of that parent. The normal completion path
+      // unloads immediately; this delayed call is an idempotent race fallback.
+      try { mgr.unloadSessionRuntime?.(sessionId, 'terminal-reap'); } catch {}
     }, reapMs);
     handle.unref?.();
     reapTimers.set(sessionId, handle);

package/src/standalone/explore-tool.mjs

@@ -18,7 +18,7 @@ export const EXPLORE_TOOL = {
   name: 'explore',
   title: 'Explore',
   annotations: { title: 'Explore', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-  description: 'Locator for broad/uncertain targets with no known path, repo or machine-wide (dot dirs included). query[] fans out up to 8 independent facets in parallel.',
+  description: 'Repo- or machine-wide locator (dot dirs included). query[] fans out up to 8 independent facets in parallel.',
   inputSchema: {
     type: 'object',
     properties: {