mixdog 1.2.2 → 1.2.3

package/src/runtime/shared/llm/usage-accounting.mjs

@@ -8,6 +8,7 @@ import { currentProviderAccountId } from '../provider-auth-binding.mjs';
 // fallback, catalog retry) runs its own accounting and its result or error
 // then returns through the enclosing send, which must not write it again.
 const recorded = new WeakSet();
+const UNMEASURED_USAGE = Object.freeze({ inputTokens: null, inputTokensKnown: false });
 const hasTokens = (usage) =>
   ['inputTokens', 'outputTokens', 'cachedTokens', 'cacheWriteTokens'].some((key) => Number(usage?.[key]) > 0);
 // One rule for every reported usage object: tokens, or a provider-reported
@@ -51,7 +52,9 @@ export async function accountProviderSend(provider, instance, send, model, opts
   // abandoned attempt or a failure shares that clock with the final attempt,
   // so timing it too would count the same seconds twice and understate speed.
   const record = async (result, id, owner, timed) => {
-    if (!result?.usage) return;
+    // A completed call that reported no usage is still a call: it is recorded
+    // as unmeasured (unknown input, unpriced) instead of vanishing from totals.
+    if (!result?.usage && !(timed && result && typeof result === 'object')) return;
     // A nested send (e.g. a fallback model re-send) already stamped its own
     // final attempt's tier; the outer context only saw the abandoned attempt.
     result.requestServiceTier ??= identity.requestServiceTier || '';
@@ -59,7 +62,7 @@ export async function accountProviderSend(provider, instance, send, model, opts
     if (openingError) throw openingError;
     if (!ledger) return;
     recorded.add(owner);
-    const usage = result.usage;
+    const usage = result.usage || UNMEASURED_USAGE;
     const row = makeUsageRecord({
       id: result.responseId ? undefined : id,
       ts: Date.now(),

package/src/runtime/shared/llm/usage-ledger-rollup.mjs

@@ -61,6 +61,8 @@ const add = (target, row) => {
     costBilled: row.cost_source === 'provider' ? row.cost_usd : 0,
     costEstimated: row.cost_source === 'provider' ? 0 : row.cost_usd,
   });
+  // A call recorded without provider usage is unmeasured whatever its provider.
+  if (row.unmeasured && !usage.unmeasuredTurns) usage.unmeasuredTurns = usage.turns || 0;
   for (const field of [
     'turns',
     'input',
@@ -311,6 +313,7 @@ export function readSessionUsage(db, sessionIds) {
                     json_extract(r.signature,'$[1]') AS model,
                     json_extract(r.signature,'$[4]') AS cost_source,
                     json_extract(r.signature,'$[7]') AS rank,
+                    COALESCE(json_extract(json_extract(r.signature,'$[5]'),'$.inputTokensKnown'),1)=0 AS unmeasured,
                     m.turns,m.input,m.output,m.cache_read,m.cache_write,m.cost_usd,m.duration_ms,
                     m.speed_output,m.speed_ms
                 FROM mine m JOIN usage_routes r ON r.id=m.route

package/src/runtime/shared/loopback-listener.mjs

@@ -9,6 +9,15 @@ export function createLoopbackListener({
   let current = null;
   let closing = null;
 
+  // close() drops only the keep-alive sockets idle at that moment; one whose
+  // in-flight response ends later would hold the close for the server's whole
+  // keepAliveTimeout (~5 s). Drop each as its response settles while stopping.
+  server.on('request', (_req, res) => {
+    res.once('close', () => {
+      if (closing) server.closeIdleConnections();
+    });
+  });
+
   function start() {
     if (closing) return Promise.reject(new Error('HTTP listener is stopping'));
     if (current) return current.promise;

package/src/runtime/shared/provider-api-key.mjs

@@ -72,12 +72,14 @@ export function getAgentApiKey(provider) {
 /** The one API-key resolver for key-based providers: an explicit config key
  *  wins, otherwise the environment/keychain (getAgentApiKey). */
 export function resolveProviderApiKey(provider, config) {
+  if (config?.apiKeyEnv) return process.env[config.apiKeyEnv] || '';
   return config?.apiKey || getAgentApiKey(provider) || '';
 }
 
 /** Auth-error reload: the stored/environment key is re-read first so a
  *  rotated key beats the stale one captured in config. */
 export function reloadProviderApiKey(provider, config) {
+  if (config?.apiKeyEnv) return process.env[config.apiKeyEnv] || '';
   return getAgentApiKey(provider) || config?.apiKey || '';
 }
 

package/src/runtime/shared/review-diff.mjs

@@ -1,5 +1,57 @@
 const TRUNCATED = '… [diff truncated for display]';
 
+// Review replies always list every changed file with its counts. Patch text
+// is carried per file within these caps (UTF-8 bytes); a file past either one
+// is listed `patchOmitted` with reason PATCH_TOO_LARGE and is read on its own,
+// up to the larger "show anyway" cap, when it is opened.
+/** Largest single-file patch a review reply carries inline. */
+export const REVIEW_FILE_PATCH_MAX_BYTES = 1024 * 1024;
+/** Largest total patch text a review reply carries. */
+export const REVIEW_PATCH_MAX_BYTES = 2 * 1024 * 1024;
+/** Largest single-file patch a file-patch read returns. */
+export const REVIEW_FILE_PATCH_SHOW_MAX_BYTES = 8 * 1024 * 1024;
+export const PATCH_TOO_LARGE = 'too_large';
+
+/** A reply file listed with its counts but without its patch, for size. */
+export function patchOmittedFile(file) {
+  return { ...file, patchOmitted: true, reason: PATCH_TOO_LARGE };
+}
+
+/** A `diff --git` section (string or Buffer) whose hunks boundReviewPatch cut. */
+export function reviewSectionTruncated(section) {
+  return section.includes(TRUNCATED);
+}
+
+/** Nothing of the reply's patch fit: no patch text, a file omitted for size. */
+export function reviewDiffTooLarge(files, patch) {
+  return !patch && (files || []).some((file) => file?.patchOmitted === true && file.reason === PATCH_TOO_LARGE);
+}
+
+/** The per-file and total caps of one reply. `admit(bytes)` takes a patch of
+ *  that size from the remaining total, or refuses it. */
+export function createReviewPatchBudget(total = REVIEW_PATCH_MAX_BYTES) {
+  let remaining = total;
+  return {
+    get remaining() {
+      return remaining;
+    },
+    admit(bytes) {
+      if (bytes > REVIEW_FILE_PATCH_MAX_BYTES || bytes > remaining) return false;
+      remaining -= bytes;
+      return true;
+    },
+  };
+}
+
+/** One file-patch read's reply: its patch, or none when past `maxBytes`. */
+export function filePatchReply(path, patch, maxBytes = REVIEW_FILE_PATCH_SHOW_MAX_BYTES) {
+  const text = typeof patch === 'string' ? patch : '';
+  if (Buffer.byteLength(text, 'utf8') > maxBytes) {
+    return { supported: true, path, patch: '', patchOmitted: true, reason: PATCH_TOO_LARGE };
+  }
+  return { supported: true, path, patch: text };
+}
+
 /** Bound hunk bodies, never the inventory of changed files. Headers are kept
  * even when the inventory itself exceeds the display budget. */
 export function boundReviewPatch(patch, maxChars) {

package/src/runtime/shared/session-sidebar-host.d.mts

@@ -0,0 +1,4 @@
+export type SessionSidebarChange = { favorite: boolean } | { archived: boolean };
+export type SessionSidebarHost = (sessionId: unknown, change: unknown) => unknown;
+export function registerSessionSidebarHost(host: SessionSidebarHost): () => void;
+export function applySessionSidebarChange(sessionId: string, change: SessionSidebarChange): Promise<void>;

package/src/runtime/shared/session-sidebar-host.mjs

@@ -0,0 +1,38 @@
+// Runtime → desktop request channel for a session's sidebar metadata
+// (favorite, archive). That metadata belongs to the desktop
+// service hosted in this daemon: it registers a host here, and the Lead's
+// `session` tool applies a change through it, so the sidebar republishes live.
+//
+// Deliberately dependency-free: the desktop service bundle imports this file
+// too, and both copies share one registry through a global symbol.
+
+const HOSTS_KEY = Symbol.for('mixdog.sessionSidebarHosts.v1');
+
+function hosts() {
+  globalThis[HOSTS_KEY] ??= [];
+  return globalThis[HOSTS_KEY];
+}
+
+/**
+ * Register a desktop host. `host(sessionId, change)` applies one change:
+ * `{ favorite: boolean }` or `{ archived: boolean }`.
+ * @returns {() => void} Unregister.
+ */
+export function registerSessionSidebarHost(host) {
+  const entry = { host };
+  hosts().push(entry);
+  return () => {
+    const list = hosts();
+    const index = list.indexOf(entry);
+    if (index >= 0) list.splice(index, 1);
+  };
+}
+
+/** Apply one change through exactly one host: the most recently registered
+ *  (active) desktop service. Never broadcast — each service writes the shared
+ *  metadata file, so a second write would be redundant at best. */
+export async function applySessionSidebarChange(sessionId, change) {
+  const active = hosts().at(-1);
+  if (!active) throw new Error('no desktop app is attached to this runtime');
+  await active.host(sessionId, change);
+}

package/src/runtime/shared/slow-span.mjs

@@ -0,0 +1,114 @@
+// slow-span.mjs
+// Passive per-request timing spans. Every traced call is timed on the same
+// monotonic clock the owner heartbeat uses (performance.now), completed spans
+// over `minMs` land in a bounded ring, and spans over `slowMs` are logged as
+// `[slow-op] <label> <ms>`. When the event loop stalls, `describe(from, to)`
+// names the spans that overlapped the stall window. Spans carry labels, phase
+// durations and sizes only — never payloads.
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { performance } from 'node:perf_hooks';
+
+export const SPAN_RING_MIN_MS = 25;
+export const SPAN_SLOW_MS = 1000;
+export const SPAN_RING_CAPACITY = 64;
+
+const current = new AsyncLocalStorage();
+
+/** Short, log-safe id of a session id. */
+export function shortId(id) {
+  const text = String(id ?? '');
+  return text ? text.slice(0, 8) : '';
+}
+
+/** Appends detail (e.g. the action name) to the label of the span the caller runs in. */
+export function annotateSpan(detail) {
+  const span = current.getStore();
+  if (span && detail) span.label += `:${detail}`;
+}
+
+/** Closes the running phase of the caller's span at `now`, under `name`. */
+export function markPhase(name) {
+  const span = current.getStore();
+  if (!span) return;
+  const t = span.now();
+  span.phases.push([name, t - span.mark]);
+  span.mark = t;
+}
+
+/** Records a size (count/bytes) on the caller's span. */
+export function noteSpanSize(size) {
+  const span = current.getStore();
+  if (span && Number.isFinite(size)) span.size = size;
+}
+
+const round = (ms) => Math.round(ms);
+
+function formatSpan(span) {
+  const phases = span.phases.map(([name, ms]) => `${name}=${round(ms)}`).join(' ');
+  const size = span.size === undefined ? '' : ` size=${span.size}`;
+  return `${span.label} ${round(span.ms)}ms${phases ? ` ${phases}` : ''}${size}`;
+}
+
+export function createSlowSpans({
+  now = () => performance.now(),
+  capacity = SPAN_RING_CAPACITY,
+  minMs = SPAN_RING_MIN_MS,
+  slowMs = SPAN_SLOW_MS,
+  log = () => {},
+} = {}) {
+  const ring = [];
+  let sink = log;
+
+  function complete(span) {
+    span.end = now();
+    span.ms = span.end - span.start;
+    if (span.ms >= minMs) {
+      ring.push({ label: span.label, start: span.start, end: span.end, ms: span.ms, phases: span.phases, size: span.size });
+      if (ring.length > capacity) ring.shift();
+    }
+    if (span.ms >= slowMs) {
+      try {
+        sink(`[slow-op] ${formatSpan(span)}`);
+      } catch {
+        /* logging must not fail the call */
+      }
+    }
+  }
+
+  return {
+    setLog(next) {
+      sink = typeof next === 'function' ? next : () => {};
+    },
+    /** Runs `fn` inside a span; markPhase/annotateSpan inside it attach to this span. */
+    async trace(label, fn) {
+      const start = now();
+      const span = { label: String(label), start, mark: start, now, phases: [], size: undefined };
+      try {
+        return await current.run(span, fn);
+      } finally {
+        complete(span);
+      }
+    },
+    /** Completed spans overlapping [from, to], longest overlap first. */
+    overlapping(from, to, limit = 3) {
+      return ring
+        .map((span) => ({ span, overlap: Math.min(span.end, to) - Math.max(span.start, from) }))
+        .filter((row) => row.overlap > 0)
+        .sort((a, b) => b.overlap - a.overlap || b.span.end - a.span.end)
+        .slice(0, limit)
+        .map((row) => row.span);
+    },
+    /** One-line description of the spans overlapping a stall window ('' when none). */
+    describe(from, to, limit = 3) {
+      const spans = this.overlapping(from, to, limit);
+      return spans.length ? `spans: ${spans.map((span) => formatSpan({ ...span })).join('; ')}` : '';
+    },
+    get recent() {
+      return ring.slice();
+    },
+  };
+}
+
+/** Process-wide recorder; the daemon points its log at daemon.log. */
+export const slowSpans = createSlowSpans();

package/src/runtime/shared/statusline/statusline-segments.mjs

@@ -76,9 +76,32 @@ export function shellJobsStatus({ clientHostPid, sessionId } = {}) {
       _shellJobsRefreshInFlight.delete(ownerPid);
     });
   }
-  const value = cached?.value || EMPTY_SHELL_JOBS;
-  if (!scoped) return value;
-  return (scope && value.sessions?.[scope]) || EMPTY_SHELL_JOBS_SESSION;
+  const own = cached?.value || EMPTY_SHELL_JOBS;
+  // Session buckets are not pid-scoped, so they come from the freshest scan of
+  // ANY owner. Reading them from this owner's own slot made the list follow
+  // that slot's age: an owner polled again after its entry was evicted (or
+  // went stale) answered with "no sessions", and the finished shells vanished
+  // until the next poll brought them back.
+  const sessions = freshestShellJobsSessions() ?? own.sessions;
+  if (!scoped) return sessions === own.sessions ? own : { ...own, sessions };
+  return (scope && sessions?.[scope]) || EMPTY_SHELL_JOBS_SESSION;
+}
+
+// Awaited fresh scan for pollers that own their cadence (desktop): the result
+// reflects the disk at call time instead of the previous poll. The CLI render
+// path keeps using the cache-only shellJobsStatus.
+export async function shellJobsStatusFresh({ clientHostPid } = {}) {
+  const ownerPid = positiveInt(clientHostPid);
+  if (!ownerPid) return EMPTY_SHELL_JOBS;
+  return refreshShellJobsStatus(ownerPid);
+}
+
+function freshestShellJobsSessions() {
+  let freshest = null;
+  for (const entry of _shellJobsSegmentCache.values()) {
+    if (!freshest || entry.at >= freshest.at) freshest = entry;
+  }
+  return freshest?.value.sessions;
 }
 
 // Memory cycle L2 segment source. The daemon-hosted memory runtime writes
@@ -142,7 +165,7 @@ async function refreshShellJobsStatus(ownerPid) {
       names = await readdir(dir);
     } catch {
       rememberShellJobs(ownerPid, value);
-      return;
+      return value;
     }
     const { ids, ownerByJob, doneIds } = listOpenShellJobs(names);
     let count = 0;
@@ -225,6 +248,7 @@ async function refreshShellJobsStatus(ownerPid) {
     value = EMPTY_SHELL_JOBS;
   }
   rememberShellJobs(ownerPid, value);
+  return value;
 }
 
 // Newest-first, capped ids of job records with no `.done` marker, plus the

package/src/runtime/shared/tool-card-model/card-header.mjs

@@ -5,7 +5,8 @@
 import { formatToolActionHeader, toolLoadingTargets } from '../tool-surface.mjs';
 import { agentActionSummary, agentActionTitle, agentResponseTitle, isAgentTool } from './agent-surface.mjs';
 import { backgroundTaskActionTitle, backgroundTaskResultTitle, taskControlTitle } from './background-task.mjs';
-import { toolSearchLoadedSummary } from './generic-detail.mjs';
+import { bridgeDescribedToolNames, toolSearchLoadedSummary } from './generic-detail.mjs';
+import { displayToolSearchTarget } from '../tool-primitives.mjs';
 import { safeInlineText } from './inline-text.mjs';
 import { shellHeader } from './shell-surface.mjs';
 
@@ -20,6 +21,10 @@ function headerLabel(base, surface, display, status, detail) {
   }
   if (display.isBackgroundMetadataResult) return backgroundTaskActionTitle(normalizedName, display.backgroundMeta);
   if (isShellSurface) return shellHeader(status.shellStatus, groupCount, parsedArgs?.verifyShell === true);
+  // Bridge load_tool describes definitions; it never loads a tool.
+  const described =
+    normalizedName === 'load_tool' && !headerPending ? bridgeDescribedToolNames(display.displayedResultText) : null;
+  if (described) return described.length ? `Described ${described.map(displayToolSearchTarget).join(', ')}` : 'Described';
   return (
     (isAgentTool(normalizedName) ? agentActionTitle(parsedArgs, display.displayedResultText) : '') ||
     formatToolActionHeader(name, args, {

package/src/runtime/shared/tool-card-model/generic-detail.mjs

@@ -51,6 +51,34 @@ export function genericCompletedDetail({ normalizedName, label, hasResult, first
   return '';
 }
 
+const uniqueToolNames = (names) => [
+  ...new Set((Array.isArray(names) ? names : []).map((name) => String(name || '').trim()).filter(Boolean)),
+];
+
+/**
+ * What a bridge load_tool result described, missed and blocked; null for a
+ * loader result (or anything that is not a describe result).
+ */
+export function bridgeDescribeResult(resultText) {
+  let parsed;
+  try {
+    parsed = JSON.parse(String(resultText || ''));
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed?.entries)) return null;
+  return {
+    described: uniqueToolNames(parsed.entries.map((entry) => entry?.name)),
+    missing: uniqueToolNames(parsed.missing),
+    blocked: uniqueToolNames((Array.isArray(parsed.blocked) ? parsed.blocked : []).map((entry) => entry?.name)),
+  };
+}
+
+/** Names a bridge load_tool result described, or null for a loader result. */
+export function bridgeDescribedToolNames(resultText) {
+  return bridgeDescribeResult(resultText)?.described ?? null;
+}
+
 export function toolSearchLoadedSummary(resultText) {
   let parsed;
   try {
@@ -61,13 +89,19 @@ export function toolSearchLoadedSummary(resultText) {
     const already = /^Already active:\s*(.+)$/m.exec(text)?.[1] || '';
     return [...(loaded ? [`Loaded: ${loaded}`] : []), ...(already ? [`Already active: ${already}`] : [])].join(' · ');
   }
+  // Bridge describe result: nothing was loaded; report what was not described.
+  const describe = bridgeDescribeResult(resultText);
+  if (describe) {
+    const { missing, blocked } = describe;
+    return [
+      ...(missing.length ? [`Missing: ${missing.join(', ')}`] : []),
+      ...(blocked.length ? [`Blocked: ${blocked.join(', ')}`] : []),
+    ].join(' · ');
+  }
   const tools = parsed?.selected?.tools;
   if (!tools || typeof tools !== 'object') return '';
-  const uniqueNames = (names) => [
-    ...new Set((Array.isArray(names) ? names : []).map((name) => String(name || '').trim()).filter(Boolean)),
-  ];
-  const loaded = uniqueNames(tools.added);
-  const already = uniqueNames(tools.already);
+  const loaded = uniqueToolNames(tools.added);
+  const already = uniqueToolNames(tools.already);
   return [
     ...(loaded.length ? [`Loaded: ${loaded.join(', ')}`] : []),
     ...(already.length ? [`Already active: ${already.join(', ')}`] : []),

package/src/runtime/shared/tool-card-model.mjs

@@ -23,7 +23,7 @@
  *   tool-card-model/card-header.mjs      — header label + arg summary
  */
 import { formatToolSurface } from './tool-surface.mjs';
-import { pluralize } from './tool-primitives.mjs';
+import { pluralize, toolCallDisplayIdentity } from './tool-primitives.mjs';
 import { deriveAggregateCardModel } from './tool-card-model/aggregate-card.mjs';
 import { isShellTool } from './tool-card-model/shell-surface.mjs';
 import { SKILL_SURFACE_NAMES } from './tool-card-model/agent-surface.mjs';
@@ -77,6 +77,7 @@ export {
   resolveBackgroundTaskMeta,
 } from './tool-card-model/background-task.mjs';
 export {
+  bridgeDescribeResult,
   genericCompletedDetail,
   shouldPrefixSyncElapsed,
   toolSearchLoadedSummary,
@@ -95,7 +96,8 @@ export { pluralize as plural };
  * @param {object} options { truncate(text,width), maxResultChars }.
  */
 export function deriveToolCardModel(input = {}, options = {}) {
-  const base = readCardInput(input, options);
+  const identity = toolCallDisplayIdentity(input.name, input.args);
+  const base = readCardInput({ ...input, name: identity.name, args: identity.args }, options);
   if (base.aggregate) return deriveAggregateCardModel(base);
 
   const { label, summary, normalizedName, args: parsedArgs } = formatToolSurface(base.name, base.args);
@@ -115,6 +117,7 @@ export function deriveToolCardModel(input = {}, options = {}) {
   return {
     aggregate: false,
     ...commonCardFields(base, status.terminalStatus),
+    ...(identity.via ? { via: identity.via } : {}),
     labelText: header.labelText,
     summaryText: header.summaryText,
     headerFailureText: status.headerFailureText,

package/src/runtime/shared/tool-output-limit.mjs

@@ -22,6 +22,10 @@ export const RECALL_OUTPUT_MAX_BYTES = positiveEnvInt('MIXDOG_RECALL_OUTPUT_MAX_
 // github results after field reduction; the full response stays in a raw
 // artifact. Provisional: reduced pr.list/run.list pages measured ~2k tokens.
 export const GITHUB_OUTPUT_MAX_BYTES = positiveEnvInt('MIXDOG_GITHUB_OUTPUT_MAX_BYTES', 10 * 1024);
+// setup results are compact JSON (a provider index, a 25-row model page, minimal
+// status rows). The same figure is the setup inline-offload threshold, so one
+// result can no longer sit just under the 50KB default (a 34-model catalog did).
+export const SETUP_OUTPUT_MAX_BYTES = positiveEnvInt('MIXDOG_SETUP_OUTPUT_MAX_BYTES', 20 * 1024);
 
 function _prefixByBytes(value, maxBytes) {
   const text = String(value || '');

package/src/runtime/shared/tool-primitives.mjs

@@ -133,6 +133,19 @@ export function parseToolArgs(args) {
   return { value: args };
 }
 
+/**
+ * Display identity of a tool call. A call_tool bridge request shows the tool
+ * it runs, with `via: 'call_tool'`; the transcript keeps the wire call.
+ */
+export function toolCallDisplayIdentity(name, args) {
+  if (rawToolName(name) !== 'call_tool') return { name, args };
+  const parsed = parseToolArgs(args);
+  const target = typeof parsed?.name === 'string' ? parsed.name.trim() : '';
+  if (!target) return { name, args };
+  const targetArgs = parsed.arguments && typeof parsed.arguments === 'object' ? parsed.arguments : {};
+  return { name: target, args: targetArgs, via: 'call_tool' };
+}
+
 export function displayToolPath(path) {
   const text = String(path ?? '');
   return text.replace(/\\/g, '/').split('/').filter(Boolean).at(-1) || text;

package/src/runtime/shared/tool-result-summary.mjs

@@ -640,8 +640,14 @@ function summarizeAgentResult({ text, trimmed, translate }) {
 
 const summarizeGeneric = ({ text, translate }) => summarizeGenericResult(text, translate);
 
+const summarizeAskUserResult = ({ text }) => {
+  const answers = /^User has answered your questions:\s*(.*?)(?:\s*You can now continue with these answers in mind\.)?$/s.exec(String(text ?? '').trim());
+  return truncateSingleLine(answers ? answers[1] : String(text ?? '').trim(), AGENT_SURFACE_BRIEF_MAX) || null;
+};
+
 const TOOL_RESULT_SUMMARIZERS = new Map(
   [
+    [['ask_user'], summarizeAskUserResult],
     [['read', 'view_image', 'read_mcp_resource'], summarizeReadResult],
     [['apply_patch'], summarizePatchResult],
     [['grep'], summarizeGrepResult],
@@ -662,7 +668,8 @@ const TOOL_RESULT_SUMMARIZERS = new Map(
         'update_memory',
         'request_user_input',
         'update_plan',
-        'cwd',
+        'cwd', // legacy: old transcripts
+        'session',
         'list_mcp_resources',
         'list_mcp_resource_templates',
       ],

package/src/runtime/shared/tool-surface.mjs

@@ -144,11 +144,14 @@ export function displayToolName(name, args = {}) {
       return 'Visualize';
     case 'list_mcp_resources':
     case 'list_mcp_resource_templates':
-    case 'cwd':
+    case 'cwd': // legacy: old transcripts
+    case 'session':
     case 'setup':
       return 'Setup';
     case 'request_user_input':
       return 'Ask User';
+    case 'ask_user':
+      return 'Question';
     case 'update_plan':
       return 'Plan';
     case 'memory':
@@ -236,6 +239,14 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
       return summarizeGithub(a, max);
     case 'goal':
       return compactParts([String(a.action || ''), truncateToolText(a.objective, max)]);
+    case 'ask_user':
+      return truncateToolText(
+        (Array.isArray(a.questions) ? a.questions : [])
+          .map((q) => String(q?.header || q?.question || '').trim())
+          .filter(Boolean)
+          .join(', '),
+        max
+      );
     case 'list':
     case 'ls':
       if (Array.isArray(a.path) || Array.isArray(a.dir) || Array.isArray(a.cwd)) {
@@ -333,8 +344,12 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
     case 'list_mcp_resources':
     case 'list_mcp_resource_templates':
       return a.server ? `server "${truncateToolText(a.server, max)}"` : 'all servers';
-    case 'cwd':
-      return compactParts([String(a.action || a.type || ''), truncateToolText(firstText(a.path, a.cwd, a.dir), max)]);
+    case 'cwd': // legacy: old transcripts
+    case 'session':
+      return compactParts([
+        String(a.action || a.type || ''),
+        truncateToolText(firstText(a.title, a.path, a.cwd, a.dir), max),
+      ]);
     case 'setup':
       return compactParts([
         String(a.action || ''),

package/src/runtime/shared/tool-work-units.mjs

@@ -85,10 +85,12 @@ const TOOL_CATEGORY = new Map([
   ['visualize', 'Visualize'],
   ['list_mcp_resources', 'Setup'],
   ['list_mcp_resource_templates', 'Setup'],
-  ['cwd', 'Setup'],
+  ['cwd', 'Setup'], // legacy: old transcripts
+  ['session', 'Setup'],
   ['setup', 'Setup'],
   ['goal', 'Setup'],
   ['request_user_input', 'Setup'],
+  ['ask_user', 'Setup'],
   ['update_plan', 'Setup'],
   ['skill', 'Skill'],
   ['skill_execute', 'Skill'],
@@ -568,7 +570,7 @@ function gitStageUnit(a) {
 function cwdUnit(a) {
   const action = String(a.action || a.type || '').toLowerCase();
   // A bare `path` selects that Project even when action is omitted.
-  if (action === 'set' || (!action && a.path)) {
+  if (action === 'set' || action === 'set-project' || (!action && a.path)) {
     return unitDescriptor('Setup', {
       active: 'Selecting',
       done: 'Selected',
@@ -576,9 +578,41 @@ function cwdUnit(a) {
       effect: true,
     });
   }
-  if (action === 'list') {
+  if (action === 'list' || action === 'list-projects') {
     return unitDescriptor('Setup', { active: 'Listing', done: 'Listed', noun: 'project' });
   }
+  if (action === 'rename') {
+    return unitDescriptor('Setup', { active: 'Renaming', done: 'Renamed', noun: 'session', effect: true });
+  }
+  if (action === 'compact') {
+    return unitDescriptor('Setup', { active: 'Scheduling', done: 'Scheduled', noun: 'compaction', effect: true });
+  }
+  if (action === 'fork') {
+    return unitDescriptor('Setup', { active: 'Forking', done: 'Forked', noun: 'session', effect: true });
+  }
+  if (action === 'favorite' || action === 'archive') {
+    const off = a.value === false;
+    const [active, done] =
+      action === 'favorite'
+        ? off
+          ? ['Unfavoriting', 'Unfavorited']
+          : ['Favoriting', 'Favorited']
+        : off
+          ? ['Unarchiving', 'Unarchived']
+          : ['Archiving', 'Archived'];
+    return unitDescriptor('Setup', { active, done, noun: 'session', effect: true });
+  }
+  if (action.endsWith('-worktree') || action.endsWith('-worktrees')) {
+    return unitDescriptor('Setup', {
+      active: 'Managing',
+      done: 'Managed',
+      noun: 'worktree',
+      effect: !action.startsWith('list'),
+    });
+  }
+  if (action === 'status') {
+    return unitDescriptor('Setup', { active: 'Checking', done: 'Checked', noun: 'session' });
+  }
   return unitDescriptor('Setup', { active: 'Checking', done: 'Checked', noun: 'working directory', pluralNoun: 'working directories' });
 }
 
@@ -689,13 +723,15 @@ const TOOL_UNITS = new Map([
   ['use_skill', skillUnit],
   ['code_graph', codeGraphUnit],
   ['request_user_input', () => unitDescriptor('Setup', { active: 'Asking', done: 'Asked', noun: 'user' })],
+  ['ask_user', () => unitDescriptor('Setup', { active: 'Asking', done: 'Asked', noun: 'user' })],
   ['update_plan', () => unitDescriptor('Setup', { active: 'Updating', done: 'Updated', noun: 'plan' })],
   ['list_mcp_resources', () => unitDescriptor('Setup', { active: 'Listing', done: 'Listed', noun: 'MCP resource' })],
   [
     'list_mcp_resource_templates',
     () => unitDescriptor('Setup', { active: 'Listing', done: 'Listed', noun: 'MCP resource template' }),
   ],
-  ['cwd', cwdUnit],
+  ['cwd', cwdUnit], // legacy: old transcripts
+  ['session', cwdUnit],
 ]);
 
 function mcpUnit(name, a) {