granttap-mcp 0.8.2 → 0.8.3

package/README.md

@@ -205,6 +205,18 @@ The bounded encrypted protocol preserves:
 An optional bounded `errorClass` may describe an error category. Full tool
 error payloads are not copied into usage telemetry by default.
 
+A shell call is named by the command it ran — `npm`, `git`, `xcodebuild` —
+with the tool that ran it kept beside the name, so the usage screen can say
+which tool was slow or failing rather than listing every call as Bash.
+
+Machine load attributes to an agent everything the agent started — its
+shells, its node workers, the build a shell ran — found through the process
+tree, and names the heaviest kinds of process it runs (`node` ×19, `zsh` ×3)
+so the phone can say what an agent is doing, not only that it is. The
+executable path and the command line are read separately and joined by pid,
+because a path with a space in it (`~/Library/Application Support/Claude/…`)
+cannot be recovered from a command line split on whitespace.
+
 ### One computer, whatever the network calls it
 
 The Mesh keys a computer by an identity written down once, on first use, in
@@ -229,11 +241,17 @@ Mesh show it. A `UserPromptSubmit` hook, installed beside the approval hook by
 `granttap setup`, adds the unread journal to the next prompt of the live
 session together with the Mesh brief — the other live Tasks in the Project,
 who is in the same file or module, the other side of the repository, and any
-question still unanswered — and names the MCP resource
-`granttap://mesh/{capability}/map`, one page of markdown with the whole
-Project: Tasks, who edits which module, the other side of each repository,
-dependencies, and what just happened. Background runs themselves receive
-nothing from the hook; the journal is kept for the session a person is in.
+question still unanswered — and names the MCP resource `granttap://mesh/map`,
+one page of markdown with the whole Project: Tasks, who edits which module,
+the other side of each repository, dependencies, and what just happened. That
+resource is listed, because Claude Code reads only listed resources, and it is
+scoped without a token: Claude Code starts one MCP server per chat and hands
+it the chat's id in `CLAUDE_CODE_SESSION_ID`, which nothing said over the
+connection can change. `granttap://mesh/current` serves the same chat's scoped
+state there. Other providers keep the tokened `granttap://mesh/{capability}`
+and `…/map` forms from an attributed `notify`. Background runs themselves
+receive nothing from the hook; the journal is kept for the session a person
+is in.
 
 ### Tool versions and updates from the phone
 

package/apps/bridge/src/machine-load/index.ts

@@ -84,6 +84,7 @@ export function buildMachineLoad(input: {
         processes: input.processes[agent]?.processes ?? 0,
         cpuPercent: input.processes[agent]?.cpuPercent ?? 0,
         memoryBytes: input.processes[agent]?.memoryBytes ?? 0,
+        topProcesses: input.processes[agent]?.groups ?? [],
         sessions: sessionsByAgent.get(agent) ?? 0,
         scanMs: scanCost[agent]?.durationMs ?? 0,
         tokensRecent: tokensByAgent.get(agent) ?? 0,

package/apps/bridge/src/machine-load/process-sampler.ts

@@ -5,17 +5,40 @@ const run = promisify(execFile);
 
 export type ProcessRow = {
   pid: number;
+  /** The parent, so a shell or a node worker an agent spawned counts as that agent's. */
+  ppid?: number;
   cpuPercent: number;
   rssBytes: number;
+  /** The full command line, arguments included. */
   command: string;
+  /**
+   * The executable's own path, from `ps -o comm`. A path with a space in it —
+   * `~/Library/Application Support/Claude/…/claude` — cannot be recovered from
+   * the command line by splitting on whitespace, which is how the Claude the
+   * desktop app runs went unattributed for as long as it did.
+   */
+  executable?: string;
+};
+
+/** One kind of process an agent runs, by executable: `node` ×43, `zsh` ×10. */
+export type ProcessGroup = {
+  name: string;
+  count: number;
+  cpuPercent: number;
+  memoryBytes: number;
 };
 
 export type AgentProcessLoad = {
   processes: number;
   cpuPercent: number;
   memoryBytes: number;
+  /** The heaviest kinds of process, so "Claude" can be read as what it runs. */
+  groups?: ProcessGroup[];
 };
 
+const MAX_GROUPS = 8;
+const INTERPRETERS = /^(node|bun|deno|python3?|npx)$/;
+
 const AGENT_EXECUTABLES: ReadonlyArray<readonly [string, readonly string[]]> = [
   ["claude", ["claude"]],
   ["codex", ["codex"]],
@@ -23,10 +46,21 @@ const AGENT_EXECUTABLES: ReadonlyArray<readonly [string, readonly string[]]> = [
   ["grok", ["grok"]],
 ];
 
-/** Parse macOS ps output while ignoring headings and malformed rows. */
+/** Parse `pid [ppid] pcpu rss remainder` lines while ignoring headings and malformed rows. */
 export function parsePsOutput(stdout: string): ProcessRow[] {
   const rows: ProcessRow[] = [];
   for (const line of stdout.split("\n")) {
+    const withParent = line.trim().match(/^(\d+)\s+(\d+)\s+([\d.]+)\s+(\d+)\s+(.+)$/);
+    if (withParent) {
+      rows.push({
+        pid: Number(withParent[1]),
+        ppid: Number(withParent[2]),
+        cpuPercent: Number(withParent[3]),
+        rssBytes: Number(withParent[4]) * 1024,
+        command: withParent[5]!,
+      });
+      continue;
+    }
     const match = line.trim().match(/^(\d+)\s+([\d.]+)\s+(\d+)\s+(.+)$/);
     if (!match) continue;
     rows.push({
@@ -39,23 +73,70 @@ export function parsePsOutput(stdout: string): ProcessRow[] {
   return rows;
 }
 
+/** Parse `pid remainder` lines into a map, for a second listing joined by pid. */
+export function parsePidListing(stdout: string): Map<number, string> {
+  const out = new Map<number, string>();
+  for (const line of stdout.split("\n")) {
+    const match = line.trim().match(/^(\d+)\s+(.+)$/);
+    if (match) out.set(Number(match[1]), match[2]!);
+  }
+  return out;
+}
+
+/** Rows from the executable listing, with each command line joined in by pid. */
+export function withCommandLines(rows: readonly ProcessRow[], commands: ReadonlyMap<number, string>): ProcessRow[] {
+  return rows.map((row) => ({
+    ...row,
+    executable: row.executable ?? row.command,
+    command: commands.get(row.pid) ?? row.command,
+  }));
+}
+
+/** The executable path of a row: stated, else the command line's first word. */
+export function executableOf(row: Pick<ProcessRow, "command" | "executable">): string {
+  return row.executable ?? (row.command.trim().split(/\s+/)[0] ?? "");
+}
+
+function leafOf(path: string): string {
+  return path.split("/").pop() ?? path;
+}
+
+/** What to call a process: the executable's own name, wherever it lives. */
+export function processGroupName(row: Pick<ProcessRow, "command" | "executable"> | string): string {
+  const executable = typeof row === "string" ? row : executableOf(row);
+  // npm retitles itself "npm run test:coverage"; the kind of process is npm.
+  const leaf = leafOf(executable).replace(/^-/, "").split(/\s+/)[0] ?? "";
+  return (leaf || "process").slice(0, 64);
+}
+
 /** Exclude desktop chat apps and framework helpers that collide with CLI names. */
-function isDesktopAppHelper(command: string): boolean {
-  if (command.includes("/Contents/Resources/")) return false;
-  if (command.includes(".app/Contents/Frameworks/")) return true;
-  return /\/(Claude|ChatGPT)\.app\//.test(command);
+function isDesktopAppHelper(path: string): boolean {
+  if (path.includes("/Contents/Resources/")) return false;
+  if (path.includes(".app/Contents/Frameworks/")) return true;
+  return /\/(Claude|ChatGPT)\.app\//.test(path);
+}
+
+/** The arguments after the executable, when the command line repeats it. */
+function argumentsOf(row: Pick<ProcessRow, "command" | "executable">): string[] {
+  const command = row.command.trim();
+  const executable = row.executable?.trim();
+  if (executable && command.startsWith(executable)) {
+    return command.slice(executable.length).trim().split(/\s+/).filter(Boolean);
+  }
+  return command.split(/\s+/).slice(1);
 }
 
-function agentForCommand(command: string): string | undefined {
-  const words = command.trim().split(/\s+/);
-  const program = words[0] ?? "";
-  const leaf = program.split("/").pop()?.toLowerCase() ?? "";
-  if (!leaf || isDesktopAppHelper(command)) return undefined;
+function agentForRow(row: Pick<ProcessRow, "command" | "executable">): string | undefined {
+  const executable = executableOf(row);
+  const leaf = leafOf(executable).toLowerCase();
+  if (!leaf || isDesktopAppHelper(executable) || isDesktopAppHelper(row.command)) return undefined;
   for (const [agent, executables] of AGENT_EXECUTABLES) {
     if (executables.includes(leaf)) return agent;
   }
-  if (/^(node|bun|deno|python3?|npx)$/.test(leaf)) {
-    const scriptLeaf = (words[1] ?? "").split("/").pop()?.toLowerCase() ?? "";
+  if (INTERPRETERS.test(leaf)) {
+    const script = argumentsOf(row)[0] ?? "";
+    // `codex.js` is codex; the extension is how node was asked, not what ran.
+    const scriptLeaf = leafOf(script).toLowerCase().replace(/\.(m?js|cjs|ts|py)$/, "");
     for (const [agent, executables] of AGENT_EXECUTABLES) {
       if (executables.includes(scriptLeaf)) return agent;
     }
@@ -63,32 +144,83 @@ function agentForCommand(command: string): string | undefined {
   return undefined;
 }
 
+/**
+ * Which agent a process belongs to: the one it is, or the one that spawned
+ * it. A Bash call, a node worker, a search — an agent's work is mostly done
+ * by its children, and counting only the agent binary itself read "Claude:
+ * one process" while forty of its children were the load.
+ */
+function attributeByAncestry(rows: readonly ProcessRow[]): Map<number, string> {
+  const direct = new Map<number, string | undefined>();
+  const parent = new Map<number, number>();
+  for (const row of rows) {
+    direct.set(row.pid, agentForRow(row));
+    if (row.ppid != null && row.ppid !== row.pid) parent.set(row.pid, row.ppid);
+  }
+  const resolved = new Map<number, string>();
+  for (const row of rows) {
+    let pid: number | undefined = row.pid;
+    const chain: number[] = [];
+    let agent: string | undefined;
+    for (let depth = 0; pid != null && depth < 32; depth += 1) {
+      const known = resolved.get(pid) ?? direct.get(pid);
+      if (known) { agent = known; break; }
+      chain.push(pid);
+      pid = parent.get(pid);
+    }
+    if (!agent) continue;
+    for (const member of chain) resolved.set(member, agent);
+    resolved.set(row.pid, agent);
+  }
+  return resolved;
+}
+
 export function attributeProcesses(
   rows: readonly ProcessRow[],
 ): Record<string, AgentProcessLoad> {
   const byAgent: Record<string, AgentProcessLoad> = {};
+  const groupsByAgent: Record<string, Map<string, ProcessGroup>> = {};
+  const owners = attributeByAncestry(rows);
   for (const row of rows) {
-    const agent = agentForCommand(row.command);
+    const agent = owners.get(row.pid);
     if (!agent) continue;
-    const current = byAgent[agent] ?? { processes: 0, cpuPercent: 0, memoryBytes: 0 };
+    const current = byAgent[agent] ?? { processes: 0, cpuPercent: 0, memoryBytes: 0, groups: [] };
     byAgent[agent] = {
       processes: current.processes + 1,
       cpuPercent: Math.round((current.cpuPercent + row.cpuPercent) * 100) / 100,
       memoryBytes: current.memoryBytes + row.rssBytes,
+      groups: [],
     };
+    const groups = (groupsByAgent[agent] ??= new Map());
+    const name = processGroupName(row);
+    const group = groups.get(name) ?? { name, count: 0, cpuPercent: 0, memoryBytes: 0 };
+    groups.set(name, {
+      name,
+      count: group.count + 1,
+      cpuPercent: Math.round((group.cpuPercent + row.cpuPercent) * 100) / 100,
+      memoryBytes: group.memoryBytes + row.rssBytes,
+    });
+  }
+  for (const [agent, groups] of Object.entries(groupsByAgent)) {
+    byAgent[agent]!.groups = [...groups.values()]
+      .sort((a, b) => (b.cpuPercent - a.cpuPercent) || (b.memoryBytes - a.memoryBytes) || (b.count - a.count))
+      .slice(0, MAX_GROUPS);
   }
   return byAgent;
 }
 
-/** Read process rows asynchronously so sampling cannot starve the relay socket. */
+/**
+ * Read process rows asynchronously so sampling cannot starve the relay socket.
+ * Two listings: the executable path on its own, then the command line, joined
+ * by pid — one listing cannot carry both once a path has a space in it.
+ */
 export async function sampleProcessRows(): Promise<ProcessRow[]> {
   try {
-    const { stdout } = await run("ps", ["-Ao", "pid=,pcpu=,rss=,command="], {
-      encoding: "utf8",
-      maxBuffer: 4_000_000,
-      timeout: 5_000,
-    });
-    return parsePsOutput(String(stdout));
+    const [{ stdout: executables }, { stdout: commands }] = await Promise.all([
+      run("ps", ["-Ao", "pid=,ppid=,pcpu=,rss=,comm="], { encoding: "utf8", maxBuffer: 4_000_000, timeout: 5_000 }),
+      run("ps", ["-Ao", "pid=,command="], { encoding: "utf8", maxBuffer: 4_000_000, timeout: 5_000 }),
+    ]);
+    return withCommandLines(parsePsOutput(String(executables)), parsePidListing(String(commands)));
   } catch {
     return [];
   }

package/apps/bridge/src/mesh/catalog.ts

@@ -213,6 +213,7 @@ export function linkSessionsToProjects(
       computerId,
       workspace: cwd,
       repositoryId: repository.canonicalRepositoryId,
+      activeAt: session.lastActivityAt,
       branch: session.branch,
       worktree: repository.worktree,
       uncommitted: hasUncommittedWork(repository.worktree ?? cwd),

package/apps/bridge/src/mesh/map.ts

@@ -40,30 +40,65 @@ function taskTitle(snapshot: MeshSnapshot, taskId: string): string {
   return compactText(snapshot.tasks.find((task) => task.taskId === taskId)?.title ?? taskId, 80);
 }
 
+/** An open execution is live when its chat did something within the hour. */
+export const LIVE_WINDOW_MS = 60 * 60_000;
+
+/**
+ * When the chat last did anything. A computer that predates `activeAt` still
+ * says when it last observed the execution, and a record nobody has touched
+ * in an hour is not live either way.
+ */
+function lastSeen(execution: MeshSnapshot["executions"][number]): number {
+  return execution.activeAt ?? execution.updatedAt ?? execution.startedAt;
+}
+
+function isLive(execution: MeshSnapshot["executions"][number], now: number): boolean {
+  return execution.endedAt == null && now - lastSeen(execution) <= LIVE_WINDOW_MS;
+}
+
 /** Where a Task is being worked right now: its live executions. */
-function liveWork(snapshot: MeshSnapshot, taskId: string): MeshSnapshot["executions"] {
-  return snapshot.executions.filter((item) => item.taskId === taskId && item.endedAt == null);
+function liveWork(snapshot: MeshSnapshot, taskId: string, now = Date.now()): MeshSnapshot["executions"] {
+  return snapshot.executions.filter((item) => item.taskId === taskId && isLive(item, now));
+}
+
+/** Open but quiet: the chat exists and has not done anything for an hour. */
+function idleWork(snapshot: MeshSnapshot, taskId: string, now = Date.now()): MeshSnapshot["executions"] {
+  return snapshot.executions.filter((item) => item.taskId === taskId && item.endedAt == null && !isLive(item, now));
+}
+
+function ago(at: number, now: number): string {
+  const minutes = Math.max(0, Math.round((now - at) / 60_000));
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes} min ago`;
+  const hours = Math.round(minutes / 60);
+  return hours < 48 ? `${hours} h ago` : `${Math.round(hours / 24)} d ago`;
 }
 
 /** The whole Project as markdown. */
 export function meshMap(snapshot: MeshSnapshot, now = Date.now()): string {
   const lines: string[] = [];
-  const live = snapshot.executions.filter((item) => item.endedAt == null);
+  const live = snapshot.executions.filter((item) => isLive(item, now));
+  const idle = snapshot.executions.filter((item) => item.endedAt == null && !isLive(item, now));
   lines.push(`# Project Mesh — ${snapshot.project.name}`);
   lines.push("");
-  lines.push(`_${snapshot.tasks.length} Task${snapshot.tasks.length === 1 ? "" : "s"} · ${live.length} live execution${live.length === 1 ? "" : "s"} · ${new Date(now).toISOString()}_`);
+  lines.push(`_${snapshot.tasks.length} Task${snapshot.tasks.length === 1 ? "" : "s"} · ${live.length} live execution${live.length === 1 ? "" : "s"}${idle.length ? ` · ${idle.length} idle` : ""} · ${new Date(now).toISOString()}_`);
 
   lines.push("", "## Tasks", "");
   const tasks = [...snapshot.tasks].sort((a, b) => b.updatedAt - a.updatedAt).slice(0, MAX_MAP_TASKS);
   if (tasks.length === 0) lines.push("- (none)");
   for (const task of tasks) {
-    const work = liveWork(snapshot, task.taskId).map((item) => {
+    const work = liveWork(snapshot, task.taskId, now).map((item) => {
       const repository = repositoryName(executionRepository(item, snapshot), snapshot);
-      return `${item.provider} on ${item.computerId}${repository ? ` in ${repository}` : ""}`;
+      const when = item.activeAt != null ? `, active ${ago(item.activeAt, now)}` : "";
+      return `${item.provider} on ${item.computerId}${repository ? ` in ${repository}` : ""}${when}`;
     });
+    const quiet = idleWork(snapshot, task.taskId, now);
+    const idleNote = work.length === 0 && quiet.length > 0
+      ? `; idle${quiet[0] ? ` since ${ago(lastSeen(quiet[0]), now)}` : ""}`
+      : "";
     const latest = [...snapshot.events].reverse().find((event) => event.taskId === task.taskId && eventLine(event));
     const tail = latest ? ` — ${eventLine(latest)}` : "";
-    lines.push(`- **${taskTitle(snapshot, task.taskId)}** — ${task.state}${work.length ? `; ${work.join(", ")}` : ""}${tail}`);
+    lines.push(`- **${taskTitle(snapshot, task.taskId)}** — ${task.state}${work.length ? `; ${work.join(", ")}` : idleNote}${tail}`);
   }
 
   const byModule = new Map<string, string[]>();
@@ -110,18 +145,24 @@ export function meshMap(snapshot: MeshSnapshot, now = Date.now()): string {
 }
 
 /** The lines of the map that matter to one Task right now; empty when nothing does. */
-export function meshBrief(snapshot: MeshSnapshot, taskId: string): string[] {
+export function meshBrief(snapshot: MeshSnapshot, taskId: string, now = Date.now()): string[] {
   const lines: string[] = [];
   const others = snapshot.tasks.filter((task) =>
-    task.taskId !== taskId && liveWork(snapshot, task.taskId).length > 0);
+    task.taskId !== taskId && liveWork(snapshot, task.taskId, now).length > 0);
+  const idle = snapshot.tasks.filter((task) =>
+    task.taskId !== taskId && liveWork(snapshot, task.taskId, now).length === 0 && idleWork(snapshot, task.taskId, now).length > 0);
   if (others.length > 0) {
     const named = others.slice(0, 5).map((task) => {
-      const execution = liveWork(snapshot, task.taskId)[0];
+      const execution = liveWork(snapshot, task.taskId, now)[0];
       const repository = execution ? repositoryName(executionRepository(execution, snapshot), snapshot) : undefined;
-      return `${taskTitle(snapshot, task.taskId)}${repository ? ` (${repository})` : ""}`;
+      const when = execution?.activeAt != null ? `, ${ago(execution.activeAt, now)}` : "";
+      return `${taskTitle(snapshot, task.taskId)}${repository ? ` (${repository}${when})` : when ? ` (${when.slice(2)})` : ""}`;
     });
     const more = others.length > 5 ? ` (+${others.length - 5})` : "";
-    lines.push(`Also live in this Project: ${named.join("; ")}${more}.`);
+    const quiet = idle.length > 0 ? ` ${idle.length} other chat${idle.length === 1 ? "" : "s"} here ${idle.length === 1 ? "is" : "are"} open but idle.` : "";
+    lines.push(`Also active in this Project within the hour: ${named.join("; ")}${more}.${quiet}`);
+  } else if (idle.length > 0) {
+    lines.push(`${idle.length} other chat${idle.length === 1 ? "" : "s"} in this Project ${idle.length === 1 ? "is" : "are"} open but idle for over an hour.`);
   }
   const neighbours = scopedNeighbours(snapshot, taskId).slice(0, 5);
   for (const { claim, kind } of neighbours) {

package/apps/bridge/src/mesh/prompt-context.ts

@@ -7,7 +7,7 @@
  * `UserPromptSubmit` hook to add to the prompt — the unread journal first,
  * then the Mesh brief — so the model coordinates without being told to look.
  */
-import { executionCapabilityFor, liveExecutionScope } from "./capability";
+import { liveExecutionScope } from "./capability";
 import { describeRun, markRunsDelivered, unreadRuns, type RunRecord } from "./journal";
 import { meshBrief } from "./map";
 import type { MeshSnapshot } from "../../../../packages/protocol/schema";
@@ -19,7 +19,6 @@ export type PromptContextDeps = {
   unread: (sessionId: string) => RunRecord[];
   markDelivered: (sessionId: string, at: number) => void;
   scope: (sessionId: string) => { snapshot: MeshSnapshot; taskId: string } | undefined;
-  capability: (sessionId: string) => string | undefined;
 };
 
 const liveDeps: PromptContextDeps = {
@@ -29,7 +28,6 @@ const liveDeps: PromptContextDeps = {
     const scope = liveExecutionScope(sessionId);
     return scope ? { snapshot: scope.snapshot, taskId: scope.execution.taskId } : undefined;
   },
-  capability: (sessionId) => executionCapabilityFor(sessionId)?.token,
 };
 
 function clock(at: number): string {
@@ -59,12 +57,13 @@ export function promptContext(
   }
   const scope = deps.scope(sessionId);
   if (scope) {
-    const brief = meshBrief(scope.snapshot, scope.taskId);
+    const brief = meshBrief(scope.snapshot, scope.taskId, now);
     if (brief.length > 0) {
       if (lines.length > 0) lines.push("");
       lines.push(`Project Mesh «${scope.snapshot.project.name}»:`, ...brief.map((line) => `- ${line}`));
-      const token = deps.capability(sessionId);
-      if (token) lines.push(`Full map: read the MCP resource granttap://mesh/${token}/map`);
+      // Listed by name, not by token: Claude Code reads only listed resources,
+      // and the server finds the chat from its own environment.
+      lines.push("Full map: read the granttap MCP resource granttap://mesh/map");
     }
   }
   if (lines.length === 0) return undefined;

package/apps/bridge/src/sessions/claude.ts

@@ -390,10 +390,27 @@ export function claudeCapabilityUsage(
   const pending = new Map<string, PendingCapabilityTool>();
   const out: CapabilityObservation[] = [];
 
+  let commandOrdinal = 0;
   for (const line of lines) {
     const row = safeParse(line);
-    if (!row || !Array.isArray(row.message?.content)) continue;
+    if (!row) continue;
     const rowAt = ts(row.timestamp);
+    // A skill the person invoked as a slash command never becomes a tool call;
+    // the host writes it as a user turn. It is a skill used all the same.
+    const command = slashCommandSkill(row);
+    if (command) {
+      commandOrdinal += 1;
+      rememberCapabilityObservation(out, {
+        sourceId: `${sourceThreadId}:command:${typeof row.uuid === "string" ? row.uuid : commandOrdinal}`,
+        sessionId: session.sessionId,
+        toolName: `/${command}`,
+        skill: command,
+        createdAt: rowAt || session.lastActivityAt,
+        outcome: "success",
+      });
+      continue;
+    }
+    if (!Array.isArray(row.message?.content)) continue;
     for (const block of row.message.content as any[]) {
       if (
         block?.type === "tool_use" &&
@@ -439,6 +456,31 @@ export function claudeCapabilityUsage(
   return out;
 }
 
+/**
+ * Housekeeping commands are the terminal's own, not a skill anyone wrote:
+ * counting `/clear` as a skill would put the tool's plumbing in the usage.
+ */
+const BUILTIN_COMMANDS = new Set([
+  "clear", "compact", "help", "model", "cost", "status", "config", "doctor", "login", "logout",
+  "memory", "permissions", "hooks", "mcp", "agents", "exit", "quit", "bug", "vim", "terminal-setup",
+  "resume", "continue", "init", "context", "release-notes", "upgrade", "fast", "theme",
+]);
+
+/** The skill a user turn invoked as a slash command, when it is one. */
+export function slashCommandSkill(row: any): string | undefined {
+  if (row?.type !== "user" && row?.message?.role !== "user") return undefined;
+  const content = row.message?.content;
+  const text = typeof content === "string"
+    ? content
+    : Array.isArray(content)
+      ? content.find((block: any) => block?.type === "text")?.text
+      : undefined;
+  if (typeof text !== "string" || !text.trimStart().startsWith("<command-name>")) return undefined;
+  const name = /<command-name>\s*\/?([A-Za-z0-9][A-Za-z0-9_:.-]{0,79})\s*<\/command-name>/.exec(text)?.[1];
+  if (!name || BUILTIN_COMMANDS.has(name.toLowerCase())) return undefined;
+  return name;
+}
+
 function appendClaudeActivity(
   out: ActivityEntry[],
   seen: Set<string>,

package/apps/bridge/src/sessions/telemetry.ts

@@ -161,17 +161,43 @@ function boundedErrorClass(value: string | undefined): string | undefined {
   return clean || undefined;
 }
 
+/**
+ * The command a shell call ran, by its first real word: `npm`, `git`, `rg` —
+ * not `Bash`. A usage screen that listed every shell call as Bash could not
+ * say which tool was slow or failing, which is the only thing it is for.
+ */
+export function commandName(preview: string | undefined | null): string | undefined {
+  if (!preview) return undefined;
+  const prefixes = new Set(["sudo", "env", "exec", "time", "nohup", "command", "builtin", "xargs"]);
+  for (const segment of preview.split(/\s*(?:&&|\|\||;|\|)\s*/)) {
+    const words = segment.trim().split(/\s+/).filter(Boolean);
+    let index = 0;
+    while (index < words.length) {
+      const word = words[index]!;
+      if (word === "cd") { index += 2; continue; }
+      if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(word) || prefixes.has(word)) { index += 1; continue; }
+      break;
+    }
+    const word = words[index];
+    if (!word) continue;
+    const leaf = word.split("/").pop() ?? word;
+    if (/^[A-Za-z0-9._+-]{1,40}$/.test(leaf) && !/^[-.]/.test(leaf)) return leaf;
+  }
+  return undefined;
+}
+
 export function toObservedCapability(
   observation: CapabilityObservation,
 ): ObservedCapability {
   const kind = observation.mcpServer ? "mcp" : observation.skill ? "skill" : "cli";
   const toolName = observation.toolName.trim().slice(0, 240);
+  const commandPreview =
+    kind === "cli" ? commandPreviewFromInput(observation.commandPreview) ?? undefined : undefined;
   return {
     kind,
-    name: (observation.mcpServer ?? observation.skill ?? toolName).trim().slice(0, 160),
+    name: (observation.mcpServer ?? observation.skill ?? commandName(commandPreview) ?? toolName).trim().slice(0, 160),
     toolName,
-    commandPreview:
-      kind === "cli" ? commandPreviewFromInput(observation.commandPreview) ?? undefined : undefined,
+    commandPreview,
     estimatedContextTokens: observation.estimatedContextTokens,
     estimatedBaselineTokens: observation.estimatedBaselineTokens,
     durationMs: observation.durationMs,
@@ -203,7 +229,9 @@ export function toRemoteCapabilityUsageEvent(
       : observation.cli
         ? "cli"
         : null;
-  const name = (observation.mcpServer ?? observation.skill ?? observation.toolName).trim();
+  const remotePreview =
+    kind === "cli" ? commandPreviewFromInput(observation.commandPreview) ?? undefined : undefined;
+  const name = (observation.mcpServer ?? observation.skill ?? commandName(remotePreview) ?? observation.toolName).trim();
   const toolName = observation.toolName.trim();
   const sessionId = observation.sessionId.trim();
   if (!kind || !name || !toolName || !sessionId || sessionId.length > 256) {

package/apps/mcp/src/mcp-tools/mesh-resource.ts

@@ -1,14 +1,38 @@
 import { ResourceTemplate, type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { resolveExecutionCapability } from "../../../bridge/src/mesh/capability";
+import {
+  executionCapabilityFor,
+  liveExecutionScope,
+  resolveExecutionCapability,
+} from "../../../bridge/src/mesh/capability";
 import { scopedMeshView } from "../../../bridge/src/mesh/scoped-view";
-import { liveExecutionScope } from "../../../bridge/src/mesh/capability";
 import { meshMap } from "../../../bridge/src/mesh/map";
 import { isMeshEnabled } from "../../../bridge/src/config/runtime";
 
 const MESH_URI = "granttap://mesh/current";
+export const MAP_URI = "granttap://mesh/map";
 const SCOPE_HINT =
-  "Project Mesh reads are scoped to one execution. Call notify to receive this "
-  + "session's granttap://mesh/<capability> URI, then read that URI.";
+  "Project Mesh reads are scoped to one execution. In Claude Code, read "
+  + `${MAP_URI}. Elsewhere, call notify to receive this session's `
+  + "granttap://mesh/<capability> URI, then read that URI.";
+
+/**
+ * The chat this server belongs to.
+ *
+ * Claude Code starts one MCP server per chat and hands it the chat's id in
+ * the environment. Nothing said over the connection can change that, which
+ * makes it the one identity a resource read — which no hook attributes — can
+ * trust. Other providers set nothing here and keep using minted capabilities.
+ */
+export function sessionFromEnvironment(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  const id = env.CLAUDE_CODE_SESSION_ID?.trim() ?? "";
+  return /^[A-Za-z0-9._-]{8,128}$/.test(id) ? id : undefined;
+}
+
+/** This chat's Project as a page of markdown, or how to get one. */
+function mapFor(sessionId: string | undefined): string {
+  const scope = isMeshEnabled() && sessionId ? liveExecutionScope(sessionId) : undefined;
+  return scope ? meshMap(scope.snapshot) : `# Project Mesh\n\n${SCOPE_HINT}\n`;
+}
 
 function json(uri: string, value: unknown) {
   return {
@@ -34,11 +58,34 @@ export function registerMeshResource(server: McpServer): void {
       description: "How to obtain this execution's scoped coordination state.",
       mimeType: "application/json",
     },
-    async (uri) => json(uri.href, {
-      schema: "granttap.mesh-scope-hint.v1",
-      enabled: isMeshEnabled(),
-      scoped: false,
-      hint: SCOPE_HINT,
+    async (uri) => {
+      // A server that knows its chat serves that chat's own scope here.
+      const sessionId = sessionFromEnvironment();
+      const capability = isMeshEnabled() && sessionId ? executionCapabilityFor(sessionId) : undefined;
+      const view = capability ? scopedMeshView(capability) : undefined;
+      if (view) return json(uri.href, { ...view, enabled: true, scoped: true });
+      return json(uri.href, {
+        schema: "granttap.mesh-scope-hint.v1",
+        enabled: isMeshEnabled(),
+        scoped: false,
+        hint: SCOPE_HINT,
+      });
+    },
+  );
+
+  // Listed, so a client that only reads listed resources — Claude Code's
+  // does — can open it straight from the prompt hook's one line.
+  server.registerResource(
+    "project-mesh-map",
+    MAP_URI,
+    {
+      title: "GrantTap Project Mesh map",
+      description: "This chat's Project as a readable map: Tasks, who edits what, the other side of each "
+        + "repository, what just happened. Transcripts are never included.",
+      mimeType: "text/markdown",
+    },
+    async (uri) => ({
+      contents: [{ uri: uri.href, mimeType: "text/markdown", text: mapFor(sessionFromEnvironment()) }],
     }),
   );
 
@@ -67,10 +114,10 @@ export function registerMeshResource(server: McpServer): void {
   // The same Project as one page of markdown: Tasks, who edits which module,
   // the other side of each repository, dependencies, and what just happened.
   server.registerResource(
-    "project-mesh-map",
+    "project-mesh-map-scoped",
     new ResourceTemplate("granttap://mesh/{capability}/map", { list: undefined }),
     {
-      title: "GrantTap Project Mesh map",
+      title: "GrantTap Project Mesh map (scoped)",
       description: "This execution's Project as a readable map. Transcripts are never included.",
       mimeType: "text/markdown",
     },
@@ -80,7 +127,7 @@ export function registerMeshResource(server: McpServer): void {
       const scope = resolved ? liveExecutionScope(resolved.sessionId) : undefined;
       const text = scope && scope.snapshot.projectId === resolved?.projectId
         ? meshMap(scope.snapshot)
-        : `# Project Mesh\n\n${SCOPE_HINT}\n`;
+        : mapFor(undefined);
       return { contents: [{ uri: uri.href, mimeType: "text/markdown", text }] };
     },
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "granttap-mcp",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "Personal live control center runtime for local coding agents on iPhone and Apple Watch.",
   "type": "module",
   "bin": {

package/packages/protocol/messages/machine.ts

@@ -5,11 +5,23 @@ const Amount = z.number().nonnegative().catch(0);
 const Count = z.number().int().nonnegative().catch(0);
 
 /** Measurements for one local coding-agent process family. */
+/** One kind of process an agent runs — `node` ×43, `zsh` ×10 — and what it costs. */
+export const ProcessGroupLoad = z.object({
+  name: z.string().trim().min(1).max(64),
+  count: Count,
+  cpuPercent: Amount,
+  memoryBytes: Amount,
+});
+export type ProcessGroupLoad = z.infer<typeof ProcessGroupLoad>;
+
 export const AgentLoadSample = z.object({
   agent: AgentId,
   processes: Count,
   cpuPercent: Amount,
   memoryBytes: Amount,
+  // The heaviest kinds of process behind the agent's number, so the phone
+  // can say what "Claude" is running, not only that it is running.
+  topProcesses: z.array(ProcessGroupLoad).max(8).optional(),
   sessions: Count,
   scanMs: Amount,
   tokensRecent: Amount,

package/packages/protocol/messages/mesh.ts

@@ -70,6 +70,10 @@ export const ExecutionSessionLink = z.object({
   // When those facts were last observed, so a late snapshot cannot replace a
   // fresh reading with a stale one.
   updatedAt: z.number().nonnegative().optional(),
+  // When the chat itself last did anything. An execution stays open while its
+  // chat exists, which is not the same as the chat being alive: without this,
+  // every idle chat of the week read as live work.
+  activeAt: z.number().nonnegative().optional(),
   startedAt: z.number().nonnegative(),
   endedAt: z.number().nonnegative().optional(),
 }).strict().superRefine((value, ctx) => {