mixdog 1.1.2 → 1.2.1

package/src/runtime/shared/skill-script-runtime.mjs

@@ -0,0 +1,264 @@
+// The interpreter a built-in skill's bundled scripts run on.
+//
+// `${MIXDOG_SKILL_DIR}` is a real directory every process can read, but the
+// pptx scripts import the runtime by relative path (../../../../runtime/...)
+// and its native dependencies (sharp, @napi-rs/canvas, pdf.js). A packaged
+// desktop keeps those only inside runtime.asar, which plain Node cannot open,
+// so `node "<dir>/scripts/x.mjs"` works from an npm install and fails there.
+//
+// So the daemon that runs the model's shells hands them its OWN runtime: a
+// per-installation directory, first on every model shell's PATH, holds
+// `mixdog-skill-node` launchers that run this process's executable (Electron
+// in node mode, or node) on src/skill-script-entry.mjs, which maps the script
+// back into the archive before importing it. Each daemon builds its own shell
+// env, so an SSH-remote or mobile session gets its execution host's runtime.
+// Launchers carry two paths and nothing else: no credentials, no daemon
+// identity.
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { writeFileAtomicSync } from './atomic-file.mjs';
+import { resolvePluginData } from './plugin-paths.mjs';
+
+/** This module's package root (src/runtime/shared → the package). */
+export const SKILL_SCRIPT_PACKAGE_ROOT = path.resolve(fileURLToPath(new URL('.', import.meta.url)), '..', '..', '..');
+
+function pathApi(platform) {
+  return platform === 'win32' ? path.win32 : path.posix;
+}
+
+/** The `…/runtime.asar` prefix of a location inside the runtime archive, or null. */
+export function archiveRootOf(location, platform = process.platform) {
+  const sep = platform === 'win32' ? '[\\\\/]' : '/';
+  const match = new RegExp(`^(.*?${sep}runtime\\.asar)(?=${sep}|$)`).exec(String(location || ''));
+  return match ? pathApi(platform).normalize(match[1]) : null;
+}
+
+/**
+ * The path a script must be imported from. A built-in skill's directory is
+ * handed out under `runtime.asar.unpacked` (skillExecutionDir), but its
+ * relative imports only resolve from the archive, so a script under the
+ * sidecar of the archive that holds this package maps back into it. Source
+ * trees and npm installs keep the real path (symlinks resolved, as the ESM
+ * loader resolves them for import.meta.url).
+ */
+export function canonicalSkillScriptPath(
+  target,
+  {
+    packageRoot = SKILL_SCRIPT_PACKAGE_ROOT,
+    platform = process.platform,
+    cwd = process.cwd(),
+    realpath = realpathSync,
+  } = {}
+) {
+  const api = pathApi(platform);
+  let location = api.resolve(cwd, String(target));
+  try {
+    location = realpath(location);
+  } catch {
+    // A missing script fails at import with its own path in the message.
+  }
+  const archive = archiveRootOf(packageRoot, platform);
+  if (!archive) return location;
+  const sidecar = `${archive}.unpacked${api.sep}`;
+  const fold = (value) => (platform === 'win32' ? value.replaceAll('/', '\\').toLowerCase() : value);
+  if (!fold(location).startsWith(fold(sidecar))) return location;
+  return `${archive}${api.sep}${location.slice(sidecar.length)}`;
+}
+
+/** The runtime this process would hand a skill script to. */
+export function skillScriptRuntime({
+  execPath = process.execPath,
+  versions = process.versions,
+  packageRoot = SKILL_SCRIPT_PACKAGE_ROOT,
+  platform = process.platform,
+} = {}) {
+  return {
+    platform,
+    interpreter: execPath,
+    // Electron's own version marker, not ELECTRON_RUN_AS_NODE: model shells
+    // scrub that variable, and a daemon may have inherited it without being
+    // Electron at all.
+    electron: Boolean(versions?.electron),
+    packageRoot,
+    entry: pathApi(platform).join(packageRoot, 'src', 'skill-script-entry.mjs'),
+  };
+}
+
+function batchQuote(value) {
+  return `"${String(value).replaceAll('%', '%%')}"`;
+}
+
+function posixQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+/**
+ * The command `${MIXDOG_SKILL_NODE}` renders to. It is the same word in every
+ * shell: model shells find it on PATH (withSkillLauncherPath), as the
+ * extensionless sh launcher (bash, sh, zsh, Git Bash) or as the .cmd beside
+ * it (cmd through PATHEXT on Windows). PowerShell model commands define a
+ * function of the same name first (renderPowerShellSkillFunction), which
+ * takes precedence over both.
+ */
+export const SKILL_LAUNCHER_COMMAND = 'mixdog-skill-node';
+
+/**
+ * sh launcher text. Electron node mode is set only inside the launcher, for
+ * the one child it execs; every argument and the exit code pass through.
+ */
+export function renderPosixSkillLauncher({ interpreter, entry, electron }) {
+  return `${[
+    '#!/bin/sh',
+    '# Mixdog skill-script launcher, generated for one installation. Do not edit.',
+    ...(electron ? ['ELECTRON_RUN_AS_NODE=1', 'export ELECTRON_RUN_AS_NODE'] : []),
+    `exec ${posixQuote(interpreter)} ${posixQuote(entry)} "$@"`,
+  ].join('\n')}\n`;
+}
+
+/** .cmd launcher text, same contract as the sh launcher. */
+export function renderWindowsSkillLauncher({ interpreter, entry, electron }) {
+  // cmd decodes a batch file in the console code page line by line, so a
+  // non-ASCII path needs UTF-8 for the lines after chcp; the caller's code
+  // page is restored before exit.
+  const unicode = /\P{ASCII}/u.test(`${interpreter}${entry}`);
+  return `${[
+    '@echo off',
+    'rem Mixdog skill-script launcher, generated for one installation. Do not edit.',
+    'setlocal EnableExtensions DisableDelayedExpansion',
+    ...(unicode
+      ? ['for /f "tokens=2 delims=:." %%C in (\'chcp\') do set "MIXDOG_SKILL_CP=%%C"', 'chcp 65001 >nul']
+      : []),
+    ...(electron ? ['set "ELECTRON_RUN_AS_NODE=1"'] : []),
+    `${batchQuote(interpreter)} ${batchQuote(entry)} %*`,
+    'set "MIXDOG_SKILL_EXIT=%ERRORLEVEL%"',
+    ...(unicode ? ['if defined MIXDOG_SKILL_CP chcp %MIXDOG_SKILL_CP% >nul'] : []),
+    'exit /b %MIXDOG_SKILL_EXIT%',
+  ].join('\r\n')}\r\n`;
+}
+
+/** Environment variable carrying a PowerShell caller's arguments to the entry. */
+export const SKILL_ARGV_ENV = 'MIXDOG_SKILL_ARGV';
+const SKILL_ARGV_TAG = 'mixdog1';
+
+function psQuote(value) {
+  // PowerShell also treats the typographic single quotes as quote characters.
+  return `'${String(value).replace(/['\u2018\u2019\u201a\u201b]/g, '$&$&')}'`;
+}
+
+/**
+ * One-line PowerShell definition of `mixdog-skill-node`, prepended to every
+ * PowerShell model command. Through PATH, PowerShell would reach the .cmd via
+ * `cmd.exe /c` with arguments it does not quote, so `'a&b'` ran `b`. The
+ * function runs this daemon's executable on the entry as a plain native
+ * command, so PowerShell's own native-command handling provides streaming,
+ * ordering, backpressure, line endings, `2>&1`/`2>$null`/`2>file`,
+ * `$LASTEXITCODE`, Ctrl-C and early stop. The caller's arguments never reach
+ * that command line: they travel in SKILL_ARGV_ENV (UTF-8 base64), because
+ * Windows PowerShell 5.1 drops empty native arguments and does not escape
+ * embedded double quotes. A failing script ends the command with its exit
+ * code (`exit`), because a PowerShell function cannot fail `$?` or the
+ * -Command exit code.
+ *
+ * SKILL_ARGV_ENV and (Electron daemons only) ELECTRON_RUN_AS_NODE are set on
+ * $env just for the call and restored in `finally`; the bootstrap deletes
+ * both before importing the script. Accepted tradeoff: while the call runs,
+ * a process a concurrent downstream pipeline stage starts can see them.
+ */
+export function renderPowerShellSkillFunction({ interpreter, entry, electron }) {
+  const names = [SKILL_ARGV_ENV, ...(electron ? ['ELECTRON_RUN_AS_NODE'] : [])];
+  const values = ['$__mxa', ...(electron ? ["'1'"] : [])];
+  const body = [
+    `$__mxa = '${SKILL_ARGV_TAG}'`,
+    "foreach ($__mxv in $args) { foreach ($__mxe in @($__mxv)) { if ($null -ne $__mxe) { $__mxa += ',' + [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes([string]$__mxe)) } } }",
+    names.map((name, i) => `$__mxo${i} = $env:${name}`).join('; '),
+    [
+      'try {',
+      ...names.map((name, i) => `$env:${name} = ${values[i]};`),
+      `& ${psQuote(interpreter)} ${psQuote(entry)}`,
+      '} finally {',
+      names.map((name, i) => `$env:${name} = $__mxo${i}`).join('; '),
+      '}',
+    ].join(' '),
+    'if ($LASTEXITCODE) { exit $LASTEXITCODE }',
+  ];
+  return `function ${SKILL_LAUNCHER_COMMAND} { ${body.join('; ')} }`;
+}
+
+/** The arguments a PowerShell caller sent through SKILL_ARGV_ENV, or null. */
+export function decodeSkillArgv(value) {
+  const text = typeof value === 'string' ? value : '';
+  if (!text.startsWith(SKILL_ARGV_TAG)) return null;
+  const rest = text.slice(SKILL_ARGV_TAG.length);
+  if (!rest) return [];
+  return rest
+    .slice(1)
+    .split(',')
+    .map((item) => Buffer.from(item, 'base64').toString('utf8'));
+}
+
+/** Launcher files of `runtime`: the sh script everywhere, plus the .cmd on Windows. */
+export function skillLauncherFiles(runtime) {
+  return [
+    { name: SKILL_LAUNCHER_COMMAND, content: renderPosixSkillLauncher(runtime) },
+    ...(runtime.platform === 'win32'
+      ? [{ name: `${SKILL_LAUNCHER_COMMAND}.cmd`, content: renderWindowsSkillLauncher(runtime) }]
+      : []),
+  ];
+}
+
+/** Private per-installation launcher directory under the data dir. */
+export function skillLauncherDir(runtime, dataDir = resolvePluginData()) {
+  const digest = createHash('sha256')
+    .update(JSON.stringify([runtime.platform, runtime.interpreter, runtime.entry, runtime.electron]))
+    .digest('hex')
+    .slice(0, 16);
+  return pathApi(runtime.platform).join(dataDir, 'skill-launchers', digest);
+}
+
+const ensuredDirs = new Set();
+
+/**
+ * Write (atomically) or refresh the launchers for `runtime`; returns their
+ * directory. A directory already verified by this process is only checked for
+ * presence, so the per-command shell env build stays a couple of stats.
+ */
+export function ensureSkillLauncherDir(runtime = skillScriptRuntime(), dataDir = resolvePluginData()) {
+  const dir = skillLauncherDir(runtime, dataDir);
+  const api = pathApi(runtime.platform);
+  const files = skillLauncherFiles(runtime);
+  if (ensuredDirs.has(dir) && files.every(({ name }) => existsSync(api.join(dir, name)))) return dir;
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  for (const { name, content } of files) {
+    const file = api.join(dir, name);
+    let current = null;
+    try {
+      current = readFileSync(file, 'utf8');
+    } catch {
+      // Not written yet.
+    }
+    if (current !== content) writeFileAtomicSync(file, content, { mode: 0o700 });
+  }
+  ensuredDirs.add(dir);
+  return dir;
+}
+
+/**
+ * `env` with this installation's launcher directory first on PATH. Only model
+ * shell environments call this; the daemon's own env, hooks and internal
+ * workers keep their PATH. The directory holds nothing but the launchers, so
+ * no existing command is shadowed.
+ */
+export function withSkillLauncherPath(env, { runtime = skillScriptRuntime(), dataDir = resolvePluginData() } = {}) {
+  const dir = ensureSkillLauncherDir(runtime, dataDir);
+  const delimiter = runtime.platform === 'win32' ? ';' : ':';
+  // Windows env keys are case-insensitive and usually spelled `Path`.
+  const key =
+    (runtime.platform === 'win32' ? Object.keys(env).find((name) => name.toUpperCase() === 'PATH') : null) || 'PATH';
+  const entries = String(env[key] || '')
+    .split(delimiter)
+    .filter((entry) => entry && entry !== dir);
+  env[key] = [dir, ...entries].join(delimiter);
+  return env;
+}

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

@@ -23,7 +23,13 @@ const SHELL_JOBS_SEGMENT_CACHE_MS = 1000;
 // Session buckets ride along with the owner-wide totals: one host process can
 // own many sessions (the desktop pools every pane's engine), so a pane must be
 // able to ask for ITS OWN jobs instead of the process aggregate.
-const EMPTY_SHELL_JOBS_SESSION = Object.freeze({ count: 0, elapsedLabel: '', jobs: Object.freeze([]) });
+const FINISHED_SHELL_JOB_TTL_MS = 30 * 60 * 1000;
+const EMPTY_SHELL_JOBS_SESSION = Object.freeze({
+  count: 0,
+  elapsedLabel: '',
+  jobs: Object.freeze([]),
+  finished: Object.freeze([]),
+});
 const EMPTY_SHELL_JOBS = Object.freeze({
   count: 0,
   elapsedLabel: '',
@@ -31,8 +37,20 @@ const EMPTY_SHELL_JOBS = Object.freeze({
   sessions: Object.freeze({}),
 });
 
-let _shellJobsSegmentCache = { ownerPid: 0, at: 0, value: EMPTY_SHELL_JOBS };
-let _shellJobsRefreshInFlight = false;
+// One entry per owner pid: a desktop host polls under whichever session frame
+// arrived last, so the owner can alternate between processes. A single shared
+// slot answered every switch with "no jobs" and made the job list flicker.
+const _shellJobsSegmentCache = new Map();
+const _shellJobsRefreshInFlight = new Set();
+const SHELL_JOBS_OWNER_CACHE_TTL_MS = 60_000;
+
+function rememberShellJobs(ownerPid, value) {
+  const at = Date.now();
+  for (const [pid, entry] of _shellJobsSegmentCache) {
+    if (at - entry.at > SHELL_JOBS_OWNER_CACHE_TTL_MS) _shellJobsSegmentCache.delete(pid);
+  }
+  _shellJobsSegmentCache.set(ownerPid, { at, value });
+}
 
 function dataDir() {
   return process.env.MIXDOG_DATA_DIR || DEFAULT_STANDALONE_DATA_DIR;
@@ -50,15 +68,15 @@ export function shellJobsStatus({ clientHostPid, sessionId } = {}) {
   const scope = String(sessionId ?? '').trim();
   if (!ownerPid) return scoped ? EMPTY_SHELL_JOBS_SESSION : EMPTY_SHELL_JOBS;
   const now = Date.now();
-  const sameOwner = _shellJobsSegmentCache.ownerPid === ownerPid;
-  const fresh = sameOwner && now - _shellJobsSegmentCache.at < SHELL_JOBS_SEGMENT_CACHE_MS;
-  if (!fresh && !_shellJobsRefreshInFlight) {
-    _shellJobsRefreshInFlight = true;
+  const cached = _shellJobsSegmentCache.get(ownerPid);
+  const fresh = cached && now - cached.at < SHELL_JOBS_SEGMENT_CACHE_MS;
+  if (!fresh && !_shellJobsRefreshInFlight.has(ownerPid)) {
+    _shellJobsRefreshInFlight.add(ownerPid);
     refreshShellJobsStatus(ownerPid).finally(() => {
-      _shellJobsRefreshInFlight = false;
+      _shellJobsRefreshInFlight.delete(ownerPid);
     });
   }
-  const value = sameOwner ? _shellJobsSegmentCache.value || EMPTY_SHELL_JOBS : EMPTY_SHELL_JOBS;
+  const value = cached?.value || EMPTY_SHELL_JOBS;
   if (!scoped) return value;
   return (scope && value.sessions?.[scope]) || EMPTY_SHELL_JOBS_SESSION;
 }
@@ -123,10 +141,10 @@ async function refreshShellJobsStatus(ownerPid) {
     try {
       names = await readdir(dir);
     } catch {
-      _shellJobsSegmentCache = { ownerPid, at: Date.now(), value };
+      rememberShellJobs(ownerPid, value);
       return;
     }
-    const { ids, ownerByJob } = listOpenShellJobs(names);
+    const { ids, ownerByJob, doneIds } = listOpenShellJobs(names);
     let count = 0;
     let oldestMs = Infinity;
     const jobs = [];
@@ -143,6 +161,10 @@ async function refreshShellJobsStatus(ownerPid) {
         continue;
       }
       if (!(await isShellJobAlive(detail, p, dir, id))) continue;
+      // A foreground command is awaited in its own tool card; listing it here
+      // made every short command flash in and out of the shell list. Only
+      // backgrounded jobs (including promoted ones) are background work.
+      if (detail?.foreground === true) continue;
       // Owner-wide totals stay this process's own; session buckets take every
       // live job regardless of which host published it.
       const ownedByThisHost = ownerByJob.get(id) === ownerPid;
@@ -162,12 +184,39 @@ async function refreshShellJobsStatus(ownerPid) {
       };
       if (ownedByThisHost) jobs.push(job);
       if (!owner) continue;
-      const bucket = bySession.get(owner) || { count: 0, oldestMs: Infinity, jobs: [] };
+      const bucket = bySession.get(owner) || { count: 0, oldestMs: Infinity, jobs: [], finished: [] };
       bucket.count += 1;
       if (jobMs < bucket.oldestMs) bucket.oldestMs = jobMs;
       bucket.jobs.push(job);
       bySession.set(owner, bucket);
     }
+    // Recently finished background jobs ride in their session bucket only;
+    // they never touch the running counts.
+    const finishedCutoff = Date.now() - FINISHED_SHELL_JOB_TTL_MS;
+    for (const id of doneIds) {
+      let detail;
+      try {
+        detail = JSON.parse(await readFile(join(dir, `${id}.json`), 'utf-8'));
+      } catch {
+        continue;
+      }
+      if (detail?.foreground === true) continue;
+      const owner = String(detail?.ownerSessionId ?? '').trim();
+      if (!owner) continue;
+      const finishedMs = Date.parse(detail?.finishedAt || detail?.recordedAt || '');
+      if (Number.isFinite(finishedMs) && finishedMs < finishedCutoff) continue;
+      const bucket = bySession.get(owner) || { count: 0, oldestMs: Infinity, jobs: [], finished: [] };
+      bucket.finished.push({
+        taskId: id,
+        command: String(detail?.command || '').trim(),
+        cwd: String(detail?.cwd || '').trim(),
+        startedAt: detail?.startedAt || null,
+        status: String(detail?.status || ''),
+        exitCode: Number.isInteger(detail?.exitCode) ? detail.exitCode : null,
+        finishedAt: detail?.finishedAt || detail?.recordedAt || null,
+      });
+      bySession.set(owner, bucket);
+    }
     // A desktop pane's job lands in a session bucket while the owner-wide
     // count stays 0 (its publisher is a shard, not this host), so an empty
     // aggregate must NOT discard the session buckets.
@@ -175,7 +224,7 @@ async function refreshShellJobsStatus(ownerPid) {
   } catch {
     value = EMPTY_SHELL_JOBS;
   }
-  _shellJobsSegmentCache = { ownerPid, at: Date.now(), value };
+  rememberShellJobs(ownerPid, value);
 }
 
 // Newest-first, capped ids of job records with no `.done` marker, plus the
@@ -209,7 +258,11 @@ function listOpenShellJobs(names) {
     // the per-refresh cap doubles with it; a live (non-.done) record set is
     // a handful in practice and terminal ones age out on their own.
     .slice(0, 60);
-  return { ids, ownerByJob };
+  const doneIds = [...done]
+    .filter((id) => names.includes(`${id}.json`))
+    .sort((a, b) => jobStampMs(b) - jobStampMs(a))
+    .slice(0, 30);
+  return { ids, ownerByJob, doneIds };
 }
 
 function summarizeShellJobs({ count, oldestMs, jobs, bySession }) {
@@ -221,6 +274,7 @@ function summarizeShellJobs({ count, oldestMs, jobs, bySession }) {
       count: bucket.count,
       elapsedLabel: Number.isFinite(bucket.oldestMs) ? formatElapsed(now - bucket.oldestMs) : '',
       jobs: bucket.jobs,
+      finished: bucket.finished,
     };
   }
   return { count, elapsedLabel, jobs, sessions };

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

@@ -22,8 +22,39 @@ function rawToolName(name) {
   return String(name || 'tool').replace(/^functions\./, '');
 }
 
-export function parseMcpToolName(name) {
-  const text = rawToolName(name);
+// Tool names shortened to fit provider limits -> their real server and tool,
+// recorded when the name is built so name-only callers in this process
+// resolve them. Bounded; the oldest entries go first.
+const MCP_TOOL_IDENTITY_MAX = 4096;
+const mcpToolIdentities = new Map();
+
+export function rememberMcpToolIdentity(name, server, tool) {
+  const key = String(name || '');
+  if (!key) return;
+  mcpToolIdentities.delete(key);
+  mcpToolIdentities.set(key, { server: String(server || ''), tool: String(tool || '') });
+  if (mcpToolIdentities.size > MCP_TOOL_IDENTITY_MAX) mcpToolIdentities.delete(mcpToolIdentities.keys().next().value);
+}
+
+/** Server and tool of a shortened MCP tool name, when this process built it. */
+export function knownMcpToolIdentity(name) {
+  const known = mcpToolIdentities.get(rawToolName(name));
+  return known ? { ...known } : null;
+}
+
+/** `{ server, tool }` of an MCP tool, or null. Takes a tool definition (its
+ *  `mcpServerName`/`mcpToolName` metadata wins) or a name (a recorded
+ *  shortened name first, else the `mcp__<server>__<tool>` form). */
+export function parseMcpToolName(nameOrTool) {
+  if (nameOrTool && typeof nameOrTool === 'object') {
+    const server = String(nameOrTool.mcpServerName || '').trim();
+    const parsed = parseMcpToolName(nameOrTool.name);
+    if (!server) return parsed;
+    return { server, tool: String(nameOrTool.mcpToolName || '') || parsed?.tool || '' };
+  }
+  const text = rawToolName(nameOrTool);
+  const known = mcpToolIdentities.get(text);
+  if (known) return { ...known };
   const match = /^mcp__(.+?)__(.+)$/.exec(text);
   if (!match) return null;
   return { server: match[1], tool: match[2] };
@@ -169,6 +200,8 @@ export function toolSearchDisplayLabel(args = {}) {
 export function displayToolSearchTarget(value) {
   const text = String(value || '').trim();
   if (/^skill:/i.test(text)) return text.slice('skill:'.length);
+  const known = knownMcpToolIdentity(text);
+  if (known) return `${known.server}.${known.tool}`;
   const mcp = /^mcp__(.*?)__(.+)$/.exec(text);
   if (mcp) return `${mcp[1]}.${mcp[2]}`;
   return stripToolPrefix(text);

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

@@ -140,6 +140,8 @@ export function displayToolName(name, args = {}) {
       return 'Media';
     case 'tidy':
       return 'Tidy';
+    case 'visualize':
+      return 'Visualize';
     case 'list_mcp_resources':
     case 'list_mcp_resource_templates':
     case 'cwd':
@@ -310,6 +312,11 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
     }
     case 'terminal':
       return compactParts([String(a.action || ''), a.tab ? `tab ${a.tab}` : '']);
+    case 'visualize': {
+      const input = a.input && typeof a.input === 'object' ? a.input : {};
+      const targets = Array.isArray(input.targets) ? input.targets.map(String).join(', ') : '';
+      return compactParts([String(a.action || ''), targets || String(input.tab || '')]);
+    }
     case 'office':
       return compactParts([String(a.action || ''), pathOrId(a.path, a.session, max)]);
     case 'media':

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

@@ -82,6 +82,7 @@ const TOOL_CATEGORY = new Map([
   ['office', 'Office'],
   ['media', 'Media'],
   ['tidy', 'Tidy'],
+  ['visualize', 'Visualize'],
   ['list_mcp_resources', 'Setup'],
   ['list_mcp_resource_templates', 'Setup'],
   ['cwd', 'Setup'],
@@ -124,6 +125,7 @@ const CATEGORY_COPY = new Map([
   ['Office', { active: 'Editing', done: 'Edited', noun: 'document action' }],
   ['Media', { active: 'Generating', done: 'Generated', noun: 'media action' }],
   ['Tidy', { active: 'Tidying', done: 'Tidied', noun: 'cleanup pass' }],
+  ['Visualize', { active: 'Showing', done: 'Showed', noun: 'artifact' }],
   ['Other', { active: 'Calling', done: 'Called', noun: 'tool' }],
 ]);
 
@@ -338,6 +340,17 @@ function officeUnit(a) {
   return unitDescriptor('Office', { count: 1, active, done, noun: 'document action', effect: true });
 }
 
+function visualizeUnit(a) {
+  const action = String(a.action || '').toLowerCase();
+  if (action === 'capture') return unitDescriptor('Visualize', { count: 1, active: 'Capturing', done: 'Captured', noun: 'screenshot' });
+  if (action === 'export') return unitDescriptor('Visualize', { count: 1, active: 'Exporting', done: 'Exported', noun: 'file' });
+  if (action === 'annotate') return unitDescriptor('Visualize', { count: 1, active: 'Marking', done: 'Marked', noun: 'annotation' });
+  if (action === 'check') return unitDescriptor('Visualize', { count: 1, active: 'Checking', done: 'Checked', noun: 'page' });
+  if (action === 'inspect') return unitDescriptor('Visualize', { count: 1, active: 'Inspecting', done: 'Inspected', noun: 'page' });
+  if (action === 'close') return unitDescriptor('Visualize', { count: 1, active: 'Closing', done: 'Closed', noun: 'tab' });
+  return unitDescriptor('Visualize', { count: 1, active: 'Showing', done: 'Showed', noun: 'artifact' });
+}
+
 function terminalUnit(a) {
   return String(a.action || '').toLowerCase() === 'list'
     ? unitDescriptor('Terminal', { count: 1, active: 'Listing', done: 'Listed', noun: 'terminal tab' })
@@ -642,6 +655,7 @@ const TOOL_UNITS = new Map([
   ['setup', setupUnit],
   ['media', mediaUnit],
   ['tidy', tidyUnit],
+  ['visualize', visualizeUnit],
   ['fetch', fetchUnit],
   ['recall', memoryReadUnit],
   ['recall_memory', memoryReadUnit],

package/src/runtime/shared/transcript-metadata.mjs

@@ -21,14 +21,29 @@ export function createTranscriptRouteMetadata(session, route = {}, at = Date.now
   return { at, ...transcriptRouteMetadataFields({ modelId, model, provider, agent }) };
 }
 
+/** A new stable message id (`meta.transcript.messageId`). */
+export function newTranscriptMessageId() {
+  return `msg_${globalThis.crypto.randomUUID().replaceAll('-', '')}`;
+}
+
+export const stableMessageId = (value) => (typeof value === 'string' && value ? value : newTranscriptMessageId());
+
+// Every persisted prompt/reply carries a stable `messageId` from creation on.
+// Compaction rewrites copy `meta`, so the id survives them; the display-only
+// compaction archive and a live view tell dropped rows from rewritten ones
+// by it. A surface that drew the row first passes its id in.
 export function persistedUserTranscriptMetadata(value) {
   if (!value || typeof value !== 'object') return null;
   return {
+    messageId: stableMessageId(value.messageId),
     ...(Number.isFinite(Number(value.at)) ? { at: Number(value.at) } : {}),
     ...transcriptRouteMetadataFields(value),
     ...(typeof value.sender === 'string' && value.sender ? { sender: value.sender } : {}),
     // The device that submitted the prompt (host-stamped display name).
     ...(typeof value.device === 'string' && value.device ? { device: value.device } : {}),
+    // The turn's change-record key (the outer prompt id), so a restored user
+    // row still addresses its turn's Undo/Reapply.
+    ...(typeof value.checkpointId === 'string' && value.checkpointId ? { checkpointId: value.checkpointId } : {}),
   };
 }
 
@@ -37,5 +52,6 @@ export function persistedAssistantTranscriptMetadata(value, fallbackAt = Date.no
   const candidateAt = Number(value.assistantAt);
   const assistantAt = Number.isFinite(candidateAt) && candidateAt > 0 ? candidateAt : fallbackAt;
   value.assistantAt = assistantAt;
-  return { at: assistantAt, ...transcriptRouteMetadataFields(value) };
+  value.assistantMessageId = stableMessageId(value.assistantMessageId);
+  return { messageId: value.assistantMessageId, at: assistantAt, ...transcriptRouteMetadataFields(value) };
 }