@axiomatic-labs/claudeflow 2.32.4 → 2.32.6

package/lib/doctor.js

@@ -146,9 +146,43 @@ function checkStaleLockfiles(cwd) {
 // Detection strategy (in order of preference):
 //   1. error-observer.json exists → read its `port` + `pid_path`.
 //   2. If pidfile exists and PID is alive → running=true.
-//   3. Else, TCP probe the observer port via `lsof -i :PORT -sTCP:LISTEN -t`.
+//   3. Else, TCP-probe the observer port with a short `net.connect` (via a
+//      one-shot `node -e` child, so the synchronous status path stays sync).
 //      The pidfile may be missing (race) but if SOMETHING is listening on
-//      the configured port, the daemon is up.
+//      the configured port, the daemon is up. This replaces a prior `lsof`
+//      probe that was slow on macOS (often >1.5s — the timeout — so a live
+//      observer read as stopped) and absent on Windows (no `lsof` → the
+//      fallback never ran). `net.connect` is a Node built-in: fast and
+//      cross-platform. Trade-off: it proves a listener EXISTS but cannot
+//      attribute the owning PID, so a probe hit returns `pid: null`.
+//
+// Synchronous TCP liveness check WITHOUT lsof. Node has no sync net.connect,
+// so we run the connect in a one-shot `node -e` child via spawnSync — keeping
+// readObserverState (and its sync callers: getMcpInfo/getObserverInfo/
+// collectStatus) synchronous. Probes both IPv4 and IPv6 loopback (the daemon
+// may bind either); exit 0 = a listener answered. Reached only when the
+// pidfile path already failed, so the ~node-startup cost is off the hot path.
+function portHasListenerSync(port) {
+  if (!Number.isFinite(port) || port <= 0) return false;
+  const script =
+    'const net=require("net");' +
+    'const port=' + Number(port) + ';' +
+    'const hosts=["127.0.0.1","::1"];' +
+    'let pending=hosts.length,done=false;' +
+    'const finish=(ok)=>{if(done)return;if(ok){done=true;process.exit(0);}if(--pending===0){done=true;process.exit(1);}};' +
+    'for(const h of hosts){const s=net.connect({host:h,port});s.setTimeout(250);' +
+    's.once("connect",()=>{s.destroy();finish(true);});' +
+    's.once("error",()=>finish(false));' +
+    's.once("timeout",()=>{s.destroy();finish(false);});}';
+  try {
+    const { spawnSync } = require('child_process');
+    const r = spawnSync(process.execPath, ['-e', script], { timeout: 1000 });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}
+
 function readObserverState(cwd) {
   const observerJsonPath = path.join(cwd, '.claudeflow', 'tmp', 'error-observer.json');
   // Defense-in-depth retry: even though the daemon now writes atomically
@@ -200,18 +234,12 @@ function readObserverState(cwd) {
     if (alive) return { running: true, pid, port, source: 'pidfile', observerJsonPath };
   }
 
-  // Fallback: TCP probe via lsof. Catches the case where pidfile is missing
-  // but the daemon process is still listening on the port.
-  try {
-    const { spawnSync } = require('child_process');
-    const r = spawnSync('lsof', ['-i', `:${port}`, '-sTCP:LISTEN', '-t'], { encoding: 'utf8', timeout: 1500 });
-    if (r.status === 0 && r.stdout && r.stdout.trim()) {
-      const tcpPid = parseInt(r.stdout.trim().split('\n')[0], 10);
-      if (Number.isFinite(tcpPid) && tcpPid > 0) {
-        return { running: true, pid: tcpPid, port, source: 'tcp-probe', observerJsonPath };
-      }
-    }
-  } catch {}
+  // Fallback: cross-platform net.connect probe. Catches the case where the
+  // pidfile is missing (race / external start) but the daemon is still
+  // listening on the port. Can't attribute the PID, so report pid: null.
+  if (portHasListenerSync(port)) {
+    return { running: true, pid: null, port, source: 'tcp-probe', observerJsonPath };
+  }
 
   return { running: false, pid: pid, port, source: 'no-listener', observerJsonPath };
 }

package/lib/panel.js

@@ -230,16 +230,32 @@ function getSetupContextInfo(cwd) {
   try { ctx = JSON.parse(fs.readFileSync(p, 'utf8')); }
   catch { return { exists: false, path: p }; }
 
-  const canonicalToolingTypes = ['unit_test', 'integration_test', 'api_contract_test', 'e2e_test', 'security_test'];
+  // Canonical evidence types per test-tooling-schema.md: the 5 binary `_test`
+  // types + the 2 observational `_verification` types. (benchmark /
+  // exploratory_test are conditional — triggered only by PERFORMANCE_CHANGE or
+  // unmeasurable correctness — so they are NOT required for "complete".)
+  // Source of truth: .claude/skills/claudeflow-init/references/test-tooling-schema.md.
+  const canonicalToolingTypes = [
+    'unit_test',
+    'integration_test',
+    'api_contract_test',
+    'e2e_test',
+    'security_test',
+    'browser_verification',
+    'visual_verification',
+  ];
   const tooling = ctx.test_tooling || {};
-  const toolingComplete = canonicalToolingTypes.every((t) => {
-    const e = tooling[t];
-    return e && typeof e === 'object' && typeof e.command_pattern === 'string' && e.command_pattern.trim();
-  });
-  const missingTooling = canonicalToolingTypes.filter((t) => {
-    const e = tooling[t];
-    return !(e && typeof e === 'object' && e.command_pattern && e.command_pattern.trim());
-  });
+  // An entry is "defined" when it is shell-backed (`command_pattern`) OR
+  // Skill-backed (`invocation`). browser_verification is Skill-backed and
+  // legitimately carries NO command_pattern, so a command_pattern-only check
+  // would false-flag it as missing.
+  const isToolingDefined = (e) =>
+    e &&
+    typeof e === 'object' &&
+    ((typeof e.command_pattern === 'string' && e.command_pattern.trim()) ||
+      (typeof e.invocation === 'string' && e.invocation.trim()));
+  const toolingComplete = canonicalToolingTypes.every((t) => isToolingDefined(tooling[t]));
+  const missingTooling = canonicalToolingTypes.filter((t) => !isToolingDefined(tooling[t]));
 
   return {
     exists: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiomatic-labs/claudeflow",
-  "version": "2.32.4",
+  "version": "2.32.6",
   "description": "Claudeflow — AI-powered development toolkit for Claude Code. Skills, agents, hooks, and quality gates that ship production apps.",
   "bin": {
     "claudeflow": "./bin/cli.js"