@linzumi/cli 1.0.16 → 1.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {

package/scripts/analyze_enter_to_typing_latency.mjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+// Enter->typing latency analyzer for a runner log (the measurement infra
+// behind the 2026-07-02 follow-up-latency RCA; see
+// test/enterToTypingHeadOfLine.test.ts for the fix it motivated).
+//
+// For every real-thread follow-up dispatch it pairs `kandan.message_queued`
+// with the next `codex.turn_starting` on the same thread and classifies the
+// window:
+//   - silent           : NO other runner activity for the thread in between.
+//                        Pre-fix this was the head-of-line block on the
+//                        `queued` message_state server ack; post-fix it
+//                        should be ~0ms.
+//   - drain_blocked/*  : a logged `kandan.queue_drain_blocked` gate
+//                        (turn_not_idle = user sent mid-turn, etc.). These
+//                        are legitimate waits, not latency bugs.
+//   - cold_spawn       : a `runner.thread_process_starting` fired in the
+//                        window (worker cold respawn).
+//
+// Usage:
+//   node scripts/analyze_enter_to_typing_latency.mjs [path-to-runner-log]
+// Default log path: ~/.linzumi/logs/linzumi-runner.log
+//
+// Ran against a production runner log on 2026-07-02 this reported, over
+// 5439 follow-up dispatches (UUID-threaded; includes local vitest threads
+// with synthetic UUIDs, which are all in the fast bucket): 204 slower than
+// 500ms, of which 158 were `silent` (p50 1343ms / p90 3119ms / p99 11928ms),
+// 46 were drain_blocked/turn_not_idle, and 0 were cold spawns - the evidence
+// that the dominant Enter->typing latency was the awaited status-paint ack,
+// not worker respawn.
+import { createReadStream } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+const logPath =
+  process.argv[2] ??
+  path.join(homedir(), '.linzumi', 'logs', 'linzumi-runner.log');
+const slowThresholdMs = Number(process.env.SLOW_THRESHOLD_MS ?? 500);
+
+// Real Linzumi thread ids are UUIDs; test threads use readable slugs.
+const uuidRe = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+function percentile(sorted, q) {
+  if (sorted.length === 0) {
+    return null;
+  }
+  return sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))];
+}
+
+const threads = new Map();
+const rows = [];
+
+const rl = createInterface({
+  input: createReadStream(logPath),
+  crlfDelay: Infinity,
+});
+
+for await (const line of rl) {
+  if (line.length > 20_000) {
+    continue;
+  }
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    continue;
+  }
+  const threadId =
+    entry.thread_id ??
+    entry.kandanThreadId ??
+    entry.linzumi_thread_id ??
+    entry.threadId ??
+    entry.kandan_thread_id;
+  if (typeof threadId !== 'string' || !uuidRe.test(threadId)) {
+    continue;
+  }
+  const atMs = Date.parse(entry.ts);
+  if (Number.isNaN(atMs)) {
+    // A malformed/absent timestamp would otherwise mint a NaN-latency row
+    // that silently falls out of both the slow and fast buckets, making the
+    // printed totals diverge from the dispatch count.
+    continue;
+  }
+  let state = threads.get(threadId);
+  if (state === undefined) {
+    state = { pending: null };
+    threads.set(threadId, state);
+  }
+  const event = entry.event;
+  if (event === 'kandan.message_queued') {
+    state.pending = { atMs, seq: entry.seq, blocked: [], spawn: false };
+  } else if (state.pending !== null) {
+    if (event === 'codex.turn_starting') {
+      rows.push({
+        threadId,
+        ts: entry.ts,
+        ms: atMs - state.pending.atMs,
+        blocked: state.pending.blocked,
+        spawn: state.pending.spawn,
+      });
+      state.pending = null;
+    } else if (event === 'kandan.queue_drain_blocked') {
+      state.pending.blocked.push(entry.reason);
+    } else if (event === 'runner.thread_process_starting') {
+      state.pending.spawn = true;
+    }
+  }
+}
+
+const slow = rows.filter((row) => row.ms > slowThresholdMs);
+const silent = slow.filter((row) => row.blocked.length === 0 && !row.spawn);
+const spawns = slow.filter((row) => row.spawn);
+const blockedCounts = new Map();
+for (const row of slow) {
+  for (const reason of new Set(row.blocked)) {
+    blockedCounts.set(reason, (blockedCounts.get(reason) ?? 0) + 1);
+  }
+}
+
+const silentSorted = silent.map((row) => row.ms).sort((a, b) => a - b);
+const fast = rows.filter((row) => row.ms <= slowThresholdMs);
+const fastSorted = fast.map((row) => row.ms).sort((a, b) => a - b);
+
+console.log(`log: ${logPath}`);
+console.log(
+  `follow-up dispatches=${rows.length} slow(>${slowThresholdMs}ms)=${slow.length}`
+);
+console.log(
+  `  silent (head-of-line on paint ack pre-fix)=${silent.length}` +
+    (silentSorted.length > 0
+      ? ` p50=${percentile(silentSorted, 0.5)}ms p90=${percentile(silentSorted, 0.9)}ms p99=${percentile(silentSorted, 0.99)}ms max=${silentSorted[silentSorted.length - 1]}ms`
+      : '')
+);
+for (const [reason, count] of blockedCounts) {
+  console.log(`  drain_blocked/${reason}=${count}`);
+}
+console.log(`  cold_spawn=${spawns.length}`);
+console.log(
+  `fast(<=${slowThresholdMs}ms)=${fast.length}` +
+    (fastSorted.length > 0 ? ` p50=${percentile(fastSorted, 0.5)}ms` : '')
+);
+if (silent.length > 0) {
+  console.log('\nslowest silent windows:');
+  for (const row of [...silent].sort((a, b) => b.ms - a.ms).slice(0, 10)) {
+    console.log(`  ${row.ts} thread=${row.threadId.slice(0, 8)} ${row.ms}ms`);
+  }
+}