mixdog 1.2.6 → 1.3.0

package/src/runtime/agent/orchestrator/session/store-summary-catalog.mjs

@@ -21,6 +21,8 @@ import { readStrictRecordFields } from './store-record-strict-scan.mjs';
 import { isAgentOnlySession, isRootLeadSession, sessionVisibility } from './store-summary-visibility.mjs';
 import { applySummaryLogText, summaryLogPath } from './store-summary-log.mjs';
 import { dataDir } from './store-summary-locations.mjs';
+import { normalizeRoutineProvenance } from './routine-result.mjs';
+import { lastMessageLine, lastMessageSummary } from './store-summary-last-message.mjs';
 import {
   desktopSession,
   importKey,
@@ -31,6 +33,7 @@ import {
   workspaceSummary,
 } from './store-summary-fields.mjs';
 import { isRealTurnMessage } from './compact/user-message-kind.mjs';
+import { sessionModeOf } from './agent-mode.mjs';
 import { byActivityThenId } from './catalog-db/schema.mjs';
 import {
   sessionStampOf,
@@ -191,6 +194,7 @@ export function normalizedRow(row) {
     status: String(row.status || (row.closed === true ? 'closed' : 'idle')),
     owner: row.owner || 'user',
     agent: row.agent || null,
+    sessionMode: sessionModeOf(row),
     sourceType: row.sourceType || null,
     sourceName: row.sourceName || null,
     scopeKey: row.scopeKey || null,
@@ -210,6 +214,10 @@ export function normalizedRow(row) {
     realTurnCount: realTurnCount(row),
     title: cleanText(row.title, 100),
     preview: cleanText(row.preview),
+    lastMessagePreview: cleanText(row.lastMessagePreview),
+    // Null for any line that is not a routine result, and on rows written
+    // before the marker existed (they show their plain text).
+    lastMessageRoutine: normalizeRoutineProvenance(row.lastMessageRoutine),
     generation: typeof row.generation === 'number' ? row.generation : 0,
     storageMtimeMs: positiveNumber(row.storageMtimeMs, 0),
     storageSize: positiveNumber(row.storageSize, 0),
@@ -224,8 +232,9 @@ function leadRows(rows) {
 }
 
 // What a row derivation decodes of a record (store-record-strict-scan.mjs):
-// rowFromSession reads its user messages whole and only the role of the rest,
-// and never these top-level fields — together ~10% of a record, mostly tool
+// rowFromSession reads its user messages whole, the newest messages back to
+// the one with a last-message line whole too, only the role of the rest, and
+// never these top-level fields — together ~10% of a record, mostly tool
 // catalogs. Every other top-level field is decoded, so a field a row starts
 // to read is there without touching this list.
 const CATALOG_RECORD_READ = {
@@ -239,6 +248,7 @@ const CATALOG_RECORD_READ = {
     'pendingDeferredToolDelta',
   ]),
   fullMessageRoles: new Set(['user']),
+  fullTailUntil: (message) => Boolean(lastMessageLine(message)),
 };
 
 function rowFromSession(session) {
@@ -256,11 +266,15 @@ function rowFromSession(session) {
       )
       .map((message) => cleanText(messageText(message.content)))
       .find(Boolean) || '';
+  // The last-message line comes from the transcript like the summary index
+  // derives it; without it a session saved after the index was written lost
+  // its contact-row preview whenever its row came from this file read.
   return normalizedRow({
     ...session,
     messageCount: messages.filter((message) => message?.role === 'user' || message?.role === 'assistant').length,
     realTurnCount: messages.filter(isRealTurnMessage).length,
     preview,
+    ...lastMessageSummary(messages),
   });
 }
 

package/src/runtime/agent/orchestrator/session/store-summary-index.mjs

@@ -16,8 +16,9 @@ import {
   writeJsonAtomicSync,
 } from '../../../shared/atomic-file.mjs';
 import { applySummaryLogText, encodeSummaryOps, summaryLogPath } from './store-summary-log.mjs';
-import { cleanSessionPreview, isSessionPreviewNoise, sessionMessageText } from '../runtime-core/session-text.mjs';
+import { isSessionPreviewNoise, sessionMessageText } from '../runtime-core/session-text.mjs';
 import { sessionVisibility } from './store-summary-visibility.mjs';
+import { sessionModeOf } from './agent-mode.mjs';
 import {
   importKey,
   inheritedFromSessionId,
@@ -27,6 +28,8 @@ import {
   workspaceSummary,
 } from './store-summary-fields.mjs';
 import { isRealTurnMessage } from './compact/user-message-kind.mjs';
+import { isRoutineResultMessage, normalizeRoutineProvenance, routineProvenance } from './routine-result.mjs';
+import { LAST_MESSAGE_PREVIEW_MAX, cleanSummaryPreview, lastMessageRawText } from './store-summary-last-message.mjs';
 
 export const SESSION_SUMMARY_INDEX_VERSION = 2;
 
@@ -37,15 +40,7 @@ export function summaryIndexPath() {
   return join(getPluginData(), 'session-summaries.json');
 }
 
-function _computeCleanPreview(text, max) {
-  const value = cleanSessionPreview(text, max);
-  return value.length > max
-    ? value
-        .slice(0, max)
-        .replace(/\s+\S*$/, '')
-        .trim()
-    : value;
-}
+const _computeCleanPreview = cleanSummaryPreview;
 
 // Every index flush re-normalizes EVERY row's stored title and preview, and
 // cleaning runs a chain of regex replaces that each allocate a copy. Those
@@ -79,8 +74,13 @@ const sessionMessageProjectionMemo = new WeakMap();
 // re-cleaned.
 const messagePreviewMemo = new WeakMap();
 
+// Routine results (a schedule's output in its owner's home thread) follow ONE
+// rule here: each is exactly one message of `messageCount` (so a thread's
+// unread count, messageCount minus the read cursor, rises by one per result),
+// never a real turn (`realTurnCount`), never the first-prompt `preview` the
+// title falls back to, and shown as its notice line in `lastMessagePreview`.
 function _previewFromMessage(message) {
-  if (message?.role !== 'user') return '';
+  if (message?.role !== 'user' || isRoutineResultMessage(message)) return '';
   const raw = sessionMessageText(message.content);
   const memo = messagePreviewMemo.get(message);
   if (memo && memo.raw === raw) return memo.preview;
@@ -89,6 +89,20 @@ function _previewFromMessage(message) {
   return preview;
 }
 
+// message → { raw, preview } for the LAST conversational message, user or
+// assistant alike (a messenger row's last-message line).
+const lastMessagePreviewMemo = new WeakMap();
+
+function _lastPreviewFromMessage(message) {
+  const raw = lastMessageRawText(message);
+  if (raw === null) return '';
+  const memo = lastMessagePreviewMemo.get(message);
+  if (memo && memo.raw === raw) return memo.preview;
+  const preview = isSessionPreviewNoise(raw) ? '' : _cleanPreview(raw, LAST_MESSAGE_PREVIEW_MAX);
+  lastMessagePreviewMemo.set(message, { raw, preview });
+  return preview;
+}
+
 function _sessionMessageProjection(session) {
   const messages = Array.isArray(session?.messages) ? session.messages : [];
   const cached = session && typeof session === 'object' ? sessionMessageProjectionMemo.get(session) : null;
@@ -134,6 +148,17 @@ function _sessionMessageProjection(session) {
       }
     }
   }
+  // The newest line, read back from the tail every time: a streamed reply
+  // fills its message in place. Tool-only and synthetic rows are skipped, and
+  // each message's text is memoized, so this stays a few lookups per save.
+  // The line's routine provenance rides along, so a client labels a routine
+  // result by this marker and never by the line's wording.
+  let last = '';
+  let lastRoutine = null;
+  for (let index = messages.length - 1; index >= 0 && !last; index -= 1) {
+    last = _lastPreviewFromMessage(messages[index]);
+    if (last) lastRoutine = routineProvenance(messages[index]);
+  }
   if (session && typeof session === 'object') {
     sessionMessageProjectionMemo.set(session, {
       length: messages.length,
@@ -144,7 +169,7 @@ function _sessionMessageProjection(session) {
       previewMessage,
     });
   }
-  return { count, real, preview };
+  return { count, real, preview, last, lastRoutine };
 }
 
 function _desktopSessionSummary(value, cwd = null) {
@@ -178,6 +203,8 @@ export function _sessionSummary(session) {
     status: String(session.status || (session.closed === true ? 'closed' : 'idle')),
     owner: session.owner || 'user',
     agent: session.agent || null,
+    // 'agent' | 'coding' (agent-mode.mjs); older records resolve it.
+    sessionMode: sessionModeOf(session),
     sourceType: session.sourceType || null,
     sourceName: session.sourceName || null,
     scopeKey: session.scopeKey || null,
@@ -209,6 +236,8 @@ export function _sessionSummary(session) {
     realTurnCount: messageProjection.real,
     title: _cleanPreview(session.title || '', 100),
     preview: messageProjection.preview,
+    lastMessagePreview: messageProjection.last,
+    lastMessageRoutine: messageProjection.lastRoutine,
     generation: typeof session.generation === 'number' ? session.generation : 0,
     storageMtimeMs: _positiveNumber(session.storageMtimeMs, 0),
     storageSize: _positiveNumber(session.storageSize, 0),
@@ -234,6 +263,7 @@ function _normalizeSummaryRow(row) {
     status: String(row.status || (row.closed === true ? 'closed' : 'idle')),
     owner: row.owner || 'user',
     agent: row.agent || null,
+    sessionMode: sessionModeOf(row),
     sourceType: row.sourceType || null,
     sourceName: row.sourceName || null,
     scopeKey: row.scopeKey || null,
@@ -264,6 +294,8 @@ function _normalizeSummaryRow(row) {
     realTurnCount: realTurnCount(row),
     title: _cleanPreview(row.title || '', 100),
     preview: _cleanPreview(row.preview || ''),
+    lastMessagePreview: _cleanPreview(row.lastMessagePreview || '', 160),
+    lastMessageRoutine: normalizeRoutineProvenance(row.lastMessageRoutine),
     generation: typeof row.generation === 'number' ? row.generation : 0,
     storageMtimeMs: _positiveNumber(row.storageMtimeMs, 0),
     storageSize: _positiveNumber(row.storageSize, 0),

package/src/runtime/agent/orchestrator/session/store-summary-last-message.mjs

@@ -0,0 +1,46 @@
+/**
+ * The summary's last-message line (a messenger row's preview): the newest
+ * user or assistant message with displayable text, and that line's routine
+ * provenance. Leaf module, shared by the summary index (store saves) and the
+ * catalog's strict file scan so both derive the same line.
+ */
+import { cleanSessionPreview, isSessionPreviewNoise, sessionMessageText } from '../runtime-core/session-text.mjs';
+import { plainPreviewText } from '../../../shared/plain-preview.mjs';
+import { isRoutineResultMessage, routineProvenance, routineResultNotice } from './routine-result.mjs';
+
+export const LAST_MESSAGE_PREVIEW_MAX = 160;
+
+/** cleanSessionPreview cut back to a word boundary within `max`. */
+export function cleanSummaryPreview(text, max) {
+  const value = cleanSessionPreview(text, max);
+  return value.length > max
+    ? value
+        .slice(0, max)
+        .replace(/\s+\S*$/, '')
+        .trim()
+    : value;
+}
+
+/** The raw text a conversational message contributes as the last line (a
+ *  routine result: its notice line); null for any other message. */
+export function lastMessageRawText(message) {
+  if (message?.role !== 'user' && message?.role !== 'assistant') return null;
+  return isRoutineResultMessage(message) ? routineResultNotice(message).text : sessionMessageText(message.content);
+}
+
+/** The message's last-message line, '' when it has none (tool-only, synthetic). */
+export function lastMessageLine(message) {
+  const raw = lastMessageRawText(message);
+  if (raw === null || isSessionPreviewNoise(raw)) return '';
+  return cleanSummaryPreview(plainPreviewText(raw), LAST_MESSAGE_PREVIEW_MAX);
+}
+
+/** `{ lastMessagePreview, lastMessageRoutine }` of a transcript. */
+export function lastMessageSummary(messages) {
+  const list = Array.isArray(messages) ? messages : [];
+  for (let index = list.length - 1; index >= 0; index -= 1) {
+    const line = lastMessageLine(list[index]);
+    if (line) return { lastMessagePreview: line, lastMessageRoutine: routineProvenance(list[index]) };
+  }
+  return { lastMessagePreview: '', lastMessageRoutine: null };
+}

package/src/runtime/agent/orchestrator/session/store-summary-visibility.mjs

@@ -49,7 +49,3 @@ export function sessionVisibility(value) {
 export function isAgentOnlySession(value) {
   return sessionVisibility(value) === SESSION_VISIBILITY_AGENT_ONLY;
 }
-
-export function isOrdinarySession(value) {
-  return !isAgentOnlySession(value);
-}

package/src/runtime/agent/orchestrator/session/transcript-restore/restore.mjs

@@ -38,8 +38,12 @@ import {
 } from '../../../../shared/tool-execution-contract.mjs';
 import { toolResultTerminalStatus } from '../../../../shared/tool-status.mjs';
 import { transcriptAttachmentFields, transcriptRouteMetadataFields } from '../../../../shared/transcript-metadata.mjs';
+import { routineTriggerField } from '../../../../shared/routine-trigger.mjs';
 import { isImportedMessage } from '../imported-message.mjs';
 import { isContextAckMessage } from '../compact/user-message-kind.mjs';
+import { isRoutineResultMessage, routineResultNotice } from '../routine-result.mjs';
+import { heldRequestNotice, isHeldRequestMessage } from '../human-gate/held-message.mjs';
+import { isRoomRowMessage, roomRowItem } from '../agent-room.mjs';
 
 /** A failed turn's recorded end: its route, reason and quota stop, the same
  *  fields the live turndone carries. */
@@ -86,6 +90,8 @@ function restoredTranscriptMetadata(message) {
     // The attachments this prompt carried, by content hash: a restored row
     // opens/downloads them by id from the attachment store.
     ...transcriptAttachmentFields(value),
+    // A routine fire this turn delivered: painted as its marker row.
+    ...routineTriggerField(value),
     // Skills this user turn explicitly loaded (header selection or `$name`).
     ...(Array.isArray(value.appliedSkills) && value.appliedSkills.length
       ? { appliedSkills: value.appliedSkills.filter((name) => typeof name === 'string' && name) }
@@ -332,7 +338,8 @@ function mergeRestoredToolItems(items) {
 function restoredMessageItemUpperBound(message) {
   const boundaries =
     (Array.isArray(message?.meta?.sessionInheritances) ? message.meta.sessionInheritances.length : 0) +
-    (Array.isArray(message?.meta?.modelSwitches) ? message.meta.modelSwitches.length : 0);
+    (Array.isArray(message?.meta?.modelSwitches) ? message.meta.modelSwitches.length : 0) +
+    (Array.isArray(message?.meta?.workflowSwitches) ? message.meta.workflowSwitches.length : 0);
   const completionCount =
     Number(Boolean(message?.meta?.transcript?.completion)) +
     (Array.isArray(message?.meta?.transcript?.previousCompletions)
@@ -377,6 +384,20 @@ function restoredUserTranscriptItems(message, nextId) {
   // skill bodies (meta:'skill'), hook/system reminders, and tag-wrapped context
   // blocks must not restore as user bubbles in any client.
   if (message?.meta === 'skill' || message?.meta === 'hook') return [];
+  // A schedule's result in its owner's home thread: a notice row.
+  // A held request of an unattended run (human-gate/held-message.mjs) likewise.
+  if (isRoutineResultMessage(message) || isHeldRequestMessage(message)) {
+    const { messageId, at } = restoredTranscriptMetadata(message);
+    return [
+      {
+        kind: 'notice',
+        id: nextId(),
+        ...(isHeldRequestMessage(message) ? heldRequestNotice(message) : routineResultNotice(message)),
+        ...(messageId ? { messageId } : {}),
+        ...(at ? { at } : {}),
+      },
+    ];
+  }
   // Imported prose renders verbatim: never a control row, card or display rewrite.
   if (isImportedMessage(message)) {
     const text = (typeof message.content === 'string' ? message.content : toolResultText(message.content)).trim();
@@ -440,6 +461,19 @@ export function modelSwitchItem(id, boundary) {
   };
 }
 
+/** The transcript row of a mid-conversation workflow switch (live and restored). */
+export function workflowSwitchItem(id, boundary) {
+  return {
+    kind: 'statusdone',
+    id,
+    status: 'workflow-switched',
+    label: 'Workflow switched',
+    from: boundary.from,
+    to: boundary.to,
+    at: boundary.at,
+  };
+}
+
 function restoreTranscriptRange(messages, start, sessionId) {
   const items = [];
   const pendingToolCalls = new Map();
@@ -450,6 +484,11 @@ function restoreTranscriptRange(messages, start, sessionId) {
     // let a tail-only restore skip the prefix without first counting every old
     // projected item.
     const restoredId = () => `hist_${sessionId}_${index}_${++part}`;
+    // A group room's posted row (agent-room.mjs): one bubble or notice row.
+    if (isRoomRowMessage(message)) {
+      items.push(roomRowItem(message, restoredId()));
+      continue;
+    }
     if (message?.role === 'user') {
       items.push(...restoredUserTranscriptItems(message, restoredId));
     } else if (message?.role === 'assistant' && !isContextAckMessage(message, messages[index - 1])) {
@@ -477,6 +516,10 @@ function restoreTranscriptRange(messages, start, sessionId) {
       if (!boundary?.provider || !boundary?.modelId) continue;
       items.push(modelSwitchItem(restoredId(), boundary));
     }
+    for (const boundary of Array.isArray(message?.meta?.workflowSwitches) ? message.meta.workflowSwitches : []) {
+      if (!boundary?.to) continue;
+      items.push(workflowSwitchItem(restoredId(), boundary));
+    }
     if (message?.meta?.transcript?.previousCompletions?.length) {
       const events = items.slice(eventStart);
       if (events.every((item) => Number.isFinite(item.at))) {

package/src/runtime/agent/orchestrator/tools/builtin/lib/shell-job-records.mjs

@@ -339,11 +339,23 @@ export function releaseShellJobWorkspace(jobId) {
   if (workspaceLeases.get(key) === leave) workspaceLeases.delete(key);
 }
 
+/** True once `sessionId` closed in this runtime. */
+export function isShellOwnerSessionClosed(sessionId) {
+  return closedOwnerSessions.has(String(sessionId || '').trim());
+}
+
 /** Flag a still-open job record as "termination unconfirmed" for the readouts. */
 export function markShellJobTerminationUnconfirmed(jobId) {
   return patchRunningShellJobRecord(jobId, { terminationUnconfirmed: true });
 }
 
+/** Record the pids a held job's termination watch last found alive, so a
+ *  reader in another process can tell a live hold from a stale one. */
+export function noteShellJobSurvivors(jobId, pids) {
+  const survivorPids = (pids || []).map(Number).filter((pid) => Number.isInteger(pid) && pid > 0);
+  return patchRunningShellJobRecord(jobId, { survivorPids });
+}
+
 function patchRunningShellJobRecord(jobId, patch) {
   const key = validJobId(jobId);
   if (!key) return Promise.resolve(false);

package/src/runtime/agent/orchestrator/tools/builtin/native-search-client.mjs

@@ -8,7 +8,8 @@
 //
 // MIXDOG_SEARCH_SERVER=0 disables; MIXDOG_SEARCH_SERVER_BIN overrides the
 // executable.
-import { existsSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, realpathSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, resolve as resolvePath, sep } from 'node:path';
 import { bindChildLifecycle, createNativeSearchTransport } from './native-search-transport.mjs';
 import { invalidateBuiltinResultCache } from './cache-layers.mjs';
 import { getPluginData } from '../../config.mjs';
@@ -254,6 +255,32 @@ export async function shutdownNativeSearchServer(reason = 'process-exit', timeou
 
 export { bindChildLifecycle as _bindNativeSearchServerLifecycle };
 
+// Inventories persisted before search roots were canonicalized (see
+// canonicalPath) can hold another spelling of a folder's files under the
+// folder's canonical key; loading one would keep serving every file twice.
+// Drop that snapshot once per data dir, before a server of this process loads
+// it. The marker records that the remaining snapshot was written by servers
+// that only ever saw canonical roots.
+const INVENTORY_SNAPSHOT_FILE = 'file-inventories-v1.bin';
+const CANONICAL_ROOTS_MARKER = 'file-inventories-v1.canonical-roots';
+let _inventorySnapshotChecked = false;
+
+function dropAliasSpelledInventorySnapshot() {
+  if (_inventorySnapshotChecked) return;
+  _inventorySnapshotChecked = true;
+  const dir = join(getPluginData(), 'search-index');
+  const marker = join(dir, CANONICAL_ROOTS_MARKER);
+  if (existsSync(marker)) return;
+  try {
+    rmSync(join(dir, INVENTORY_SNAPSHOT_FILE), { force: true });
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(marker, '');
+  } catch {
+    // A snapshot that cannot be removed now (held open by another server) is
+    // retried by the next process; search itself does not depend on it.
+  }
+}
+
 function _ensureServer() {
   if (_server) return _server;
   if (
@@ -261,6 +288,7 @@ function _ensureServer() {
     Date.now() - _lastFailureAt < RESTART_BACKOFF_MS
   )
     return null;
+  dropAliasSpelledInventorySnapshot();
   let transport;
   try {
     transport = createNativeSearchTransport({
@@ -633,15 +661,93 @@ function consumedDeadline(response, deadlineMs) {
   );
 }
 
+// The server walks a root as the request spells it, but its file-change
+// updates carry the resolved path. Any other spelling of the same folder —
+// letter case on Windows, a junction or symlink, a `..` segment — therefore
+// listed every file twice (one copy per spelling). Roots are resolved once,
+// here, so the first walk, later updates and the inventory key agree.
+function canonicalPath(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
+
+// One positional operand resolved against the canonical cwd. An operand that
+// is already canonical is sent unchanged. An exact file that is itself a
+// symlink keeps its own name: --glob/--type filter the name the caller asked
+// for. `file` tells restoreOperandSpelling how the server prints the operand.
+function canonicalOperand(cwd, operand) {
+  const joined = isAbsolute(operand) ? operand : `${cwd}${sep}${operand}`;
+  let canonical;
+  let file;
+  try {
+    file = statSync(joined).isFile();
+    canonical =
+      file && lstatSync(joined).isSymbolicLink()
+        ? join(realpathSync.native(dirname(joined)), basename(joined))
+        : realpathSync.native(joined);
+  } catch {
+    return null;
+  }
+  if (canonical === (isAbsolute(operand) ? operand : resolvePath(cwd, operand))) return null;
+  // The server prints results with `/` when the operand only uses `/`.
+  const sent = operand.includes('/') && !operand.includes('\\') ? canonical.replaceAll('\\', '/') : canonical;
+  if (sent === operand) return null;
+  // A directory is printed with its trailing separators trimmed.
+  const printed = (path) => (file ? path : path.replace(/[\\/]+$/, ''));
+  return { sent, from: printed(sent), to: printed(operand), file };
+}
+
+// Canonical cwd and operands for a search request, plus the operands whose
+// spelling restoreOperandSpelling puts back into the result lines. Positional
+// operands follow the last `--` (search-builders emits it before them; a `--`
+// pattern is always an `-e` value before it).
+function canonicalSearchRequest(cwd, argsList) {
+  const root = canonicalPath(cwd);
+  const args = argsList.map(String);
+  const remaps = [];
+  const operandsAt = args.lastIndexOf('--') + 1;
+  if (operandsAt > 0) {
+    for (let i = operandsAt; i < args.length; i += 1) {
+      const remap = canonicalOperand(root, args[i]);
+      if (!remap) continue;
+      args[i] = remap.sent;
+      remaps.push(remap);
+    }
+  }
+  remaps.sort((a, b) => b.from.length - a.from.length);
+  return { cwd: root, args, remaps };
+}
+
+// Results under a canonicalized operand are printed by the server as
+// `<operand><sep><relative>` (a directory) or as the operand itself followed
+// by `:`/`-` fields (an exact file); show them under the caller's spelling.
+function restoreOperandSpelling(lines, remaps) {
+  if (remaps.length === 0) return lines;
+  return lines.map((line) => {
+    if (typeof line !== 'string') return line;
+    for (const { from, to, file } of remaps) {
+      if (!line.startsWith(from)) continue;
+      const rest = line.slice(from.length);
+      if (rest !== '' && !(file ? /^[:-]/ : /^[\\/]/).test(rest)) continue;
+      return `${to}${rest}`;
+    }
+    return line;
+  });
+}
+
 /** Returns a runRgWindowedLines-shaped result, or null when the native server
  *  is disabled or the response carries no line list. */
 export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
   if (searchServerDisabled()) return null;
   const deadlineMs = callerDeadlineMs(execOptions, REQUEST_TIMEOUT_MS);
+  const canonical = canonicalSearchRequest(String(execOptions.cwd || process.cwd()), argsList);
   const buildRequest = (server, remaining) => ({
     id: ++server.sequence,
-    cwd: String(execOptions.cwd || process.cwd()),
-    args: argsList.map(String),
+    cwd: canonical.cwd,
+    args: [...canonical.args],
     offset: Math.max(0, Math.floor(Number(opts.offset) || 0)),
     limit: Number.isFinite(Number(opts.limit)) && Number(opts.limit) > 0 ? Math.floor(Number(opts.limit)) : 0,
     deadlineMs: softDeadlineMs(remaining),
@@ -701,7 +807,7 @@ export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
     ? response.walkErrorDetails.map(String).slice(0, 8)
     : [];
   return {
-    lines: response.lines,
+    lines: restoreOperandSpelling(response.lines, canonical.remaps),
     complete: response.complete === true,
     totalSeen: Math.max(0, Math.floor(Number(response.totalSeen) || 0)),
     partial: response.partial === true,
@@ -731,7 +837,8 @@ export async function tryServeFuzzySearch(args, execOptions = {}) {
   const response = await requestNativeWithRestart(
     (server, remaining) => ({
       id: ++server.sequence,
-      cwd: String(args?.cwd || execOptions.cwd || process.cwd()),
+      // Matches are relative to cwd, so only the root needs canonicalizing.
+      cwd: canonicalPath(String(args?.cwd || execOptions.cwd || process.cwd())),
       fuzzy: String(args?.query || ''),
       limit: Math.max(1, Math.min(1_000, Math.floor(Number(args?.limit) || 25))),
       hidden: args?.hidden !== false,
@@ -813,4 +920,5 @@ export function _resetNativeSearchClientForTest() {
   _binaryResolveStarted = false;
   _warmPromise = null;
   _lastTimeoutRecycleAt = 0;
+  _inventorySnapshotChecked = false;
 }

package/src/runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs

@@ -28,8 +28,10 @@ import {
   adoptShellWorkspaceAdmission,
   clearTerminationHold,
   completeShellJobRecord,
+  isShellOwnerSessionClosed,
   listShellJobRecords,
   markShellJobTerminationUnconfirmed,
+  noteShellJobSurvivors,
   publishShellJobRecord,
   registerTerminationHold,
   retireShellJobRecord,
@@ -194,6 +196,8 @@ function trackShellJobRecord(task, options) {
       sweep: killed,
       onTerminated: finish,
       releaseRequested: () => takeReleaseRequest(jobId),
+      ownerClosed: () => isShellOwnerSessionClosed(options?.ownerSessionId),
+      onSurvivors: (pids) => void noteShellJobSurvivors(jobId, pids),
       onUnconfirmed: () => {
         void markShellJobTerminationUnconfirmed(jobId);
         registerTerminationHold(jobId, {

package/src/runtime/agent/orchestrator/tools/lib/shell-descendants.mjs

@@ -195,12 +195,22 @@ function sweepLiveIdentities(tracker) {
  *
  *  `sweep` (a killed tree): a pass that finds captured identities alive
  *  terminates them and observes again in the same pass, so a cancellation
- *  ends with the tree gone instead of a held folder over live processes. */
+ *  ends with the tree gone instead of a held folder over live processes.
+ *
+ *  `ownerClosed`: once the owning session has closed and the root has
+ *  exited, a tree without a complete pre-kill snapshot is observed after
+ *  exit (what is still linked to the root) instead of answering 'unknown'
+ *  forever — no one is left to release it, and the close must end in a
+ *  definitive state. `onSurvivors(pids)` reports the pids a pass that is
+ *  not 'gone' found alive, whenever that set changes, so out-of-process
+ *  readers can tell a live hold from a stale one. */
 export function watchTermination({
   tracker,
   rootExited = () => true,
   onTerminated,
   onUnconfirmed = null,
+  onSurvivors = null,
+  ownerClosed = null,
   releaseRequested = null,
   intervalMs = TERMINATION_RECHECK_MS,
   sweep = false,
@@ -208,6 +218,7 @@ export function watchTermination({
   let timer = null;
   let stopped = false;
   let reportedUnconfirmed = false;
+  let survivorKey = null;
   const stop = () => {
     stopped = true;
     if (timer) clearTimeout(timer);
@@ -223,6 +234,7 @@ export function watchTermination({
     if (releaseRequested?.()) state = 'gone';
     else
       try {
+        if (!tracker.complete && rootExited() && ownerClosed?.()) tracker.acceptExitObservation();
         observation = tracker.observe({ rootExited: rootExited() });
         observation.catch(() => {});
         // A pass that has not answered by the next cadence tick is unknown.
@@ -250,6 +262,18 @@ export function watchTermination({
         /* presentation only */
       }
     }
+    if (state !== 'gone' && onSurvivors) {
+      const pids = tracker.live.map((entry) => entry.pid);
+      const key = pids.join(',');
+      if (key !== survivorKey) {
+        survivorKey = key;
+        try {
+          onSurvivors(pids);
+        } catch {
+          /* presentation only */
+        }
+      }
+    }
     if (state === 'gone') {
       try {
         await onTerminated();

package/src/runtime/agent/orchestrator/tools/lib/shell-run-background/promote-job.mjs

@@ -60,6 +60,14 @@ export async function promoteWithRetry(
  */
 export function killAfterFailedPromotion(run, reason, promotionFailure) {
   run.autoBackgrounded = false;
+  // The command finished while it was being promoted (the spawn server
+  // releases a foreground task's record at its exit, so the promotion found
+  // none): report that completion. Killing the exited root would have no
+  // pre-kill snapshot and hold the workspace as unconfirmed for good.
+  if (run.child.exitCode != null || run.child.signalCode != null) {
+    if (run.promotionClose) void run.settle(...run.promotionClose);
+    return;
+  }
   if (reason === 'timeout') {
     run.timedOut = true;
     treeKillForceSettle(run, 'timeout');

package/src/runtime/agent/orchestrator/tools/lib/shell-run-settle.mjs

@@ -8,6 +8,8 @@ import { unregisterOwnedShellTree } from './owned-shell-trees.mjs';
 import {
   adoptShellWorkspaceAdmission,
   clearTerminationHold,
+  isShellOwnerSessionClosed,
+  noteShellJobSurvivors,
   registerTerminationHold,
   takeReleaseRequest,
 } from '../builtin/lib/shell-job-records.mjs';
@@ -60,6 +62,8 @@ export function releaseAdmissionOnConfirmedTermination(run, { markNow = true } =
     sweep: run.killed === true,
     onTerminated: release,
     onUnconfirmed: markNow ? null : () => keepTerminationUnconfirmedRecord(run),
+    onSurvivors: (pids) => void noteShellJobSurvivors(run.foregroundRecordId, pids),
+    ownerClosed: () => isShellOwnerSessionClosed(run.foregroundRecordInput?.ownerSessionId),
     releaseRequested: () => takeReleaseRequest(run.foregroundRecordId),
   });
 }
@@ -164,6 +168,8 @@ export function createSettle(run, releasePromotedCapture) {
     if (run.settled) return;
     if (run.ownedTree) unregisterOwnedShellTree(run.foregroundRecordId, run.ownedTree);
     if (run.autoBackgrounded) {
+      // A failed promotion settles the run with this close instead.
+      run.promotionClose = [exitCode, signal];
       releasePromotedCapture();
       return;
     }