mixdog 1.2.6 → 1.3.1

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

@@ -6,7 +6,7 @@
  */
 import { contextMeasurementStats } from '../../../../shared/context-measurement.mjs';
 import { toolResultText } from './tool-result-text.mjs';
-import { restoredUserImageRefs, restoredUserText } from './user-text.mjs';
+import { createUserTextRestore } from './user-text.mjs';
 import {
   completionCardFromExecution,
   parseModelVisibleCompletionWrapper,
@@ -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)
@@ -372,17 +379,31 @@ function restoredNotificationToolItem(parsed, text, message, nextId, errorLabel)
   };
 }
 
-function restoredUserTranscriptItems(message, nextId) {
+function restoredUserTranscriptItems(message, nextId, userText) {
   // Injected model-context payloads are model-visible but never user-authored:
   // 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();
     return text ? [{ kind: 'user', id: nextId(), text, ...restoredTranscriptMetadata(message) }] : [];
   }
-  const text = restoredUserText(message?.content).trim();
+  const text = userText.text(message?.content).trim();
   // Persisted async-completion wrappers ("Async shell task ... finished. Result:
   // > ...") are the only durable record of a background completion — the live
   // Response card is an event-time push that does not survive a transcript
@@ -413,7 +434,7 @@ function restoredUserTranscriptItems(message, nextId) {
   }
   const synthetic = parseSyntheticAgentMessage(text);
   if (!synthetic) {
-    const imageRefs = restoredUserImageRefs(message?.content);
+    const imageRefs = userText.imageRefs(message?.content);
     return [
       {
         kind: 'user',
@@ -421,6 +442,8 @@ function restoredUserTranscriptItems(message, nextId) {
         text,
         ...restoredTranscriptMetadata(message),
         ...(imageRefs.length ? { imageRefs } : {}),
+        // Read by the model inside its running turn, as the live row says.
+        ...(message?.meta?.source === 'steering' ? { steered: true } : {}),
       },
     ];
   }
@@ -440,7 +463,20 @@ export function modelSwitchItem(id, boundary) {
   };
 }
 
-function restoreTranscriptRange(messages, start, sessionId) {
+/** 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, userText) {
   const items = [];
   const pendingToolCalls = new Map();
   for (let index = start; index < messages.length; index += 1) {
@@ -450,8 +486,13 @@ 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));
+      items.push(...restoredUserTranscriptItems(message, restoredId, userText));
     } else if (message?.role === 'assistant' && !isContextAckMessage(message, messages[index - 1])) {
       items.push(...restoredAssistantTranscriptItems(message, restoredId));
       items.push(...restoredToolCallItems(message, restoredId, pendingToolCalls));
@@ -477,6 +518,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))) {
@@ -490,9 +535,12 @@ function restoreTranscriptRange(messages, start, sessionId) {
 
 export function restoreTranscriptItems(messages, { sessionId = 'session', itemLimit = Number.POSITIVE_INFINITY } = {}) {
   const source = Array.isArray(messages) ? messages : [];
+  // One projection per load: a widened range reuses each prompt's parts and
+  // the paste-line reads share one budget.
+  const userText = createUserTextRestore();
   const numericLimit = Number(itemLimit);
   const limited = Number.isFinite(numericLimit) && numericLimit > 0;
-  if (!limited) return restoreTranscriptRange(source, 0, sessionId);
+  if (!limited) return restoreTranscriptRange(source, 0, sessionId, userText);
 
   const limit = Math.max(1, Math.floor(numericLimit));
   // Restore beyond the visible cap so a boundary tool run can merge exactly
@@ -506,7 +554,7 @@ export function restoreTranscriptItems(messages, { sessionId = 'session', itemLi
     upperBound += restoredMessageItemUpperBound(source[start]);
   }
 
-  let restored = restoreTranscriptRange(source, start, sessionId);
+  let restored = restoreTranscriptRange(source, start, sessionId, userText);
   // Hidden/context messages and aggregate tool runs can make the cheap upper
   // bound optimistic. Expand backward exponentially only when necessary.
   let expansionTarget = Math.max(64, limit - restored.length);
@@ -516,7 +564,7 @@ export function restoreTranscriptItems(messages, { sessionId = 'session', itemLi
       start -= 1;
       expansion += restoredMessageItemUpperBound(source[start]);
     }
-    restored = restoreTranscriptRange(source, start, sessionId);
+    restored = restoreTranscriptRange(source, start, sessionId, userText);
     expansionTarget *= 2;
   }
   return restored.length > limit ? restored.slice(-limit) : restored;

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

@@ -116,14 +116,64 @@ function referencedFeedbackText(part) {
   }
 }
 
+const PASTED_LINES = /· (\d+) lines?$/;
+const PASTED_TEXT_MAX_BYTES = 1024 * 1024;
+/** Blob bytes one transcript load may read to count the lines of pastes
+ *  whose stored name does not carry the count (pastes stored before it did). */
+export const PASTED_LINE_READ_BUDGET_BYTES = 4 * 1024 * 1024;
+
+/** Visible lines of a stored paste (as `pastedTextLineCount` counts them), or
+ *  null when the count would take a read past the load's budget. */
+function storedPasteLines(part, budget) {
+  const named = PASTED_LINES.exec(String(part.filename || ''));
+  if (named) return Number(named[1]);
+  const allowance = Math.min(PASTED_TEXT_MAX_BYTES, budget.remaining);
+  if (allowance <= 0) return null;
+  try {
+    const read = readAttachmentTextWithin(part, allowance);
+    if (read == null) return null;
+    budget.remaining -= Buffer.byteLength(read, 'utf8');
+    const value = read.replace(/\r\n?/g, '\n').replace(/\n+$/, '');
+    return value ? value.split('\n').length : 0;
+  } catch (error) {
+    // A blob that failed its integrity check was read before it failed: the
+    // read counts against the cap (at most the allowance). A missing blob
+    // read nothing.
+    if (error?.code !== 'ENOENT') budget.remaining -= allowance;
+    return null;
+  }
+}
+
+/** The chip token a stored pasted / attached text stood for in the live
+ *  bubble (intake moved its body into the store and dropped the token). A
+ *  paste whose line count is unknown shows as the plain `[Pasted text #n]`. */
+function storedTextToken(part, number, budget) {
+  if (part?.type !== 'text') return '';
+  if (part.textKind === 'paste') {
+    const lines = storedPasteLines(part, budget);
+    return lines == null ? `[Pasted text #${number}]` : `[Pasted text #${number} +${lines} lines]`;
+  }
+  if (part.textKind === 'file') return `[File #${number}: ${part.filename || 'attachment.txt'}]`;
+  return '';
+}
+
 /** The display lines of a stored prompt's parts, and for each image part the
  *  line that draws it: the composer's metadata line right before it, else a
- *  bare line of its own (a bare line never stands for the next image). */
-function restoredUserParts(content) {
+ *  bare line of its own (a bare line never stands for the next image). A
+ *  stored pasted or attached text shows as its chip token. */
+function restoredUserParts(content, budget) {
   const texts = [];
   const images = [];
   let pendingMetadata = '';
+  let storedTexts = 0;
   for (const part of content) {
+    const token = isAttachmentReference(part) ? storedTextToken(part, storedTexts + 1, budget) : '';
+    if (token) {
+      storedTexts += 1;
+      texts.push(token);
+      pendingMetadata = '';
+      continue;
+    }
     if (part?.type === 'image' || part?.type === 'input_image') {
       let line = pendingMetadata;
       if (!line) {
@@ -141,21 +191,48 @@ function restoredUserParts(content) {
   return { texts, images };
 }
 
+/**
+ * The user-bubble projection of one transcript load: each stored prompt's
+ * parts are worked out once (its text and its image refs share them, and a
+ * load that widens its range sees the same messages again), and the blob
+ * reads that count paste lines share one byte budget.
+ */
+export function createUserTextRestore({ readBudgetBytes = PASTED_LINE_READ_BUDGET_BYTES } = {}) {
+  const budget = { remaining: readBudgetBytes };
+  const parts = new WeakMap();
+  const partsOf = (content) => {
+    let found = parts.get(content);
+    if (!found) {
+      found = restoredUserParts(content, budget);
+      parts.set(content, found);
+    }
+    return found;
+  };
+  return {
+    text(content) {
+      if (!Array.isArray(content)) {
+        return withVisualizeFeedbackDisplay(typeof content === 'string' ? content : toolResultText(content));
+      }
+      return withVisualizeFeedbackDisplay(partsOf(content).texts.join('\n'));
+    },
+    /** The stored original of each image the restored bubble draws, by the
+     *  `[Image: …]` line that draws it. Every image keeps its slot (one
+     *  without a stored original has no `ref`) so later images do not shift
+     *  onto it; empty when no image has a stored original. */
+    imageRefs(content) {
+      if (!Array.isArray(content)) return [];
+      const slots = partsOf(content).images.map(({ part, line }) =>
+        isAttachmentReference(part) ? { line, ref: part.attachmentRef } : { line }
+      );
+      return slots.some((slot) => slot.ref) ? slots : [];
+    },
+  };
+}
+
 export function restoredUserText(content) {
-  if (!Array.isArray(content)) {
-    return withVisualizeFeedbackDisplay(typeof content === 'string' ? content : toolResultText(content));
-  }
-  return withVisualizeFeedbackDisplay(restoredUserParts(content).texts.join('\n'));
+  return createUserTextRestore().text(content);
 }
 
-/** The stored original of each image the restored bubble draws, by the
- *  `[Image: …]` line that draws it. Every image keeps its slot (one without a
- *  stored original has no `ref`) so later images do not shift onto it; empty
- *  when no image has a stored original. */
 export function restoredUserImageRefs(content) {
-  if (!Array.isArray(content)) return [];
-  const slots = restoredUserParts(content).images.map(({ part, line }) =>
-    isAttachmentReference(part) ? { line, ref: part.attachmentRef } : { line }
-  );
-  return slots.some((slot) => slot.ref) ? slots : [];
+  return createUserTextRestore().imageRefs(content);
 }

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;
     }