claude-flow 3.32.2 → 3.32.9

package/v3/@claude-flow/cli/dist/src/commands/doctor.js

@@ -5,7 +5,7 @@
  * Created with ruv.io
  */
 import { output } from '../output.js';
-import { existsSync, readFileSync, statSync } from 'fs';
+import { existsSync, readFileSync, statSync, openSync, readSync, closeSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
@@ -216,6 +216,16 @@ async function checkDaemonStatus() {
     }
 }
 // Check memory database
+//
+// #2737: renamed the reported row from "Memory Database" to "Memory Database
+// Presence" — this check is existsSync()+statSync() ONLY, it never opens the
+// file or queries it, so it PASSES for any file that exists and can be
+// stat'd, corrupt or not. It was the ONLY memory probe in the default
+// `allChecks` run (the real integrity checks were --component memory only),
+// so a corrupt .swarm/memory.db could sail through a bare `doctor` run as
+// "healthy". The name change makes the check's actual scope honest; the
+// behavior below is unchanged. See checkMemoryStructuralIntegrity below for
+// the new default-run check that actually opens the file.
 async function checkMemoryDatabase() {
     // Authoritative path comes from `getMemoryRoot()` (honors
     // `CLAUDE_FLOW_MEMORY_PATH`, claude-flow.config.json's `memory.persistPath`,
@@ -238,14 +248,14 @@ async function checkMemoryDatabase() {
             try {
                 const stats = statSync(dbPath);
                 const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-                return { name: 'Memory Database', status: 'pass', message: `${dbPath} (${sizeMB} MB)` };
+                return { name: 'Memory Database Presence', status: 'pass', message: `${dbPath} (${sizeMB} MB) — existence/size only, not a health check (see Memory Structural Integrity)` };
             }
             catch {
-                return { name: 'Memory Database', status: 'warn', message: `${dbPath} (unable to stat)` };
+                return { name: 'Memory Database Presence', status: 'warn', message: `${dbPath} (unable to stat)` };
             }
         }
     }
-    return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'claude-flow memory configure --backend hybrid' };
+    return { name: 'Memory Database Presence', status: 'warn', message: 'Not initialized', fix: 'claude-flow memory configure --backend hybrid' };
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // #2677 — memory doctor: functional checks (stuinfla)
@@ -305,46 +315,282 @@ async function tryOpenSqlJs(dbPath) {
         return null;
     }
 }
-// Check 1 — sql.js can open it AND PRAGMA integrity_check returns 'ok'.
-// Two fail modes handled distinctly per "UNKNOWN is never PASS":
-//   - Open fails: warn ("cannot open; encrypted DB or corrupt — doctor
-//     can't distinguish from this side")
-//   - Open succeeds but pragma != 'ok': fail (definite corruption)
+// ── #2737 shared helpers: encryption-at-rest carve-out ─────────────────────
+//
+// "file is not a database" / "malformed" from sql.js or better-sqlite3 is
+// EXACTLY the signal a legitimately RFE1-encrypted-at-rest memory.db also
+// produces when opened without decrypting (ADR-096). Before either the new
+// default-run check or the strengthened checkMemoryIntegrity below concludes
+// "malformed = fail", they sniff for the RFE1 magic using the SAME detector
+// checkEncryptionAtRest uses (isEncryptedBlob), so the two checks can never
+// disagree about what counts as "encrypted".
+/** Read just the first `len` bytes of a file without loading the whole file
+ * into memory — a multi-GB memory.db shouldn't get fully buffered just to
+ * check a 4-byte magic. Returns fewer bytes (or empty) when the file is
+ * shorter than `len`; isEncryptedBlob() correctly treats a too-short blob
+ * as "not encrypted", so callers don't need to special-case that. */
+function readHeaderBytes(path, len) {
+    const fd = openSync(path, 'r');
+    try {
+        const buf = Buffer.alloc(len);
+        const bytesRead = readSync(fd, buf, 0, len, 0);
+        return buf.subarray(0, bytesRead);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+// RFE1 wire format is magic(4) + iv(12) + ciphertext(N) + tag(16); the
+// shortest possible blob is 32 bytes. 64 gives headroom without importing
+// vault.ts's private MIN_BLOB_LEN constant.
+const ENCRYPTION_SNIFF_LEN = 64;
+/** True iff `dbPath` is a legitimately RFE1-encrypted-at-rest file. A read
+ * failure (permissions, races) is treated as "not encrypted" — callers
+ * still hit their own open/query error handling right after, so nothing
+ * gets silently swallowed. */
+function isMemoryDbEncryptedAtRest(dbPath) {
+    try {
+        return isEncryptedBlob(readHeaderBytes(dbPath, ENCRYPTION_SNIFF_LEN));
+    }
+    catch {
+        return false;
+    }
+}
+// #2737 part 1 — bare `doctor` (no --component flag) never actually opened
+// memory.db: checkMemoryDatabase above is existsSync()+statSync() only, so
+// it PASSES on any file that exists and can be stat'd, corrupt or not, and
+// it was the ONLY memory probe `allChecks` ran. The real integrity checks
+// (checkMemoryIntegrity/Content/EmbeddingCoverage below) were, and remain,
+// --component memory only.
+//
+// This is a NEW, cheaper, native check added to the default `allChecks` run
+// (not a replacement for the deep trio):
+//   - better-sqlite3 (native) instead of sql.js: it's WAL-aware because
+//     SQLite itself resolves any sibling -wal file next to the main image;
+//     sql.js is WAL-blind — tryOpenSqlJs() above only readFileSync()s the
+//     main file and hands the raw bytes to the WASM build, so any
+//     committed-but-not-checkpointed rows sitting in a -wal file are
+//     invisible to it.
+//   - PRAGMA quick_check, not integrity_check: per sqlite.org, quick_check
+//     "is like integrity_check except that it does not verify UNIQUE
+//     constraints and does not verify that index content matches table
+//     content" — bounded enough to run unconditionally on every bare
+//     `doctor` call. The full integrity_check (with those extra
+//     cross-checks) is what the strengthened checkMemoryIntegrity below
+//     runs when better-sqlite3 is available.
+// Explicitly labeled "structural-only" in both the row name and every
+// message so nobody mistakes this cheap default-run probe for the deeper
+// --component memory one.
+async function checkMemoryStructuralIntegrity() {
+    const NAME = 'Memory Structural Integrity (quick_check)';
+    const dbPath = await resolveMemoryDbPath();
+    if (!dbPath) {
+        // Not-yet-initialized project — Memory Database Presence above already
+        // surfaces this; "UNKNOWN is never PASS" still applies, so this stays a
+        // warn rather than a silent skip, but doesn't pile on a second red for
+        // the same root cause.
+        return {
+            name: NAME,
+            status: 'warn',
+            message: 'no memory.db found (see Memory Database Presence above) — structural-only check skipped',
+        };
+    }
+    // Encryption-at-rest carve-out (#2737 part 3) — see helpers above.
+    if (isMemoryDbEncryptedAtRest(dbPath)) {
+        return {
+            name: NAME,
+            status: 'warn',
+            message: `${dbPath} — RFE1-encrypted at rest; structural-only check can't run without decrypting (expected, not corruption — see Encryption at Rest)`,
+        };
+    }
+    let Database;
+    try {
+        Database = (await import('better-sqlite3')).default;
+    }
+    catch {
+        return {
+            name: NAME,
+            status: 'warn',
+            message: `${dbPath} — better-sqlite3 not installed; structural-only check skipped (optional native module)`,
+            fix: 'npm install better-sqlite3  (enables WAL-aware structural checks on every `doctor` run)',
+        };
+    }
+    let db;
+    try {
+        db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    }
+    catch (e) {
+        const msg = e.message || String(e);
+        // Encryption already ruled out above — an unencrypted file
+        // better-sqlite3 can't even open is definitive corruption.
+        // #2737 part 3: fail, not warn.
+        return {
+            name: NAME,
+            status: 'fail',
+            message: `${dbPath} — better-sqlite3 failed to open: ${msg} (unencrypted; definitively malformed) [structural-only]`,
+            fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+        };
+    }
+    try {
+        const rows = db.pragma('quick_check');
+        const values = rows.map((r) => String(Object.values(r)[0]));
+        if (values.length === 1 && values[0] === 'ok') {
+            return {
+                name: NAME,
+                status: 'pass',
+                message: `${dbPath} — PRAGMA quick_check: ok [structural-only, native + WAL-aware]`,
+            };
+        }
+        return {
+            name: NAME,
+            status: 'fail',
+            message: `${dbPath} — PRAGMA quick_check: ${values.slice(0, 3).join('; ')}${values.length > 3 ? ` (+${values.length - 3} more)` : ''} [structural-only]`,
+            fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+        };
+    }
+    catch (e) {
+        const msg = e.message || String(e);
+        // Encryption ruled out above; DB opened but the pragma itself threw —
+        // still definitive, unencrypted breakage. Fail, not warn.
+        return {
+            name: NAME,
+            status: 'fail',
+            message: `${dbPath} — quick_check probe threw: ${msg} (unencrypted) [structural-only]`,
+            fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+        };
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { /* best-effort */ }
+    }
+}
+// Check 1 (--component memory, deep path) — #2737 part 2 strengthens this:
+// prefer native better-sqlite3 PRAGMA integrity_check (adds index↔table
+// cross-checking + UNIQUE verification that quick_check above deliberately
+// skips, and is WAL-aware — see checkMemoryStructuralIntegrity's comment)
+// when better-sqlite3 is available, falling back to the original sql.js
+// probe when it's not. The sql.js fallback is main-image-only (WAL-blind);
+// its message says so explicitly so operators know its limits.
+//
+// #2737 part 3: with the encryption carve-out applied up front on BOTH
+// paths, a "file is not a database" / "malformed" result is now definitive,
+// unencrypted corruption in every branch below — fail, not warn (the
+// previous version treated this as an ambiguous warn because it couldn't
+// tell corruption from encryption; that ambiguity is what the carve-out
+// resolves).
 async function checkMemoryIntegrity() {
     const dbPath = await resolveMemoryDbPath();
     if (!dbPath)
-        return { name: 'Memory Integrity', status: 'warn', message: 'no memory.db found (see Memory Database check above)' };
+        return { name: 'Memory Integrity', status: 'warn', message: 'no memory.db found (see Memory Database Presence check above)' };
+    if (isMemoryDbEncryptedAtRest(dbPath)) {
+        return {
+            name: 'Memory Integrity',
+            status: 'warn',
+            message: `${dbPath} — RFE1-encrypted at rest; integrity check can't run without decrypting (expected, not corruption — see Encryption at Rest)`,
+        };
+    }
+    // Prefer native better-sqlite3 (WAL-aware, full integrity_check). Module
+    // load is isolated in its own try/catch so ONLY "not installed" falls
+    // through to the sql.js fallback below — once the module loaded, any
+    // open/query failure is resolved (fail) right here, not silently
+    // reclassified as "sql.js fallback, main-image-only" by an outer catch.
+    let Database;
+    try {
+        Database = (await import('better-sqlite3')).default;
+    }
+    catch {
+        Database = null; // not installed — fall through to the sql.js fallback below.
+    }
+    if (Database) {
+        let db;
+        try {
+            db = new Database(dbPath, { readonly: true, fileMustExist: true });
+        }
+        catch (e) {
+            const msg = e.message || String(e);
+            return {
+                name: 'Memory Integrity',
+                status: 'fail',
+                message: `${dbPath} — better-sqlite3 failed to open: ${msg} (unencrypted; definitively malformed) [native, WAL-aware]`,
+                fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+            };
+        }
+        try {
+            const rows = db.pragma('integrity_check');
+            const values = rows.map((r) => String(Object.values(r)[0]));
+            if (values.length === 1 && values[0] === 'ok') {
+                return { name: 'Memory Integrity', status: 'pass', message: `${dbPath} — PRAGMA integrity_check: ok [native, WAL-aware]` };
+            }
+            return {
+                name: 'Memory Integrity',
+                status: 'fail',
+                message: `${dbPath} — PRAGMA integrity_check: ${values.slice(0, 3).join('; ')}${values.length > 3 ? ` (+${values.length - 3} more)` : ''} [native, WAL-aware]`,
+                fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+            };
+        }
+        catch (e) {
+            // DB opened but the pragma itself threw — still definitive,
+            // unencrypted breakage (encryption ruled out above). Fail, not warn,
+            // and NOT a fall-through to the sql.js fallback: better-sqlite3 IS
+            // installed and just gave us the answer.
+            const msg = e.message || String(e);
+            return {
+                name: 'Memory Integrity',
+                status: 'fail',
+                message: `${dbPath} — integrity_check probe threw: ${msg} (unencrypted; definitively malformed) [native, WAL-aware]`,
+                fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
+            };
+        }
+        finally {
+            try {
+                db.close();
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    // Fallback: sql.js — main-image-only (WAL-blind). tryOpenSqlJs()
+    // readFileSync()s the base file directly, so any committed-but-not-
+    // checkpointed rows sitting in a sibling -wal file are invisible here.
+    // Install better-sqlite3 for the WAL-aware path above.
     const db = await tryOpenSqlJs(dbPath);
     if (!db) {
+        // Encryption already ruled out above — an unencrypted file sql.js can't
+        // even open is definitive corruption too.
         return {
             name: 'Memory Integrity',
-            status: 'warn',
-            message: `${dbPath} — sql.js can't open (encrypted DB or corrupt; doctor can't tell which from outside)`,
-            fix: 'if encrypted: expected. if not: back up + `claude-flow memory init --force` to rebuild',
+            status: 'fail',
+            message: `${dbPath} — sql.js can't open (unencrypted; definitively malformed) [main-image-only fallback — install better-sqlite3 for WAL-aware checking]`,
+            fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
         };
     }
     try {
         const res = db.exec('PRAGMA integrity_check');
         const rows = res[0]?.values?.map((v) => String(v[0])) ?? [];
         if (rows.length === 1 && rows[0] === 'ok') {
-            return { name: 'Memory Integrity', status: 'pass', message: `${dbPath} — PRAGMA integrity_check: ok` };
+            return { name: 'Memory Integrity', status: 'pass', message: `${dbPath} — PRAGMA integrity_check: ok [main-image-only fallback — sql.js can't see WAL-only data; install better-sqlite3 for full coverage]` };
         }
         return {
             name: 'Memory Integrity',
             status: 'fail',
-            message: `${dbPath} — PRAGMA integrity_check: ${rows.slice(0, 3).join('; ')}${rows.length > 3 ? ` (+${rows.length - 3} more)` : ''}`,
+            message: `${dbPath} — PRAGMA integrity_check: ${rows.slice(0, 3).join('; ')}${rows.length > 3 ? ` (+${rows.length - 3} more)` : ''} [main-image-only fallback]`,
             fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
         };
     }
     catch (e) {
         const msg = e.message || String(e);
-        const encryptedOrCorrupt = msg.includes('file is not a database') || msg.includes('malformed');
+        const definitivelyMalformed = msg.includes('file is not a database') || msg.includes('malformed');
+        // Encryption already ruled out above, so — matched pattern or not —
+        // this is a query refusal on a file we KNOW isn't RFE1-encrypted.
+        // #2737 part 3: fail, not warn.
         return {
             name: 'Memory Integrity',
-            status: 'warn',
-            message: encryptedOrCorrupt
-                ? `${dbPath} — DB refused query: ${msg} (encrypted DB or corruption; see Memory Integrity above)`
-                : `${dbPath} — probe threw: ${msg}`,
+            status: 'fail',
+            message: definitivelyMalformed
+                ? `${dbPath} — DB refused query: ${msg} (unencrypted; definitively malformed) [main-image-only fallback]`
+                : `${dbPath} — probe threw: ${msg} (unencrypted — encryption ruled out above) [main-image-only fallback]`,
+            fix: 'back up .swarm/memory.db then `claude-flow memory init --force`',
         };
     }
     finally {
@@ -978,7 +1224,7 @@ async function checkFunnel() {
     }
 }
 /** Meta LLM Proxy — sponsored-downtime health (ADR-313). */
-async function checkProxy() {
+async function checkProxySponsoredConsent() {
     try {
         const { funnelStateDir, hasConsent, readRateLimitStatus, lastRecordedEvent } = await import('../funnel/index.js');
         const dir = funnelStateDir();
@@ -1019,6 +1265,208 @@ async function checkProxy() {
         };
     }
 }
+/**
+ * Binary presence + tamper check (ADR-307). Deliberately NEVER spawns the
+ * binary to probe a version — confirmed empirically (2026-07-16) that
+ * `meta-proxy` has no `--version`/`--help` flag and starts the live server
+ * as a side effect of ANY invocation, which a doctor health check must never
+ * do. Version info instead comes from install-manifest.json (written at
+ * install time) and, once running, the proxy's own `/status` endpoint via
+ * checkProxyProcess below.
+ */
+async function checkProxyBinary() {
+    const NAME = 'Meta LLM Proxy binary (ADR-307)';
+    try {
+        const { proxyBinaryPath, proxyInstallManifestPath } = await import('../proxy/paths.js');
+        const binPath = proxyBinaryPath();
+        if (!existsSync(binPath)) {
+            return { name: NAME, status: 'warn', message: 'not installed', fix: 'ruflo proxy install' };
+        }
+        const manifestPath = proxyInstallManifestPath();
+        if (!existsSync(manifestPath)) {
+            return {
+                name: NAME,
+                status: 'warn',
+                message: 'binary present but no install-manifest.json — provenance unknown (installed outside `ruflo proxy install`?)',
+                fix: 'ruflo proxy update --release <x.y.z>',
+            };
+        }
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+        const liveSha = createHash('sha256').update(readFileSync(binPath)).digest('hex');
+        if (liveSha !== manifest.sha256) {
+            return {
+                name: NAME,
+                status: 'fail',
+                message: `binary sha256 does not match the recorded install manifest — possible tampering or a manual overwrite (expected ${manifest.sha256.slice(0, 12)}…, got ${liveSha.slice(0, 12)}…)`,
+                fix: 'ruflo proxy update --release <x.y.z>',
+            };
+        }
+        return { name: NAME, status: 'pass', message: `v${manifest.version}, signature-verified at install (${manifest.verifiedAt})` };
+    }
+    catch (err) {
+        return { name: NAME, status: 'warn', message: `check failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+/** PID-file liveness (ADR-307) — mirrors daemon.ts's signal-0 probe pattern. */
+async function checkProxyProcess() {
+    const NAME = 'Meta LLM Proxy process (ADR-307)';
+    try {
+        const { proxyPidFilePath } = await import('../proxy/paths.js');
+        const pidPath = proxyPidFilePath();
+        if (!existsSync(pidPath)) {
+            return { name: NAME, status: 'warn', message: 'not running (no PID file)', fix: 'ruflo proxy start' };
+        }
+        const pidRaw = readFileSync(pidPath, 'utf-8').trim();
+        const pid = parseInt(pidRaw, 10);
+        if (!Number.isFinite(pid)) {
+            return { name: NAME, status: 'warn', message: `PID file is malformed: ${JSON.stringify(pidRaw)}`, fix: 'ruflo proxy stop && ruflo proxy start' };
+        }
+        try {
+            process.kill(pid, 0); // signal-0 liveness probe — throws if the process is dead
+        }
+        catch {
+            return { name: NAME, status: 'warn', message: `PID file points at ${pid}, which is not running — stale PID file`, fix: 'ruflo proxy start' };
+        }
+        // Live version-compat + data-plane info, ONLY once PID liveness already
+        // confirmed a process is running (never spawns anything — see
+        // checkProxyBinary's comment on why probing via process launch is unsafe).
+        // GET /status shape confirmed against the real v0.1.0 binary:
+        // {"version","data_plane","bind","sponsored_available","proxy_token_valid"}.
+        const { proxyConfigPath, proxyTokenPath, proxyInstallManifestPath } = await import('../proxy/paths.js');
+        const bindMatch = existsSync(proxyConfigPath())
+            ? readFileSync(proxyConfigPath(), 'utf-8').match(/^bind\s*=\s*"([^"]*)"/m)
+            : null;
+        const bind = bindMatch ? bindMatch[1] : '127.0.0.1:11435';
+        let token;
+        try {
+            token = readFileSync(proxyTokenPath(), 'utf-8').trim();
+        }
+        catch {
+            return { name: NAME, status: 'pass', message: `running (pid ${pid}); no proxy-token to query /status` };
+        }
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 2000);
+            const resp = await fetch(`http://${bind}/status`, {
+                headers: { authorization: `Bearer ${token}` },
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            if (!resp.ok) {
+                return { name: NAME, status: 'warn', message: `running (pid ${pid}); /status returned HTTP ${resp.status}` };
+            }
+            const body = (await resp.json());
+            let versionNote = '';
+            if (existsSync(proxyInstallManifestPath())) {
+                const manifest = JSON.parse(readFileSync(proxyInstallManifestPath(), 'utf-8'));
+                if (manifest.version && body.version && manifest.version !== body.version) {
+                    return {
+                        name: NAME,
+                        status: 'warn',
+                        message: `running (pid ${pid}) reports v${body.version}, but the installed binary is v${manifest.version} — a stale process from a previous version?`,
+                        fix: 'ruflo proxy stop && ruflo proxy start',
+                    };
+                }
+                versionNote = body.version ? ` v${body.version}` : '';
+            }
+            return {
+                name: NAME,
+                status: 'pass',
+                message: `running (pid ${pid})${versionNote}; data plane: ${body.data_plane ?? 'unknown'}`,
+            };
+        }
+        catch (err) {
+            // Live process but /status unreachable (still starting up, or a
+            // network hiccup) — not a failure, PID liveness already passed.
+            return {
+                name: NAME,
+                status: 'pass',
+                message: `running (pid ${pid}); /status unreachable (${err instanceof Error ? err.message : String(err)})`,
+            };
+        }
+    }
+    catch (err) {
+        return { name: NAME, status: 'warn', message: `check failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+/** Non-loopback bind exposure warning (ADR-307's mandated startup warning, surfaced in doctor too). */
+async function checkProxyBindAddress() {
+    const NAME = 'Meta LLM Proxy bind address (ADR-307)';
+    try {
+        const { proxyConfigPath, isLoopbackBind } = await import('../proxy/paths.js');
+        const cfgPath = proxyConfigPath();
+        if (!existsSync(cfgPath)) {
+            return { name: NAME, status: 'pass', message: 'no config file yet — defaults to loopback-only (127.0.0.1:11435)' };
+        }
+        const raw = readFileSync(cfgPath, 'utf-8');
+        const match = raw.match(/^bind\s*=\s*"([^"]*)"/m);
+        const bind = match ? match[1] : '127.0.0.1:11435';
+        if (!isLoopbackBind(bind)) {
+            return {
+                name: NAME,
+                status: 'warn',
+                message: `bound to non-loopback address ${bind} — this exposes the proxy to your network`,
+                fix: 'Set bind back to 127.0.0.1:<port> in proxy-config.toml unless external exposure is intended',
+            };
+        }
+        return { name: NAME, status: 'pass', message: `loopback-only (${bind})` };
+    }
+    catch (err) {
+        return { name: NAME, status: 'warn', message: `check failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+/** `ruflo auth` health (ADR-306). Warn (never fail) on absence — auth is never required for core functionality. */
+async function checkAuth() {
+    const NAME = 'Cognitum identity (ADR-306)';
+    try {
+        const { listProfiles } = await import('../auth/state.js');
+        const { domainForScope } = await import('../auth/scopes.js');
+        const { hasConsent } = await import('../funnel/index.js');
+        const { profiles } = listProfiles();
+        if (profiles.length === 0) {
+            return { name: NAME, status: 'warn', message: 'not logged in', fix: 'ruflo auth login' };
+        }
+        let keychainAvailable = 'unknown';
+        try {
+            const sec = await import('@claude-flow/security');
+            keychainAvailable = await (await sec.createKeychainAdapter()).isAvailable();
+        }
+        catch {
+            keychainAvailable = 'unknown'; // security package unavailable — surfaced by checkProxyBinary's sibling concerns, not duplicated here
+        }
+        // Scope-vs-receipt consistency check (ADR-306: "fail-closed... reports").
+        // Unlike every other check in this file, a violation here is a FAIL, not
+        // a warn — a scope present without a matching consent receipt is exactly
+        // the condition ADR-306 says must never silently pass.
+        const violations = [];
+        for (const p of profiles) {
+            for (const scope of p.scopes) {
+                const domain = domainForScope(scope);
+                if (domain && !hasConsent(domain))
+                    violations.push(`${p.profile}: ${scope}`);
+            }
+        }
+        if (violations.length > 0) {
+            return {
+                name: NAME,
+                status: 'fail',
+                message: `scope granted without a matching consent receipt: ${violations.join(', ')}`,
+                fix: 'ruflo auth logout && ruflo auth login',
+            };
+        }
+        const names = profiles.map((p) => p.profile).join(', ');
+        const sessionOnly = profiles.filter((p) => !p.keychainRef).map((p) => p.profile);
+        const parts = [`profiles: ${names}`];
+        if (keychainAvailable === false)
+            parts.push('keychain backend unreachable — falling back to session-only tokens');
+        if (sessionOnly.length > 0)
+            parts.push(`session-only (no persisted refresh token): ${sessionOnly.join(', ')}`);
+        return { name: NAME, status: 'pass', message: parts.join('; ') };
+    }
+    catch (err) {
+        return { name: NAME, status: 'warn', message: `check failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
 async function checkMetaharnessIntegration() {
     // Locate plugins dir.
     //
@@ -1395,7 +1843,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, agentic-flow, encryption, federation, funnel, proxy, metaharness)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, agentic-flow, encryption, federation, funnel, proxy, auth, metaharness)',
             type: 'string'
         },
         {
@@ -1513,6 +1961,7 @@ export const doctorCommand = {
             checkStaleSettingsNpx, // #2448 — runaway `npx @latest` in statusLine/hooks
             checkDaemonStatus,
             checkMemoryDatabase,
+            checkMemoryStructuralIntegrity, // #2737 — bounded, native quick_check on every default run
             checkLearningBridge, // #2545 — can the auto-memory hook actually load @claude-flow/memory?
             checkApiKeys,
             checkMcpServers,
@@ -1525,7 +1974,8 @@ export const doctorCommand = {
             checkMetaharness, // ADR-150 — MetaHarness upstream package
             checkMetaharnessIntegration, // iter 45 — ruflo-side integration layer
             checkFunnel, // ADR-305 — effective funnel state + deciding precedence source
-            checkProxy, // ADR-313 — Meta LLM Proxy sponsored-downtime health
+            checkProxySponsoredConsent, // ADR-313 — Meta LLM Proxy sponsored-downtime health
+            checkAuth, // ADR-306 — Cognitum identity (warn-only; never fails bare `ruflo doctor`)
         ];
         // #2677: `--component memory` now runs the whole memory-health suite,
         // not just the existence check. Values can be a single check or an
@@ -1563,7 +2013,11 @@ export const doctorCommand = {
             'metaharness': checkMetaharness, // ADR-150 — upstream package
             'metaharness-integration': checkMetaharnessIntegration, // iter 45 — ruflo-side
             'funnel': checkFunnel, // ADR-305
-            'proxy': checkProxy, // ADR-313
+            // ADR-307 — deep-dive array, same pattern as 'memory' above: the cheap
+            // sponsored-consent check first, then binary/process/bind in the order
+            // a user would actually debug them (is it installed? running? exposed?).
+            'proxy': [checkProxySponsoredConsent, checkProxyBinary, checkProxyProcess, checkProxyBindAddress],
+            'auth': checkAuth, // ADR-306
         };
         let checksToRun = allChecks;
         if (component && componentMap[component]) {

package/v3/@claude-flow/cli/dist/src/commands/hooks.js

@@ -3485,12 +3485,54 @@ const statuslineCommand = {
             const contextPct = Math.min(100, Math.floor(learning.sessions * 5));
             return { memoryMB, contextPct, intelligencePct, subAgents };
         }
+        // #2733: Claude Code pipes session JSON (incl. the real active model) on
+        // stdin to statusline commands. Read it synchronously the same way
+        // .claude/helpers/statusline.cjs's getModelFromStdin() does, so this CLI
+        // subcommand is correct standalone — not just when the generated helper
+        // happens to override its output. Read once, memoized per invocation
+        // (mirrors statusline.cjs's _stdinData cache).
+        let _stdinData;
+        let _stdinRead = false;
+        function getStdinData() {
+            if (_stdinRead)
+                return _stdinData;
+            _stdinRead = true;
+            try {
+                if (process.stdin.isTTY) {
+                    _stdinData = null;
+                    return null;
+                }
+                const chunks = [];
+                const buf = Buffer.alloc(4096);
+                let bytesRead;
+                try {
+                    while ((bytesRead = fs.readSync(0, buf, 0, buf.length, null)) > 0) {
+                        chunks.push(Buffer.from(buf.subarray(0, bytesRead)));
+                    }
+                }
+                catch { /* EOF or read error */ }
+                const raw = Buffer.concat(chunks).toString('utf-8').trim();
+                _stdinData = (raw && raw.startsWith('{')) ? JSON.parse(raw) : null;
+            }
+            catch {
+                _stdinData = null;
+            }
+            return _stdinData;
+        }
+        function getModelFromStdin() {
+            const data = getStdinData();
+            return (data && data.model && typeof data.model.display_name === 'string') ? data.model.display_name : null;
+        }
         // Get user info
         function getUserInfo() {
             const identityMode = (process.env.RUFLO_STATUSLINE_IDENTITY || 'project').toLowerCase();
             let name = path.basename(process.cwd()) || 'project';
             let gitBranch = '';
-            const modelName = 'Opus 4.6 (1M context)';
+            // Real active model from Claude Code's stdin payload when available;
+            // this string is only a last-resort label for direct/manual CLI
+            // invocation with no stdin (e.g. a bare terminal run) — never shown
+            // when Claude Code itself is the caller.
+            const modelName = getModelFromStdin() || 'Claude Code';
             const isWindows = process.platform === 'win32';
             try {
                 const rootCmd = isWindows

package/v3/@claude-flow/cli/dist/src/commands/index.js

@@ -79,6 +79,8 @@ const commandLoaders = {
     // User-facing preferences wrapper (ADR-311 copy discipline — no "funnel" in
     // the user surface). Forwards to the funnel primitives internally.
     settings: () => import('./settings.js'),
+    // Cognitum identity — login/logout/status (ADR-306)
+    auth: () => import('./auth.js'),
     // Meta LLM Proxy — sponsored downtime capacity (ADR-304/307/313)
     proxy: () => import('./proxy.js'),
     // Fable co-pilot advisor tip in the statusline insight ticker (ADR-316)