feat(#142 T2.1): per-agent process telemetry — RSS / CPU% / uptime / in-flight count

v0.10.0 Track 2 / T2.1 — agent-node side per-agent process telemetry.

Extends #119's host-telemetry.ts with metrics scoped to THIS agent-node
process (vs the host machine). Aggregated by commhub-server T2.2
(派 通信牛) and rendered by dashboard sidebar/hover T2.3 (派 N站马).

New module: agent-node/src/process-telemetry.ts (~75 LOC)

Public API:
  getProcessTelemetry(): ProcessTelemetry
    {
      rss_bytes: number,       // process.memoryUsage().rss
      rss_mb: number,          // rss_bytes / 1MB, rounded to 1 decimal
      cpu_pct: number | null,  // delta cpuUsage / wall delta, % (null on first sample)
      uptime_seconds: number,  // Math.round(process.uptime())
      in_flight_count: number, // current think() invocations in flight
    }
  incrementInFlight() / decrementInFlight() / getInFlightCount()
  _resetProcessTelemetry()  // test-only, resets sampler state

Wiring in cli.ts:
  - register() + reportStatus() payloads now include process_telemetry
    field alongside the existing host field (additive, ignored by old
    commhub servers per the same conservative-additive principle as #119)
  - think() wraps the run() body with incrementInFlight() / try /
    decrementInFlight() in finally so the counter accurately reflects
    active task processing even on error paths

CPU% calculation:
  cpu.user_us + cpu.system_us delta over wall-clock delta, expressed
  as percent. Can exceed 100 on multi-core systems (e.g. async I/O
  parallelism). First sample returns null because there's no prior
  reference point.

Unit smoke (local /tmp/p142-telemetry-smoke.mjs) PASS:
  sample 1 (no prev): rss_mb=34, cpu_pct=null ✓
  busy-loop 100ms + 3 incr + 1 decr →
  sample 2: rss_mb=42.6, cpu_pct=109.3, in_flight_count=2 ✓

Bundle clean: bun 84 modules → 0.32 MB cli.js.

Refs #142 (T2.1 of 4)
Refs #140 (v0.10.0 tracker)

Author-Agent: 通信SDK马

Author: vansin

agent-node/src/cli.ts

@@ -14,6 +14,7 @@ import { join } from "path";
 import { hostname as osHostname, homedir } from "os";
 import { createCommhubSdkMcpServer } from "./commhub-mcp";
 import { getHostTelemetry } from "./host-telemetry";
+import { getProcessTelemetry, incrementInFlight, decrementInFlight } from "./process-telemetry";
 
 const home = homedir();
 
@@ -451,6 +452,7 @@ const register = () => callCommHub("report_status", {
   model: MODEL || undefined,
   network_id: NETWORK_ID || undefined,
   host: getHostTelemetry(),
+  process_telemetry: getProcessTelemetry(),
 });
 const reportStatus = (status: string, task?: string) => callCommHub("report_status", {
   resume_id: RESUME_ID, alias: ALIAS, status, task,
@@ -460,6 +462,7 @@ const reportStatus = (status: string, task?: string) => callCommHub("report_stat
   channels: channelSpecs.length ? JSON.stringify(channelSpecs) : undefined,
   network_id: NETWORK_ID || undefined,
   host: getHostTelemetry(),
+  process_telemetry: getProcessTelemetry(),
 });
 const getInbox = async () => (await callCommHub("get_inbox", { alias: ALIAS, limit: 20 }))?.messages || [];
 const ackMessage = (id: string) => callCommHub("ack_inbox", { alias: ALIAS, message_id: id });
@@ -1031,6 +1034,10 @@ function think(task: string, from: string, taskId: string | null, images?: strin
     // is more reliable for multi-task interleavings.
     const prev = process.env.CURRENT_TASK_ID;
     if (taskId) process.env.CURRENT_TASK_ID = taskId; else delete process.env.CURRENT_TASK_ID;
+    // #142 — track in-flight task count for per-agent telemetry. thinkQueue
+    // serializes so the counter is mostly 0 or 1, but the increment/decrement
+    // pattern is still correct under future concurrency changes.
+    incrementInFlight();
     try {
       if (RUNTIME === "codex") {
         // #141 Phase 1.3 — opt-in to direct app-server stdio.
@@ -1046,6 +1053,7 @@ function think(task: string, from: string, taskId: string | null, images?: strin
       return await processWithClaude(task, from);
     } finally {
       if (prev !== undefined) process.env.CURRENT_TASK_ID = prev; else delete process.env.CURRENT_TASK_ID;
+      decrementInFlight();
     }
   };
   const next = thinkQueue.then(run, run);

agent-node/src/process-telemetry.ts

@@ -0,0 +1,81 @@
+// Per-agent process telemetry for #142 (Track 2 of v0.10.0).
+//
+// Extends #119's host-telemetry.ts with metrics scoped to this agent-node
+// process — RSS, CPU%, uptime, in-flight task count. Aggregated by commhub-
+// server (T2.2, 通信牛) and rendered by dashboard sidebar/hover (T2.3,
+// N站马) alongside the existing per-host fields.
+//
+// All fields are nullable independently. CPU% is null on the first sample
+// because it needs a delta against a previous sample. After that it tracks
+// the rate of cpuUsage growth over wall-clock time.
+//
+// The in-flight counter is incremented when think() begins processing a
+// task and decremented when it returns (success or error). Race-free
+// because think() serializes through thinkQueue.
+
+export interface ProcessTelemetry {
+  rss_bytes: number;
+  rss_mb: number;
+  cpu_pct: number | null;
+  uptime_seconds: number;
+  in_flight_count: number;
+}
+
+interface CpuSample {
+  ts_ms: number;
+  user_us: number;
+  system_us: number;
+}
+
+let _lastCpu: CpuSample | null = null;
+let _inFlight = 0;
+
+export function incrementInFlight(): void {
+  _inFlight++;
+}
+
+export function decrementInFlight(): void {
+  _inFlight = Math.max(0, _inFlight - 1);
+}
+
+export function getInFlightCount(): number {
+  return _inFlight;
+}
+
+export function getProcessTelemetry(): ProcessTelemetry {
+  const now = Date.now();
+  const cpu = process.cpuUsage();
+
+  let cpu_pct: number | null = null;
+  if (_lastCpu) {
+    const wallDeltaMs = now - _lastCpu.ts_ms;
+    const userDeltaUs = cpu.user - _lastCpu.user_us;
+    const systemDeltaUs = cpu.system - _lastCpu.system_us;
+    const cpuDeltaMs = (userDeltaUs + systemDeltaUs) / 1000;
+    if (wallDeltaMs > 0) {
+      // cpu% can exceed 100 on multi-core systems (e.g. parallel I/O).
+      // Round to 1 decimal for readability.
+      cpu_pct = Math.round((cpuDeltaMs / wallDeltaMs) * 100 * 10) / 10;
+    }
+  }
+  _lastCpu = { ts_ms: now, user_us: cpu.user, system_us: cpu.system };
+
+  const mem = process.memoryUsage();
+  const rss_bytes = mem.rss;
+  const rss_mb = Math.round((rss_bytes / (1024 * 1024)) * 10) / 10;
+
+  return {
+    rss_bytes,
+    rss_mb,
+    cpu_pct,
+    uptime_seconds: Math.round(process.uptime()),
+    in_flight_count: _inFlight,
+  };
+}
+
+// Test-only: reset sampler state (cpu delta history + in-flight counter).
+// Not part of public API but available for unit tests.
+export function _resetProcessTelemetry(): void {
+  _lastCpu = null;
+  _inFlight = 0;
+}